Vendor import of libc++ trunk r321017:vendor/libc++/libc++-trunk-r321017

https://llvm.org/svn/llvm-project/libcxx/trunk@321017

739 files changed, 11560 insertions, 7990 deletions

diff --git a/.arcconfig b/.arcconfig
index c96fbc1b4e6c..b7486508bc1e 100644
--- a/.arcconfig
+++ b/.arcconfig
@@ -1,4 +1,4 @@
 {
-  "project_id" : "libcxx",
+  "repository.callsign" : "CXX",
   "conduit_uri" : "https://reviews.llvm.org/"
 }
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ca5afba86d19..29eef8f35dbc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -23,7 +23,7 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   project(libcxx CXX C)
 
   set(PACKAGE_NAME libcxx)
-  set(PACKAGE_VERSION 5.0.0)
+  set(PACKAGE_VERSION 6.0.0svn)
   set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
   set(PACKAGE_BUGREPORT "llvm-bugs@lists.llvm.org")
 
@@ -99,6 +99,9 @@ cmake_dependent_option(LIBCXX_INSTALL_EXPERIMENTAL_LIBRARY
         "LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY;LIBCXX_INSTALL_LIBRARY" OFF)
 set(LIBCXX_ABI_VERSION 1 CACHE STRING "ABI version of libc++.")
 option(LIBCXX_ABI_UNSTABLE "Unstable ABI of libc++." OFF)
+option(LIBCXX_ABI_FORCE_ITANIUM "Ignore auto-detection and force use of the Itanium ABI.")
+option(LIBCXX_ABI_FORCE_MICROSOFT "Ignore auto-detection and force use of the Microsoft ABI.")
+set(LIBCXX_ABI_DEFINES "" CACHE STRING "A semicolon separated list of ABI macros to define in the site config header.")
 option(LIBCXX_USE_COMPILER_RT "Use compiler-rt instead of libgcc" OFF)
 
 if (NOT LIBCXX_ENABLE_SHARED AND NOT LIBCXX_ENABLE_STATIC)
@@ -337,6 +340,10 @@ if (LIBCXX_HAS_MUSL_LIBC AND NOT LIBCXX_INSTALL_SUPPORT_HEADERS)
                       "when building for Musl with LIBCXX_HAS_MUSL_LIBC.")
 endif()
 
+if (LIBCXX_ABI_FORCE_ITANIUM AND LIBCXX_ABI_FORCE_MICROSOFT)
+  message(FATAL_ERROR "Only one of LIBCXX_ABI_FORCE_ITANIUM and LIBCXX_ABI_FORCE_MICROSOFT can be specified.")
+endif ()
+
 #===============================================================================
 # Configure System
 #===============================================================================
@@ -594,6 +601,8 @@ if (NOT LIBCXX_ABI_VERSION EQUAL "1")
   config_define(${LIBCXX_ABI_VERSION} _LIBCPP_ABI_VERSION)
 endif()
 config_define_if(LIBCXX_ABI_UNSTABLE _LIBCPP_ABI_UNSTABLE)
+config_define_if(LIBCXX_ABI_FORCE_ITANIUM _LIBCPP_ABI_FORCE_ITANIUM)
+config_define_if(LIBCXX_ABI_FORCE_MICROSOFT _LIBCPP_ABI_FORCE_MICROSOFT)
 
 config_define_if_not(LIBCXX_ENABLE_GLOBAL_FILESYSTEM_NAMESPACE _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE)
 config_define_if_not(LIBCXX_ENABLE_STDIN _LIBCPP_HAS_NO_STDIN)
@@ -606,6 +615,19 @@ config_define_if(LIBCXX_HAS_PTHREAD_API _LIBCPP_HAS_THREAD_API_PTHREAD)
 config_define_if(LIBCXX_HAS_EXTERNAL_THREAD_API _LIBCPP_HAS_THREAD_API_EXTERNAL)
 config_define_if(LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL)
 config_define_if(LIBCXX_HAS_MUSL_LIBC _LIBCPP_HAS_MUSL_LIBC)
+config_define_if(LIBCXX_NO_VCRUNTIME _LIBCPP_NO_VCRUNTIME)
+
+if (LIBCXX_ABI_DEFINES)
+  set(abi_defines)
+  foreach (abi_define ${LIBCXX_ABI_DEFINES})
+    if (NOT abi_define MATCHES "^_LIBCPP_ABI_")
+      message(SEND_ERROR "Invalid ABI macro ${abi_define} in LIBCXX_ABI_DEFINES")
+    endif()
+    list(APPEND abi_defines "#define ${abi_define}")
+  endforeach()
+  string(REPLACE ";" "\n" abi_defines "${abi_defines}")
+  config_define(${abi_defines} _LIBCPP_ABI_DEFINES)
+endif()
 
 # By default libc++ on Windows expects to use a shared library, which requires
 # the headers to use DLL import/export semantics. However when building a
@@ -615,9 +637,10 @@ if (DEFINED WIN32 AND LIBCXX_ENABLE_STATIC AND NOT LIBCXX_ENABLE_SHARED)
   config_define(ON _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
 endif()
 
+set(site_config_path "${LIBCXX_BINARY_DIR}/__config_site")
 if (LIBCXX_NEEDS_SITE_CONFIG)
   configure_file("include/__config_site.in"
-                 "${LIBCXX_BINARY_DIR}/__config_site"
+                 "${site_config_path}"
                  @ONLY)
 
   # Provide the config definitions by included the generated __config_site
@@ -627,6 +650,11 @@ if (LIBCXX_NEEDS_SITE_CONFIG)
   else()
     add_compile_flags("-include ${LIBCXX_BINARY_DIR}/__config_site")
   endif()
+else()
+  if (EXISTS "${site_config_path}")
+    message(STATUS "Removing stale site configuration ${site_config_path}")
+    file(REMOVE "${site_config_path}")
+  endif()
 endif()
 
 #===============================================================================
@@ -647,6 +675,7 @@ endif()
 #
 # However, since some submission systems strip test/ subdirectories, check for
 # it before adding it.
+
 if(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/test")
   add_subdirectory(test)
 endif()
@@ -654,6 +683,16 @@ if (LIBCXX_INCLUDE_TESTS)
   add_subdirectory(lib/abi)
 endif()
 
+if (LIBCXX_STANDALONE_BUILD AND EXISTS "${LLVM_MAIN_SRC_DIR}/utils/llvm-lit")
+  include(AddLLVM) # for get_llvm_lit_path
+  # Make sure the llvm-lit script is generated into the bin directory, and do
+  # it after adding all tests, since the generated script will only work
+  # correctly discovered tests against test locations from the source tree that
+  # have already been discovered.
+  add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/llvm-lit
+                   ${CMAKE_CURRENT_BINARY_DIR}/llvm-lit)
+endif()
+
 if (LIBCXX_INCLUDE_DOCS)
   add_subdirectory(docs)
 endif()
diff --git a/CREDITS.TXT b/CREDITS.TXT
index 92123d736bf0..88d923a48e91 100644
--- a/CREDITS.TXT
+++ b/CREDITS.TXT
@@ -41,6 +41,10 @@ N: Jonathan B Coe
 E: jbcoe@me.com
 D: Implementation of propagate_const.
 
+N: Glen Joseph Fernandes
+E: glenjofe@gmail.com
+D: Implementation of to_address.
+
 N: Eric Fiselier
 E: eric@efcs.ca
 D: LFTS support, patches and bug fixes.
diff --git a/appveyor-reqs-install.cmd b/appveyor-reqs-install.cmd
index e5b30cf43f3a..43655d5612a8 100644
--- a/appveyor-reqs-install.cmd
+++ b/appveyor-reqs-install.cmd
@@ -9,7 +9,7 @@ cd C:\projects\deps
 :: Setup Compiler
 ::###########################################################################
 if NOT EXIST llvm-installer.exe (
-  appveyor DownloadFile http://llvm.org/pre-releases/win-snapshots/LLVM-5.0.0-r303050-win32.exe -FileName llvm-installer.exe
+  appveyor DownloadFile http://prereleases.llvm.org/win-snapshots/LLVM-6.0.0-r316086-win32.exe -FileName llvm-installer.exe
 )
 if "%CLANG_VERSION%"=="ToT" (
     START /WAIT llvm-installer.exe /S /D=C:\"Program Files\LLVM"
diff --git a/cmake/Modules/HandleLibCXXABI.cmake b/cmake/Modules/HandleLibCXXABI.cmake
index b1f6bee8f945..558e11ba2cc1 100644
--- a/cmake/Modules/HandleLibCXXABI.cmake
+++ b/cmake/Modules/HandleLibCXXABI.cmake
@@ -56,7 +56,7 @@ macro(setup_abi_lib abidefines abilib abifiles abidirs)
         if (LIBCXX_INSTALL_HEADERS)
           install(FILES "${LIBCXX_BINARY_INCLUDE_DIR}/${fpath}"
             DESTINATION ${LIBCXX_INSTALL_PREFIX}include/c++/v1/${dstdir}
-            COMPONENT libcxx
+            COMPONENT cxx-headers
             PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
             )
         endif()
diff --git a/cmake/Modules/HandleOutOfTreeLLVM.cmake b/cmake/Modules/HandleOutOfTreeLLVM.cmake
index 879882dcfea6..83948b14fd1f 100644
--- a/cmake/Modules/HandleOutOfTreeLLVM.cmake
+++ b/cmake/Modules/HandleOutOfTreeLLVM.cmake
@@ -106,14 +106,22 @@ macro(configure_out_of_tree_llvm)
     set(LLVM_ENABLE_SPHINX OFF)
   endif()
 
-  # Required LIT Configuration ------------------------------------------------
-  # Define the default arguments to use with 'lit', and an option for the user
-  # to override.
-  set(LIT_ARGS_DEFAULT "-sv --show-xfail --show-unsupported")
-  if (MSVC OR XCODE)
-    set(LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar")
+  # In a standalone build, we don't have llvm to automatically generate the
+  # llvm-lit script for us.  So we need to provide an explicit directory that
+  # the configurator should write the script into.
+  set(LLVM_LIT_OUTPUT_DIR "${libcxx_BINARY_DIR}/bin")
+
+  if (LLVM_INCLUDE_TESTS)
+    # Required LIT Configuration ------------------------------------------------
+    # Define the default arguments to use with 'lit', and an option for the user
+    # to override.
+    set(LLVM_EXTERNAL_LIT "${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py")
+    set(LIT_ARGS_DEFAULT "-sv --show-xfail --show-unsupported")
+    if (MSVC OR XCODE)
+      set(LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar")
+    endif()
+    set(LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit")
   endif()
-  set(LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit")
 
   # Required doc configuration
   if (LLVM_ENABLE_SPHINX)
diff --git a/docs/BuildingLibcxx.rst b/docs/BuildingLibcxx.rst
index 81a7c2341473..3dae2f41c274 100644
--- a/docs/BuildingLibcxx.rst
+++ b/docs/BuildingLibcxx.rst
@@ -130,7 +130,7 @@ just specify a toolset.
           -DCMAKE_SYSTEM_NAME=Windows                                                 ^
           -DCMAKE_C_COMPILER=clang-cl                                                 ^
           -DCMAKE_C_FLAGS="-fms-compatibility-version=19.00 --target=i686--windows"   ^
-          -DCMAKE_CXX_COMPILER=clang-c                                                ^
+          -DCMAKE_CXX_COMPILER=clang-cl                                                ^
           -DCMAKE_CXX_FLAGS="-fms-compatibility-version=19.00 --target=i686--windows" ^
           -DLLVM_PATH=/path/to/llvm/tree                                              ^
           -DLIBCXX_ENABLE_SHARED=YES                                                  ^
@@ -347,6 +347,13 @@ The following options allow building libc++ for a different ABI version.
   Build the "unstable" ABI version of libc++. Includes all ABI changing features
   on top of the current stable version.
 
+.. option:: LIBCXX_ABI_DEFINES:STRING
+
+  **Default**: ``""``
+
+  A semicolon-separated list of ABI macros to persist in the site config header.
+  See ``include/__config`` for the list of ABI macros.
+
 .. _LLVM-specific variables:
 
 LLVM-specific options
diff --git a/docs/TestingLibcxx.rst b/docs/TestingLibcxx.rst
index 5c48ebe61ddf..43c0684dc7de 100644
--- a/docs/TestingLibcxx.rst
+++ b/docs/TestingLibcxx.rst
@@ -112,7 +112,7 @@ configuration. Passing the option on the command line will override the default.
 
 .. option:: std=<standard version>
 
-  **Values**: c++98, c++03, c++11, c++14, c++1z
+  **Values**: c++98, c++03, c++11, c++14, c++17, c++2a
 
   Change the standard version used when building the tests.
 
diff --git a/docs/UsingLibcxx.rst b/docs/UsingLibcxx.rst
index 183664655aa3..f54234d6aa3f 100644
--- a/docs/UsingLibcxx.rst
+++ b/docs/UsingLibcxx.rst
@@ -185,6 +185,26 @@ thread safety annotations.
     * Giving `set`, `map`, `multiset`, `multimap` a comparator which is not
       const callable.
 
+**_LIBCPP_NO_VCRUNTIME**:
+  Microsoft's C and C++ headers are fairly entangled, and some of their C++
+  headers are fairly hard to avoid. In particular, `vcruntime_new.h` gets pulled
+  in from a lot of other headers and provides definitions which clash with
+  libc++ headers, such as `nothrow_t` (note that `nothrow_t` is a struct, so
+  there's no way for libc++ to provide a compatible definition, since you can't
+  have multiple definitions).
+
+  By default, libc++ solves this problem by deferring to Microsoft's vcruntime
+  headers where needed. However, it may be undesirable to depend on vcruntime
+  headers, since they may not always be available in cross-compilation setups,
+  or they may clash with other headers. The `_LIBCPP_NO_VCRUNTIME` macro
+  prevents libc++ from depending on vcruntime headers. Consequently, it also
+  prevents libc++ headers from being interoperable with vcruntime headers (from
+  the aforementioned clashes), so users of this macro are promising to not
+  attempt to combine libc++ headers with the problematic vcruntime headers. This
+  macro also currently prevents certain `operator new`/`operator delete`
+  replacement scenarios from working, e.g. replacing `operator new` and
+  expecting a non-replaced `operator new[]` to call the replaced `operator new`.
+
 C++17 Specific Configuration Macros
 -----------------------------------
 **_LIBCPP_ENABLE_CXX17_REMOVED_FEATURES**:
diff --git a/docs/conf.py b/docs/conf.py
index 17fb401a8470..bb231ac3e353 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -47,9 +47,9 @@ copyright = u'2011-2017, LLVM Project'
 # built documents.
 #
 # The short X.Y version.
-version = '5.0'
+version = '6.0'
 # The full version, including alpha/beta/rc tags.
-release = '5.0'
+release = '6.0'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
diff --git a/fuzzing/RoutineNames.txt b/fuzzing/RoutineNames.txt
new file mode 100644
index 000000000000..06ef70ed6491
--- /dev/null
+++ b/fuzzing/RoutineNames.txt
@@ -0,0 +1,20 @@
+sort
+stable_sort
+partition
+partition_copy
+stable_partition
+unique
+unique_copy
+nth_element
+partial_sort
+partial_sort_copy
+make_heap
+push_heap
+pop_heap
+regex_ECMAScript
+regex_POSIX
+regex_extended
+regex_awk
+regex_grep
+regex_egrep
+search
diff --git a/fuzzing/fuzzing.cpp b/fuzzing/fuzzing.cpp
new file mode 100644
index 000000000000..9471a1d0af90
--- /dev/null
+++ b/fuzzing/fuzzing.cpp
@@ -0,0 +1,551 @@
+// -*- C++ -*-
+//===------------------------- fuzzing.cpp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+//	A set of routines to use when fuzzing the algorithms in libc++
+//	Each one tests a single algorithm.
+//
+//	They all have the form of:
+//		int `algorithm`(const uint8_t *data, size_t size);
+//
+//	They perform the operation, and then check to see if the results are correct.
+//	If so, they return zero, and non-zero otherwise.
+//
+//	For example, sort calls std::sort, then checks two things:
+//		(1) The resulting vector is sorted
+//		(2) The resulting vector contains the same elements as the original data.
+
+
+
+#include "fuzzing.h"
+#include <vector>
+#include <algorithm>
+#include <functional>
+#include <regex>
+#include <cassert>
+
+#include <iostream>
+
+//	If we had C++14, we could use the four iterator version of is_permutation and equal
+
+namespace fuzzing {
+
+//	This is a struct we can use to test the stable_XXX algorithms.
+//	perform the operation on the key, then check the order of the payload.
+
+struct stable_test {
+	uint8_t key;
+	size_t payload;
+	
+	stable_test(uint8_t k) : key(k), payload(0) {}
+	stable_test(uint8_t k, size_t p) : key(k), payload(p) {}
+	};
+
+void swap(stable_test &lhs, stable_test &rhs)
+{
+	using std::swap;
+	swap(lhs.key,     rhs.key);
+	swap(lhs.payload, rhs.payload);
+}
+
+struct key_less
+{
+	bool operator () (const stable_test &lhs, const stable_test &rhs) const
+	{
+		return lhs.key < rhs.key;
+	}
+};
+
+struct payload_less
+{
+	bool operator () (const stable_test &lhs, const stable_test &rhs) const
+	{
+		return lhs.payload < rhs.payload;
+	}
+};
+
+struct total_less
+{
+	bool operator () (const stable_test &lhs, const stable_test &rhs) const
+	{
+		return lhs.key == rhs.key ? lhs.payload < rhs.payload : lhs.key < rhs.key;
+	}
+};
+
+bool operator==(const stable_test &lhs, const stable_test &rhs)
+{ 
+	return lhs.key == rhs.key && lhs.payload == rhs.payload;
+}
+
+
+template<typename T>
+struct is_even
+{
+	bool operator () (const T &t) const
+	{
+		return t % 2 == 0;
+	}
+};
+
+
+template<>
+struct is_even<stable_test>
+{
+	bool operator () (const stable_test &t) const
+	{
+		return t.key % 2 == 0;
+	}
+};
+
+typedef std::vector<uint8_t> Vec;
+typedef std::vector<stable_test> StableVec;
+
+//	== sort ==
+int sort(const uint8_t *data, size_t size)
+{
+	Vec working(data, data + size);
+	std::sort(working.begin(), working.end());
+
+	if (!std::is_sorted(working.begin(), working.end())) return 1;
+	if (!std::is_permutation(data, data + size, working.begin())) return 99;
+	return 0;
+}
+
+
+//	== stable_sort ==
+int stable_sort(const uint8_t *data, size_t size)
+{
+	StableVec input;
+	for (size_t i = 0; i < size; ++i)
+		input.push_back(stable_test(data[i], i));
+	StableVec working = input;
+	std::stable_sort(working.begin(), working.end(), key_less());
+
+	if (!std::is_sorted(working.begin(), working.end(), key_less()))   return 1;
+	auto iter = working.begin();
+	while (iter != working.end())
+	{
+		auto range = std::equal_range(iter, working.end(), *iter, key_less());
+		if (!std::is_sorted(range.first, range.second, total_less())) return 2;			
+		iter = range.second;
+	}
+	if (!std::is_permutation(input.begin(), input.end(), working.begin())) return 99;
+	return 0;
+}
+
+//	== partition ==
+int partition(const uint8_t *data, size_t size)
+{
+	Vec working(data, data + size);
+	auto iter = std::partition(working.begin(), working.end(), is_even<uint8_t>());
+
+	if (!std::all_of (working.begin(), iter, is_even<uint8_t>())) return 1;
+	if (!std::none_of(iter,   working.end(), is_even<uint8_t>())) return 2;
+	if (!std::is_permutation(data, data + size, working.begin())) return 99;
+	return 0;
+}
+
+
+//	== partition_copy ==
+int partition_copy(const uint8_t *data, size_t size)
+{
+	Vec v1, v2;
+	auto iter = std::partition_copy(data, data + size,
+		std::back_inserter<Vec>(v1), std::back_inserter<Vec>(v2),
+		is_even<uint8_t>());
+
+//	The two vectors should add up to the original size
+	if (v1.size() + v2.size() != size) return 1;
+
+//	All of the even values should be in the first vector, and none in the second
+	if (!std::all_of (v1.begin(), v1.end(), is_even<uint8_t>())) return 2;
+	if (!std::none_of(v2.begin(), v2.end(), is_even<uint8_t>())) return 3;
+
+//	Every value in both vectors has to be in the original
+	for (auto v: v1)
+		if (std::find(data, data + size, v) == data + size) return 4;
+			
+	for (auto v: v2)
+		if (std::find(data, data + size, v) == data + size) return 5;
+			
+	return 0;
+}
+
+//	== stable_partition ==
+int stable_partition (const uint8_t *data, size_t size)
+{
+	StableVec input;
+	for (size_t i = 0; i < size; ++i)
+		input.push_back(stable_test(data[i], i));
+	StableVec working = input;
+	auto iter = std::stable_partition(working.begin(), working.end(), is_even<stable_test>());
+
+	if (!std::all_of (working.begin(), iter, is_even<stable_test>())) return 1;
+	if (!std::none_of(iter,   working.end(), is_even<stable_test>())) return 2;
+	if (!std::is_sorted(working.begin(), iter, payload_less()))   return 3;
+	if (!std::is_sorted(iter,   working.end(), payload_less()))   return 4;
+	if (!std::is_permutation(input.begin(), input.end(), working.begin())) return 99;
+	return 0;
+}
+
+//	== nth_element ==
+//	use the first element as a position into the data
+int nth_element (const uint8_t *data, size_t size)
+{
+	if (size <= 1) return 0;
+	const size_t partition_point = data[0] % size;	
+	Vec working(data + 1, data + size);
+	const auto partition_iter = working.begin() + partition_point;
+	std::nth_element(working.begin(), partition_iter, working.end());
+
+//	nth may be the end iterator, in this case nth_element has no effect.
+	if (partition_iter == working.end())
+	{
+		if (!std::equal(data + 1, data + size, working.begin())) return 98;
+	}
+	else
+	{
+		const uint8_t nth = *partition_iter;
+		if (!std::all_of(working.begin(), partition_iter, [=](uint8_t v) { return v <= nth; }))
+			return 1;
+		if (!std::all_of(partition_iter, working.end(),   [=](uint8_t v) { return v >= nth; }))
+			return 2;
+		if (!std::is_permutation(data + 1, data + size, working.begin())) return 99;
+		}
+
+	return 0;
+}
+
+//	== partial_sort ==
+//	use the first element as a position into the data
+int partial_sort (const uint8_t *data, size_t size)
+{
+	if (size <= 1) return 0;
+	const size_t sort_point = data[0] % size;
+	Vec working(data + 1, data + size);
+	const auto sort_iter = working.begin() + sort_point;
+	std::partial_sort(working.begin(), sort_iter, working.end());
+
+	if (sort_iter != working.end())
+	{
+		const uint8_t nth = *std::min_element(sort_iter, working.end());
+		if (!std::all_of(working.begin(), sort_iter, [=](uint8_t v) { return v <= nth; }))
+			return 1;
+		if (!std::all_of(sort_iter, working.end(),   [=](uint8_t v) { return v >= nth; }))
+			return 2;		
+	}
+	if (!std::is_sorted(working.begin(), sort_iter)) return 3;
+	if (!std::is_permutation(data + 1, data + size, working.begin())) return 99;
+
+	return 0;
+}
+
+
+//	== partial_sort_copy ==
+//	use the first element as a count
+int partial_sort_copy (const uint8_t *data, size_t size)
+{
+	if (size <= 1) return 0;
+	const size_t num_results = data[0] % size;
+	Vec results(num_results);
+	(void) std::partial_sort_copy(data + 1, data + size, results.begin(), results.end());
+
+//	The results have to be sorted
+	if (!std::is_sorted(results.begin(), results.end())) return 1;
+//	All the values in results have to be in the original data
+	for (auto v: results)
+		if (std::find(data + 1, data + size, v) == data + size) return 2;
+
+//	The things in results have to be the smallest N in the original data
+	Vec sorted(data + 1, data + size);
+	std::sort(sorted.begin(), sorted.end());
+	if (!std::equal(results.begin(), results.end(), sorted.begin())) return 3;
+	return 0;
+}
+
+//	The second sequence has been "uniqued"
+template <typename Iter1, typename Iter2>
+static bool compare_unique(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2)
+{
+	assert(first1 != last1 && first2 != last2);
+	if (*first1 != *first2) return false;
+
+	uint8_t last_value = *first1;
+	++first1; ++first2;
+	while(first1 != last1 && first2 != last2)
+	{
+	//	Skip over dups in the first sequence
+		while (*first1 == last_value)
+			if (++first1 == last1) return false;
+		if (*first1 != *first2) return false;
+		last_value = *first1;
+		++first1; ++first2;
+	}
+
+//	Still stuff left in the 'uniqued' sequence - oops
+	if (first1 == last1 && first2 != last2) return false;
+
+//	Still stuff left in the original sequence - better be all the same
+	while (first1 != last1)
+	{
+		if (*first1 != last_value) return false;
+		++first1;
+	}
+	return true;
+}
+
+//	== unique ==
+int unique (const uint8_t *data, size_t size)
+{
+	Vec working(data, data + size);
+	std::sort(working.begin(), working.end());
+	Vec results = working;
+	Vec::iterator new_end = std::unique(results.begin(), results.end());
+	Vec::iterator it;	// scratch iterator
+	
+//	Check the size of the unique'd sequence.
+//	it should only be zero if the input sequence was empty.
+	if (results.begin() == new_end)
+		return working.size() == 0 ? 0 : 1;
+	
+//	'results' is sorted
+	if (!std::is_sorted(results.begin(), new_end)) return 2;
+
+//	All the elements in 'results' must be different
+	it = results.begin();
+	uint8_t prev_value = *it++;
+	for (; it != new_end; ++it)
+	{
+		if (*it == prev_value) return 3;
+		prev_value = *it;
+	}
+	
+//	Every element in 'results' must be in 'working'
+	for (it = results.begin(); it != new_end; ++it)
+		if (std::find(working.begin(), working.end(), *it) == working.end())
+			return 4;
+			
+//	Every element in 'working' must be in 'results'
+	for (auto v : working)
+		if (std::find(results.begin(), new_end, v) == new_end)
+			return 5;
+	
+	return 0;
+}
+
+//	== unique_copy ==
+int unique_copy (const uint8_t *data, size_t size)
+{
+	Vec working(data, data + size);
+	std::sort(working.begin(), working.end());
+	Vec results;
+	(void) std::unique_copy(working.begin(), working.end(),
+	                        std::back_inserter<Vec>(results));
+	Vec::iterator it;	// scratch iterator
+	
+//	Check the size of the unique'd sequence.
+//	it should only be zero if the input sequence was empty.
+	if (results.size() == 0)
+		return working.size() == 0 ? 0 : 1;
+	
+//	'results' is sorted
+	if (!std::is_sorted(results.begin(), results.end())) return 2;
+
+//	All the elements in 'results' must be different
+	it = results.begin();
+	uint8_t prev_value = *it++;
+	for (; it != results.end(); ++it)
+	{
+		if (*it == prev_value) return 3;
+		prev_value = *it;
+	}
+	
+//	Every element in 'results' must be in 'working'
+	for (auto v : results)
+		if (std::find(working.begin(), working.end(), v) == working.end())
+			return 4;
+			
+//	Every element in 'working' must be in 'results'
+	for (auto v : working)
+		if (std::find(results.begin(), results.end(), v) == results.end())
+			return 5;
+	
+	return 0;
+}
+
+
+// --	regex fuzzers
+static int regex_helper(const uint8_t *data, size_t size, std::regex::flag_type flag)
+{
+	if (size > 0)
+	{
+		try
+		{
+			std::string s((const char *)data, size);
+			std::regex re(s, flag);
+			return std::regex_match(s, re) ? 1 : 0;
+		} 
+		catch (std::regex_error &ex) {} 
+	}
+	return 0;		
+}
+
+
+int regex_ECMAScript (const uint8_t *data, size_t size)
+{
+	(void) regex_helper(data, size, std::regex_constants::ECMAScript);
+	return 0;
+}
+
+int regex_POSIX (const uint8_t *data, size_t size)
+{
+	(void) regex_helper(data, size, std::regex_constants::basic);
+	return 0;
+}
+
+int regex_extended (const uint8_t *data, size_t size)
+{
+	(void) regex_helper(data, size, std::regex_constants::extended);
+	return 0;
+}
+
+int regex_awk (const uint8_t *data, size_t size)
+{
+	(void) regex_helper(data, size, std::regex_constants::awk);
+	return 0;
+}
+
+int regex_grep (const uint8_t *data, size_t size)
+{
+	(void) regex_helper(data, size, std::regex_constants::grep);
+	return 0;
+}
+
+int regex_egrep (const uint8_t *data, size_t size)
+{
+	(void) regex_helper(data, size, std::regex_constants::egrep);
+	return 0;
+}
+
+// --	heap fuzzers
+int make_heap (const uint8_t *data, size_t size)
+{
+	Vec working(data, data + size);
+	std::make_heap(working.begin(), working.end());
+
+	if (!std::is_heap(working.begin(), working.end())) return 1;
+	if (!std::is_permutation(data, data + size, working.begin())) return 99;
+	return 0;
+}
+
+int push_heap (const uint8_t *data, size_t size)
+{
+	if (size < 2) return 0;
+
+//	Make a heap from the first half of the data
+	Vec working(data, data + size);
+	auto iter = working.begin() + (size / 2);
+	std::make_heap(working.begin(), iter);
+	if (!std::is_heap(working.begin(), iter)) return 1;
+
+//	Now push the rest onto the heap, one at a time
+	++iter;
+	for (; iter != working.end(); ++iter) {
+		std::push_heap(working.begin(), iter);
+		if (!std::is_heap(working.begin(), iter)) return 2;	
+		}
+
+	if (!std::is_permutation(data, data + size, working.begin())) return 99;
+	return 0;
+}
+
+int pop_heap (const uint8_t *data, size_t size)
+{
+	if (size < 2) return 0;
+	Vec working(data, data + size);
+	std::make_heap(working.begin(), working.end());
+
+//	Pop things off, one at a time
+	auto iter = --working.end();
+	while (iter != working.begin()) {
+		std::pop_heap(working.begin(), iter);
+		if (!std::is_heap(working.begin(), --iter)) return 2;	
+		}
+
+	return 0;
+}
+
+
+// --	search fuzzers
+int search (const uint8_t *data, size_t size)
+{
+	if (size < 2) return 0;
+	
+	const size_t pat_size = data[0] * (size - 1) / std::numeric_limits<uint8_t>::max();
+	assert(pat_size <= size - 1);
+	const uint8_t *pat_begin = data + 1;
+	const uint8_t *pat_end   = pat_begin + pat_size;
+	const uint8_t *data_end  = data + size;
+	assert(pat_end <= data_end);
+// 	std::cerr << "data[0] = " << size_t(data[0]) << " ";
+// 	std::cerr << "Pattern size = " << pat_size << "; corpus is " << size - 1 << std::endl;
+	auto it = std::search(pat_end, data_end, pat_begin, pat_end);
+	if (it != data_end) // not found
+		if (!std::equal(pat_begin, pat_end, it))
+			return 1;
+	return 0;
+}
+
+template <typename S>
+static int search_helper (const uint8_t *data, size_t size)
+{
+	if (size < 2) return 0;
+	
+	const size_t pat_size = data[0] * (size - 1) / std::numeric_limits<uint8_t>::max();
+	const uint8_t *pat_begin = data + 1;
+	const uint8_t *pat_end   = pat_begin + pat_size;
+	const uint8_t *data_end  = data + size;
+
+	auto it = std::search(pat_end, data_end, S(pat_begin, pat_end));
+	if (it != data_end) // not found
+		if (!std::equal(pat_begin, pat_end, it))
+			return 1;
+	return 0;
+}
+
+//	These are still in std::experimental
+// int search_boyer_moore (const uint8_t *data, size_t size)
+// {
+// 	return search_helper<std::boyer_moore_searcher<const uint8_t *>>(data, size);
+// }
+// 
+// int search_boyer_moore_horspool (const uint8_t *data, size_t size)
+// {
+// 	return search_helper<std::boyer_moore_horspool_searcher<const uint8_t *>>(data, size);
+// }
+
+
+// --	set operation fuzzers
+template <typename S>
+static void set_helper (const uint8_t *data, size_t size, Vec &v1, Vec &v2)
+{
+	assert(size > 1);
+	
+	const size_t pat_size = data[0] * (size - 1) / std::numeric_limits<uint8_t>::max();
+	const uint8_t *pat_begin = data + 1;
+	const uint8_t *pat_end   = pat_begin + pat_size;
+	const uint8_t *data_end  = data + size;
+	v1.assign(pat_begin, pat_end);
+	v2.assign(pat_end, data_end);
+
+	std::sort(v1.begin(), v1.end());
+	std::sort(v2.begin(), v2.end());
+}
+
+} // namespace fuzzing
diff --git a/fuzzing/fuzzing.h b/fuzzing/fuzzing.h
new file mode 100644
index 000000000000..06f58904b1fc
--- /dev/null
+++ b/fuzzing/fuzzing.h
@@ -0,0 +1,62 @@
+// -*- C++ -*-
+//===-------------------------- fuzzing.h --------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_FUZZING
+#define _LIBCPP_FUZZING
+
+#include <cstddef> // for size_t
+#include <cstdint> // for uint8_t
+
+namespace fuzzing {
+
+//  These all return 0 on success; != 0 on failure
+    int sort             (const uint8_t *data, size_t size);
+    int stable_sort      (const uint8_t *data, size_t size);
+    int partition        (const uint8_t *data, size_t size);
+    int partition_copy   (const uint8_t *data, size_t size);
+    int stable_partition (const uint8_t *data, size_t size);
+	int unique           (const uint8_t *data, size_t size);
+	int unique_copy      (const uint8_t *data, size_t size);
+
+//  partition and stable_partition take Bi-Di iterators.
+//  Should test those, too
+    int nth_element       (const uint8_t *data, size_t size);
+    int partial_sort      (const uint8_t *data, size_t size);
+    int partial_sort_copy (const uint8_t *data, size_t size);
+
+//  Heap operations
+    int make_heap        (const uint8_t *data, size_t size);
+    int push_heap        (const uint8_t *data, size_t size);
+    int pop_heap         (const uint8_t *data, size_t size);
+
+//  Various flavors of regex
+    int regex_ECMAScript (const uint8_t *data, size_t size);
+    int regex_POSIX      (const uint8_t *data, size_t size);
+    int regex_extended   (const uint8_t *data, size_t size);
+    int regex_awk        (const uint8_t *data, size_t size);
+    int regex_grep       (const uint8_t *data, size_t size);
+    int regex_egrep      (const uint8_t *data, size_t size);
+
+//	Searching
+	int search                      (const uint8_t *data, size_t size);
+// 	int search_boyer_moore          (const uint8_t *data, size_t size);
+// 	int search_boyer_moore_horspool (const uint8_t *data, size_t size);
+
+//	Set operations
+// 	int includes                 (const uint8_t *data, size_t size);
+// 	int set_union                (const uint8_t *data, size_t size);
+// 	int set_intersection         (const uint8_t *data, size_t size);
+// 	int set_difference           (const uint8_t *data, size_t size);
+// 	int set_symmetric_difference (const uint8_t *data, size_t size);
+// 	int merge                    (const uint8_t *data, size_t size);
+
+} // namespace fuzzing
+
+#endif // _LIBCPP_FUZZING
diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index 5a1b2ccdc426..b98e09260ca1 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -58,9 +58,12 @@ if (LIBCXX_INSTALL_HEADERS)
                       COMMAND "${CMAKE_COMMAND}"
                               -DCMAKE_INSTALL_COMPONENT=cxx-headers
                               -P "${CMAKE_BINARY_DIR}/cmake_install.cmake")
+    # Stripping is a no-op for headers
+    add_custom_target(install-cxx-headers-stripped DEPENDS install-cxx-headers)
 
     add_custom_target(libcxx-headers)
     add_custom_target(install-libcxx-headers DEPENDS install-cxx-headers)
+    add_custom_target(install-libcxx-headers-stripped DEPENDS install-cxx-headers-stripped)
   endif()
 
 endif()
diff --git a/include/__config b/include/__config
index f15d2d06e564..d0f95ef28342 100644
--- a/include/__config
+++ b/include/__config
@@ -33,7 +33,7 @@
 #define _GNUC_VER_NEW 0
 #endif
 
-#define _LIBCPP_VERSION 5000
+#define _LIBCPP_VERSION 6000
 
 #ifndef _LIBCPP_ABI_VERSION
 #define _LIBCPP_ABI_VERSION 1
@@ -45,6 +45,8 @@
 #define _LIBCPP_OBJECT_FORMAT_MACHO 1
 #elif defined(_WIN32)
 #define _LIBCPP_OBJECT_FORMAT_COFF  1
+#elif defined(__wasm__)
+#define _LIBCPP_OBJECT_FORMAT_WASM  1
 #else
 #error Unknown object file format
 #endif
@@ -55,11 +57,11 @@
 #define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 // Fix deque iterator type in order to support incomplete types.
 #define _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE
-// Fix undefined behavior in how std::list stores it's linked nodes.
+// Fix undefined behavior in how std::list stores its linked nodes.
 #define _LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB
 // Fix undefined behavior in  how __tree stores its end and parent nodes.
 #define _LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB
-// Fix undefined behavior in how __hash_table stores it's pointer types
+// Fix undefined behavior in how __hash_table stores its pointer types.
 #define _LIBCPP_ABI_FIX_UNORDERED_NODE_POINTER_UB
 #define _LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB
 #define _LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE
@@ -76,9 +78,11 @@
 // its vtable and typeinfo to libc++ rather than having all other libraries
 // using that class define their own copies.
 #define _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
-
 // Enable optimized version of __do_get_(un)signed which avoids redundant copies.
 #define _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
+// Use the smallest possible integer type to represent the index of the variant.
+// Previously libc++ used "unsigned int" exclusivly.
+#define _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION
 #elif _LIBCPP_ABI_VERSION == 1
 #if !defined(_LIBCPP_OBJECT_FORMAT_COFF)
 // Enable compiling copies of now inline methods into the dylib to support
@@ -121,6 +125,9 @@
 #ifndef __has_feature
 #define __has_feature(__x) 0
 #endif
+#ifndef __has_cpp_attribute
+#define __has_cpp_attribute(__x) 0
+#endif
 // '__is_identifier' returns '0' if '__x' is a reserved identifier provided by
 // the compiler and '1' otherwise.
 #ifndef __is_identifier
@@ -157,11 +164,21 @@
 
 // FIXME: ABI detection should be done via compiler builtin macros. This
 // is just a placeholder until Clang implements such macros. For now assume
-// that Windows compilers pretending to be MSVC++ target the microsoft ABI.
-#if defined(_WIN32) && defined(_MSC_VER)
+// that Windows compilers pretending to be MSVC++ target the Microsoft ABI,
+// and allow the user to explicitly specify the ABI to handle cases where this
+// heuristic falls short.
+#if defined(_LIBCPP_ABI_FORCE_ITANIUM) && defined(_LIBCPP_ABI_FORCE_MICROSOFT)
+# error "Only one of _LIBCPP_ABI_FORCE_ITANIUM and _LIBCPP_ABI_FORCE_MICROSOFT can be defined"
+#elif defined(_LIBCPP_ABI_FORCE_ITANIUM)
+# define _LIBCPP_ABI_ITANIUM
+#elif defined(_LIBCPP_ABI_FORCE_MICROSOFT)
 # define _LIBCPP_ABI_MICROSOFT
 #else
-# define _LIBCPP_ABI_ITANIUM
+# if defined(_WIN32) && defined(_MSC_VER)
+#  define _LIBCPP_ABI_MICROSOFT
+# else
+#  define _LIBCPP_ABI_ITANIUM
+# endif
 #endif
 
 // Need to detect which libc we're using if we're on Linux.
@@ -174,36 +191,30 @@
 
 #ifdef __LITTLE_ENDIAN__
 #if __LITTLE_ENDIAN__
-#define _LIBCPP_LITTLE_ENDIAN 1
-#define _LIBCPP_BIG_ENDIAN    0
+#define _LIBCPP_LITTLE_ENDIAN
 #endif  // __LITTLE_ENDIAN__
 #endif  // __LITTLE_ENDIAN__
 
 #ifdef __BIG_ENDIAN__
 #if __BIG_ENDIAN__
-#define _LIBCPP_LITTLE_ENDIAN 0
-#define _LIBCPP_BIG_ENDIAN    1
+#define _LIBCPP_BIG_ENDIAN
 #endif  // __BIG_ENDIAN__
 #endif  // __BIG_ENDIAN__
 
 #ifdef __BYTE_ORDER__
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-#define _LIBCPP_LITTLE_ENDIAN 1
-#define _LIBCPP_BIG_ENDIAN 0
+#define _LIBCPP_LITTLE_ENDIAN
 #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-#define _LIBCPP_LITTLE_ENDIAN 0
-#define _LIBCPP_BIG_ENDIAN 1
+#define _LIBCPP_BIG_ENDIAN
 #endif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 #endif // __BYTE_ORDER__
 
 #ifdef __FreeBSD__
 # include <sys/endian.h>
 #  if _BYTE_ORDER == _LITTLE_ENDIAN
-#   define _LIBCPP_LITTLE_ENDIAN 1
-#   define _LIBCPP_BIG_ENDIAN    0
+#   define _LIBCPP_LITTLE_ENDIAN
 # else  // _BYTE_ORDER == _LITTLE_ENDIAN
-#   define _LIBCPP_LITTLE_ENDIAN 0
-#   define _LIBCPP_BIG_ENDIAN    1
+#   define _LIBCPP_BIG_ENDIAN
 # endif  // _BYTE_ORDER == _LITTLE_ENDIAN
 # ifndef __LONG_LONG_SUPPORTED
 #  define _LIBCPP_HAS_NO_LONG_LONG
@@ -213,19 +224,16 @@
 #ifdef __NetBSD__
 # include <sys/endian.h>
 #  if _BYTE_ORDER == _LITTLE_ENDIAN
-#   define _LIBCPP_LITTLE_ENDIAN 1
-#   define _LIBCPP_BIG_ENDIAN    0
+#   define _LIBCPP_LITTLE_ENDIAN
 # else  // _BYTE_ORDER == _LITTLE_ENDIAN
-#   define _LIBCPP_LITTLE_ENDIAN 0
-#   define _LIBCPP_BIG_ENDIAN    1
+#   define _LIBCPP_BIG_ENDIAN
 # endif  // _BYTE_ORDER == _LITTLE_ENDIAN
 # define _LIBCPP_HAS_QUICK_EXIT
 #endif  // __NetBSD__
 
 #if defined(_WIN32)
 #  define _LIBCPP_WIN32API
-#  define _LIBCPP_LITTLE_ENDIAN 1
-#  define _LIBCPP_BIG_ENDIAN    0
+#  define _LIBCPP_LITTLE_ENDIAN
 #  define _LIBCPP_SHORT_WCHAR   1
 // Both MinGW and native MSVC provide a "MSVC"-like enviroment
 #  define _LIBCPP_MSVCRT_LIKE
@@ -255,11 +263,9 @@
 #ifdef __sun__
 # include <sys/isa_defs.h>
 # ifdef _LITTLE_ENDIAN
-#   define _LIBCPP_LITTLE_ENDIAN 1
-#   define _LIBCPP_BIG_ENDIAN    0
+#   define _LIBCPP_LITTLE_ENDIAN
 # else
-#   define _LIBCPP_LITTLE_ENDIAN 0
-#   define _LIBCPP_BIG_ENDIAN    1
+#   define _LIBCPP_BIG_ENDIAN
 # endif
 #endif // __sun__
 
@@ -269,6 +275,8 @@
   // random data even when using sandboxing mechanisms such as chroots,
   // Capsicum, etc.
 # define _LIBCPP_USING_ARC4_RANDOM
+#elif defined(__Fuchsia__)
+# define _LIBCPP_USING_GETENTROPY
 #elif defined(__native_client__)
   // NaCl's sandbox (which PNaCl also runs in) doesn't allow filesystem access,
   // including accesses to the special files under /dev. C++11's
@@ -280,18 +288,16 @@
 # define _LIBCPP_USING_DEV_RANDOM
 #endif
 
-#if !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
+#if !defined(_LIBCPP_LITTLE_ENDIAN) && !defined(_LIBCPP_BIG_ENDIAN)
 # include <endian.h>
 # if __BYTE_ORDER == __LITTLE_ENDIAN
-#  define _LIBCPP_LITTLE_ENDIAN 1
-#  define _LIBCPP_BIG_ENDIAN    0
+#  define _LIBCPP_LITTLE_ENDIAN
 # elif __BYTE_ORDER == __BIG_ENDIAN
-#  define _LIBCPP_LITTLE_ENDIAN 0
-#  define _LIBCPP_BIG_ENDIAN    1
+#  define _LIBCPP_BIG_ENDIAN
 # else  // __BYTE_ORDER == __BIG_ENDIAN
 #  error unable to determine endian
 # endif
-#endif  // !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
+#endif  // !defined(_LIBCPP_LITTLE_ENDIAN) && !defined(_LIBCPP_BIG_ENDIAN)
 
 #if __has_attribute(__no_sanitize__) && !defined(_LIBCPP_COMPILER_GCC)
 #define _LIBCPP_NO_CFI __attribute__((__no_sanitize__("cfi")))
@@ -454,6 +460,10 @@ namespace std {
 #define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK __attribute__((__no_sanitize__("unsigned-integer-overflow")))
 #endif 
 
+#if __has_builtin(__builtin_launder)
+#define	_LIBCPP_COMPILER_HAS_BUILTIN_LAUNDER
+#endif
+
 #elif defined(_LIBCPP_COMPILER_GCC)
 
 #define _ALIGNAS(x) __attribute__((__aligned__(x)))
@@ -536,6 +546,10 @@ namespace std {
 #define _LIBCPP_HAS_NO_ASAN
 #endif
 
+#if _GNUC_VER >= 700
+#define	_LIBCPP_COMPILER_HAS_BUILTIN_LAUNDER
+#endif
+
 #elif defined(_LIBCPP_COMPILER_MSVC)
 
 #define _LIBCPP_TOSTRING2(x) #x
@@ -880,7 +894,7 @@ template <unsigned> struct __static_assert_check {};
 #define _LIBCPP_NONUNIQUE_RTTI_BIT (1ULL << 63)
 #endif
 
-#if defined(__APPLE__) || defined(__FreeBSD__) || defined(_LIBCPP_MSVCRT) ||   \
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(_LIBCPP_MSVCRT_LIKE) || \
     defined(__sun__) || defined(__NetBSD__) || defined(__CloudABI__)
 #define _LIBCPP_LOCALE__L_EXTENSIONS 1
 #endif
@@ -954,6 +968,18 @@ template <unsigned> struct __static_assert_check {};
 #define _LIBCPP_CONSTEXPR_AFTER_CXX14
 #endif
 
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CXX14_CONSTEXPR)
+#define _LIBCPP_CONSTEXPR_AFTER_CXX17 constexpr
+#else
+#define _LIBCPP_CONSTEXPR_AFTER_CXX17
+#endif
+
+#if __has_cpp_attribute(nodiscard) && _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_DISABLE_NODISCARD_AFTER_CXX17)
+#define _LIBCPP_NODISCARD_AFTER_CXX17 [[nodiscard]]
+#else
+#define _LIBCPP_NODISCARD_AFTER_CXX17
+#endif
+
 // FIXME: Remove all usages of this macro once compilers catch up.
 #if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606L)
 # define _LIBCPP_HAS_NO_INLINE_VARIABLES
@@ -1241,6 +1267,13 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
 # endif
 #endif // defined(_LIBCPP_HAS_NO_PRAGMA_PUSH_POP_MACRO)
 
+#if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_BUILDING_LIBRARY)
+# if defined(_DLL)
+#   pragma(lib, "c++.lib")
+# else
+#   pragma(lib, "libc++.lib")
+# endif
+#endif // defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_BUILDING_LIBRARY)
 
 #endif // __cplusplus
 
diff --git a/include/__config_site.in b/include/__config_site.in
index 667b4e94ccc9..86418a3e17b1 100644
--- a/include/__config_site.in
+++ b/include/__config_site.in
@@ -12,6 +12,8 @@
 
 #cmakedefine _LIBCPP_ABI_VERSION @_LIBCPP_ABI_VERSION@
 #cmakedefine _LIBCPP_ABI_UNSTABLE
+#cmakedefine _LIBCPP_ABI_FORCE_ITANIUM
+#cmakedefine _LIBCPP_ABI_FORCE_MICROSOFT
 #cmakedefine _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
 #cmakedefine _LIBCPP_HAS_NO_STDIN
 #cmakedefine _LIBCPP_HAS_NO_STDOUT
@@ -23,5 +25,8 @@
 #cmakedefine _LIBCPP_HAS_THREAD_API_EXTERNAL
 #cmakedefine _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL
 #cmakedefine _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
+#cmakedefine _LIBCPP_NO_VCRUNTIME
+
+@_LIBCPP_ABI_DEFINES@
 
 #endif // _LIBCPP_CONFIG_SITE
diff --git a/include/__libcpp_version b/include/__libcpp_version
index e9c02dad1826..a77fd92cf17b 100644
--- a/include/__libcpp_version
+++ b/include/__libcpp_version
@@ -1 +1 @@
-5000
+6000
diff --git a/include/__locale b/include/__locale
index 91ed9e709ee3..601f0d1ec325 100644
--- a/include/__locale
+++ b/include/__locale
@@ -49,7 +49,7 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if !defined(_LIBCPP_LOCALE__L_EXTENSIONS) || defined(_LIBCPP_MSVCRT)
+#if !defined(_LIBCPP_LOCALE__L_EXTENSIONS)
 struct __libcpp_locale_guard {
   _LIBCPP_INLINE_VISIBILITY
   __libcpp_locale_guard(locale_t& __loc) : __old_loc_(uselocale(__loc)) {}
@@ -65,6 +65,32 @@ private:
   __libcpp_locale_guard(__libcpp_locale_guard const&);
   __libcpp_locale_guard& operator=(__libcpp_locale_guard const&);
 };
+#elif defined(_LIBCPP_MSVCRT_LIKE)
+struct __libcpp_locale_guard {
+    __libcpp_locale_guard(locale_t __l) :
+        __status(_configthreadlocale(_ENABLE_PER_THREAD_LOCALE)),
+        __locale_collate(setlocale(LC_COLLATE, __l.__get_locale())),
+        __locale_ctype(setlocale(LC_CTYPE, __l.__get_locale())),
+        __locale_monetary(setlocale(LC_MONETARY, __l.__get_locale())),
+        __locale_numeric(setlocale(LC_NUMERIC, __l.__get_locale())),
+        __locale_time(setlocale(LC_TIME, __l.__get_locale()))
+        // LC_MESSAGES is not supported on Windows.
+    {}
+    ~__libcpp_locale_guard() {
+        setlocale(LC_COLLATE, __locale_collate);
+        setlocale(LC_CTYPE, __locale_ctype);
+        setlocale(LC_MONETARY, __locale_monetary);
+        setlocale(LC_NUMERIC, __locale_numeric);
+        setlocale(LC_TIME, __locale_time);
+        _configthreadlocale(__status);
+    }
+    int __status;
+    char* __locale_collate;
+    char* __locale_ctype;
+    char* __locale_monetary;
+    char* __locale_numeric;
+    char* __locale_time;
+};
 #endif
 
 
diff --git a/include/__tree b/include/__tree
index 792870aa6ebc..3ccfcb700310 100644
--- a/include/__tree
+++ b/include/__tree
@@ -84,7 +84,7 @@ __tree_is_left_child(_NodePtr __x) _NOEXCEPT
     return __x == __x->__parent_->__left_;
 }
 
-// Determintes if the subtree rooted at __x is a proper red black subtree.  If
+// Determines if the subtree rooted at __x is a proper red black subtree.  If
 //    __x is a proper subtree, returns the black height (null counts as 1).  If
 //    __x is an improper subtree, returns 0.
 template <class _NodePtr>
@@ -119,7 +119,7 @@ __tree_sub_invariant(_NodePtr __x)
     return __h + __x->__is_black_;  // return black height of this node
 }
 
-// Determintes if the red black tree rooted at __root is a proper red black tree.
+// Determines if the red black tree rooted at __root is a proper red black tree.
 //    __root == nullptr is a proper tree.  Returns true is __root is a proper
 //    red black tree, else returns false.
 template <class _NodePtr>
diff --git a/include/algorithm b/include/algorithm
index 00db6d7e7c87..35c6129ea508 100644
--- a/include/algorithm
+++ b/include/algorithm
@@ -734,15 +734,15 @@ struct __less<_T1, const _T1>
 };
 
 template <class _Predicate>
-class __negate
+class __invert // invert the sense of a comparison
 {
 private:
     _Predicate __p_;
 public:
-    _LIBCPP_INLINE_VISIBILITY __negate() {}
+    _LIBCPP_INLINE_VISIBILITY __invert() {}
 
     _LIBCPP_INLINE_VISIBILITY
-    explicit __negate(_Predicate __p) : __p_(__p) {}
+    explicit __invert(_Predicate __p) : __p_(__p) {}
 
     template <class _T1>
     _LIBCPP_INLINE_VISIBILITY
@@ -750,7 +750,7 @@ public:
 
     template <class _T1, class _T2>
     _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _T1& __x, const _T2& __y) {return !__p_(__x, __y);}
+    bool operator()(const _T1& __x, const _T2& __y) {return __p_(__y, __x);}
 };
 
 #ifdef _LIBCPP_DEBUG
@@ -797,7 +797,7 @@ unsigned __ctz(unsigned __x) {
   unsigned long where;
   // Search from LSB to MSB for first set bit.
   // Returns zero if no set bit is found.
-  if (_BitScanForward(&where, mask))
+  if (_BitScanForward(&where, __x))
     return where;
   return 32;
 #endif
@@ -823,15 +823,15 @@ unsigned long long __ctz(unsigned long long __x) {
 // Returns zero if no set bit is found.
 #if defined(_LIBCPP_HAS_BITSCAN64)
     (defined(_M_AMD64) || defined(__x86_64__))
-  if (_BitScanForward64(&where, mask))
+  if (_BitScanForward64(&where, __x))
     return static_cast<int>(where);
 #else
   // Win32 doesn't have _BitScanForward64 so emulate it with two 32 bit calls.
   // Scan the Low Word.
-  if (_BitScanForward(&where, static_cast<unsigned long>(mask)))
+  if (_BitScanForward(&where, static_cast<unsigned long>(__x)))
     return where;
   // Scan the High Word.
-  if (_BitScanForward(&where, static_cast<unsigned long>(mask >> 32)))
+  if (_BitScanForward(&where, static_cast<unsigned long>(__x >> 32)))
     return where + 32; // Create a bit offset from the LSB.
 #endif
   return 64;
@@ -849,7 +849,7 @@ unsigned __clz(unsigned __x) {
   unsigned long where;
   // Search from LSB to MSB for first set bit.
   // Returns zero if no set bit is found.
-  if (_BitScanReverse(&where, mask))
+  if (_BitScanReverse(&where, __x))
     return 31 - where;
   return 32; // Undefined Behavior.
 #endif
@@ -874,14 +874,14 @@ unsigned long long __clz(unsigned long long __x) {
 // BitScanReverse scans from MSB to LSB for first set bit.
 // Returns 0 if no set bit is found.
 #if defined(_LIBCPP_HAS_BITSCAN64)
-  if (_BitScanReverse64(&where, mask))
+  if (_BitScanReverse64(&where, __x))
     return static_cast<int>(63 - where);
 #else
   // Scan the high 32 bits.
-  if (_BitScanReverse(&where, static_cast<unsigned long>(mask >> 32)))
+  if (_BitScanReverse(&where, static_cast<unsigned long>(__x >> 32)))
     return 63 - (where + 32); // Create a bit offset from the MSB.
   // Scan the low 32 bits.
-  if (_BitScanReverse(&where, static_cast<unsigned long>(mask)))
+  if (_BitScanReverse(&where, static_cast<unsigned long>(__x)))
     return 63 - where;
 #endif
   return 64; // Undefined Behavior.
@@ -3210,28 +3210,28 @@ template <class _PopulationIterator, class _SampleIterator, class _Distance,
           class _UniformRandomNumberGenerator>
 _LIBCPP_INLINE_VISIBILITY
 _SampleIterator __sample(_PopulationIterator __first,
-                         _PopulationIterator __last, _SampleIterator __output,
+                         _PopulationIterator __last, _SampleIterator __output_iter,
                          _Distance __n,
                          _UniformRandomNumberGenerator & __g,
                          input_iterator_tag) {
 
   _Distance __k = 0;
   for (; __first != __last && __k < __n; ++__first, (void)++__k)
-    __output[__k] = *__first;
+    __output_iter[__k] = *__first;
   _Distance __sz = __k;
   for (; __first != __last; ++__first, (void)++__k) {
     _Distance __r = _VSTD::uniform_int_distribution<_Distance>(0, __k)(__g);
     if (__r < __sz)
-      __output[__r] = *__first;
+      __output_iter[__r] = *__first;
   }
-  return __output + _VSTD::min(__n, __k);
+  return __output_iter + _VSTD::min(__n, __k);
 }
 
 template <class _PopulationIterator, class _SampleIterator, class _Distance,
           class _UniformRandomNumberGenerator>
 _LIBCPP_INLINE_VISIBILITY
 _SampleIterator __sample(_PopulationIterator __first,
-                         _PopulationIterator __last, _SampleIterator __output,
+                         _PopulationIterator __last, _SampleIterator __output_iter,
                          _Distance __n,
                          _UniformRandomNumberGenerator& __g,
                          forward_iterator_tag) {
@@ -3240,18 +3240,18 @@ _SampleIterator __sample(_PopulationIterator __first,
     _Distance __r =
         _VSTD::uniform_int_distribution<_Distance>(0, --__unsampled_sz)(__g);
     if (__r < __n) {
-      *__output++ = *__first;
+      *__output_iter++ = *__first;
       --__n;
     }
   }
-  return __output;
+  return __output_iter;
 }
 
 template <class _PopulationIterator, class _SampleIterator, class _Distance,
           class _UniformRandomNumberGenerator>
 _LIBCPP_INLINE_VISIBILITY
 _SampleIterator __sample(_PopulationIterator __first,
-                         _PopulationIterator __last, _SampleIterator __output,
+                         _PopulationIterator __last, _SampleIterator __output_iter,
                          _Distance __n, _UniformRandomNumberGenerator& __g) {
   typedef typename iterator_traits<_PopulationIterator>::iterator_category
         _PopCategory;
@@ -3263,7 +3263,7 @@ _SampleIterator __sample(_PopulationIterator __first,
   typedef typename common_type<_Distance, _Difference>::type _CommonType;
   _LIBCPP_ASSERT(__n >= 0, "N must be a positive number.");
   return _VSTD::__sample(
-      __first, __last, __output, _CommonType(__n),
+      __first, __last, __output_iter, _CommonType(__n),
       __g, _PopCategory());
 }
 
@@ -3272,9 +3272,9 @@ template <class _PopulationIterator, class _SampleIterator, class _Distance,
           class _UniformRandomNumberGenerator>
 inline _LIBCPP_INLINE_VISIBILITY
 _SampleIterator sample(_PopulationIterator __first,
-                       _PopulationIterator __last, _SampleIterator __output,
+                       _PopulationIterator __last, _SampleIterator __output_iter,
                        _Distance __n, _UniformRandomNumberGenerator&& __g) {
-    return _VSTD::__sample(__first, __last, __output, __n, __g);
+    return _VSTD::__sample(__first, __last, __output_iter, __n, __g);
 }
 #endif // _LIBCPP_STD_VER > 14
 
@@ -4568,7 +4568,7 @@ __buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator
         typedef reverse_iterator<value_type*> _Rv;
         __half_inplace_merge(_Rv(__p), _Rv(__buff),
                              _RBi(__middle), _RBi(__first),
-                             _RBi(__last), __negate<_Compare>(__comp));
+                             _RBi(__last), __invert<_Compare>(__comp));
     }
 }
 
@@ -5547,9 +5547,9 @@ __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
         }
         else
         {
-            *__result = *__first1;
             if (!__comp(*__first1, *__first2))
                 ++__first2;
+            *__result = *__first1;
             ++__first1;
         }
     }
diff --git a/include/array b/include/array
index 12780992e5c4..4eb2fe6fc624 100644
--- a/include/array
+++ b/include/array
@@ -183,7 +183,7 @@ struct _LIBCPP_TEMPLATE_VIS array
     _LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT {return _Size;}
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return _Size;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return _Size == 0;}
 
     // element access:
diff --git a/include/bitset b/include/bitset
index 583122fbfdab..cd6c289b4c48 100644
--- a/include/bitset
+++ b/include/bitset
@@ -235,8 +235,13 @@ void
 __bitset<_N_words, _Size>::__init(unsigned long long __v, false_type) _NOEXCEPT
 {
     __storage_type __t[sizeof(unsigned long long) / sizeof(__storage_type)];
-    for (size_t __i = 0; __i < sizeof(__t)/sizeof(__t[0]); ++__i, __v >>= __bits_per_word)
-        __t[__i] = static_cast<__storage_type>(__v);
+    size_t __sz = _Size;
+    for (size_t __i = 0; __i < sizeof(__t)/sizeof(__t[0]); ++__i, __v >>= __bits_per_word, __sz -= __bits_per_word )
+        if ( __sz < __bits_per_word)
+        	__t[__i] = static_cast<__storage_type>(__v) & ( 1ULL << __sz ) - 1;
+        else
+        	__t[__i] = static_cast<__storage_type>(__v);
+
     _VSTD::copy(__t, __t + sizeof(__t)/sizeof(__t[0]), __first_);
     _VSTD::fill(__first_ + sizeof(__t)/sizeof(__t[0]), __first_ + sizeof(__first_)/sizeof(__first_[0]),
                __storage_type(0));
@@ -248,6 +253,9 @@ void
 __bitset<_N_words, _Size>::__init(unsigned long long __v, true_type) _NOEXCEPT
 {
     __first_[0] = __v;
+    if (_Size < __bits_per_word)
+    	__first_[0] &= ( 1ULL << _Size ) - 1;
+
     _VSTD::fill(__first_ + 1, __first_ + sizeof(__first_)/sizeof(__first_[0]), __storage_type(0));
 }
 
@@ -261,7 +269,9 @@ __bitset<_N_words, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
 #if __SIZEOF_SIZE_T__ == 8
     : __first_{__v}
 #elif __SIZEOF_SIZE_T__ == 4
-    : __first_{static_cast<__storage_type>(__v), static_cast<__storage_type>(__v >> __bits_per_word)}
+    : __first_{static_cast<__storage_type>(__v), 
+    			_Size >= 2 * __bits_per_word ? static_cast<__storage_type>(__v >> __bits_per_word)
+    			: static_cast<__storage_type>((__v >> __bits_per_word) & (__storage_type(1) << (_Size - __bits_per_word)) - 1)}
 #else
 #error This constructor has not been ported to this platform
 #endif
@@ -503,7 +513,10 @@ template <size_t _Size>
 inline
 _LIBCPP_CONSTEXPR
 __bitset<1, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
-    : __first_(static_cast<__storage_type>(__v))
+    : __first_(
+        _Size == __bits_per_word ? static_cast<__storage_type>(__v)
+                                 : static_cast<__storage_type>(__v) & ((__storage_type(1) << _Size) - 1)
+    )
 {
 }
 
diff --git a/include/chrono b/include/chrono
index 4b793c760559..c69e88ae4ded 100644
--- a/include/chrono
+++ b/include/chrono
@@ -283,18 +283,18 @@ typedef steady_clock high_resolution_clock;
 
 }  // chrono
 
-constexpr chrono::hours                                 operator "" h(unsigned long long); // C++14
-constexpr chrono::duration<unspecified , ratio<3600,1>> operator "" h(long double); // C++14
-constexpr chrono::minutes                               operator "" min(unsigned long long); // C++14
-constexpr chrono::duration<unspecified , ratio<60,1>>   operator "" min(long double); // C++14
-constexpr chrono::seconds                               operator "" s(unsigned long long); // C++14
-constexpr chrono::duration<unspecified >                operator "" s(long double); // C++14
-constexpr chrono::milliseconds                          operator "" ms(unsigned long long); // C++14
-constexpr chrono::duration<unspecified , milli>         operator "" ms(long double); // C++14
-constexpr chrono::microseconds                          operator "" us(unsigned long long); // C++14
-constexpr chrono::duration<unspecified , micro>         operator "" us(long double); // C++14
-constexpr chrono::nanoseconds                           operator "" ns(unsigned long long); // C++14
-constexpr chrono::duration<unspecified , nano>          operator "" ns(long double); // C++14
+constexpr chrono::hours                                 operator ""h(unsigned long long); // C++14
+constexpr chrono::duration<unspecified , ratio<3600,1>> operator ""h(long double); // C++14
+constexpr chrono::minutes                               operator ""min(unsigned long long); // C++14
+constexpr chrono::duration<unspecified , ratio<60,1>>   operator ""min(long double); // C++14
+constexpr chrono::seconds                               operator ""s(unsigned long long); // C++14
+constexpr chrono::duration<unspecified >                operator ""s(long double); // C++14
+constexpr chrono::milliseconds                          operator ""ms(unsigned long long); // C++14
+constexpr chrono::duration<unspecified , milli>         operator ""ms(long double); // C++14
+constexpr chrono::microseconds                          operator ""us(unsigned long long); // C++14
+constexpr chrono::duration<unspecified , micro>         operator ""us(long double); // C++14
+constexpr chrono::nanoseconds                           operator ""ns(unsigned long long); // C++14
+constexpr chrono::duration<unspecified , nano>          operator ""ns(long double); // C++14
 
 }  // std
 */
@@ -1087,67 +1087,67 @@ inline namespace literals
   inline namespace chrono_literals
   {
 
-    constexpr chrono::hours operator"" h(unsigned long long __h)
+    constexpr chrono::hours operator""h(unsigned long long __h)
     {
         return chrono::hours(static_cast<chrono::hours::rep>(__h));
     }
 
-    constexpr chrono::duration<long double, ratio<3600,1>> operator"" h(long double __h)
+    constexpr chrono::duration<long double, ratio<3600,1>> operator""h(long double __h)
     {
         return chrono::duration<long double, ratio<3600,1>>(__h);
     }
 
 
-    constexpr chrono::minutes operator"" min(unsigned long long __m)
+    constexpr chrono::minutes operator""min(unsigned long long __m)
     {
         return chrono::minutes(static_cast<chrono::minutes::rep>(__m));
     }
 
-    constexpr chrono::duration<long double, ratio<60,1>> operator"" min(long double __m)
+    constexpr chrono::duration<long double, ratio<60,1>> operator""min(long double __m)
     {
         return chrono::duration<long double, ratio<60,1>> (__m);
     }
 
 
-    constexpr chrono::seconds operator"" s(unsigned long long __s)
+    constexpr chrono::seconds operator""s(unsigned long long __s)
     {
         return chrono::seconds(static_cast<chrono::seconds::rep>(__s));
     }
 
-    constexpr chrono::duration<long double> operator"" s(long double __s)
+    constexpr chrono::duration<long double> operator""s(long double __s)
     {
         return chrono::duration<long double> (__s);
     }
 
 
-    constexpr chrono::milliseconds operator"" ms(unsigned long long __ms)
+    constexpr chrono::milliseconds operator""ms(unsigned long long __ms)
     {
         return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(__ms));
     }
 
-    constexpr chrono::duration<long double, milli> operator"" ms(long double __ms)
+    constexpr chrono::duration<long double, milli> operator""ms(long double __ms)
     {
         return chrono::duration<long double, milli>(__ms);
     }
 
 
-    constexpr chrono::microseconds operator"" us(unsigned long long __us)
+    constexpr chrono::microseconds operator""us(unsigned long long __us)
     {
         return chrono::microseconds(static_cast<chrono::microseconds::rep>(__us));
     }
 
-    constexpr chrono::duration<long double, micro> operator"" us(long double __us)
+    constexpr chrono::duration<long double, micro> operator""us(long double __us)
     {
         return chrono::duration<long double, micro> (__us);
     }
     
 
-    constexpr chrono::nanoseconds operator"" ns(unsigned long long __ns)
+    constexpr chrono::nanoseconds operator""ns(unsigned long long __ns)
     {
         return chrono::nanoseconds(static_cast<chrono::nanoseconds::rep>(__ns));
     }
 
-    constexpr chrono::duration<long double, nano> operator"" ns(long double __ns)
+    constexpr chrono::duration<long double, nano> operator""ns(long double __ns)
     {
         return chrono::duration<long double, nano> (__ns);
     }
diff --git a/include/cstddef b/include/cstddef
index 62584494d97c..adeefdac9be6 100644
--- a/include/cstddef
+++ b/include/cstddef
@@ -64,23 +64,46 @@ namespace std  // purposefully not versioned
 {
 enum class byte : unsigned char {};
 
-constexpr byte& operator|=(byte& __lhs, byte __rhs) noexcept
-{ return __lhs = byte(static_cast<unsigned char>(__lhs) | static_cast<unsigned char>(__rhs)); }
 constexpr byte  operator| (byte  __lhs, byte __rhs) noexcept
-{ return         byte(static_cast<unsigned char>(__lhs) | static_cast<unsigned char>(__rhs)); }
+{
+	return static_cast<byte>(
+	  static_cast<unsigned char>(
+	     static_cast<unsigned int>(__lhs) | static_cast<unsigned int>(__rhs)
+	));
+}
+
+constexpr byte& operator|=(byte& __lhs, byte __rhs) noexcept
+{ return __lhs = __lhs | __rhs; }
 
-constexpr byte& operator&=(byte& __lhs, byte __rhs) noexcept
-{ return __lhs = byte(static_cast<unsigned char>(__lhs) & static_cast<unsigned char>(__rhs)); }
 constexpr byte  operator& (byte  __lhs, byte __rhs) noexcept
-{ return         byte(static_cast<unsigned char>(__lhs) & static_cast<unsigned char>(__rhs)); }
+{
+	return static_cast<byte>(
+	  static_cast<unsigned char>(
+	     static_cast<unsigned int>(__lhs) & static_cast<unsigned int>(__rhs)
+	));
+}
+
+constexpr byte& operator&=(byte& __lhs, byte __rhs) noexcept
+{ return __lhs = __lhs & __rhs; }
 
-constexpr byte& operator^=(byte& __lhs, byte __rhs) noexcept 
-{ return __lhs = byte(static_cast<unsigned char>(__lhs) ^ static_cast<unsigned char>(__rhs)); }
 constexpr byte  operator^ (byte  __lhs, byte __rhs) noexcept
-{ return         byte(static_cast<unsigned char>(__lhs) ^ static_cast<unsigned char>(__rhs)); }
+{
+	return static_cast<byte>(
+	  static_cast<unsigned char>(
+	     static_cast<unsigned int>(__lhs) ^ static_cast<unsigned int>(__rhs)
+	));
+}
+
+constexpr byte& operator^=(byte& __lhs, byte __rhs) noexcept 
+{ return __lhs = __lhs ^ __rhs; }
 
 constexpr byte  operator~ (byte __b) noexcept
-{ return  byte(~static_cast<unsigned char>(__b)); }
+{
+    return static_cast<byte>(
+      static_cast<unsigned char>(
+        ~static_cast<unsigned int>(__b)
+    ));
+}
 
 }
 
diff --git a/include/deque b/include/deque
index fee75614b97f..08cb295408be 100644
--- a/include/deque
+++ b/include/deque
@@ -1314,7 +1314,7 @@ public:
     void resize(size_type __n);
     void resize(size_type __n, const value_type& __v);
     void shrink_to_fit() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT {return __base::size() == 0;}
 
     // element access:
diff --git a/include/exception b/include/exception
index ca2eaf5c6a04..79bd6ac2ae35 100644
--- a/include/exception
+++ b/include/exception
@@ -82,7 +82,7 @@ template <class E> void rethrow_if_nested(const E& e);
 #include <cstdlib>
 #include <type_traits>
 
-#if defined(_LIBCPP_ABI_MICROSOFT)
+#if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_NO_VCRUNTIME)
 #include <vcruntime_exception.h>
 #endif
 
@@ -93,7 +93,7 @@ template <class E> void rethrow_if_nested(const E& e);
 namespace std  // purposefully not using versioning namespace
 {
 
-#if !defined(_LIBCPP_ABI_MICROSOFT)
+#if !defined(_LIBCPP_ABI_MICROSOFT) || defined(_LIBCPP_NO_VCRUNTIME)
 class _LIBCPP_EXCEPTION_ABI exception
 {
 public:
@@ -110,7 +110,7 @@ public:
     virtual ~bad_exception() _NOEXCEPT;
     virtual const char* what() const _NOEXCEPT;
 };
-#endif // !_LIBCPP_ABI_MICROSOFT
+#endif // !_LIBCPP_ABI_MICROSOFT || _LIBCPP_NO_VCRUNTIME
 
 #if _LIBCPP_STD_VER <= 14 \
     || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS) \
diff --git a/include/experimental/algorithm b/include/experimental/algorithm
index 3801cae4f16e..a6a28f07181b 100644
--- a/include/experimental/algorithm
+++ b/include/experimental/algorithm
@@ -61,9 +61,9 @@ template <class _PopulationIterator, class _SampleIterator, class _Distance,
           class _UniformRandomNumberGenerator>
 inline _LIBCPP_INLINE_VISIBILITY
 _SampleIterator sample(_PopulationIterator __first, _PopulationIterator __last,
-                       _SampleIterator __output, _Distance __n,
+                       _SampleIterator __output_iter, _Distance __n,
                        _UniformRandomNumberGenerator &&__g) {
-  return _VSTD::__sample(__first, __last, __output, __n, __g);
+  return _VSTD::__sample(__first, __last, __output_iter, __n, __g);
 }
 
 _LIBCPP_END_NAMESPACE_LFTS
diff --git a/include/experimental/filesystem b/include/experimental/filesystem
index 42157ba309bc..674490f60381 100644
--- a/include/experimental/filesystem
+++ b/include/experimental/filesystem
@@ -81,10 +81,10 @@
     path canonical(const path& p, const path& base, error_code& ec);
 
     void copy(const path& from, const path& to);
-    void copy(const path& from, const path& to, error_code& ec) _NOEXCEPT;
+    void copy(const path& from, const path& to, error_code& ec);
     void copy(const path& from, const path& to, copy_options options);
     void copy(const path& from, const path& to, copy_options options,
-                   error_code& ec) _NOEXCEPT;
+                   error_code& ec);
 
     bool copy_file(const path& from, const path& to);
     bool copy_file(const path& from, const path& to, error_code& ec) _NOEXCEPT;
@@ -972,7 +972,8 @@ public:
     _LIBCPP_INLINE_VISIBILITY path extension()      const { return string_type(__extension()); }
 
     // query
-    _LIBCPP_INLINE_VISIBILITY bool empty() const _NOEXCEPT { return __pn_.empty(); }
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY 
+    bool empty() const _NOEXCEPT { return __pn_.empty(); }
 
     _LIBCPP_INLINE_VISIBILITY bool has_root_name()      const { return !__root_name().empty(); }
     _LIBCPP_INLINE_VISIBILITY bool has_root_directory() const { return !__root_directory().empty(); }
@@ -1351,7 +1352,7 @@ void copy(const path& __from, const path& __to) {
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
-void copy(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT {
+void copy(const path& __from, const path& __to, error_code& __ec) {
     __copy(__from, __to, copy_options::none, &__ec);
 }
 
@@ -1362,7 +1363,7 @@ void copy(const path& __from, const path& __to, copy_options __opt) {
 
 inline _LIBCPP_INLINE_VISIBILITY
 void copy(const path& __from, const path& __to,
-          copy_options __opt, error_code& __ec) _NOEXCEPT {
+          copy_options __opt, error_code& __ec) {
     __copy(__from, __to, __opt, &__ec);
 }
 
@@ -1561,7 +1562,7 @@ bool is_empty(const path& __p) {
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
-bool is_empty(const path& __p, error_code& __ec) _NOEXCEPT {
+bool is_empty(const path& __p, error_code& __ec) {
     return __fs_is_empty(__p, &__ec);
 }
 
@@ -1903,12 +1904,12 @@ public:
         : directory_iterator(__p, nullptr, __opts)
     { }
 
-    directory_iterator(const path& __p, error_code& __ec) _NOEXCEPT
+    directory_iterator(const path& __p, error_code& __ec)
         : directory_iterator(__p, &__ec)
     { }
 
     directory_iterator(const path& __p, directory_options __opts,
-                       error_code& __ec) _NOEXCEPT
+                       error_code& __ec)
         : directory_iterator(__p, &__ec, __opts)
     { }
 
@@ -1943,7 +1944,7 @@ public:
         return __p;
     }
 
-    directory_iterator& increment(error_code& __ec) _NOEXCEPT
+    directory_iterator& increment(error_code& __ec)
     { return __increment(&__ec); }
 
 private:
@@ -2013,12 +2014,12 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY
     recursive_directory_iterator(const path& __p,
-        directory_options __xoptions, error_code& __ec) _NOEXCEPT
+        directory_options __xoptions, error_code& __ec)
         : recursive_directory_iterator(__p, __xoptions, &__ec)
     { }
 
     _LIBCPP_INLINE_VISIBILITY
-    recursive_directory_iterator(const path& __p, error_code& __ec) _NOEXCEPT
+    recursive_directory_iterator(const path& __p, error_code& __ec)
         : recursive_directory_iterator(__p, directory_options::none,  &__ec)
     { }
 
@@ -2060,7 +2061,7 @@ public:
     }
 
     _LIBCPP_INLINE_VISIBILITY
-    recursive_directory_iterator& increment(error_code& __ec) _NOEXCEPT
+    recursive_directory_iterator& increment(error_code& __ec)
     { return __increment(&__ec); }
 
     _LIBCPP_FUNC_VIS directory_options options() const;
diff --git a/include/experimental/iterator b/include/experimental/iterator
index 37186b3d0b30..ea672e966315 100644
--- a/include/experimental/iterator
+++ b/include/experimental/iterator
@@ -75,19 +75,19 @@ public:
     typedef void                                 reference;
 
     ostream_joiner(ostream_type& __os, _Delim&& __d)
-        : __output(_VSTD::addressof(__os)), __delim(_VSTD::move(__d)), __first(true) {}
+        : __output_iter(_VSTD::addressof(__os)), __delim(_VSTD::move(__d)), __first(true) {}
         
     ostream_joiner(ostream_type& __os, const _Delim& __d)
-        : __output(_VSTD::addressof(__os)), __delim(__d), __first(true) {}
+        : __output_iter(_VSTD::addressof(__os)), __delim(__d), __first(true) {}
     
 
     template<typename _Tp>
     ostream_joiner& operator=(const _Tp& __v)
     {
         if (!__first)
-            *__output << __delim;
+            *__output_iter << __delim;
         __first = false;
-        *__output << __v;
+        *__output_iter << __v;
         return *this;
     }
 
@@ -96,7 +96,7 @@ public:
     ostream_joiner& operator++(int) _NOEXCEPT { return *this; }
 
 private:
-    ostream_type*   __output;
+    ostream_type*   __output_iter;
     _Delim          __delim;
     bool            __first;
 };
diff --git a/include/forward_list b/include/forward_list
index 8bfa9a084338..7b8204137201 100644
--- a/include/forward_list
+++ b/include/forward_list
@@ -728,7 +728,7 @@ public:
     const_iterator cbefore_begin() const _NOEXCEPT
         {return const_iterator(base::__before_begin());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT
         {return base::__before_begin()->__next_ == nullptr;}
     _LIBCPP_INLINE_VISIBILITY
diff --git a/include/fstream b/include/fstream
index ffd569839bd4..f57908c8dfaf 100644
--- a/include/fstream
+++ b/include/fstream
@@ -315,7 +315,7 @@ basic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs)
         else
             this->setp((char_type*)__extbuf_,
                        (char_type*)__extbuf_ + (__rhs. epptr() - __rhs.pbase()));
-        this->pbump(__rhs. pptr() - __rhs.pbase());
+        this->__pbump(__rhs. pptr() - __rhs.pbase());
     }
     else if (__rhs.eback())
     {
@@ -434,7 +434,7 @@ basic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs)
         ptrdiff_t __e = this->epptr() - this->pbase();
         this->setp((char_type*)__extbuf_min_,
                    (char_type*)__extbuf_min_ + __e);
-        this->pbump(__n);
+        this->__pbump(__n);
     }
     if (__rhs.eback() == (char_type*)__extbuf_min_)
     {
@@ -450,7 +450,7 @@ basic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs)
         ptrdiff_t __e = __rhs.epptr() - __rhs.pbase();
         __rhs.setp((char_type*)__rhs.__extbuf_min_,
                    (char_type*)__rhs.__extbuf_min_ + __e);
-        __rhs.pbump(__n);
+        __rhs.__pbump(__n);
     }
 }
 
@@ -724,7 +724,7 @@ basic_filebuf<_CharT, _Traits>::overflow(int_type __c)
                     if (__r == codecvt_base::partial)
                     {
                         this->setp(const_cast<char_type*>(__e), this->pptr());
-                        this->pbump(this->epptr() - this->pbase());
+                        this->__pbump(this->epptr() - this->pbase());
                     }
                 }
                 else
diff --git a/include/future b/include/future
index e38876758e13..a7c28a4746cf 100644
--- a/include/future
+++ b/include/future
@@ -2335,6 +2335,7 @@ inline _LIBCPP_INLINE_VISIBILITY bool __does_policy_contain(launch __policy, lau
 { return (int(__policy) & int(__value)) != 0; }
 
 template <class _Fp, class... _Args>
+_LIBCPP_NODISCARD_AFTER_CXX17
 future<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type>
 async(launch __policy, _Fp&& __f, _Args&&... __args)
 {
@@ -2360,7 +2361,7 @@ async(launch __policy, _Fp&& __f, _Args&&... __args)
 }
 
 template <class _Fp, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY
 future<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type>
 async(_Fp&& __f, _Args&&... __args)
 {
diff --git a/include/istream b/include/istream
index 0b8e05d95bd8..5c73df38f650 100644
--- a/include/istream
+++ b/include/istream
@@ -1069,16 +1069,18 @@ basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_typ
                 this->rdbuf()->sbumpc();
                 ++__gc_;
             }
-            if (__n > 0)
-                *__s = char_type();
             if (__gc_ == 0)
                __err |= ios_base::failbit;
             this->setstate(__err);
         }
+        if (__n > 0)
+            *__s = char_type();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
+        if (__n > 0)
+            *__s = char_type();
         this->__set_badbit_and_consider_rethrow();
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
diff --git a/include/iterator b/include/iterator
index d163ab1b0910..8b887db037b9 100644
--- a/include/iterator
+++ b/include/iterator
@@ -37,16 +37,6 @@ struct iterator_traits<T*>
     typedef random_access_iterator_tag iterator_category;
 };
 
-template<class T>
-struct iterator_traits<const T*>
-{
-    typedef ptrdiff_t difference_type;
-    typedef T value_type;
-    typedef const T* pointer;
-    typedef const T& reference;
-    typedef random_access_iterator_tag iterator_category;
-};
-
 template<class Category, class T, class Distance = ptrdiff_t,
          class Pointer = T*, class Reference = T&>
 struct iterator
@@ -494,7 +484,7 @@ template<class _Tp>
 struct _LIBCPP_TEMPLATE_VIS iterator_traits<_Tp*>
 {
     typedef ptrdiff_t difference_type;
-    typedef typename remove_const<_Tp>::type value_type;
+    typedef typename remove_cv<_Tp>::type value_type;
     typedef _Tp* pointer;
     typedef _Tp& reference;
     typedef random_access_iterator_tag iterator_category;
@@ -604,21 +594,27 @@ distance(_InputIter __first, _InputIter __last)
 
 template <class _InputIter>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-_InputIter
+typename enable_if
+<
+    __is_input_iterator<_InputIter>::value, 
+    _InputIter
+>::type
 next(_InputIter __x,
-     typename iterator_traits<_InputIter>::difference_type __n = 1,
-     typename enable_if<__is_input_iterator<_InputIter>::value>::type* = 0)
+     typename iterator_traits<_InputIter>::difference_type __n = 1)
 {
     _VSTD::advance(__x, __n);
     return __x;
 }
 
-template <class _BidiretionalIter>
+template <class _BidirectionalIter>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-_BidiretionalIter
-prev(_BidiretionalIter __x,
-     typename iterator_traits<_BidiretionalIter>::difference_type __n = 1,
-     typename enable_if<__is_bidirectional_iterator<_BidiretionalIter>::value>::type* = 0)
+typename enable_if
+<
+    __is_bidirectional_iterator<_BidirectionalIter>::value, 
+    _BidirectionalIter
+>::type
+prev(_BidirectionalIter __x,
+     typename iterator_traits<_BidirectionalIter>::difference_type __n = 1)
 {
     _VSTD::advance(__x, -__n);
     return __x;
@@ -908,15 +904,37 @@ public:
     _LIBCPP_INLINE_VISIBILITY istream_iterator  operator++(int)
         {istream_iterator __t(*this); ++(*this); return __t;}
 
+    template <class _Up, class _CharU, class _TraitsU, class _DistanceU>
     friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const istream_iterator& __x, const istream_iterator& __y)
-        {return __x.__in_stream_ == __y.__in_stream_;}
+    bool
+    operator==(const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __x,
+               const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __y);
 
+    template <class _Up, class _CharU, class _TraitsU, class _DistanceU>
     friend _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const istream_iterator& __x, const istream_iterator& __y)
-        {return !(__x == __y);}
+    bool
+    operator==(const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __x,
+               const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __y);
 };
 
+template <class _Tp, class _CharT, class _Traits, class _Distance>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
+           const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y)
+{
+    return __x.__in_stream_ == __y.__in_stream_;
+}
+
+template <class _Tp, class _CharT, class _Traits, class _Distance>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
+           const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y)
+{
+    return !(__x == __y);
+}
+
 template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT> >
 class _LIBCPP_TEMPLATE_VIS ostream_iterator
     : public iterator<output_iterator_tag, void, void, void, void>
@@ -1794,31 +1812,67 @@ end(const _Cp& __c)
 #endif  // !defined(_LIBCPP_CXX03_LANG)
 
 #if _LIBCPP_STD_VER > 14
+
+// #if _LIBCPP_STD_VER > 11
+// template <>
+// struct _LIBCPP_TEMPLATE_VIS plus<void>
+// {
+//     template <class _T1, class _T2>
+//     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+//     auto operator()(_T1&& __t, _T2&& __u) const
+//     _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)))
+//     -> decltype        (_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u))
+//         { return        _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); }
+//     typedef void is_transparent;
+// };
+// #endif
+
 template <class _Cont>
-constexpr auto size(const _Cont& __c) -> decltype(__c.size()) { return __c.size(); }
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr auto size(const _Cont& __c)
+_NOEXCEPT_(noexcept(__c.size()))
+-> decltype        (__c.size())
+{ return            __c.size(); }
 
 template <class _Tp, size_t _Sz>
+inline _LIBCPP_INLINE_VISIBILITY
 constexpr size_t size(const _Tp (&)[_Sz]) noexcept { return _Sz; }
 
 template <class _Cont>
-constexpr auto empty(const _Cont& __c) -> decltype(__c.empty()) { return __c.empty(); }
+_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY
+constexpr auto empty(const _Cont& __c)
+_NOEXCEPT_(noexcept(__c.empty()))
+-> decltype        (__c.empty())
+{ return            __c.empty(); }
 
 template <class _Tp, size_t _Sz>
+_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY
 constexpr bool empty(const _Tp (&)[_Sz]) noexcept { return false; }
 
 template <class _Ep>
+_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY
 constexpr bool empty(initializer_list<_Ep> __il) noexcept { return __il.size() == 0; }
 
 template <class _Cont> constexpr
-auto data(_Cont& __c) -> decltype(__c.data()) { return __c.data(); }
+inline _LIBCPP_INLINE_VISIBILITY
+auto data(_Cont& __c)
+_NOEXCEPT_(noexcept(__c.data()))
+-> decltype        (__c.data())
+{ return            __c.data(); }
 
 template <class _Cont> constexpr
-auto data(const _Cont& __c) -> decltype(__c.data()) { return __c.data(); }
+inline _LIBCPP_INLINE_VISIBILITY
+auto data(const _Cont& __c)
+_NOEXCEPT_(noexcept(__c.data()))
+-> decltype        (__c.data()) 
+{ return            __c.data(); }
 
 template <class _Tp, size_t _Sz>
+inline _LIBCPP_INLINE_VISIBILITY
 constexpr _Tp* data(_Tp (&__array)[_Sz]) noexcept { return __array; }
 
 template <class _Ep>
+inline _LIBCPP_INLINE_VISIBILITY
 constexpr const _Ep* data(initializer_list<_Ep> __il) noexcept { return __il.begin(); }
 #endif
 
diff --git a/include/list b/include/list
index 9c70fff946c7..32e9a27bd2a4 100644
--- a/include/list
+++ b/include/list
@@ -481,7 +481,7 @@ public:
     {
 #if _LIBCPP_DEBUG_LEVEL >= 2
         _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
-                       "Attempted to dereference a non-dereferenceable list::iterator");
+                       "Attempted to dereference a non-dereferenceable list::const_iterator");
 #endif
         return pointer_traits<pointer>::pointer_to(__ptr_->__as_node()->__value_);
     }
@@ -896,7 +896,7 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT     {return base::__sz();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT         {return base::empty();}
     _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT
@@ -1071,6 +1071,16 @@ public:
 
     bool __invariants() const;
 
+    typedef __allocator_destructor<__node_allocator> __node_destructor;
+    typedef unique_ptr<__node, __node_destructor> __hold_pointer;
+
+    _LIBCPP_INLINE_VISIBILITY
+    __hold_pointer __allocate_node(__node_allocator& __na) {
+      __node_pointer __p = __node_alloc_traits::allocate(__na, 1);
+      __p->__prev_ = nullptr;
+      return __hold_pointer(__p, __node_destructor(__na, 1));
+    }
+
 #if _LIBCPP_DEBUG_LEVEL >= 2
 
     bool __dereferenceable(const const_iterator* __i) const;
@@ -1397,9 +1407,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, const value_type& __x)
         " referring to this list");
 #endif
     __node_allocator& __na = base::__node_alloc();
-    typedef __allocator_destructor<__node_allocator> _Dp;
-    unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
-    __hold->__prev_ = 0;
+    __hold_pointer __hold = __allocate_node(__na);
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
     __link_nodes(__p.__ptr_, __hold->__as_link(), __hold->__as_link());
     ++base::__sz();
@@ -1426,9 +1434,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& _
     {
         size_type __ds = 0;
         __node_allocator& __na = base::__node_alloc();
-        typedef __allocator_destructor<__node_allocator> _Dp;
-        unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
-        __hold->__prev_ = 0;
+        __hold_pointer __hold = __allocate_node(__na);
         __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
         ++__ds;
 #if _LIBCPP_DEBUG_LEVEL >= 2
@@ -1494,9 +1500,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
     {
         size_type __ds = 0;
         __node_allocator& __na = base::__node_alloc();
-        typedef __allocator_destructor<__node_allocator> _Dp;
-        unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
-        __hold->__prev_ = 0;
+        __hold_pointer __hold = __allocate_node(__na);
         __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f);
         ++__ds;
 #if _LIBCPP_DEBUG_LEVEL >= 2
@@ -1549,8 +1553,7 @@ void
 list<_Tp, _Alloc>::push_front(const value_type& __x)
 {
     __node_allocator& __na = base::__node_alloc();
-    typedef __allocator_destructor<__node_allocator> _Dp;
-    unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
+    __hold_pointer __hold = __allocate_node(__na);
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
     __link_pointer __nl = __hold->__as_link();
     __link_nodes_at_front(__nl, __nl);
@@ -1563,8 +1566,7 @@ void
 list<_Tp, _Alloc>::push_back(const value_type& __x)
 {
     __node_allocator& __na = base::__node_alloc();
-    typedef __allocator_destructor<__node_allocator> _Dp;
-    unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
+    __hold_pointer __hold = __allocate_node(__na);
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
     __link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link());
     ++base::__sz();
@@ -1578,8 +1580,7 @@ void
 list<_Tp, _Alloc>::push_front(value_type&& __x)
 {
     __node_allocator& __na = base::__node_alloc();
-    typedef __allocator_destructor<__node_allocator> _Dp;
-    unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
+    __hold_pointer __hold = __allocate_node(__na);
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
     __link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link());
     ++base::__sz();
@@ -1591,8 +1592,7 @@ void
 list<_Tp, _Alloc>::push_back(value_type&& __x)
 {
     __node_allocator& __na = base::__node_alloc();
-    typedef __allocator_destructor<__node_allocator> _Dp;
-    unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
+    __hold_pointer __hold = __allocate_node(__na);
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
     __link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link());
     ++base::__sz();
@@ -1609,8 +1609,7 @@ void
 list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
 {
     __node_allocator& __na = base::__node_alloc();
-    typedef __allocator_destructor<__node_allocator> _Dp;
-    unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
+    __hold_pointer __hold = __allocate_node(__na);
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
     __link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link());
     ++base::__sz();
@@ -1631,8 +1630,7 @@ void
 list<_Tp, _Alloc>::emplace_back(_Args&&... __args)
 {
     __node_allocator& __na = base::__node_alloc();
-    typedef __allocator_destructor<__node_allocator> _Dp;
-    unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
+    __hold_pointer __hold = __allocate_node(__na);
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
     __link_pointer __nl = __hold->__as_link();
     __link_nodes_at_back(__nl, __nl);
@@ -1655,9 +1653,7 @@ list<_Tp, _Alloc>::emplace(const_iterator __p, _Args&&... __args)
         " referring to this list");
 #endif
     __node_allocator& __na = base::__node_alloc();
-    typedef __allocator_destructor<__node_allocator> _Dp;
-    unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
-    __hold->__prev_ = 0;
+    __hold_pointer __hold = __allocate_node(__na);
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
     __link_pointer __nl = __hold.get()->__as_link();
     __link_nodes(__p.__ptr_, __nl, __nl);
@@ -1680,9 +1676,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, value_type&& __x)
         " referring to this list");
 #endif
     __node_allocator& __na = base::__node_alloc();
-    typedef __allocator_destructor<__node_allocator> _Dp;
-    unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
-    __hold->__prev_ = 0;
+    __hold_pointer __hold = __allocate_node(__na);
     __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
     __link_pointer __nl = __hold->__as_link();
     __link_nodes(__p.__ptr_, __nl, __nl);
@@ -1855,9 +1849,7 @@ list<_Tp, _Alloc>::resize(size_type __n)
         __n -= base::__sz();
         size_type __ds = 0;
         __node_allocator& __na = base::__node_alloc();
-        typedef __allocator_destructor<__node_allocator> _Dp;
-        unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
-        __hold->__prev_ = 0;
+        __hold_pointer __hold = __allocate_node(__na);
         __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_));
         ++__ds;
 #if _LIBCPP_DEBUG_LEVEL >= 2
@@ -1914,9 +1906,7 @@ list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
         __n -= base::__sz();
         size_type __ds = 0;
         __node_allocator& __na = base::__node_alloc();
-        typedef __allocator_destructor<__node_allocator> _Dp;
-        unique_ptr<__node, _Dp> __hold(__node_alloc_traits::allocate(__na, 1), _Dp(__na, 1));
-        __hold->__prev_ = 0;
+        __hold_pointer __hold = __allocate_node(__na);
         __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
         ++__ds;
         __link_pointer __nl = __hold.release()->__as_link();
diff --git a/include/locale b/include/locale
index d30d950c7f85..a86645d2cc4b 100644
--- a/include/locale
+++ b/include/locale
@@ -4110,7 +4110,7 @@ wbuffer_convert<_Codecvt, _Elem, _Tr>::overflow(int_type __c)
                     if (__r == codecvt_base::partial)
                     {
                         this->setp(const_cast<char_type *>(__e), this->pptr());
-                        this->pbump(this->epptr() - this->pbase());
+                        this->__pbump(this->epptr() - this->pbase());
                     }
                 }
                 else
diff --git a/include/map b/include/map
index 71f18693f6d1..952149389814 100644
--- a/include/map
+++ b/include/map
@@ -1012,7 +1012,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crend() const _NOEXCEPT {return rend();}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool      empty() const _NOEXCEPT {return __tree_.size() == 0;}
     _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT {return __tree_.size();}
@@ -1669,7 +1669,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crend() const _NOEXCEPT {return rend();}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
     _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT {return __tree_.size();}
diff --git a/include/memory b/include/memory
index 22706d029d5f..df221ffa7510 100644
--- a/include/memory
+++ b/include/memory
@@ -46,6 +46,9 @@ struct pointer_traits<T*>
     static pointer pointer_to(<details>) noexcept;
 };
 
+template <class T> constexpr T* to_address(T* p) noexcept; // C++20
+template <class Ptr> auto to_address(const Ptr& p) noexcept; // C++20
+
 template <class Alloc>
 struct allocator_traits
 {
@@ -81,8 +84,8 @@ struct allocator_traits
     template <class T> using rebind_alloc  = Alloc::rebind<U>::other | Alloc<T, Args...>;
     template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
 
-    static pointer allocate(allocator_type& a, size_type n);
-    static pointer allocate(allocator_type& a, size_type n, const_void_pointer hint);
+    static pointer allocate(allocator_type& a, size_type n);                          // [[nodiscard]] in C++20
+    static pointer allocate(allocator_type& a, size_type n, const_void_pointer hint); // [[nodiscard]] in C++20
 
     static void deallocate(allocator_type& a, pointer p, size_type n) noexcept;
 
@@ -384,6 +387,9 @@ template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args);
 template<class T>                unique_ptr<T> make_unique(size_t n);           // C++14
 template<class T, class... Args> unspecified   make_unique(Args&&...) = delete; // C++14, T == U[N]
 
+template<class E, class T, class Y, class D>
+    basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, unique_ptr<Y, D> const& p);
+
 template<class T>
 class shared_ptr
 {
@@ -724,7 +730,7 @@ template <class _Tp, class = void>
 struct __has_element_type : false_type {};
 
 template <class _Tp>
-struct __has_element_type<_Tp, 
+struct __has_element_type<_Tp,
               typename __void_t<typename _Tp::element_type>::type> : true_type {};
 
 template <class _Ptr, bool = __has_element_type<_Ptr>::value>
@@ -808,7 +814,7 @@ template <class _Tp, class = void>
 struct __has_difference_type : false_type {};
 
 template <class _Tp>
-struct __has_difference_type<_Tp, 
+struct __has_difference_type<_Tp,
             typename __void_t<typename _Tp::difference_type>::type> : true_type {};
 
 template <class _Ptr, bool = __has_difference_type<_Ptr>::value>
@@ -994,7 +1000,7 @@ template <class _Tp, class = void>
 struct __has_pointer_type : false_type {};
 
 template <class _Tp>
-struct __has_pointer_type<_Tp, 
+struct __has_pointer_type<_Tp,
           typename __void_t<typename _Tp::pointer>::type> : true_type {};
 
 namespace __pointer_type_imp
@@ -1024,7 +1030,7 @@ template <class _Tp, class = void>
 struct __has_const_pointer : false_type {};
 
 template <class _Tp>
-struct __has_const_pointer<_Tp, 
+struct __has_const_pointer<_Tp,
             typename __void_t<typename _Tp::const_pointer>::type> : true_type {};
 
 template <class _Tp, class _Ptr, class _Alloc, bool = __has_const_pointer<_Alloc>::value>
@@ -1047,7 +1053,7 @@ template <class _Tp, class = void>
 struct __has_void_pointer : false_type {};
 
 template <class _Tp>
-struct __has_void_pointer<_Tp, 
+struct __has_void_pointer<_Tp,
                typename __void_t<typename _Tp::void_pointer>::type> : true_type {};
 
 template <class _Ptr, class _Alloc, bool = __has_void_pointer<_Alloc>::value>
@@ -1070,7 +1076,7 @@ template <class _Tp, class = void>
 struct __has_const_void_pointer : false_type {};
 
 template <class _Tp>
-struct __has_const_void_pointer<_Tp, 
+struct __has_const_void_pointer<_Tp,
             typename __void_t<typename _Tp::const_void_pointer>::type> : true_type {};
 
 template <class _Ptr, class _Alloc, bool = __has_const_void_pointer<_Alloc>::value>
@@ -1090,13 +1096,14 @@ struct __const_void_pointer<_Ptr, _Alloc, false>
 };
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 _Tp*
 __to_raw_pointer(_Tp* __p) _NOEXCEPT
 {
     return __p;
 }
 
+#if _LIBCPP_STD_VER <= 17
 template <class _Pointer>
 inline _LIBCPP_INLINE_VISIBILITY
 typename pointer_traits<_Pointer>::element_type*
@@ -1104,6 +1111,41 @@ __to_raw_pointer(_Pointer __p) _NOEXCEPT
 {
     return _VSTD::__to_raw_pointer(__p.operator->());
 }
+#else
+template <class _Pointer>
+inline _LIBCPP_INLINE_VISIBILITY
+auto
+__to_raw_pointer(const _Pointer& __p) _NOEXCEPT
+-> decltype(pointer_traits<_Pointer>::to_address(__p))
+{
+    return pointer_traits<_Pointer>::to_address(__p);
+}
+
+template <class _Pointer, class... _None>
+inline _LIBCPP_INLINE_VISIBILITY
+auto
+__to_raw_pointer(const _Pointer& __p, _None...) _NOEXCEPT
+{
+    return _VSTD::__to_raw_pointer(__p.operator->());
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY constexpr
+_Tp*
+to_address(_Tp* __p) _NOEXCEPT
+{
+    static_assert(!is_function_v<_Tp>, "_Tp is a function type");
+    return __p;
+}
+
+template <class _Pointer>
+inline _LIBCPP_INLINE_VISIBILITY
+auto
+to_address(const _Pointer& __p) _NOEXCEPT
+{
+    return _VSTD::__to_raw_pointer(__p);
+}
+#endif
 
 template <class _Tp, class = void>
 struct __has_size_type : false_type {};
@@ -1148,7 +1190,7 @@ template <class _Tp, class = void>
 struct __has_propagate_on_container_move_assignment : false_type {};
 
 template <class _Tp>
-struct __has_propagate_on_container_move_assignment<_Tp, 
+struct __has_propagate_on_container_move_assignment<_Tp,
            typename __void_t<typename _Tp::propagate_on_container_move_assignment>::type>
                : true_type {};
 
@@ -1168,7 +1210,7 @@ template <class _Tp, class = void>
 struct __has_propagate_on_container_swap : false_type {};
 
 template <class _Tp>
-struct __has_propagate_on_container_swap<_Tp, 
+struct __has_propagate_on_container_swap<_Tp,
            typename __void_t<typename _Tp::propagate_on_container_swap>::type>
                : true_type {};
 
@@ -1188,7 +1230,7 @@ template <class _Tp, class = void>
 struct __has_is_always_equal : false_type {};
 
 template <class _Tp>
-struct __has_is_always_equal<_Tp, 
+struct __has_is_always_equal<_Tp,
            typename __void_t<typename _Tp::is_always_equal>::type>
                : true_type {};
 
@@ -1302,7 +1344,7 @@ struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1, _A2>, _Up, false>
 template <class _Alloc, class _SizeType, class _ConstVoidPtr>
 auto
 __has_allocate_hint_test(_Alloc&& __a, _SizeType&& __sz, _ConstVoidPtr&& __p)
-    -> decltype(__a.allocate(__sz, __p), true_type());
+    -> decltype((void)__a.allocate(__sz, __p), true_type());
 
 template <class _Alloc, class _SizeType, class _ConstVoidPtr>
 auto
@@ -1313,7 +1355,7 @@ template <class _Alloc, class _SizeType, class _ConstVoidPtr>
 struct __has_allocate_hint
     : integral_constant<bool,
         is_same<
-            decltype(__has_allocate_hint_test(declval<_Alloc>(),
+            decltype(_VSTD::__has_allocate_hint_test(declval<_Alloc>(),
                                           declval<_SizeType>(),
                                           declval<_ConstVoidPtr>())),
             true_type>::value>
@@ -1346,7 +1388,7 @@ template <class _Alloc, class _Pointer, class ..._Args>
 struct __has_construct
     : integral_constant<bool,
         is_same<
-            decltype(__has_construct_test(declval<_Alloc>(),
+            decltype(_VSTD::__has_construct_test(declval<_Alloc>(),
                                           declval<_Pointer>(),
                                           declval<_Args>()...)),
             true_type>::value>
@@ -1367,7 +1409,7 @@ template <class _Alloc, class _Pointer>
 struct __has_destroy
     : integral_constant<bool,
         is_same<
-            decltype(__has_destroy_test(declval<_Alloc>(),
+            decltype(_VSTD::__has_destroy_test(declval<_Alloc>(),
                                         declval<_Pointer>())),
             true_type>::value>
 {
@@ -1387,7 +1429,7 @@ template <class _Alloc>
 struct __has_max_size
     : integral_constant<bool,
         is_same<
-            decltype(__has_max_size_test(declval<_Alloc&>())),
+            decltype(_VSTD::__has_max_size_test(declval<_Alloc&>())),
             true_type>::value>
 {
 };
@@ -1406,7 +1448,7 @@ template <class _Alloc>
 struct __has_select_on_container_copy_construction
     : integral_constant<bool,
         is_same<
-            decltype(__has_select_on_container_copy_construction_test(declval<_Alloc&>())),
+            decltype(_VSTD::__has_select_on_container_copy_construction_test(declval<_Alloc&>())),
             true_type>::value>
 {
 };
@@ -1497,10 +1539,10 @@ struct _LIBCPP_TEMPLATE_VIS allocator_traits
         {typedef allocator_traits<typename rebind_alloc<_Tp>::other> other;};
 #endif  // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     static pointer allocate(allocator_type& __a, size_type __n)
         {return __a.allocate(__n);}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
         {return __allocate(__a, __n, __hint,
             __has_allocate_hint<allocator_type, size_type, const_void_pointer>());}
@@ -1688,10 +1730,10 @@ private:
             }
 
     _LIBCPP_INLINE_VISIBILITY
-    static size_type __max_size(true_type, const allocator_type& __a)
+    static size_type __max_size(true_type, const allocator_type& __a) _NOEXCEPT
             {return __a.max_size();}
     _LIBCPP_INLINE_VISIBILITY
-    static size_type __max_size(false_type, const allocator_type&)
+    static size_type __max_size(false_type, const allocator_type&) _NOEXCEPT
             {return numeric_limits<size_type>::max() / sizeof(value_type);}
 
     _LIBCPP_INLINE_VISIBILITY
@@ -1739,7 +1781,8 @@ public:
         {return _VSTD::addressof(__x);}
     _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT
         {return _VSTD::addressof(__x);}
-    _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY 
+    pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
         {
         if (__n > max_size())
             __throw_length_error("allocator<T>::allocate(size_t n)"
@@ -1941,7 +1984,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY raw_storage_iterator  operator++(int)
         {raw_storage_iterator __t(*this); ++__x_; return __t;}
 #if _LIBCPP_STD_VER >= 14
-    _LIBCPP_INLINE_VISIBILITY _OutputIterator base() const { return __x_; } 
+    _LIBCPP_INLINE_VISIBILITY _OutputIterator base() const { return __x_; }
 #endif
 };
 
@@ -2040,11 +2083,12 @@ struct __compressed_pair_elem {
   typedef const _Tp& const_reference;
 
 #ifndef _LIBCPP_CXX03_LANG
-  constexpr __compressed_pair_elem() : __value_() {}
+  _LIBCPP_INLINE_VISIBILITY constexpr __compressed_pair_elem() : __value_() {}
 
   template <class _Up, class = typename enable_if<
       !is_same<__compressed_pair_elem, typename decay<_Up>::type>::value
   >::type>
+  _LIBCPP_INLINE_VISIBILITY
   constexpr explicit
   __compressed_pair_elem(_Up&& __u)
       : __value_(_VSTD::forward<_Up>(__u)){};
@@ -2055,11 +2099,13 @@ struct __compressed_pair_elem {
                          __tuple_indices<_Indexes...>)
       : __value_(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {}
 #else
-  __compressed_pair_elem() : __value_() {}
+  _LIBCPP_INLINE_VISIBILITY __compressed_pair_elem() : __value_() {}
+  _LIBCPP_INLINE_VISIBILITY
   __compressed_pair_elem(_ParamT __p) : __value_(std::forward<_ParamT>(__p)) {}
 #endif
 
-  reference __get() _NOEXCEPT { return __value_; }
+  _LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return __value_; }
+  _LIBCPP_INLINE_VISIBILITY
   const_reference __get() const _NOEXCEPT { return __value_; }
 
 private:
@@ -2074,11 +2120,12 @@ struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp {
   typedef _Tp __value_type;
 
 #ifndef _LIBCPP_CXX03_LANG
-  constexpr __compressed_pair_elem() = default;
+  _LIBCPP_INLINE_VISIBILITY constexpr __compressed_pair_elem() = default;
 
   template <class _Up, class = typename enable_if<
         !is_same<__compressed_pair_elem, typename decay<_Up>::type>::value
   >::type>
+  _LIBCPP_INLINE_VISIBILITY
   constexpr explicit
   __compressed_pair_elem(_Up&& __u)
       : __value_type(_VSTD::forward<_Up>(__u)){};
@@ -2089,12 +2136,14 @@ struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp {
                          __tuple_indices<_Indexes...>)
       : __value_type(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {}
 #else
-  __compressed_pair_elem() : __value_type() {}
+  _LIBCPP_INLINE_VISIBILITY __compressed_pair_elem() : __value_type() {}
+  _LIBCPP_INLINE_VISIBILITY
   __compressed_pair_elem(_ParamT __p)
       : __value_type(std::forward<_ParamT>(__p)) {}
 #endif
 
-  reference __get() _NOEXCEPT { return *this; }
+  _LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return *this; }
+  _LIBCPP_INLINE_VISIBILITY
   const_reference __get() const _NOEXCEPT { return *this; }
 };
 
@@ -3850,7 +3899,7 @@ public:
         _LIBCPP_INLINE_VISIBILITY
         _Dp* __get_deleter() const _NOEXCEPT
             {return static_cast<_Dp*>(__cntrl_
-                    ? const_cast<void *>(__cntrl_->__get_deleter(typeid(_Dp))) 
+                    ? const_cast<void *>(__cntrl_->__get_deleter(typeid(_Dp)))
                       : nullptr);}
 #endif  // _LIBCPP_NO_RTTI
 
@@ -4216,6 +4265,7 @@ template<class ..._Args>
 shared_ptr<_Tp>
 shared_ptr<_Tp>::make_shared(_Args&& ...__args)
 {
+    static_assert( is_constructible<_Tp, _Args...>::value, "Can't construct object in make_shared" );
     typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk;
     typedef allocator<_CntrlBlk> _A2;
     typedef __allocator_destructor<_A2> _D2;
@@ -4234,6 +4284,7 @@ template<class _Alloc, class ..._Args>
 shared_ptr<_Tp>
 shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _Args&& ...__args)
 {
+    static_assert( is_constructible<_Tp, _Args...>::value, "Can't construct object in allocate_shared" );
     typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk;
     typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
     typedef __allocator_destructor<_A2> _D2;
@@ -4254,6 +4305,7 @@ template<class _Tp>
 shared_ptr<_Tp>
 shared_ptr<_Tp>::make_shared()
 {
+    static_assert((is_constructible<_Tp>::value), "Can't construct object in make_shared" );
     typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk;
     typedef allocator<_CntrlBlk> _Alloc2;
     typedef __allocator_destructor<_Alloc2> _D2;
@@ -4272,6 +4324,7 @@ template<class _A0>
 shared_ptr<_Tp>
 shared_ptr<_Tp>::make_shared(_A0& __a0)
 {
+    static_assert((is_constructible<_Tp, _A0>::value), "Can't construct object in make_shared" );
     typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk;
     typedef allocator<_CntrlBlk> _Alloc2;
     typedef __allocator_destructor<_Alloc2> _D2;
@@ -4290,6 +4343,7 @@ template<class _A0, class _A1>
 shared_ptr<_Tp>
 shared_ptr<_Tp>::make_shared(_A0& __a0, _A1& __a1)
 {
+    static_assert((is_constructible<_Tp, _A0, _A1>::value), "Can't construct object in make_shared" );
     typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk;
     typedef allocator<_CntrlBlk> _Alloc2;
     typedef __allocator_destructor<_Alloc2> _D2;
@@ -4308,6 +4362,7 @@ template<class _A0, class _A1, class _A2>
 shared_ptr<_Tp>
 shared_ptr<_Tp>::make_shared(_A0& __a0, _A1& __a1, _A2& __a2)
 {
+    static_assert((is_constructible<_Tp, _A0, _A1, _A2>::value), "Can't construct object in make_shared" );
     typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk;
     typedef allocator<_CntrlBlk> _Alloc2;
     typedef __allocator_destructor<_Alloc2> _D2;
@@ -4326,6 +4381,7 @@ template<class _Alloc>
 shared_ptr<_Tp>
 shared_ptr<_Tp>::allocate_shared(const _Alloc& __a)
 {
+    static_assert((is_constructible<_Tp>::value), "Can't construct object in allocate_shared" );
     typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk;
     typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _Alloc2;
     typedef __allocator_destructor<_Alloc2> _D2;
@@ -4345,6 +4401,7 @@ template<class _Alloc, class _A0>
 shared_ptr<_Tp>
 shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0)
 {
+    static_assert((is_constructible<_Tp, _A0>::value), "Can't construct object in allocate_shared" );
     typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk;
     typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _Alloc2;
     typedef __allocator_destructor<_Alloc2> _D2;
@@ -4364,6 +4421,7 @@ template<class _Alloc, class _A0, class _A1>
 shared_ptr<_Tp>
 shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1)
 {
+    static_assert((is_constructible<_Tp, _A0, _A1>::value), "Can't construct object in allocate_shared" );
     typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk;
     typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _Alloc2;
     typedef __allocator_destructor<_Alloc2> _D2;
@@ -4383,6 +4441,7 @@ template<class _Alloc, class _A0, class _A1, class _A2>
 shared_ptr<_Tp>
 shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2)
 {
+    static_assert((is_constructible<_Tp, _A0, _A1, _A2>::value), "Can't construct object in allocate_shared" );
     typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk;
     typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _Alloc2;
     typedef __allocator_destructor<_Alloc2> _D2;
@@ -4477,7 +4536,7 @@ inline
 typename enable_if
 <
     !is_array<_Yp>::value &&
-    is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, 
+    is_convertible<typename unique_ptr<_Yp, _Dp>::pointer,
                    typename shared_ptr<_Tp>::element_type*>::value,
     shared_ptr<_Tp>&
 >::type
@@ -4512,7 +4571,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     !is_array<_Yp>::value &&
-    is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, 
+    is_convertible<typename unique_ptr<_Yp, _Dp>::pointer,
                    typename shared_ptr<_Tp>::element_type*>::value,
     shared_ptr<_Tp>&
 >::type
@@ -5311,7 +5370,7 @@ atomic_load(const shared_ptr<_Tp>* __p)
     __m.unlock();
     return __q;
 }
-  
+
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
@@ -5352,7 +5411,7 @@ atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
     __m.unlock();
     return __r;
 }
-  
+
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
@@ -5484,7 +5543,7 @@ void __swap_allocator(_Alloc & __a1, _Alloc & __a2)
     _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
 #endif
 {
-    __swap_allocator(__a1, __a2, 
+    __swap_allocator(__a1, __a2,
       integral_constant<bool, _VSTD::allocator_traits<_Alloc>::propagate_on_container_swap::value>());
 }
 
@@ -5506,7 +5565,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void __swap_allocator(_Alloc &, _Alloc &, false_type) _NOEXCEPT {}
 
 template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> >
-struct __noexcept_move_assign_container : public integral_constant<bool, 
+struct __noexcept_move_assign_container : public integral_constant<bool,
     _Traits::propagate_on_container_move_assignment::value
 #if _LIBCPP_STD_VER > 14
         || _Traits::is_always_equal::value
@@ -5520,17 +5579,17 @@ struct __noexcept_move_assign_container : public integral_constant<bool,
 template <class _Tp, class _Alloc>
 struct __temp_value {
     typedef allocator_traits<_Alloc> _Traits;
-    
+
     typename aligned_storage<sizeof(_Tp), alignof(_Tp)>::type __v;
     _Alloc &__a;
 
     _Tp *__addr() { return reinterpret_cast<_Tp *>(addressof(__v)); }
     _Tp &   get() { return *__addr(); }
-        
+
     template<class... _Args>
     __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc)
     { _Traits::construct(__a, __addr(), _VSTD::forward<_Args>(__args)...); }
-    
+
     ~__temp_value() { _Traits::destroy(__a, __addr()); }
     };
 #endif
diff --git a/include/new b/include/new
index 34df2efee09e..4e527501b1e2 100644
--- a/include/new
+++ b/include/new
@@ -46,13 +46,15 @@ typedef void (*new_handler)();
 new_handler set_new_handler(new_handler new_p) noexcept;
 new_handler get_new_handler() noexcept;
 
+// 21.6.4, pointer optimization barrier
+template <class T> constexpr T* launder(T* p) noexcept; // C++17
 }  // std
 
-void* operator new(std::size_t size);                                   // replaceable
-void* operator new(std::size_t size, std::align_val_t alignment);       // replaceable, C++17
-void* operator new(std::size_t size, const std::nothrow_t&) noexcept;   // replaceable
+void* operator new(std::size_t size);                                   // replaceable, nodiscard in C++2a
+void* operator new(std::size_t size, std::align_val_t alignment);       // replaceable, C++17, nodiscard in C++2a
+void* operator new(std::size_t size, const std::nothrow_t&) noexcept;   // replaceable, nodiscard in C++2a
 void* operator new(std::size_t size, std::align_val_t alignment,
-                   const std::nothrow_t&) noexcept;                     // replaceable, C++17
+                   const std::nothrow_t&) noexcept;                     // replaceable, C++17, nodiscard in C++2a
 void  operator delete(void* ptr) noexcept;                              // replaceable
 void  operator delete(void* ptr, std::size_t size) noexcept;            // replaceable, C++14
 void  operator delete(void* ptr, std::align_val_t alignment) noexcept;  // replaceable, C++17
@@ -62,12 +64,12 @@ void  operator delete(void* ptr, const std::nothrow_t&) noexcept;       // repla
 void  operator delete(void* ptr, std:align_val_t alignment,
                       const std::nothrow_t&) noexcept;                  // replaceable, C++17
 
-void* operator new[](std::size_t size);                                 // replaceable
+void* operator new[](std::size_t size);                                 // replaceable, nodiscard in C++2a
 void* operator new[](std::size_t size,
-                     std::align_val_t alignment) noexcept;              // replaceable, C++17
-void* operator new[](std::size_t size, const std::nothrow_t&) noexcept; // replaceable
+                     std::align_val_t alignment) noexcept;              // replaceable, C++17, nodiscard in C++2a
+void* operator new[](std::size_t size, const std::nothrow_t&) noexcept; // replaceable, nodiscard in C++2a
 void* operator new[](std::size_t size, std::align_val_t alignment,
-                     const std::nothrow_t&) noexcept;                   // replaceable, C++17
+                     const std::nothrow_t&) noexcept;                   // replaceable, C++17, nodiscard in C++2a
 void  operator delete[](void* ptr) noexcept;                            // replaceable
 void  operator delete[](void* ptr, std::size_t size) noexcept;          // replaceable, C++14
 void  operator delete[](void* ptr,
@@ -78,8 +80,8 @@ void  operator delete[](void* ptr, const std::nothrow_t&) noexcept;     // repla
 void  operator delete[](void* ptr, std::align_val_t alignment,
                         const std::nothrow_t&) noexcept;                // replaceable, C++17
 
-void* operator new  (std::size_t size, void* ptr) noexcept;
-void* operator new[](std::size_t size, void* ptr) noexcept;
+void* operator new  (std::size_t size, void* ptr) noexcept;             // nodiscard in C++2a
+void* operator new[](std::size_t size, void* ptr) noexcept;             // nodiscard in C++2a
 void  operator delete  (void* ptr, void*) noexcept;
 void  operator delete[](void* ptr, void*) noexcept;
 
@@ -92,7 +94,7 @@ void  operator delete[](void* ptr, void*) noexcept;
 #include <cstdlib>
 #endif
 
-#if defined(_LIBCPP_ABI_MICROSOFT)
+#if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_NO_VCRUNTIME)
 #include <new.h>
 #endif
 
@@ -114,7 +116,7 @@ void  operator delete[](void* ptr, void*) noexcept;
 namespace std  // purposefully not using versioning namespace
 {
 
-#if !defined(_LIBCPP_ABI_MICROSOFT)
+#if !defined(_LIBCPP_ABI_MICROSOFT) || defined(_LIBCPP_NO_VCRUNTIME)
 struct _LIBCPP_TYPE_VIS nothrow_t {};
 extern _LIBCPP_FUNC_VIS const nothrow_t nothrow;
 
@@ -140,7 +142,7 @@ typedef void (*new_handler)();
 _LIBCPP_FUNC_VIS new_handler set_new_handler(new_handler) _NOEXCEPT;
 _LIBCPP_FUNC_VIS new_handler get_new_handler() _NOEXCEPT;
 
-#endif // !_LIBCPP_ABI_MICROSOFT
+#endif // !_LIBCPP_ABI_MICROSOFT || _LIBCPP_NO_VCRUNTIME
 
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_bad_alloc();  // not in C++ spec
 
@@ -174,18 +176,18 @@ enum align_val_t { __zero = 0, __max = (size_t)-1 };
 #define _THROW_BAD_ALLOC
 #endif
 
-#if !defined(_LIBCPP_ABI_MICROSOFT)
+#if !defined(_LIBCPP_ABI_MICROSOFT) || defined(_LIBCPP_NO_VCRUNTIME)
 
-_LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz) _THROW_BAD_ALLOC;
-_LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS;
+_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz) _THROW_BAD_ALLOC;
+_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS;
 _LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete(void* __p) _NOEXCEPT;
 _LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete(void* __p, const std::nothrow_t&) _NOEXCEPT;
 #ifndef _LIBCPP_HAS_NO_SIZED_DEALLOCATION
 _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE void  operator delete(void* __p, std::size_t __sz) _NOEXCEPT;
 #endif
 
-_LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new[](std::size_t __sz) _THROW_BAD_ALLOC;
-_LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new[](std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS;
+_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new[](std::size_t __sz) _THROW_BAD_ALLOC;
+_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new[](std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS;
 _LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete[](void* __p) _NOEXCEPT;
 _LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete[](void* __p, const std::nothrow_t&) _NOEXCEPT;
 #ifndef _LIBCPP_HAS_NO_SIZED_DEALLOCATION
@@ -193,16 +195,16 @@ _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE void  operato
 #endif
 
 #ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
-_LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz, std::align_val_t) _THROW_BAD_ALLOC;
-_LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz, std::align_val_t, const std::nothrow_t&) _NOEXCEPT _NOALIAS;
+_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz, std::align_val_t) _THROW_BAD_ALLOC;
+_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz, std::align_val_t, const std::nothrow_t&) _NOEXCEPT _NOALIAS;
 _LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete(void* __p, std::align_val_t) _NOEXCEPT;
 _LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete(void* __p, std::align_val_t, const std::nothrow_t&) _NOEXCEPT;
 #ifndef _LIBCPP_HAS_NO_SIZED_DEALLOCATION
 _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE void  operator delete(void* __p, std::size_t __sz, std::align_val_t) _NOEXCEPT;
 #endif
 
-_LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new[](std::size_t __sz, std::align_val_t) _THROW_BAD_ALLOC;
-_LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new[](std::size_t __sz, std::align_val_t, const std::nothrow_t&) _NOEXCEPT _NOALIAS;
+_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new[](std::size_t __sz, std::align_val_t) _THROW_BAD_ALLOC;
+_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new[](std::size_t __sz, std::align_val_t, const std::nothrow_t&) _NOEXCEPT _NOALIAS;
 _LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete[](void* __p, std::align_val_t) _NOEXCEPT;
 _LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete[](void* __p, std::align_val_t, const std::nothrow_t&) _NOEXCEPT;
 #ifndef _LIBCPP_HAS_NO_SIZED_DEALLOCATION
@@ -210,12 +212,12 @@ _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE void  operato
 #endif
 #endif
 
-inline _LIBCPP_INLINE_VISIBILITY void* operator new  (std::size_t, void* __p) _NOEXCEPT {return __p;}
-inline _LIBCPP_INLINE_VISIBILITY void* operator new[](std::size_t, void* __p) _NOEXCEPT {return __p;}
+_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY void* operator new  (std::size_t, void* __p) _NOEXCEPT {return __p;}
+_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY void* operator new[](std::size_t, void* __p) _NOEXCEPT {return __p;}
 inline _LIBCPP_INLINE_VISIBILITY void  operator delete  (void*, void*) _NOEXCEPT {}
 inline _LIBCPP_INLINE_VISIBILITY void  operator delete[](void*, void*) _NOEXCEPT {}
 
-#endif // !_LIBCPP_ABI_MICROSOFT
+#endif // !_LIBCPP_ABI_MICROSOFT || _LIBCPP_NO_VCRUNTIME
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
@@ -250,6 +252,29 @@ void __throw_bad_array_length()
 }
 #endif
 
+template <class _Tp>
+_LIBCPP_NODISCARD_AFTER_CXX17 inline 
+_LIBCPP_CONSTEXPR _Tp* __launder(_Tp* __p) _NOEXCEPT
+{
+    static_assert (!(is_function<_Tp>::value), "can't launder functions" );
+    static_assert (!(is_same<void, typename remove_cv<_Tp>::type>::value), "can't launder cv-void" );
+#ifdef _LIBCPP_COMPILER_HAS_BUILTIN_LAUNDER
+    return __builtin_launder(__p);
+#else
+    return __p;
+#endif
+}
+
+
+#if _LIBCPP_STD_VER > 14
+template <class _Tp>
+_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY
+constexpr _Tp* launder(_Tp* __p) noexcept
+{
+    return _VSTD::__launder(__p);
+}
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_NEW
diff --git a/include/optional b/include/optional
index 1fb953bab743..35a4d74c2e86 100644
--- a/include/optional
+++ b/include/optional
@@ -57,17 +57,17 @@ namespace std {
 
   // 23.6.8, comparison with T
   template <class T, class U> constexpr bool operator==(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator==(const U&, const optional<T>&);
+  template <class T, class U> constexpr bool operator==(const T&, const optional<U>&);
   template <class T, class U> constexpr bool operator!=(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator!=(const U&, const optional<T>&);
+  template <class T, class U> constexpr bool operator!=(const T&, const optional<U>&);
   template <class T, class U> constexpr bool operator<(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator<(const U&, const optional<T>&);
+  template <class T, class U> constexpr bool operator<(const T&, const optional<U>&);
   template <class T, class U> constexpr bool operator<=(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator<=(const U&, const optional<T>&);
+  template <class T, class U> constexpr bool operator<=(const T&, const optional<U>&);
   template <class T, class U> constexpr bool operator>(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator>(const U&, const optional<T>&);
+  template <class T, class U> constexpr bool operator>(const T&, const optional<U>&);
   template <class T, class U> constexpr bool operator>=(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator>=(const U&, const optional<T>&);
+  template <class T, class U> constexpr bool operator>=(const T&, const optional<U>&);
 
   // 23.6.9, specialized algorithms
   template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below );
diff --git a/include/ostream b/include/ostream
index 9bf8d3cdcfb5..f3250a7080dd 100644
--- a/include/ostream
+++ b/include/ostream
@@ -1071,6 +1071,20 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p)
     return __os << __p.get();
 }
 
+#ifndef _LIBCPP_HAS_NO_DECLTYPE
+template<class _CharT, class _Traits, class _Yp, class _Dp>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+    is_same<void, typename __void_t<decltype(declval<basic_ostream<_CharT, _Traits>&>() << declval<_Yp>())>::type>::value,
+    basic_ostream<_CharT, _Traits>&
+>::type
+operator<<(basic_ostream<_CharT, _Traits>& __os, unique_ptr<_Yp, _Dp> const& __p)
+{
+    return __os << __p.get();
+}
+#endif
+
 template <class _CharT, class _Traits, size_t _Size>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)
diff --git a/include/queue b/include/queue
index feaae8920463..670fbb722ee2 100644
--- a/include/queue
+++ b/include/queue
@@ -268,7 +268,7 @@ public:
 
 #endif  // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool      empty() const {return c.empty();}
     _LIBCPP_INLINE_VISIBILITY
     size_type size() const  {return c.size();}
@@ -490,7 +490,7 @@ public:
                                                          _Alloc>::value>::type* = 0);
 #endif  // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool            empty() const {return c.empty();}
     _LIBCPP_INLINE_VISIBILITY
     size_type       size() const  {return c.size();}
diff --git a/include/random b/include/random
index ba8a088dfcb1..9073a5285b1a 100644
--- a/include/random
+++ b/include/random
@@ -2308,6 +2308,7 @@ template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
 void
 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
     __t, __c, __l, __f>::seed(result_type __sd)
+    _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
 {   // __w >= 2
     __x_[0] = __sd & _Max;
     for (size_t __i = 1; __i < __n; ++__i)
diff --git a/include/regex b/include/regex
index 77ca648109b2..ff84b2738b78 100644
--- a/include/regex
+++ b/include/regex
@@ -773,6 +773,8 @@ _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 
+#define _LIBCPP_REGEX_COMPLEXITY_FACTOR 4096
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace regex_constants
@@ -2407,17 +2409,28 @@ __bracket_expression<_CharT, _Traits>::__exec(__state& __s) const
                 goto __exit;
             }
         }
-        if (!__neg_chars_.empty())
+        // set of "__found" chars =
+        //   union(complement(union(__neg_chars_, __neg_mask_)),
+        //         other cases...)
+        //
+        // __neg_chars_ and __neg_mask_'d better be handled together, as there
+        // are no short circuit opportunities.
+        //
+        // In addition, when __neg_mask_/__neg_chars_ is empty, they should be
+        // treated as all ones/all chars.
         {
-            for (size_t __i = 0; __i < __neg_chars_.size(); ++__i)
-            {
-                if (__ch == __neg_chars_[__i])
-                    goto __is_neg_char;
-            }
+          const bool __in_neg_mask = (__neg_mask_ == 0) ||
+              __traits_.isctype(__ch, __neg_mask_);
+          const bool __in_neg_chars =
+              __neg_chars_.empty() ||
+              std::find(__neg_chars_.begin(), __neg_chars_.end(), __ch) !=
+              __neg_chars_.end();
+          if (!(__in_neg_mask || __in_neg_chars))
+          {
             __found = true;
             goto __exit;
+          }
         }
-__is_neg_char:
         if (!__ranges_.empty())
         {
             string_type __s2 = __collate_ ?
@@ -2449,11 +2462,6 @@ __is_neg_char:
             __found = true;
             goto __exit;
         }
-        if (__neg_mask_ && !__traits_.isctype(__ch, __neg_mask_))
-        {
-            __found = true;
-            goto __exit;
-        }
     }
     else
         __found = __negate_;  // force reject
@@ -4056,6 +4064,8 @@ basic_regex<_CharT, _Traits>::__parse_DUP_COUNT(_ForwardIterator __first,
                  __first != __last && ( __val = __traits_.value(*__first, 10)) != -1;
                  ++__first)
             {
+                if (__c >= std::numeric_limits<int>::max() / 10)
+                    __throw_regex_error<regex_constants::error_badbrace>();
                 __c *= 10;
                 __c += __val;
             }
@@ -4317,8 +4327,12 @@ basic_regex<_CharT, _Traits>::__parse_decimal_escape(_ForwardIterator __first,
             unsigned __v = *__first - '0';
             for (++__first;
                     __first != __last && '0' <= *__first && *__first <= '9'; ++__first)
+                {
+                if (__v >= std::numeric_limits<unsigned>::max() / 10)
+                    __throw_regex_error<regex_constants::error_backref>();
                 __v = 10 * __v + *__first - '0';
-            if (__v > mark_count())
+                }
+            if (__v == 0 || __v > mark_count())
                 __throw_regex_error<regex_constants::error_backref>();
             __push_back_ref(__v);
         }
@@ -5226,11 +5240,11 @@ public:
 
     // size:
     _LIBCPP_INLINE_VISIBILITY
-    size_type size() const {return __matches_.size();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const {return __matches_.max_size();}
+    size_type size() const _NOEXCEPT {return __matches_.size();}
     _LIBCPP_INLINE_VISIBILITY
-    bool empty() const {return size() == 0;}
+    size_type max_size() const _NOEXCEPT {return __matches_.max_size();}
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
+    bool empty() const _NOEXCEPT {return size() == 0;}
 
     // element access:
     _LIBCPP_INLINE_VISIBILITY
@@ -5263,15 +5277,15 @@ public:
     // format:
     template <class _OutputIter>
         _OutputIter
-        format(_OutputIter __output, const char_type* __fmt_first,
+        format(_OutputIter __output_iter, const char_type* __fmt_first,
                const char_type* __fmt_last,
                regex_constants::match_flag_type __flags = regex_constants::format_default) const;
     template <class _OutputIter, class _ST, class _SA>
         _LIBCPP_INLINE_VISIBILITY
         _OutputIter
-        format(_OutputIter __output, const basic_string<char_type, _ST, _SA>& __fmt,
+        format(_OutputIter __output_iter, const basic_string<char_type, _ST, _SA>& __fmt,
                regex_constants::match_flag_type __flags = regex_constants::format_default) const
-            {return format(__output, __fmt.data(), __fmt.data() + __fmt.size(), __flags);}
+            {return format(__output_iter, __fmt.data(), __fmt.data() + __fmt.size(), __flags);}
     template <class _ST, class _SA>
         _LIBCPP_INLINE_VISIBILITY
         basic_string<char_type, _ST, _SA>
@@ -5383,7 +5397,7 @@ match_results<_BidirectionalIterator, _Allocator>::__init(unsigned __s,
 template <class _BidirectionalIterator, class _Allocator>
 template <class _OutputIter>
 _OutputIter
-match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __output,
+match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __output_iter,
         const char_type* __fmt_first, const char_type* __fmt_last,
         regex_constants::match_flag_type __flags) const
 {
@@ -5392,27 +5406,27 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __output,
         for (; __fmt_first != __fmt_last; ++__fmt_first)
         {
             if (*__fmt_first == '&')
-                __output = _VSTD::copy(__matches_[0].first, __matches_[0].second,
-                                   __output);
+                __output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second,
+                                   __output_iter);
             else if (*__fmt_first == '\\' && __fmt_first + 1 != __fmt_last)
             {
                 ++__fmt_first;
                 if ('0' <= *__fmt_first && *__fmt_first <= '9')
                 {
                     size_t __i = *__fmt_first - '0';
-                    __output = _VSTD::copy((*this)[__i].first,
-                                        (*this)[__i].second, __output);
+                    __output_iter = _VSTD::copy((*this)[__i].first,
+                                        (*this)[__i].second, __output_iter);
                 }
                 else
                 {
-                    *__output = *__fmt_first;
-                    ++__output;
+                    *__output_iter = *__fmt_first;
+                    ++__output_iter;
                 }
             }
             else
             {
-                *__output = *__fmt_first;
-                ++__output;
+                *__output_iter = *__fmt_first;
+                ++__output_iter;
             }
         }
     }
@@ -5425,52 +5439,54 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __output,
                 switch (__fmt_first[1])
                 {
                 case '$':
-                    *__output = *++__fmt_first;
-                    ++__output;
+                    *__output_iter = *++__fmt_first;
+                    ++__output_iter;
                     break;
                 case '&':
                     ++__fmt_first;
-                    __output = _VSTD::copy(__matches_[0].first, __matches_[0].second,
-                                       __output);
+                    __output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second,
+                                       __output_iter);
                     break;
                 case '`':
                     ++__fmt_first;
-                    __output = _VSTD::copy(__prefix_.first, __prefix_.second, __output);
+                    __output_iter = _VSTD::copy(__prefix_.first, __prefix_.second, __output_iter);
                     break;
                 case '\'':
                     ++__fmt_first;
-                    __output = _VSTD::copy(__suffix_.first, __suffix_.second, __output);
+                    __output_iter = _VSTD::copy(__suffix_.first, __suffix_.second, __output_iter);
                     break;
                 default:
                     if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9')
                     {
                         ++__fmt_first;
-                        size_t __i = *__fmt_first - '0';
+                        size_t __idx = *__fmt_first - '0';
                         if (__fmt_first + 1 != __fmt_last &&
                             '0' <= __fmt_first[1] && __fmt_first[1] <= '9')
                         {
                             ++__fmt_first;
-                            __i = 10 * __i + *__fmt_first - '0';
+                            if (__idx >= std::numeric_limits<size_t>::max() / 10)
+                                __throw_regex_error<regex_constants::error_escape>();
+                            __idx = 10 * __idx + *__fmt_first - '0';
                         }
-                        __output = _VSTD::copy((*this)[__i].first,
-                                            (*this)[__i].second, __output);
+                        __output_iter = _VSTD::copy((*this)[__idx].first,
+                                            (*this)[__idx].second, __output_iter);
                     }
                     else
                     {
-                        *__output = *__fmt_first;
-                        ++__output;
+                        *__output_iter = *__fmt_first;
+                        ++__output_iter;
                     }
                     break;
                 }
             }
             else
             {
-                *__output = *__fmt_first;
-                ++__output;
+                *__output_iter = *__fmt_first;
+                ++__output_iter;
             }
         }
     }
-    return __output;
+    return __output_iter;
 }
 
 template <class _BidirectionalIterator, class _Allocator>
@@ -5552,8 +5568,14 @@ basic_regex<_CharT, _Traits>::__match_at_start_ecma(
         __states.back().__node_ = __st;
         __states.back().__flags_ = __flags;
         __states.back().__at_first_ = __at_first;
+        int __counter = 0;
+        int __length = __last - __first;
         do
         {
+            ++__counter;
+            if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
+                __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
+              __throw_regex_error<regex_constants::error_complexity>();
             __state& __s = __states.back();
             if (__s.__node_)
                 __s.__node_->__exec(__s);
@@ -5627,8 +5649,14 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
         __states.back().__flags_ = __flags;
         __states.back().__at_first_ = __at_first;
         bool __matched = false;
+        int __counter = 0;
+        int __length = __last - __first;
         do
         {
+            ++__counter;
+            if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
+                __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
+              __throw_regex_error<regex_constants::error_complexity>();
             __state& __s = __states.back();
             if (__s.__node_)
                 __s.__node_->__exec(__s);
@@ -5724,8 +5752,14 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
         __states.back().__at_first_ = __at_first;
         const _CharT* __current = __first;
         bool __matched = false;
+        int __counter = 0;
+        int __length = __last - __first;
         do
         {
+            ++__counter;
+            if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
+                __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
+              __throw_regex_error<regex_constants::error_complexity>();
             __state& __s = __states.back();
             if (__s.__node_)
                 __s.__node_->__exec(__s);
@@ -6460,7 +6494,7 @@ typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
 template <class _OutputIterator, class _BidirectionalIterator,
           class _Traits, class _CharT>
 _OutputIterator
-regex_replace(_OutputIterator __output,
+regex_replace(_OutputIterator __output_iter,
               _BidirectionalIterator __first, _BidirectionalIterator __last,
               const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
@@ -6471,7 +6505,7 @@ regex_replace(_OutputIterator __output,
     if (__i == __eof)
     {
         if (!(__flags & regex_constants::format_no_copy))
-            __output = _VSTD::copy(__first, __last, __output);
+            __output_iter = _VSTD::copy(__first, __last, __output_iter);
     }
     else
     {
@@ -6479,29 +6513,29 @@ regex_replace(_OutputIterator __output,
         for (size_t __len = char_traits<_CharT>::length(__fmt); __i != __eof; ++__i)
         {
             if (!(__flags & regex_constants::format_no_copy))
-                __output = _VSTD::copy(__i->prefix().first, __i->prefix().second, __output);
-            __output = __i->format(__output, __fmt, __fmt + __len, __flags);
+                __output_iter = _VSTD::copy(__i->prefix().first, __i->prefix().second, __output_iter);
+            __output_iter = __i->format(__output_iter, __fmt, __fmt + __len, __flags);
             __lm = __i->suffix();
             if (__flags & regex_constants::format_first_only)
                 break;
         }
         if (!(__flags & regex_constants::format_no_copy))
-            __output = _VSTD::copy(__lm.first, __lm.second, __output);
+            __output_iter = _VSTD::copy(__lm.first, __lm.second, __output_iter);
     }
-    return __output;
+    return __output_iter;
 }
 
 template <class _OutputIterator, class _BidirectionalIterator,
           class _Traits, class _CharT, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
-regex_replace(_OutputIterator __output,
+regex_replace(_OutputIterator __output_iter,
               _BidirectionalIterator __first, _BidirectionalIterator __last,
               const basic_regex<_CharT, _Traits>& __e,
               const basic_string<_CharT, _ST, _SA>& __fmt,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
-    return _VSTD::regex_replace(__output, __first, __last, __e, __fmt.c_str(), __flags);
+    return _VSTD::regex_replace(__output_iter, __first, __last, __e, __fmt.c_str(), __flags);
 }
 
 template <class _Traits, class _CharT, class _ST, class _SA, class _FST,
diff --git a/include/scoped_allocator b/include/scoped_allocator
index d60ae94f14e1..4760d946def7 100644
--- a/include/scoped_allocator
+++ b/include/scoped_allocator
@@ -68,8 +68,8 @@ public:
     outer_allocator_type& outer_allocator() noexcept;
     const outer_allocator_type& outer_allocator() const noexcept;
 
-    pointer allocate(size_type n);
-    pointer allocate(size_type n, const_void_pointer hint);
+    pointer allocate(size_type n);                           // [[nodiscard]] in C++20
+    pointer allocate(size_type n, const_void_pointer hint);  // [[nodiscard]] in C++20
     void deallocate(pointer p, size_type n) noexcept;
 
     size_type max_size() const;
@@ -477,11 +477,11 @@ public:
     const outer_allocator_type& outer_allocator() const _NOEXCEPT
         {return base::outer_allocator();}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     pointer allocate(size_type __n)
         {return allocator_traits<outer_allocator_type>::
             allocate(outer_allocator(), __n);}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     pointer allocate(size_type __n, const_void_pointer __hint)
         {return allocator_traits<outer_allocator_type>::
             allocate(outer_allocator(), __n, __hint);}
diff --git a/include/set b/include/set
index 30f2fa88f256..b4c6b2ef8c53 100644
--- a/include/set
+++ b/include/set
@@ -575,7 +575,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crend() const _NOEXCEPT {return rend();}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
     _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT {return __tree_.size();}
@@ -984,7 +984,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     const_reverse_iterator crend() const _NOEXCEPT {return rend();}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
     _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT {return __tree_.size();}
diff --git a/include/sstream b/include/sstream
index fe65fd7db53d..34b0014c14ad 100644
--- a/include/sstream
+++ b/include/sstream
@@ -243,7 +243,6 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(ios_base::openmode
     : __hm_(0),
       __mode_(__wch)
 {
-    str(string_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -289,7 +288,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(basic_stringbuf&&
     if (__bout != -1)
     {
         this->setp(__p + __bout, __p + __eout);
-        this->pbump(__nout);
+        this->__pbump(__nout);
     }
     __hm_ = __hm == -1 ? nullptr : __p + __hm;
     __p = const_cast<char_type*>(__rhs.__str_.data());
@@ -332,7 +331,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::operator=(basic_stringbuf&& __rhs)
     if (__bout != -1)
     {
         this->setp(__p + __bout, __p + __eout);
-        this->pbump(__nout);
+        this->__pbump(__nout);
     }
     else
         this->setp(nullptr, nullptr);
@@ -403,7 +402,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::swap(basic_stringbuf& __rhs)
     if (__rbout != -1)
     {
         this->setp(__p + __rbout, __p + __reout);
-        this->pbump(__rnout);
+        this->__pbump(__rnout);
     }
     else
         this->setp(nullptr, nullptr);
@@ -416,7 +415,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::swap(basic_stringbuf& __rhs)
     if (__lbout != -1)
     {
         __rhs.setp(__p + __lbout, __p + __leout);
-        __rhs.pbump(__lnout);
+        __rhs.__pbump(__lnout);
     }
     else
         __rhs.setp(nullptr, nullptr);
@@ -471,7 +470,15 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::str(const string_type& __s)
         this->setp(const_cast<char_type*>(__str_.data()),
                    const_cast<char_type*>(__str_.data()) + __str_.size());
         if (__mode_ & (ios_base::app | ios_base::ate))
-            this->pbump(__sz);
+        {
+            while (__sz > INT_MAX)
+            {
+            	this->pbump(INT_MAX);
+            	__sz -= INT_MAX;
+            }
+            if (__sz > 0)
+            	this->pbump(__sz);
+    	}
     }
 }
 
@@ -536,7 +543,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::overflow(int_type __c)
                 __str_.resize(__str_.capacity());
                 char_type* __p = const_cast<char_type*>(__str_.data());
                 this->setp(__p, __p + __str_.size());
-                this->pbump(__nout);
+                this->__pbump(__nout);
                 __hm_ = this->pbase() + __hm;
 #ifndef _LIBCPP_NO_EXCEPTIONS
             }
diff --git a/include/stack b/include/stack
index b2d4e2395017..0cb4c6ca925e 100644
--- a/include/stack
+++ b/include/stack
@@ -181,7 +181,7 @@ public:
             : c(_VSTD::move(__s.c), __a) {}
 #endif  // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool empty()     const      {return c.empty();}
     _LIBCPP_INLINE_VISIBILITY
     size_type size() const      {return c.size();}
diff --git a/include/streambuf b/include/streambuf
index a10ce1bf5636..ea64f5780459 100644
--- a/include/streambuf
+++ b/include/streambuf
@@ -255,6 +255,9 @@ protected:
     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
     void pbump(int __n) { __nout_ += __n; }
 
+    _LIBCPP_ALWAYS_INLINE
+    void __pbump(streamsize __n) { __nout_ += __n; }
+
     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
     void setp(char_type* __pbeg, char_type* __pend) {
         __bout_ = __nout_ = __pbeg;
@@ -404,7 +407,8 @@ basic_streambuf<_CharT, _Traits>::xsgetn(char_type* __s, streamsize __n)
     {
         if (__ninp_ < __einp_)
         {
-            const streamsize __len = _VSTD::min(__einp_ - __ninp_, __n - __i);
+            const streamsize __len = _VSTD::min(static_cast<streamsize>(INT_MAX),
+                                _VSTD::min(__einp_ - __ninp_, __n - __i));
             traits_type::copy(__s, __ninp_, __len);
             __s +=  __len;
             __i +=  __len;
diff --git a/include/string b/include/string
index 7775587a42d9..f5d548965aae 100644
--- a/include/string
+++ b/include/string
@@ -301,6 +301,13 @@ public:
     int compare(size_type pos1, size_type n1, const value_type* s) const;
     int compare(size_type pos1, size_type n1, const value_type* s, size_type n2) const;
 
+    bool starts_with(basic_string_view<charT, traits> sv) const noexcept; // C++2a
+    bool starts_with(charT c) const noexcept;                             // C++2a
+    bool starts_with(const charT* s) const;                               // C++2a
+    bool ends_with(basic_string_view<charT, traits> sv) const noexcept;   // C++2a
+    bool ends_with(charT c) const noexcept;                               // C++2a
+    bool ends_with(const charT* s) const;                                 // C++2a
+
     bool __invariants() const;
 };
 
@@ -608,7 +615,7 @@ struct __libcpp_string_gets_noexcept_iterator
 
 template <class _CharT, class _Traits, class _Tp>
 struct __can_be_converted_to_string_view : public _LIBCPP_BOOL_CONSTANT(
-	( is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value &&
+    ( is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value &&
      !is_convertible<const _Tp&, const _CharT*>::value)) {};
 
 #ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
@@ -670,7 +677,7 @@ private:
         size_type __cap_;
     };
 
-#if _LIBCPP_BIG_ENDIAN
+#ifdef _LIBCPP_BIG_ENDIAN
     static const size_type __short_mask = 0x01;
     static const size_type __long_mask  = 0x1ul;
 #else  // _LIBCPP_BIG_ENDIAN
@@ -700,7 +707,7 @@ private:
         pointer   __data_;
     };
 
-#if _LIBCPP_BIG_ENDIAN
+#ifdef _LIBCPP_BIG_ENDIAN
     static const size_type __short_mask = 0x80;
     static const size_type __long_mask  = ~(size_type(~0) >> 1);
 #else  // _LIBCPP_BIG_ENDIAN
@@ -901,7 +908,8 @@ public:
     void shrink_to_fit() _NOEXCEPT {reserve();}
     _LIBCPP_INLINE_VISIBILITY
     void clear() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY bool empty() const _NOEXCEPT {return size() == 0;}
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
+    bool empty() const _NOEXCEPT {return size() == 0;}
 
     _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __pos) const _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY reference       operator[](size_type __pos)       _NOEXCEPT;
@@ -1127,7 +1135,7 @@ public:
     const value_type* c_str() const _NOEXCEPT {return data();}
     _LIBCPP_INLINE_VISIBILITY
     const value_type* data() const _NOEXCEPT  {return _VSTD::__to_raw_pointer(__get_pointer());}
-#if _LIBCPP_STD_VER > 14
+#if _LIBCPP_STD_VER > 14 || defined(_LIBCPP_BUILDING_LIBRARY)
     _LIBCPP_INLINE_VISIBILITY
     value_type* data()             _NOEXCEPT  {return _VSTD::__to_raw_pointer(__get_pointer());}
 #endif
@@ -1214,6 +1222,32 @@ public:
     int compare(size_type __pos1, size_type __n1, const value_type* __s) const;
     int compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const;
 
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool starts_with(__self_view __sv) const _NOEXCEPT
+    { return __self_view(data(), size()).starts_with(__sv); }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool starts_with(value_type __c) const _NOEXCEPT
+    { return !empty() && _Traits::eq(front(), __c); }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool starts_with(const value_type* __s) const _NOEXCEPT
+    { return starts_with(__self_view(__s)); }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool ends_with(__self_view __sv) const _NOEXCEPT
+    { return __self_view(data(), size()).ends_with( __sv); }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool ends_with(value_type __c) const _NOEXCEPT
+    { return !empty() && _Traits::eq(back(), __c); }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool ends_with(const value_type* __s) const _NOEXCEPT
+    { return ends_with(__self_view(__s)); }
+#endif
+
     _LIBCPP_INLINE_VISIBILITY bool __invariants() const;
 
     _LIBCPP_INLINE_VISIBILITY
@@ -1241,7 +1275,7 @@ private:
 
     _LIBCPP_INLINE_VISIBILITY
     void __set_short_size(size_type __s) _NOEXCEPT
-#   if _LIBCPP_BIG_ENDIAN
+#   ifdef _LIBCPP_BIG_ENDIAN
         {__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
 #   else
         {__r_.first().__s.__size_ = (unsigned char)(__s);}
@@ -1249,7 +1283,7 @@ private:
 
     _LIBCPP_INLINE_VISIBILITY
     size_type __get_short_size() const _NOEXCEPT
-#   if _LIBCPP_BIG_ENDIAN
+#   ifdef _LIBCPP_BIG_ENDIAN
         {return __r_.first().__s.__size_ >> 1;}
 #   else
         {return __r_.first().__s.__size_;}
@@ -1259,7 +1293,7 @@ private:
 
     _LIBCPP_INLINE_VISIBILITY
     void __set_short_size(size_type __s) _NOEXCEPT
-#   if _LIBCPP_BIG_ENDIAN
+#   ifdef _LIBCPP_BIG_ENDIAN
         {__r_.first().__s.__size_ = (unsigned char)(__s);}
 #   else
         {__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
@@ -1267,7 +1301,7 @@ private:
 
     _LIBCPP_INLINE_VISIBILITY
     size_type __get_short_size() const _NOEXCEPT
-#   if _LIBCPP_BIG_ENDIAN
+#   ifdef _LIBCPP_BIG_ENDIAN
         {return __r_.first().__s.__size_;}
 #   else
         {return __r_.first().__s.__size_ >> 1;}
@@ -1756,10 +1790,10 @@ template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(
              const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a,
-			 typename enable_if<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, void>::type *)
+             typename enable_if<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, void>::type *)
     : __r_(__second_tag(), __a)
 {
-	__self_view __sv = __self_view(__t).substr(__pos, __n);
+    __self_view __sv = __self_view(__t).substr(__pos, __n);
     __init(__sv.data(), __sv.size());
 #if _LIBCPP_DEBUG_LEVEL >= 2
     __get_db()->__insert_c(this);
@@ -2145,7 +2179,7 @@ template <class _Tp>
 typename enable_if
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
-	basic_string<_CharT, _Traits, _Allocator>&
+    basic_string<_CharT, _Traits, _Allocator>&
 >::type
 basic_string<_CharT, _Traits, _Allocator>::assign(const _Tp & __t, size_type __pos, size_type __n)
 {
@@ -2493,7 +2527,7 @@ template <class _Tp>
 typename enable_if
 <
     __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
-	basic_string<_CharT, _Traits, _Allocator>&
+    basic_string<_CharT, _Traits, _Allocator>&
 >::type
 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const _Tp& __t,
                                                   size_type __pos2, size_type __n)
@@ -2682,8 +2716,8 @@ template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
 typename enable_if
 <
-	__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
-	basic_string<_CharT, _Traits, _Allocator>&
+    __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
+    basic_string<_CharT, _Traits, _Allocator>&
 >::type
 basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const _Tp& __t,
                                                    size_type __pos2, size_type __n2)
@@ -2870,7 +2904,7 @@ typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::max_size() const _NOEXCEPT
 {
     size_type __m = __alloc_traits::max_size(__alloc());
-#if _LIBCPP_BIG_ENDIAN
+#ifdef _LIBCPP_BIG_ENDIAN
     return (__m <= ~__long_mask ? __m : __m/2) - __alignment;
 #else
     return __m - __alignment;
@@ -3462,8 +3496,8 @@ template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp>
 typename enable_if
 <
-	__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
-	int
+    __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
+    int
 >::type
 basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
                                                    size_type __n1,
diff --git a/include/string_view b/include/string_view
index 4c759ab5daea..4d8358288f0c 100644
--- a/include/string_view
+++ b/include/string_view
@@ -143,6 +143,13 @@ namespace std {
       constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
       constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;
 
+      constexpr bool starts_with(basic_string_view s) const noexcept; // C++2a
+      constexpr bool starts_with(charT c) const noexcept;             // C++2a
+      constexpr bool starts_with(const charT* s) const;               // C++2a
+      constexpr bool ends_with(basic_string_view s) const noexcept;   // C++2a
+      constexpr bool ends_with(charT c) const noexcept;               // C++2a
+      constexpr bool ends_with(const charT* s) const;                 // C++2a
+
      private:
       const_pointer data_;  // exposition only
       size_type     size_;  // exposition only
@@ -155,10 +162,10 @@ namespace std {
   template <> struct hash<u32string_view>;
   template <> struct hash<wstring_view>;
 
-  constexpr basic_string<char>     operator "" s( const char *str,     size_t len ); // C++17
-  constexpr basic_string<wchar_t>  operator "" s( const wchar_t *str,  size_t len ); // C++17
-  constexpr basic_string<char16_t> operator "" s( const char16_t *str, size_t len ); // C++17
-  constexpr basic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++17
+  constexpr basic_string_view<char>     operator "" sv( const char *str,     size_t len ) noexcept;
+  constexpr basic_string_view<wchar_t>  operator "" sv( const wchar_t *str,  size_t len ) noexcept;
+  constexpr basic_string_view<char16_t> operator "" sv( const char16_t *str, size_t len ) noexcept;
+  constexpr basic_string_view<char32_t> operator "" sv( const char32_t *str, size_t len ) noexcept;
 
 }  // namespace std
 
@@ -186,388 +193,414 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template<class _CharT, class _Traits = char_traits<_CharT> >
 class _LIBCPP_TEMPLATE_VIS basic_string_view {
 public:
-	// types
-	typedef _Traits                                    traits_type;
-	typedef _CharT                                     value_type;
-	typedef const _CharT*                              pointer;
-	typedef const _CharT*                              const_pointer;
-	typedef const _CharT&                              reference;
-	typedef const _CharT&                              const_reference;
-	typedef const_pointer                              const_iterator; // See [string.view.iterators]
-	typedef const_iterator                             iterator;
-	typedef _VSTD::reverse_iterator<const_iterator>    const_reverse_iterator;
-	typedef const_reverse_iterator                     reverse_iterator;
-	typedef size_t                                     size_type;
-	typedef ptrdiff_t                                  difference_type;
-	static _LIBCPP_CONSTEXPR const size_type npos = -1; // size_type(-1);
+    // types
+    typedef _Traits                                    traits_type;
+    typedef _CharT                                     value_type;
+    typedef const _CharT*                              pointer;
+    typedef const _CharT*                              const_pointer;
+    typedef const _CharT&                              reference;
+    typedef const _CharT&                              const_reference;
+    typedef const_pointer                              const_iterator; // See [string.view.iterators]
+    typedef const_iterator                             iterator;
+    typedef _VSTD::reverse_iterator<const_iterator>    const_reverse_iterator;
+    typedef const_reverse_iterator                     reverse_iterator;
+    typedef size_t                                     size_type;
+    typedef ptrdiff_t                                  difference_type;
+    static _LIBCPP_CONSTEXPR const size_type npos = -1; // size_type(-1);
 
     static_assert(is_pod<value_type>::value, "Character type of basic_string_view must be a POD");
     static_assert((is_same<_CharT, typename traits_type::char_type>::value),
                   "traits_type::char_type must be the same type as CharT");
 
-	// [string.view.cons], construct/copy
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	basic_string_view() _NOEXCEPT : __data (nullptr), __size(0) {}
+    // [string.view.cons], construct/copy
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    basic_string_view() _NOEXCEPT : __data (nullptr), __size(0) {}
 
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	basic_string_view(const basic_string_view&) _NOEXCEPT = default;
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    basic_string_view(const basic_string_view&) _NOEXCEPT = default;
 
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	basic_string_view& operator=(const basic_string_view&) _NOEXCEPT = default;
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    basic_string_view& operator=(const basic_string_view&) _NOEXCEPT = default;
 
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	basic_string_view(const _CharT* __s, size_type __len)
-		: __data(__s), __size(__len)
-	{
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    basic_string_view(const _CharT* __s, size_type __len) _NOEXCEPT
+        : __data(__s), __size(__len)
+    {
 // #if _LIBCPP_STD_VER > 11
 //         _LIBCPP_ASSERT(__len == 0 || __s != nullptr, "string_view::string_view(_CharT *, size_t): received nullptr");
 // #endif
-	}
-
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	basic_string_view(const _CharT* __s)
-		: __data(__s), __size(_Traits::length(__s)) {}
-
-	// [string.view.iterators], iterators
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	const_iterator begin()  const _NOEXCEPT { return cbegin(); }
-
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	const_iterator end()    const _NOEXCEPT { return cend(); }
-
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	const_iterator cbegin() const _NOEXCEPT { return __data; }
-
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	const_iterator cend()   const _NOEXCEPT { return __data + __size; }
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY
-	const_reverse_iterator rbegin()   const _NOEXCEPT { return const_reverse_iterator(cend()); }
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY
-	const_reverse_iterator rend()     const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY
-	const_reverse_iterator crbegin()  const _NOEXCEPT { return const_reverse_iterator(cend()); }
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY
-	const_reverse_iterator crend()    const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
-
-	// [string.view.capacity], capacity
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	size_type size()     const _NOEXCEPT { return __size; }
-
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	size_type length()   const _NOEXCEPT { return __size; }
-
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	size_type max_size() const _NOEXCEPT { return numeric_limits<size_type>::max(); }
-
-	_LIBCPP_CONSTEXPR bool _LIBCPP_INLINE_VISIBILITY
-	empty()         const _NOEXCEPT { return __size == 0; }
-
-	// [string.view.access], element access
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	const_reference operator[](size_type __pos) const _NOEXCEPT { return __data[__pos]; }
-
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	const_reference at(size_type __pos) const
-	{
-		return __pos >= size()
-			? (__throw_out_of_range("string_view::at"), __data[0])
-			: __data[__pos];
-	}
-
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	const_reference front() const
-	{
-		return _LIBCPP_ASSERT(!empty(), "string_view::front(): string is empty"), __data[0];
-	}
-
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	const_reference back() const
-	{
-		return _LIBCPP_ASSERT(!empty(), "string_view::back(): string is empty"), __data[__size-1];
-	}
-
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	const_pointer data() const _NOEXCEPT { return __data; }
-
-	// [string.view.modifiers], modifiers:
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	void remove_prefix(size_type __n) _NOEXCEPT
-	{
-		_LIBCPP_ASSERT(__n <= size(), "remove_prefix() can't remove more than size()");
-		__data += __n;
-		__size -= __n;
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	void remove_suffix(size_type __n) _NOEXCEPT
-	{
-		_LIBCPP_ASSERT(__n <= size(), "remove_suffix() can't remove more than size()");
-		__size -= __n;
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	void swap(basic_string_view& __other) _NOEXCEPT
-	{
-		const value_type *__p = __data;
-		__data = __other.__data;
-		__other.__data = __p;
-
-		size_type __sz = __size;
-		__size = __other.__size;
-		__other.__size = __sz;
-	}
-
-	_LIBCPP_INLINE_VISIBILITY
-	size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const
-	{
-		if (__pos > size())
-			__throw_out_of_range("string_view::copy");
-		size_type __rlen = _VSTD::min(__n, size() - __pos);
-		_Traits::copy(__s, data() + __pos, __rlen);
-		return __rlen;
-	}
-
-	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-	basic_string_view substr(size_type __pos = 0, size_type __n = npos) const
-	{
-		return __pos > size()
-			? (__throw_out_of_range("string_view::substr"), basic_string_view())
-			: basic_string_view(data() + __pos, _VSTD::min(__n, size() - __pos));
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 int compare(basic_string_view __sv) const _NOEXCEPT
-	{
-		size_type __rlen = _VSTD::min( size(), __sv.size());
-		int __retval = _Traits::compare(data(), __sv.data(), __rlen);
-		if ( __retval == 0 ) // first __rlen chars matched
-			__retval = size() == __sv.size() ? 0 : ( size() < __sv.size() ? -1 : 1 );
-		return __retval;
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	int compare(size_type __pos1, size_type __n1, basic_string_view __sv) const
-	{
-		return substr(__pos1, __n1).compare(__sv);
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	int compare(                       size_type __pos1, size_type __n1, 
-				basic_string_view __sv, size_type __pos2, size_type __n2) const
-	{
-		return substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	int compare(const _CharT* __s) const _NOEXCEPT
-	{
-		return compare(basic_string_view(__s));
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	int compare(size_type __pos1, size_type __n1, const _CharT* __s) const
-	{
-		return substr(__pos1, __n1).compare(basic_string_view(__s));
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	int compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const
-	{
-		return substr(__pos1, __n1).compare(basic_string_view(__s, __n2));
-	}
-
-	// find
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
-	{
-		_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
-		return __str_find<value_type, size_type, traits_type, npos>
-			(data(), size(), __s.data(), __pos, __s.size());
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find(_CharT __c, size_type __pos = 0) const _NOEXCEPT
-	{
-		return __str_find<value_type, size_type, traits_type, npos>
-			(data(), size(), __c, __pos);
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find(const _CharT* __s, size_type __pos, size_type __n) const
-	{
-		_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find(): received nullptr");
-		return __str_find<value_type, size_type, traits_type, npos>
-			(data(), size(), __s, __pos, __n);
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find(const _CharT* __s, size_type __pos = 0) const
-	{
-		_LIBCPP_ASSERT(__s != nullptr, "string_view::find(): received nullptr");
-		return __str_find<value_type, size_type, traits_type, npos>
-			(data(), size(), __s, __pos, traits_type::length(__s));
-	}
-
-	// rfind
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type rfind(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT
-	{
-		_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
-		return __str_rfind<value_type, size_type, traits_type, npos>
-			(data(), size(), __s.data(), __pos, __s.size());
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type rfind(_CharT __c, size_type __pos = npos) const _NOEXCEPT
-	{
-		return __str_rfind<value_type, size_type, traits_type, npos>
-			(data(), size(), __c, __pos);
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const
-	{
-		_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::rfind(): received nullptr");
-		return __str_rfind<value_type, size_type, traits_type, npos>
-			(data(), size(), __s, __pos, __n);
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type rfind(const _CharT* __s, size_type __pos=npos) const
-	{
-		_LIBCPP_ASSERT(__s != nullptr, "string_view::rfind(): received nullptr");
-		return __str_rfind<value_type, size_type, traits_type, npos>
-			(data(), size(), __s, __pos, traits_type::length(__s));
-	}
-
-	// find_first_of
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find_first_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
-	{
-		_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_of(): received nullptr");
-		return __str_find_first_of<value_type, size_type, traits_type, npos>
-			(data(), size(), __s.data(), __pos, __s.size());
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find_first_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT
-	{ return find(__c, __pos); }
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
-	{
-		_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_of(): received nullptr");
-		return __str_find_first_of<value_type, size_type, traits_type, npos>
-			(data(), size(), __s, __pos, __n);
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find_first_of(const _CharT* __s, size_type __pos=0) const
-	{
-		_LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_of(): received nullptr");
-		return __str_find_first_of<value_type, size_type, traits_type, npos>
-			(data(), size(), __s, __pos, traits_type::length(__s));
-	}
-
-	// find_last_of
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find_last_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
-	{
-		_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_of(): received nullptr");
-		return __str_find_last_of<value_type, size_type, traits_type, npos>
-			(data(), size(), __s.data(), __pos, __s.size());
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find_last_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT
-	{ return rfind(__c, __pos); }
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
-	{
-		_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_of(): received nullptr");
-		return __str_find_last_of<value_type, size_type, traits_type, npos>
-			(data(), size(), __s, __pos, __n);
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find_last_of(const _CharT* __s, size_type __pos=npos) const
-	{
-		_LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_of(): received nullptr");
-		return __str_find_last_of<value_type, size_type, traits_type, npos>
-			(data(), size(), __s, __pos, traits_type::length(__s));
-	}
-
-	// find_first_not_of
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find_first_not_of(basic_string_view __s, size_type __pos=0) const _NOEXCEPT
-	{
-		_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_not_of(): received nullptr");
-		return __str_find_first_not_of<value_type, size_type, traits_type, npos>
-			(data(), size(), __s.data(), __pos, __s.size());
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find_first_not_of(_CharT __c, size_type __pos=0) const _NOEXCEPT
-	{
-		return __str_find_first_not_of<value_type, size_type, traits_type, npos>
-			(data(), size(), __c, __pos);
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
-	{
-		_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_not_of(): received nullptr");
-		return __str_find_first_not_of<value_type, size_type, traits_type, npos>
-			(data(), size(), __s, __pos, __n);
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find_first_not_of(const _CharT* __s, size_type __pos=0) const
-	{
-		_LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_not_of(): received nullptr");
-		return __str_find_first_not_of<value_type, size_type, traits_type, npos>
-			(data(), size(), __s, __pos, traits_type::length(__s));
-	}
-
-	// find_last_not_of
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find_last_not_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
-	{
-		_LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_not_of(): received nullptr");
-		return __str_find_last_not_of<value_type, size_type, traits_type, npos>
-			(data(), size(), __s.data(), __pos, __s.size());
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find_last_not_of(_CharT __c, size_type __pos=npos) const _NOEXCEPT
-	{
-		return __str_find_last_not_of<value_type, size_type, traits_type, npos>
-			(data(), size(), __c, __pos);
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
-	{
-		_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_not_of(): received nullptr");
-		return __str_find_last_not_of<value_type, size_type, traits_type, npos>
-			(data(), size(), __s, __pos, __n);
-	}
-
-	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
-	size_type find_last_not_of(const _CharT* __s, size_type __pos=npos) const
-	{
-		_LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_not_of(): received nullptr");
-		return __str_find_last_not_of<value_type, size_type, traits_type, npos>
-			(data(), size(), __s, __pos, traits_type::length(__s));
-	}
+    }
+
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    basic_string_view(const _CharT* __s)
+        : __data(__s), __size(_Traits::length(__s)) {}
+
+    // [string.view.iterators], iterators
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    const_iterator begin()  const _NOEXCEPT { return cbegin(); }
+
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    const_iterator end()    const _NOEXCEPT { return cend(); }
+
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    const_iterator cbegin() const _NOEXCEPT { return __data; }
+
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    const_iterator cend()   const _NOEXCEPT { return __data + __size; }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY
+    const_reverse_iterator rbegin()   const _NOEXCEPT { return const_reverse_iterator(cend()); }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY
+    const_reverse_iterator rend()     const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY
+    const_reverse_iterator crbegin()  const _NOEXCEPT { return const_reverse_iterator(cend()); }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX14 _LIBCPP_INLINE_VISIBILITY
+    const_reverse_iterator crend()    const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
+
+    // [string.view.capacity], capacity
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    size_type size()     const _NOEXCEPT { return __size; }
+
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    size_type length()   const _NOEXCEPT { return __size; }
+
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    size_type max_size() const _NOEXCEPT { return numeric_limits<size_type>::max(); }
+
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+    bool empty()         const _NOEXCEPT { return __size == 0; }
+
+    // [string.view.access], element access
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    const_reference operator[](size_type __pos) const _NOEXCEPT { return __data[__pos]; }
+
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    const_reference at(size_type __pos) const
+    {
+        return __pos >= size()
+            ? (__throw_out_of_range("string_view::at"), __data[0])
+            : __data[__pos];
+    }
+
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    const_reference front() const
+    {
+        return _LIBCPP_ASSERT(!empty(), "string_view::front(): string is empty"), __data[0];
+    }
+
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    const_reference back() const
+    {
+        return _LIBCPP_ASSERT(!empty(), "string_view::back(): string is empty"), __data[__size-1];
+    }
+
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    const_pointer data() const _NOEXCEPT { return __data; }
+
+    // [string.view.modifiers], modifiers:
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    void remove_prefix(size_type __n) _NOEXCEPT
+    {
+        _LIBCPP_ASSERT(__n <= size(), "remove_prefix() can't remove more than size()");
+        __data += __n;
+        __size -= __n;
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    void remove_suffix(size_type __n) _NOEXCEPT
+    {
+        _LIBCPP_ASSERT(__n <= size(), "remove_suffix() can't remove more than size()");
+        __size -= __n;
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    void swap(basic_string_view& __other) _NOEXCEPT
+    {
+        const value_type *__p = __data;
+        __data = __other.__data;
+        __other.__data = __p;
+
+        size_type __sz = __size;
+        __size = __other.__size;
+        __other.__size = __sz;
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const
+    {
+        if (__pos > size())
+            __throw_out_of_range("string_view::copy");
+        size_type __rlen = _VSTD::min(__n, size() - __pos);
+        _Traits::copy(__s, data() + __pos, __rlen);
+        return __rlen;
+    }
+
+    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
+    basic_string_view substr(size_type __pos = 0, size_type __n = npos) const
+    {
+        return __pos > size()
+            ? (__throw_out_of_range("string_view::substr"), basic_string_view())
+            : basic_string_view(data() + __pos, _VSTD::min(__n, size() - __pos));
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 int compare(basic_string_view __sv) const _NOEXCEPT
+    {
+        size_type __rlen = _VSTD::min( size(), __sv.size());
+        int __retval = _Traits::compare(data(), __sv.data(), __rlen);
+        if ( __retval == 0 ) // first __rlen chars matched
+            __retval = size() == __sv.size() ? 0 : ( size() < __sv.size() ? -1 : 1 );
+        return __retval;
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    int compare(size_type __pos1, size_type __n1, basic_string_view __sv) const
+    {
+        return substr(__pos1, __n1).compare(__sv);
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    int compare(                       size_type __pos1, size_type __n1, 
+                basic_string_view __sv, size_type __pos2, size_type __n2) const
+    {
+        return substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    int compare(const _CharT* __s) const _NOEXCEPT
+    {
+        return compare(basic_string_view(__s));
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    int compare(size_type __pos1, size_type __n1, const _CharT* __s) const
+    {
+        return substr(__pos1, __n1).compare(basic_string_view(__s));
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    int compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const
+    {
+        return substr(__pos1, __n1).compare(basic_string_view(__s, __n2));
+    }
+
+    // find
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
+    {
+        _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
+        return __str_find<value_type, size_type, traits_type, npos>
+            (data(), size(), __s.data(), __pos, __s.size());
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find(_CharT __c, size_type __pos = 0) const _NOEXCEPT
+    {
+        return __str_find<value_type, size_type, traits_type, npos>
+            (data(), size(), __c, __pos);
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+        _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find(): received nullptr");
+        return __str_find<value_type, size_type, traits_type, npos>
+            (data(), size(), __s, __pos, __n);
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find(const _CharT* __s, size_type __pos = 0) const
+    {
+        _LIBCPP_ASSERT(__s != nullptr, "string_view::find(): received nullptr");
+        return __str_find<value_type, size_type, traits_type, npos>
+            (data(), size(), __s, __pos, traits_type::length(__s));
+    }
+
+    // rfind
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type rfind(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT
+    {
+        _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
+        return __str_rfind<value_type, size_type, traits_type, npos>
+            (data(), size(), __s.data(), __pos, __s.size());
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type rfind(_CharT __c, size_type __pos = npos) const _NOEXCEPT
+    {
+        return __str_rfind<value_type, size_type, traits_type, npos>
+            (data(), size(), __c, __pos);
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+        _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::rfind(): received nullptr");
+        return __str_rfind<value_type, size_type, traits_type, npos>
+            (data(), size(), __s, __pos, __n);
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type rfind(const _CharT* __s, size_type __pos=npos) const
+    {
+        _LIBCPP_ASSERT(__s != nullptr, "string_view::rfind(): received nullptr");
+        return __str_rfind<value_type, size_type, traits_type, npos>
+            (data(), size(), __s, __pos, traits_type::length(__s));
+    }
+
+    // find_first_of
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find_first_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
+    {
+        _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_of(): received nullptr");
+        return __str_find_first_of<value_type, size_type, traits_type, npos>
+            (data(), size(), __s.data(), __pos, __s.size());
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find_first_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT
+    { return find(__c, __pos); }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+        _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_of(): received nullptr");
+        return __str_find_first_of<value_type, size_type, traits_type, npos>
+            (data(), size(), __s, __pos, __n);
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find_first_of(const _CharT* __s, size_type __pos=0) const
+    {
+        _LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_of(): received nullptr");
+        return __str_find_first_of<value_type, size_type, traits_type, npos>
+            (data(), size(), __s, __pos, traits_type::length(__s));
+    }
+
+    // find_last_of
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find_last_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
+    {
+        _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_of(): received nullptr");
+        return __str_find_last_of<value_type, size_type, traits_type, npos>
+            (data(), size(), __s.data(), __pos, __s.size());
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find_last_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT
+    { return rfind(__c, __pos); }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+        _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_of(): received nullptr");
+        return __str_find_last_of<value_type, size_type, traits_type, npos>
+            (data(), size(), __s, __pos, __n);
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find_last_of(const _CharT* __s, size_type __pos=npos) const
+    {
+        _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_of(): received nullptr");
+        return __str_find_last_of<value_type, size_type, traits_type, npos>
+            (data(), size(), __s, __pos, traits_type::length(__s));
+    }
+
+    // find_first_not_of
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find_first_not_of(basic_string_view __s, size_type __pos=0) const _NOEXCEPT
+    {
+        _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_not_of(): received nullptr");
+        return __str_find_first_not_of<value_type, size_type, traits_type, npos>
+            (data(), size(), __s.data(), __pos, __s.size());
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find_first_not_of(_CharT __c, size_type __pos=0) const _NOEXCEPT
+    {
+        return __str_find_first_not_of<value_type, size_type, traits_type, npos>
+            (data(), size(), __c, __pos);
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+        _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_not_of(): received nullptr");
+        return __str_find_first_not_of<value_type, size_type, traits_type, npos>
+            (data(), size(), __s, __pos, __n);
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find_first_not_of(const _CharT* __s, size_type __pos=0) const
+    {
+        _LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_not_of(): received nullptr");
+        return __str_find_first_not_of<value_type, size_type, traits_type, npos>
+            (data(), size(), __s, __pos, traits_type::length(__s));
+    }
+
+    // find_last_not_of
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find_last_not_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
+    {
+        _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_not_of(): received nullptr");
+        return __str_find_last_not_of<value_type, size_type, traits_type, npos>
+            (data(), size(), __s.data(), __pos, __s.size());
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find_last_not_of(_CharT __c, size_type __pos=npos) const _NOEXCEPT
+    {
+        return __str_find_last_not_of<value_type, size_type, traits_type, npos>
+            (data(), size(), __c, __pos);
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+        _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_not_of(): received nullptr");
+        return __str_find_last_not_of<value_type, size_type, traits_type, npos>
+            (data(), size(), __s, __pos, __n);
+    }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    size_type find_last_not_of(const _CharT* __s, size_type __pos=npos) const
+    {
+        _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_not_of(): received nullptr");
+        return __str_find_last_not_of<value_type, size_type, traits_type, npos>
+            (data(), size(), __s, __pos, traits_type::length(__s));
+    }
+
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool starts_with(basic_string_view __s) const _NOEXCEPT
+    { return size() >= __s.size() && compare(0, __s.size(), __s) == 0; }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool starts_with(value_type __c) const _NOEXCEPT
+    { return !empty() && _Traits::eq(front(), __c); }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool starts_with(const value_type* __s) const _NOEXCEPT
+    { return starts_with(basic_string_view(__s)); }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool ends_with(basic_string_view __s) const _NOEXCEPT
+    { return size() >= __s.size() && compare(size() - __s.size(), npos, __s) == 0; }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool ends_with(value_type __c) const _NOEXCEPT
+    { return !empty() && _Traits::eq(back(), __c); }
+
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+    bool ends_with(const value_type* __s) const _NOEXCEPT
+    { return ends_with(basic_string_view(__s)); }
+#endif
 
 private:
-	const   value_type* __data;
-	size_type           __size;
+    const   value_type* __data;
+    size_type           __size;
 };
 
 
@@ -576,28 +609,28 @@ private:
 template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator==(basic_string_view<_CharT, _Traits> __lhs,
-				basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
+                basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
-	if ( __lhs.size() != __rhs.size()) return false;
-	return __lhs.compare(__rhs) == 0;
+    if ( __lhs.size() != __rhs.size()) return false;
+    return __lhs.compare(__rhs) == 0;
 }
 
 template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator==(basic_string_view<_CharT, _Traits> __lhs,
-				typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
+                typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
 {
-	if ( __lhs.size() != __rhs.size()) return false;
-	return __lhs.compare(__rhs) == 0;
+    if ( __lhs.size() != __rhs.size()) return false;
+    return __lhs.compare(__rhs) == 0;
 }
 
 template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator==(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs, 
-				basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
+                basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
-	if ( __lhs.size() != __rhs.size()) return false;
-	return __lhs.compare(__rhs) == 0;
+    if ( __lhs.size() != __rhs.size()) return false;
+    return __lhs.compare(__rhs) == 0;
 }
 
 
@@ -606,29 +639,29 @@ template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator!=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
-	if ( __lhs.size() != __rhs.size())
-		return true;
-	return __lhs.compare(__rhs) != 0;
+    if ( __lhs.size() != __rhs.size())
+        return true;
+    return __lhs.compare(__rhs) != 0;
 }
 
 template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator!=(basic_string_view<_CharT, _Traits> __lhs,
-				typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
+                typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
 {
-	if ( __lhs.size() != __rhs.size())
-		return true;
-	return __lhs.compare(__rhs) != 0;
+    if ( __lhs.size() != __rhs.size())
+        return true;
+    return __lhs.compare(__rhs) != 0;
 }
 
 template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator!=(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs, 
-				basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
+                basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
-	if ( __lhs.size() != __rhs.size())
-		return true;
-	return __lhs.compare(__rhs) != 0;
+    if ( __lhs.size() != __rhs.size())
+        return true;
+    return __lhs.compare(__rhs) != 0;
 }
 
 
@@ -637,23 +670,23 @@ template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator<(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
-	return __lhs.compare(__rhs) < 0;
+    return __lhs.compare(__rhs) < 0;
 }
 
 template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator<(basic_string_view<_CharT, _Traits> __lhs,
-				typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
+                typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
 {
-	return __lhs.compare(__rhs) < 0;
+    return __lhs.compare(__rhs) < 0;
 }
 
 template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator<(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs, 
-				basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
+                basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
-	return __lhs.compare(__rhs) < 0;
+    return __lhs.compare(__rhs) < 0;
 }
 
 
@@ -662,23 +695,23 @@ template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator> (basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
-	return __lhs.compare(__rhs) > 0;
+    return __lhs.compare(__rhs) > 0;
 }
 
 template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator>(basic_string_view<_CharT, _Traits> __lhs,
-				typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
+                typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
 {
-	return __lhs.compare(__rhs) > 0;
+    return __lhs.compare(__rhs) > 0;
 }
 
 template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator>(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs, 
-				basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
+                basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
-	return __lhs.compare(__rhs) > 0;
+    return __lhs.compare(__rhs) > 0;
 }
 
 
@@ -687,23 +720,23 @@ template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator<=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
-	return __lhs.compare(__rhs) <= 0;
+    return __lhs.compare(__rhs) <= 0;
 }
 
 template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator<=(basic_string_view<_CharT, _Traits> __lhs,
-				typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
+                typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
 {
-	return __lhs.compare(__rhs) <= 0;
+    return __lhs.compare(__rhs) <= 0;
 }
 
 template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator<=(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs, 
-				basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
+                basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
-	return __lhs.compare(__rhs) <= 0;
+    return __lhs.compare(__rhs) <= 0;
 }
 
 
@@ -712,24 +745,24 @@ template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator>=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
-	return __lhs.compare(__rhs) >= 0;
+    return __lhs.compare(__rhs) >= 0;
 }
 
 
 template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator>=(basic_string_view<_CharT, _Traits> __lhs,
-				typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
+                typename common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
 {
-	return __lhs.compare(__rhs) >= 0;
+    return __lhs.compare(__rhs) >= 0;
 }
 
 template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator>=(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs, 
-				basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
+                basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
-	return __lhs.compare(__rhs) >= 0;
+    return __lhs.compare(__rhs) >= 0;
 }
 
 typedef basic_string_view<char>     string_view;
@@ -760,25 +793,25 @@ inline namespace literals
   inline namespace string_view_literals
   {
     inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    basic_string_view<char> operator "" sv(const char *__str, size_t __len)
+    basic_string_view<char> operator "" sv(const char *__str, size_t __len) _NOEXCEPT
     {
         return basic_string_view<char> (__str, __len);
     }
 
     inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    basic_string_view<wchar_t> operator "" sv(const wchar_t *__str, size_t __len)
+    basic_string_view<wchar_t> operator "" sv(const wchar_t *__str, size_t __len) _NOEXCEPT
     {
         return basic_string_view<wchar_t> (__str, __len);
     }
 
     inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    basic_string_view<char16_t> operator "" sv(const char16_t *__str, size_t __len)
+    basic_string_view<char16_t> operator "" sv(const char16_t *__str, size_t __len) _NOEXCEPT
     {
         return basic_string_view<char16_t> (__str, __len);
     }
 
     inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    basic_string_view<char32_t> operator "" sv(const char32_t *__str, size_t __len)
+    basic_string_view<char32_t> operator "" sv(const char32_t *__str, size_t __len) _NOEXCEPT
     {
         return basic_string_view<char32_t> (__str, __len);
     }
diff --git a/include/support/win32/locale_win32.h b/include/support/win32/locale_win32.h
index b2b3ac4c799b..aebfff22ecf0 100644
--- a/include/support/win32/locale_win32.h
+++ b/include/support/win32/locale_win32.h
@@ -14,6 +14,7 @@
 #include <__config>
 #include <stdio.h>
 #include <xlocinfo.h> // _locale_t
+#include <__nullptr>
 
 #define LC_COLLATE_MASK _M_COLLATE
 #define LC_CTYPE_MASK _M_CTYPE
@@ -28,13 +29,77 @@
                      | LC_NUMERIC_MASK \
                      | LC_TIME_MASK )
 
-#define locale_t _locale_t
+class locale_t {
+public:
+    locale_t()
+        : __locale(nullptr), __locale_str(nullptr) {}
+    locale_t(std::nullptr_t)
+        : __locale(nullptr), __locale_str(nullptr) {}
+    locale_t(_locale_t __locale, const char* __locale_str)
+        : __locale(__locale), __locale_str(__locale_str) {}
+
+    friend bool operator==(const locale_t& __left, const locale_t& __right) {
+        return __left.__locale == __right.__locale;
+    }
+
+    friend bool operator==(const locale_t& __left, int __right) {
+        return __left.__locale == nullptr && __right == 0;
+    }
+
+    friend bool operator==(const locale_t& __left, std::nullptr_t) {
+        return __left.__locale == nullptr;
+    }
+
+    friend bool operator==(int __left, const locale_t& __right) {
+        return __left == 0 && nullptr == __right.__locale;
+    }
+
+    friend bool operator==(std::nullptr_t, const locale_t& __right) {
+        return nullptr == __right.__locale;
+    }
+
+    friend bool operator!=(const locale_t& __left, const locale_t& __right) {
+        return !(__left == __right);
+    }
+
+    friend bool operator!=(const locale_t& __left, int __right) {
+        return !(__left == __right);
+    }
+
+    friend bool operator!=(const locale_t& __left, std::nullptr_t __right) {
+        return !(__left == __right);
+    }
+
+    friend bool operator!=(int __left, const locale_t& __right) {
+        return !(__left == __right);
+    }
+
+    friend bool operator!=(std::nullptr_t __left, const locale_t& __right) {
+        return !(__left == __right);
+    }
+
+    operator bool() const {
+        return __locale != nullptr;
+    }
+
+    const char* __get_locale() const { return __locale_str; }
+
+    operator _locale_t() const {
+        return __locale;
+    }
+private:
+    _locale_t __locale;
+    const char* __locale_str;
+};
 
 // Locale management functions
 #define freelocale _free_locale
 // FIXME: base currently unused. Needs manual work to construct the new locale
 locale_t newlocale( int mask, const char * locale, locale_t base );
-locale_t uselocale( locale_t newloc );
+// uselocale can't be implemented on Windows because Windows allows partial modification
+// of thread-local locale and so _get_current_locale() returns a copy while uselocale does
+// not create any copies.
+// We can still implement raii even without uselocale though.
 
 
 lconv *localeconv_l( locale_t loc );
@@ -100,9 +165,12 @@ isupper_l(int c, _locale_t loc)
 #define iswxdigit_l _iswxdigit_l
 #define towupper_l _towupper_l
 #define towlower_l _towlower_l
+#if defined(__MINGW32__) && __MSVCRT_VERSION__ < 0x0800
+#define strftime_l( __s, __l, __f, __tm, __loc ) strftime( __s, __l, __f, __tm )
+#else
 #define strftime_l _strftime_l
+#endif
 #define sscanf_l( __s, __l, __f, ...) _sscanf_l( __s, __f, __l, __VA_ARGS__ )
-#define vsscanf_l( __s, __l, __f, ...) _sscanf_l( __s, __f, __l, __VA_ARGS__ )
 #define sprintf_l( __s, __l, __f, ... ) _sprintf_l( __s, __f, __l, __VA_ARGS__ )
 #define vsprintf_l( __s, __l, __f, ... ) _vsprintf_l( __s, __f, __l, __VA_ARGS__ )
 #define vsnprintf_l( __s, __n, __l, __f, ... ) _vsnprintf_l( __s, __n, __f, __l, __VA_ARGS__ )
diff --git a/include/system_error b/include/system_error
index a29807db0d65..12745525f57f 100644
--- a/include/system_error
+++ b/include/system_error
@@ -230,6 +230,7 @@ template <> struct hash<std::error_condition>;
 #include <type_traits>
 #include <stdexcept>
 #include <__functional_base>
+#include <string>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
diff --git a/include/tuple b/include/tuple
index a52b934aaca7..5e32b6dfe2ac 100644
--- a/include/tuple
+++ b/include/tuple
@@ -929,7 +929,7 @@ public:
     void swap(tuple&) _NOEXCEPT {}
 };
 
-#ifdef __cpp_deduction_guides
+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 // NOTE: These are not yet standardized, but are required to simulate the
 // implicit deduction guide that should be generated had libc++ declared the
 // tuple-like constructors "correctly"
@@ -1012,10 +1012,10 @@ constexpr size_t __find_idx(size_t __i, const bool (&__matches)[_Nx]) {
 
 template <class _T1, class ..._Args>
 struct __find_exactly_one_checked {
-  static constexpr bool __matches[] = {is_same<_T1, _Args>::value...};
+    static constexpr bool __matches[sizeof...(_Args)] = {is_same<_T1, _Args>::value...};
     static constexpr size_t value = __find_detail::__find_idx(0, __matches);
-    static_assert (value != __not_found, "type not found in type list" );
-    static_assert(value != __ambiguous,"type occurs more than once in type list");
+    static_assert(value != __not_found, "type not found in type list" );
+    static_assert(value != __ambiguous, "type occurs more than once in type list");
 };
 
 template <class _T1>
diff --git a/include/type_traits b/include/type_traits
index 6c111abfd1e8..60b5dec5b839 100644
--- a/include/type_traits
+++ b/include/type_traits
@@ -137,25 +137,25 @@ namespace std
     template <class Base, class Derived> struct is_base_of;
     template <class From, class To> struct is_convertible;
 
-    template <class, class R = void> struct is_callable; // not defined
-    template <class Fn, class... ArgTypes, class R>
-      struct is_callable<Fn(ArgTypes...), R>;
+    template <class Fn, class... ArgTypes> struct is_invocable;
+    template <class R, class Fn, class... ArgTypes> struct is_invocable_r;
 
-    template <class, class R = void> struct is_nothrow_callable; // not defined
-    template <class Fn, class... ArgTypes, class R>
-      struct is_nothrow_callable<Fn(ArgTypes...), R>;
+    template <class Fn, class... ArgTypes> struct is_nothrow_invocable;
+    template <class R, class Fn, class... ArgTypes> struct is_nothrow_invocable_r;
 
     // Alignment properties and transformations:
     template <class T> struct alignment_of;
     template <size_t Len, size_t Align = most_stringent_alignment_requirement>
         struct aligned_storage;
     template <size_t Len, class... Types> struct aligned_union;
+    template <class T> struct remove_cvref; // C++20
 
     template <class T> struct decay;
     template <class... T> struct common_type;
     template <class T> struct underlying_type;
     template <class> class result_of; // undefined
     template <class Fn, class... ArgTypes> class result_of<Fn(ArgTypes...)>;
+    template <class Fn, class... ArgTypes> struct invoke_result;  // C++17
 
     // const-volatile modifications:
     template <class T>
@@ -203,6 +203,8 @@ namespace std
     template <std::size_t Len, class... Types>
       using aligned_union_t   = typename aligned_union<Len,Types...>::type;  // C++14
     template <class T>
+      using remove_cvref_t    = typename remove_cvref<T>::type;  // C++20
+    template <class T>
       using decay_t           = typename decay<T>::type;  // C++14
     template <bool b, class T=void>
       using enable_if_t       = typename enable_if<b,T>::type;  // C++14
@@ -212,8 +214,10 @@ namespace std
       using common_type_t     = typename common_type<T...>::type;  // C++14
     template <class T>
       using underlying_type_t = typename underlying_type<T>::type;  // C++14
-    template <class F, class... ArgTypes>
-      using result_of_t       = typename result_of<F(ArgTypes...)>::type;  // C++14
+    template <class T>
+      using result_of_t       = typename result_of<T>::type;  // C++14
+    template <class Fn, class... ArgTypes>
+      using invoke_result_t   = typename invoke_result<Fn, ArgTypes...>::type;  // C++17
 
     template <class...>
       using void_t = void;   // C++17
@@ -367,10 +371,14 @@ namespace std
         = is_base_of<Base, Derived>::value;                              // C++17
       template <class From, class To> constexpr bool is_convertible_v
         = is_convertible<From, To>::value;                               // C++17
-      template <class T, class R = void> constexpr bool is_callable_v
-        = is_callable<T, R>::value;                                      // C++17
-      template <class T, class R = void> constexpr bool is_nothrow_callable_v
-        = is_nothrow_callable<T, R>::value;                              // C++17
+      template <class Fn, class... ArgTypes> constexpr bool is_invocable_v
+        = is_invocable<Fn, ArgTypes...>::value;                          // C++17
+      template <class R, class Fn, class... ArgTypes> constexpr bool is_invocable_r_v
+        = is_invocable_r<R, Fn, ArgTypes...>::value;                     // C++17
+      template <class Fn, class... ArgTypes> constexpr bool is_nothrow_invocable_v
+        = is_nothrow_invocable<Fn, ArgTypes...>::value;                  // C++17
+      template <class R, class Fn, class... ArgTypes> constexpr bool is_nothrow_invocable_r_v
+        = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;             // C++17
 
       // [meta.logical], logical operator traits:
       template<class... B> struct conjunction;                           // C++17
@@ -1141,6 +1149,17 @@ template <class _Tp, class _Up>
 struct __is_same_uncvref : is_same<typename __uncvref<_Tp>::type,
                                    typename __uncvref<_Up>::type> {};
 
+#if _LIBCPP_STD_VER > 17
+// aligned_union - same as __uncvref
+template <class _Tp>
+struct remove_cvref {
+    using type = remove_cv_t<remove_reference_t<_Tp>>;
+};
+
+template <class _Tp> using remove_cvref_t = typename remove_cvref<_Tp>::type;
+#endif
+
+
 struct __any
 {
     __any(...);
@@ -4388,6 +4407,13 @@ using __nothrow_invokable_r =
     >;
 
 template <class _Fp, class ..._Args>
+using __nothrow_invokable =
+    __nothrow_invokable_r_imp<
+            __invokable<_Fp, _Args...>::value,
+            true, void, _Fp, _Args...
+    >;
+
+template <class _Fp, class ..._Args>
 struct __invoke_of
     : public enable_if<
         __invokable<_Fp, _Args...>::value,
@@ -4409,30 +4435,48 @@ template <class _Tp> using result_of_t = typename result_of<_Tp>::type;
 
 #if _LIBCPP_STD_VER > 14
 
-// is_callable
+// invoke_result
+
+template <class _Fn, class... _Args>
+struct _LIBCPP_TEMPLATE_VIS invoke_result
+    : __invoke_of<_Fn, _Args...>
+{
+};
+
+template <class _Fn, class... _Args>
+using invoke_result_t = typename invoke_result<_Fn, _Args...>::type;
+
+// is_invocable
 
-template <class _Fn, class _Ret = void>
-struct _LIBCPP_TEMPLATE_VIS is_callable;
+template <class _Fn, class ..._Args>
+struct _LIBCPP_TEMPLATE_VIS is_invocable
+    : integral_constant<bool, __invokable<_Fn, _Args...>::value> {};
 
-template <class _Fn, class ..._Args, class _Ret>
-struct _LIBCPP_TEMPLATE_VIS is_callable<_Fn(_Args...), _Ret>
+template <class _Ret, class _Fn, class ..._Args>
+struct _LIBCPP_TEMPLATE_VIS is_invocable_r
     : integral_constant<bool, __invokable_r<_Ret, _Fn, _Args...>::value> {};
 
-template <class _Fn, class _Ret = void>
-constexpr bool is_callable_v = is_callable<_Fn, _Ret>::value;
+template <class _Fn, class ..._Args>
+constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value;
+
+template <class _Ret, class _Fn, class ..._Args>
+constexpr bool is_invocable_r_v = is_invocable_r<_Ret, _Fn, _Args...>::value;
 
 // is_nothrow_callable
 
-template <class _Fn, class _Ret = void>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_callable;
+template <class _Fn, class ..._Args>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_invocable
+    : integral_constant<bool, __nothrow_invokable<_Fn, _Args...>::value> {};
 
-template <class _Fn, class ..._Args, class _Ret>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_callable<_Fn(_Args...), _Ret>
-    : integral_constant<bool, __nothrow_invokable_r<_Ret, _Fn, _Args...>::value>
-{};
+template <class _Ret, class _Fn, class ..._Args>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_invocable_r
+    : integral_constant<bool, __nothrow_invokable_r<_Ret, _Fn, _Args...>::value> {};
+
+template <class _Fn, class ..._Args>
+constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<_Fn, _Args...>::value;
 
-template <class _Fn, class _Ret = void>
-constexpr bool is_nothrow_callable_v = is_nothrow_callable<_Fn, _Ret>::value;
+template <class _Ret, class _Fn, class ..._Args>
+constexpr bool is_nothrow_invocable_r_v = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value;
 
 #endif // _LIBCPP_STD_VER > 14
 
@@ -4638,6 +4682,11 @@ long long __convert_to_integral(long long __val) { return __val; }
 inline _LIBCPP_INLINE_VISIBILITY
 unsigned long long __convert_to_integral(unsigned long long __val) {return __val; }
 
+template<typename _Fp>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if<is_floating_point<_Fp>::value, long long>::type
+ __convert_to_integral(_Fp __val) { return __val; }
+
 #ifndef _LIBCPP_HAS_NO_INT128
 inline _LIBCPP_INLINE_VISIBILITY
 __int128_t __convert_to_integral(__int128_t __val) { return __val; }
@@ -4747,26 +4796,26 @@ namespace std  // purposefully not versioned
 template <class _Integer>
   constexpr typename enable_if<is_integral_v<_Integer>, byte>::type &
   operator<<=(byte& __lhs, _Integer __shift) noexcept
-  { return __lhs = byte(static_cast<unsigned char>(__lhs) << __shift); }
+  { return __lhs = __lhs << __shift; }
   
 template <class _Integer>
   constexpr typename enable_if<is_integral_v<_Integer>, byte>::type
   operator<< (byte  __lhs, _Integer __shift) noexcept
-  { return         byte(static_cast<unsigned char>(__lhs) << __shift); }
+  { return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(__lhs) << __shift)); }
 
 template <class _Integer>
   constexpr typename enable_if<is_integral_v<_Integer>, byte>::type &
   operator>>=(byte& __lhs, _Integer __shift) noexcept
-  { return __lhs = byte(static_cast<unsigned char>(__lhs) >> __shift); }
+  { return __lhs = __lhs >> __shift; }
 
 template <class _Integer>
   constexpr typename enable_if<is_integral_v<_Integer>, byte>::type
   operator>> (byte  __lhs, _Integer __shift) noexcept
-  { return         byte(static_cast<unsigned char>(__lhs) >> __shift); }
+  { return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(__lhs) >> __shift)); }
   
 template <class _Integer>
   constexpr typename enable_if<is_integral_v<_Integer>, _Integer>::type
-  to_integer(byte __b) noexcept { return _Integer(__b); }
+  to_integer(byte __b) noexcept { return static_cast<_Integer>(__b); }
 
 }
 #endif
diff --git a/include/typeinfo b/include/typeinfo
index 8624b349764a..7e8d3990ed98 100644
--- a/include/typeinfo
+++ b/include/typeinfo
@@ -69,18 +69,17 @@ public:
 #pragma GCC system_header
 #endif
 
-#if defined(_LIBCPP_ABI_MICROSOFT)
-#include <vcruntime_typeinfo.h>
-#elif defined(_LIBCPP_NONUNIQUE_RTTI_BIT)
+#if !defined(_LIBCPP_ABI_MICROSOFT)
+#if defined(_LIBCPP_NONUNIQUE_RTTI_BIT)
 #define _LIBCPP_HAS_NONUNIQUE_TYPEINFO
 #else
 #define _LIBCPP_HAS_UNIQUE_TYPEINFO
 #endif
+#endif
 
 namespace std  // purposefully not using versioning namespace
 {
 
-#if !defined(_LIBCPP_ABI_MICROSOFT)
 class _LIBCPP_EXCEPTION_ABI type_info
 {
     type_info& operator=(const type_info&);
@@ -92,7 +91,17 @@ class _LIBCPP_EXCEPTION_ABI type_info
     { return __builtin_strcmp(name(), __arg.name()); }
 #endif
 
+#if defined(_LIBCPP_ABI_MICROSOFT)
+    mutable struct {
+      const char *__undecorated_name;
+      const char __decorated_name[1];
+    } __data;
+
+    int __compare(const type_info &__rhs) const _NOEXCEPT;
+#endif // _LIBCPP_ABI_MICROSOFT
+
 protected:
+#if !defined(_LIBCPP_ABI_MICROSOFT)
 #if defined(_LIBCPP_HAS_NONUNIQUE_TYPEINFO)
     // A const char* with the non-unique RTTI bit possibly set.
     uintptr_t __type_name;
@@ -106,11 +115,27 @@ protected:
     _LIBCPP_INLINE_VISIBILITY
     explicit type_info(const char* __n) : __type_name(__n) {}
 #endif
+#endif // ! _LIBCPP_ABI_MICROSOFT
 
 public:
     _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE
     virtual ~type_info();
 
+#if defined(_LIBCPP_ABI_MICROSOFT)
+    const char *name() const _NOEXCEPT;
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool before(const type_info& __arg) const _NOEXCEPT {
+      return __compare(__arg) < 0;
+    }
+
+    size_t hash_code() const _NOEXCEPT;
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool operator==(const type_info& __arg) const _NOEXCEPT {
+      return __compare(__arg) == 0;
+    }
+#else
 #if defined(_LIBCPP_HAS_NONUNIQUE_TYPEINFO)
     _LIBCPP_INLINE_VISIBILITY
     const char* name() const _NOEXCEPT
@@ -167,6 +192,7 @@ public:
     bool operator==(const type_info& __arg) const _NOEXCEPT
     { return __type_name == __arg.__type_name; }
 #endif
+#endif // _LIBCPP_ABI_MICROSOFT
 
     _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const type_info& __arg) const _NOEXCEPT
@@ -191,8 +217,6 @@ public:
     virtual const char* what() const _NOEXCEPT;
 };
 
-#endif // !_LIBCPP_ABI_MICROSOFT
-
 }  // std
 
 _LIBCPP_BEGIN_NAMESPACE_STD
diff --git a/include/unordered_map b/include/unordered_map
index 0546c0e2f9f2..725cb6af2759 100644
--- a/include/unordered_map
+++ b/include/unordered_map
@@ -885,7 +885,7 @@ public:
     allocator_type get_allocator() const _NOEXCEPT
         {return allocator_type(__table_.__node_alloc());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
     _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT  {return __table_.size();}
@@ -1634,7 +1634,7 @@ public:
     allocator_type get_allocator() const _NOEXCEPT
         {return allocator_type(__table_.__node_alloc());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
     _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT  {return __table_.size();}
diff --git a/include/unordered_set b/include/unordered_set
index a14fb0004922..3ae024a45eed 100644
--- a/include/unordered_set
+++ b/include/unordered_set
@@ -450,7 +450,7 @@ public:
     allocator_type get_allocator() const _NOEXCEPT
         {return allocator_type(__table_.__node_alloc());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
     _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT  {return __table_.size();}
@@ -968,7 +968,7 @@ public:
     allocator_type get_allocator() const _NOEXCEPT
         {return allocator_type(__table_.__node_alloc());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
     _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT  {return __table_.size();}
diff --git a/include/utility b/include/utility
index 00e3cd208ecb..288c6e823c3b 100644
--- a/include/utility
+++ b/include/utility
@@ -545,6 +545,11 @@ private:
 #endif
 };
 
+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
+template<class _T1, class _T2>
+pair(_T1, _T2) -> pair<_T1, _T2>;
+#endif // _LIBCPP_HAS_NO_DEDUCTION_GUIDES
+
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 bool
diff --git a/include/variant b/include/variant
index f8d3e28bae45..8a66add865ae 100644
--- a/include/variant
+++ b/include/variant
@@ -207,11 +207,15 @@ namespace std {
 #include <tuple>
 #include <type_traits>
 #include <utility>
+#include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 namespace std { // explicitly not using versioning namespace
 
 class _LIBCPP_EXCEPTION_ABI bad_variant_access : public exception {
@@ -283,7 +287,28 @@ struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, variant<_Types...>> {
 };
 
 constexpr size_t variant_npos = static_cast<size_t>(-1);
-constexpr unsigned int __variant_npos = static_cast<unsigned int>(-1);
+
+constexpr int __choose_index_type(unsigned int __num_elem) {
+  if (__num_elem < std::numeric_limits<unsigned char>::max())
+    return 0;
+  if (__num_elem < std::numeric_limits<unsigned short>::max())
+    return 1;
+  return 2;
+}
+
+template <size_t _NumAlts>
+using __variant_index_t =
+#ifndef _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION
+  unsigned int;
+#else
+  std::tuple_element_t<
+      __choose_index_type(_NumAlts),
+      std::tuple<unsigned char, unsigned short, unsigned int>
+  >;
+#endif
+
+template <class _IndexType>
+constexpr _IndexType __variant_npos = static_cast<_IndexType>(-1);
 
 namespace __find_detail {
 
@@ -557,7 +582,7 @@ struct __variant {
 private:
   template <class _Visitor, class... _Values>
   static constexpr void __std_visit_exhaustive_visitor_check() {
-    static_assert(is_callable_v<_Visitor(_Values...)>,
+    static_assert(is_invocable_v<_Visitor, _Values...>,
                   "`std::visit` requires the visitor to be exhaustive.");
   }
 
@@ -647,9 +672,11 @@ _LIBCPP_VARIANT_UNION(_Trait::_Unavailable, ~__union() = delete;);
 template <_Trait _DestructibleTrait, class... _Types>
 class _LIBCPP_TEMPLATE_VIS __base {
 public:
+  using __index_t = __variant_index_t<sizeof...(_Types)>;
+
   inline _LIBCPP_INLINE_VISIBILITY
   explicit constexpr __base(__valueless_t tag) noexcept
-      : __data(tag), __index(__variant_npos) {}
+      : __data(tag), __index(__variant_npos<__index_t>) {}
 
   template <size_t _Ip, class... _Args>
   inline _LIBCPP_INLINE_VISIBILITY
@@ -665,7 +692,7 @@ public:
 
   inline _LIBCPP_INLINE_VISIBILITY
   constexpr size_t index() const noexcept {
-    return __index == __variant_npos ? variant_npos : __index;
+    return __index == __variant_npos<__index_t> ? variant_npos : __index;
   }
 
 protected:
@@ -685,7 +712,7 @@ protected:
   static constexpr size_t __size() { return sizeof...(_Types); }
 
   __union<_DestructibleTrait, 0, _Types...> __data;
-  unsigned int __index;
+  __index_t __index;
 
   friend struct __access::__base;
   friend struct __visitation::__base;
@@ -696,10 +723,11 @@ class _LIBCPP_TEMPLATE_VIS __destructor;
 
 #define _LIBCPP_VARIANT_DESTRUCTOR(destructible_trait, destructor, destroy)    \
   template <class... _Types>                                                   \
-  class _LIBCPP_TEMPLATE_VIS __destructor<__traits<_Types...>,                \
+  class _LIBCPP_TEMPLATE_VIS __destructor<__traits<_Types...>,                 \
                                            destructible_trait>                 \
       : public __base<destructible_trait, _Types...> {                         \
     using __base_type = __base<destructible_trait, _Types...>;                 \
+    using __index_t = typename __base_type::__index_t;                         \
                                                                                \
   public:                                                                      \
     using __base_type::__base_type;                                            \
@@ -719,7 +747,7 @@ class _LIBCPP_TEMPLATE_VIS __destructor;
 _LIBCPP_VARIANT_DESTRUCTOR(
     _Trait::_TriviallyAvailable,
     ~__destructor() = default;,
-    void __destroy() noexcept { this->__index = __variant_npos; });
+    void __destroy() noexcept { this->__index = __variant_npos<__index_t>; });
 
 _LIBCPP_VARIANT_DESTRUCTOR(
     _Trait::_Available,
@@ -733,7 +761,7 @@ _LIBCPP_VARIANT_DESTRUCTOR(
             },
             *this);
       }
-      this->__index = __variant_npos;
+      this->__index = __variant_npos<__index_t>;
     });
 
 _LIBCPP_VARIANT_DESTRUCTOR(
@@ -1561,4 +1589,6 @@ struct _LIBCPP_TEMPLATE_VIS hash<monostate> {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif  // _LIBCPP_VARIANT
diff --git a/include/vector b/include/vector
index b2f8f092c63d..54b1e8831d5b 100644
--- a/include/vector
+++ b/include/vector
@@ -634,7 +634,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     size_type capacity() const _NOEXCEPT
         {return __base::capacity();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT
         {return this->__begin_ == this->__end_;}
     size_type max_size() const _NOEXCEPT;
@@ -2290,7 +2290,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT
         {return __size_;}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT
         {return __size_ == 0;}
     void reserve(size_type __n);
diff --git a/include/wchar.h b/include/wchar.h
index a5666e193a5b..f74fe6ddcff4 100644
--- a/include/wchar.h
+++ b/include/wchar.h
@@ -125,6 +125,10 @@ size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len,
 #  if __GLIBC_PREREQ(2, 10)
 #    define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
 #  endif
+#elif defined(_LIBCPP_MSVCRT)
+#  if defined(_CRT_CONST_CORRECT_OVERLOADS)
+#    define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
+#  endif
 #endif
 
 #if defined(__cplusplus) && !defined(_LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS) && defined(_LIBCPP_PREFERRED_OVERLOAD)
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 578651423f3b..aa5ebf1568ec 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -91,6 +91,7 @@ else()
   add_library_flags_if(LIBCXX_HAS_GCC_S_LIB gcc_s)
 endif()
 add_library_flags_if(LIBCXX_HAVE_CXX_ATOMICS_WITH_LIB atomic)
+add_library_flags_if(MINGW "${MINGW_LIBRARIES}")
 
 # Add the unwinder library.
 if (LIBCXXABI_USE_LLVM_UNWINDER)
@@ -269,6 +270,7 @@ if (LIBCXX_ENABLE_STATIC)
       ${PYTHON_EXECUTABLE} ${LIBCXX_SOURCE_DIR}/utils/merge_archives.py
     ARGS
       -o $<TARGET_LINKER_FILE:cxx_static>
+      --ar "${CMAKE_AR}"
       "$<TARGET_LINKER_FILE:cxx_static>"
       "${MERGE_ARCHIVES_ABI_TARGET}"
       "${MERGE_ARCHIVES_SEARCH_PATHS}"
@@ -387,5 +389,13 @@ if (NOT CMAKE_CONFIGURATION_TYPES AND (LIBCXX_INSTALL_LIBRARY OR
                       COMMAND "${CMAKE_COMMAND}"
                       -DCMAKE_INSTALL_COMPONENT=cxx
                       -P "${LIBCXX_BINARY_DIR}/cmake_install.cmake")
+    add_custom_target(install-cxx-stripped
+                      DEPENDS ${lib_install_target}
+                              ${experimental_lib_install_target}
+                              ${header_install_target}
+                      COMMAND "${CMAKE_COMMAND}"
+                      -DCMAKE_INSTALL_COMPONENT=cxx
+                      -DCMAKE_INSTALL_DO_STRIP=1
+                      -P "${LIBCXX_BINARY_DIR}/cmake_install.cmake")
     add_custom_target(install-libcxx DEPENDS install-cxx)
 endif()
diff --git a/lib/abi/5.0/x86_64-apple-darwin16.abilist b/lib/abi/5.0/x86_64-apple-darwin16.abilist
deleted file mode 100644
index 5d91c4b62783..000000000000
--- a/lib/abi/5.0/x86_64-apple-darwin16.abilist
+++ /dev/null
@@ -1,2376 +0,0 @@
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt10bad_typeid4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt10bad_typeid4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt11logic_error4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt11logic_error4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt12bad_any_cast4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt12experimental15fundamentals_v112bad_any_cast4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt13bad_exception4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt13bad_exception4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt13runtime_error4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt13runtime_error4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt16bad_array_length4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt16bad_array_length4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt16nested_exception14rethrow_nestedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt18bad_variant_access4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt19bad_optional_access4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt20bad_array_new_length4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt20bad_array_new_length4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110__time_put8__do_putEPcRS1_PK2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110__time_put8__do_putEPwRS1_PK2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110error_code7messageEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb0EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIcLb1EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb0EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__110moneypunctIwLb1EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db15__decrementableEPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db15__find_c_from_iEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db15__subscriptableEPKvl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db17__dereferenceableEPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db17__find_c_and_lockEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db22__less_than_comparableEPKvS2_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db8__find_cEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__111__libcpp_db9__addableEPKvl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112bad_weak_ptr4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE12find_last_ofEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE13find_first_ofEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE16find_last_not_ofEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE17find_first_not_ofEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE12find_last_ofEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE13find_first_ofEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE16find_last_not_ofEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE17find_first_not_ofEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4copyEPwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIcE10do_tolowerEPcPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIcE10do_tolowerEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIcE10do_toupperEPcPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIcE10do_toupperEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_scan_isEjPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_tolowerEPwPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_tolowerEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_toupperEPwPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE10do_toupperEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE11do_scan_notEjPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE5do_isEPKwS3_Pj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE5do_isEjw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE8do_widenEPKcS3_Pw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE8do_widenEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE9do_narrowEPKwS3_cPc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112ctype_bynameIwE9do_narrowEwc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__112strstreambuf6pcountEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__113random_device7entropyEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDiE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IDsE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114__codecvt_utf8IwE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114collate_bynameIcE10do_compareEPKcS3_S3_S3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114collate_bynameIcE12do_transformEPKcS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114collate_bynameIwE10do_compareEPKwS3_S3_S3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114collate_bynameIwE12do_transformEPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114error_category10equivalentERKNS_10error_codeEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114error_category10equivalentEiRKNS_15error_conditionE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__114error_category23default_error_conditionEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb0EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDiLb1EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb0EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IDsLb1EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb0EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115__codecvt_utf16IwLb1EE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115basic_streambufIcNS_11char_traitsIcEEE6getlocEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115basic_streambufIwNS_11char_traitsIwEEE6getlocEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__115error_condition7messageEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb0EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIcLb1EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb0EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE13do_neg_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE13do_pos_formatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE14do_curr_symbolEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE14do_frac_digitsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE16do_negative_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE16do_positive_signEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__117moneypunct_bynameIwLb1EE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__118__time_get_storageIcE15__do_date_orderEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__118__time_get_storageIwE15__do_date_orderEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__119__shared_weak_count13__get_deleterERKSt9type_info'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDiE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IDsE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE10do_unshiftER11__mbstate_tPcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__codecvt_utf8_utf16IwE9do_lengthER11__mbstate_tPKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE3__XEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE3__cEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE3__rEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE3__xEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE7__am_pmEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE7__weeksEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIcE8__monthsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE3__XEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE3__cEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE3__rEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE3__xEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE7__am_pmEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE7__weeksEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__time_get_c_storageIwE8__monthsEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__120__vector_base_commonILb1EE20__throw_out_of_rangeEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__121__basic_string_commonILb1EE20__throw_out_of_rangeEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__123__match_any_but_newlineIcE6__execERNS_7__stateIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__123__match_any_but_newlineIwE6__execERNS_7__stateIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__124__libcpp_debug_exception4whatEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE10do_tolowerEPcPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE10do_tolowerEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE10do_toupperEPcPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE10do_toupperEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE8do_widenEPKcS3_Pc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE8do_widenEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE9do_narrowEPKcS3_cPc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIcE9do_narrowEcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_scan_isEjPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_tolowerEPwPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_tolowerEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_toupperEPwPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE10do_toupperEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE11do_scan_notEjPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE5do_isEPKwS3_Pj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE5do_isEjw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE8do_widenEPKcS3_Pw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE8do_widenEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE9do_narrowEPKwS3_cPc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__15ctypeIwE9do_narrowEwc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__16locale4nameEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__16locale9has_facetERNS0_2idE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__16locale9use_facetERNS0_2idE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__16localeeqERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE5do_inERS1_PKcS5_RS5_PDiS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE6do_outERS1_PKDiS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDic11__mbstate_tE9do_lengthERS1_PKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE5do_inERS1_PKcS5_RS5_PDsS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE6do_outERS1_PKDsS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIDsc11__mbstate_tE9do_lengthERS1_PKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE5do_inERS1_PKcS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE6do_outERS1_PKcS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIcc11__mbstate_tE9do_lengthERS1_PKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE11do_encodingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE13do_max_lengthEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE16do_always_noconvEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE5do_inERS1_PKcS5_RS5_PwS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE6do_outERS1_PKwS5_RS5_PcS7_RS7_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17codecvtIwc11__mbstate_tE9do_lengthERS1_PKcS5_m'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIcE10do_compareEPKcS3_S3_S3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIcE12do_transformEPKcS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIcE7do_hashEPKcS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIwE10do_compareEPKwS3_S3_S3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIwE12do_transformEPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17collateIwE7do_hashEPKwS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEce'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18ios_base6getlocEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIcE6do_getEliiRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIcE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIcE8do_closeEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIwE6do_getEliiRKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIwE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18messagesIwE8do_closeEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE11do_truenameEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE12do_falsenameEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIcE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE11do_groupingEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE11do_truenameEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE12do_falsenameEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE16do_decimal_pointEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18numpunctIwE16do_thousands_sepEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13do_date_orderEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKcSC_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13do_date_orderEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKwSC_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE3putES4_RNS_8ios_baseEcPK2tmPKcSC_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPK2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE3putES4_RNS_8ios_baseEwPK2tmPKwSC_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPK2tmcc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIcS3_NS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIwS3_NS_9allocatorIwEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEcRKNS_12basic_stringIcS3_NS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEce'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwRKNS_12basic_stringIwS3_NS_9allocatorIwEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt8bad_cast4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt8bad_cast4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt9bad_alloc4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt9bad_alloc4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNKSt9exception4whatEv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNKSt9exception4whatEv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidC1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidC1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidC2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidC2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt10bad_typeidD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt10bad_typeidD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC1ERKS_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_errorC2ERKS_'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11logic_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11logic_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11logic_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11logic_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11logic_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11logic_errorD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt11logic_erroraSERKS_'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11range_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11range_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11range_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11range_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt11range_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt11range_errorD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12domain_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12domain_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12domain_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12domain_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12domain_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12domain_errorD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt12experimental19bad_optional_accessD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12length_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12length_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12length_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12length_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12length_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12length_errorD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12out_of_rangeD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12out_of_rangeD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12out_of_rangeD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12out_of_rangeD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt12out_of_rangeD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt12out_of_rangeD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13bad_exceptionD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13bad_exceptionD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13bad_exceptionD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13bad_exceptionD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13bad_exceptionD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13bad_exceptionD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrC1ERKS_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrC2ERKS_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptrD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13exception_ptraSERKS_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC1ERKS_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_errorC2ERKS_'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13runtime_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13runtime_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13runtime_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13runtime_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt13runtime_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt13runtime_errorD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt13runtime_erroraSERKS_'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt14overflow_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt14overflow_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt14overflow_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt14overflow_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt14overflow_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt14overflow_errorD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt15underflow_errorD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt15underflow_errorD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt15underflow_errorD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt15underflow_errorD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt15underflow_errorD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt15underflow_errorD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt16bad_array_lengthC1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt16bad_array_lengthC1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt16bad_array_lengthC2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt16bad_array_lengthC2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt16bad_array_lengthD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt16bad_array_lengthD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt16bad_array_lengthD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt16bad_array_lengthD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt16bad_array_lengthD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt16bad_array_lengthD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt16invalid_argumentD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt16invalid_argumentD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt16invalid_argumentD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt16invalid_argumentD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt16invalid_argumentD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt16invalid_argumentD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt16nested_exceptionD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt19bad_optional_accessD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt19bad_optional_accessD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt19bad_optional_accessD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthC1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthC1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthC2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthC2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt20bad_array_new_lengthD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt20bad_array_new_lengthD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_getD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110__time_putD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110adopt_lockE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5alnumE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5alphaE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5blankE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5cntrlE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5digitE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5graphE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5lowerE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5printE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5punctE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5spaceE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base5upperE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110ctype_base6xdigitE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110defer_lockE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110istrstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110istrstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110istrstreamD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIcLb0EE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIcLb0EE4intlE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIcLb1EE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIcLb1EE4intlE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIwLb0EE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIwLb0EE4intlE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIwLb1EE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__110moneypunctIwLb1EE4intlE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110ostrstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110ostrstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110ostrstreamD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__110to_wstringEy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__call_onceERVmPvPFvS2_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db10__insert_cEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db10__insert_iEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db11__insert_icEPvPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db15__iterator_copyEPvPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db16__invalidate_allEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db4swapEPvS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db9__erase_cEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_db9__erase_iEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_dbC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_dbC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_dbD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__libcpp_dbD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_getIcE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_SF_Ri'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_getIwE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_SJ_Ri'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_putIcE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_Ri'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_putIcE8__formatEPcRS2_S3_jPKcS5_RKNS_5ctypeIcEEbRKNS_10money_base7patternEccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESL_SL_i'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_putIwE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_Ri'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111__money_putIwE8__formatEPwRS2_S3_jPKwS5_RKNS_5ctypeIwEEbRKNS_10money_base7patternEwwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNSE_IwNSF_IwEENSH_IwEEEESQ_i'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111regex_errorC1ENS_15regex_constants10error_typeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111regex_errorC2ENS_15regex_constants10error_typeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111regex_errorD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111regex_errorD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111regex_errorD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111this_thread9sleep_forERKNS_6chrono8durationIxNS_5ratioILl1ELl1000000000EEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutex4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutex6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutex8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutexC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutexC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutexD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__111timed_mutexD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__111try_to_lockE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__do_nothingEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__get_sp_mutEPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__next_primeEm'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112__rs_default4__c_E', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultC1ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultC2ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112__rs_defaultclEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112bad_weak_ptrD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112bad_weak_ptrD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112bad_weak_ptrD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE21__grow_by_and_replaceEmmmmmmPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4nposE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5eraseEmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendERKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignERKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertENS_11__wrap_iterIPKcEEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6resizeEmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmmc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEmmmmmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9push_backEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_RKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_mmRKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_RKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_mmRKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE21__grow_by_and_replaceEmmmmmmPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4nposE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5eraseEmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendERKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignERKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertENS_11__wrap_iterIPKwEEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6resizeEmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmRKS5_mm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmmw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7reserveEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9__grow_byEmmmmmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9push_backEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_RKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_mmRKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_RKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_mmRKS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSERKS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIcED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112ctype_bynameIwED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112future_errorC1ENS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112future_errorC2ENS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112future_errorD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112future_errorD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112future_errorD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_1E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_2E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_3E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_4E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_5E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_6E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_7E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_8E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders2_9E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__112placeholders3_10E', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf3strEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf4swapERS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf6__initEPclS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf6freezeEb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf7seekoffExNS_8ios_base7seekdirEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf7seekposENS_4fposI11__mbstate_tEEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf8overflowEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf9pbackfailEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambuf9underflowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPFPvmEPFvS1_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPKal'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPKcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPKhl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPalS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPclS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1EPhlS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC1El'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPFPvmEPFvS1_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPKal'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPKcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPKhl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPalS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPclS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2EPhlS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufC2El'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112strstreambufD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_error6__initERKNS_10error_codeENS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1ENS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1ENS_10error_codeEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1EiRKNS_14error_categoryE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1EiRKNS_14error_categoryEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC1EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2ENS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2ENS_10error_codeEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2EiRKNS_14error_categoryE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2EiRKNS_14error_categoryEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorC2EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__112system_errorD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__113allocator_argE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPclc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4peekEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4readEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4swapERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4syncEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgENS_4fposI11__mbstate_tEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgExNS_8ios_base7seekdirE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5tellgEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5ungetEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6ignoreEli'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC1ERS3_b'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC2ERS3_b'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPclc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7putbackEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE8readsomeEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_8ios_baseES5_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_9basic_iosIcS2_EES6_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRS3_S4_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERs'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwlw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4peekEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4readEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4swapERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4syncEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgENS_4fposI11__mbstate_tEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgExNS_8ios_base7seekdirE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5tellgEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5ungetEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6ignoreEli'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC1ERS3_b'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC2ERS3_b'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwlw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7putbackEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE8readsomeEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_8ios_baseES5_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_9basic_iosIwS2_EES6_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRS3_S4_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPNS_15basic_streambufIwS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERs'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE3putEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE4swapERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5flushEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpENS_4fposI11__mbstate_tEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpExNS_8ios_base7seekdirE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5tellpEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5writeEPKcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC1ERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC2ERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_8ios_baseES5_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_9basic_iosIcS2_EES6_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRS3_S4_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEs'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE3putEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE4swapERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5flushEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpENS_4fposI11__mbstate_tEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpExNS_8ios_base7seekdirE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5tellpEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5writeEPKwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC1ERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC2ERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_8ios_baseES5_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_9basic_iosIwS2_EES6_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRS3_S4_E'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPKv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPNS_15basic_streambufIwS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEs'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEt'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113random_deviceC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113random_deviceC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113random_deviceD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113random_deviceD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113random_deviceclEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113shared_futureIvED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113shared_futureIvED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__113shared_futureIvEaSERKS1_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__get_const_dbEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__num_get_base10__get_baseERNS_8ios_baseE'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__114__num_get_base5__srcE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__num_put_base12__format_intEPcPKcbj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__num_put_base14__format_floatEPcPKcj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__num_put_base18__identify_paddingEPcS1_RKNS_8ios_baseE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__shared_count12__add_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__shared_count16__release_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__shared_countD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__shared_countD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114__shared_countD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEE4swapERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDic11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDic11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDic11__mbstate_tED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDsc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDsc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIDsc11__mbstate_tED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIcc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIcc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIcc11__mbstate_tED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIwc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIwc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114codecvt_bynameIwc11__mbstate_tED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIcED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114collate_bynameIwED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114error_categoryC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114error_categoryD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114error_categoryD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__114error_categoryD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__get_classnameEPKcb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_struct25notify_all_at_thread_exitEPNS_18condition_variableEPNS_5mutexE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_struct27__make_ready_at_thread_exitEPNS_17__assoc_sub_stateE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_structC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_structC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_structD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115__thread_structD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekoffExNS_8ios_base7seekdirEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekposENS_4fposI11__mbstate_tEEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setgEPcS4_S4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setpEPcS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4swapERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4syncEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5gbumpEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5pbumpEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetcEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetnEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputcEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputnEPKcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5uflowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6sbumpcEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6setbufEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6snextcEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsgetnEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsputnEPKcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7pubsyncEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekposENS_4fposI11__mbstate_tEEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7sungetcEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8in_availEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8overflowEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8pubimbueERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pbackfailEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pubsetbufEPcl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9showmanycEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9sputbackcEc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9underflowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1ERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2ERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEaSERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekoffExNS_8ios_base7seekdirEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekposENS_4fposI11__mbstate_tEEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setgEPwS4_S4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setpEPwS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4swapERS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4syncEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5gbumpEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5imbueERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5pbumpEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetcEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetnEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputcEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputnEPKwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5uflowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6sbumpcEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6setbufEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6snextcEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsgetnEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsputnEPKwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7pubsyncEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekoffExNS_8ios_base7seekdirEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekposENS_4fposI11__mbstate_tEEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7sungetcEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8in_availEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8overflowEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8pubimbueERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pbackfailEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pubsetbufEPwl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9showmanycEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9sputbackcEw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9underflowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1ERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2ERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEaSERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115future_categoryEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcE6__initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIcED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwE6__initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115numpunct_bynameIwED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutex4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutex6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutex8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutexC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutexC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutexD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115recursive_mutexD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__115system_categoryEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__check_groupingERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjS8_Rj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm16EED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm16EED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm16EED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm32EED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm32EED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116__narrow_to_utf8ILm32EED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__116generic_categoryEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state10__sub_waitERNS_11unique_lockINS_5mutexEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state12__make_readyEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state13set_exceptionESt13exception_ptr'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state16__on_zero_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state24set_value_at_thread_exitEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state28set_exception_at_thread_exitESt13exception_ptr'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state4copyEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state4waitEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state9__executeEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__assoc_sub_state9set_valueEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm16EED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm16EED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm16EED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm32EED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm32EED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117__widen_from_utf8ILm32EED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117declare_reachableEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117iostream_categoryEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117moneypunct_bynameIcLb0EE4initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117moneypunct_bynameIcLb1EE4initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117moneypunct_bynameIwLb0EE4initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__117moneypunct_bynameIwLb1EE4initEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcE4initERKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcE9__analyzeEcRKNS_5ctypeIcEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcEC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcEC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwE4initERKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwE9__analyzeEcRKNS_5ctypeIwEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwEC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwEC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118__time_get_storageIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variable10notify_allEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variable10notify_oneEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variable15__do_timed_waitERNS_11unique_lockINS_5mutexEEENS_6chrono10time_pointINS5_12system_clockENS5_8durationIxNS_5ratioILl1ELl1000000000EEEEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variable4waitERNS_11unique_lockINS_5mutexEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variableD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118condition_variableD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118get_pointer_safetyEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex11lock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex13unlock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex15try_lock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutex8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutexC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__118shared_timed_mutexC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base11lock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base13unlock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base15try_lock_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_base8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_baseC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_mutex_baseC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count10__add_weakEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count12__add_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count14__release_weakEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count16__release_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_count4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_countD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_countD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__shared_weak_countD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__119__start_std_streamsE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119__thread_local_dataEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__119declare_no_pointersEPcm'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__119piecewise_constructE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__120__get_collation_nameEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__120__throw_system_errorEiPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121__thread_specific_ptrINS_15__thread_structEE16__at_thread_exitEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121__throw_runtime_errorEPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121__undeclare_reachableEPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutex4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutex6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutex8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutexC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutexC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutexD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121recursive_timed_mutexD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__121undeclare_no_pointersEPcm'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__123__libcpp_debug_functionE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC1ERKNS_19__libcpp_debug_infoE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC1ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC2ERKNS_19__libcpp_debug_infoE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC2ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__124__libcpp_debug_exceptionD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__125notify_all_at_thread_exitERNS_18condition_variableENS_11unique_lockINS_5mutexEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIaaEEPaEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIccEEPcEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIddEEPdEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIeeEEPeEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIffEEPfEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIhhEEPhEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIiiEEPiEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIjjEEPjEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIllEEPlEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessImmEEPmEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIssEEPsEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIttEEPtEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIwwEEPwEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIxxEEPxEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIyyEEPyEEbT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__127__libcpp_set_debug_functionEPFvRKNS_19__libcpp_debug_infoEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__129__libcpp_abort_debug_functionERKNS_19__libcpp_debug_infoE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__129__libcpp_throw_debug_functionERKNS_19__libcpp_debug_infoE'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__13cinE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__14cerrE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__14clogE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__14coutE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stodERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stodERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stofERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stofERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stoiERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stoiERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stolERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__14stolERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__14wcinE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15alignEmmRPvRm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcE13classic_tableEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcEC1EPKjbm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcEC2EPKjbm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIcED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__15ctypeIwE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15ctypeIwED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15mutex4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15mutex6unlockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15mutex8try_lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15mutexD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15mutexD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stoldERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stoldERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stollERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stollERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stoulERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__15stoulERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__15wcerrE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__15wclogE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__15wcoutE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIaaEEPaEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIccEEPcEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIddEEPdEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIeeEEPeEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIffEEPfEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIhhEEPhEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIiiEEPiEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIjjEEPjEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIllEEPlEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessImmEEPmEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIssEEPsEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIttEEPtEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIwwEEPwEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIxxEEPxEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16__sortIRNS_6__lessIyyEEPyEEvT0_S5_T_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16chrono12steady_clock3nowEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16chrono12steady_clock9is_steadyE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16chrono12system_clock11from_time_tEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16chrono12system_clock3nowEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16chrono12system_clock9is_steadyE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16chrono12system_clock9to_time_tERKNS0_10time_pointIS1_NS0_8durationIxNS_5ratioILl1ELl1000000EEEEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16futureIvE3getEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16futureIvEC1EPNS_17__assoc_sub_stateE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16futureIvEC2EPNS_17__assoc_sub_stateE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16futureIvED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16futureIvED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16gslice6__initEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale14__install_ctorERKS0_PNS0_5facetEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale2id5__getEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale2id6__initEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale2id9__next_idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale3allE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale4noneE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale4timeE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale5ctypeE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale5facet16__on_zero_sharedEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale5facetD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale5facetD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale5facetD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale6globalERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale7classicEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale7collateE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale7numericE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16locale8__globalEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale8messagesE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__16locale8monetaryE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1ERKS0_PKci'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1ERKS0_S2_i'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2EPKc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2ERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2ERKS0_PKci'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2ERKS0_S2_i'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16localeaSERKS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16stoullERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16stoullERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16thread20hardware_concurrencyEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16thread4joinEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16thread6detachEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16threadD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__16threadD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17__sort5IRNS_6__lessIeeEEPeEEjT0_S5_S5_S5_S5_T_'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDic11__mbstate_tE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDic11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDic11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDic11__mbstate_tED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDsc11__mbstate_tE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDsc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDsc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIDsc11__mbstate_tED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17codecvtIcc11__mbstate_tE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIcc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIcc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIcc11__mbstate_tED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tEC1EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tEC1Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tEC2EPKcm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tEC2Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17codecvtIwc11__mbstate_tED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17collateIcE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIcED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17collateIwE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17collateIwED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvE10get_futureEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvE13set_exceptionESt13exception_ptr'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvE24set_value_at_thread_exitEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvE28set_exception_at_thread_exitESt13exception_ptr'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvE9set_valueEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvEC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvEC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__17promiseIvED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__c_node5__addEPNS_8__i_nodeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__c_nodeD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__c_nodeD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__c_nodeD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__get_dbEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__i_nodeD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__i_nodeD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__rs_getEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__sp_mut4lockEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18__sp_mut6unlockEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base10floatfieldE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base10scientificE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base11adjustfieldE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base15sync_with_stdioEb'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base16__call_callbacksENS0_5eventE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base17register_callbackEPFvNS0_5eventERS0_iEi'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base2inE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base33__set_badbit_and_consider_rethrowEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base34__set_failbit_and_consider_rethrowEv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3appE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3ateE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3decE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3hexE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3octE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base3outE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4InitC1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4InitC2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4InitD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4InitD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4initEPv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base4leftE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4moveERS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base4swapERS0_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base5clearEj'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base5fixedE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base5imbueERKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base5iwordEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base5pwordEi'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base5rightE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base5truncE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base6badbitE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base6binaryE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base6eofbitE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base6skipwsE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base6xallocEv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7copyfmtERKS0_'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failbitE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureC1EPKcRKNS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureC2EPKcRKNS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_base7failureD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base7goodbitE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base7showposE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base7unitbufE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base8internalE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base8showbaseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base9__xindex_E', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base9basefieldE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base9boolalphaE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base9showpointE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18ios_base9uppercaseE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_baseD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_baseD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18ios_baseD2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18messagesIcE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18messagesIwE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcEC1Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcEC2Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIcED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwEC1Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwEC2Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18numpunctIwED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18valarrayImE6resizeEmm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18valarrayImEC1Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18valarrayImEC2Em'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18valarrayImED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__18valarrayImED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIcE17__stage2_int_loopEciPcRS2_RjcRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_S2_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIcE17__stage2_int_prepERNS_8ios_baseEPcRc'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIcE19__stage2_float_loopEcRbRcPcRS4_ccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjS4_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIcE19__stage2_float_prepERNS_8ios_baseEPcRcS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIwE17__stage2_int_loopEwiPcRS2_RjwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_Pw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIwE17__stage2_int_prepERNS_8ios_baseEPwRw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIwE19__stage2_float_loopEwRbRcPcRS4_wwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjPw'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_getIwE19__stage2_float_prepERNS_8ios_baseEPwRwS5_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_putIcE21__widen_and_group_intEPcS2_S2_S2_RS2_S3_RKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_putIcE23__widen_and_group_floatEPcS2_S2_S2_RS2_S3_RKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_putIwE21__widen_and_group_intEPcS2_S2_PwRS3_S4_RKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19__num_putIwE23__widen_and_group_floatEPcS2_S2_PwRS3_S4_RKNS_6localeE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIcNS_11char_traitsIcEEE7copyfmtERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIcNS_11char_traitsIcEEED2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIwNS_11char_traitsIwEEE7copyfmtERKS3_'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19basic_iosIwNS_11char_traitsIwEEED2Ev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIcEERNS_10unique_ptrIcPFvPvEEERPcSM_'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIwEERNS_10unique_ptrIwPFvPvEEERPwSM_'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'size': 0}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19strstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19strstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19strstreamD2Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEd'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEe'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEf'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEi'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEj'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEl'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEx'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__19to_stringEy'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZNSt3__1plIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_12basic_stringIT_T0_T1_EEPKS6_RKS9_'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castC1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castC1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castC2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castC2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt8bad_castD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt8bad_castD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocC1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocC1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocC2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocC2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9bad_allocD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9bad_allocD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9exceptionD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9exceptionD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9exceptionD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9exceptionD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9exceptionD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9exceptionD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9type_infoD0Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9type_infoD0Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9type_infoD1Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9type_infoD1Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZNSt9type_infoD2Ev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZNSt9type_infoD2Ev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt10unexpectedv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt10unexpectedv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt13get_terminatev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt13get_terminatev'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt13set_terminatePFvvE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt13set_terminatePFvvE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt14get_unexpectedv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt14get_unexpectedv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt14set_unexpectedPFvvE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt14set_unexpectedPFvvE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt15get_new_handlerv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt15get_new_handlerv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt15set_new_handlerPFvvE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt15set_new_handlerPFvvE'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt17__throw_bad_allocv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt17current_exceptionv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt17rethrow_exceptionSt13exception_ptr'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt18uncaught_exceptionv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZSt19uncaught_exceptionsv'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZSt7nothrow', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZSt9terminatev'}
-{'type': 'I', 'is_defined': True, 'name': '__ZSt9terminatev'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__110istrstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__110ostrstreamE0_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE0_NS_13basic_istreamIcS2_EE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE16_NS_13basic_ostreamIcS2_EE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__19strstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__19strstreamE0_NS_14basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTCNSt3__19strstreamE16_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIDs'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt12experimental15fundamentals_v112bad_any_castE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt12experimental19bad_optional_accessE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110__time_getE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110__time_putE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110ctype_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110istrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110money_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110moneypunctIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110moneypunctIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110moneypunctIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110moneypunctIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__110ostrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__111__money_getIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__111__money_getIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__111__money_putIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__111__money_putIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__111regex_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112bad_weak_ptrE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112codecvt_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112ctype_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112ctype_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112future_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112strstreambufE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__112system_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__113messages_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__codecvt_utf8IDiEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__codecvt_utf8IDsEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__codecvt_utf8IwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__num_get_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__num_put_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114__shared_countE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114codecvt_bynameIDic11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114codecvt_bynameIcc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114codecvt_bynameIwc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114collate_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114collate_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__114error_categoryE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IDiLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IDiLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IDsLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IDsLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115__codecvt_utf16IwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115messages_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115messages_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115numpunct_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115numpunct_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__116__narrow_to_utf8ILm16EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__116__narrow_to_utf8ILm32EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117__assoc_sub_stateE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117__widen_from_utf8ILm16EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117__widen_from_utf8ILm32EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117moneypunct_bynameIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117moneypunct_bynameIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117moneypunct_bynameIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__117moneypunct_bynameIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__118__time_get_storageIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__118__time_get_storageIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__119__shared_weak_countE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__120__codecvt_utf8_utf16IDiEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__120__codecvt_utf8_utf16IDsEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__120__codecvt_utf8_utf16IwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__120__time_get_c_storageIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__120__time_get_c_storageIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__124__libcpp_debug_exceptionE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__15ctypeIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__15ctypeIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__16locale5facetE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17codecvtIDic11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17codecvtIDsc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17codecvtIcc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17codecvtIwc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17collateIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17collateIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18__c_nodeE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18ios_base7failureE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18ios_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18messagesIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18messagesIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18numpunctIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18numpunctIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19__num_getIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19__num_getIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19__num_putIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19__num_putIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19strstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTINSt3__19time_baseE', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPDs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKDs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKd'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKd'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPKy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPKy'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPd'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPd'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIPy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIPy'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt10bad_typeid'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt10bad_typeid'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt11logic_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt11logic_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt11range_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt11range_error'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt12bad_any_cast', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt12domain_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt12domain_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt12length_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt12length_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt12out_of_range'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt12out_of_range'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt13bad_exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt13bad_exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt13runtime_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt13runtime_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt14overflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt14overflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt15underflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt15underflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt16bad_array_length'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt16bad_array_length'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt16invalid_argument'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt16invalid_argument'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt16nested_exception', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt18bad_variant_access', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTISt19bad_optional_access', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt20bad_array_new_length'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt20bad_array_new_length'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt8bad_cast'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt8bad_cast'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt9bad_alloc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt9bad_alloc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt9exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt9exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTISt9type_info'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTISt9type_info'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTId'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTId'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTIy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTIy'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSDs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv116__enum_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv116__enum_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv117__array_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv117__array_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv117__class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv117__class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv117__pbase_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv117__pbase_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv119__pointer_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv119__pointer_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv120__function_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv120__function_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv120__si_class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv120__si_class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv121__vmi_class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv121__vmi_class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv123__fundamental_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv123__fundamental_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSN10__cxxabiv129__pointer_to_member_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSN10__cxxabiv129__pointer_to_member_type_infoE'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt12experimental15fundamentals_v112bad_any_castE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt12experimental19bad_optional_accessE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110ctype_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110istrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110money_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110moneypunctIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110moneypunctIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110moneypunctIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110moneypunctIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__110ostrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__111regex_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112bad_weak_ptrE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112codecvt_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112ctype_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112ctype_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112future_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112strstreambufE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__112system_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__113messages_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__114collate_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__114collate_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__114error_categoryE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115messages_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115messages_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115numpunct_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115numpunct_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__117moneypunct_bynameIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__117moneypunct_bynameIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__117moneypunct_bynameIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__117moneypunct_bynameIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__15ctypeIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__15ctypeIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__16locale5facetE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17codecvtIDic11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17codecvtIDsc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17codecvtIcc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17codecvtIwc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17collateIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17collateIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18__c_nodeE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18ios_base7failureE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18ios_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18messagesIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18messagesIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18numpunctIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18numpunctIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19__num_getIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19__num_getIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19__num_putIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19__num_putIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19strstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSNSt3__19time_baseE', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPDs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKDi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKDi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKDn'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKDn'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKDs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKDs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKd'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKd'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPKy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPKy'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPd'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPd'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSPy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSPy'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt10bad_typeid'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt10bad_typeid'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt11logic_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt11logic_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt11range_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt11range_error'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt12bad_any_cast', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt12domain_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt12domain_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt12length_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt12length_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt12out_of_range'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt12out_of_range'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt13bad_exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt13bad_exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt13runtime_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt13runtime_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt14overflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt14overflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt15underflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt15underflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt16bad_array_length'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt16bad_array_length'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt16invalid_argument'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt16invalid_argument'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt16nested_exception', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt18bad_variant_access', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTSSt19bad_optional_access', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt20bad_array_new_length'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt20bad_array_new_length'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt8bad_cast'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt8bad_cast'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt9bad_alloc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt9bad_alloc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt9exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt9exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSSt9type_info'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSSt9type_info'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSa'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSa'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSb'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSb'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSd'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSd'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSe'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSe'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSf'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSf'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSh'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSh'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSi'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSi'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSj'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSj'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSl'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSl'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSm'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSm'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSs'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSs'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSt'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSt'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSv'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSv'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSw'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSw'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSx'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSx'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTSy'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTSy'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__110istrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__110ostrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTTNSt3__19strstreamE', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv116__enum_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv116__enum_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv117__array_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv117__array_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv117__class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv117__class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv117__pbase_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv117__pbase_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv119__pointer_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv119__pointer_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv120__function_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv120__function_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv120__si_class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv120__si_class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv121__vmi_class_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv121__vmi_class_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv123__fundamental_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv123__fundamental_type_infoE'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVN10__cxxabiv129__pointer_to_member_type_infoE'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVN10__cxxabiv129__pointer_to_member_type_infoE'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt12experimental15fundamentals_v112bad_any_castE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt12experimental19bad_optional_accessE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110istrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110moneypunctIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110moneypunctIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110moneypunctIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110moneypunctIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__110ostrstreamE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__111regex_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112bad_weak_ptrE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112ctype_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112ctype_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112future_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112strstreambufE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__112system_errorE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114__codecvt_utf8IDiEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114__codecvt_utf8IDsEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114__codecvt_utf8IwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114__shared_countE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114codecvt_bynameIDic11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114codecvt_bynameIcc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114codecvt_bynameIwc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114collate_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114collate_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__114error_categoryE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IDiLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IDiLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IDsLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IDsLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115__codecvt_utf16IwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115messages_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115messages_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115numpunct_bynameIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115numpunct_bynameIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__116__narrow_to_utf8ILm16EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__116__narrow_to_utf8ILm32EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117__assoc_sub_stateE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117__widen_from_utf8ILm16EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117__widen_from_utf8ILm32EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117moneypunct_bynameIcLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117moneypunct_bynameIcLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117moneypunct_bynameIwLb0EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__117moneypunct_bynameIwLb1EEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__119__shared_weak_countE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__120__codecvt_utf8_utf16IDiEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__120__codecvt_utf8_utf16IDsEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__120__codecvt_utf8_utf16IwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__124__libcpp_debug_exceptionE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__15ctypeIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__15ctypeIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__16locale5facetE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17codecvtIDic11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17codecvtIDsc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17codecvtIcc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17codecvtIwc11__mbstate_tEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17collateIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17collateIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18__c_nodeE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18ios_base7failureE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18ios_baseE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18messagesIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18messagesIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18numpunctIcEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18numpunctIwEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVNSt3__19strstreamE', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt10bad_typeid'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt10bad_typeid'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt11logic_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt11logic_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt11range_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt11range_error'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt12bad_any_cast', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt12domain_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt12domain_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt12length_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt12length_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt12out_of_range'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt12out_of_range'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt13bad_exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt13bad_exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt13runtime_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt13runtime_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt14overflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt14overflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt15underflow_error'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt15underflow_error'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt16bad_array_length'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt16bad_array_length'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt16invalid_argument'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt16invalid_argument'}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt16nested_exception', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt18bad_variant_access', 'size': 0}
-{'type': 'OBJECT', 'is_defined': True, 'name': '__ZTVSt19bad_optional_access', 'size': 0}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt20bad_array_new_length'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt20bad_array_new_length'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt8bad_cast'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt8bad_cast'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt9bad_alloc'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt9bad_alloc'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt9exception'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt9exception'}
-{'type': 'U', 'is_defined': False, 'name': '__ZTVSt9type_info'}
-{'type': 'I', 'is_defined': True, 'name': '__ZTVSt9type_info'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__19strstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZThn16_NSt3__19strstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__110istrstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__110istrstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__110ostrstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__110ostrstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__19strstreamD0Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZTv0_n24_NSt3__19strstreamD1Ev'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvSt11align_val_tRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdaPvmSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPv'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvSt11align_val_tRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZdlPvmSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__Znam'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnamRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnamSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnamSt11align_val_tRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__Znwm'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnwmRKSt9nothrow_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnwmSt11align_val_t'}
-{'type': 'FUNC', 'is_defined': True, 'name': '__ZnwmSt11align_val_tRKSt9nothrow_t'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_allocate_exception'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_allocate_exception'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_atexit'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_bad_cast'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_bad_cast'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_bad_typeid'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_bad_typeid'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_begin_catch'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_begin_catch'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_call_unexpected'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_call_unexpected'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_current_exception_type'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_current_exception_type'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_current_primary_exception'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_decrement_exception_refcount'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_demangle'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_demangle'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_end_catch'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_end_catch'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_free_exception'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_free_exception'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_get_exception_ptr'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_get_exception_ptr'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_get_globals'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_get_globals'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_get_globals_fast'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_get_globals_fast'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_guard_abort'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_guard_abort'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_guard_acquire'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_guard_acquire'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_guard_release'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_guard_release'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_increment_exception_refcount'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_pure_virtual'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_pure_virtual'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_rethrow'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_rethrow'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_rethrow_primary_exception'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_throw'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_throw'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_uncaught_exception'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_cctor'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_cctor'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_cleanup'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_cleanup'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_ctor'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_ctor'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_delete'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_delete'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_delete2'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_delete2'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_delete3'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_delete3'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_dtor'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_dtor'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_new'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_new'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_new2'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_new2'}
-{'type': 'U', 'is_defined': False, 'name': '___cxa_vec_new3'}
-{'type': 'I', 'is_defined': True, 'name': '___cxa_vec_new3'}
-{'type': 'U', 'is_defined': False, 'name': '___dynamic_cast'}
-{'type': 'I', 'is_defined': True, 'name': '___dynamic_cast'}
-{'type': 'U', 'is_defined': False, 'name': '___gxx_personality_v0'}
-{'type': 'I', 'is_defined': True, 'name': '___gxx_personality_v0'}
diff --git a/lib/abi/5.0/x86_64-unknown-linux-gnu.abilist b/lib/abi/5.0/x86_64-unknown-linux-gnu.abilist
deleted file mode 100644
index d6fd52488a6f..000000000000
--- a/lib/abi/5.0/x86_64-unknown-linux-gnu.abilist
+++ /dev/null
@@ -1,1883 +0,0 @@
-{'is_defined': False, 'name': '_ZNKSt11logic_error4whatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt12bad_any_cast4whatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt12experimental15fundamentals_v112bad_any_cast4whatEv', 'type': 'FUNC'}
-{'is_defined': False, 'name': '_ZNKSt13runtime_error4whatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt16nested_exception14rethrow_nestedEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt18bad_variant_access4whatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt19bad_optional_access4whatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110__time_put8__do_putEPcRS1_PK2tmcc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110__time_put8__do_putEPwRS1_PK2tmcc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110error_code7messageEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE11do_groupingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE13do_neg_formatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE13do_pos_formatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE14do_curr_symbolEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE14do_frac_digitsEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE16do_decimal_pointEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE16do_negative_signEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE16do_positive_signEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb0EE16do_thousands_sepEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE11do_groupingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE13do_neg_formatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE13do_pos_formatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE14do_curr_symbolEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE14do_frac_digitsEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE16do_decimal_pointEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE16do_negative_signEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE16do_positive_signEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIcLb1EE16do_thousands_sepEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE11do_groupingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE13do_neg_formatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE13do_pos_formatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE14do_curr_symbolEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE14do_frac_digitsEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE16do_decimal_pointEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE16do_negative_signEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE16do_positive_signEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb0EE16do_thousands_sepEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE11do_groupingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE13do_neg_formatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE13do_pos_formatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE14do_curr_symbolEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE14do_frac_digitsEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE16do_decimal_pointEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE16do_negative_signEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE16do_positive_signEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__110moneypunctIwLb1EE16do_thousands_sepEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db15__decrementableEPKv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db15__find_c_from_iEPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db15__subscriptableEPKvl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db17__dereferenceableEPKv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db17__find_c_and_lockEPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db22__less_than_comparableEPKvS2_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db6unlockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db8__find_cEPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__111__libcpp_db9__addableEPKvl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112bad_weak_ptr4whatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE12find_last_ofEPKcmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE13find_first_ofEPKcmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE16find_last_not_ofEPKcmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE17find_first_not_ofEPKcmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEPKcmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEPKcmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmRKS5_mm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE12find_last_ofEPKwmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE13find_first_ofEPKwmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE16find_last_not_ofEPKwmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE17find_first_not_ofEPKwmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4copyEPwmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEPKwmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEwm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEPKwmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEwm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEPKw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKwm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmRKS5_mm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIcE10do_tolowerEPcPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIcE10do_tolowerEc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIcE10do_toupperEPcPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIcE10do_toupperEc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE10do_scan_isEtPKwS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE10do_tolowerEPwPKw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE10do_tolowerEw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE10do_toupperEPwPKw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE10do_toupperEw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE11do_scan_notEtPKwS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE5do_isEPKwS3_Pt', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE5do_isEtw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE8do_widenEPKcS3_Pw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE8do_widenEc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE9do_narrowEPKwS3_cPc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112ctype_bynameIwE9do_narrowEwc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__112strstreambuf6pcountEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__113random_device7entropyEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDiE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDiE11do_encodingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDiE13do_max_lengthEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDiE16do_always_noconvEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDiE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDsE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDsE11do_encodingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDsE13do_max_lengthEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDsE16do_always_noconvEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IDsE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IwE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IwE11do_encodingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IwE13do_max_lengthEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IwE16do_always_noconvEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114__codecvt_utf8IwE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114collate_bynameIcE10do_compareEPKcS3_S3_S3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114collate_bynameIcE12do_transformEPKcS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114collate_bynameIwE10do_compareEPKwS3_S3_S3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114collate_bynameIwE12do_transformEPKwS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114error_category10equivalentERKNS_10error_codeEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114error_category10equivalentEiRKNS_15error_conditionE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__114error_category23default_error_conditionEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE11do_encodingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE13do_max_lengthEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE16do_always_noconvEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE11do_encodingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE13do_max_lengthEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE16do_always_noconvEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDiLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE11do_encodingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE13do_max_lengthEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE16do_always_noconvEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE11do_encodingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE13do_max_lengthEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE16do_always_noconvEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IDsLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE11do_encodingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE13do_max_lengthEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE16do_always_noconvEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb0EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE11do_encodingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE13do_max_lengthEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE16do_always_noconvEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115__codecvt_utf16IwLb1EE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115basic_streambufIcNS_11char_traitsIcEEE6getlocEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115basic_streambufIwNS_11char_traitsIwEEE6getlocEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__115error_condition7messageEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE11do_groupingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE13do_neg_formatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE13do_pos_formatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE14do_curr_symbolEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE14do_frac_digitsEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE16do_decimal_pointEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE16do_negative_signEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE16do_positive_signEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb0EE16do_thousands_sepEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE11do_groupingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE13do_neg_formatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE13do_pos_formatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE14do_curr_symbolEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE14do_frac_digitsEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE16do_decimal_pointEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE16do_negative_signEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE16do_positive_signEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIcLb1EE16do_thousands_sepEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE11do_groupingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE13do_neg_formatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE13do_pos_formatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE14do_curr_symbolEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE14do_frac_digitsEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE16do_decimal_pointEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE16do_negative_signEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE16do_positive_signEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb0EE16do_thousands_sepEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE11do_groupingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE13do_neg_formatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE13do_pos_formatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE14do_curr_symbolEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE14do_frac_digitsEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE16do_decimal_pointEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE16do_negative_signEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE16do_positive_signEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__117moneypunct_bynameIwLb1EE16do_thousands_sepEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__118__time_get_storageIcE15__do_date_orderEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__118__time_get_storageIwE15__do_date_orderEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__119__shared_weak_count13__get_deleterERKSt9type_info', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE11do_encodingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE13do_max_lengthEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE16do_always_noconvEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDiE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE11do_encodingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE13do_max_lengthEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE16do_always_noconvEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IDsE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE10do_unshiftER11__mbstate_tPcS4_RS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE11do_encodingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE13do_max_lengthEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE16do_always_noconvEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__codecvt_utf8_utf16IwE9do_lengthER11__mbstate_tPKcS5_m', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIcE3__XEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIcE3__cEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIcE3__rEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIcE3__xEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIcE7__am_pmEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIcE7__weeksEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIcE8__monthsEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIwE3__XEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIwE3__cEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIwE3__rEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIwE3__xEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIwE7__am_pmEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIwE7__weeksEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__time_get_c_storageIwE8__monthsEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__120__vector_base_commonILb1EE20__throw_out_of_rangeEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__121__basic_string_commonILb1EE20__throw_out_of_rangeEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__123__match_any_but_newlineIcE6__execERNS_7__stateIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__123__match_any_but_newlineIwE6__execERNS_7__stateIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__124__libcpp_debug_exception4whatEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIcE10do_tolowerEPcPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIcE10do_tolowerEc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIcE10do_toupperEPcPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIcE10do_toupperEc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIcE8do_widenEPKcS3_Pc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIcE8do_widenEc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIcE9do_narrowEPKcS3_cPc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIcE9do_narrowEcc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE10do_scan_isEtPKwS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE10do_tolowerEPwPKw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE10do_tolowerEw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE10do_toupperEPwPKw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE10do_toupperEw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE11do_scan_notEtPKwS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE5do_isEPKwS3_Pt', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE5do_isEtw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE8do_widenEPKcS3_Pw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE8do_widenEc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE9do_narrowEPKwS3_cPc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__15ctypeIwE9do_narrowEwc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__16locale4nameEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__16locale9has_facetERNS0_2idE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__16locale9use_facetERNS0_2idE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__16localeeqERKS0_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE11do_encodingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE13do_max_lengthEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE16do_always_noconvEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE5do_inERS1_PKcS5_RS5_PDiS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE6do_outERS1_PKDiS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDic11__mbstate_tE9do_lengthERS1_PKcS5_m', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE11do_encodingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE13do_max_lengthEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE16do_always_noconvEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE5do_inERS1_PKcS5_RS5_PDsS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE6do_outERS1_PKDsS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIDsc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE11do_encodingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE13do_max_lengthEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE16do_always_noconvEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE5do_inERS1_PKcS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE6do_outERS1_PKcS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIcc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE11do_encodingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE13do_max_lengthEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE16do_always_noconvEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE5do_inERS1_PKcS5_RS5_PwS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE6do_outERS1_PKwS5_RS5_PcS7_RS7_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17codecvtIwc11__mbstate_tE9do_lengthERS1_PKcS5_m', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17collateIcE10do_compareEPKcS3_S3_S3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17collateIcE12do_transformEPKcS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17collateIcE7do_hashEPKcS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17collateIwE10do_compareEPKwS3_S3_S3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17collateIwE12do_transformEPKwS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17collateIwE7do_hashEPKwS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRb', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRd', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRe', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRf', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRt', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRx', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRy', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRb', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRd', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRe', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRf', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRt', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRx', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRy', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPKv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcb', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcd', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEce', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcx', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcy', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPKv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwb', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwd', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwe', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwx', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwy', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18ios_base6getlocEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18messagesIcE6do_getEliiRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18messagesIcE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18messagesIcE8do_closeEl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18messagesIwE6do_getEliiRKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18messagesIwE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18messagesIwE8do_closeEl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18numpunctIcE11do_groupingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18numpunctIcE11do_truenameEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18numpunctIcE12do_falsenameEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18numpunctIcE16do_decimal_pointEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18numpunctIcE16do_thousands_sepEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18numpunctIwE11do_groupingEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18numpunctIwE11do_truenameEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18numpunctIwE12do_falsenameEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18numpunctIwE16do_decimal_pointEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18numpunctIwE16do_thousands_sepEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13do_date_orderEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKcSC_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13do_date_orderEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKwSC_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE3putES4_RNS_8ios_baseEcPK2tmPKcSC_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPK2tmcc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE3putES4_RNS_8ios_baseEwPK2tmPKwSC_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPK2tmcc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIcS3_NS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIwS3_NS_9allocatorIwEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEcRKNS_12basic_stringIcS3_NS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEce', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwRKNS_12basic_stringIwS3_NS_9allocatorIwEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwe', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt11logic_errorC1EPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt11logic_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt11logic_errorC1ERKS_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt11logic_errorC2EPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt11logic_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt11logic_errorC2ERKS_', 'type': 'FUNC'}
-{'is_defined': False, 'name': '_ZNSt11logic_errorD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt11logic_erroraSERKS_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt12experimental19bad_optional_accessD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt12experimental19bad_optional_accessD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt12experimental19bad_optional_accessD2Ev', 'type': 'FUNC'}
-{'is_defined': False, 'name': '_ZNSt12length_errorD1Ev', 'type': 'FUNC'}
-{'is_defined': False, 'name': '_ZNSt12out_of_rangeD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt13exception_ptrC1ERKS_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt13exception_ptrC2ERKS_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt13exception_ptrD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt13exception_ptrD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt13exception_ptraSERKS_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt13runtime_errorC1EPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt13runtime_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt13runtime_errorC1ERKS_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt13runtime_errorC2EPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt13runtime_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt13runtime_errorC2ERKS_', 'type': 'FUNC'}
-{'is_defined': False, 'name': '_ZNSt13runtime_errorD1Ev', 'type': 'FUNC'}
-{'is_defined': False, 'name': '_ZNSt13runtime_errorD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt13runtime_erroraSERKS_', 'type': 'FUNC'}
-{'is_defined': False, 'name': '_ZNSt14overflow_errorD1Ev', 'type': 'FUNC'}
-{'is_defined': False, 'name': '_ZNSt16invalid_argumentD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt16nested_exceptionC1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt16nested_exceptionC2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt16nested_exceptionD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt16nested_exceptionD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt16nested_exceptionD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt19bad_optional_accessD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt19bad_optional_accessD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt19bad_optional_accessD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110__time_getC1EPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110__time_getC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110__time_getC2EPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110__time_getC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110__time_getD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110__time_getD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110__time_putC1EPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110__time_putC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110__time_putC2EPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110__time_putC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110__time_putD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110__time_putD2Ev', 'type': 'FUNC'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__110adopt_lockE', 'type': 'OBJECT'}
-{'size': 2, 'is_defined': True, 'name': '_ZNSt3__110ctype_base5alnumE', 'type': 'OBJECT'}
-{'size': 2, 'is_defined': True, 'name': '_ZNSt3__110ctype_base5alphaE', 'type': 'OBJECT'}
-{'size': 2, 'is_defined': True, 'name': '_ZNSt3__110ctype_base5blankE', 'type': 'OBJECT'}
-{'size': 2, 'is_defined': True, 'name': '_ZNSt3__110ctype_base5cntrlE', 'type': 'OBJECT'}
-{'size': 2, 'is_defined': True, 'name': '_ZNSt3__110ctype_base5digitE', 'type': 'OBJECT'}
-{'size': 2, 'is_defined': True, 'name': '_ZNSt3__110ctype_base5graphE', 'type': 'OBJECT'}
-{'size': 2, 'is_defined': True, 'name': '_ZNSt3__110ctype_base5lowerE', 'type': 'OBJECT'}
-{'size': 2, 'is_defined': True, 'name': '_ZNSt3__110ctype_base5printE', 'type': 'OBJECT'}
-{'size': 2, 'is_defined': True, 'name': '_ZNSt3__110ctype_base5punctE', 'type': 'OBJECT'}
-{'size': 2, 'is_defined': True, 'name': '_ZNSt3__110ctype_base5spaceE', 'type': 'OBJECT'}
-{'size': 2, 'is_defined': True, 'name': '_ZNSt3__110ctype_base5upperE', 'type': 'OBJECT'}
-{'size': 2, 'is_defined': True, 'name': '_ZNSt3__110ctype_base6xdigitE', 'type': 'OBJECT'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__110defer_lockE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__110istrstreamD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110istrstreamD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110istrstreamD2Ev', 'type': 'FUNC'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__110moneypunctIcLb0EE2idE', 'type': 'OBJECT'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__110moneypunctIcLb0EE4intlE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__110moneypunctIcLb1EE2idE', 'type': 'OBJECT'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__110moneypunctIcLb1EE4intlE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__110moneypunctIwLb0EE2idE', 'type': 'OBJECT'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__110moneypunctIwLb0EE4intlE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__110moneypunctIwLb1EE2idE', 'type': 'OBJECT'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__110moneypunctIwLb1EE4intlE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__110ostrstreamD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110ostrstreamD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110ostrstreamD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110to_wstringEd', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110to_wstringEe', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110to_wstringEf', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110to_wstringEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110to_wstringEj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110to_wstringEl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110to_wstringEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110to_wstringEx', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__110to_wstringEy', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__call_onceERVmPvPFvS2_E', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__libcpp_db10__insert_cEPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__libcpp_db10__insert_iEPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__libcpp_db11__insert_icEPvPKv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__libcpp_db15__iterator_copyEPvPKv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__libcpp_db16__invalidate_allEPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__libcpp_db4swapEPvS1_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__libcpp_db9__erase_cEPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__libcpp_db9__erase_iEPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__libcpp_dbC1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__libcpp_dbC2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__libcpp_dbD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__libcpp_dbD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__money_getIcE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_SF_Ri', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__money_getIwE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_SJ_Ri', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__money_putIcE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_Ri', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__money_putIcE8__formatEPcRS2_S3_jPKcS5_RKNS_5ctypeIcEEbRKNS_10money_base7patternEccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESL_SL_i', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__money_putIwE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_Ri', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111__money_putIwE8__formatEPwRS2_S3_jPKwS5_RKNS_5ctypeIwEEbRKNS_10money_base7patternEwwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNSE_IwNSF_IwEENSH_IwEEEESQ_i', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111regex_errorC1ENS_15regex_constants10error_typeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111regex_errorC2ENS_15regex_constants10error_typeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111regex_errorD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111regex_errorD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111regex_errorD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111this_thread9sleep_forERKNS_6chrono8durationIxNS_5ratioILl1ELl1000000000EEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111timed_mutex4lockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111timed_mutex6unlockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111timed_mutex8try_lockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111timed_mutexC1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111timed_mutexC2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111timed_mutexD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__111timed_mutexD2Ev', 'type': 'FUNC'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__111try_to_lockE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__112__do_nothingEPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112__get_sp_mutEPKv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112__next_primeEm', 'type': 'FUNC'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__112__rs_default4__c_E', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__112__rs_defaultC1ERKS0_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112__rs_defaultC1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112__rs_defaultC2ERKS0_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112__rs_defaultC2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112__rs_defaultD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112__rs_defaultD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112__rs_defaultclEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112bad_weak_ptrD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112bad_weak_ptrD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112bad_weak_ptrD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE21__grow_by_and_replaceEmmmmmmPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm', 'type': 'FUNC'}
-{'size': 8, 'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4nposE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5eraseEmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEmc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendERKS5_mm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEmc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignERKS5_mm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEmc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertENS_11__wrap_iterIPKcEEc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmRKS5_mm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmmc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6resizeEmc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmRKS5_mm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmmc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEmmmmmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9push_backEc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_RKS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_mmRKS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_RKS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_mmRKS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSERKS5_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSEc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE21__grow_by_and_replaceEmmmmmmPKw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm', 'type': 'FUNC'}
-{'size': 8, 'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4nposE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5eraseEmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEmw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKwm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendERKS5_mm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEmw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKwm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignERKS5_mm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEmw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertENS_11__wrap_iterIPKwEEw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKwm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmRKS5_mm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmmw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6resizeEmw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKwm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmRKS5_mm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmmw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7reserveEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9__grow_byEmmmmmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9push_backEw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_RKS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_mmRKS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_RKS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_mmRKS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSERKS5_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSEw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIcEC1EPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIcEC2EPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIcED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIcED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIcED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIwEC1EPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIwEC2EPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIwED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIwED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112ctype_bynameIwED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112future_errorC1ENS_10error_codeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112future_errorC2ENS_10error_codeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112future_errorD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112future_errorD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112future_errorD2Ev', 'type': 'FUNC'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__112placeholders2_1E', 'type': 'OBJECT'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__112placeholders2_2E', 'type': 'OBJECT'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__112placeholders2_3E', 'type': 'OBJECT'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__112placeholders2_4E', 'type': 'OBJECT'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__112placeholders2_5E', 'type': 'OBJECT'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__112placeholders2_6E', 'type': 'OBJECT'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__112placeholders2_7E', 'type': 'OBJECT'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__112placeholders2_8E', 'type': 'OBJECT'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__112placeholders2_9E', 'type': 'OBJECT'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__112placeholders3_10E', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambuf3strEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambuf4swapERS0_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambuf6__initEPclS1_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambuf6freezeEb', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambuf7seekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambuf7seekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambuf8overflowEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambuf9pbackfailEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambuf9underflowEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufC1EPFPvmEPFvS1_E', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufC1EPKal', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufC1EPKcl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufC1EPKhl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufC1EPalS1_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufC1EPclS1_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufC1EPhlS1_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufC1El', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufC2EPFPvmEPFvS1_E', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufC2EPKal', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufC2EPKcl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufC2EPKhl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufC2EPalS1_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufC2EPclS1_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufC2EPhlS1_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufC2El', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112strstreambufD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112system_error6__initERKNS_10error_codeENS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112system_errorC1ENS_10error_codeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112system_errorC1ENS_10error_codeEPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112system_errorC1ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112system_errorC1EiRKNS_14error_categoryE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112system_errorC1EiRKNS_14error_categoryEPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112system_errorC1EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112system_errorC2ENS_10error_codeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112system_errorC2ENS_10error_codeEPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112system_errorC2ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112system_errorC2EiRKNS_14error_categoryE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112system_errorC2EiRKNS_14error_categoryEPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112system_errorC2EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112system_errorD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112system_errorD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__112system_errorD2Ev', 'type': 'FUNC'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__113allocator_argE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPcl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPclc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EEc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4peekEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4readEPcl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4swapERS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4syncEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgENS_4fposI11__mbstate_tEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgExNS_8ios_base7seekdirE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5tellgEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5ungetEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6ignoreEli', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC1ERS3_b', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC2ERS3_b', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPcl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPclc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7putbackEc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE8readsomeEPcl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_8ios_baseES5_E', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_9basic_iosIcS2_EES6_E', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRS3_S4_E', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERb', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERd', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERe', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERf', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERs', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERt', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERx', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERy', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwlw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EEw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4peekEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4readEPwl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4swapERS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4syncEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgENS_4fposI11__mbstate_tEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgExNS_8ios_base7seekdirE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5tellgEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5ungetEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6ignoreElj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC1ERS3_b', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC2ERS3_b', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwlw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7putbackEw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE8readsomeEPwl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_8ios_baseES5_E', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_9basic_iosIwS2_EES6_E', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRS3_S4_E', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERb', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERd', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERe', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERf', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERs', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERt', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERx', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERy', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE3putEc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE4swapERS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5flushEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpENS_4fposI11__mbstate_tEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpExNS_8ios_base7seekdirE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5tellpEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5writeEPKcl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC1ERS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC2ERS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_8ios_baseES5_E', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_9basic_iosIcS2_EES6_E', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRS3_S4_E', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPKv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEb', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEd', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEe', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEf', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEs', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEt', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEx', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEy', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE3putEw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE4swapERS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5flushEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpENS_4fposI11__mbstate_tEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpExNS_8ios_base7seekdirE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5tellpEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5writeEPKwl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC1ERS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC2ERS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_8ios_baseES5_E', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_9basic_iosIwS2_EES6_E', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRS3_S4_E', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPKv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPNS_15basic_streambufIwS2_EE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEb', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEd', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEe', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEf', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEs', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEt', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEx', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEy', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113random_deviceC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113random_deviceC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113random_deviceD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113random_deviceD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113random_deviceclEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113shared_futureIvED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113shared_futureIvED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__113shared_futureIvEaSERKS1_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114__get_const_dbEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114__num_get_base10__get_baseERNS_8ios_baseE', 'type': 'FUNC'}
-{'size': 33, 'is_defined': True, 'name': '_ZNSt3__114__num_get_base5__srcE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__114__num_put_base12__format_intEPcPKcbj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114__num_put_base14__format_floatEPcPKcj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114__num_put_base18__identify_paddingEPcS1_RKNS_8ios_baseE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114__shared_count12__add_sharedEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114__shared_count16__release_sharedEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114__shared_countD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114__shared_countD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114__shared_countD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEE4swapERS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIDic11__mbstate_tED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIDic11__mbstate_tED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIDic11__mbstate_tED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIDsc11__mbstate_tED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIDsc11__mbstate_tED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIDsc11__mbstate_tED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIcc11__mbstate_tED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIcc11__mbstate_tED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIcc11__mbstate_tED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIwc11__mbstate_tED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIwc11__mbstate_tED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114codecvt_bynameIwc11__mbstate_tED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIcEC1EPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIcEC2EPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIcED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIcED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIcED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIwEC1EPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIwEC2EPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIwED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIwED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114collate_bynameIwED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114error_categoryC2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114error_categoryD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114error_categoryD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__114error_categoryD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115__get_classnameEPKcb', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115__thread_struct25notify_all_at_thread_exitEPNS_18condition_variableEPNS_5mutexE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115__thread_struct27__make_ready_at_thread_exitEPNS_17__assoc_sub_stateE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115__thread_structC1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115__thread_structC2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115__thread_structD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115__thread_structD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setgEPcS4_S4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setpEPcS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4swapERS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4syncEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5gbumpEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5pbumpEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetcEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetnEPcl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputcEc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputnEPKcl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5uflowEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6sbumpcEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6setbufEPcl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6snextcEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsgetnEPcl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsputnEPKcl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7pubsyncEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7sungetcEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8in_availEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8overflowEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8pubimbueERKNS_6localeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pbackfailEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pubsetbufEPcl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9showmanycEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9sputbackcEc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9underflowEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1ERKS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2ERKS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEaSERKS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setgEPwS4_S4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setpEPwS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4swapERS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4syncEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5gbumpEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5imbueERKNS_6localeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5pbumpEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetcEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetnEPwl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputcEw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputnEPKwl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5uflowEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6sbumpcEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6setbufEPwl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6snextcEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsgetnEPwl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsputnEPKwl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7pubsyncEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekoffExNS_8ios_base7seekdirEj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekposENS_4fposI11__mbstate_tEEj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7sungetcEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8in_availEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8overflowEj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8pubimbueERKNS_6localeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pbackfailEj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pubsetbufEPwl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9showmanycEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9sputbackcEw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9underflowEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1ERKS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2ERKS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEaSERKS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115future_categoryEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIcE6__initEPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIcEC1EPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIcEC2EPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIcED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIcED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIcED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIwE6__initEPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIwEC1EPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIwEC2EPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIwED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIwED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115numpunct_bynameIwED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115recursive_mutex4lockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115recursive_mutex6unlockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115recursive_mutex8try_lockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115recursive_mutexC1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115recursive_mutexC2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115recursive_mutexD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115recursive_mutexD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__115system_categoryEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__116__check_groupingERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjS8_Rj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__116__narrow_to_utf8ILm16EED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__116__narrow_to_utf8ILm16EED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__116__narrow_to_utf8ILm16EED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__116__narrow_to_utf8ILm32EED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__116__narrow_to_utf8ILm32EED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__116__narrow_to_utf8ILm32EED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__116generic_categoryEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state10__sub_waitERNS_11unique_lockINS_5mutexEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state12__make_readyEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state13set_exceptionESt13exception_ptr', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state16__on_zero_sharedEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state24set_value_at_thread_exitEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state28set_exception_at_thread_exitESt13exception_ptr', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state4copyEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state4waitEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state9__executeEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117__assoc_sub_state9set_valueEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117__widen_from_utf8ILm16EED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117__widen_from_utf8ILm16EED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117__widen_from_utf8ILm16EED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117__widen_from_utf8ILm32EED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117__widen_from_utf8ILm32EED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117__widen_from_utf8ILm32EED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117declare_reachableEPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117iostream_categoryEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIcLb0EE4initEPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIcLb1EE4initEPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIwLb0EE4initEPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__117moneypunct_bynameIwLb1EE4initEPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcE4initERKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcE9__analyzeEcRKNS_5ctypeIcEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC1EPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC2EPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwE4initERKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwE9__analyzeEcRKNS_5ctypeIwEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwEC1EPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwEC2EPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118__time_get_storageIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118condition_variable10notify_allEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118condition_variable10notify_oneEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118condition_variable15__do_timed_waitERNS_11unique_lockINS_5mutexEEENS_6chrono10time_pointINS5_12system_clockENS5_8durationIxNS_5ratioILl1ELl1000000000EEEEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118condition_variable4waitERNS_11unique_lockINS_5mutexEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118condition_variableD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118condition_variableD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118get_pointer_safetyEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118shared_timed_mutex11lock_sharedEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118shared_timed_mutex13unlock_sharedEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118shared_timed_mutex15try_lock_sharedEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118shared_timed_mutex4lockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118shared_timed_mutex6unlockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118shared_timed_mutex8try_lockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118shared_timed_mutexC1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__118shared_timed_mutexC2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119__shared_mutex_base11lock_sharedEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119__shared_mutex_base13unlock_sharedEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119__shared_mutex_base15try_lock_sharedEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119__shared_mutex_base4lockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119__shared_mutex_base6unlockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119__shared_mutex_base8try_lockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119__shared_mutex_baseC1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119__shared_mutex_baseC2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119__shared_weak_count10__add_weakEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119__shared_weak_count12__add_sharedEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119__shared_weak_count14__release_weakEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119__shared_weak_count16__release_sharedEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119__shared_weak_count4lockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119__shared_weak_countD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119__shared_weak_countD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119__shared_weak_countD2Ev', 'type': 'FUNC'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__119__start_std_streamsE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__119__thread_local_dataEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__119declare_no_pointersEPcm', 'type': 'FUNC'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__119piecewise_constructE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__120__get_collation_nameEPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__120__throw_system_errorEiPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__121__thread_specific_ptrINS_15__thread_structEE16__at_thread_exitEPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__121__throw_runtime_errorEPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__121__undeclare_reachableEPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__121recursive_timed_mutex4lockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__121recursive_timed_mutex6unlockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__121recursive_timed_mutex8try_lockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__121recursive_timed_mutexC1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__121recursive_timed_mutexC2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__121recursive_timed_mutexD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__121recursive_timed_mutexD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__121undeclare_no_pointersEPcm', 'type': 'FUNC'}
-{'size': 8, 'is_defined': True, 'name': '_ZNSt3__123__libcpp_debug_functionE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionC1ERKNS_19__libcpp_debug_infoE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionC1ERKS0_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionC1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionC2ERKNS_19__libcpp_debug_infoE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionC2ERKS0_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionC2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__124__libcpp_debug_exceptionD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__125__num_get_signed_integralIlEET_PKcS3_Rji', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__125__num_get_signed_integralIxEET_PKcS3_Rji', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__125notify_all_at_thread_exitERNS_18condition_variableENS_11unique_lockINS_5mutexEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIaaEEPaEEbT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIccEEPcEEbT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIddEEPdEEbT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIeeEEPeEEbT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIffEEPfEEbT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIhhEEPhEEbT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIiiEEPiEEbT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIjjEEPjEEbT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIllEEPlEEbT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessImmEEPmEEbT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIssEEPsEEbT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIttEEPtEEbT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIwwEEPwEEbT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIxxEEPxEEbT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIyyEEPyEEbT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__libcpp_set_debug_functionEPFvRKNS_19__libcpp_debug_infoEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__num_get_unsigned_integralIjEET_PKcS3_Rji', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__num_get_unsigned_integralImEET_PKcS3_Rji', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__num_get_unsigned_integralItEET_PKcS3_Rji', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__127__num_get_unsigned_integralIyEET_PKcS3_Rji', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__129__libcpp_abort_debug_functionERKNS_19__libcpp_debug_infoE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__129__libcpp_throw_debug_functionERKNS_19__libcpp_debug_infoE', 'type': 'FUNC'}
-{'size': 168, 'is_defined': True, 'name': '_ZNSt3__13cinE', 'type': 'OBJECT'}
-{'size': 160, 'is_defined': True, 'name': '_ZNSt3__14cerrE', 'type': 'OBJECT'}
-{'size': 160, 'is_defined': True, 'name': '_ZNSt3__14clogE', 'type': 'OBJECT'}
-{'size': 160, 'is_defined': True, 'name': '_ZNSt3__14coutE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__14stodERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__14stodERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__14stofERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__14stofERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__14stoiERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__14stoiERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__14stolERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__14stolERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
-{'size': 168, 'is_defined': True, 'name': '_ZNSt3__14wcinE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__15alignEmmRPvRm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15ctypeIcE13classic_tableEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15ctypeIcE21__classic_lower_tableEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15ctypeIcE21__classic_upper_tableEv', 'type': 'FUNC'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__15ctypeIcE2idE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__15ctypeIcEC1EPKtbm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15ctypeIcEC2EPKtbm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15ctypeIcED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15ctypeIcED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15ctypeIcED2Ev', 'type': 'FUNC'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__15ctypeIwE2idE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__15ctypeIwED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15ctypeIwED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15ctypeIwED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15mutex4lockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15mutex6unlockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15mutex8try_lockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15mutexD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15mutexD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15stoldERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15stoldERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15stollERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15stollERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15stoulERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__15stoulERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
-{'size': 160, 'is_defined': True, 'name': '_ZNSt3__15wcerrE', 'type': 'OBJECT'}
-{'size': 160, 'is_defined': True, 'name': '_ZNSt3__15wclogE', 'type': 'OBJECT'}
-{'size': 160, 'is_defined': True, 'name': '_ZNSt3__15wcoutE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__16__clocEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIaaEEPaEEvT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIccEEPcEEvT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIddEEPdEEvT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIeeEEPeEEvT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIffEEPfEEvT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIhhEEPhEEvT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIiiEEPiEEvT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIjjEEPjEEvT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIllEEPlEEvT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessImmEEPmEEvT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIssEEPsEEvT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIttEEPtEEvT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIwwEEPwEEvT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIxxEEPxEEvT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16__sortIRNS_6__lessIyyEEPyEEvT0_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16chrono12steady_clock3nowEv', 'type': 'FUNC'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__16chrono12steady_clock9is_steadyE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__16chrono12system_clock11from_time_tEl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16chrono12system_clock3nowEv', 'type': 'FUNC'}
-{'size': 1, 'is_defined': True, 'name': '_ZNSt3__16chrono12system_clock9is_steadyE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__16chrono12system_clock9to_time_tERKNS0_10time_pointIS1_NS0_8durationIxNS_5ratioILl1ELl1000000EEEEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16futureIvE3getEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16futureIvEC1EPNS_17__assoc_sub_stateE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16futureIvEC2EPNS_17__assoc_sub_stateE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16futureIvED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16futureIvED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16gslice6__initEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16locale14__install_ctorERKS0_PNS0_5facetEl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16locale2id5__getEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16locale2id6__initEv', 'type': 'FUNC'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__16locale2id9__next_idE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__16locale3allE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__16locale4noneE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__16locale4timeE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__16locale5ctypeE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__16locale5facet16__on_zero_sharedEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16locale5facetD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16locale5facetD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16locale5facetD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16locale6globalERKS0_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16locale7classicEv', 'type': 'FUNC'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__16locale7collateE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__16locale7numericE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__16locale8__globalEv', 'type': 'FUNC'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__16locale8messagesE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__16locale8monetaryE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__16localeC1EPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16localeC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16localeC1ERKS0_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16localeC1ERKS0_PKci', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16localeC1ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16localeC1ERKS0_S2_i', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16localeC1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16localeC2EPKc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16localeC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16localeC2ERKS0_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16localeC2ERKS0_PKci', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16localeC2ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16localeC2ERKS0_S2_i', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16localeC2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16localeD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16localeD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16localeaSERKS0_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16stoullERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16stoullERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16thread20hardware_concurrencyEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16thread4joinEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16thread6detachEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16threadD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__16threadD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17__sort5IRNS_6__lessIaaEEPaEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17__sort5IRNS_6__lessIccEEPcEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17__sort5IRNS_6__lessIddEEPdEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17__sort5IRNS_6__lessIeeEEPeEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17__sort5IRNS_6__lessIffEEPfEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17__sort5IRNS_6__lessIhhEEPhEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17__sort5IRNS_6__lessIiiEEPiEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17__sort5IRNS_6__lessIjjEEPjEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17__sort5IRNS_6__lessIllEEPlEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17__sort5IRNS_6__lessImmEEPmEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17__sort5IRNS_6__lessIssEEPsEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17__sort5IRNS_6__lessIttEEPtEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17__sort5IRNS_6__lessIwwEEPwEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17__sort5IRNS_6__lessIxxEEPxEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17__sort5IRNS_6__lessIyyEEPyEEjT0_S5_S5_S5_S5_T_', 'type': 'FUNC'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__17codecvtIDic11__mbstate_tE2idE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__17codecvtIDic11__mbstate_tED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17codecvtIDic11__mbstate_tED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17codecvtIDic11__mbstate_tED2Ev', 'type': 'FUNC'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__17codecvtIDsc11__mbstate_tE2idE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__17codecvtIDsc11__mbstate_tED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17codecvtIDsc11__mbstate_tED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17codecvtIDsc11__mbstate_tED2Ev', 'type': 'FUNC'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__17codecvtIcc11__mbstate_tE2idE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__17codecvtIcc11__mbstate_tED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17codecvtIcc11__mbstate_tED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17codecvtIcc11__mbstate_tED2Ev', 'type': 'FUNC'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__17codecvtIwc11__mbstate_tE2idE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__17codecvtIwc11__mbstate_tEC1EPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17codecvtIwc11__mbstate_tEC1Em', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17codecvtIwc11__mbstate_tEC2EPKcm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17codecvtIwc11__mbstate_tEC2Em', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17codecvtIwc11__mbstate_tED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17codecvtIwc11__mbstate_tED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17codecvtIwc11__mbstate_tED2Ev', 'type': 'FUNC'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__17collateIcE2idE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__17collateIcED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17collateIcED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17collateIcED2Ev', 'type': 'FUNC'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__17collateIwE2idE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__17collateIwED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17collateIwED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17collateIwED2Ev', 'type': 'FUNC'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__17promiseIvE10get_futureEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17promiseIvE13set_exceptionESt13exception_ptr', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17promiseIvE24set_value_at_thread_exitEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17promiseIvE28set_exception_at_thread_exitESt13exception_ptr', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17promiseIvE9set_valueEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17promiseIvEC1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17promiseIvEC2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17promiseIvED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__17promiseIvED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18__c_node5__addEPNS_8__i_nodeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18__c_nodeD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18__c_nodeD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18__c_nodeD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18__get_dbEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18__i_nodeD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18__i_nodeD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18__rs_getEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18__sp_mut4lockEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18__sp_mut6unlockEv', 'type': 'FUNC'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base10floatfieldE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base10scientificE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base11adjustfieldE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base15sync_with_stdioEb', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base16__call_callbacksENS0_5eventE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base17register_callbackEPFvNS0_5eventERS0_iEi', 'type': 'FUNC'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base2inE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base33__set_badbit_and_consider_rethrowEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base34__set_failbit_and_consider_rethrowEv', 'type': 'FUNC'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base3appE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base3ateE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base3decE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base3hexE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base3octE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base3outE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base4InitC1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base4InitC2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base4InitD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base4InitD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base4initEPv', 'type': 'FUNC'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base4leftE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base4moveERS0_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base4swapERS0_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base5clearEj', 'type': 'FUNC'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base5fixedE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base5imbueERKNS_6localeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base5iwordEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base5pwordEi', 'type': 'FUNC'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base5rightE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base5truncE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base6badbitE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base6binaryE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base6eofbitE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base6skipwsE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base6xallocEv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base7copyfmtERKS0_', 'type': 'FUNC'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base7failbitE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base7failureC1EPKcRKNS_10error_codeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base7failureC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base7failureC2EPKcRKNS_10error_codeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base7failureC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base7failureD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base7failureD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_base7failureD2Ev', 'type': 'FUNC'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base7goodbitE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base7showposE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base7unitbufE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base8internalE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base8showbaseE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base9__xindex_E', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base9basefieldE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base9boolalphaE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base9showpointE', 'type': 'OBJECT'}
-{'size': 4, 'is_defined': True, 'name': '_ZNSt3__18ios_base9uppercaseE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_baseD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_baseD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18ios_baseD2Ev', 'type': 'FUNC'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__18messagesIcE2idE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__18messagesIwE2idE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__18numpunctIcE2idE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__18numpunctIcEC1Em', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18numpunctIcEC2Em', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18numpunctIcED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18numpunctIcED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18numpunctIcED2Ev', 'type': 'FUNC'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__18numpunctIwE2idE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__18numpunctIwEC1Em', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18numpunctIwEC2Em', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18numpunctIwED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18numpunctIwED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18numpunctIwED2Ev', 'type': 'FUNC'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__18valarrayImE6resizeEmm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18valarrayImEC1Em', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18valarrayImEC2Em', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18valarrayImED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__18valarrayImED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19__num_getIcE17__stage2_int_loopEciPcRS2_RjcRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_S2_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19__num_getIcE17__stage2_int_prepERNS_8ios_baseEPcRc', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19__num_getIcE19__stage2_float_loopEcRbRcPcRS4_ccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjS4_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19__num_getIcE19__stage2_float_prepERNS_8ios_baseEPcRcS5_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19__num_getIwE17__stage2_int_loopEwiPcRS2_RjwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_Pw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19__num_getIwE17__stage2_int_prepERNS_8ios_baseEPwRw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19__num_getIwE19__stage2_float_loopEwRbRcPcRS4_wwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjPw', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19__num_getIwE19__stage2_float_prepERNS_8ios_baseEPwRwS5_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19__num_putIcE21__widen_and_group_intEPcS2_S2_S2_RS2_S3_RKNS_6localeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19__num_putIcE23__widen_and_group_floatEPcS2_S2_S2_RS2_S3_RKNS_6localeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19__num_putIwE21__widen_and_group_intEPcS2_S2_PwRS3_S4_RKNS_6localeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19__num_putIwE23__widen_and_group_floatEPcS2_S2_PwRS3_S4_RKNS_6localeE', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19basic_iosIcNS_11char_traitsIcEEE7copyfmtERKS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19basic_iosIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19basic_iosIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19basic_iosIcNS_11char_traitsIcEEED2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19basic_iosIwNS_11char_traitsIwEEE7copyfmtERKS3_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19basic_iosIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19basic_iosIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19basic_iosIwNS_11char_traitsIwEEED2Ev', 'type': 'FUNC'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIcEERNS_10unique_ptrIcPFvPvEEERPcSM_', 'type': 'FUNC'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIwEERNS_10unique_ptrIwPFvPvEEERPwSM_', 'type': 'FUNC'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE2idE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE2idE', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZNSt3__19strstreamD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19strstreamD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19strstreamD2Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19to_stringEd', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19to_stringEe', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19to_stringEf', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19to_stringEi', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19to_stringEj', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19to_stringEl', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19to_stringEm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19to_stringEx', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__19to_stringEy', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__1plIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_12basic_stringIT_T0_T1_EEPKS6_RKS9_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZNSt3__1plIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_12basic_stringIT_T0_T1_EERKS9_PKS6_', 'type': 'FUNC'}
-{'is_defined': False, 'name': '_ZNSt8bad_castC1Ev', 'type': 'FUNC'}
-{'is_defined': False, 'name': '_ZNSt8bad_castD1Ev', 'type': 'FUNC'}
-{'is_defined': False, 'name': '_ZNSt8bad_castD2Ev', 'type': 'FUNC'}
-{'is_defined': False, 'name': '_ZNSt9bad_allocC1Ev', 'type': 'FUNC'}
-{'is_defined': False, 'name': '_ZNSt9bad_allocD1Ev', 'type': 'FUNC'}
-{'is_defined': False, 'name': '_ZNSt9exceptionD2Ev', 'type': 'FUNC'}
-{'is_defined': False, 'name': '_ZSt15get_new_handlerv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZSt17__throw_bad_allocv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZSt17current_exceptionv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZSt17rethrow_exceptionSt13exception_ptr', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZSt18make_exception_ptrINSt3__112future_errorEESt13exception_ptrT_', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZSt18uncaught_exceptionv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZSt19uncaught_exceptionsv', 'type': 'FUNC'}
-{'size': 1, 'is_defined': True, 'name': '_ZSt7nothrow', 'type': 'OBJECT'}
-{'is_defined': False, 'name': '_ZSt9terminatev', 'type': 'FUNC'}
-{'size': 80, 'is_defined': True, 'name': '_ZTCNSt3__110istrstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 80, 'is_defined': True, 'name': '_ZTCNSt3__110ostrstreamE0_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 80, 'is_defined': True, 'name': '_ZTCNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE0_NS_13basic_istreamIcS2_EE', 'type': 'OBJECT'}
-{'size': 80, 'is_defined': True, 'name': '_ZTCNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE16_NS_13basic_ostreamIcS2_EE', 'type': 'OBJECT'}
-{'size': 80, 'is_defined': True, 'name': '_ZTCNSt3__19strstreamE0_NS_13basic_istreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 120, 'is_defined': True, 'name': '_ZTCNSt3__19strstreamE0_NS_14basic_iostreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 80, 'is_defined': True, 'name': '_ZTCNSt3__19strstreamE16_NS_13basic_ostreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt12experimental15fundamentals_v112bad_any_castE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt12experimental19bad_optional_accessE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__110__time_getE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__110__time_putE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__110ctype_baseE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__110istrstreamE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__110money_baseE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__110moneypunctIcLb0EEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__110moneypunctIcLb1EEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__110moneypunctIwLb0EEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__110moneypunctIwLb1EEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__110ostrstreamE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__111__money_getIcEE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__111__money_getIwEE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__111__money_putIcEE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__111__money_putIwEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__111regex_errorE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__112bad_weak_ptrE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__112codecvt_baseE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__112ctype_bynameIcEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__112ctype_bynameIwEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__112future_errorE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__112strstreambufE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__112system_errorE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTINSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTINSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTINSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTINSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__113messages_baseE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__114__codecvt_utf8IDiEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__114__codecvt_utf8IDsEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__114__codecvt_utf8IwEE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__114__num_get_baseE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__114__num_put_baseE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__114__shared_countE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__114codecvt_bynameIDic11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__114codecvt_bynameIcc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__114codecvt_bynameIwc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__114collate_bynameIcEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__114collate_bynameIwEE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__114error_categoryE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__115__codecvt_utf16IDiLb0EEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__115__codecvt_utf16IDiLb1EEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__115__codecvt_utf16IDsLb0EEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__115__codecvt_utf16IDsLb1EEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__115__codecvt_utf16IwLb0EEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__115__codecvt_utf16IwLb1EEE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__115messages_bynameIcEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__115messages_bynameIwEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__115numpunct_bynameIcEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__115numpunct_bynameIwEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__116__narrow_to_utf8ILm16EEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__116__narrow_to_utf8ILm32EEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__117__assoc_sub_stateE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__117__widen_from_utf8ILm16EEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__117__widen_from_utf8ILm32EEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__117moneypunct_bynameIcLb0EEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__117moneypunct_bynameIcLb1EEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__117moneypunct_bynameIwLb0EEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__117moneypunct_bynameIwLb1EEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__118__time_get_storageIcEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__118__time_get_storageIwEE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTINSt3__119__shared_weak_countE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__120__codecvt_utf8_utf16IDiEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__120__codecvt_utf8_utf16IDsEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__120__codecvt_utf8_utf16IwEE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__120__time_get_c_storageIcEE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__120__time_get_c_storageIwEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__124__libcpp_debug_exceptionE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__15ctypeIcEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__15ctypeIwEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__16locale5facetE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__17codecvtIDic11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__17codecvtIDsc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__17codecvtIcc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__17codecvtIwc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__17collateIcEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__17collateIwEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__18__c_nodeE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__18ios_base7failureE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__18ios_baseE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__18messagesIcEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__18messagesIwEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__18numpunctIcEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__18numpunctIwEE', 'type': 'OBJECT'}
-{'size': 72, 'is_defined': True, 'name': '_ZTINSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 72, 'is_defined': True, 'name': '_ZTINSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTINSt3__19__num_getIcEE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTINSt3__19__num_getIwEE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTINSt3__19__num_putIcEE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTINSt3__19__num_putIwEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTINSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTINSt3__19strstreamE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTINSt3__19time_baseE', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTISt11logic_error', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTISt12bad_any_cast', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTISt12length_error', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTISt12out_of_range', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTISt13runtime_error', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTISt14overflow_error', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTISt16invalid_argument', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTISt16nested_exception', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTISt18bad_variant_access', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTISt19bad_optional_access', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTISt8bad_cast', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTISt9bad_alloc', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTISt9exception', 'type': 'OBJECT'}
-{'size': 50, 'is_defined': True, 'name': '_ZTSNSt12experimental15fundamentals_v112bad_any_castE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTSNSt12experimental19bad_optional_accessE', 'type': 'OBJECT'}
-{'size': 21, 'is_defined': True, 'name': '_ZTSNSt3__110__time_getE', 'type': 'OBJECT'}
-{'size': 21, 'is_defined': True, 'name': '_ZTSNSt3__110__time_putE', 'type': 'OBJECT'}
-{'size': 21, 'is_defined': True, 'name': '_ZTSNSt3__110ctype_baseE', 'type': 'OBJECT'}
-{'size': 21, 'is_defined': True, 'name': '_ZTSNSt3__110istrstreamE', 'type': 'OBJECT'}
-{'size': 21, 'is_defined': True, 'name': '_ZTSNSt3__110money_baseE', 'type': 'OBJECT'}
-{'size': 28, 'is_defined': True, 'name': '_ZTSNSt3__110moneypunctIcLb0EEE', 'type': 'OBJECT'}
-{'size': 28, 'is_defined': True, 'name': '_ZTSNSt3__110moneypunctIcLb1EEE', 'type': 'OBJECT'}
-{'size': 28, 'is_defined': True, 'name': '_ZTSNSt3__110moneypunctIwLb0EEE', 'type': 'OBJECT'}
-{'size': 28, 'is_defined': True, 'name': '_ZTSNSt3__110moneypunctIwLb1EEE', 'type': 'OBJECT'}
-{'size': 21, 'is_defined': True, 'name': '_ZTSNSt3__110ostrstreamE', 'type': 'OBJECT'}
-{'size': 25, 'is_defined': True, 'name': '_ZTSNSt3__111__money_getIcEE', 'type': 'OBJECT'}
-{'size': 25, 'is_defined': True, 'name': '_ZTSNSt3__111__money_getIwEE', 'type': 'OBJECT'}
-{'size': 25, 'is_defined': True, 'name': '_ZTSNSt3__111__money_putIcEE', 'type': 'OBJECT'}
-{'size': 25, 'is_defined': True, 'name': '_ZTSNSt3__111__money_putIwEE', 'type': 'OBJECT'}
-{'size': 22, 'is_defined': True, 'name': '_ZTSNSt3__111regex_errorE', 'type': 'OBJECT'}
-{'size': 23, 'is_defined': True, 'name': '_ZTSNSt3__112bad_weak_ptrE', 'type': 'OBJECT'}
-{'size': 23, 'is_defined': True, 'name': '_ZTSNSt3__112codecvt_baseE', 'type': 'OBJECT'}
-{'size': 26, 'is_defined': True, 'name': '_ZTSNSt3__112ctype_bynameIcEE', 'type': 'OBJECT'}
-{'size': 26, 'is_defined': True, 'name': '_ZTSNSt3__112ctype_bynameIwEE', 'type': 'OBJECT'}
-{'size': 23, 'is_defined': True, 'name': '_ZTSNSt3__112future_errorE', 'type': 'OBJECT'}
-{'size': 23, 'is_defined': True, 'name': '_ZTSNSt3__112strstreambufE', 'type': 'OBJECT'}
-{'size': 23, 'is_defined': True, 'name': '_ZTSNSt3__112system_errorE', 'type': 'OBJECT'}
-{'size': 47, 'is_defined': True, 'name': '_ZTSNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 47, 'is_defined': True, 'name': '_ZTSNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'type': 'OBJECT'}
-{'size': 47, 'is_defined': True, 'name': '_ZTSNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 47, 'is_defined': True, 'name': '_ZTSNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTSNSt3__113messages_baseE', 'type': 'OBJECT'}
-{'size': 29, 'is_defined': True, 'name': '_ZTSNSt3__114__codecvt_utf8IDiEE', 'type': 'OBJECT'}
-{'size': 29, 'is_defined': True, 'name': '_ZTSNSt3__114__codecvt_utf8IDsEE', 'type': 'OBJECT'}
-{'size': 28, 'is_defined': True, 'name': '_ZTSNSt3__114__codecvt_utf8IwEE', 'type': 'OBJECT'}
-{'size': 25, 'is_defined': True, 'name': '_ZTSNSt3__114__num_get_baseE', 'type': 'OBJECT'}
-{'size': 25, 'is_defined': True, 'name': '_ZTSNSt3__114__num_put_baseE', 'type': 'OBJECT'}
-{'size': 25, 'is_defined': True, 'name': '_ZTSNSt3__114__shared_countE', 'type': 'OBJECT'}
-{'size': 48, 'is_defined': True, 'name': '_ZTSNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 43, 'is_defined': True, 'name': '_ZTSNSt3__114codecvt_bynameIDic11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 43, 'is_defined': True, 'name': '_ZTSNSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 42, 'is_defined': True, 'name': '_ZTSNSt3__114codecvt_bynameIcc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 42, 'is_defined': True, 'name': '_ZTSNSt3__114codecvt_bynameIwc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 28, 'is_defined': True, 'name': '_ZTSNSt3__114collate_bynameIcEE', 'type': 'OBJECT'}
-{'size': 28, 'is_defined': True, 'name': '_ZTSNSt3__114collate_bynameIwEE', 'type': 'OBJECT'}
-{'size': 25, 'is_defined': True, 'name': '_ZTSNSt3__114error_categoryE', 'type': 'OBJECT'}
-{'size': 34, 'is_defined': True, 'name': '_ZTSNSt3__115__codecvt_utf16IDiLb0EEE', 'type': 'OBJECT'}
-{'size': 34, 'is_defined': True, 'name': '_ZTSNSt3__115__codecvt_utf16IDiLb1EEE', 'type': 'OBJECT'}
-{'size': 34, 'is_defined': True, 'name': '_ZTSNSt3__115__codecvt_utf16IDsLb0EEE', 'type': 'OBJECT'}
-{'size': 34, 'is_defined': True, 'name': '_ZTSNSt3__115__codecvt_utf16IDsLb1EEE', 'type': 'OBJECT'}
-{'size': 33, 'is_defined': True, 'name': '_ZTSNSt3__115__codecvt_utf16IwLb0EEE', 'type': 'OBJECT'}
-{'size': 33, 'is_defined': True, 'name': '_ZTSNSt3__115__codecvt_utf16IwLb1EEE', 'type': 'OBJECT'}
-{'size': 49, 'is_defined': True, 'name': '_ZTSNSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 49, 'is_defined': True, 'name': '_ZTSNSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'type': 'OBJECT'}
-{'size': 29, 'is_defined': True, 'name': '_ZTSNSt3__115messages_bynameIcEE', 'type': 'OBJECT'}
-{'size': 29, 'is_defined': True, 'name': '_ZTSNSt3__115messages_bynameIwEE', 'type': 'OBJECT'}
-{'size': 29, 'is_defined': True, 'name': '_ZTSNSt3__115numpunct_bynameIcEE', 'type': 'OBJECT'}
-{'size': 29, 'is_defined': True, 'name': '_ZTSNSt3__115numpunct_bynameIwEE', 'type': 'OBJECT'}
-{'size': 77, 'is_defined': True, 'name': '_ZTSNSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 77, 'is_defined': True, 'name': '_ZTSNSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 77, 'is_defined': True, 'name': '_ZTSNSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 77, 'is_defined': True, 'name': '_ZTSNSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 34, 'is_defined': True, 'name': '_ZTSNSt3__116__narrow_to_utf8ILm16EEE', 'type': 'OBJECT'}
-{'size': 34, 'is_defined': True, 'name': '_ZTSNSt3__116__narrow_to_utf8ILm32EEE', 'type': 'OBJECT'}
-{'size': 28, 'is_defined': True, 'name': '_ZTSNSt3__117__assoc_sub_stateE', 'type': 'OBJECT'}
-{'size': 35, 'is_defined': True, 'name': '_ZTSNSt3__117__widen_from_utf8ILm16EEE', 'type': 'OBJECT'}
-{'size': 35, 'is_defined': True, 'name': '_ZTSNSt3__117__widen_from_utf8ILm32EEE', 'type': 'OBJECT'}
-{'size': 35, 'is_defined': True, 'name': '_ZTSNSt3__117moneypunct_bynameIcLb0EEE', 'type': 'OBJECT'}
-{'size': 35, 'is_defined': True, 'name': '_ZTSNSt3__117moneypunct_bynameIcLb1EEE', 'type': 'OBJECT'}
-{'size': 35, 'is_defined': True, 'name': '_ZTSNSt3__117moneypunct_bynameIwLb0EEE', 'type': 'OBJECT'}
-{'size': 35, 'is_defined': True, 'name': '_ZTSNSt3__117moneypunct_bynameIwLb1EEE', 'type': 'OBJECT'}
-{'size': 32, 'is_defined': True, 'name': '_ZTSNSt3__118__time_get_storageIcEE', 'type': 'OBJECT'}
-{'size': 32, 'is_defined': True, 'name': '_ZTSNSt3__118__time_get_storageIwEE', 'type': 'OBJECT'}
-{'size': 30, 'is_defined': True, 'name': '_ZTSNSt3__119__shared_weak_countE', 'type': 'OBJECT'}
-{'size': 35, 'is_defined': True, 'name': '_ZTSNSt3__120__codecvt_utf8_utf16IDiEE', 'type': 'OBJECT'}
-{'size': 35, 'is_defined': True, 'name': '_ZTSNSt3__120__codecvt_utf8_utf16IDsEE', 'type': 'OBJECT'}
-{'size': 34, 'is_defined': True, 'name': '_ZTSNSt3__120__codecvt_utf8_utf16IwEE', 'type': 'OBJECT'}
-{'size': 34, 'is_defined': True, 'name': '_ZTSNSt3__120__time_get_c_storageIcEE', 'type': 'OBJECT'}
-{'size': 34, 'is_defined': True, 'name': '_ZTSNSt3__120__time_get_c_storageIwEE', 'type': 'OBJECT'}
-{'size': 35, 'is_defined': True, 'name': '_ZTSNSt3__124__libcpp_debug_exceptionE', 'type': 'OBJECT'}
-{'size': 18, 'is_defined': True, 'name': '_ZTSNSt3__15ctypeIcEE', 'type': 'OBJECT'}
-{'size': 18, 'is_defined': True, 'name': '_ZTSNSt3__15ctypeIwEE', 'type': 'OBJECT'}
-{'size': 22, 'is_defined': True, 'name': '_ZTSNSt3__16locale5facetE', 'type': 'OBJECT'}
-{'size': 35, 'is_defined': True, 'name': '_ZTSNSt3__17codecvtIDic11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 35, 'is_defined': True, 'name': '_ZTSNSt3__17codecvtIDsc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 34, 'is_defined': True, 'name': '_ZTSNSt3__17codecvtIcc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 34, 'is_defined': True, 'name': '_ZTSNSt3__17codecvtIwc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 20, 'is_defined': True, 'name': '_ZTSNSt3__17collateIcEE', 'type': 'OBJECT'}
-{'size': 20, 'is_defined': True, 'name': '_ZTSNSt3__17collateIwEE', 'type': 'OBJECT'}
-{'size': 68, 'is_defined': True, 'name': '_ZTSNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 68, 'is_defined': True, 'name': '_ZTSNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 68, 'is_defined': True, 'name': '_ZTSNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 68, 'is_defined': True, 'name': '_ZTSNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 18, 'is_defined': True, 'name': '_ZTSNSt3__18__c_nodeE', 'type': 'OBJECT'}
-{'size': 26, 'is_defined': True, 'name': '_ZTSNSt3__18ios_base7failureE', 'type': 'OBJECT'}
-{'size': 18, 'is_defined': True, 'name': '_ZTSNSt3__18ios_baseE', 'type': 'OBJECT'}
-{'size': 21, 'is_defined': True, 'name': '_ZTSNSt3__18messagesIcEE', 'type': 'OBJECT'}
-{'size': 21, 'is_defined': True, 'name': '_ZTSNSt3__18messagesIwEE', 'type': 'OBJECT'}
-{'size': 21, 'is_defined': True, 'name': '_ZTSNSt3__18numpunctIcEE', 'type': 'OBJECT'}
-{'size': 21, 'is_defined': True, 'name': '_ZTSNSt3__18numpunctIwEE', 'type': 'OBJECT'}
-{'size': 69, 'is_defined': True, 'name': '_ZTSNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 69, 'is_defined': True, 'name': '_ZTSNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 69, 'is_defined': True, 'name': '_ZTSNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 69, 'is_defined': True, 'name': '_ZTSNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 22, 'is_defined': True, 'name': '_ZTSNSt3__19__num_getIcEE', 'type': 'OBJECT'}
-{'size': 22, 'is_defined': True, 'name': '_ZTSNSt3__19__num_getIwEE', 'type': 'OBJECT'}
-{'size': 22, 'is_defined': True, 'name': '_ZTSNSt3__19__num_putIcEE', 'type': 'OBJECT'}
-{'size': 22, 'is_defined': True, 'name': '_ZTSNSt3__19__num_putIwEE', 'type': 'OBJECT'}
-{'size': 42, 'is_defined': True, 'name': '_ZTSNSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 42, 'is_defined': True, 'name': '_ZTSNSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'type': 'OBJECT'}
-{'size': 70, 'is_defined': True, 'name': '_ZTSNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 70, 'is_defined': True, 'name': '_ZTSNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 70, 'is_defined': True, 'name': '_ZTSNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 70, 'is_defined': True, 'name': '_ZTSNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 19, 'is_defined': True, 'name': '_ZTSNSt3__19strstreamE', 'type': 'OBJECT'}
-{'size': 19, 'is_defined': True, 'name': '_ZTSNSt3__19time_baseE', 'type': 'OBJECT'}
-{'size': 17, 'is_defined': True, 'name': '_ZTSSt12bad_any_cast', 'type': 'OBJECT'}
-{'size': 21, 'is_defined': True, 'name': '_ZTSSt16nested_exception', 'type': 'OBJECT'}
-{'size': 23, 'is_defined': True, 'name': '_ZTSSt18bad_variant_access', 'type': 'OBJECT'}
-{'size': 24, 'is_defined': True, 'name': '_ZTSSt19bad_optional_access', 'type': 'OBJECT'}
-{'size': 32, 'is_defined': True, 'name': '_ZTTNSt3__110istrstreamE', 'type': 'OBJECT'}
-{'size': 32, 'is_defined': True, 'name': '_ZTTNSt3__110ostrstreamE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTTNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTTNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTTNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 16, 'is_defined': True, 'name': '_ZTTNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTTNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 80, 'is_defined': True, 'name': '_ZTTNSt3__19strstreamE', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTVN10__cxxabiv117__class_type_infoE', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTVN10__cxxabiv120__si_class_type_infoE', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTVN10__cxxabiv121__vmi_class_type_infoE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTVNSt12experimental15fundamentals_v112bad_any_castE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTVNSt12experimental19bad_optional_accessE', 'type': 'OBJECT'}
-{'size': 80, 'is_defined': True, 'name': '_ZTVNSt3__110istrstreamE', 'type': 'OBJECT'}
-{'size': 112, 'is_defined': True, 'name': '_ZTVNSt3__110moneypunctIcLb0EEE', 'type': 'OBJECT'}
-{'size': 112, 'is_defined': True, 'name': '_ZTVNSt3__110moneypunctIcLb1EEE', 'type': 'OBJECT'}
-{'size': 112, 'is_defined': True, 'name': '_ZTVNSt3__110moneypunctIwLb0EEE', 'type': 'OBJECT'}
-{'size': 112, 'is_defined': True, 'name': '_ZTVNSt3__110moneypunctIwLb1EEE', 'type': 'OBJECT'}
-{'size': 80, 'is_defined': True, 'name': '_ZTVNSt3__110ostrstreamE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTVNSt3__111regex_errorE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTVNSt3__112bad_weak_ptrE', 'type': 'OBJECT'}
-{'size': 104, 'is_defined': True, 'name': '_ZTVNSt3__112ctype_bynameIcEE', 'type': 'OBJECT'}
-{'size': 136, 'is_defined': True, 'name': '_ZTVNSt3__112ctype_bynameIwEE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTVNSt3__112future_errorE', 'type': 'OBJECT'}
-{'size': 128, 'is_defined': True, 'name': '_ZTVNSt3__112strstreambufE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTVNSt3__112system_errorE', 'type': 'OBJECT'}
-{'size': 80, 'is_defined': True, 'name': '_ZTVNSt3__113basic_istreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 80, 'is_defined': True, 'name': '_ZTVNSt3__113basic_istreamIwNS_11char_traitsIwEEEE', 'type': 'OBJECT'}
-{'size': 80, 'is_defined': True, 'name': '_ZTVNSt3__113basic_ostreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 80, 'is_defined': True, 'name': '_ZTVNSt3__113basic_ostreamIwNS_11char_traitsIwEEEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__114__codecvt_utf8IDiEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__114__codecvt_utf8IDsEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__114__codecvt_utf8IwEE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTVNSt3__114__shared_countE', 'type': 'OBJECT'}
-{'size': 120, 'is_defined': True, 'name': '_ZTVNSt3__114basic_iostreamIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__114codecvt_bynameIDic11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__114codecvt_bynameIDsc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__114codecvt_bynameIcc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__114codecvt_bynameIwc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 64, 'is_defined': True, 'name': '_ZTVNSt3__114collate_bynameIcEE', 'type': 'OBJECT'}
-{'size': 64, 'is_defined': True, 'name': '_ZTVNSt3__114collate_bynameIwEE', 'type': 'OBJECT'}
-{'size': 72, 'is_defined': True, 'name': '_ZTVNSt3__114error_categoryE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__115__codecvt_utf16IDiLb0EEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__115__codecvt_utf16IDiLb1EEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__115__codecvt_utf16IDsLb0EEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__115__codecvt_utf16IDsLb1EEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__115__codecvt_utf16IwLb0EEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__115__codecvt_utf16IwLb1EEE', 'type': 'OBJECT'}
-{'size': 128, 'is_defined': True, 'name': '_ZTVNSt3__115basic_streambufIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 128, 'is_defined': True, 'name': '_ZTVNSt3__115basic_streambufIwNS_11char_traitsIwEEEE', 'type': 'OBJECT'}
-{'size': 64, 'is_defined': True, 'name': '_ZTVNSt3__115messages_bynameIcEE', 'type': 'OBJECT'}
-{'size': 64, 'is_defined': True, 'name': '_ZTVNSt3__115messages_bynameIwEE', 'type': 'OBJECT'}
-{'size': 80, 'is_defined': True, 'name': '_ZTVNSt3__115numpunct_bynameIcEE', 'type': 'OBJECT'}
-{'size': 80, 'is_defined': True, 'name': '_ZTVNSt3__115numpunct_bynameIwEE', 'type': 'OBJECT'}
-{'size': 224, 'is_defined': True, 'name': '_ZTVNSt3__115time_get_bynameIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 224, 'is_defined': True, 'name': '_ZTVNSt3__115time_get_bynameIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 48, 'is_defined': True, 'name': '_ZTVNSt3__115time_put_bynameIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 48, 'is_defined': True, 'name': '_ZTVNSt3__115time_put_bynameIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__116__narrow_to_utf8ILm16EEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__116__narrow_to_utf8ILm32EEE', 'type': 'OBJECT'}
-{'size': 48, 'is_defined': True, 'name': '_ZTVNSt3__117__assoc_sub_stateE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__117__widen_from_utf8ILm16EEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__117__widen_from_utf8ILm32EEE', 'type': 'OBJECT'}
-{'size': 112, 'is_defined': True, 'name': '_ZTVNSt3__117moneypunct_bynameIcLb0EEE', 'type': 'OBJECT'}
-{'size': 112, 'is_defined': True, 'name': '_ZTVNSt3__117moneypunct_bynameIcLb1EEE', 'type': 'OBJECT'}
-{'size': 112, 'is_defined': True, 'name': '_ZTVNSt3__117moneypunct_bynameIwLb0EEE', 'type': 'OBJECT'}
-{'size': 112, 'is_defined': True, 'name': '_ZTVNSt3__117moneypunct_bynameIwLb1EEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTVNSt3__119__shared_weak_countE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__120__codecvt_utf8_utf16IDiEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__120__codecvt_utf8_utf16IDsEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__120__codecvt_utf8_utf16IwEE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTVNSt3__124__libcpp_debug_exceptionE', 'type': 'OBJECT'}
-{'size': 104, 'is_defined': True, 'name': '_ZTVNSt3__15ctypeIcEE', 'type': 'OBJECT'}
-{'size': 136, 'is_defined': True, 'name': '_ZTVNSt3__15ctypeIwEE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTVNSt3__16locale5facetE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__17codecvtIDic11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__17codecvtIDsc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__17codecvtIcc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 96, 'is_defined': True, 'name': '_ZTVNSt3__17codecvtIwc11__mbstate_tEE', 'type': 'OBJECT'}
-{'size': 64, 'is_defined': True, 'name': '_ZTVNSt3__17collateIcEE', 'type': 'OBJECT'}
-{'size': 64, 'is_defined': True, 'name': '_ZTVNSt3__17collateIwEE', 'type': 'OBJECT'}
-{'size': 128, 'is_defined': True, 'name': '_ZTVNSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 128, 'is_defined': True, 'name': '_ZTVNSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 104, 'is_defined': True, 'name': '_ZTVNSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 104, 'is_defined': True, 'name': '_ZTVNSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 64, 'is_defined': True, 'name': '_ZTVNSt3__18__c_nodeE', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTVNSt3__18ios_base7failureE', 'type': 'OBJECT'}
-{'size': 32, 'is_defined': True, 'name': '_ZTVNSt3__18ios_baseE', 'type': 'OBJECT'}
-{'size': 64, 'is_defined': True, 'name': '_ZTVNSt3__18messagesIcEE', 'type': 'OBJECT'}
-{'size': 64, 'is_defined': True, 'name': '_ZTVNSt3__18messagesIwEE', 'type': 'OBJECT'}
-{'size': 80, 'is_defined': True, 'name': '_ZTVNSt3__18numpunctIcEE', 'type': 'OBJECT'}
-{'size': 80, 'is_defined': True, 'name': '_ZTVNSt3__18numpunctIwEE', 'type': 'OBJECT'}
-{'size': 168, 'is_defined': True, 'name': '_ZTVNSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 168, 'is_defined': True, 'name': '_ZTVNSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 48, 'is_defined': True, 'name': '_ZTVNSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 48, 'is_defined': True, 'name': '_ZTVNSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 32, 'is_defined': True, 'name': '_ZTVNSt3__19basic_iosIcNS_11char_traitsIcEEEE', 'type': 'OBJECT'}
-{'size': 32, 'is_defined': True, 'name': '_ZTVNSt3__19basic_iosIwNS_11char_traitsIwEEEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTVNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTVNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTVNSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEEE', 'type': 'OBJECT'}
-{'size': 56, 'is_defined': True, 'name': '_ZTVNSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEEE', 'type': 'OBJECT'}
-{'size': 120, 'is_defined': True, 'name': '_ZTVNSt3__19strstreamE', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTVSt11logic_error', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTVSt12bad_any_cast', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTVSt12length_error', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTVSt12out_of_range', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTVSt13runtime_error', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTVSt14overflow_error', 'type': 'OBJECT'}
-{'size': 0, 'is_defined': False, 'name': '_ZTVSt16invalid_argument', 'type': 'OBJECT'}
-{'size': 32, 'is_defined': True, 'name': '_ZTVSt16nested_exception', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTVSt18bad_variant_access', 'type': 'OBJECT'}
-{'size': 40, 'is_defined': True, 'name': '_ZTVSt19bad_optional_access', 'type': 'OBJECT'}
-{'is_defined': True, 'name': '_ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZThn16_NSt3__19strstreamD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZThn16_NSt3__19strstreamD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZTv0_n24_NSt3__110istrstreamD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZTv0_n24_NSt3__110istrstreamD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZTv0_n24_NSt3__110ostrstreamD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZTv0_n24_NSt3__110ostrstreamD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZTv0_n24_NSt3__19strstreamD0Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZTv0_n24_NSt3__19strstreamD1Ev', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZdaPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZdaPvRKSt9nothrow_t', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZdaPvSt11align_val_t', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZdaPvSt11align_val_tRKSt9nothrow_t', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZdaPvm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZdaPvmSt11align_val_t', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZdlPv', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZdlPvRKSt9nothrow_t', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZdlPvSt11align_val_t', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZdlPvSt11align_val_tRKSt9nothrow_t', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZdlPvm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZdlPvmSt11align_val_t', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_Znam', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZnamRKSt9nothrow_t', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZnamSt11align_val_t', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZnamSt11align_val_tRKSt9nothrow_t', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_Znwm', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZnwmRKSt9nothrow_t', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZnwmSt11align_val_t', 'type': 'FUNC'}
-{'is_defined': True, 'name': '_ZnwmSt11align_val_tRKSt9nothrow_t', 'type': 'FUNC'}
-{'is_defined': False, 'name': '__cxa_allocate_exception', 'type': 'FUNC'}
-{'is_defined': False, 'name': '__cxa_begin_catch', 'type': 'FUNC'}
-{'is_defined': False, 'name': '__cxa_current_primary_exception', 'type': 'FUNC'}
-{'is_defined': False, 'name': '__cxa_decrement_exception_refcount', 'type': 'FUNC'}
-{'is_defined': False, 'name': '__cxa_end_catch', 'type': 'FUNC'}
-{'is_defined': False, 'name': '__cxa_free_exception', 'type': 'FUNC'}
-{'is_defined': False, 'name': '__cxa_guard_abort', 'type': 'FUNC'}
-{'is_defined': False, 'name': '__cxa_guard_acquire', 'type': 'FUNC'}
-{'is_defined': False, 'name': '__cxa_guard_release', 'type': 'FUNC'}
-{'is_defined': False, 'name': '__cxa_increment_exception_refcount', 'type': 'FUNC'}
-{'is_defined': False, 'name': '__cxa_pure_virtual', 'type': 'FUNC'}
-{'is_defined': False, 'name': '__cxa_rethrow', 'type': 'FUNC'}
-{'is_defined': False, 'name': '__cxa_rethrow_primary_exception', 'type': 'FUNC'}
-{'is_defined': False, 'name': '__cxa_throw', 'type': 'FUNC'}
-{'is_defined': False, 'name': '__cxa_uncaught_exception', 'type': 'FUNC'}
diff --git a/lib/abi/CHANGELOG.TXT b/lib/abi/CHANGELOG.TXT
index b979b46945b9..b8a0cbebefd8 100644
--- a/lib/abi/CHANGELOG.TXT
+++ b/lib/abi/CHANGELOG.TXT
@@ -16,6 +16,16 @@ New entries should be added directly below the "Version" header.
 Version 5.0
 -----------
 
+* r313500 - Fix undefined "___cxa_deleted_virtual" symbol in macosx
+
+  x86_64-linux-gnu
+  ----------------
+  No changes
+
+  x86_64-apple-darwin16.0
+  -----------------------
+  Symbol added: ___cxa_deleted_virtual
+
 * r296729 - Remove std::num_get template methods which should be inline
 
   These functions should never have had visible definitions in the dylib but
diff --git a/lib/abi/x86_64-apple-darwin16.abilist b/lib/abi/x86_64-apple-darwin16.abilist
index 5d91c4b62783..4e212b18c120 100644
--- a/lib/abi/x86_64-apple-darwin16.abilist
+++ b/lib/abi/x86_64-apple-darwin16.abilist
@@ -2323,6 +2323,8 @@
 {'type': 'I', 'is_defined': True, 'name': '___cxa_current_exception_type'}
 {'type': 'U', 'is_defined': False, 'name': '___cxa_current_primary_exception'}
 {'type': 'U', 'is_defined': False, 'name': '___cxa_decrement_exception_refcount'}
+{'type': 'U', 'is_defined': False, 'name': '___cxa_deleted_virtual'}
+{'type': 'I', 'is_defined': True, 'name': '___cxa_deleted_virtual'}
 {'type': 'U', 'is_defined': False, 'name': '___cxa_demangle'}
 {'type': 'I', 'is_defined': True, 'name': '___cxa_demangle'}
 {'type': 'U', 'is_defined': False, 'name': '___cxa_end_catch'}
diff --git a/lib/libc++abi.exp b/lib/libc++abi.exp
index 87035b295f3c..879b4dd141e5 100644
--- a/lib/libc++abi.exp
+++ b/lib/libc++abi.exp
@@ -12,6 +12,7 @@ ___cxa_guard_acquire
 ___cxa_guard_release
 ___cxa_rethrow
 ___cxa_pure_virtual
+___cxa_deleted_virtual
 ___cxa_begin_catch
 ___cxa_throw
 ___cxa_vec_cctor
diff --git a/lib/libc++abi2.exp b/lib/libc++abi2.exp
index eb088f37057d..0059eb49e24e 100644
--- a/lib/libc++abi2.exp
+++ b/lib/libc++abi2.exp
@@ -12,6 +12,7 @@ ___cxa_guard_acquire
 ___cxa_guard_release
 ___cxa_rethrow
 ___cxa_pure_virtual
+___cxa_deleted_virtual
 ___cxa_begin_catch
 ___cxa_throw
 ___cxa_vec_cctor
diff --git a/lib/libc++sjlj-abi.exp b/lib/libc++sjlj-abi.exp
index e646df1a4bd6..f494e17cfdee 100644
--- a/lib/libc++sjlj-abi.exp
+++ b/lib/libc++sjlj-abi.exp
@@ -12,6 +12,7 @@ ___cxa_guard_acquire
 ___cxa_guard_release
 ___cxa_rethrow
 ___cxa_pure_virtual
+___cxa_deleted_virtual
 ___cxa_begin_catch
 ___cxa_throw
 ___cxa_vec_cctor
diff --git a/src/exception.cpp b/src/exception.cpp
index 4359d126173a..3d2dcfd5b10e 100644
--- a/src/exception.cpp
+++ b/src/exception.cpp
@@ -31,6 +31,7 @@
 #include "support/runtime/exception_glibcxx.ipp"
 #include "support/runtime/exception_pointer_glibcxx.ipp"
 #else
+#include "include/atomic_support.h"
 #include "support/runtime/exception_fallback.ipp"
 #include "support/runtime/exception_pointer_unimplemented.ipp"
 #endif
diff --git a/src/experimental/filesystem/directory_iterator.cpp b/src/experimental/filesystem/directory_iterator.cpp
index 25135857d40c..a552fdc4461d 100644
--- a/src/experimental/filesystem/directory_iterator.cpp
+++ b/src/experimental/filesystem/directory_iterator.cpp
@@ -296,24 +296,43 @@ void recursive_directory_iterator::__advance(error_code* ec) {
 }
 
 bool recursive_directory_iterator::__try_recursion(error_code *ec) {
-
     bool rec_sym =
         bool(options() & directory_options::follow_directory_symlink);
+
     auto& curr_it = __imp_->__stack_.top();
 
-    if (is_directory(curr_it.__entry_.status()) &&
-        (!is_symlink(curr_it.__entry_.symlink_status()) || rec_sym))
-    {
-        std::error_code m_ec;
+    bool skip_rec = false;
+    std::error_code m_ec;
+    if (!rec_sym) {
+      file_status st = curr_it.__entry_.symlink_status(m_ec);
+      if (m_ec && status_known(st))
+        m_ec.clear();
+      if (m_ec || is_symlink(st) || !is_directory(st))
+        skip_rec = true;
+    } else {
+      file_status st = curr_it.__entry_.status(m_ec);
+      if (m_ec && status_known(st))
+        m_ec.clear();
+      if (m_ec || !is_directory(st))
+        skip_rec = true;
+    }
+
+    if (!skip_rec) {
         __dir_stream new_it(curr_it.__entry_.path(), __imp_->__options_, m_ec);
         if (new_it.good()) {
             __imp_->__stack_.push(_VSTD::move(new_it));
             return true;
         }
-        if (m_ec) {
-            __imp_.reset();
-            set_or_throw(m_ec, ec,
-                               "recursive_directory_iterator::operator++()");
+    }
+    if (m_ec) {
+        const bool allow_eacess = bool(__imp_->__options_
+            & directory_options::skip_permission_denied);
+        if (m_ec.value() == EACCES && allow_eacess) {
+          if (ec) ec->clear();
+        } else {
+          __imp_.reset();
+          set_or_throw(m_ec, ec,
+                       "recursive_directory_iterator::operator++()");
         }
     }
     return false;
diff --git a/src/experimental/filesystem/operations.cpp b/src/experimental/filesystem/operations.cpp
index 641a3c53636d..1a514545cec5 100644
--- a/src/experimental/filesystem/operations.cpp
+++ b/src/experimental/filesystem/operations.cpp
@@ -182,20 +182,20 @@ void __copy(const path& from, const path& to, copy_options options,
     const bool sym_status2 = bool(options &
         copy_options::copy_symlinks);
 
-    std::error_code m_ec;
+    std::error_code m_ec1;
     struct ::stat f_st = {};
     const file_status f = sym_status || sym_status2
-                                     ? detail::posix_lstat(from, f_st, &m_ec)
-                                     : detail::posix_stat(from,  f_st, &m_ec);
-    if (m_ec)
-        return set_or_throw(m_ec, ec, "copy", from, to);
+                                     ? detail::posix_lstat(from, f_st, &m_ec1)
+                                     : detail::posix_stat(from,  f_st, &m_ec1);
+    if (m_ec1)
+        return set_or_throw(m_ec1, ec, "copy", from, to);
 
     struct ::stat t_st = {};
-    const file_status t = sym_status ? detail::posix_lstat(to, t_st, &m_ec)
-                                     : detail::posix_stat(to, t_st, &m_ec);
+    const file_status t = sym_status ? detail::posix_lstat(to, t_st, &m_ec1)
+                                     : detail::posix_stat(to, t_st, &m_ec1);
 
     if (not status_known(t))
-        return set_or_throw(m_ec, ec, "copy", from, to);
+        return set_or_throw(m_ec1, ec, "copy", from, to);
 
     if (!exists(f) || is_other(f) || is_other(t)
         || (is_directory(f) && is_regular_file(t))
@@ -249,9 +249,9 @@ void __copy(const path& from, const path& to, copy_options options,
         directory_iterator it = ec ? directory_iterator(from, *ec)
                                    : directory_iterator(from);
         if (ec && *ec) { return; }
-        std::error_code m_ec;
-        for (; it != directory_iterator(); it.increment(m_ec)) {
-            if (m_ec) return set_or_throw(m_ec, ec, "copy", from, to);
+        std::error_code m_ec2;
+        for (; it != directory_iterator(); it.increment(m_ec2)) {
+            if (m_ec2) return set_or_throw(m_ec2, ec, "copy", from, to);
             __copy(it->path(), to / it->path().filename(),
                    options | copy_options::__in_recursive_copy, ec);
             if (ec && *ec) { return; }
diff --git a/src/include/atomic_support.h b/src/include/atomic_support.h
index 08847e630705..ccd8d78d3d71 100644
--- a/src/include/atomic_support.h
+++ b/src/include/atomic_support.h
@@ -16,6 +16,7 @@
 #if defined(__clang__) && __has_builtin(__atomic_load_n)             \
                        && __has_builtin(__atomic_store_n)            \
                        && __has_builtin(__atomic_add_fetch)          \
+                       && __has_builtin(__atomic_exchange_n)         \
                        && __has_builtin(__atomic_compare_exchange_n) \
                        && defined(__ATOMIC_RELAXED)                  \
                        && defined(__ATOMIC_CONSUME)                  \
@@ -84,6 +85,14 @@ _ValueType __libcpp_atomic_add(_ValueType* __val, _AddType __a,
 
 template <class _ValueType>
 inline _LIBCPP_INLINE_VISIBILITY
+_ValueType __libcpp_atomic_exchange(_ValueType* __target,
+                                    _ValueType __value, int __order = _AO_Seq)
+{
+    return __atomic_exchange_n(__target, __value, __order);
+}
+
+template <class _ValueType>
+inline _LIBCPP_INLINE_VISIBILITY
 bool __libcpp_atomic_compare_exchange(_ValueType* __val,
     _ValueType* __expected, _ValueType __after,
     int __success_order = _AO_Seq,
@@ -137,6 +146,16 @@ _ValueType __libcpp_atomic_add(_ValueType* __val, _AddType __a,
 
 template <class _ValueType>
 inline _LIBCPP_INLINE_VISIBILITY
+_ValueType __libcpp_atomic_exchange(_ValueType* __target,
+                                    _ValueType __value, int __order = _AO_Seq)
+{
+    _ValueType old = *__target;
+    *__target = __value;
+    return old;
+}
+
+template <class _ValueType>
+inline _LIBCPP_INLINE_VISIBILITY
 bool __libcpp_atomic_compare_exchange(_ValueType* __val,
     _ValueType* __expected, _ValueType __after,
     int = 0, int = 0)
diff --git a/src/include/config_elast.h b/src/include/config_elast.h
index 8328978ef953..4c4d853c2a68 100644
--- a/src/include/config_elast.h
+++ b/src/include/config_elast.h
@@ -24,7 +24,7 @@
 #define _LIBCPP_ELAST __ELASTERROR
 #elif defined(__Fuchsia__)
 // No _LIBCPP_ELAST needed on Fuchsia
-#elif defined(__linux__)
+#elif defined(__linux__) || defined(_LIBCPP_HAS_MUSL_LIBC)
 #define _LIBCPP_ELAST 4095
 #elif defined(__APPLE__)
 // No _LIBCPP_ELAST needed on Apple
diff --git a/src/include/refstring.h b/src/include/refstring.h
index f0d5b4456da5..702f2b7388da 100644
--- a/src/include/refstring.h
+++ b/src/include/refstring.h
@@ -18,6 +18,7 @@
 #include <dlfcn.h>
 #include <mach-o/dyld.h>
 #endif
+#include "atomic_support.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
@@ -83,7 +84,7 @@ __libcpp_refstring::__libcpp_refstring(const __libcpp_refstring &s) _NOEXCEPT
     : __imp_(s.__imp_)
 {
     if (__uses_refcount())
-        __sync_add_and_fetch(&rep_from_data(__imp_)->count, 1);
+        __libcpp_atomic_add(&rep_from_data(__imp_)->count, 1);
 }
 
 inline
@@ -92,10 +93,10 @@ __libcpp_refstring& __libcpp_refstring::operator=(__libcpp_refstring const& s) _
     struct _Rep_base *old_rep = rep_from_data(__imp_);
     __imp_ = s.__imp_;
     if (__uses_refcount())
-        __sync_add_and_fetch(&rep_from_data(__imp_)->count, 1);
+        __libcpp_atomic_add(&rep_from_data(__imp_)->count, 1);
     if (adjust_old_count)
     {
-        if (__sync_add_and_fetch(&old_rep->count, count_t(-1)) < 0)
+        if (__libcpp_atomic_add(&old_rep->count, count_t(-1)) < 0)
         {
             ::operator delete(old_rep);
         }
@@ -107,7 +108,7 @@ inline
 __libcpp_refstring::~__libcpp_refstring() {
     if (__uses_refcount()) {
         _Rep_base* rep = rep_from_data(__imp_);
-        if (__sync_add_and_fetch(&rep->count, count_t(-1)) < 0) {
+        if (__libcpp_atomic_add(&rep->count, count_t(-1)) < 0) {
             ::operator delete(rep);
         }
     }
diff --git a/src/iostream.cpp b/src/iostream.cpp
index 534b47a917d5..2b47cf25b640 100644
--- a/src/iostream.cpp
+++ b/src/iostream.cpp
@@ -11,19 +11,23 @@
 #include "string"
 #include "new"
 
+#define _str(s) #s
+#define str(s) _str(s)
+#define _LIBCPP_NAMESPACE_STR str(_LIBCPP_NAMESPACE)
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_HAS_NO_STDIN
 _ALIGNAS_TYPE (istream) _LIBCPP_FUNC_VIS char cin[sizeof(istream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?cin@__1@std@@3V?$basic_istream@DU?$char_traits@D@__1@std@@@12@A")
+__asm__("?cin@" _LIBCPP_NAMESPACE_STR "@std@@3V?$basic_istream@DU?$char_traits@D@" _LIBCPP_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
 _ALIGNAS_TYPE (__stdinbuf<char> ) static char __cin[sizeof(__stdinbuf <char>)];
 static mbstate_t mb_cin;
 _ALIGNAS_TYPE (wistream) _LIBCPP_FUNC_VIS char wcin[sizeof(wistream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?wcin@__1@std@@3V?$basic_istream@_WU?$char_traits@_W@__1@std@@@12@A")
+__asm__("?wcin@" _LIBCPP_NAMESPACE_STR "@std@@3V?$basic_istream@_WU?$char_traits@_W@" _LIBCPP_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
 _ALIGNAS_TYPE (__stdinbuf<wchar_t> ) static char __wcin[sizeof(__stdinbuf <wchar_t>)];
@@ -33,14 +37,14 @@ static mbstate_t mb_wcin;
 #ifndef _LIBCPP_HAS_NO_STDOUT
 _ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char cout[sizeof(ostream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?cout@__1@std@@3V?$basic_ostream@DU?$char_traits@D@__1@std@@@12@A")
+__asm__("?cout@" _LIBCPP_NAMESPACE_STR "@std@@3V?$basic_ostream@DU?$char_traits@D@" _LIBCPP_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
 _ALIGNAS_TYPE (__stdoutbuf<char>) static char __cout[sizeof(__stdoutbuf<char>)];
 static mbstate_t mb_cout;
 _ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcout[sizeof(wostream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?wcout@__1@std@@3V?$basic_ostream@_WU?$char_traits@_W@__1@std@@@12@A")
+__asm__("?wcout@" _LIBCPP_NAMESPACE_STR "@std@@3V?$basic_ostream@_WU?$char_traits@_W@" _LIBCPP_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
 _ALIGNAS_TYPE (__stdoutbuf<wchar_t>) static char __wcout[sizeof(__stdoutbuf<wchar_t>)];
@@ -49,14 +53,14 @@ static mbstate_t mb_wcout;
 
 _ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char cerr[sizeof(ostream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?cerr@__1@std@@3V?$basic_ostream@DU?$char_traits@D@__1@std@@@12@A")
+__asm__("?cerr@" _LIBCPP_NAMESPACE_STR "@std@@3V?$basic_ostream@DU?$char_traits@D@" _LIBCPP_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
 _ALIGNAS_TYPE (__stdoutbuf<char>) static char __cerr[sizeof(__stdoutbuf<char>)];
 static mbstate_t mb_cerr;
 _ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcerr[sizeof(wostream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?wcerr@__1@std@@3V?$basic_ostream@_WU?$char_traits@_W@__1@std@@@12@A")
+__asm__("?wcerr@" _LIBCPP_NAMESPACE_STR "@std@@3V?$basic_ostream@_WU?$char_traits@_W@" _LIBCPP_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
 _ALIGNAS_TYPE (__stdoutbuf<wchar_t>) static char __wcerr[sizeof(__stdoutbuf<wchar_t>)];
@@ -64,12 +68,12 @@ static mbstate_t mb_wcerr;
 
 _ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char clog[sizeof(ostream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?clog@__1@std@@3V?$basic_ostream@DU?$char_traits@D@__1@std@@@12@A")
+__asm__("?clog@" _LIBCPP_NAMESPACE_STR "@std@@3V?$basic_ostream@DU?$char_traits@D@" _LIBCPP_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
 _ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wclog[sizeof(wostream)]
 #if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?wclog@__1@std@@3V?$basic_ostream@_WU?$char_traits@_W@__1@std@@@12@A")
+__asm__("?wclog@" _LIBCPP_NAMESPACE_STR "@std@@3V?$basic_ostream@_WU?$char_traits@_W@" _LIBCPP_NAMESPACE_STR "@std@@@12@A")
 #endif
 ;
 
diff --git a/src/locale.cpp b/src/locale.cpp
index 3b4c83a09007..a6cb0e97d128 100644
--- a/src/locale.cpp
+++ b/src/locale.cpp
@@ -36,6 +36,7 @@
 #endif
 #include <stdlib.h>
 #include <stdio.h>
+#include "include/atomic_support.h"
 #include "__undef_macros"
 
 // On Linux, wint_t and wchar_t have different signed-ness, and this causes
@@ -667,7 +668,7 @@ locale::id::__get()
 void
 locale::id::__init()
 {
-    __id_ = __sync_add_and_fetch(&__next_id, 1);
+    __id_ = __libcpp_atomic_add(&__next_id, 1);
 }
 
 // template <> class collate_byname<char>
diff --git a/src/new.cpp b/src/new.cpp
index 2b2682fa6617..e228a0d83d8e 100644
--- a/src/new.cpp
+++ b/src/new.cpp
@@ -12,9 +12,12 @@
 #include <stdlib.h>
 
 #include "new"
+#include "include/atomic_support.h"
 
 #if defined(_LIBCPP_ABI_MICROSOFT)
-// nothing todo
+#if defined(_LIBCPP_NO_VCRUNTIME)
+#include "support/runtime/new_handler_fallback.ipp"
+#endif
 #elif defined(LIBCXX_BUILDING_LIBCXXABI)
 #include <cxxabi.h>
 #elif defined(LIBCXXRT)
@@ -53,7 +56,8 @@ __throw_bad_alloc()
 
 }  // std
 
-#if !defined(__GLIBCXX__) && !defined(_LIBCPP_ABI_MICROSOFT) && \
+#if !defined(__GLIBCXX__) &&                                                   \
+    (!defined(_LIBCPP_ABI_MICROSOFT) || defined(_LIBCPP_NO_VCRUNTIME)) &&      \
     !defined(_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS)
 
 // Implement all new and delete operators as weak definitions
@@ -299,4 +303,4 @@ operator delete[] (void* ptr, size_t, std::align_val_t alignment) _NOEXCEPT
 }
 
 #endif // !_LIBCPP_HAS_NO_ALIGNED_ALLOCATION
-#endif // !__GLIBCXX__ && !_LIBCPP_ABI_MICROSOFT && !_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS
+#endif // !__GLIBCXX__ && (!_LIBCPP_ABI_MICROSOFT || _LIBCPP_NO_VCRUNTIME) && !_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS
diff --git a/src/random.cpp b/src/random.cpp
index eb2510a48c85..4a2468368d06 100644
--- a/src/random.cpp
+++ b/src/random.cpp
@@ -25,7 +25,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#if defined(_LIBCPP_USING_DEV_RANDOM)
+#if defined(_LIBCPP_USING_GETENTROPY)
+#include <sys/random.h>
+#elif defined(_LIBCPP_USING_DEV_RANDOM)
 #include <fcntl.h>
 #include <unistd.h>
 #elif defined(_LIBCPP_USING_NACL_RANDOM)
@@ -35,7 +37,30 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if defined(_LIBCPP_USING_ARC4_RANDOM)
+#if defined(_LIBCPP_USING_GETENTROPY)
+
+random_device::random_device(const string& __token)
+{
+    if (__token != "/dev/urandom")
+        __throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
+}
+
+random_device::~random_device()
+{
+}
+
+unsigned
+random_device::operator()()
+{
+    unsigned r;
+    size_t n = sizeof(r);
+    int err = getentropy(&r, n);
+    if (err)
+        __throw_system_error(errno, "random_device getentropy failed");
+    return r;
+}
+
+#elif defined(_LIBCPP_USING_ARC4_RANDOM)
 
 random_device::random_device(const string& __token)
 {
diff --git a/src/strstream.cpp b/src/strstream.cpp
index 01523cf45462..8b8521f76af1 100644
--- a/src/strstream.cpp
+++ b/src/strstream.cpp
@@ -186,7 +186,7 @@ strstreambuf::overflow(int_type __c)
         }
         setg(buf, buf + ninp, buf + einp);
         setp(buf + einp, buf + new_size);
-        pbump(static_cast<int>(nout));
+        __pbump(nout);
         __strmode_ |= __allocated;
     }
     *pptr() = static_cast<char>(__c);
@@ -282,7 +282,7 @@ strstreambuf::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmod
                 // min(pbase, newpos), newpos, epptr()
                 __off = epptr() - newpos;
                 setp(min(pbase(), newpos), epptr());
-                pbump(static_cast<int>((epptr() - pbase()) - __off));
+                __pbump((epptr() - pbase()) - __off);
             }
             __p = newoff;
         }
@@ -312,7 +312,7 @@ strstreambuf::seekpos(pos_type __sp, ios_base::openmode __which)
                     // min(pbase, newpos), newpos, epptr()
                     off_type temp = epptr() - newpos;
                     setp(min(pbase(), newpos), epptr());
-                    pbump(static_cast<int>((epptr() - pbase()) - temp));
+                    __pbump((epptr() - pbase()) - temp);
                 }
                 __p = newoff;
             }
diff --git a/src/support/runtime/exception_fallback.ipp b/src/support/runtime/exception_fallback.ipp
index 69c06a9ce3a8..664e7f48c09a 100644
--- a/src/support/runtime/exception_fallback.ipp
+++ b/src/support/runtime/exception_fallback.ipp
@@ -20,13 +20,13 @@ _LIBCPP_SAFE_STATIC static std::unexpected_handler __unexpected_handler;
 unexpected_handler
 set_unexpected(unexpected_handler func) _NOEXCEPT
 {
-  return __sync_lock_test_and_set(&__unexpected_handler, func);
+  return __libcpp_atomic_exchange(&__unexpected_handler, func);
 }
 
 unexpected_handler
 get_unexpected() _NOEXCEPT
 {
-  return __sync_fetch_and_add(&__unexpected_handler, (unexpected_handler)0);
+  return __libcpp_atomic_load(&__unexpected_handler);
 
 }
 
@@ -41,14 +41,13 @@ void unexpected()
 terminate_handler
 set_terminate(terminate_handler func) _NOEXCEPT
 {
-  return __sync_lock_test_and_set(&__terminate_handler, func);
+  return __libcpp_atomic_exchange(&__terminate_handler, func);
 }
 
 terminate_handler
 get_terminate() _NOEXCEPT
 {
-  return __sync_fetch_and_add(&__terminate_handler, (terminate_handler)0);
-
+  return __libcpp_atomic_load(&__terminate_handler);
 }
 
 #ifndef __EMSCRIPTEN__ // We provide this in JS
diff --git a/src/support/runtime/exception_msvc.ipp b/src/support/runtime/exception_msvc.ipp
index 950ec0cebfe7..d5bf5b726ea5 100644
--- a/src/support/runtime/exception_msvc.ipp
+++ b/src/support/runtime/exception_msvc.ipp
@@ -14,12 +14,35 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <eh.h>
-#include <corecrt_terminate.h>
+
+#if !defined(_ACRTIMP)
+#define _ACRTIMP __declspec(dllimport)
+#endif
+
+#if !defined(_VCRTIMP)
+#define _VCRTIMP __declspec(dllimport)
+#endif
+
+#if !defined(__CRTDECL)
+#define __CRTDECL __cdecl
+#endif
+
+extern "C" {
+typedef void (__CRTDECL* terminate_handler)();
+_ACRTIMP terminate_handler __cdecl set_terminate(
+    terminate_handler _NewTerminateHandler) throw();
+_ACRTIMP terminate_handler __cdecl _get_terminate();
+
+typedef void (__CRTDECL* unexpected_handler)();
+_VCRTIMP unexpected_handler __cdecl set_unexpected(
+    unexpected_handler _NewUnexpectedHandler) throw();
+_VCRTIMP unexpected_handler __cdecl _get_unexpected();
+
+_VCRTIMP int __cdecl __uncaught_exceptions();
+}
 
 namespace std {
 
-// libcxxrt provides implementations of these functions itself.
 unexpected_handler
 set_unexpected(unexpected_handler func) _NOEXCEPT {
   return ::set_unexpected(func);
@@ -86,4 +109,82 @@ bad_array_length::what() const _NOEXCEPT
     return "bad_array_length";
 }
 
+bad_cast::bad_cast() _NOEXCEPT
+{
+}
+
+bad_cast::~bad_cast() _NOEXCEPT
+{
+}
+
+const char *
+bad_cast::what() const _NOEXCEPT
+{
+  return "std::bad_cast";
+}
+
+bad_typeid::bad_typeid() _NOEXCEPT
+{
+}
+
+bad_typeid::~bad_typeid() _NOEXCEPT
+{
+}
+
+const char *
+bad_typeid::what() const _NOEXCEPT
+{
+  return "std::bad_typeid";
+}
+
+#if defined(_LIBCPP_NO_VCRUNTIME)
+exception::~exception() _NOEXCEPT
+{
+}
+
+const char* exception::what() const _NOEXCEPT
+{
+  return "std::exception";
+}
+
+
+bad_exception::~bad_exception() _NOEXCEPT
+{
+}
+
+const char* bad_exception::what() const _NOEXCEPT
+{
+  return "std::bad_exception";
+}
+
+
+bad_alloc::bad_alloc() _NOEXCEPT
+{
+}
+
+bad_alloc::~bad_alloc() _NOEXCEPT
+{
+}
+
+const char*
+bad_alloc::what() const _NOEXCEPT
+{
+    return "std::bad_alloc";
+}
+
+bad_array_new_length::bad_array_new_length() _NOEXCEPT
+{
+}
+
+bad_array_new_length::~bad_array_new_length() _NOEXCEPT
+{
+}
+
+const char*
+bad_array_new_length::what() const _NOEXCEPT
+{
+    return "bad_array_new_length";
+}
+#endif // _LIBCPP_NO_VCRUNTIME
+
 } // namespace std
diff --git a/src/support/runtime/exception_pointer_msvc.ipp b/src/support/runtime/exception_pointer_msvc.ipp
index eab5d30a9487..5ca7519a6001 100644
--- a/src/support/runtime/exception_pointer_msvc.ipp
+++ b/src/support/runtime/exception_pointer_msvc.ipp
@@ -10,26 +10,32 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <yvals.h> // for _CRTIMP2_PURE
 
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCreate(_Out_ void*);
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrDestroy(_Inout_ void*);
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopy(_Out_ void*,
-                                                              _In_ const void*);
+#if !defined(_CRTIMP2_PURE)
+#define _CRTIMP2_PURE __declspec(dllimport)
+#endif
+
+#if !defined(__CLRCALL_PURE_OR_CDECL)
+#define __CLRCALL_PURE_OR_CDECL __cdecl
+#endif
+
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCreate(void*);
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrDestroy(void*);
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrCopy(void*,
+                                                              const void*);
 _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
-__ExceptionPtrAssign(_Inout_ void*, _In_ const void*);
+__ExceptionPtrAssign(void*, const void*);
 _CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL
-__ExceptionPtrCompare(_In_ const void*, _In_ const void*);
+__ExceptionPtrCompare(const void*, const void*);
 _CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL
-__ExceptionPtrToBool(_In_ const void*);
-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrSwap(_Inout_ void*,
-                                                              _Inout_ void*);
+__ExceptionPtrToBool(const void*);
+_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrSwap(void*, void*);
 _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
-__ExceptionPtrCurrentException(_Out_ void*);
+__ExceptionPtrCurrentException(void*);
 [[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
-__ExceptionPtrRethrow(_In_ const void*);
+__ExceptionPtrRethrow(const void*);
 _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
-__ExceptionPtrCopyException(_Inout_ void*, _In_ const void*, _In_ const void*);
+__ExceptionPtrCopyException(void*, const void*, const void*);
 
 namespace std {
 
diff --git a/src/support/runtime/new_handler_fallback.ipp b/src/support/runtime/new_handler_fallback.ipp
index b7092d542d97..ec3f52354ca8 100644
--- a/src/support/runtime/new_handler_fallback.ipp
+++ b/src/support/runtime/new_handler_fallback.ipp
@@ -15,13 +15,13 @@ _LIBCPP_SAFE_STATIC static std::new_handler __new_handler;
 new_handler
 set_new_handler(new_handler handler) _NOEXCEPT
 {
-    return __sync_lock_test_and_set(&__new_handler, handler);
+    return __libcpp_atomic_exchange(&__new_handler, handler);
 }
 
 new_handler
 get_new_handler() _NOEXCEPT
 {
-    return __sync_fetch_and_add(&__new_handler, nullptr);
+    return __libcpp_atomic_load(&__new_handler);
 }
 
 } // namespace std
diff --git a/src/support/win32/locale_win32.cpp b/src/support/win32/locale_win32.cpp
index 13a6eaedacb2..fdca7efff067 100644
--- a/src/support/win32/locale_win32.cpp
+++ b/src/support/win32/locale_win32.cpp
@@ -18,21 +18,7 @@ using std::__libcpp_locale_guard;
 // FIXME: base currently unused. Needs manual work to construct the new locale
 locale_t newlocale( int mask, const char * locale, locale_t /*base*/ )
 {
-    return _create_locale( mask, locale );
-}
-
-locale_t uselocale( locale_t newloc )
-{
-    locale_t old_locale = _get_current_locale();
-    if ( newloc == NULL )
-        return old_locale;
-    // uselocale sets the thread's locale by definition, so unconditionally use thread-local locale
-    _configthreadlocale( _ENABLE_PER_THREAD_LOCALE );
-    // uselocale sets all categories
-    // disable setting locale on Windows temporarily because the structure is opaque (PR31516)
-    //setlocale( LC_ALL, newloc->locinfo->lc_category[LC_ALL].locale );
-    // uselocale returns the old locale_t
-    return old_locale;
+    return {_create_locale( LC_ALL, locale ), locale};
 }
 
 decltype(MB_CUR_MAX) MB_CUR_MAX_L( locale_t __l )
diff --git a/src/system_error.cpp b/src/system_error.cpp
index 17f2c9a5ba79..72623ea6bc81 100644
--- a/src/system_error.cpp
+++ b/src/system_error.cpp
@@ -73,39 +73,59 @@ string do_strerror_r(int ev) {
   std::snprintf(buffer, strerror_buff_size, "unknown error %d", ev);
   return string(buffer);
 }
-#elif defined(__linux__) && !defined(_LIBCPP_HAS_MUSL_LIBC) &&                 \
-    (!defined(__ANDROID__) || __ANDROID_API__ >= 23)
-// GNU Extended version
-string do_strerror_r(int ev) {
-    char buffer[strerror_buff_size];
-    char* ret = ::strerror_r(ev, buffer, strerror_buff_size);
-    return string(ret);
-}
 #else
-// POSIX version
+
+// Only one of the two following functions will be used, depending on
+// the return type of strerror_r:
+
+// For the GNU variant, a char* return value:
+__attribute__((unused)) const char *
+handle_strerror_r_return(char *strerror_return, char *buffer) {
+  // GNU always returns a string pointer in its return value. The
+  // string might point to either the input buffer, or a static
+  // buffer, but we don't care which.
+  return strerror_return;
+}
+
+// For the POSIX variant: an int return value.
+__attribute__((unused)) const char *
+handle_strerror_r_return(int strerror_return, char *buffer) {
+  // The POSIX variant either:
+  // - fills in the provided buffer and returns 0
+  // - returns a positive error value, or
+  // - returns -1 and fills in errno with an error value.
+  if (strerror_return == 0)
+    return buffer;
+
+  // Only handle EINVAL. Other errors abort.
+  int new_errno = strerror_return == -1 ? errno : strerror_return;
+  if (new_errno == EINVAL)
+    return "";
+
+  _LIBCPP_ASSERT(new_errno == ERANGE, "unexpected error from ::strerror_r");
+  // FIXME maybe? 'strerror_buff_size' is likely to exceed the
+  // maximum error size so ERANGE shouldn't be returned.
+  std::abort();
+}
+
+// This function handles both GNU and POSIX variants, dispatching to
+// one of the two above functions.
 string do_strerror_r(int ev) {
     char buffer[strerror_buff_size];
+    // Preserve errno around the call. (The C++ standard requires that
+    // system_error functions not modify errno).
     const int old_errno = errno;
-    int ret;
-    if ((ret = ::strerror_r(ev, buffer, strerror_buff_size)) != 0) {
-        // If `ret == -1` then the error is specified using `errno`, otherwise
-        // `ret` represents the error.
-        const int new_errno = ret == -1 ? errno : ret;
-        errno = old_errno;
-        if (new_errno == EINVAL) {
-            std::snprintf(buffer, strerror_buff_size, "Unknown error %d", ev);
-            return string(buffer);
-        } else {
-            _LIBCPP_ASSERT(new_errno == ERANGE, "unexpected error from ::strerr_r");
-            // FIXME maybe? 'strerror_buff_size' is likely to exceed the
-            // maximum error size so ERANGE shouldn't be returned.
-            std::abort();
-        }
+    const char *error_message = handle_strerror_r_return(
+        ::strerror_r(ev, buffer, strerror_buff_size), buffer);
+    // If we didn't get any message, print one now.
+    if (!error_message[0]) {
+      std::snprintf(buffer, strerror_buff_size, "Unknown error %d", ev);
+      error_message = buffer;
     }
-    return string(buffer);
+    errno = old_errno;
+    return string(error_message);
 }
 #endif
-
 } // end namespace
 #endif
 
diff --git a/src/typeinfo.cpp b/src/typeinfo.cpp
index 02778f368704..0cb193b77d9e 100644
--- a/src/typeinfo.cpp
+++ b/src/typeinfo.cpp
@@ -9,11 +9,48 @@
 
 #include "typeinfo"
 
+#if defined(_LIBCPP_ABI_MICROSOFT)
+#include <string.h>
+
+int std::type_info::__compare(const type_info &__rhs) const _NOEXCEPT {
+  if (&__data == &__rhs.__data)
+    return 0;
+  return strcmp(&__data.__decorated_name[1], &__rhs.__data.__decorated_name[1]);
+}
+
+const char *std::type_info::name() const _NOEXCEPT {
+  // TODO(compnerd) cache demangled &__data.__decorated_name[1]
+  return &__data.__decorated_name[1];
+}
+
+size_t std::type_info::hash_code() const _NOEXCEPT {
+#if defined(_WIN64)
+  constexpr size_t fnv_offset_basis = 14695981039346656037ull;
+  constexpr size_t fnv_prime = 10995116282110ull;
+#else
+  constexpr size_t fnv_offset_basis = 2166136261ull;
+  constexpr size_t fnv_prime = 16777619ull;
+#endif
+
+  size_t value = fnv_offset_basis;
+  for (const char* c = &__data.__decorated_name[1]; *c; ++c) {
+    value ^= static_cast<size_t>(static_cast<unsigned char>(*c));
+    value *= fnv_prime;
+  }
+
+#if defined(_WIN64)
+  value ^= value >> 32;
+#endif
+
+  return value;
+}
+#endif // _LIBCPP_ABI_MICROSOFT
+
 // FIXME: Remove __APPLE__ default here once buildit is gone.
-#if (!defined(_LIBCPP_ABI_MICROSOFT) && !defined(LIBCXX_BUILDING_LIBCXXABI) && \
-    !defined(LIBCXXRT) && !defined(__GLIBCXX__) && \
-    !defined(__APPLE__)) || \
-    defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) // FIXME: remove this configuration.
+// FIXME: Remove the _LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY configuration.
+#if (!defined(LIBCXX_BUILDING_LIBCXXABI) && !defined(LIBCXXRT) &&              \
+     !defined(__GLIBCXX__) && !defined(__APPLE__)) ||                          \
+    defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY)
 std::type_info::~type_info()
 {
 }
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 7b8a8322a11f..53c6416cca6b 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -49,11 +49,6 @@ set(LIBCXX_EXECUTOR "None" CACHE STRING
 
 set(AUTO_GEN_COMMENT "## Autogenerated by libcxx configuration.\n# Do not edit!")
 
-configure_file(
-  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
-  ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
-  @ONLY)
-
 set(LIBCXX_TEST_DEPS "")
 
 if (LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY)
@@ -65,7 +60,12 @@ if (LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY)
 endif()
 
 if (LIBCXX_INCLUDE_TESTS)
-  include(AddLLVM) # for add_lit_testsuite
+  include(AddLLVM) # for configure_lit_site_cfg and add_lit_testsuit
+
+  configure_lit_site_cfg(
+    ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+    ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg)
+
   add_lit_testsuite(check-cxx
     "Running libcxx tests"
     ${CMAKE_CURRENT_BINARY_DIR}
diff --git a/test/libcxx/algorithms/debug_less.pass.cpp b/test/libcxx/algorithms/debug_less.pass.cpp
index 2e875ff277c4..e030f64e5dd9 100644
--- a/test/libcxx/algorithms/debug_less.pass.cpp
+++ b/test/libcxx/algorithms/debug_less.pass.cpp
@@ -164,4 +164,4 @@ void test_failing() {
 int main() {
     test_passing();
     test_failing();
-}
\ No newline at end of file
+}
diff --git a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp
index 589af7cc453b..6e25b0c3cbcf 100644
--- a/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp
+++ b/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_db1.pass.cpp
@@ -27,4 +27,4 @@ int main()
     std::list<int> v2(3);
     v1.insert(v2.begin(), 4);
     assert(false);
-}
\ No newline at end of file
+}
diff --git a/test/libcxx/containers/unord/next_pow2.pass.cpp b/test/libcxx/containers/unord/next_pow2.pass.cpp
index 3784eb87cebb..a878da4f5aa6 100644
--- a/test/libcxx/containers/unord/next_pow2.pass.cpp
+++ b/test/libcxx/containers/unord/next_pow2.pass.cpp
@@ -54,12 +54,12 @@ test_next_pow2()
         assert(std::__next_hash_pow2(pow2) == pow2);
     }
 
-	test_next_pow2_val(3);
-	test_next_pow2_val(7);
-	test_next_pow2_val(9);
-	test_next_pow2_val(15);
-	test_next_pow2_val(127);
-	test_next_pow2_val(129);
+    test_next_pow2_val(3);
+    test_next_pow2_val(7);
+    test_next_pow2_val(9);
+    test_next_pow2_val(15);
+    test_next_pow2_val(127);
+    test_next_pow2_val(129);
 }
 
 // Note: this is only really useful when run with -fsanitize=undefined.
diff --git a/test/libcxx/depr/depr.c.headers/complex.h.pass.cpp b/test/libcxx/depr/depr.c.headers/complex.h.pass.cpp
index da0707990d80..7abe8e0a064d 100644
--- a/test/libcxx/depr/depr.c.headers/complex.h.pass.cpp
+++ b/test/libcxx/depr/depr.c.headers/complex.h.pass.cpp
@@ -18,4 +18,5 @@
 int main()
 {
     std::complex<double> d;
+    (void)d;
 }
diff --git a/test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp b/test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp
index a2ef814dcae1..931e3a32f9ce 100644
--- a/test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp
+++ b/test/libcxx/depr/depr.c.headers/tgmath_h.pass.cpp
@@ -18,6 +18,7 @@
 int main()
 {
     std::complex<double> cd;
+    (void)cd;
     double x = sin(1.0);
     (void)x; // to placate scan-build
 }
diff --git a/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp b/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp
index f06dbb927acb..1847dac2ed00 100644
--- a/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp
+++ b/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp
@@ -24,25 +24,25 @@ int identity(int v) { return v; }
 int sum(int a, int b) { return a + b; }
 
 struct Foo {
-	int zero() const { return 0; }
-	int identity(int v) const { return v; }
-	int sum(int a, int b) const { return a + b; }
+    int zero() const { return 0; }
+    int identity(int v) const { return v; }
+    int sum(int a, int b) const { return a + b; }
 };
 
 int main()
 {
-	typedef std::pointer_to_unary_function<int, int> PUF;
-	typedef std::pointer_to_binary_function<int, int, int> PBF;
-	assert((std::ptr_fun<int, int>(identity)(4) == 4));
-	assert((std::ptr_fun<int, int, int>(sum)(4, 5) == 9));
+    typedef std::pointer_to_unary_function<int, int> PUF;
+    typedef std::pointer_to_binary_function<int, int, int> PBF;
+    assert((std::ptr_fun<int, int>(identity)(4) == 4));
+    assert((std::ptr_fun<int, int, int>(sum)(4, 5) == 9));
 
-	Foo f;
-	assert((std::mem_fn(&Foo::identity)(f, 5) == 5));
-	assert((std::mem_fn(&Foo::sum)(f, 5, 6) == 11));
+    Foo f;
+    assert((std::mem_fn(&Foo::identity)(f, 5) == 5));
+    assert((std::mem_fn(&Foo::sum)(f, 5, 6) == 11));
 
     typedef std::mem_fun_ref_t<int, Foo> MFR;
     typedef std::const_mem_fun_ref_t<int, Foo> CMFR;
 
-	assert((std::mem_fun_ref(&Foo::zero)(f) == 0));
-	assert((std::mem_fun_ref(&Foo::identity)(f, 5) == 5));
+    assert((std::mem_fun_ref(&Foo::zero)(f) == 0));
+    assert((std::mem_fun_ref(&Foo::identity)(f, 5) == 5));
 }
diff --git a/test/libcxx/diagnostics/nodiscard.fail.cpp b/test/libcxx/diagnostics/nodiscard.fail.cpp
new file mode 100644
index 000000000000..903a24a72805
--- /dev/null
+++ b/test/libcxx/diagnostics/nodiscard.fail.cpp
@@ -0,0 +1,24 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// Test that _LIBCPP_NODISCARD_AFTER_CXX17 works
+//	#define _LIBCPP_NODISCARD_AFTER_CXX17 [[nodiscard]]
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <__config>
+
+_LIBCPP_NODISCARD_AFTER_CXX17 int foo() { return 6; }
+
+int main ()
+{
+	foo();	// expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/utilities/optional/optional.nullopt/not_brace_initializable.fail.cpp b/test/libcxx/diagnostics/nodiscard.pass.cpp
index 86da5054a708..d308248cff22 100644
--- a/test/std/utilities/optional/optional.nullopt/not_brace_initializable.fail.cpp
+++ b/test/libcxx/diagnostics/nodiscard.pass.cpp
@@ -1,3 +1,4 @@
+// -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -7,19 +8,18 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++98, c++03, c++11, c++14
-// <optional>
+// Test that _LIBCPP_NODISCARD_AFTER_CXX17 works
+//	#define _LIBCPP_NODISCARD_AFTER_CXX17 [[nodiscard]]
 
-// struct nullopt_t{see below};
+// UNSUPPORTED: c++98, c++03, c++11, c++14
 
-#include <optional>
+// MODULES_DEFINES: _LIBCPP_DISABLE_NODISCARD_AFTER_CXX17
+#define _LIBCPP_DISABLE_NODISCARD_AFTER_CXX17
+#include <__config>
 
-using std::optional;
-using std::nullopt_t;
+_LIBCPP_NODISCARD_AFTER_CXX17 int foo() { return 6; }
 
-int main()
+int main ()
 {
-    // I roughly interpret LWG2736 as "it shall not be possible to copy-list-initialize nullopt_t with an
-    // empty braced-init-list."
-    nullopt_t foo = {};
+	foo();	// no error here!
 }
diff --git a/test/libcxx/experimental/filesystem/class.path/path.itr/iterator_db.pass.cpp b/test/libcxx/experimental/filesystem/class.path/path.itr/iterator_db.pass.cpp
index a98a9ccd2a80..aea46f10c9bc 100644
--- a/test/libcxx/experimental/filesystem/class.path/path.itr/iterator_db.pass.cpp
+++ b/test/libcxx/experimental/filesystem/class.path/path.itr/iterator_db.pass.cpp
@@ -71,4 +71,4 @@ int main() {
       assert(false);
     } catch (int) {}
   }
-}
\ No newline at end of file
+}
diff --git a/test/libcxx/experimental/filesystem/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp b/test/libcxx/experimental/filesystem/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp
index 6f839befb5cf..5a6f5304a061 100644
--- a/test/libcxx/experimental/filesystem/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp
+++ b/test/libcxx/experimental/filesystem/class.path/path.itr/reverse_iterator_produces_diagnostic.fail.cpp
@@ -23,7 +23,7 @@ int main() {
   using namespace fs;
   using RIt = std::reverse_iterator<path::iterator>;
 
-  // expected-error@iterator:* {{static_assert failed "The specified iterator type cannot be used with reverse_iterator; Using stashing iterators with reverse_iterator causes undefined behavior"}}
+  // expected-error-re@iterator:* {{static_assert failed{{.*}} "The specified iterator type cannot be used with reverse_iterator; Using stashing iterators with reverse_iterator causes undefined behavior"}}
   {
     RIt r;
     ((void)r);
diff --git a/test/libcxx/fuzzing/nth_element.cpp b/test/libcxx/fuzzing/nth_element.cpp
new file mode 100644
index 000000000000..ee7f0d824c94
--- /dev/null
+++ b/test/libcxx/fuzzing/nth_element.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===----------------------- nth_element.cpp ------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+	"",
+	"s",
+	"bac",
+	"bacasf"
+	"lkajseravea",
+	"adsfkajdsfjkas;lnc441324513,34535r34525234"
+	};
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+
+int main ()
+{
+	for (size_t i = 0; i < k_num_tests; ++i)
+		{
+		const size_t   size = std::strlen(test_cases[i]);
+		const uint8_t *data = (const uint8_t *) test_cases[i];
+		assert(0 == fuzzing::nth_element(data, size));
+		}
+	return 0;
+}
diff --git a/test/libcxx/fuzzing/partial_sort.cpp b/test/libcxx/fuzzing/partial_sort.cpp
new file mode 100644
index 000000000000..0c5889dbde8e
--- /dev/null
+++ b/test/libcxx/fuzzing/partial_sort.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===-------------------------- partial_sort.cpp --------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+	"",
+	"s",
+	"bac",
+	"bacasf"
+	"lkajseravea",
+	"adsfkajdsfjkas;lnc441324513,34535r34525234"
+	};
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+
+int main ()
+{
+	for (size_t i = 0; i < k_num_tests; ++i)
+		{
+		const size_t   size = std::strlen(test_cases[i]);
+		const uint8_t *data = (const uint8_t *) test_cases[i];
+		assert(0 == fuzzing::partial_sort(data, size));
+		}
+	return 0;
+}
diff --git a/test/libcxx/fuzzing/partial_sort_copy.cpp b/test/libcxx/fuzzing/partial_sort_copy.cpp
new file mode 100644
index 000000000000..368eed11bf7e
--- /dev/null
+++ b/test/libcxx/fuzzing/partial_sort_copy.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===----------------------- partial_sort_copy.cpp ------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+	"",
+	"s",
+	"bac",
+	"bacasf"
+	"lkajseravea",
+	"adsfkajdsfjkas;lnc441324513,34535r34525234"
+	};
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+
+int main ()
+{
+	for (size_t i = 0; i < k_num_tests; ++i)
+		{
+		const size_t   size = std::strlen(test_cases[i]);
+		const uint8_t *data = (const uint8_t *) test_cases[i];
+		assert(0 == fuzzing::partial_sort_copy(data, size));
+		}
+	return 0;
+}
diff --git a/test/libcxx/fuzzing/partition.cpp b/test/libcxx/fuzzing/partition.cpp
new file mode 100644
index 000000000000..03eed8c925ac
--- /dev/null
+++ b/test/libcxx/fuzzing/partition.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===--------------------------- partition.cpp ----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+	"",
+	"s",
+	"bac",
+	"bacasf"
+	"lkajseravea",
+	"adsfkajdsfjkas;lnc441324513,34535r34525234"
+	};
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+
+int main ()
+{
+	for (size_t i = 0; i < k_num_tests; ++i)
+		{
+		const size_t   size = std::strlen(test_cases[i]);
+		const uint8_t *data = (const uint8_t *) test_cases[i];
+		assert(0 == fuzzing::partition(data, size));
+		}
+	return 0;
+}
diff --git a/test/libcxx/fuzzing/partition_copy.cpp b/test/libcxx/fuzzing/partition_copy.cpp
new file mode 100644
index 000000000000..68d821f632a6
--- /dev/null
+++ b/test/libcxx/fuzzing/partition_copy.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===------------------------ partition_copy.cpp --------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+	"",
+	"s",
+	"bac",
+	"bacasf"
+	"lkajseravea",
+	"adsfkajdsfjkas;lnc441324513,34535r34525234"
+	};
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+
+int main ()
+{
+	for (size_t i = 0; i < k_num_tests; ++i)
+		{
+		const size_t   size = std::strlen(test_cases[i]);
+		const uint8_t *data = (const uint8_t *) test_cases[i];
+		assert(0 == fuzzing::partition_copy(data, size));
+		}
+	return 0;
+}
diff --git a/test/libcxx/fuzzing/regex_ECMAScript.cpp b/test/libcxx/fuzzing/regex_ECMAScript.cpp
new file mode 100644
index 000000000000..2e57126022f3
--- /dev/null
+++ b/test/libcxx/fuzzing/regex_ECMAScript.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===--------------------- regex_ECMAScript.cpp ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+	"",
+	"s",
+	"b*c",
+	"ba?sf"
+	"lka*ea",
+	"adsf*kas;lnc441[0-9]1r34525234"
+	};
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+int main ()
+{
+	for (size_t i = 0; i < k_num_tests; ++i)
+		{
+		const size_t   size = std::strlen(test_cases[i]);
+		const uint8_t *data = (const uint8_t *) test_cases[i];
+		assert(0 == fuzzing::regex_ECMAScript(data, size));
+		}
+	return 0;
+}
diff --git a/test/libcxx/fuzzing/regex_POSIX.cpp b/test/libcxx/fuzzing/regex_POSIX.cpp
new file mode 100644
index 000000000000..f0bd28919fe5
--- /dev/null
+++ b/test/libcxx/fuzzing/regex_POSIX.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===----------------------- regex_POSIX.cpp ------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+	"",
+	"s",
+	"b*c",
+	"ba?sf"
+	"lka*ea",
+	"adsf*kas;lnc441[0-9]1r34525234"
+	};
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+int main ()
+{
+	for (size_t i = 0; i < k_num_tests; ++i)
+		{
+		const size_t   size = std::strlen(test_cases[i]);
+		const uint8_t *data = (const uint8_t *) test_cases[i];
+		assert(0 == fuzzing::regex_POSIX(data, size));
+		}
+	return 0;
+}
diff --git a/test/libcxx/fuzzing/regex_awk.cpp b/test/libcxx/fuzzing/regex_awk.cpp
new file mode 100644
index 000000000000..2e57126022f3
--- /dev/null
+++ b/test/libcxx/fuzzing/regex_awk.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===--------------------- regex_ECMAScript.cpp ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+	"",
+	"s",
+	"b*c",
+	"ba?sf"
+	"lka*ea",
+	"adsf*kas;lnc441[0-9]1r34525234"
+	};
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+int main ()
+{
+	for (size_t i = 0; i < k_num_tests; ++i)
+		{
+		const size_t   size = std::strlen(test_cases[i]);
+		const uint8_t *data = (const uint8_t *) test_cases[i];
+		assert(0 == fuzzing::regex_ECMAScript(data, size));
+		}
+	return 0;
+}
diff --git a/test/libcxx/fuzzing/regex_egrep.cpp b/test/libcxx/fuzzing/regex_egrep.cpp
new file mode 100644
index 000000000000..056869f5222c
--- /dev/null
+++ b/test/libcxx/fuzzing/regex_egrep.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===------------------------ regex_egrep.cpp -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+	"",
+	"s",
+	"b*c",
+	"ba?sf"
+	"lka*ea",
+	"adsf*kas;lnc441[0-9]1r34525234"
+	};
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+int main ()
+{
+	for (size_t i = 0; i < k_num_tests; ++i)
+		{
+		const size_t   size = std::strlen(test_cases[i]);
+		const uint8_t *data = (const uint8_t *) test_cases[i];
+		assert(0 == fuzzing::regex_egrep(data, size));
+		}
+	return 0;
+}
diff --git a/test/libcxx/fuzzing/regex_extended.cpp b/test/libcxx/fuzzing/regex_extended.cpp
new file mode 100644
index 000000000000..ac850eb5cbb4
--- /dev/null
+++ b/test/libcxx/fuzzing/regex_extended.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===---------------------- regex_extended.cpp ----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+	"",
+	"s",
+	"b*c",
+	"ba?sf"
+	"lka*ea",
+	"adsf*kas;lnc441[0-9]1r34525234"
+	};
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+int main ()
+{
+	for (size_t i = 0; i < k_num_tests; ++i)
+		{
+		const size_t   size = std::strlen(test_cases[i]);
+		const uint8_t *data = (const uint8_t *) test_cases[i];
+		assert(0 == fuzzing::regex_extended(data, size));
+		}
+	return 0;
+}
diff --git a/test/libcxx/fuzzing/regex_grep.cpp b/test/libcxx/fuzzing/regex_grep.cpp
new file mode 100644
index 000000000000..5b1dda293dfa
--- /dev/null
+++ b/test/libcxx/fuzzing/regex_grep.cpp
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===------------------------ regex_grep.cpp ------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+	"",
+	"s",
+	"b*c",
+	"ba?sf"
+	"lka*ea",
+	"adsf*kas;lnc441[0-9]1r34525234"
+	};
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+int main ()
+{
+	for (size_t i = 0; i < k_num_tests; ++i)
+		{
+		const size_t   size = std::strlen(test_cases[i]);
+		const uint8_t *data = (const uint8_t *) test_cases[i];
+		assert(0 == fuzzing::regex_grep(data, size));
+		}
+	return 0;
+}
diff --git a/test/libcxx/fuzzing/sort.cpp b/test/libcxx/fuzzing/sort.cpp
new file mode 100644
index 000000000000..4c468948deb6
--- /dev/null
+++ b/test/libcxx/fuzzing/sort.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===--------------------------- sort.cpp ---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+	"",
+	"s",
+	"bac",
+	"bacasf"
+	"lkajseravea",
+	"adsfkajdsfjkas;lnc441324513,34535r34525234"
+	};
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+
+int main ()
+{
+	for (size_t i = 0; i < k_num_tests; ++i)
+		{
+		const size_t   size = std::strlen(test_cases[i]);
+		const uint8_t *data = (const uint8_t *) test_cases[i];
+		assert(0 == fuzzing::sort(data, size));
+		}
+	return 0;
+}
diff --git a/test/libcxx/fuzzing/stable_partition.cpp b/test/libcxx/fuzzing/stable_partition.cpp
new file mode 100644
index 000000000000..c21e6489049c
--- /dev/null
+++ b/test/libcxx/fuzzing/stable_partition.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===--------------------- stable_partition.cpp ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+	"",
+	"s",
+	"bac",
+	"bacasf"
+	"lkajseravea",
+	"adsfkajdsfjkas;lnc441324513,34535r34525234"
+	};
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+
+int main ()
+{
+	for (size_t i = 0; i < k_num_tests; ++i)
+		{
+		const size_t   size = std::strlen(test_cases[i]);
+		const uint8_t *data = (const uint8_t *) test_cases[i];
+		assert(0 == fuzzing::stable_partition(data, size));
+		}
+	return 0;
+}
diff --git a/test/libcxx/fuzzing/stable_sort.cpp b/test/libcxx/fuzzing/stable_sort.cpp
new file mode 100644
index 000000000000..1a7bbb9528e2
--- /dev/null
+++ b/test/libcxx/fuzzing/stable_sort.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===------------------------ stable_sort.cpp ----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+	"",
+	"s",
+	"bac",
+	"bacasf"
+	"lkajseravea",
+	"adsfkajdsfjkas;lnc441324513,34535r34525234"
+	};
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+
+int main ()
+{
+	for (size_t i = 0; i < k_num_tests; ++i)
+		{
+		const size_t   size = std::strlen(test_cases[i]);
+		const uint8_t *data = (const uint8_t *) test_cases[i];
+		assert(0 == fuzzing::stable_sort(data, size));
+		}
+	return 0;
+}
diff --git a/test/libcxx/fuzzing/unique.cpp b/test/libcxx/fuzzing/unique.cpp
new file mode 100644
index 000000000000..4bfa25a2b5c1
--- /dev/null
+++ b/test/libcxx/fuzzing/unique.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===--------------------------- unique.cpp -------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+	"",
+	"s",
+	"bac",
+	"bacasf"
+	"lkajseravea",
+	"adsfkajdsfjkas;lnc441324513,34535r34525234"
+	};
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+
+int main ()
+{
+	for (size_t i = 0; i < k_num_tests; ++i)
+		{
+		const size_t   size = std::strlen(test_cases[i]);
+		const uint8_t *data = (const uint8_t *) test_cases[i];
+		assert(0 == fuzzing::unique(data, size));
+		}
+	return 0;
+}
diff --git a/test/libcxx/fuzzing/unique_copy.cpp b/test/libcxx/fuzzing/unique_copy.cpp
new file mode 100644
index 000000000000..ed6fc7ea5513
--- /dev/null
+++ b/test/libcxx/fuzzing/unique_copy.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===------------------------ unique_copy.cpp -----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// XFAIL
+
+#include "fuzzing.h"
+#include <cassert>
+#include <cstring> // for strlen
+
+const char * test_cases[] = {
+	"",
+	"s",
+	"bac",
+	"bacasf"
+	"lkajseravea",
+	"adsfkajdsfjkas;lnc441324513,34535r34525234"
+	};
+
+const size_t k_num_tests = sizeof(test_cases)/sizeof(test_cases[0]);
+
+
+int main ()
+{
+	for (size_t i = 0; i < k_num_tests; ++i)
+		{
+		const size_t   size = std::strlen(test_cases[i]);
+		const uint8_t *data = (const uint8_t *) test_cases[i];
+		assert(0 == fuzzing::unique_copy(data, size));
+		}
+	return 0;
+}
diff --git a/test/libcxx/iterators/trivial_iterators.pass.cpp b/test/libcxx/iterators/trivial_iterators.pass.cpp
index fa3ebf260486..f30c13163ccc 100644
--- a/test/libcxx/iterators/trivial_iterators.pass.cpp
+++ b/test/libcxx/iterators/trivial_iterators.pass.cpp
@@ -126,42 +126,42 @@ int main()
     static_assert((!std::__libcpp_is_trivial_iterator<NonThrowingIterator   <char *> >::value), "");
 
 
-//	Iterator classification
-	static_assert(( std::__is_input_iterator        <char *>::value), "" );
-	static_assert(( std::__is_forward_iterator      <char *>::value), "" );
-	static_assert(( std::__is_bidirectional_iterator<char *>::value), "" );
-	static_assert(( std::__is_random_access_iterator<char *>::value), "" );
-	static_assert((!std::__is_exactly_input_iterator<char *>::value), "" );
-
-	static_assert(( std::__is_input_iterator        <input_iterator<char *> >::value), "" );
-	static_assert((!std::__is_forward_iterator      <input_iterator<char *> >::value), "" );
-	static_assert((!std::__is_bidirectional_iterator<input_iterator<char *> >::value), "" );
-	static_assert((!std::__is_random_access_iterator<input_iterator<char *> >::value), "" );
-	static_assert(( std::__is_exactly_input_iterator<input_iterator<char *> >::value), "" );
-
-	static_assert(( std::__is_input_iterator        <forward_iterator<char *> >::value), "" );
-	static_assert(( std::__is_forward_iterator      <forward_iterator<char *> >::value), "" );
-	static_assert((!std::__is_bidirectional_iterator<forward_iterator<char *> >::value), "" );
-	static_assert((!std::__is_random_access_iterator<forward_iterator<char *> >::value), "" );
-	static_assert((!std::__is_exactly_input_iterator<forward_iterator<char *> >::value), "" );
-
-	static_assert(( std::__is_input_iterator        <bidirectional_iterator<char *> >::value), "" );
-	static_assert(( std::__is_forward_iterator      <bidirectional_iterator<char *> >::value), "" );
-	static_assert(( std::__is_bidirectional_iterator<bidirectional_iterator<char *> >::value), "" );
-	static_assert((!std::__is_random_access_iterator<bidirectional_iterator<char *> >::value), "" );
-	static_assert((!std::__is_exactly_input_iterator<bidirectional_iterator<char *> >::value), "" );
-
-	static_assert(( std::__is_input_iterator        <random_access_iterator<char *> >::value), "" );
-	static_assert(( std::__is_forward_iterator      <random_access_iterator<char *> >::value), "" );
-	static_assert(( std::__is_bidirectional_iterator<random_access_iterator<char *> >::value), "" );
-	static_assert(( std::__is_random_access_iterator<random_access_iterator<char *> >::value), "" );
-	static_assert((!std::__is_exactly_input_iterator<random_access_iterator<char *> >::value), "" );
-
-	static_assert(( std::__is_input_iterator        <my_input_iterator<char *> >::value), "" );
-	static_assert((!std::__is_forward_iterator      <my_input_iterator<char *> >::value), "" );
-	static_assert((!std::__is_bidirectional_iterator<my_input_iterator<char *> >::value), "" );
-	static_assert((!std::__is_random_access_iterator<my_input_iterator<char *> >::value), "" );
-	static_assert(( std::__is_exactly_input_iterator<my_input_iterator<char *> >::value), "" );
+//  Iterator classification
+    static_assert(( std::__is_input_iterator        <char *>::value), "" );
+    static_assert(( std::__is_forward_iterator      <char *>::value), "" );
+    static_assert(( std::__is_bidirectional_iterator<char *>::value), "" );
+    static_assert(( std::__is_random_access_iterator<char *>::value), "" );
+    static_assert((!std::__is_exactly_input_iterator<char *>::value), "" );
+
+    static_assert(( std::__is_input_iterator        <input_iterator<char *> >::value), "" );
+    static_assert((!std::__is_forward_iterator      <input_iterator<char *> >::value), "" );
+    static_assert((!std::__is_bidirectional_iterator<input_iterator<char *> >::value), "" );
+    static_assert((!std::__is_random_access_iterator<input_iterator<char *> >::value), "" );
+    static_assert(( std::__is_exactly_input_iterator<input_iterator<char *> >::value), "" );
+
+    static_assert(( std::__is_input_iterator        <forward_iterator<char *> >::value), "" );
+    static_assert(( std::__is_forward_iterator      <forward_iterator<char *> >::value), "" );
+    static_assert((!std::__is_bidirectional_iterator<forward_iterator<char *> >::value), "" );
+    static_assert((!std::__is_random_access_iterator<forward_iterator<char *> >::value), "" );
+    static_assert((!std::__is_exactly_input_iterator<forward_iterator<char *> >::value), "" );
+
+    static_assert(( std::__is_input_iterator        <bidirectional_iterator<char *> >::value), "" );
+    static_assert(( std::__is_forward_iterator      <bidirectional_iterator<char *> >::value), "" );
+    static_assert(( std::__is_bidirectional_iterator<bidirectional_iterator<char *> >::value), "" );
+    static_assert((!std::__is_random_access_iterator<bidirectional_iterator<char *> >::value), "" );
+    static_assert((!std::__is_exactly_input_iterator<bidirectional_iterator<char *> >::value), "" );
+
+    static_assert(( std::__is_input_iterator        <random_access_iterator<char *> >::value), "" );
+    static_assert(( std::__is_forward_iterator      <random_access_iterator<char *> >::value), "" );
+    static_assert(( std::__is_bidirectional_iterator<random_access_iterator<char *> >::value), "" );
+    static_assert(( std::__is_random_access_iterator<random_access_iterator<char *> >::value), "" );
+    static_assert((!std::__is_exactly_input_iterator<random_access_iterator<char *> >::value), "" );
+
+    static_assert(( std::__is_input_iterator        <my_input_iterator<char *> >::value), "" );
+    static_assert((!std::__is_forward_iterator      <my_input_iterator<char *> >::value), "" );
+    static_assert((!std::__is_bidirectional_iterator<my_input_iterator<char *> >::value), "" );
+    static_assert((!std::__is_random_access_iterator<my_input_iterator<char *> >::value), "" );
+    static_assert(( std::__is_exactly_input_iterator<my_input_iterator<char *> >::value), "" );
 
 //
 //  iterators from libc++'s containers
diff --git a/test/libcxx/language.support/cxa_deleted_virtual.pass.cpp b/test/libcxx/language.support/cxa_deleted_virtual.pass.cpp
new file mode 100644
index 000000000000..ddef5d00e5da
--- /dev/null
+++ b/test/libcxx/language.support/cxa_deleted_virtual.pass.cpp
@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// Test exporting the symbol: "__cxa_deleted_virtual" in macosx
+// But don't expect the symbol to be exported in previous versions.
+//
+// XFAIL: with_system_cxx_lib=macosx10.13
+// XFAIL: with_system_cxx_lib=macosx10.12
+// XFAIL: with_system_cxx_lib=macosx10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+// XFAIL: with_system_cxx_lib=macosx10.8
+// XFAIL: with_system_cxx_lib=macosx10.7
+
+struct S { virtual void f() = delete; virtual ~S() {} };
+int main() {
+  S *s = new S;
+  delete s;
+}
diff --git a/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp b/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp
index 21aaa669fd43..cc98517b9f51 100644
--- a/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp
+++ b/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp
@@ -18,4 +18,5 @@
 int main()
 {
     std::complex<double> d;
+    (void)d;
 }
diff --git a/test/libcxx/selftest/test_macros.pass.cpp b/test/libcxx/selftest/test_macros.pass.cpp
index 69e75b788711..8d68c2184d65 100644
--- a/test/libcxx/selftest/test_macros.pass.cpp
+++ b/test/libcxx/selftest/test_macros.pass.cpp
@@ -56,7 +56,7 @@ void test_libcxx_macros()
 # endif
 #endif
 
-//  ===== C++1z features =====
+//  ===== C++17 features =====
 }
 
 int main()
diff --git a/test/libcxx/strings/iterators.noexcept.pass.cpp b/test/libcxx/strings/iterators.noexcept.pass.cpp
index 20b4e3d769e5..c9d2bf5c21d9 100644
--- a/test/libcxx/strings/iterators.noexcept.pass.cpp
+++ b/test/libcxx/strings/iterators.noexcept.pass.cpp
@@ -20,7 +20,7 @@
 //
 
 // MODULES_DEFINES: _LIBCPP_NO_EXCEPTIONS
-#define	_LIBCPP_NO_EXCEPTIONS
+#define _LIBCPP_NO_EXCEPTIONS
 
 #include <iterator>
 #include <cassert>
diff --git a/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp b/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp
index de225fe78384..7463b78af326 100644
--- a/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp
+++ b/test/libcxx/thread/thread.condition/PR30202_notify_from_pthread_created_thread.pass.cpp
@@ -20,7 +20,7 @@
 //   notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
 
 // Test that this function works with threads that were not created by
-// std::thread. See http://llvm.org/PR30202.
+// std::thread. See: https://bugs.llvm.org/show_bug.cgi?id=30202
 
 
 #include <condition_variable>
diff --git a/test/libcxx/type_traits/lazy_metafunctions.pass.cpp b/test/libcxx/type_traits/lazy_metafunctions.pass.cpp
index 8f75080ab956..8cf47a039594 100644
--- a/test/libcxx/type_traits/lazy_metafunctions.pass.cpp
+++ b/test/libcxx/type_traits/lazy_metafunctions.pass.cpp
@@ -134,4 +134,4 @@ int main() {
     LazyNotTest();
     LazyAndTest();
     LazyOrTest();
-}
\ No newline at end of file
+}
diff --git a/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp b/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
index 803c501f8c9e..58bb5fd10848 100644
--- a/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
+++ b/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
@@ -213,4 +213,4 @@ int main() {
     TestCase<ArgType volatile>::run();
     TestCase<ArgType const volatile>::run();
     TestCase<ArgType*>::run();
-}
\ No newline at end of file
+}
diff --git a/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp b/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp
index 87cd29264b4e..c94ce75fe685 100644
--- a/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp
+++ b/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/function_type_default_deleter.fail.cpp
@@ -36,7 +36,7 @@ int main() {
     SPtr<2> s2(getFn<2>(), Deleter{}); // OK
     SPtr<3> s3(nullptr, Deleter{}); // OK
   }
-  // expected-error@memory:* 2 {{static_assert failed "default_delete cannot be instantiated for function types"}}
+  // expected-error-re@memory:* 2 {{static_assert failed{{.*}} "default_delete cannot be instantiated for function types"}}
   {
     SPtr<4> s4(getFn<4>()); // expected-note {{requested here}}
     SPtr<5> s5(getFn<5>(), std::default_delete<FnType<5>>{}); // expected-note {{requested here}}
diff --git a/test/libcxx/utilities/tuple/tuple.tuple/diagnose_reference_binding.fail.cpp b/test/libcxx/utilities/tuple/tuple.tuple/diagnose_reference_binding.fail.cpp
index 76d5f0d679f6..1cc3c73d10fe 100644
--- a/test/libcxx/utilities/tuple/tuple.tuple/diagnose_reference_binding.fail.cpp
+++ b/test/libcxx/utilities/tuple/tuple.tuple/diagnose_reference_binding.fail.cpp
@@ -22,7 +22,7 @@
 int main() {
     std::allocator<void> alloc;
 
-    // expected-error@tuple:* 4 {{static_assert failed "Attempted to construct a reference element in a tuple with an rvalue"}}
+    // expected-error-re@tuple:* 4 {{static_assert failed{{.*}} "Attempted to construct a reference element in a tuple with an rvalue"}}
 
     // bind lvalue to rvalue
     std::tuple<int const&> t(42); // expected-note {{requested here}}
diff --git a/test/libcxx/utilities/tuple/tuple.tuple/diagnose_reference_binding.pass.cpp b/test/libcxx/utilities/tuple/tuple.tuple/diagnose_reference_binding.pass.cpp
index a90a2912d3a8..78446976431e 100644
--- a/test/libcxx/utilities/tuple/tuple.tuple/diagnose_reference_binding.pass.cpp
+++ b/test/libcxx/utilities/tuple/tuple.tuple/diagnose_reference_binding.pass.cpp
@@ -68,4 +68,4 @@ int main() {
         std::tuple<int const&> t4(std::allocator_arg, alloc, cr);
         assert(&std::get<0>(t4) == &x);
     }
-}
\ No newline at end of file
+}
diff --git a/test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp b/test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp
new file mode 100644
index 000000000000..a836ef5169ef
--- /dev/null
+++ b/test/libcxx/utilities/variant/variant.variant/variant_size.pass.cpp
@@ -0,0 +1,68 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <variant>
+
+// template <class ...Types> class variant;
+
+#include <limits>
+#include <type_traits>
+#include <utility>
+#include <variant>
+
+template <class Sequence>
+struct make_variant_imp;
+
+template <size_t ...Indices>
+struct make_variant_imp<std::integer_sequence<size_t, Indices...>> {
+  using type = std::variant<decltype((Indices, char(0)))...>;
+};
+
+template <size_t N>
+using make_variant_t = typename make_variant_imp<std::make_index_sequence<N>>::type;
+
+constexpr bool ExpectEqual =
+#ifdef _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION
+  false;
+#else
+  true;
+#endif
+
+template <class IndexType>
+void test_index_type() {
+  using Lim = std::numeric_limits<IndexType>;
+  using T1 = make_variant_t<Lim::max() - 1>;
+  using T2 = make_variant_t<Lim::max()>;
+  static_assert((sizeof(T1) == sizeof(T2)) == ExpectEqual, "");
+}
+
+template <class IndexType>
+void test_index_internals() {
+  using Lim = std::numeric_limits<IndexType>;
+  static_assert(std::__choose_index_type(Lim::max() -1) !=
+                std::__choose_index_type(Lim::max()), "");
+  static_assert(std::is_same_v<
+      std::__variant_index_t<Lim::max()-1>,
+      std::__variant_index_t<Lim::max()>
+    > == ExpectEqual, "");
+  using IndexT = std::__variant_index_t<Lim::max()-1>;
+  using IndexLim = std::numeric_limits<IndexT>;
+  static_assert(std::__variant_npos<IndexT> == IndexLim::max(), "");
+}
+
+int main() {
+  test_index_type<unsigned char>();
+  // This won't compile due to template depth issues.
+  //test_index_type<unsigned short>();
+  test_index_internals<unsigned char>();
+  test_index_internals<unsigned short>();
+}
diff --git a/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
index a9ccaf4cd959..b7322542931d 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp
@@ -15,32 +15,49 @@
 //   void
 //   generate_n(Iter first, Size n, Generator gen);
 
+#ifdef _MSC_VER
+#pragma warning(disable: 4244) // conversion from 'const double' to 'int', possible loss of data
+#endif
+
 #include <algorithm>
 #include <cassert>
 
+#include "test_macros.h"
 #include "test_iterators.h"
 #include "user_defined_integral.hpp"
 
-typedef UserDefinedIntegral<unsigned> UDI;
-
 struct gen_test
 {
     int operator()() const {return 2;}
 };
 
-template <class Iter>
+template <class Iter, class Size>
 void
-test()
+test2()
 {
     const unsigned n = 4;
     int ia[n] = {0};
-    assert(std::generate_n(Iter(ia), UDI(n), gen_test()) == Iter(ia+n));
+    assert(std::generate_n(Iter(ia), Size(n), gen_test()) == Iter(ia+n));
     assert(ia[0] == 2);
     assert(ia[1] == 2);
     assert(ia[2] == 2);
     assert(ia[3] == 2);
 }
 
+template <class Iter>
+void
+test()
+{
+    test2<Iter, int>();
+    test2<Iter, unsigned int>();
+    test2<Iter, long>();
+    test2<Iter, unsigned long>();
+    test2<Iter, UserDefinedIntegral<unsigned> >();
+    test2<Iter, float>();
+    test2<Iter, double>();  // this is PR#35498
+    test2<Iter, long double>();
+}
+
 int main()
 {
     test<forward_iterator<int*> >();
diff --git a/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
index ec0526c2dc5c..b837a0e514cf 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp
@@ -21,10 +21,10 @@
 #include "test_iterators.h"
 
 struct eq {
-	eq (int val) : v(val) {}
-	bool operator () (int v2) const { return v == v2; }
-	int v;
-	};
+    eq (int val) : v(val) {}
+    bool operator () (int v2) const { return v == v2; }
+    int v;
+    };
 
 
 int main()
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
index 761d71bbf287..fa1faf17e0f4 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp
@@ -21,10 +21,10 @@
 #include "test_iterators.h"
 
 struct eq {
-	eq (int val) : v(val) {}
-	bool operator () (int v2) const { return v == v2; }
-	int v;
-	};
+    eq (int val) : v(val) {}
+    bool operator () (int v2) const { return v == v2; }
+    int v;
+    };
 
 int main()
 {
diff --git a/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
index 2e52e260336d..1f3c34b2144f 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp
@@ -21,10 +21,10 @@
 #include "test_iterators.h"
 
 struct ne {
-	ne (int val) : v(val) {}
-	bool operator () (int v2) const { return v != v2; }
-	int v;
-	};
+    ne (int val) : v(val) {}
+    bool operator () (int v2) const { return v != v2; }
+    int v;
+    };
 
 
 int main()
diff --git a/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
index f7f8ee092796..4874bcad833e 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp
@@ -66,7 +66,7 @@ test()
     assert(std::search_n(Iter(ic), Iter(ic+sc), 4, 0) == Iter(ic+sc));
 
     // Check that we properly convert the size argument to an integral.
-    std::search_n(Iter(ic), Iter(ic+sc), UserDefinedIntegral<unsigned>(0), 0);
+    (void)std::search_n(Iter(ic), Iter(ic+sc), UserDefinedIntegral<unsigned>(0), 0);
 }
 
 int main()
diff --git a/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp
index 8bc6f4d26bdb..ff459b348932 100644
--- a/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp
@@ -142,7 +142,7 @@ test()
     count_equal::count = 0;
 
     // Check that we properly convert the size argument to an integral.
-    std::search_n(Iter(ic), Iter(ic+sc), UserDefinedIntegral<unsigned>(4), 0, count_equal());
+    TEST_IGNORE_NODISCARD std::search_n(Iter(ic), Iter(ic+sc), UserDefinedIntegral<unsigned>(4), 0, count_equal());
     count_equal::count = 0;
 }
 
diff --git a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
index eb37ccac5779..d4bc3fd70a81 100644
--- a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp
@@ -26,7 +26,7 @@ int main()
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
     int ib[] = {0, 1, 2, 3, 0, 1, 2, 3};
-    const unsigned sb = sizeof(ib)/sizeof(ib[0]); ((void)sb); // unused in c++11
+    const unsigned sb = sizeof(ib)/sizeof(ib[0]); ((void)sb); // unused in C++11
 
     typedef input_iterator<const int*> II;
     typedef random_access_iterator<const int*>  RAI;
diff --git a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
index d78809b48524..2a363826261e 100644
--- a/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
+++ b/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp
@@ -32,7 +32,7 @@ int main()
     int ia[] = {0, 1, 2, 2, 0, 1, 2, 3};
     const unsigned sa = sizeof(ia)/sizeof(ia[0]);
     int ib[] = {0, 1, 2, 3, 0, 1, 2, 3};
-    const unsigned sb = sizeof(ib)/sizeof(ib[0]); ((void)sb); // unused in c++11
+    const unsigned sb = sizeof(ib)/sizeof(ib[0]); ((void)sb); // unused in C++11
 
     typedef input_iterator<const int*> II;
     typedef random_access_iterator<const int*>  RAI;
diff --git a/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp b/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
index 1e18720bfbb3..7d734144ddce 100644
--- a/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.clamp/clamp.pass.cpp
@@ -18,13 +18,13 @@
 #include <cassert>
 
 struct Tag {
-	Tag() : val(0), tag("Default") {}
-	Tag(int a, const char *b) : val(a), tag(b) {}
-	~Tag() {}
+    Tag() : val(0), tag("Default") {}
+    Tag(int a, const char *b) : val(a), tag(b) {}
+    ~Tag() {}
 
-	int val;
-	const char *tag;
-	};
+    int val;
+    const char *tag;
+    };
 
 bool eq(const Tag& rhs, const Tag& lhs) { return rhs.val == lhs.val && rhs.tag == lhs.tag; }
 // bool operator==(const Tag& rhs, const Tag& lhs) { return rhs.val == lhs.val; }
diff --git a/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp b/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
index 683b07d32089..3743fa535239 100644
--- a/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp
@@ -23,24 +23,24 @@
 
 #if TEST_STD_VER >= 11
 struct S {
-	S() : i_(0) {}
-	S(int i) : i_(i) {}
+    S() : i_(0) {}
+    S(int i) : i_(i) {}
 
-	S(const S&  rhs) : i_(rhs.i_) {}
-	S(      S&& rhs) : i_(rhs.i_) { rhs.i_ = -1; }
+    S(const S&  rhs) : i_(rhs.i_) {}
+    S(      S&& rhs) : i_(rhs.i_) { rhs.i_ = -1; }
 
-	S& operator =(const S&  rhs) { i_ = rhs.i_;              return *this; }
-	S& operator =(      S&& rhs) { i_ = rhs.i_; rhs.i_ = -2; assert(this != &rhs); return *this; }
-	S& operator =(int i)         { i_ = i;                   return *this; }
+    S& operator =(const S&  rhs) { i_ = rhs.i_;              return *this; }
+    S& operator =(      S&& rhs) { i_ = rhs.i_; rhs.i_ = -2; assert(this != &rhs); return *this; }
+    S& operator =(int i)         { i_ = i;                   return *this; }
 
-	bool operator  <(const S&  rhs) const { return i_ < rhs.i_; }
-	bool operator ==(const S&  rhs) const { return i_ == rhs.i_; }
-	bool operator ==(int i)         const { return i_ == i; }
+    bool operator  <(const S&  rhs) const { return i_ < rhs.i_; }
+    bool operator ==(const S&  rhs) const { return i_ == rhs.i_; }
+    bool operator ==(int i)         const { return i_ == i; }
 
-	void set(int i) { i_ = i; }
+    void set(int i) { i_ = i; }
 
-	int i_;
-	};
+    int i_;
+    };
 #endif
 
 std::mt19937 randomness;
diff --git a/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
index 3d8902ec2271..992862a4ecf4 100644
--- a/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp
@@ -33,25 +33,25 @@ struct indirect_less
 };
 
 struct S {
-	S() : i_(0) {}
-	S(int i) : i_(i) {}
+    S() : i_(0) {}
+    S(int i) : i_(i) {}
 
-	S(const S&  rhs) : i_(rhs.i_) {}
-	S(      S&& rhs) : i_(rhs.i_) { rhs.i_ = -1; }
+    S(const S&  rhs) : i_(rhs.i_) {}
+    S(      S&& rhs) : i_(rhs.i_) { rhs.i_ = -1; }
 
-	S& operator =(const S&  rhs) { i_ = rhs.i_;              return *this; }
-	S& operator =(      S&& rhs) { i_ = rhs.i_; rhs.i_ = -2; assert(this != &rhs); return *this; }
-	S& operator =(int i)         { i_ = i;                   return *this; }
+    S& operator =(const S&  rhs) { i_ = rhs.i_;              return *this; }
+    S& operator =(      S&& rhs) { i_ = rhs.i_; rhs.i_ = -2; assert(this != &rhs); return *this; }
+    S& operator =(int i)         { i_ = i;                   return *this; }
 
-	bool operator  <(const S&  rhs) const { return i_ < rhs.i_; }
-	bool operator  >(const S&  rhs) const { return i_ > rhs.i_; }
-	bool operator ==(const S&  rhs) const { return i_ == rhs.i_; }
-	bool operator ==(int i)         const { return i_ == i; }
+    bool operator  <(const S&  rhs) const { return i_ < rhs.i_; }
+    bool operator  >(const S&  rhs) const { return i_ > rhs.i_; }
+    bool operator ==(const S&  rhs) const { return i_ == rhs.i_; }
+    bool operator ==(int i)         const { return i_ == i; }
 
-	void set(int i) { i_ = i; }
+    void set(int i) { i_ = i; }
 
-	int i_;
-	};
+    int i_;
+    };
 
 
 #endif  // TEST_STD_VER >= 11
@@ -116,6 +116,26 @@ test()
     test<Iter>(1000);
 }
 
+struct less_by_first {
+  template <typename Pair>
+  bool operator()(const Pair& lhs, const Pair& rhs) {
+    return std::less<typename Pair::first_type>()(lhs.first, rhs.first);
+  }
+};
+
+void test_PR31166 ()
+{
+    typedef std::pair<int, int> P;
+    typedef std::vector<P> V;
+    P vec[5] = {P(1, 0), P(2, 0), P(2, 1), P(2, 2), P(2, 3)};
+    for ( int i = 0; i < 5; ++i ) {
+        V res(vec, vec + 5);
+        std::inplace_merge(res.begin(), res.begin() + i, res.end(), less_by_first());
+        assert(res.size() == 5);
+        assert(std::equal(res.begin(), res.end(), vec));
+    }
+}
+
 int main()
 {
     test<bidirectional_iterator<int*> >();
@@ -146,4 +166,6 @@ int main()
     delete [] ia;
     }
 #endif  // TEST_STD_VER >= 11
+
+    test_PR31166();
 }
diff --git a/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp b/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
index 402d57dae69e..da76d2a36c18 100644
--- a/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp
@@ -87,8 +87,8 @@ struct less { constexpr bool operator ()( const int &x, const int &y) const { re
 void constexpr_test()
 {
 #if TEST_STD_VER >= 14
-	constexpr auto p = std::min_element(il, il+8, less());
-	static_assert(*p == 1, "");
+    constexpr auto p = std::min_element(il, il+8, less());
+    static_assert(*p == 1, "");
 #endif
 }
 
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_move.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_move.pass.cpp
new file mode 100644
index 000000000000..078060176b73
--- /dev/null
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_move.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// template<InputIterator InIter1, InputIterator InIter2, typename OutIter,
+//          CopyConstructible Compare>
+//   requires OutputIterator<OutIter, InIter1::reference>
+//         && OutputIterator<OutIter, InIter2::reference>
+//         && Predicate<Compare, InIter1::value_type, InIter2::value_type>
+//         && Predicate<Compare, InIter2::value_type, InIter1::value_type>
+//   OutIter
+//   set_union(InIter1 first1, InIter1 last1, InIter2 first2, InIter2 last2,
+//             OutIter result, Compare comp);
+
+// UNSUPPORTED: c++98, c++03
+
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+#include <vector>
+
+#include "MoveOnly.h"
+
+
+int main()
+{
+    std::vector<MoveOnly> lhs, rhs;
+    lhs.push_back(MoveOnly(2));
+    rhs.push_back(MoveOnly(2));
+
+    std::vector<MoveOnly> res;
+    std::set_union(std::make_move_iterator(lhs.begin()),
+                   std::make_move_iterator(lhs.end()),
+                   std::make_move_iterator(rhs.begin()),
+                   std::make_move_iterator(rhs.end()), std::back_inserter(res));
+
+    assert(res.size() == 1);
+    assert(res[0].get() == 2);
+}
diff --git a/test/std/atomics/atomics.types.generic/integral.pass.cpp b/test/std/atomics/atomics.types.generic/integral.pass.cpp
index 63cc02befb7e..74b8c60a3877 100644
--- a/test/std/atomics/atomics.types.generic/integral.pass.cpp
+++ b/test/std/atomics/atomics.types.generic/integral.pass.cpp
@@ -187,14 +187,14 @@ int main()
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<std::atomic_wchar_t, wchar_t>();
 
-	test<std::atomic_int8_t,    int8_t>();
-	test<std::atomic_uint8_t,  uint8_t>();
-	test<std::atomic_int16_t,   int16_t>();
-	test<std::atomic_uint16_t, uint16_t>();
-	test<std::atomic_int32_t,   int32_t>();
-	test<std::atomic_uint32_t, uint32_t>();
-	test<std::atomic_int64_t,   int64_t>();
-	test<std::atomic_uint64_t, uint64_t>();
+    test<std::atomic_int8_t,    int8_t>();
+    test<std::atomic_uint8_t,  uint8_t>();
+    test<std::atomic_int16_t,   int16_t>();
+    test<std::atomic_uint16_t, uint16_t>();
+    test<std::atomic_int32_t,   int32_t>();
+    test<std::atomic_uint32_t, uint32_t>();
+    test<std::atomic_int64_t,   int64_t>();
+    test<std::atomic_uint64_t, uint64_t>();
 
     test<volatile std::atomic_char, char>();
     test<volatile std::atomic_schar, signed char>();
@@ -213,12 +213,12 @@ int main()
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<volatile std::atomic_wchar_t, wchar_t>();
 
-	test<volatile std::atomic_int8_t,    int8_t>();
-	test<volatile std::atomic_uint8_t,  uint8_t>();
-	test<volatile std::atomic_int16_t,   int16_t>();
-	test<volatile std::atomic_uint16_t, uint16_t>();
-	test<volatile std::atomic_int32_t,   int32_t>();
-	test<volatile std::atomic_uint32_t, uint32_t>();
-	test<volatile std::atomic_int64_t,   int64_t>();
-	test<volatile std::atomic_uint64_t, uint64_t>();
+    test<volatile std::atomic_int8_t,    int8_t>();
+    test<volatile std::atomic_uint8_t,  uint8_t>();
+    test<volatile std::atomic_int16_t,   int16_t>();
+    test<volatile std::atomic_uint16_t, uint16_t>();
+    test<volatile std::atomic_int32_t,   int32_t>();
+    test<volatile std::atomic_uint32_t, uint32_t>();
+    test<volatile std::atomic_int64_t,   int64_t>();
+    test<volatile std::atomic_uint64_t, uint64_t>();
 }
diff --git a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h
index 482b7319dab2..2ba561fe2d3b 100644
--- a/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h
+++ b/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h
@@ -43,14 +43,14 @@ struct TestEachIntegralType {
         TestFunctor<char16_t>()();
         TestFunctor<char32_t>()();
 #endif
-		TestFunctor<  int8_t>()();
-		TestFunctor< uint8_t>()();
-		TestFunctor< int16_t>()();
-		TestFunctor<uint16_t>()();
-		TestFunctor< int32_t>()();
-		TestFunctor<uint32_t>()();
-		TestFunctor< int64_t>()();
-		TestFunctor<uint64_t>()();
+        TestFunctor<  int8_t>()();
+        TestFunctor< uint8_t>()();
+        TestFunctor< int16_t>()();
+        TestFunctor<uint16_t>()();
+        TestFunctor< int32_t>()();
+        TestFunctor<uint32_t>()();
+        TestFunctor< int64_t>()();
+        TestFunctor<uint64_t>()();
     }
 };
 
diff --git a/test/std/containers/Emplaceable.h b/test/std/containers/Emplaceable.h
index f9319d410d2b..331a81ff311f 100644
--- a/test/std/containers/Emplaceable.h
+++ b/test/std/containers/Emplaceable.h
@@ -45,8 +45,10 @@ namespace std {
 
 template <>
 struct hash<Emplaceable>
-    : public std::unary_function<Emplaceable, std::size_t>
 {
+    typedef Emplaceable argument_type;
+    typedef std::size_t result_type;
+
     std::size_t operator()(const Emplaceable& x) const {return x.get();}
 };
 
diff --git a/test/std/containers/NotConstructible.h b/test/std/containers/NotConstructible.h
index ac8b98ef99f0..55e6480496ee 100644
--- a/test/std/containers/NotConstructible.h
+++ b/test/std/containers/NotConstructible.h
@@ -29,8 +29,10 @@ namespace std
 
 template <>
 struct hash<NotConstructible>
-    : public std::unary_function<NotConstructible, std::size_t>
 {
+    typedef NotConstructible argument_type;
+    typedef std::size_t result_type;
+
     std::size_t operator()(const NotConstructible&) const {return 0;}
 };
 
diff --git a/test/std/containers/associative/map/map.access/at.pass.cpp b/test/std/containers/associative/map/map.access/at.pass.cpp
index 6d3e98e9e78b..5822706fbfb3 100644
--- a/test/std/containers/associative/map/map.access/at.pass.cpp
+++ b/test/std/containers/associative/map/map.access/at.pass.cpp
@@ -46,7 +46,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
-            m.at(6);
+            TEST_IGNORE_NODISCARD m.at(6);
             assert(false);
         }
         catch (std::out_of_range&)
@@ -79,7 +79,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
-            m.at(6);
+            TEST_IGNORE_NODISCARD m.at(6);
             assert(false);
         }
         catch (std::out_of_range&)
@@ -115,7 +115,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
-            m.at(6);
+            TEST_IGNORE_NODISCARD m.at(6);
             assert(false);
         }
         catch (std::out_of_range&)
@@ -148,7 +148,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
-            m.at(6);
+            TEST_IGNORE_NODISCARD m.at(6);
             assert(false);
         }
         catch (std::out_of_range&)
diff --git a/test/std/containers/associative/map/map.access/empty.fail.cpp b/test/std/containers/associative/map/map.access/empty.fail.cpp
new file mode 100644
index 000000000000..14ac13c99688
--- /dev/null
+++ b/test/std/containers/associative/map/map.access/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// class map
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <map>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::map<int, int> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/associative/map/map.cons/compare.pass.cpp b/test/std/containers/associative/map/map.cons/compare.pass.cpp
index 5d8d5e252507..326ce74fc39c 100644
--- a/test/std/containers/associative/map/map.cons/compare.pass.cpp
+++ b/test/std/containers/associative/map/map.cons/compare.pass.cpp
@@ -13,6 +13,8 @@
 
 // explicit map(const key_compare& comp);
 
+// key_compare key_comp() const;
+
 #include <map>
 #include <cassert>
 
@@ -23,7 +25,7 @@ int main()
 {
     {
     typedef test_compare<std::less<int> > C;
-    std::map<int, double, C> m(C(3));
+    const std::map<int, double, C> m(C(3));
     assert(m.empty());
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(3));
@@ -31,7 +33,7 @@ int main()
 #if TEST_STD_VER >= 11
     {
     typedef test_compare<std::less<int> > C;
-    std::map<int, double, C, min_allocator<std::pair<const int, double>>> m(C(3));
+    const std::map<int, double, C, min_allocator<std::pair<const int, double>>> m(C(3));
     assert(m.empty());
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(3));
diff --git a/test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp b/test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp
index 210c27050a60..a1fde845e9cb 100644
--- a/test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/associative/map/map.cons/compare_copy_constructible.fail.cpp
@@ -16,14 +16,14 @@
 
 template <class T>
 struct Comp {
-	bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
+    bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
 
-	Comp () {}
+    Comp () {}
 private:
-	Comp (const Comp &); // declared but not defined
-	};
+    Comp (const Comp &); // declared but not defined
+    };
 
 
 int main() {
-	std::map<int, int, Comp<int> > m;
+    std::map<int, int, Comp<int> > m;
 }
diff --git a/test/std/containers/associative/map/map.ops/count0.pass.cpp b/test/std/containers/associative/map/map.ops/count0.pass.cpp
index 1fa8c4a70bd9..5649c57f25b9 100644
--- a/test/std/containers/associative/map/map.ops/count0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/count0.pass.cpp
@@ -30,10 +30,10 @@ int main()
 {
     {
     typedef std::map<int, double, transparent_less> M;
-    M().count(C2Int{5});
+    assert(M().count(C2Int{5}) == 0);
     }
     {
     typedef std::map<int, double, transparent_less_not_referenceable> M;
-    M().count(C2Int{5});
+    assert(M().count(C2Int{5}) == 0);
     }
 }
diff --git a/test/std/containers/associative/map/map.ops/count1.fail.cpp b/test/std/containers/associative/map/map.ops/count1.fail.cpp
index bd0bf2ec4a04..9fa9f87b8dab 100644
--- a/test/std/containers/associative/map/map.ops/count1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/count1.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::map<int, double, transparent_less_no_type> M;
 
-    M().count(C2Int{5});
+    TEST_IGNORE_NODISCARD M().count(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/map/map.ops/count2.fail.cpp b/test/std/containers/associative/map/map.ops/count2.fail.cpp
index ff4bed8cb60c..c6380635af4e 100644
--- a/test/std/containers/associative/map/map.ops/count2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/count2.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::map<int, double, transparent_less_private> M;
 
-    M().count(C2Int{5});
+    TEST_IGNORE_NODISCARD M().count(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/map/map.ops/count3.fail.cpp b/test/std/containers/associative/map/map.ops/count3.fail.cpp
index 55a463ed38a6..0fddf61b8d82 100644
--- a/test/std/containers/associative/map/map.ops/count3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/count3.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
 
-    M().count(C2Int{5});
+    TEST_IGNORE_NODISCARD M().count(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp b/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp
index c254fb6a7db7..310db6d89374 100644
--- a/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range0.pass.cpp
@@ -30,10 +30,16 @@ int main()
 {
     {
     typedef std::map<int, double, transparent_less> M;
-    M().equal_range(C2Int{5});
+    typedef std::pair<typename M::iterator, typename M::iterator> P;
+    M example;
+    P result = example.equal_range(C2Int{5});
+    assert(result.first == result.second);
     }
     {
     typedef std::map<int, double, transparent_less_not_referenceable> M;
-    M().equal_range(C2Int{5});
+    typedef std::pair<typename M::iterator, typename M::iterator> P;
+    M example;
+    P result = example.equal_range(C2Int{5});
+    assert(result.first == result.second);
     }
 }
diff --git a/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp b/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp
index a92ad96921c1..b8c8607ee33d 100644
--- a/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range1.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::map<int, double, transparent_less_no_type> M;
 
-    M().equal_range(C2Int{5});
+    TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp b/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp
index 23357e26897a..2fb1b2d2e8bb 100644
--- a/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range2.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::map<int, double, transparent_less_private> M;
 
-    M().equal_range(C2Int{5});
+    TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp b/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp
index 3ffa3f22a619..ad499e1c6cfc 100644
--- a/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/equal_range3.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
 
-    M().equal_range(C2Int{5});
+    TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/map/map.ops/find0.pass.cpp b/test/std/containers/associative/map/map.ops/find0.pass.cpp
index 76fe9242a476..a11acb103745 100644
--- a/test/std/containers/associative/map/map.ops/find0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/find0.pass.cpp
@@ -30,10 +30,12 @@ int main()
 {
     {
     typedef std::map<int, double, transparent_less> M;
-    M().find(C2Int{5});
+    M example;
+    assert(example.find(C2Int{5}) == example.end());
     }
     {
     typedef std::map<int, double, transparent_less_not_referenceable> M;
-    M().find(C2Int{5});
+    M example;
+    assert(example.find(C2Int{5}) == example.end());
     }
 }
diff --git a/test/std/containers/associative/map/map.ops/find1.fail.cpp b/test/std/containers/associative/map/map.ops/find1.fail.cpp
index 5346821b42af..6c0f237a2476 100644
--- a/test/std/containers/associative/map/map.ops/find1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/find1.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::map<int, double, transparent_less_no_type> M;
 
-    M().find(C2Int{5});
+    TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/map/map.ops/find2.fail.cpp b/test/std/containers/associative/map/map.ops/find2.fail.cpp
index 1dfb7fa44b06..b915b4396748 100644
--- a/test/std/containers/associative/map/map.ops/find2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/find2.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::map<int, double, transparent_less_private> M;
 
-    M().find(C2Int{5});
+    TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/map/map.ops/find3.fail.cpp b/test/std/containers/associative/map/map.ops/find3.fail.cpp
index f5e92b8264b7..9303a7f07bc1 100644
--- a/test/std/containers/associative/map/map.ops/find3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/find3.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
 
-    M().find(C2Int{5});
+    TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp b/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp
index de7a545b6497..2936da3cb441 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound0.pass.cpp
@@ -30,10 +30,12 @@ int main()
 {
     {
     typedef std::map<int, double, transparent_less> M;
-    M().lower_bound(C2Int{5});
+    M example;
+    assert(example.lower_bound(C2Int{5}) == example.end());
     }
     {
     typedef std::map<int, double, transparent_less_not_referenceable> M;
-    M().lower_bound(C2Int{5});
+    M example;
+    assert(example.lower_bound(C2Int{5}) == example.end());
     }
 }
diff --git a/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp b/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp
index 6a3ed96a4fc5..beb901cf0775 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound1.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::map<int, double, transparent_less_no_type> M;
 
-    M().lower_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp b/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp
index 87fffe7afcce..2a2258e8f4e1 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound2.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::map<int, double, transparent_less_private> M;
 
-    M().lower_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp b/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp
index fbccd3ab221b..40dc708ad754 100644
--- a/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/lower_bound3.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
 
-    M().lower_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp b/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp
index 94508d284fd2..fa97a7144862 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound0.pass.cpp
@@ -30,10 +30,12 @@ int main()
 {
     {
     typedef std::map<int, double, transparent_less> M;
-    M().upper_bound(C2Int{5});
+    M example;
+    assert(example.upper_bound(C2Int{5}) == example.end());
     }
     {
     typedef std::map<int, double, transparent_less_not_referenceable> M;
-    M().upper_bound(C2Int{5});
+    M example;
+    assert(example.upper_bound(C2Int{5}) == example.end());
     }
 }
diff --git a/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp b/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp
index cb23588e2b97..be40cec7612b 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound1.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::map<int, double, transparent_less_no_type> M;
 
-    M().upper_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp b/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp
index 1fa4cbc70012..c03c249b7364 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound2.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::map<int, double, transparent_less_private> M;
 
-    M().upper_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp b/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp
index 0f3cea238295..584833921e9a 100644
--- a/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp
+++ b/test/std/containers/associative/map/map.ops/upper_bound3.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::map<int, double, transparent_less_not_a_type> M;
 
-    M().upper_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/multimap/empty.fail.cpp b/test/std/containers/associative/multimap/empty.fail.cpp
new file mode 100644
index 000000000000..12ca05ef192b
--- /dev/null
+++ b/test/std/containers/associative/multimap/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <map>
+
+// class multimap
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <map>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::multimap<int, int> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp b/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
index 59a972f45687..02fde1a5388a 100644
--- a/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/compare.pass.cpp
@@ -13,6 +13,8 @@
 
 // explicit multimap(const key_compare& comp);
 
+// key_compare key_comp() const;
+
 #include <map>
 #include <cassert>
 
@@ -23,7 +25,7 @@ int main()
 {
     {
     typedef test_compare<std::less<int> > C;
-    std::multimap<int, double, C> m(C(3));
+    const std::multimap<int, double, C> m(C(3));
     assert(m.empty());
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(3));
@@ -31,7 +33,7 @@ int main()
 #if TEST_STD_VER >= 11
     {
     typedef test_compare<std::less<int> > C;
-    std::multimap<int, double, C, min_allocator<std::pair<const int, double>>> m(C(3));
+    const std::multimap<int, double, C, min_allocator<std::pair<const int, double>>> m(C(3));
     assert(m.empty());
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(3));
diff --git a/test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp b/test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp
index 3d33f721a56d..ee96ed0a13af 100644
--- a/test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.cons/compare_copy_constructible.fail.cpp
@@ -16,14 +16,14 @@
 
 template <class T>
 struct Comp {
-	bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
+    bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
 
-	Comp () {}
+    Comp () {}
 private:
-	Comp (const Comp &); // declared but not defined
-	};
+    Comp (const Comp &); // declared but not defined
+    };
 
 
 int main() {
-	std::multimap<int, int, Comp<int> > m;
+    std::multimap<int, int, Comp<int> > m;
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp
index 289d405739ac..db84dcf7b29e 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count0.pass.cpp
@@ -30,10 +30,10 @@ int main()
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
-    M().count(C2Int{5});
+    assert(M().count(C2Int{5}) == 0);
     }
     {
     typedef std::multimap<int, double, transparent_less_not_referenceable> M;
-    M().count(C2Int{5});
+    assert(M().count(C2Int{5}) == 0);
     }
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp
index 70464b12c741..393dd2988086 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count1.fail.cpp
@@ -33,6 +33,6 @@ int main()
 {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
-    M().count(C2Int{5});
+    TEST_IGNORE_NODISCARD M().count(C2Int{5});
 }
 #endif
diff --git a/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp
index ad15ff441d74..3fda00765761 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count2.fail.cpp
@@ -33,6 +33,6 @@ int main()
 {
     typedef std::multimap<int, double, transparent_less_private> M;
 
-    M().count(C2Int{5});
+    TEST_IGNORE_NODISCARD M().count(C2Int{5});
 }
 #endif
diff --git a/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp
index 5e6c9ab6f967..94453c8f3fae 100644
--- a/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/count3.fail.cpp
@@ -33,6 +33,6 @@ int main()
 {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
-    M().count(C2Int{5});
+    TEST_IGNORE_NODISCARD M().count(C2Int{5});
 }
 #endif
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp
index 8cdd3c03372f..0c093898d13b 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range0.pass.cpp
@@ -30,10 +30,16 @@ int main()
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
-    M().equal_range(C2Int{5});
+    typedef std::pair<typename M::iterator, typename M::iterator> P;
+    M example;
+    P result = example.equal_range(C2Int{5});
+    assert(result.first == result.second);
     }
     {
     typedef std::multimap<int, double, transparent_less_not_referenceable> M;
-    M().equal_range(C2Int{5});
+    typedef std::pair<typename M::iterator, typename M::iterator> P;
+    M example;
+    P result = example.equal_range(C2Int{5});
+    assert(result.first == result.second);
     }
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp
index a339467f7390..396b49ebc650 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range1.fail.cpp
@@ -33,6 +33,6 @@ int main()
 {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
-    M().equal_range(C2Int{5});
+    TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
 }
 #endif
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp
index 633e0615bef0..1741ee24c174 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range2.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::multimap<int, double, transparent_less_private> M;
 
-    M().equal_range(C2Int{5});
+    TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp
index 34b1b4b77fbe..f555a31f92fd 100644
--- a/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/equal_range3.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
-    M().equal_range(C2Int{5});
+    TEST_IGNORE_NODISCARD M().equal_range(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp
index a06ec4d702d5..0cff61131a00 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find0.pass.cpp
@@ -30,10 +30,12 @@ int main()
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
-    M().find(C2Int{5});
+    M example;
+    assert(example.find(C2Int{5}) == example.end());
     }
     {
     typedef std::multimap<int, double, transparent_less_not_referenceable> M;
-    M().find(C2Int{5});
+    M example;
+    assert(example.find(C2Int{5}) == example.end());
     }
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp
index bc3593292be2..acea15604319 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find1.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
-    M().find(C2Int{5});
+    TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp
index 254f524afd5b..38b77684c2d1 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find2.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::multimap<int, double, transparent_less_private> M;
 
-    M().find(C2Int{5});
+    TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp
index 2805f47598f6..feb6009ed8d0 100644
--- a/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/find3.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
-    M().find(C2Int{5});
+    TEST_IGNORE_NODISCARD M().find(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp
index 1000aa772b31..4a882af4ee09 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound0.pass.cpp
@@ -30,10 +30,12 @@ int main()
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
-    M().lower_bound(C2Int{5});
+    M example;
+    assert(example.lower_bound(C2Int{5}) == example.end());
     }
     {
     typedef std::multimap<int, double, transparent_less_not_referenceable> M;
-    M().lower_bound(C2Int{5});
+    M example;
+    assert(example.lower_bound(C2Int{5}) == example.end());
     }
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp
index 4b0db47872af..aec942fa00f4 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound1.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
-    M().lower_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp
index 300364cffa25..1a856ad84c64 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound2.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::multimap<int, double, transparent_less_private> M;
 
-    M().lower_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp
index 09963096fdfa..4b02c97f834f 100644
--- a/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/lower_bound3.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
-    M().lower_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().lower_bound(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp
index 1a572e9c5070..d7618141fe1d 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound0.pass.cpp
@@ -30,10 +30,12 @@ int main()
 {
     {
     typedef std::multimap<int, double, transparent_less> M;
-    M().upper_bound(C2Int{5});
+    M example;
+    assert(example.upper_bound(C2Int{5}) == example.end());
     }
     {
     typedef std::multimap<int, double, transparent_less_not_referenceable> M;
-    M().upper_bound(C2Int{5});
+    M example;
+    assert(example.upper_bound(C2Int{5}) == example.end());
     }
 }
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp
index 10e59c5e580e..613194abb632 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound1.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::multimap<int, double, transparent_less_no_type> M;
 
-    M().upper_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp
index 81ebbb832c06..100a45e5e61d 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound2.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::multimap<int, double, transparent_less_private> M;
 
-    M().upper_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp b/test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp
index fe41315247ea..b90cd0ac633f 100644
--- a/test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp
+++ b/test/std/containers/associative/multimap/multimap.ops/upper_bound3.fail.cpp
@@ -34,7 +34,7 @@ int main()
     {
     typedef std::multimap<int, double, transparent_less_not_a_type> M;
 
-    M().upper_bound(C2Int{5});
+    TEST_IGNORE_NODISCARD M().upper_bound(C2Int{5});
     }
 }
 #endif
diff --git a/test/std/containers/associative/multiset/empty.fail.cpp b/test/std/containers/associative/multiset/empty.fail.cpp
new file mode 100644
index 000000000000..2169a07e4bbe
--- /dev/null
+++ b/test/std/containers/associative/multiset/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <set>
+
+// class multiset
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <set>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::multiset<int> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/associative/multiset/equal_range.pass.cpp b/test/std/containers/associative/multiset/equal_range.pass.cpp
index 1a3beebcf66b..c9f469ba39be 100644
--- a/test/std/containers/associative/multiset/equal_range.pass.cpp
+++ b/test/std/containers/associative/multiset/equal_range.pass.cpp
@@ -77,7 +77,7 @@ int main()
             9,
             9
         };
-        M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
+        const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
         R r = m.equal_range(4);
         assert(r.first  == next(m.begin(), 0));
         assert(r.second == next(m.begin(), 0));
@@ -156,7 +156,7 @@ int main()
             9,
             9
         };
-        M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
+        const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
         R r = m.equal_range(4);
         assert(r.first  == next(m.begin(), 0));
         assert(r.second == next(m.begin(), 0));
diff --git a/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp b/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp
index 84038ca1e142..26ca80120fdc 100644
--- a/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/compare.pass.cpp
@@ -12,6 +12,10 @@
 // class multiset
 
 // explicit multiset(const value_compare& comp);
+// value_compare and key_compare are the same type for set/multiset
+
+// key_compare    key_comp() const;
+// value_compare value_comp() const;
 
 #include <set>
 #include <cassert>
@@ -21,8 +25,9 @@
 int main()
 {
     typedef test_compare<std::less<int> > C;
-    std::multiset<int, C> m(C(3));
+    const std::multiset<int, C> m(C(3));
     assert(m.empty());
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(3));
+    assert(m.value_comp() == C(3));
 }
diff --git a/test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp b/test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp
index 9287a035becb..4f9a6d61be4a 100644
--- a/test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/associative/multiset/multiset.cons/compare_copy_constructible.fail.cpp
@@ -16,14 +16,14 @@
 
 template <class T>
 struct Comp {
-	bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
+    bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
 
-	Comp () {}
+    Comp () {}
 private:
-	Comp (const Comp &); // declared but not defined
-	};
+    Comp (const Comp &); // declared but not defined
+    };
 
 
 int main() {
-	std::multiset<int, Comp<int> > m;
+    std::multiset<int, Comp<int> > m;
 }
diff --git a/test/std/containers/associative/set/empty.fail.cpp b/test/std/containers/associative/set/empty.fail.cpp
new file mode 100644
index 000000000000..0eea6fb675fe
--- /dev/null
+++ b/test/std/containers/associative/set/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <set>
+
+// class set
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <set>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::set<int> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/associative/set/set.cons/compare.pass.cpp b/test/std/containers/associative/set/set.cons/compare.pass.cpp
index af94c70671b8..0dac363cab70 100644
--- a/test/std/containers/associative/set/set.cons/compare.pass.cpp
+++ b/test/std/containers/associative/set/set.cons/compare.pass.cpp
@@ -11,7 +11,11 @@
 
 // class set
 
-// explicit set(const value_compare& comp);
+// explicit set(const value_compare& comp) const;
+// value_compare and key_compare are the same type for set/multiset
+
+// key_compare    key_comp() const;
+// value_compare value_comp() const;
 
 #include <set>
 #include <cassert>
@@ -21,8 +25,9 @@
 int main()
 {
     typedef test_compare<std::less<int> > C;
-    std::set<int, C> m(C(3));
+    const std::set<int, C> m(C(3));
     assert(m.empty());
     assert(m.begin() == m.end());
     assert(m.key_comp() == C(3));
+    assert(m.value_comp() == C(3));
 }
diff --git a/test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp b/test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp
index 858ee4161f03..94ce9cd55247 100644
--- a/test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/associative/set/set.cons/compare_copy_constructible.fail.cpp
@@ -16,14 +16,14 @@
 
 template <class T>
 struct Comp {
-	bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
+    bool operator () (const T& lhs, const T& rhs) const { return lhs < rhs; }
 
-	Comp () {}
+    Comp () {}
 private:
-	Comp (const Comp &); // declared but not defined
-	};
+    Comp (const Comp &); // declared but not defined
+    };
 
 
 int main() {
-	std::set<int, Comp<int> > m;
+    std::set<int, Comp<int> > m;
 }
diff --git a/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.fail.cpp b/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.fail.cpp
new file mode 100644
index 000000000000..c034f22b773a
--- /dev/null
+++ b/test/std/containers/container.adaptors/priority.queue/priqueue.members/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <queue>
+
+// class priority_queue
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <queue>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::priority_queue<int> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/container.adaptors/priority.queue/types.fail.cpp b/test/std/containers/container.adaptors/priority.queue/types.fail.cpp
index 0d3025e1739a..832f09058411 100644
--- a/test/std/containers/container.adaptors/priority.queue/types.fail.cpp
+++ b/test/std/containers/container.adaptors/priority.queue/types.fail.cpp
@@ -31,5 +31,5 @@
 int main()
 {
 //  LWG#2566 says that the first template param must match the second one's value type
-	std::priority_queue<double, std::deque<int>> t;
+    std::priority_queue<double, std::deque<int>> t;
 }
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/empty.fail.cpp b/test/std/containers/container.adaptors/queue/queue.defn/empty.fail.cpp
new file mode 100644
index 000000000000..ce017d2ddd4f
--- /dev/null
+++ b/test/std/containers/container.adaptors/queue/queue.defn/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <queue>
+
+// class queue
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <queue>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::queue<int> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp b/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp
index 2b8341fff009..4bd90a88b11f 100644
--- a/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp
+++ b/test/std/containers/container.adaptors/queue/queue.defn/types.fail.cpp
@@ -16,5 +16,5 @@
 int main()
 {
 //  LWG#2566 says that the first template param must match the second one's value type
-	std::queue<double, std::deque<int>> t;
+    std::queue<double, std::deque<int>> t;
 }
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/empty.fail.cpp b/test/std/containers/container.adaptors/stack/stack.defn/empty.fail.cpp
new file mode 100644
index 000000000000..001a38fe3d2b
--- /dev/null
+++ b/test/std/containers/container.adaptors/stack/stack.defn/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <stack>
+
+// class stack
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <stack>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::stack<int> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp b/test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp
index ee4c5441e7c3..1cfa8e4da3ab 100644
--- a/test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp
+++ b/test/std/containers/container.adaptors/stack/stack.defn/types.fail.cpp
@@ -31,5 +31,5 @@
 int main()
 {
 //  LWG#2566 says that the first template param must match the second one's value type
-	std::stack<double, std::deque<int>> t;
+    std::stack<double, std::deque<int>> t;
 }
diff --git a/test/std/containers/sequences/array/at.pass.cpp b/test/std/containers/sequences/array/at.pass.cpp
index efec4e403001..27b326fa7ce4 100644
--- a/test/std/containers/sequences/array/at.pass.cpp
+++ b/test/std/containers/sequences/array/at.pass.cpp
@@ -27,7 +27,7 @@
 constexpr bool check_idx( size_t idx, double val )
 {
     std::array<double, 3> arr = {1, 2, 3.5};
-	return arr.at(idx) == val;
+    return arr.at(idx) == val;
 }
 #endif
 
@@ -50,7 +50,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
-            (void) c.at(3);
+            TEST_IGNORE_NODISCARD  c.at(3);
             assert(false);
         }
         catch (const std::out_of_range &) {}
@@ -69,7 +69,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
-            (void) c.at(3);
+            TEST_IGNORE_NODISCARD  c.at(3);
             assert(false);
         }
         catch (const std::out_of_range &) {}
diff --git a/test/std/containers/sequences/array/empty.fail.cpp b/test/std/containers/sequences/array/empty.fail.cpp
new file mode 100644
index 000000000000..85bf5a7c9dab
--- /dev/null
+++ b/test/std/containers/sequences/array/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <array>
+
+// class array
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <array>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::array<int, 1> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/sequences/array/empty.pass.cpp b/test/std/containers/sequences/array/empty.pass.cpp
new file mode 100644
index 000000000000..2c01dfc86c19
--- /dev/null
+++ b/test/std/containers/sequences/array/empty.pass.cpp
@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <array>
+
+// class array
+
+// bool empty() const noexcept;
+
+#include <array>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::array<int, 2> C;
+    C c;
+    ASSERT_NOEXCEPT(c.empty());
+    assert(!c.empty());
+    }
+    {
+    typedef std::array<int, 0> C;
+    C c;
+    ASSERT_NOEXCEPT(c.empty());
+    assert( c.empty());
+    }
+}
diff --git a/test/std/containers/sequences/array/front_back.pass.cpp b/test/std/containers/sequences/array/front_back.pass.cpp
index 68fc6cdc4543..0591ca7fac31 100644
--- a/test/std/containers/sequences/array/front_back.pass.cpp
+++ b/test/std/containers/sequences/array/front_back.pass.cpp
@@ -27,13 +27,13 @@
 constexpr bool check_front( double val )
 {
     std::array<double, 3> arr = {1, 2, 3.5};
-	return arr.front() == val;
+    return arr.front() == val;
 }
 
 constexpr bool check_back( double val )
 {
     std::array<double, 3> arr = {1, 2, 3.5};
-	return arr.back() == val;
+    return arr.back() == val;
 }
 #endif
 
diff --git a/test/std/containers/sequences/array/indexing.pass.cpp b/test/std/containers/sequences/array/indexing.pass.cpp
index 3a5b9ee9727d..43c494777a9d 100644
--- a/test/std/containers/sequences/array/indexing.pass.cpp
+++ b/test/std/containers/sequences/array/indexing.pass.cpp
@@ -27,7 +27,7 @@
 constexpr bool check_idx( size_t idx, double val )
 {
     std::array<double, 3> arr = {1, 2, 3.5};
-	return arr[idx] == val;
+    return arr[idx] == val;
 }
 #endif
 
diff --git a/test/std/containers/sequences/array/max_size.pass.cpp b/test/std/containers/sequences/array/max_size.pass.cpp
new file mode 100644
index 000000000000..9a3fed3950e3
--- /dev/null
+++ b/test/std/containers/sequences/array/max_size.pass.cpp
@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <array>
+
+// class array
+
+// bool max_size() const noexcept;
+
+#include <array>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::array<int, 2> C;
+    C c;
+    ASSERT_NOEXCEPT(c.max_size());
+    assert(c.max_size() == 2);
+    }
+    {
+    typedef std::array<int, 0> C;
+    C c;
+    ASSERT_NOEXCEPT(c.max_size());
+    assert(c.max_size() == 0);
+    }
+}
diff --git a/test/std/containers/sequences/deque/deque.capacity/empty.fail.cpp b/test/std/containers/sequences/deque/deque.capacity/empty.fail.cpp
new file mode 100644
index 000000000000..adfd5f2d8167
--- /dev/null
+++ b/test/std/containers/sequences/deque/deque.capacity/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <deque>
+
+// class deque
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <deque>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::deque<int> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp
new file mode 100644
index 000000000000..629a51cab95b
--- /dev/null
+++ b/test/std/containers/sequences/deque/deque.capacity/empty.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <deque>
+
+// class deque
+
+// bool empty() const noexcept;
+
+#include <deque>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::deque<int> C;
+    C c;
+    ASSERT_NOEXCEPT(c.empty());
+    assert(c.empty());
+    c.push_back(C::value_type(1));
+    assert(!c.empty());
+    c.clear();
+    assert(c.empty());
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::deque<int, min_allocator<int>> C;
+    C c;
+    ASSERT_NOEXCEPT(c.empty());
+    assert(c.empty());
+    c.push_back(C::value_type(1));
+    assert(!c.empty());
+    c.clear();
+    assert(c.empty());
+    }
+#endif
+}
diff --git a/test/std/containers/sequences/deque/deque.capacity/size.pass.cpp b/test/std/containers/sequences/deque/deque.capacity/size.pass.cpp
new file mode 100644
index 000000000000..4974fc74d0b1
--- /dev/null
+++ b/test/std/containers/sequences/deque/deque.capacity/size.pass.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <deque>
+
+// class deque
+
+// size_type size() const noexcept;
+
+#include <deque>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::deque<int> C;
+    C c;
+    ASSERT_NOEXCEPT(c.size());
+    assert(c.size() == 0);
+    c.push_back(C::value_type(2));
+    assert(c.size() == 1);
+    c.push_back(C::value_type(1));
+    assert(c.size() == 2);
+    c.push_back(C::value_type(3));
+    assert(c.size() == 3);
+    c.erase(c.begin());
+    assert(c.size() == 2);
+    c.erase(c.begin());
+    assert(c.size() == 1);
+    c.erase(c.begin());
+    assert(c.size() == 0);
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::deque<int, min_allocator<int>> C;
+    C c;
+    ASSERT_NOEXCEPT(c.size());
+    assert(c.size() == 0);
+    c.push_back(C::value_type(2));
+    assert(c.size() == 1);
+    c.push_back(C::value_type(1));
+    assert(c.size() == 2);
+    c.push_back(C::value_type(3));
+    assert(c.size() == 3);
+    c.erase(c.begin());
+    assert(c.size() == 2);
+    c.erase(c.begin());
+    assert(c.size() == 1);
+    c.erase(c.begin());
+    assert(c.size() == 0);
+    }
+#endif
+}
diff --git a/test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp
index fdf67d23a12d..baae755bc27d 100644
--- a/test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.cons/move_noexcept.pass.cpp
@@ -45,9 +45,9 @@ int main()
         typedef std::deque<MoveOnly, other_allocator<MoveOnly>> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
     }
-#endif // _LIBCPP_VERSION
     {
         typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+#endif // _LIBCPP_VERSION
 }
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp
index db22086fd4c9..4c1e15f7acb8 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_back_exception_safety.pass.cpp
@@ -80,17 +80,17 @@ int main()
         assert(false);
     }
     catch (...) {
-	    gCopyConstructorShouldThow = false;
+        gCopyConstructorShouldThow = false;
         assert(vec==vec2);
     }
-	}
+    }
 
-	{
-	typedef std::deque<CMyClass, test_allocator<CMyClass> > C;
+    {
+    typedef std::deque<CMyClass, test_allocator<CMyClass> > C;
     C vec;
     C vec2(vec);
 
-	C::allocator_type::throw_after = 1;
+    C::allocator_type::throw_after = 1;
     try {
         vec.push_back(instance);
         assert(false);
diff --git a/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp b/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp
index 7a90c8a75962..0688ed025089 100644
--- a/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.modifiers/push_front_exception_safety.pass.cpp
@@ -80,17 +80,17 @@ int main()
         assert(false);
     }
     catch (...) {
-	    gCopyConstructorShouldThow = false;
+        gCopyConstructorShouldThow = false;
         assert(vec==vec2);
     }
-	}
+    }
 
-	{
-	typedef std::deque<CMyClass, test_allocator<CMyClass> > C;
+    {
+    typedef std::deque<CMyClass, test_allocator<CMyClass> > C;
     C vec;
     C vec2(vec);
 
-	C::allocator_type::throw_after = 1;
+    C::allocator_type::throw_after = 1;
     try {
         vec.push_front(instance);
         assert(false);
diff --git a/test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp b/test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp
index 0db30a031282..01a10964b77f 100644
--- a/test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/deque/deque.special/swap_noexcept.pass.cpp
@@ -72,7 +72,7 @@ int main()
     {
         typedef std::deque<MoveOnly, some_alloc<MoveOnly>> C;
 #if TEST_STD_VER >= 14
-    //  In c++14, if POCS is set, swapping the allocator is required not to throw
+    //  In C++14, if POCS is set, swapping the allocator is required not to throw
         static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 #else
         static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
diff --git a/test/std/containers/sequences/forwardlist/empty.fail.cpp b/test/std/containers/sequences/forwardlist/empty.fail.cpp
new file mode 100644
index 000000000000..78928b480c9a
--- /dev/null
+++ b/test/std/containers/sequences/forwardlist/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <forward_list>
+
+// class forward_list
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <forward_list>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::forward_list<int> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/sequences/forwardlist/empty.pass.cpp b/test/std/containers/sequences/forwardlist/empty.pass.cpp
new file mode 100644
index 000000000000..1226e68ed3c8
--- /dev/null
+++ b/test/std/containers/sequences/forwardlist/empty.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <forward_list>
+
+// class forward_list
+
+// bool empty() const noexcept;
+
+#include <forward_list>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::forward_list<int> C;
+    C c;
+    ASSERT_NOEXCEPT(c.empty());
+    assert(c.empty());
+    c.push_front(C::value_type(1));
+    assert(!c.empty());
+    c.clear();
+    assert(c.empty());
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::forward_list<int, min_allocator<int>> C;
+    C c;
+    ASSERT_NOEXCEPT(c.empty());
+    assert(c.empty());
+    c.push_front(C::value_type(1));
+    assert(!c.empty());
+    c.clear();
+    assert(c.empty());
+    }
+#endif
+}
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp
index 3390c331e00e..a4c776abc3e5 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.cons/move_noexcept.pass.cpp
@@ -45,9 +45,9 @@ int main()
         typedef std::forward_list<MoveOnly, other_allocator<MoveOnly>> C;
         static_assert(std::is_nothrow_move_constructible<C>::value, "");
     }
-#endif // _LIBCPP_VERSION
     {
         typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C;
         static_assert(!std::is_nothrow_move_constructible<C>::value, "");
     }
+#endif // _LIBCPP_VERSION
 }
diff --git a/test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp b/test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp
index d93c079e15ed..ae48d1a4b95c 100644
--- a/test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/forwardlist/forwardlist.spec/swap_noexcept.pass.cpp
@@ -72,7 +72,7 @@ int main()
     {
         typedef std::forward_list<MoveOnly, some_alloc<MoveOnly>> C;
 #if TEST_STD_VER >= 14
-    //  In c++14, if POCS is set, swapping the allocator is required not to throw
+    //  In C++14, if POCS is set, swapping the allocator is required not to throw
         static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 #else
         static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
diff --git a/test/std/containers/sequences/list/list.capacity/empty.fail.cpp b/test/std/containers/sequences/list/list.capacity/empty.fail.cpp
new file mode 100644
index 000000000000..fe0387c834d4
--- /dev/null
+++ b/test/std/containers/sequences/list/list.capacity/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// class list
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <list>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::list<int> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/sequences/list/list.capacity/empty.pass.cpp b/test/std/containers/sequences/list/list.capacity/empty.pass.cpp
new file mode 100644
index 000000000000..b564990f2d0c
--- /dev/null
+++ b/test/std/containers/sequences/list/list.capacity/empty.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// class list
+
+// bool empty() const noexcept;
+
+#include <list>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::list<int> C;
+    C c;
+    ASSERT_NOEXCEPT(c.empty());
+    assert(c.empty());
+    c.push_back(C::value_type(1));
+    assert(!c.empty());
+    c.clear();
+    assert(c.empty());
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::list<int, min_allocator<int>> C;
+    C c;
+    ASSERT_NOEXCEPT(c.empty());
+    assert(c.empty());
+    c.push_back(C::value_type(1));
+    assert(!c.empty());
+    c.clear();
+    assert(c.empty());
+    }
+#endif
+}
diff --git a/test/std/containers/sequences/list/list.capacity/size.pass.cpp b/test/std/containers/sequences/list/list.capacity/size.pass.cpp
new file mode 100644
index 000000000000..bddaeb5ac04d
--- /dev/null
+++ b/test/std/containers/sequences/list/list.capacity/size.pass.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <list>
+
+// class list
+
+// size_type size() const noexcept;
+
+#include <list>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::list<int> C;
+    C c;
+    ASSERT_NOEXCEPT(c.size());
+    assert(c.size() == 0);
+    c.push_back(C::value_type(2));
+    assert(c.size() == 1);
+    c.push_back(C::value_type(1));
+    assert(c.size() == 2);
+    c.push_back(C::value_type(3));
+    assert(c.size() == 3);
+    c.erase(c.begin());
+    assert(c.size() == 2);
+    c.erase(c.begin());
+    assert(c.size() == 1);
+    c.erase(c.begin());
+    assert(c.size() == 0);
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::list<int, min_allocator<int>> C;
+    C c;
+    ASSERT_NOEXCEPT(c.size());
+    assert(c.size() == 0);
+    c.push_back(C::value_type(2));
+    assert(c.size() == 1);
+    c.push_back(C::value_type(1));
+    assert(c.size() == 2);
+    c.push_back(C::value_type(3));
+    assert(c.size() == 3);
+    c.erase(c.begin());
+    assert(c.size() == 2);
+    c.erase(c.begin());
+    assert(c.size() == 1);
+    c.erase(c.begin());
+    assert(c.size() == 0);
+    }
+#endif
+}
diff --git a/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp b/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp
index cfe1bfd2f411..acb68f3b5beb 100644
--- a/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/list/list.special/swap_noexcept.pass.cpp
@@ -72,7 +72,7 @@ int main()
     {
         typedef std::list<MoveOnly, some_alloc<MoveOnly>> C;
 #if TEST_STD_VER >= 14
-    //  In c++14, if POCS is set, swapping the allocator is required not to throw
+    //  In C++14, if POCS is set, swapping the allocator is required not to throw
         static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 #else
         static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
diff --git a/test/std/containers/sequences/list/types.pass.cpp b/test/std/containers/sequences/list/types.pass.cpp
index 7d5f5b6fa2f0..8c47606fadcc 100644
--- a/test/std/containers/sequences/list/types.pass.cpp
+++ b/test/std/containers/sequences/list/types.pass.cpp
@@ -31,8 +31,8 @@ struct A { std::list<A> v; }; // incomplete type support
 
 int main()
 {
-	{
-	typedef std::list<int> C;
+    {
+    typedef std::list<int> C;
     static_assert((std::is_same<C::value_type, int>::value), "");
     static_assert((std::is_same<C::allocator_type, std::allocator<int> >::value), "");
     static_assert((std::is_same<C::reference, std::allocator<int>::reference>::value), "");
@@ -46,11 +46,11 @@ int main()
         typename std::iterator_traits<typename C::iterator>::difference_type>::value), "");
     static_assert((std::is_same<typename C::difference_type,
         typename std::iterator_traits<typename C::const_iterator>::difference_type>::value), "");
-	}
+    }
 
 #if TEST_STD_VER >= 11
     {
-	typedef std::list<int, min_allocator<int>> C;
+    typedef std::list<int, min_allocator<int>> C;
     static_assert((std::is_same<C::value_type, int>::value), "");
     static_assert((std::is_same<C::allocator_type, min_allocator<int> >::value), "");
     static_assert((std::is_same<C::reference, int&>::value), "");
diff --git a/test/std/containers/sequences/vector.bool/construct_default.pass.cpp b/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
index a18ba8fbaab7..0f51c219ee49 100644
--- a/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/construct_default.pass.cpp
@@ -24,9 +24,9 @@ void
 test0()
 {
 #if TEST_STD_VER > 14
-	static_assert((noexcept(C{})), "" );
+    static_assert((noexcept(C{})), "" );
 #elif TEST_STD_VER >= 11
-	static_assert((noexcept(C()) == noexcept(typename C::allocator_type())), "" );
+    static_assert((noexcept(C()) == noexcept(typename C::allocator_type())), "" );
 #endif
     C c;
     LIBCPP_ASSERT(c.__invariants());
@@ -45,9 +45,9 @@ void
 test1(const typename C::allocator_type& a)
 {
 #if TEST_STD_VER > 14
-	static_assert((noexcept(C{typename C::allocator_type{}})), "" );
+    static_assert((noexcept(C{typename C::allocator_type{}})), "" );
 #elif TEST_STD_VER >= 11
-	static_assert((noexcept(C(typename C::allocator_type())) == std::is_nothrow_copy_constructible<typename C::allocator_type>::value), "" );
+    static_assert((noexcept(C(typename C::allocator_type())) == std::is_nothrow_copy_constructible<typename C::allocator_type>::value), "" );
 #endif
     C c(a);
     LIBCPP_ASSERT(c.__invariants());
diff --git a/test/std/containers/sequences/vector.bool/empty.fail.cpp b/test/std/containers/sequences/vector.bool/empty.fail.cpp
new file mode 100644
index 000000000000..99c245d0c09c
--- /dev/null
+++ b/test/std/containers/sequences/vector.bool/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// class vector
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <vector>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::vector<bool> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/sequences/vector.bool/empty.pass.cpp b/test/std/containers/sequences/vector.bool/empty.pass.cpp
new file mode 100644
index 000000000000..1471c39ebb07
--- /dev/null
+++ b/test/std/containers/sequences/vector.bool/empty.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// class vector
+
+// bool empty() const noexcept;
+
+#include <vector>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::vector<bool> C;
+    C c;
+    ASSERT_NOEXCEPT(c.empty());
+    assert(c.empty());
+    c.push_back(false);
+    assert(!c.empty());
+    c.clear();
+    assert(c.empty());
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::vector<bool, min_allocator<bool>> C;
+    C c;
+    ASSERT_NOEXCEPT(c.empty());
+    assert(c.empty());
+    c.push_back(false);
+    assert(!c.empty());
+    c.clear();
+    assert(c.empty());
+    }
+#endif
+}
diff --git a/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp b/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
index 06351e418ac4..8fe18d4b4f84 100644
--- a/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/reference.swap.pass.cpp
@@ -23,17 +23,17 @@ int main()
     bool a[] = {false, true, false, true};
     bool* an = a + sizeof(a)/sizeof(a[0]);
 
-	std::vector<bool> v(a, an);
-	std::vector<bool>::reference r1 = v[0];
-	std::vector<bool>::reference r2 = v[3];
+    std::vector<bool> v(a, an);
+    std::vector<bool>::reference r1 = v[0];
+    std::vector<bool>::reference r2 = v[3];
 
 #if TEST_STD_VER >= 11
     static_assert((noexcept(v.swap(r1,r2))), "");
 #endif
 
-	assert(!r1);
-	assert( r2);
-	v.swap(r1, r2);
-	assert( r1);
-	assert(!r2);
+    assert(!r1);
+    assert( r2);
+    v.swap(r1, r2);
+    assert( r1);
+    assert(!r2);
 }
diff --git a/test/std/containers/sequences/vector.bool/size.pass.cpp b/test/std/containers/sequences/vector.bool/size.pass.cpp
new file mode 100644
index 000000000000..43330c0a5224
--- /dev/null
+++ b/test/std/containers/sequences/vector.bool/size.pass.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// class vector
+
+// size_type size() const noexcept;
+
+#include <vector>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::vector<bool> C;
+    C c;
+    ASSERT_NOEXCEPT(c.size());
+    assert(c.size() == 0);
+    c.push_back(false);
+    assert(c.size() == 1);
+    c.push_back(true);
+    assert(c.size() == 2);
+    c.push_back(false);
+    assert(c.size() == 3);
+    c.erase(c.begin());
+    assert(c.size() == 2);
+    c.erase(c.begin());
+    assert(c.size() == 1);
+    c.erase(c.begin());
+    assert(c.size() == 0);
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::vector<bool, min_allocator<bool>> C;
+    C c;
+    ASSERT_NOEXCEPT(c.size());
+    assert(c.size() == 0);
+    c.push_back(false);
+    assert(c.size() == 1);
+    c.push_back(true);
+    assert(c.size() == 2);
+    c.push_back(false);
+    assert(c.size() == 3);
+    c.erase(c.begin());
+    assert(c.size() == 2);
+    c.erase(c.begin());
+    assert(c.size() == 1);
+    c.erase(c.begin());
+    assert(c.size() == 0);
+    }
+#endif
+}
diff --git a/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp b/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
index d888af05f92f..68d04dbb3e9f 100644
--- a/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector.bool/swap_noexcept.pass.cpp
@@ -72,7 +72,7 @@ int main()
     {
 #if TEST_STD_VER >= 14
 #if defined(_LIBCPP_VERSION)
-    //  In c++14, if POCS is set, swapping the allocator is required not to throw
+    //  In C++14, if POCS is set, swapping the allocator is required not to throw
         typedef std::vector<bool, some_alloc<bool>> C;
         static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 #endif // _LIBCPP_VERSION
diff --git a/test/std/containers/sequences/vector/vector.capacity/empty.fail.cpp b/test/std/containers/sequences/vector/vector.capacity/empty.fail.cpp
new file mode 100644
index 000000000000..abfdfbfb9c42
--- /dev/null
+++ b/test/std/containers/sequences/vector/vector.capacity/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// class vector
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <vector>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::vector<int> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp
new file mode 100644
index 000000000000..d81683133f5c
--- /dev/null
+++ b/test/std/containers/sequences/vector/vector.capacity/empty.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// class vector
+
+// bool empty() const noexcept;
+
+#include <vector>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::vector<int> C;
+    C c;
+    ASSERT_NOEXCEPT(c.empty());
+    assert(c.empty());
+    c.push_back(C::value_type(1));
+    assert(!c.empty());
+    c.clear();
+    assert(c.empty());
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::vector<int, min_allocator<int>> C;
+    C c;
+    ASSERT_NOEXCEPT(c.empty());
+    assert(c.empty());
+    c.push_back(C::value_type(1));
+    assert(!c.empty());
+    c.clear();
+    assert(c.empty());
+    }
+#endif
+}
diff --git a/test/std/containers/sequences/vector/vector.capacity/size.pass.cpp b/test/std/containers/sequences/vector/vector.capacity/size.pass.cpp
new file mode 100644
index 000000000000..71f531c48888
--- /dev/null
+++ b/test/std/containers/sequences/vector/vector.capacity/size.pass.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// class vector
+
+// size_type size() const noexcept;
+
+#include <vector>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::vector<int> C;
+    C c;
+    ASSERT_NOEXCEPT(c.size());
+    assert(c.size() == 0);
+    c.push_back(C::value_type(2));
+    assert(c.size() == 1);
+    c.push_back(C::value_type(1));
+    assert(c.size() == 2);
+    c.push_back(C::value_type(3));
+    assert(c.size() == 3);
+    c.erase(c.begin());
+    assert(c.size() == 2);
+    c.erase(c.begin());
+    assert(c.size() == 1);
+    c.erase(c.begin());
+    assert(c.size() == 0);
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::vector<int, min_allocator<int>> C;
+    C c;
+    ASSERT_NOEXCEPT(c.size());
+    assert(c.size() == 0);
+    c.push_back(C::value_type(2));
+    assert(c.size() == 1);
+    c.push_back(C::value_type(1));
+    assert(c.size() == 2);
+    c.push_back(C::value_type(3));
+    assert(c.size() == 3);
+    c.erase(c.begin());
+    assert(c.size() == 2);
+    c.erase(c.begin());
+    assert(c.size() == 1);
+    c.erase(c.begin());
+    assert(c.size() == 0);
+    }
+#endif
+}
diff --git a/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp b/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
index edeae04d7bd7..a71f5b32c039 100644
--- a/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.cons/construct_default.pass.cpp
@@ -27,9 +27,9 @@ void
 test0()
 {
 #if TEST_STD_VER > 14
-	static_assert((noexcept(C{})), "" );
+    static_assert((noexcept(C{})), "" );
 #elif TEST_STD_VER >= 11
-	static_assert((noexcept(C()) == noexcept(typename C::allocator_type())), "" );
+    static_assert((noexcept(C()) == noexcept(typename C::allocator_type())), "" );
 #endif
     C c;
     LIBCPP_ASSERT(c.__invariants());
@@ -50,9 +50,9 @@ void
 test1(const typename C::allocator_type& a)
 {
 #if TEST_STD_VER > 14
-	static_assert((noexcept(C{typename C::allocator_type{}})), "" );
+    static_assert((noexcept(C{typename C::allocator_type{}})), "" );
 #elif TEST_STD_VER >= 11
-	static_assert((noexcept(C(typename C::allocator_type())) == std::is_nothrow_copy_constructible<typename C::allocator_type>::value), "" );
+    static_assert((noexcept(C(typename C::allocator_type())) == std::is_nothrow_copy_constructible<typename C::allocator_type>::value), "" );
 #endif
     C c(a);
     LIBCPP_ASSERT(c.__invariants());
diff --git a/test/std/containers/sequences/vector/vector.data/data.pass.cpp b/test/std/containers/sequences/vector/vector.data/data.pass.cpp
index b7ea3a286f32..0fc335f15ac9 100644
--- a/test/std/containers/sequences/vector/vector.data/data.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.data/data.pass.cpp
@@ -18,13 +18,13 @@
 #include "asan_testing.h"
 
 struct Nasty {
-	Nasty() : i_(0) {}
-	Nasty(int i) : i_(i) {}
-	~Nasty() {}
+    Nasty() : i_(0) {}
+    Nasty(int i) : i_(i) {}
+    ~Nasty() {}
 
-	Nasty * operator&() const { assert(false); return nullptr; }
-	int i_;
-	};
+    Nasty * operator&() const { assert(false); return nullptr; }
+    int i_;
+    };
 
 int main()
 {
diff --git a/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp b/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
index 3c013c1ae8af..fa8b6a8afdf2 100644
--- a/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.data/data_const.pass.cpp
@@ -18,13 +18,13 @@
 #include "asan_testing.h"
 
 struct Nasty {
-	Nasty() : i_(0) {}
-	Nasty(int i) : i_(i) {}
-	~Nasty() {}
+    Nasty() : i_(0) {}
+    Nasty(int i) : i_(i) {}
+    ~Nasty() {}
 
-	Nasty * operator&() const { assert(false); return nullptr; }
-	int i_;
-	};
+    Nasty * operator&() const { assert(false); return nullptr; }
+    int i_;
+    };
 
 int main()
 {
diff --git a/test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp b/test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp
index f92ab8a5c300..062ee22c3fd9 100644
--- a/test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp
+++ b/test/std/containers/sequences/vector/vector.special/swap_noexcept.pass.cpp
@@ -73,7 +73,7 @@ int main()
     {
         typedef std::vector<MoveOnly, some_alloc<MoveOnly>> C;
 #if TEST_STD_VER >= 14
-    //  In c++14, if POCS is set, swapping the allocator is required not to throw
+    //  In C++14, if POCS is set, swapping the allocator is required not to throw
         static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 #else
         static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
diff --git a/test/std/containers/test_compare.h b/test/std/containers/test_compare.h
index 9c54799172e0..35f4640f1cad 100644
--- a/test/std/containers/test_compare.h
+++ b/test/std/containers/test_compare.h
@@ -33,4 +33,13 @@ public:
         {return data_ == c.data_;}
 };
 
+
+template <class C>
+class non_const_compare
+{
+//	operator() deliberately not marked as 'const'
+    bool operator()(const C& x,const C&y) { return x < y; }
+};
+
+
 #endif  // TEST_COMPARE_H
diff --git a/test/std/containers/unord/unord.map/empty.fail.cpp b/test/std/containers/unord/unord.map/empty.fail.cpp
new file mode 100644
index 000000000000..1c67169bb518
--- /dev/null
+++ b/test/std/containers/unord/unord.map/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// class unordered_map
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <unordered_map>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::unordered_map<int, int> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/unord/unord.map/empty.pass.cpp b/test/std/containers/unord/unord.map/empty.pass.cpp
new file mode 100644
index 000000000000..4488b20b30bb
--- /dev/null
+++ b/test/std/containers/unord/unord.map/empty.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// class unordered_map
+
+// bool empty() const noexcept;
+
+#include <unordered_map>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::unordered_map<int, double> M;
+    M m;
+    ASSERT_NOEXCEPT(m.empty());
+    assert(m.empty());
+    m.insert(M::value_type(1, 1.5));
+    assert(!m.empty());
+    m.clear();
+    assert(m.empty());
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::unordered_map<int, double, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, double>>> M;
+    M m;
+    ASSERT_NOEXCEPT(m.empty());
+    assert(m.empty());
+    m.insert(M::value_type(1, 1.5));
+    assert(!m.empty());
+    m.clear();
+    assert(m.empty());
+    }
+#endif
+}
diff --git a/test/std/containers/unord/unord.map/rehash.pass.cpp b/test/std/containers/unord/unord.map/rehash.pass.cpp
index 58222b7f924d..41015726ef6c 100644
--- a/test/std/containers/unord/unord.map/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.map/rehash.pass.cpp
@@ -25,7 +25,7 @@
 template <class C>
 void rehash_postcondition(const C& c, size_t n)
 {
-	assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
+    assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
 }
 
 template <class C>
diff --git a/test/std/containers/unord/unord.map/size.pass.cpp b/test/std/containers/unord/unord.map/size.pass.cpp
new file mode 100644
index 000000000000..5bf75648ff76
--- /dev/null
+++ b/test/std/containers/unord/unord.map/size.pass.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// class unordered_map
+
+// size_type size() const noexcept;
+
+#include <unordered_map>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::unordered_map<int, double> M;
+    M m;
+    ASSERT_NOEXCEPT(m.size());
+    assert(m.size() == 0);
+    m.insert(M::value_type(2, 1.5));
+    assert(m.size() == 1);
+    m.insert(M::value_type(1, 1.5));
+    assert(m.size() == 2);
+    m.insert(M::value_type(3, 1.5));
+    assert(m.size() == 3);
+    m.erase(m.begin());
+    assert(m.size() == 2);
+    m.erase(m.begin());
+    assert(m.size() == 1);
+    m.erase(m.begin());
+    assert(m.size() == 0);
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::unordered_map<int, double, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, double>>> M;
+    M m;
+    ASSERT_NOEXCEPT(m.size());
+    assert(m.size() == 0);
+    m.insert(M::value_type(2, 1.5));
+    assert(m.size() == 1);
+    m.insert(M::value_type(1, 1.5));
+    assert(m.size() == 2);
+    m.insert(M::value_type(3, 1.5));
+    assert(m.size() == 3);
+    m.erase(m.begin());
+    assert(m.size() == 2);
+    m.erase(m.begin());
+    assert(m.size() == 1);
+    m.erase(m.begin());
+    assert(m.size() == 0);
+    }
+#endif
+}
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp
index 7f62a4fedf83..8f6f16c62a62 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/compare_copy_constructible.fail.cpp
@@ -19,14 +19,14 @@
 
 template <class T>
 struct Comp {
-	bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
+    bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
 
-	Comp () {}
+    Comp () {}
 private:
-	Comp (const Comp &); // declared but not defined
-	};
+    Comp (const Comp &); // declared but not defined
+    };
 
 
 int main() {
-	std::unordered_map<int, int, std::hash<int>, Comp<int> > m;
+    std::unordered_map<int, int, std::hash<int>, Comp<int> > m;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp
index 2525c4444ffb..aca2a5aa3655 100644
--- a/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.cnstr/hash_copy_constructible.fail.cpp
@@ -19,14 +19,14 @@
 
 template <class T>
 struct Hash {
-	std::size_t operator () (const T& lhs) const { return 0; }
+    std::size_t operator () (const T& lhs) const { return 0; }
 
-	Hash () {}
+    Hash () {}
 private:
-	Hash (const Hash &); // declared but not defined
+    Hash (const Hash &); // declared but not defined
 };
 
 
 int main() {
-	std::unordered_map<int, int, Hash<int> > m;
+    std::unordered_map<int, int, Hash<int> > m;
 }
diff --git a/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp b/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
index 8fbded4cd5fb..e526b654a197 100644
--- a/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.elem/at.pass.cpp
@@ -72,7 +72,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
-            c.at(11);
+            TEST_IGNORE_NODISCARD c.at(11);
             assert(false);
         }
         catch (std::out_of_range&)
@@ -130,7 +130,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try
         {
-            c.at(11);
+            TEST_IGNORE_NODISCARD c.at(11);
             assert(false);
         }
         catch (std::out_of_range&)
diff --git a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp
index a4d8abc7d317..e84301e9e71f 100644
--- a/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.modifiers/insert_or_assign.pass.cpp
@@ -189,4 +189,4 @@ int main()
         assert(r->second.get() == 5);  // value
     }
 
-}
\ No newline at end of file
+}
diff --git a/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp b/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp
index 75807fa78889..9497b15233cb 100644
--- a/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp
+++ b/test/std/containers/unord/unord.map/unord.map.swap/swap_noexcept.pass.cpp
@@ -122,7 +122,7 @@ struct some_alloc3
 
 int main()
 {
-	typedef std::pair<const MoveOnly, MoveOnly> MapType;
+    typedef std::pair<const MoveOnly, MoveOnly> MapType;
     {
         typedef std::unordered_map<MoveOnly, MoveOnly> C;
         static_assert(noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
diff --git a/test/std/containers/unord/unord.multimap/empty.fail.cpp b/test/std/containers/unord/unord.multimap/empty.fail.cpp
new file mode 100644
index 000000000000..7e3a6f4b95d1
--- /dev/null
+++ b/test/std/containers/unord/unord.multimap/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// class unordered_multimap
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <unordered_map>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::unordered_multimap<int, int> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/unord/unord.multimap/empty.pass.cpp b/test/std/containers/unord/unord.multimap/empty.pass.cpp
new file mode 100644
index 000000000000..68405f229628
--- /dev/null
+++ b/test/std/containers/unord/unord.multimap/empty.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// class unordered_multimap
+
+// bool empty() const noexcept;
+
+#include <unordered_map>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::unordered_multimap<int, double> M;
+    M m;
+    ASSERT_NOEXCEPT(m.empty());
+    assert(m.empty());
+    m.insert(M::value_type(1, 1.5));
+    assert(!m.empty());
+    m.clear();
+    assert(m.empty());
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::unordered_multimap<int, double, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, double>>> M;
+    M m;
+    ASSERT_NOEXCEPT(m.empty());
+    assert(m.empty());
+    m.insert(M::value_type(1, 1.5));
+    assert(!m.empty());
+    m.clear();
+    assert(m.empty());
+    }
+#endif
+}
diff --git a/test/std/containers/unord/unord.multimap/rehash.pass.cpp b/test/std/containers/unord/unord.multimap/rehash.pass.cpp
index 3d3832a2fe3c..22202ccb612a 100644
--- a/test/std/containers/unord/unord.multimap/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.multimap/rehash.pass.cpp
@@ -28,7 +28,7 @@
 template <class C>
 void rehash_postcondition(const C& c, size_t n)
 {
-	assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
+    assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
 }
 
 template <class C>
diff --git a/test/std/containers/unord/unord.multimap/size.pass.cpp b/test/std/containers/unord/unord.multimap/size.pass.cpp
new file mode 100644
index 000000000000..b1296624057f
--- /dev/null
+++ b/test/std/containers/unord/unord.multimap/size.pass.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// class unordered_multimap
+
+// size_type size() const noexcept;
+
+#include <unordered_map>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::unordered_multimap<int, double> M;
+    M m;
+    ASSERT_NOEXCEPT(m.size());
+    assert(m.size() == 0);
+    m.insert(M::value_type(2, 1.5));
+    assert(m.size() == 1);
+    m.insert(M::value_type(1, 1.5));
+    assert(m.size() == 2);
+    m.insert(M::value_type(3, 1.5));
+    assert(m.size() == 3);
+    m.erase(m.begin());
+    assert(m.size() == 2);
+    m.erase(m.begin());
+    assert(m.size() == 1);
+    m.erase(m.begin());
+    assert(m.size() == 0);
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::unordered_multimap<int, double, std::hash<int>, std::equal_to<int>, min_allocator<std::pair<const int, double>>> M;
+    M m;
+    ASSERT_NOEXCEPT(m.size());
+    assert(m.size() == 0);
+    m.insert(M::value_type(2, 1.5));
+    assert(m.size() == 1);
+    m.insert(M::value_type(1, 1.5));
+    assert(m.size() == 2);
+    m.insert(M::value_type(3, 1.5));
+    assert(m.size() == 3);
+    m.erase(m.begin());
+    assert(m.size() == 2);
+    m.erase(m.begin());
+    assert(m.size() == 1);
+    m.erase(m.begin());
+    assert(m.size() == 0);
+    }
+#endif
+}
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp
index 1c46e7adeafa..cb0ce522d3f9 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/compare_copy_constructible.fail.cpp
@@ -19,14 +19,14 @@
 
 template <class T>
 struct Comp {
-	bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
+    bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
 
-	Comp () {}
+    Comp () {}
 private:
-	Comp (const Comp &); // declared but not defined
-	};
+    Comp (const Comp &); // declared but not defined
+    };
 
 
 int main() {
-	std::unordered_multimap<int, int, std::hash<int>, Comp<int> > m;
+    std::unordered_multimap<int, int, std::hash<int>, Comp<int> > m;
 }
diff --git a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp
index 71e1c9f6d4be..f5f42e5d26a7 100644
--- a/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/hash_copy_constructible.fail.cpp
@@ -19,14 +19,14 @@
 
 template <class T>
 struct Hash {
-	std::size_t operator () (const T& lhs) const { return 0; }
+    std::size_t operator () (const T& lhs) const { return 0; }
 
-	Hash () {}
+    Hash () {}
 private:
-	Hash (const Hash &); // declared but not defined
-	};
+    Hash (const Hash &); // declared but not defined
+    };
 
 
 int main() {
-	std::unordered_multimap<int, int, Hash<int> > m;
+    std::unordered_multimap<int, int, Hash<int> > m;
 }
diff --git a/test/std/containers/unord/unord.multiset/empty.fail.cpp b/test/std/containers/unord/unord.multiset/empty.fail.cpp
new file mode 100644
index 000000000000..8e068a4e1ece
--- /dev/null
+++ b/test/std/containers/unord/unord.multiset/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// class unordered_multiset
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <unordered_set>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::unordered_multiset<int> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/unord/unord.multiset/empty.pass.cpp b/test/std/containers/unord/unord.multiset/empty.pass.cpp
new file mode 100644
index 000000000000..8c65bc23ba68
--- /dev/null
+++ b/test/std/containers/unord/unord.multiset/empty.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// class unordered_multiset
+
+// bool empty() const noexcept;
+
+#include <unordered_set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::unordered_multiset<int> M;
+    M m;
+    ASSERT_NOEXCEPT(m.empty());
+    assert(m.empty());
+    m.insert(M::value_type(1));
+    assert(!m.empty());
+    m.clear();
+    assert(m.empty());
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> M;
+    M m;
+    ASSERT_NOEXCEPT(m.empty());
+    assert(m.empty());
+    m.insert(M::value_type(1));
+    assert(!m.empty());
+    m.clear();
+    assert(m.empty());
+    }
+#endif
+}
diff --git a/test/std/containers/unord/unord.multiset/rehash.pass.cpp b/test/std/containers/unord/unord.multiset/rehash.pass.cpp
index 2c5d509951a8..83fb58d8a480 100644
--- a/test/std/containers/unord/unord.multiset/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.multiset/rehash.pass.cpp
@@ -24,7 +24,7 @@
 template <class C>
 void rehash_postcondition(const C& c, size_t n)
 {
-	assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
+    assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
 }
 
 template <class C>
diff --git a/test/std/containers/unord/unord.multiset/size.pass.cpp b/test/std/containers/unord/unord.multiset/size.pass.cpp
new file mode 100644
index 000000000000..2c23202ce8fc
--- /dev/null
+++ b/test/std/containers/unord/unord.multiset/size.pass.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// class unordered_multiset
+
+// size_type size() const noexcept;
+
+#include <unordered_set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::unordered_multiset<int> M;
+    M m;
+    ASSERT_NOEXCEPT(m.size());
+    assert(m.size() == 0);
+    m.insert(M::value_type(2));
+    assert(m.size() == 1);
+    m.insert(M::value_type(1));
+    assert(m.size() == 2);
+    m.insert(M::value_type(3));
+    assert(m.size() == 3);
+    m.erase(m.begin());
+    assert(m.size() == 2);
+    m.erase(m.begin());
+    assert(m.size() == 1);
+    m.erase(m.begin());
+    assert(m.size() == 0);
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::unordered_multiset<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> M;
+    M m;
+    ASSERT_NOEXCEPT(m.size());
+    assert(m.size() == 0);
+    m.insert(M::value_type(2));
+    assert(m.size() == 1);
+    m.insert(M::value_type(1));
+    assert(m.size() == 2);
+    m.insert(M::value_type(3));
+    assert(m.size() == 3);
+    m.erase(m.begin());
+    assert(m.size() == 2);
+    m.erase(m.begin());
+    assert(m.size() == 1);
+    m.erase(m.begin());
+    assert(m.size() == 0);
+    }
+#endif
+}
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp
index 1cda95be6eba..1b81905b6738 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/compare_copy_constructible.fail.cpp
@@ -16,14 +16,14 @@
 
 template <class T>
 struct Comp {
-	bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
+    bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
 
-	Comp () {}
+    Comp () {}
 private:
-	Comp (const Comp &); // declared but not defined
-	};
+    Comp (const Comp &); // declared but not defined
+    };
 
 
 int main() {
-	std::unordered_multiset<int, std::hash<int>, Comp<int> > m;
+    std::unordered_multiset<int, std::hash<int>, Comp<int> > m;
 }
diff --git a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp
index 6fa52a794907..cae8ab9733e1 100644
--- a/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/hash_copy_constructible.fail.cpp
@@ -16,14 +16,14 @@
 
 template <class T>
 struct Hash {
-	std::size_t operator () (const T& lhs) const { return 0; }
+    std::size_t operator () (const T& lhs) const { return 0; }
 
-	Hash () {}
+    Hash () {}
 private:
-	Hash (const Hash &); // declared but not defined
-	};
+    Hash (const Hash &); // declared but not defined
+    };
 
 
 int main() {
-	std::unordered_multiset<int, Hash<int> > m;
+    std::unordered_multiset<int, Hash<int> > m;
 }
diff --git a/test/std/containers/unord/unord.set/empty.fail.cpp b/test/std/containers/unord/unord.set/empty.fail.cpp
new file mode 100644
index 000000000000..23603c2619b9
--- /dev/null
+++ b/test/std/containers/unord/unord.set/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// class unordered_set
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <unordered_set>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::unordered_set<int> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/containers/unord/unord.set/empty.pass.cpp b/test/std/containers/unord/unord.set/empty.pass.cpp
new file mode 100644
index 000000000000..de28cb256944
--- /dev/null
+++ b/test/std/containers/unord/unord.set/empty.pass.cpp
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// class unordered_set
+
+// bool empty() const noexcept;
+
+#include <unordered_set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::unordered_set<int> M;
+    M m;
+    ASSERT_NOEXCEPT(m.empty());
+    assert(m.empty());
+    m.insert(M::value_type(1));
+    assert(!m.empty());
+    m.clear();
+    assert(m.empty());
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> M;
+    M m;
+    ASSERT_NOEXCEPT(m.empty());
+    assert(m.empty());
+    m.insert(M::value_type(1));
+    assert(!m.empty());
+    m.clear();
+    assert(m.empty());
+    }
+#endif
+}
diff --git a/test/std/containers/unord/unord.set/rehash.pass.cpp b/test/std/containers/unord/unord.set/rehash.pass.cpp
index fd689bfd9dfa..dc3adccc6e73 100644
--- a/test/std/containers/unord/unord.set/rehash.pass.cpp
+++ b/test/std/containers/unord/unord.set/rehash.pass.cpp
@@ -24,7 +24,7 @@
 template <class C>
 void rehash_postcondition(const C& c, size_t n)
 {
-	assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
+    assert(c.bucket_count() >= c.size() / c.max_load_factor() && c.bucket_count() >= n);
 }
 
 template <class C>
diff --git a/test/std/containers/unord/unord.set/size.pass.cpp b/test/std/containers/unord/unord.set/size.pass.cpp
new file mode 100644
index 000000000000..c127ddf263db
--- /dev/null
+++ b/test/std/containers/unord/unord.set/size.pass.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_set>
+
+// class unordered_set
+
+// size_type size() const noexcept;
+
+#include <unordered_set>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main()
+{
+    {
+    typedef std::unordered_set<int> M;
+    M m;
+    ASSERT_NOEXCEPT(m.size());
+    assert(m.size() == 0);
+    m.insert(M::value_type(2));
+    assert(m.size() == 1);
+    m.insert(M::value_type(1));
+    assert(m.size() == 2);
+    m.insert(M::value_type(3));
+    assert(m.size() == 3);
+    m.erase(m.begin());
+    assert(m.size() == 2);
+    m.erase(m.begin());
+    assert(m.size() == 1);
+    m.erase(m.begin());
+    assert(m.size() == 0);
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::unordered_set<int, std::hash<int>, std::equal_to<int>, min_allocator<int>> M;
+    M m;
+    ASSERT_NOEXCEPT(m.size());
+    assert(m.size() == 0);
+    m.insert(M::value_type(2));
+    assert(m.size() == 1);
+    m.insert(M::value_type(1));
+    assert(m.size() == 2);
+    m.insert(M::value_type(3));
+    assert(m.size() == 3);
+    m.erase(m.begin());
+    assert(m.size() == 2);
+    m.erase(m.begin());
+    assert(m.size() == 1);
+    m.erase(m.begin());
+    assert(m.size() == 0);
+    }
+#endif
+}
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp
index 79782550d0fe..411731479cbd 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/compare_copy_constructible.fail.cpp
@@ -16,14 +16,14 @@
 
 template <class T>
 struct Comp {
-	bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
+    bool operator () (const T& lhs, const T& rhs) const { return lhs == rhs; }
 
-	Comp () {}
+    Comp () {}
 private:
-	Comp (const Comp &); // declared but not defined
-	};
+    Comp (const Comp &); // declared but not defined
+    };
 
 
 int main() {
-	std::unordered_set<int, std::hash<int>, Comp<int> > m;
+    std::unordered_set<int, std::hash<int>, Comp<int> > m;
 }
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
index 81ad16b7244b..caa4bef0278e 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/default.pass.cpp
@@ -82,7 +82,7 @@ int main()
         assert(c.max_load_factor() == 1);
         }
         {
-    	A a;
+        A a;
         C c(a);
         LIBCPP_ASSERT(c.bucket_count() == 0);
         assert(c.hash_function() == test_hash<std::hash<NotConstructible> >());
diff --git a/test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp b/test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp
index 9e135e2c141e..da368a154230 100644
--- a/test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp
+++ b/test/std/containers/unord/unord.set/unord.set.cnstr/hash_copy_constructible.fail.cpp
@@ -16,14 +16,14 @@
 
 template <class T>
 struct Hash {
-	std::size_t operator () (const T& lhs) const { return 0; }
+    std::size_t operator () (const T& lhs) const { return 0; }
 
-	Hash () {}
+    Hash () {}
 private:
-	Hash (const Hash &); // declared but not defined
-	};
+    Hash (const Hash &); // declared but not defined
+    };
 
 
 int main() {
-	std::unordered_set<int, Hash<int> > m;
+    std::unordered_set<int, Hash<int> > m;
 }
diff --git a/test/std/depr/depr.c.headers/complex.h.pass.cpp b/test/std/depr/depr.c.headers/complex.h.pass.cpp
index 0e3fd3e990b1..4effd9653e50 100644
--- a/test/std/depr/depr.c.headers/complex.h.pass.cpp
+++ b/test/std/depr/depr.c.headers/complex.h.pass.cpp
@@ -14,4 +14,5 @@
 int main()
 {
     std::complex<double> d;
+    (void)d;
 }
diff --git a/test/std/depr/depr.c.headers/tgmath_h.pass.cpp b/test/std/depr/depr.c.headers/tgmath_h.pass.cpp
index 965a8de3c56e..91727b6cc728 100644
--- a/test/std/depr/depr.c.headers/tgmath_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/tgmath_h.pass.cpp
@@ -14,6 +14,7 @@
 int main()
 {
     std::complex<double> cd;
+    (void)cd;
     double x = sin(1.0);
     (void)x; // to placate scan-build
 }
diff --git a/test/std/depr/depr.c.headers/uchar_h.pass.cpp b/test/std/depr/depr.c.headers/uchar_h.pass.cpp
index f5f69f8e553b..f12169845599 100644
--- a/test/std/depr/depr.c.headers/uchar_h.pass.cpp
+++ b/test/std/depr/depr.c.headers/uchar_h.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
+// XFAIL: suse-linux-enterprise-server-11
 // XFAIL: apple-darwin
 // XFAIL: newlib
 
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.cxx1z.fail.cpp
index 1c56aa9f5dc5..c77ecf92ff14 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun.cxx1z.fail.cpp
@@ -12,7 +12,7 @@
 // template<cReturnable S, ClassType T>
 //   const_mem_fun_t<S,T>
 //   mem_fun(S (T::*f)() const);
-// Removed in c++1z
+// Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 #include <functional>
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.cxx1z.fail.cpp
index c727e955b1d5..24b86f542c0c 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1.cxx1z.fail.cpp
@@ -12,7 +12,7 @@
 // template<Returnable S, ClassType T, CopyConstructible A>
 //   const_mem_fun1_t<S,T,A>
 //   mem_fun(S (T::*f)(A) const);
-// Removed in c++1z
+// Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 #include <functional>
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.cxx1z.fail.cpp
index 39b3112da94c..b89aeb8cceb1 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_ref_t.cxx1z.fail.cpp
@@ -10,7 +10,7 @@
 // <functional>
 
 // const_mem_fun1_ref_t
-// Removed in c++1z
+// Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 #include <functional>
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.cxx1z.fail.cpp
index f07a3b798e72..bb583aa37a91 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun1_t.cxx1z.fail.cpp
@@ -10,7 +10,7 @@
 // <functional>
 
 // const_mem_fun1_t
-// Removed in c++1z
+// Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 #include <functional>
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.cxx1z.fail.cpp
index fea1441b31f1..db4606adb556 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref.cxx1z.fail.cpp
@@ -12,7 +12,7 @@
 // template<Returnable S, ClassType T>
 //   const_mem_fun_ref_t<S,T>
 //   mem_fun_ref(S (T::*f)() const);
-// Removed in c++1z
+// Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 #include <functional>
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.cxx1z.fail.cpp
index f993b7ce1949..cce5c44270b0 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref1.cxx1z.fail.cpp
@@ -12,7 +12,7 @@
 // template<Returnable S, ClassType T, CopyConstructible A>
 //   const_mem_fun1_ref_t<S,T,A>
 //   mem_fun_ref(S (T::*f)(A) const);
-// Removed in c++1z
+// Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 #include <functional>
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.cxx1z.fail.cpp
index e195213f9c02..85ee737d8260 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_ref_t.cxx1z.fail.cpp
@@ -10,7 +10,7 @@
 // <functional>
 
 // const_mem_fun_ref_t
-// Removed in c++1z
+// Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 #include <functional>
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.cxx1z.fail.cpp
index 228eb3da60a6..5bce7099cdbd 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/const_mem_fun_t.cxx1z.fail.cpp
@@ -10,7 +10,7 @@
 // <functional>
 
 // const_mem_fun_t
-// Removed in c++1z
+// Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 #include <functional>
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.cxx1z.fail.cpp
index 8f59a1ae2f82..523a2a612b41 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun.cxx1z.fail.cpp
@@ -12,7 +12,7 @@
 // template<Returnable S, ClassType T>
 //   mem_fun_t<S,T>
 //   mem_fun(S (T::*f)());
-// Removed in c++1z
+// Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 #include <functional>
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.cpp
index 6191de3fbe63..9b7101f58e43 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1.cxx1z.fail.cpp
@@ -12,7 +12,7 @@
 // template<Returnable S, ClassType T, CopyConstructible A>
 //   mem_fun1_t<S,T,A>
 //   mem_fun(S (T::*f)(A));
-// Removed in c++1z
+// Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 #include <functional>
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.cxx1z.fail.cpp
index 0effd33f3784..2713b2f8dc5f 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_ref_t.cxx1z.fail.cpp
@@ -10,7 +10,7 @@
 // <functional>
 
 // mem_fun1_ref_t
-// Removed in c++1z
+// Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 #include <functional>
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.cpp
index aa8e25abe438..22e7fd6b9143 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun1_t.cxx1z.fail.cpp
@@ -10,7 +10,7 @@
 // <functional>
 
 // mem_fun1_t
-// Removed in c++1z
+// Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 #include <functional>
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.cxx1z.fail.cpp
index ff7f28af8e30..6f85dae41110 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref.cxx1z.fail.cpp
@@ -12,7 +12,7 @@
 // template<Returnable S, ClassType T>
 //   mem_fun_ref_t<S,T>
 //   mem_fun_ref(S (T::*f)());
-// Removed in c++1z
+// Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 #include <functional>
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.cxx1z.fail.cpp
index 82d47fefd3d4..b881cb71f2a8 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref1.cxx1z.fail.cpp
@@ -12,7 +12,7 @@
 // template<Returnable S, ClassType T, CopyConstructible A>
 //   mem_fun1_ref_t<S,T,A>
 //   mem_fun_ref(S (T::*f)(A));
-// Removed in c++1z
+// Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 #include <functional>
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.cxx1z.fail.cpp
index f1cf01c5c424..62e8daed1edf 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_ref_t.cxx1z.fail.cpp
@@ -10,7 +10,7 @@
 // <functional>
 
 // mem_fun_ref_t
-// Removed in c++1z
+// Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 #include <functional>
diff --git a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.cpp b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.cpp
index e6a1ed330762..b2d6db84c6ea 100644
--- a/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.cpp
+++ b/test/std/depr/depr.function.objects/depr.adaptors/depr.member.pointer.adaptors/mem_fun_t.cxx1z.fail.cpp
@@ -10,7 +10,7 @@
 // <functional>
 
 // mem_fun_t
-// Removed in c++1z
+// Removed in c++17
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 #include <functional>
diff --git a/test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp b/test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp
index ddca8fdd63a4..0ae3b00d2bc4 100644
--- a/test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.base/binary_function.pass.cpp
@@ -8,6 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 // <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
+// binary_function was removed in C++17
 
 // template <class Arg1, class Arg2, class Result>
 // struct binary_function
diff --git a/test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp b/test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp
index 87cfe09a33cd..ededc5376e9b 100644
--- a/test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp
+++ b/test/std/depr/depr.function.objects/depr.base/unary_function.pass.cpp
@@ -8,6 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 // <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
+// unary_function was removed in C++17
 
 // template <class Arg, class Result>
 // struct unary_function
diff --git a/test/std/diagnostics/syserr/is_error_code_enum.pass.cpp b/test/std/diagnostics/syserr/is_error_code_enum.pass.cpp
index bd843621def8..a74bd2f6bdff 100644
--- a/test/std/diagnostics/syserr/is_error_code_enum.pass.cpp
+++ b/test/std/diagnostics/syserr/is_error_code_enum.pass.cpp
@@ -28,8 +28,8 @@ test()
 }
 
 class A {
-	A();
-	operator std::error_code () const { return std::error_code(); }
+    A();
+    operator std::error_code () const { return std::error_code(); }
 };
 
 // Specialize the template for my class
diff --git a/test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp b/test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp
index b2efd9e07750..1321dcc6b952 100644
--- a/test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp
+++ b/test/std/diagnostics/syserr/is_error_condition_enum.pass.cpp
@@ -28,8 +28,8 @@ test()
 }
 
 class A {
-	A();
-	operator std::error_condition () const { return std::error_condition(); }
+    A();
+    operator std::error_condition () const { return std::error_condition(); }
 };
 
 // Specialize the template for my class
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp
index 0783de85c5ff..cd76a9f5e734 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/generic_category.pass.cpp
@@ -7,6 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: suse-linux-enterprise-server-11
 // XFAIL: with_system_cxx_lib=macosx10.12
 // XFAIL: with_system_cxx_lib=macosx10.11
 // XFAIL: with_system_cxx_lib=macosx10.10
diff --git a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp
index 8cccb025538d..c9c6d52e2ebf 100644
--- a/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp
+++ b/test/std/diagnostics/syserr/syserr.errcat/syserr.errcat.objects/system_category.pass.cpp
@@ -13,6 +13,7 @@
 
 // const error_category& system_category();
 
+// XFAIL: suse-linux-enterprise-server-11
 // XFAIL: with_system_cxx_lib=macosx10.12
 // XFAIL: with_system_cxx_lib=macosx10.11
 // XFAIL: with_system_cxx_lib=macosx10.10
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp
new file mode 100644
index 000000000000..6c76a25526f6
--- /dev/null
+++ b/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/types.pass.cpp
@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <system_error>
+// class error_code
+
+// Make sure that the error_code bits of <system_error> are self-contained.
+
+#include <system_error>
+#include "test_macros.h"
+
+int main()
+{
+    std::error_code x;
+    TEST_IGNORE_NODISCARD  x.category();   // returns a std::error_category &
+    TEST_IGNORE_NODISCARD  x.default_error_condition(); // std::error_condition
+    TEST_IGNORE_NODISCARD  x.message();    // returns a std::string
+}
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp
new file mode 100644
index 000000000000..62539ab3ee69
--- /dev/null
+++ b/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/types.pass.cpp
@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <system_error>
+// class error_condition
+
+// Make sure that the error_condition bits of <system_error> are self-contained.
+
+#include <system_error>
+#include "test_macros.h"
+
+int main()
+{
+    std::error_condition x = std::errc(0);
+    TEST_IGNORE_NODISCARD  x.category();   // returns a std::error_condition &
+    TEST_IGNORE_NODISCARD  x.message();    // returns a std::string
+}
diff --git a/test/std/experimental/algorithms/alg.search/search.pass.cpp b/test/std/experimental/algorithms/alg.search/search.pass.cpp
index 81d220ba1aed..126f7c8a8e59 100644
--- a/test/std/experimental/algorithms/alg.search/search.pass.cpp
+++ b/test/std/experimental/algorithms/alg.search/search.pass.cpp
@@ -15,7 +15,7 @@
 //   ForwardIterator search(ForwardIterator first, ForwardIterator last,
 //                          const Searcher& searcher);
 //
-//		returns searcher.operator(first, last).first
+//      returns searcher.operator(first, last).first
 //
 
 #include <experimental/algorithm>
diff --git a/test/std/experimental/any/any.class/any.assign/value_non_copyable_assign.fail.cpp b/test/std/experimental/any/any.class/any.assign/value_non_copyable_assign.fail.cpp
index ce0d44f32d98..7d2d33d63cfc 100644
--- a/test/std/experimental/any/any.class/any.assign/value_non_copyable_assign.fail.cpp
+++ b/test/std/experimental/any/any.class/any.assign/value_non_copyable_assign.fail.cpp
@@ -32,7 +32,7 @@ int main()
     using namespace std::experimental;
     non_copyable nc;
     any a;
-    a = static_cast<non_copyable &&>(nc); // expected-error@experimental/any:* 2 {{static_assert failed "_ValueType must be CopyConstructible."}}
+    a = static_cast<non_copyable &&>(nc); // expected-error-re@experimental/any:* 2 {{static_assert failed{{.*}} "_ValueType must be CopyConstructible."}}
         // expected-error@experimental/any:* {{calling a private constructor of class 'non_copyable'}}
 
 }
diff --git a/test/std/experimental/any/any.class/any.cons/non_copyable_value.fail.cpp b/test/std/experimental/any/any.class/any.cons/non_copyable_value.fail.cpp
index 643b9621ca2f..c4f7568ec853 100644
--- a/test/std/experimental/any/any.class/any.cons/non_copyable_value.fail.cpp
+++ b/test/std/experimental/any/any.class/any.cons/non_copyable_value.fail.cpp
@@ -31,6 +31,6 @@ int main()
     using namespace std::experimental;
     non_copyable nc;
     any a(static_cast<non_copyable &&>(nc));
-    // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType must be CopyConstructible."}}
+    // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType must be CopyConstructible."}}
     // expected-error@experimental/any:* 1 {{calling a private constructor of class 'non_copyable'}}
 }
diff --git a/test/std/experimental/any/any.nonmembers/any.cast/reference_types.fail.cpp b/test/std/experimental/any/any.nonmembers/any.cast/reference_types.fail.cpp
index 6c6ccc68787a..edef3d0a42be 100644
--- a/test/std/experimental/any/any.nonmembers/any.cast/reference_types.fail.cpp
+++ b/test/std/experimental/any/any.nonmembers/any.cast/reference_types.fail.cpp
@@ -25,13 +25,13 @@ using std::experimental::any_cast;
 int main()
 {
     any a(1);
-    any_cast<int &>(&a); // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
-    any_cast<int &&>(&a); // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
-    any_cast<int const &>(&a); // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
-    any_cast<int const&&>(&a); // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+    any_cast<int &>(&a); // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+    any_cast<int &&>(&a); // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+    any_cast<int const &>(&a); // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+    any_cast<int const&&>(&a); // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
     any const& a2 = a;
-    any_cast<int &>(&a2); // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
-    any_cast<int &&>(&a2); // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
-    any_cast<int const &>(&a2); // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
-    any_cast<int const &&>(&a2); // expected-error@experimental/any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+    any_cast<int &>(&a2); // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+    any_cast<int &&>(&a2); // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+    any_cast<int const &>(&a2); // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
+    any_cast<int const &&>(&a2); // expected-error-re@experimental/any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
 }
diff --git a/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/ctor.pass.cpp b/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/ctor.pass.cpp
index 830e8123150a..4fd60887b54c 100644
--- a/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/ctor.pass.cpp
+++ b/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/ctor.pass.cpp
@@ -15,8 +15,8 @@
 
 // explicit directory_iterator(const path& p);
 // directory_iterator(const path& p, directory_options options);
-// directory_iterator(const path& p, error_code& ec) noexcept;
-// directory_iterator(const path& p, directory_options options, error_code& ec) noexcept;
+// directory_iterator(const path& p, error_code& ec);
+// directory_iterator(const path& p, directory_options options, error_code& ec);
 
 #include <experimental/filesystem>
 #include <type_traits>
@@ -40,15 +40,22 @@ TEST_CASE(test_constructor_signatures)
     static_assert(std::is_constructible<D, path>::value, "");
     static_assert(!std::is_nothrow_constructible<D, path>::value, "");
 
-    // directory_iterator(path const&, error_code&) noexcept
-    static_assert(std::is_nothrow_constructible<D, path, std::error_code&>::value, "");
+    // directory_iterator(path const&, error_code&)
+    static_assert(std::is_constructible<D, path,
+        std::error_code&>::value, "");
+    static_assert(!std::is_nothrow_constructible<D, path,
+        std::error_code&>::value, "");
 
     // directory_iterator(path const&, directory_options);
     static_assert(std::is_constructible<D, path, directory_options>::value, "");
     static_assert(!std::is_nothrow_constructible<D, path, directory_options>::value, "");
 
-    // directory_iterator(path const&, directory_options, error_code&) noexcept
-    static_assert(std::is_nothrow_constructible<D, path, directory_options, std::error_code&>::value, "");
+    // directory_iterator(path const&, directory_options, error_code&)
+    static_assert(std::is_constructible<D, path, directory_options,
+        std::error_code&>::value, "");
+    static_assert(!std::is_nothrow_constructible<D, path, directory_options,
+        std::error_code&>::value, "");
+
 }
 
 TEST_CASE(test_construction_from_bad_path)
diff --git a/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/increment.pass.cpp b/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/increment.pass.cpp
index 589b4eca7efa..8d888717b101 100644
--- a/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/increment.pass.cpp
+++ b/test/std/experimental/filesystem/class.directory_iterator/directory_iterator.members/increment.pass.cpp
@@ -14,7 +14,7 @@
 // class directory_iterator
 
 // directory_iterator& operator++();
-// directory_iterator& increment(error_code& ec) noexcept;
+// directory_iterator& increment(error_code& ec);
 
 #include <experimental/filesystem>
 #include <type_traits>
@@ -40,7 +40,7 @@ TEST_CASE(test_increment_signatures)
     ASSERT_NOT_NOEXCEPT(++d);
 
     ASSERT_SAME_TYPE(decltype(d.increment(ec)), directory_iterator&);
-    ASSERT_NOEXCEPT(d.increment(ec));
+    ASSERT_NOT_NOEXCEPT(d.increment(ec));
 }
 
 TEST_CASE(test_prefix_increment)
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.decompose/empty.fail.cpp b/test/std/experimental/filesystem/class.path/path.member/path.decompose/empty.fail.cpp
new file mode 100644
index 000000000000..7e1fea7d34d2
--- /dev/null
+++ b/test/std/experimental/filesystem/class.path/path.member/path.decompose/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/filesystem>
+
+// class path
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <experimental/filesystem>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::experimental::filesystem::path c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/experimental/filesystem/class.path/path.member/path.decompose/path.decompose.pass.cpp b/test/std/experimental/filesystem/class.path/path.member/path.decompose/path.decompose.pass.cpp
index 078e006663e9..267d4932c316 100644
--- a/test/std/experimental/filesystem/class.path/path.member/path.decompose/path.decompose.pass.cpp
+++ b/test/std/experimental/filesystem/class.path/path.member/path.decompose/path.decompose.pass.cpp
@@ -177,6 +177,7 @@ void decompFilenameTest()
   for (auto const & TC : FilenameTestCases) {
     path p(TC.raw);
     assert(p == TC.raw);
+    ASSERT_NOEXCEPT(p.empty());
 
     assert(p.filename() == TC.filename);
     assert(p.has_filename() != TC.filename.empty());
diff --git a/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp
index 8f6009d399c1..1469dae049eb 100644
--- a/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp
+++ b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp
@@ -16,8 +16,8 @@
 //
 // explicit recursive_directory_iterator(const path& p);
 // recursive_directory_iterator(const path& p, directory_options options);
-// recursive_directory_iterator(const path& p, error_code& ec) noexcept;
-// recursive_directory_iterator(const path& p, directory_options options, error_code& ec) noexcept;
+// recursive_directory_iterator(const path& p, error_code& ec);
+// recursive_directory_iterator(const path& p, directory_options options, error_code& ec);
 
 
 #include <experimental/filesystem>
@@ -44,15 +44,19 @@ TEST_CASE(test_constructor_signatures)
     static_assert(std::is_constructible<D, path>::value, "");
     static_assert(!std::is_nothrow_constructible<D, path>::value, "");
 
-    // directory_iterator(path const&, error_code&) noexcept
-    static_assert(std::is_nothrow_constructible<D, path, std::error_code&>::value, "");
+    // directory_iterator(path const&, error_code&)
+    static_assert(std::is_constructible<D, path,
+        std::error_code&>::value, "");
+    static_assert(!std::is_nothrow_constructible<D, path,
+        std::error_code&>::value, "");
 
     // directory_iterator(path const&, directory_options);
     static_assert(std::is_constructible<D, path, directory_options>::value, "");
     static_assert(!std::is_nothrow_constructible<D, path, directory_options>::value, "");
 
-    // directory_iterator(path const&, directory_options, error_code&) noexcept
-    static_assert(std::is_nothrow_constructible<D, path, directory_options, std::error_code&>::value, "");
+    // directory_iterator(path const&, directory_options, error_code&)
+    static_assert(std::is_constructible<D, path, directory_options, std::error_code&>::value, "");
+    static_assert(!std::is_nothrow_constructible<D, path, directory_options, std::error_code&>::value, "");
 }
 
 TEST_CASE(test_construction_from_bad_path)
diff --git a/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/increment.pass.cpp b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/increment.pass.cpp
index 26fc3ca28d8e..ea81ee25313d 100644
--- a/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/increment.pass.cpp
+++ b/test/std/experimental/filesystem/class.rec.dir.itr/rec.dir.itr.members/increment.pass.cpp
@@ -40,7 +40,7 @@ TEST_CASE(test_increment_signatures)
     ASSERT_NOT_NOEXCEPT(++d);
 
     ASSERT_SAME_TYPE(decltype(d.increment(ec)), recursive_directory_iterator&);
-    ASSERT_NOEXCEPT(d.increment(ec));
+    ASSERT_NOT_NOEXCEPT(d.increment(ec));
 }
 
 TEST_CASE(test_prefix_increment)
@@ -237,4 +237,250 @@ TEST_CASE(access_denied_on_recursion_test_case)
     }
 }
 
+// See llvm.org/PR35078
+TEST_CASE(test_PR35078)
+{
+  using namespace std::experimental::filesystem;
+    scoped_test_env env;
+    const path testFiles[] = {
+        env.create_dir("dir1"),
+        env.create_dir("dir1/dir2"),
+        env.create_dir("dir1/dir2/dir3"),
+        env.create_file("dir1/file1"),
+        env.create_file("dir1/dir2/dir3/file2")
+    };
+    const path startDir = testFiles[0];
+    const path permDeniedDir = testFiles[1];
+    const path nestedDir = testFiles[2];
+    const path nestedFile = testFiles[3];
+
+    // Change the permissions so we can no longer iterate
+    permissions(permDeniedDir,
+                perms::remove_perms|perms::group_exec
+               |perms::owner_exec|perms::others_exec);
+
+    const std::error_code eacess_ec =
+        std::make_error_code(std::errc::permission_denied);
+    std::error_code ec = GetTestEC();
+
+    const recursive_directory_iterator endIt;
+
+    auto SetupState = [&](bool AllowEAccess, bool& SeenFile3) {
+      SeenFile3 = false;
+      auto Opts = AllowEAccess ? directory_options::skip_permission_denied
+          : directory_options::none;
+      recursive_directory_iterator it(startDir, Opts, ec);
+      while (!ec && it != endIt && *it != nestedDir) {
+        if (*it == nestedFile)
+          SeenFile3 = true;
+        it.increment(ec);
+      }
+      return it;
+    };
+
+    {
+      bool SeenNestedFile = false;
+      recursive_directory_iterator it = SetupState(false, SeenNestedFile);
+      TEST_REQUIRE(it != endIt);
+      TEST_REQUIRE(*it == nestedDir);
+      ec = GetTestEC();
+      it.increment(ec);
+      TEST_CHECK(ec);
+      TEST_CHECK(ec == eacess_ec);
+      TEST_CHECK(it == endIt);
+    }
+    {
+      bool SeenNestedFile = false;
+      recursive_directory_iterator it = SetupState(true, SeenNestedFile);
+      TEST_REQUIRE(it != endIt);
+      TEST_REQUIRE(*it == nestedDir);
+      ec = GetTestEC();
+      it.increment(ec);
+      TEST_CHECK(!ec);
+      if (SeenNestedFile) {
+        TEST_CHECK(it == endIt);
+      } else {
+        TEST_REQUIRE(it != endIt);
+        TEST_CHECK(*it == nestedFile);
+      }
+    }
+}
+
+
+// See llvm.org/PR35078
+TEST_CASE(test_PR35078_with_symlink)
+{
+  using namespace std::experimental::filesystem;
+    scoped_test_env env;
+    const path testFiles[] = {
+        env.create_dir("dir1"),
+        env.create_file("dir1/file1"),
+        env.create_dir("sym_dir"),
+        env.create_dir("sym_dir/nested_sym_dir"),
+        env.create_symlink("sym_dir/nested_sym_dir", "dir1/dir2"),
+        env.create_dir("sym_dir/dir1"),
+        env.create_dir("sym_dir/dir1/dir2"),
+
+    };
+   // const unsigned TestFilesSize = sizeof(testFiles) / sizeof(testFiles[0]);
+    const path startDir = testFiles[0];
+    const path nestedFile = testFiles[1];
+    const path permDeniedDir = testFiles[2];
+    const path symDir = testFiles[4];
+
+    // Change the permissions so we can no longer iterate
+    permissions(permDeniedDir,
+                perms::remove_perms|perms::group_exec
+               |perms::owner_exec|perms::others_exec);
+
+    const std::error_code eacess_ec =
+        std::make_error_code(std::errc::permission_denied);
+    std::error_code ec = GetTestEC();
+
+    const recursive_directory_iterator endIt;
+
+    auto SetupState = [&](bool AllowEAccess, bool FollowSym, bool& SeenFile3) {
+      SeenFile3 = false;
+      auto Opts = AllowEAccess ? directory_options::skip_permission_denied
+          : directory_options::none;
+      if (FollowSym)
+        Opts |= directory_options::follow_directory_symlink;
+      recursive_directory_iterator it(startDir, Opts, ec);
+      while (!ec && it != endIt && *it != symDir) {
+        std::cout << *it << std::endl;
+        if (*it == nestedFile)
+          SeenFile3 = true;
+        it.increment(ec);
+      }
+      return it;
+    };
+
+    struct {
+      bool SkipPermDenied;
+      bool FollowSymlinks;
+      bool ExpectSuccess;
+    } TestCases[]  = {
+        // Passing cases
+        {false, false, true}, {true, true, true}, {true, false, true},
+        // Failing cases
+        {false, true, false}
+    };
+    for (auto TC : TestCases) {
+      bool SeenNestedFile = false;
+      recursive_directory_iterator it = SetupState(TC.SkipPermDenied,
+                                                   TC.FollowSymlinks,
+                                                   SeenNestedFile);
+      TEST_REQUIRE(!ec);
+      TEST_REQUIRE(it != endIt);
+      TEST_REQUIRE(*it == symDir);
+      ec = GetTestEC();
+      it.increment(ec);
+      if (TC.ExpectSuccess) {
+        TEST_CHECK(!ec);
+        if (SeenNestedFile) {
+          TEST_CHECK(it == endIt);
+        } else {
+          TEST_REQUIRE(it != endIt);
+          TEST_CHECK(*it == nestedFile);
+        }
+      } else {
+        TEST_CHECK(ec);
+        TEST_CHECK(ec == eacess_ec);
+        TEST_CHECK(it == endIt);
+      }
+    }
+}
+
+
+// See llvm.org/PR35078
+TEST_CASE(test_PR35078_with_symlink_file)
+{
+  using namespace std::experimental::filesystem;
+    scoped_test_env env;
+    const path testFiles[] = {
+        env.create_dir("dir1"),
+        env.create_dir("dir1/dir2"),
+        env.create_file("dir1/file2"),
+        env.create_dir("sym_dir"),
+        env.create_dir("sym_dir/sdir1"),
+        env.create_file("sym_dir/sdir1/sfile1"),
+        env.create_symlink("sym_dir/sdir1/sfile1", "dir1/dir2/file1")
+    };
+    const unsigned TestFilesSize = sizeof(testFiles) / sizeof(testFiles[0]);
+    const path startDir = testFiles[0];
+    const path nestedDir = testFiles[1];
+    const path nestedFile = testFiles[2];
+    const path permDeniedDir = testFiles[3];
+    const path symFile = testFiles[TestFilesSize - 1];
+
+    // Change the permissions so we can no longer iterate
+    permissions(permDeniedDir,
+                perms::remove_perms|perms::group_exec
+               |perms::owner_exec|perms::others_exec);
+
+    const std::error_code eacess_ec =
+        std::make_error_code(std::errc::permission_denied);
+    std::error_code ec = GetTestEC();
+
+    const recursive_directory_iterator EndIt;
+
+    auto SetupState = [&](bool AllowEAccess, bool FollowSym, bool& SeenNestedFile) {
+      SeenNestedFile = false;
+      auto Opts = AllowEAccess ? directory_options::skip_permission_denied
+          : directory_options::none;
+      if (FollowSym)
+        Opts |= directory_options::follow_directory_symlink;
+      recursive_directory_iterator it(startDir, Opts, ec);
+      while (!ec && it != EndIt && *it != nestedDir) {
+        if (*it == nestedFile)
+          SeenNestedFile = true;
+        it.increment(ec);
+      }
+      return it;
+    };
+
+    struct {
+      bool SkipPermDenied;
+      bool FollowSymlinks;
+      bool ExpectSuccess;
+    } TestCases[]  = {
+        // Passing cases
+        {false, false, true}, {true, true, true}, {true, false, true},
+        // Failing cases
+        {false, true, false}
+    };
+    for (auto TC : TestCases){
+      bool SeenNestedFile = false;
+      recursive_directory_iterator it = SetupState(TC.SkipPermDenied,
+                                                   TC.FollowSymlinks,
+                                                   SeenNestedFile);
+      TEST_REQUIRE(!ec);
+      TEST_REQUIRE(it != EndIt);
+      TEST_REQUIRE(*it == nestedDir);
+      ec = GetTestEC();
+      it.increment(ec);
+      TEST_REQUIRE(it != EndIt);
+      TEST_CHECK(!ec);
+      TEST_CHECK(*it == symFile);
+      ec = GetTestEC();
+      it.increment(ec);
+      if (TC.ExpectSuccess) {
+        if (!SeenNestedFile) {
+          TEST_CHECK(!ec);
+          TEST_REQUIRE(it != EndIt);
+          TEST_CHECK(*it == nestedFile);
+          ec = GetTestEC();
+          it.increment(ec);
+        }
+        TEST_CHECK(!ec);
+        TEST_CHECK(it == EndIt);
+      } else {
+        TEST_CHECK(ec);
+        TEST_CHECK(ec == eacess_ec);
+        TEST_CHECK(it == EndIt);
+      }
+    }
+}
+
+
 TEST_SUITE_END()
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.copy/copy.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.copy/copy.pass.cpp
index c9b42b3596ad..8f44e0d5a23b 100644
--- a/test/std/experimental/filesystem/fs.op.funcs/fs.op.copy/copy.pass.cpp
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.copy/copy.pass.cpp
@@ -12,10 +12,10 @@
 // <experimental/filesystem>
 
 // void copy(const path& from, const path& to);
-// void copy(const path& from, const path& to, error_code& ec) noexcept;
+// void copy(const path& from, const path& to, error_code& ec);
 // void copy(const path& from, const path& to, copy_options options);
 // void copy(const path& from, const path& to, copy_options options,
-//           error_code& ec) noexcept;
+//           error_code& ec);
 
 #include <experimental/filesystem>
 #include <type_traits>
@@ -39,9 +39,9 @@ TEST_CASE(signature_test)
     std::error_code ec; ((void)ec);
     const copy_options opts{}; ((void)opts);
     ASSERT_NOT_NOEXCEPT(fs::copy(p, p));
-    ASSERT_NOEXCEPT(fs::copy(p, p, ec));
+    ASSERT_NOT_NOEXCEPT(fs::copy(p, p, ec));
     ASSERT_NOT_NOEXCEPT(copy(p, p, opts));
-    ASSERT_NOEXCEPT(copy(p, p, opts, ec));
+    ASSERT_NOT_NOEXCEPT(copy(p, p, opts, ec));
 }
 
 // There are 4 cases is the proposal for absolute path.
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_empty/is_empty.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_empty/is_empty.pass.cpp
index bc62086c2cff..2da163c33471 100644
--- a/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_empty/is_empty.pass.cpp
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.is_empty/is_empty.pass.cpp
@@ -12,7 +12,7 @@
 // <experimental/filesystem>
 
 // bool is_empty(path const& p);
-// bool is_empty(path const& p, std::error_code& ec) noexcept;
+// bool is_empty(path const& p, std::error_code& ec);
 
 #include <experimental/filesystem>
 #include <type_traits>
@@ -30,7 +30,7 @@ TEST_CASE(signature_test)
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
-    ASSERT_NOEXCEPT(is_empty(p, ec));
+    ASSERT_NOT_NOEXCEPT(is_empty(p, ec));
     ASSERT_NOT_NOEXCEPT(is_empty(p));
 }
 
diff --git a/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp b/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
index ed25649531b9..cdd177399aa7 100644
--- a/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
+++ b/test/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
@@ -88,6 +88,16 @@ bool TestSupportsNegativeTimes() {
     return !ec && new_write_time <= -5;
 }
 
+// In some configurations, the comparison is tautological and the test is valid.
+// We disable the warning so that we can actually test it regardless. Also, that
+// diagnostic is pretty new, so also don't fail if old clang does not support it
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunknown-warning-option"
+#pragma clang diagnostic ignored "-Wunknown-pragmas"
+#pragma clang diagnostic ignored "-Wtautological-constant-compare"
+#endif
+
 bool TestSupportsMaxTime() {
     using namespace std::chrono;
     using Lim = std::numeric_limits<std::time_t>;
@@ -106,11 +116,25 @@ bool TestSupportsMaxTime() {
     return !ec && new_write_time > max_sec - 1;
 }
 
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
 static const bool SupportsNegativeTimes = TestSupportsNegativeTimes();
 static const bool SupportsMaxTime = TestSupportsMaxTime();
 
 } // end namespace
 
+// In some configurations, the comparison is tautological and the test is valid.
+// We disable the warning so that we can actually test it regardless. Also, that
+// diagnostic is pretty new, so also don't fail if old clang does not support it
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunknown-warning-option"
+#pragma clang diagnostic ignored "-Wunknown-pragmas"
+#pragma clang diagnostic ignored "-Wtautological-constant-compare"
+#endif
+
 // Check if a time point is representable on a given filesystem. Check that:
 // (A) 'tp' is representable as a time_t
 // (B) 'tp' is non-negative or the filesystem supports negative times.
@@ -127,6 +151,10 @@ inline bool TimeIsRepresentableByFilesystem(file_time_type tp) {
     return true;
 }
 
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
 TEST_SUITE(exists_test_suite)
 
 TEST_CASE(signature_test)
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
index 467e09d5d2b6..68c786bc7b10 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp
@@ -39,7 +39,7 @@
 #include "test_iterators.h"
 
 template <typename T> struct MyHash {
-	size_t operator () (T t) const { return static_cast<size_t>(t); }
+    size_t operator () (T t) const { return static_cast<size_t>(t); }
 };
 
 template <typename Iter1, typename Iter2>
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
index b0e5e877dfe1..fe03fa081bce 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp
@@ -39,7 +39,7 @@
 #include "test_iterators.h"
 
 template <typename T> struct MyHash {
-	size_t operator () (T t) const { return static_cast<size_t>(t); }
+    size_t operator () (T t) const { return static_cast<size_t>(t); }
 };
 
 struct count_equal
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
index abfab17d02ce..e2d34df8235a 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp
@@ -38,7 +38,7 @@
 #include "test_iterators.h"
 
 template <typename T> struct MyHash {
-	size_t operator () (T t) const { return static_cast<size_t>(t); }
+    size_t operator () (T t) const { return static_cast<size_t>(t); }
 };
 
 template <typename Iter1, typename Iter2>
diff --git a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
index 28f3324966ea..eaa5233d627c 100644
--- a/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
+++ b/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp
@@ -38,7 +38,7 @@
 #include "test_iterators.h"
 
 template <typename T> struct MyHash {
-	size_t operator () (T t) const { return static_cast<size_t>(t); }
+    size_t operator () (T t) const { return static_cast<size_t>(t); }
 };
 
 struct count_equal
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp
index 5c84d210e53e..0bae57e1b182 100644
--- a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.pass.cpp
@@ -26,33 +26,33 @@
 namespace exp = std::experimental;
 
 int main () {
-	const char eight = '8';
-	const std::string nine = "9";
-	const std::wstring ten = L"10";
-	const int eleven = 11;
-
-//	Narrow streams w/rvalues
-	{ exp::ostream_joiner<char>         oj(std::cout, '8'); }
-	{ exp::ostream_joiner<std::string>  oj(std::cout, std::string("9")); }
-	{ exp::ostream_joiner<std::wstring> oj(std::cout, std::wstring(L"10")); }
-	{ exp::ostream_joiner<int>          oj(std::cout, 11); }
-
-//	Narrow streams w/lvalues
-	{ exp::ostream_joiner<char>         oj(std::cout, eight); }
-	{ exp::ostream_joiner<std::string>  oj(std::cout, nine); }
-	{ exp::ostream_joiner<std::wstring> oj(std::cout, ten); }
-	{ exp::ostream_joiner<int>          oj(std::cout, eleven); }
-
-//	Wide streams w/rvalues
-	{ exp::ostream_joiner<char, wchar_t>         oj(std::wcout, '8'); }
-	{ exp::ostream_joiner<std::string, wchar_t>  oj(std::wcout, std::string("9")); }
-	{ exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, std::wstring(L"10")); }
-	{ exp::ostream_joiner<int, wchar_t>          oj(std::wcout, 11); }
-
-//	Wide streams w/lvalues
-	{ exp::ostream_joiner<char, wchar_t>         oj(std::wcout, eight); }
-	{ exp::ostream_joiner<std::string, wchar_t>  oj(std::wcout, nine); }
-	{ exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, ten); }
-	{ exp::ostream_joiner<int, wchar_t>          oj(std::wcout, eleven); }
-
-	}
+    const char eight = '8';
+    const std::string nine = "9";
+    const std::wstring ten = L"10";
+    const int eleven = 11;
+
+//  Narrow streams w/rvalues
+    { exp::ostream_joiner<char>         oj(std::cout, '8'); }
+    { exp::ostream_joiner<std::string>  oj(std::cout, std::string("9")); }
+    { exp::ostream_joiner<std::wstring> oj(std::cout, std::wstring(L"10")); }
+    { exp::ostream_joiner<int>          oj(std::cout, 11); }
+
+//  Narrow streams w/lvalues
+    { exp::ostream_joiner<char>         oj(std::cout, eight); }
+    { exp::ostream_joiner<std::string>  oj(std::cout, nine); }
+    { exp::ostream_joiner<std::wstring> oj(std::cout, ten); }
+    { exp::ostream_joiner<int>          oj(std::cout, eleven); }
+
+//  Wide streams w/rvalues
+    { exp::ostream_joiner<char, wchar_t>         oj(std::wcout, '8'); }
+    { exp::ostream_joiner<std::string, wchar_t>  oj(std::wcout, std::string("9")); }
+    { exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, std::wstring(L"10")); }
+    { exp::ostream_joiner<int, wchar_t>          oj(std::wcout, 11); }
+
+//  Wide streams w/lvalues
+    { exp::ostream_joiner<char, wchar_t>         oj(std::wcout, eight); }
+    { exp::ostream_joiner<std::string, wchar_t>  oj(std::wcout, nine); }
+    { exp::ostream_joiner<std::wstring, wchar_t> oj(std::wcout, ten); }
+    { exp::ostream_joiner<int, wchar_t>          oj(std::wcout, eleven); }
+
+    }
diff --git a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
index b2c294fd034b..87ab1e271dc8 100644
--- a/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
+++ b/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp
@@ -27,10 +27,10 @@
 #include "test_iterators.h"
 
 struct mutating_delimiter {
-	mutating_delimiter(char c = ' ') : c_(c) {}
-	char get () const { return c_++; }
-	mutable char c_;
-	};
+    mutating_delimiter(char c = ' ') : c_(c) {}
+    char get () const { return c_++; }
+    mutable char c_;
+    };
 
 template<class _CharT, class _Traits>
 std::basic_ostream<_CharT, _Traits>&
@@ -39,10 +39,10 @@ operator<<(std::basic_ostream<_CharT, _Traits>& os, const mutating_delimiter &d)
 
 
 struct mutating_delimiter2 { // same as above, w/o the const and the mutable
-	mutating_delimiter2(char c = ' ') : c_(c) {}
-	char get () { return c_++; }
-	char c_;
-	};
+    mutating_delimiter2(char c = ' ') : c_(c) {}
+    char get () { return c_++; }
+    char c_;
+    };
 
 template<class _CharT, class _Traits>
 std::basic_ostream<_CharT, _Traits>&
@@ -54,67 +54,67 @@ namespace exp = std::experimental;
 
 template <class Delim, class Iter, class CharT = char, class Traits = std::char_traits<CharT>>
 void test (Delim &&d, Iter first, Iter last, const CharT *expected ) {
-	typedef exp::ostream_joiner<typename std::decay<Delim>::type, CharT, Traits> Joiner;
+    typedef exp::ostream_joiner<typename std::decay<Delim>::type, CharT, Traits> Joiner;
 
-	static_assert((std::is_copy_constructible<Joiner>::value == std::is_copy_constructible<typename std::decay<Delim>::type>::value), "" );
-	static_assert((std::is_move_constructible<Joiner>::value == std::is_move_constructible<typename std::decay<Delim>::type>::value), "" );
-	static_assert((std::is_copy_assignable<Joiner>   ::value == std::is_copy_assignable<typename std::decay<Delim>::type>   ::value), "" );
-	static_assert((std::is_move_assignable<Joiner>   ::value == std::is_move_assignable<typename std::decay<Delim>::type>   ::value), "" );
+    static_assert((std::is_copy_constructible<Joiner>::value == std::is_copy_constructible<typename std::decay<Delim>::type>::value), "" );
+    static_assert((std::is_move_constructible<Joiner>::value == std::is_move_constructible<typename std::decay<Delim>::type>::value), "" );
+    static_assert((std::is_copy_assignable<Joiner>   ::value == std::is_copy_assignable<typename std::decay<Delim>::type>   ::value), "" );
+    static_assert((std::is_move_assignable<Joiner>   ::value == std::is_move_assignable<typename std::decay<Delim>::type>   ::value), "" );
 
-	std::basic_stringstream<CharT, Traits> sstream;
-	Joiner joiner(sstream, d);
-	while (first != last)
-		*joiner++ = *first++;
-	assert(sstream.str() == expected);
-	}
+    std::basic_stringstream<CharT, Traits> sstream;
+    Joiner joiner(sstream, d);
+    while (first != last)
+        *joiner++ = *first++;
+    assert(sstream.str() == expected);
+    }
 
 int main () {
 {
-	const char chars[] = "0123456789";
-	const int  ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
-
-	test('X', chars, chars+10, "0X1X2X3X4X5X6X7X8X9");
-	test('x',  ints,  ints+10, "10x11x12x13x14x15x16x17x18x19");
-	test('X', input_iterator<const char*>(chars),         input_iterator<const char*>(chars+10),         "0X1X2X3X4X5X6X7X8X9");
-	test('x', input_iterator<const int*>(ints),           input_iterator<const int*>(ints+10),           "10x11x12x13x14x15x16x17x18x19");
-	test('X', forward_iterator<const char*>(chars),       forward_iterator<const char*>(chars+10),       "0X1X2X3X4X5X6X7X8X9");
-	test('x', forward_iterator<const int*>(ints),         forward_iterator<const int*>(ints+10),         "10x11x12x13x14x15x16x17x18x19");
-	test('X', random_access_iterator<const char*>(chars), random_access_iterator<const char*>(chars+10), "0X1X2X3X4X5X6X7X8X9");
-	test('x', random_access_iterator<const int*>(ints),   random_access_iterator<const int*>(ints+10),   "10x11x12x13x14x15x16x17x18x19");
-
-	test("Z", chars, chars+10, "0Z1Z2Z3Z4Z5Z6Z7Z8Z9");
-	test("z", ints,  ints+10,  "10z11z12z13z14z15z16z17z18z19");
-
-	test<char, const char *, wchar_t> ('X', chars, chars+10, L"0X1X2X3X4X5X6X7X8X9");
-	test<char, const int *,  wchar_t> ('x',  ints,  ints+10, L"10x11x12x13x14x15x16x17x18x19");
-// 	test<char, const char *, char16_t>('X', chars, chars+10, u"0X1X2X3X4X5X6X7X8X9");
-// 	test<char, const int *,  char16_t>('x',  ints,  ints+10, u"10x11x12x13x14x15x16x17x18x19");
-// 	test<char, const char *, char32_t>('X', chars, chars+10, U"0X1X2X3X4X5X6X7X8X9");
-// 	test<char, const int *,  char32_t>('x',  ints,  ints+10, U"10x11x12x13x14x15x16x17x18x19");
-
-	test(mutating_delimiter(),  chars, chars+10, "0 1!2\"3#4$5%6&7'8(9");
-	test(mutating_delimiter2(), chars, chars+10, "0 1!2\"3#4$5%6&7'8(9");
-	}
-
-	{
-	const wchar_t chars[] = L"0123456789";
-	const int  ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
-	test(L'X', chars, chars+10, L"0X1X2X3X4X5X6X7X8X9");
-	test(L'x',  ints,  ints+10, L"10x11x12x13x14x15x16x17x18x19");
-	test(L'X', input_iterator<const wchar_t*>(chars),         input_iterator<const wchar_t*>(chars+10),         L"0X1X2X3X4X5X6X7X8X9");
-	test(L'x', input_iterator<const int*>(ints),              input_iterator<const int*>(ints+10),              L"10x11x12x13x14x15x16x17x18x19");
-	test(L'X', forward_iterator<const wchar_t*>(chars),       forward_iterator<const wchar_t*>(chars+10),       L"0X1X2X3X4X5X6X7X8X9");
-	test(L'x', forward_iterator<const int*>(ints),            forward_iterator<const int*>(ints+10),            L"10x11x12x13x14x15x16x17x18x19");
-	test(L'X', random_access_iterator<const wchar_t*>(chars), random_access_iterator<const wchar_t*>(chars+10), L"0X1X2X3X4X5X6X7X8X9");
-	test(L'x', random_access_iterator<const int*>(ints),      random_access_iterator<const int*>(ints+10),      L"10x11x12x13x14x15x16x17x18x19");
-
-	test(L"Z", chars, chars+10, L"0Z1Z2Z3Z4Z5Z6Z7Z8Z9");
-	test(L"z", ints,  ints+10,  L"10z11z12z13z14z15z16z17z18z19");
-
-	test<char, const wchar_t *, wchar_t> ('X', chars, chars+10, L"0X1X2X3X4X5X6X7X8X9");
-	test<char, const int *,  wchar_t>    ('x',  ints,  ints+10, L"10x11x12x13x14x15x16x17x18x19");
-
-	test(mutating_delimiter(), chars, chars+10, L"0 1!2\"3#4$5%6&7'8(9");
-	}
+    const char chars[] = "0123456789";
+    const int  ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
+
+    test('X', chars, chars+10, "0X1X2X3X4X5X6X7X8X9");
+    test('x',  ints,  ints+10, "10x11x12x13x14x15x16x17x18x19");
+    test('X', input_iterator<const char*>(chars),         input_iterator<const char*>(chars+10),         "0X1X2X3X4X5X6X7X8X9");
+    test('x', input_iterator<const int*>(ints),           input_iterator<const int*>(ints+10),           "10x11x12x13x14x15x16x17x18x19");
+    test('X', forward_iterator<const char*>(chars),       forward_iterator<const char*>(chars+10),       "0X1X2X3X4X5X6X7X8X9");
+    test('x', forward_iterator<const int*>(ints),         forward_iterator<const int*>(ints+10),         "10x11x12x13x14x15x16x17x18x19");
+    test('X', random_access_iterator<const char*>(chars), random_access_iterator<const char*>(chars+10), "0X1X2X3X4X5X6X7X8X9");
+    test('x', random_access_iterator<const int*>(ints),   random_access_iterator<const int*>(ints+10),   "10x11x12x13x14x15x16x17x18x19");
+
+    test("Z", chars, chars+10, "0Z1Z2Z3Z4Z5Z6Z7Z8Z9");
+    test("z", ints,  ints+10,  "10z11z12z13z14z15z16z17z18z19");
+
+    test<char, const char *, wchar_t> ('X', chars, chars+10, L"0X1X2X3X4X5X6X7X8X9");
+    test<char, const int *,  wchar_t> ('x',  ints,  ints+10, L"10x11x12x13x14x15x16x17x18x19");
+//  test<char, const char *, char16_t>('X', chars, chars+10, u"0X1X2X3X4X5X6X7X8X9");
+//  test<char, const int *,  char16_t>('x',  ints,  ints+10, u"10x11x12x13x14x15x16x17x18x19");
+//  test<char, const char *, char32_t>('X', chars, chars+10, U"0X1X2X3X4X5X6X7X8X9");
+//  test<char, const int *,  char32_t>('x',  ints,  ints+10, U"10x11x12x13x14x15x16x17x18x19");
+
+    test(mutating_delimiter(),  chars, chars+10, "0 1!2\"3#4$5%6&7'8(9");
+    test(mutating_delimiter2(), chars, chars+10, "0 1!2\"3#4$5%6&7'8(9");
+    }
+
+    {
+    const wchar_t chars[] = L"0123456789";
+    const int  ints [] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
+    test(L'X', chars, chars+10, L"0X1X2X3X4X5X6X7X8X9");
+    test(L'x',  ints,  ints+10, L"10x11x12x13x14x15x16x17x18x19");
+    test(L'X', input_iterator<const wchar_t*>(chars),         input_iterator<const wchar_t*>(chars+10),         L"0X1X2X3X4X5X6X7X8X9");
+    test(L'x', input_iterator<const int*>(ints),              input_iterator<const int*>(ints+10),              L"10x11x12x13x14x15x16x17x18x19");
+    test(L'X', forward_iterator<const wchar_t*>(chars),       forward_iterator<const wchar_t*>(chars+10),       L"0X1X2X3X4X5X6X7X8X9");
+    test(L'x', forward_iterator<const int*>(ints),            forward_iterator<const int*>(ints+10),            L"10x11x12x13x14x15x16x17x18x19");
+    test(L'X', random_access_iterator<const wchar_t*>(chars), random_access_iterator<const wchar_t*>(chars+10), L"0X1X2X3X4X5X6X7X8X9");
+    test(L'x', random_access_iterator<const int*>(ints),      random_access_iterator<const int*>(ints+10),      L"10x11x12x13x14x15x16x17x18x19");
+
+    test(L"Z", chars, chars+10, L"0Z1Z2Z3Z4Z5Z6Z7Z8Z9");
+    test(L"z", ints,  ints+10,  L"10z11z12z13z14z15z16z17z18z19");
+
+    test<char, const wchar_t *, wchar_t> ('X', chars, chars+10, L"0X1X2X3X4X5X6X7X8X9");
+    test<char, const int *,  wchar_t>    ('x',  ints,  ints+10, L"10x11x12x13x14x15x16x17x18x19");
+
+    test(mutating_delimiter(), chars, chars+10, L"0 1!2\"3#4$5%6&7'8(9");
+    }
 
 }
diff --git a/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp b/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp
index 20bcf60fbf00..83c9da66de44 100644
--- a/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp
+++ b/test/std/experimental/language.support/support.coroutines/end.to.end/fullexpr-dtor.pass.cpp
@@ -33,7 +33,7 @@ struct Noisy {
   Noisy(Noisy const&) = delete;
 #else
   // FIXME: This test depends on copy elision taking place in C++14
-  // (pre-c++17 guaranteed copy elision)
+  // (pre-C++17 guaranteed copy elision)
   Noisy(Noisy const&);
 #endif
 };
diff --git a/test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp b/test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp
index eddfede29630..8cce9d293f9b 100644
--- a/test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp
+++ b/test/std/experimental/memory/memory.resource/memory.resource.priv/protected_members.fail.cpp
@@ -24,4 +24,4 @@ int main() {
     m->do_allocate(0, 0); // expected-error{{'do_allocate' is a protected member}}
     m->do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a protected member}}
     m->do_is_equal(*m); // expected-error{{'do_is_equal' is a protected member}}
-}
\ No newline at end of file
+}
diff --git a/test/std/experimental/numeric/numeric.ops/numeric.ops.lcm/lcm.pass.cpp b/test/std/experimental/numeric/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
index fd463e88e63f..211363aeac68 100644
--- a/test/std/experimental/numeric/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
+++ b/test/std/experimental/numeric/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
@@ -132,8 +132,8 @@ int main()
 //  LWG#2792
     {
     auto res1 = std::experimental::lcm((int64_t)1234, (int32_t)-2147483648);
-    (void) std::experimental::lcm<int, unsigned long>(INT_MIN, 2);	// this used to trigger UBSAN
+    (void) std::experimental::lcm<int, unsigned long>(INT_MIN, 2);  // this used to trigger UBSAN
     static_assert( std::is_same<decltype(res1), std::common_type<int64_t, int32_t>::type>::value, "");
-	assert(res1 == 1324997410816LL);
+    assert(res1 == 1324997410816LL);
     }
 }
diff --git a/test/std/experimental/optional/optional.syn/optional_includes_initializer_list.pass.cpp b/test/std/experimental/optional/optional.syn/optional_includes_initializer_list.pass.cpp
index 8cf11b553e74..b8fba47f7e78 100644
--- a/test/std/experimental/optional/optional.syn/optional_includes_initializer_list.pass.cpp
+++ b/test/std/experimental/optional/optional.syn/optional_includes_initializer_list.pass.cpp
@@ -19,4 +19,5 @@ int main()
     using std::experimental::optional;
 
     std::initializer_list<int> list;
+    (void)list;
 }
diff --git a/test/std/experimental/string.view/string.view.cons/from_string1.fail.cpp b/test/std/experimental/string.view/string.view.cons/from_string1.fail.cpp
index b2ffa61c29d9..72e9dad83c84 100644
--- a/test/std/experimental/string.view/string.view.cons/from_string1.fail.cpp
+++ b/test/std/experimental/string.view/string.view.cons/from_string1.fail.cpp
@@ -29,4 +29,4 @@ int main () {
     assert ( sv1.size() == s.size());
     assert ( sv1.data() == s.data());
     }
-}
\ No newline at end of file
+}
diff --git a/test/std/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp b/test/std/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp
index d37557a7b172..5cfb15e3df29 100644
--- a/test/std/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp
+++ b/test/std/experimental/utilities/tuple/header.tuple.synop/includes.pass.cpp
@@ -16,4 +16,5 @@
 int main()
 {
   std::tuple<int> x(1);
+  (void)x;
 }
diff --git a/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp b/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp
index a00cf139be93..342e33724cc7 100644
--- a/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp
+++ b/test/std/input.output/iostream.format/ext.manip/put_money.pass.cpp
@@ -35,18 +35,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = str_.size();
-                str_.push_back(__c);
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp b/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp
index d12b91cc0cba..dae74f0401f8 100644
--- a/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp
+++ b/test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp
@@ -35,18 +35,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp
index 29ed68e9770c..6b6737a765da 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.formatted/istream_extractors/streambuf.pass.cpp
@@ -41,18 +41,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = str_.size();
-                str_.push_back(__c);
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp
index e7327293bf82..0a48393e01d2 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp
@@ -38,18 +38,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp
index 292cf7c3b11d..c6368b44afb1 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp
@@ -39,18 +39,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp
index 465824a659f2..7ee2c295636b 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size.pass.cpp
@@ -7,6 +7,14 @@
 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: with_system_cxx_lib=macosx10.13
+// XFAIL: with_system_cxx_lib=macosx10.12
+// XFAIL: with_system_cxx_lib=macosx10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+// XFAIL: with_system_cxx_lib=macosx10.8
+// XFAIL: with_system_cxx_lib=macosx10.7
+
 // <istream>
 
 // basic_istream<charT,traits>& getline(char_type* s, streamsize n);
@@ -14,6 +22,8 @@
 #include <istream>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class CharT>
 struct testbuf
     : public std::basic_streambuf<CharT>
@@ -59,7 +69,33 @@ int main()
         assert(!is.fail());
         assert(std::string(s) == " ");
         assert(is.gcount() == 1);
+        // Check that even in error case the buffer is properly 0-terminated.
+        is.getline(s, 5);
+        assert( is.eof());
+        assert( is.fail());
+        assert(std::string(s) == "");
+        assert(is.gcount() == 0);
+    }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    {
+        testbuf<char> sb(" ");
+        std::istream is(&sb);
+        char s[5] = "test";
+        is.exceptions(std::istream::eofbit | std::istream::badbit);
+        try
+        {
+            is.getline(s, 5);
+            assert(false);
+        }
+        catch (std::ios_base::failure&)
+        {
+        }
+        assert( is.eof());
+        assert( is.fail());
+        assert(std::string(s) == " ");
+        assert(is.gcount() == 1);
     }
+#endif
     {
         testbuf<wchar_t> sb(L"  \n    \n ");
         std::wistream is(&sb);
@@ -79,5 +115,31 @@ int main()
         assert(!is.fail());
         assert(std::wstring(s) == L" ");
         assert(is.gcount() == 1);
+        // Check that even in error case the buffer is properly 0-terminated.
+        is.getline(s, 5);
+        assert( is.eof());
+        assert( is.fail());
+        assert(std::wstring(s) == L"");
+        assert(is.gcount() == 0);
+    }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    {
+        testbuf<wchar_t> sb(L" ");
+        std::wistream is(&sb);
+        wchar_t s[5] = L"test";
+        is.exceptions(std::wistream::eofbit | std::wistream::badbit);
+        try
+        {
+            is.getline(s, 5);
+            assert(false);
+        }
+        catch (std::ios_base::failure&)
+        {
+        }
+        assert( is.eof());
+        assert( is.fail());
+        assert(std::wstring(s) == L" ");
+        assert(is.gcount() == 1);
     }
+#endif
 }
diff --git a/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp b/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp
index 7362959966a6..1bce3fa5d4a5 100644
--- a/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp
+++ b/test/std/input.output/iostream.format/input.streams/istream.unformatted/getline_pointer_size_chart.pass.cpp
@@ -7,6 +7,14 @@
 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: with_system_cxx_lib=macosx10.13
+// XFAIL: with_system_cxx_lib=macosx10.12
+// XFAIL: with_system_cxx_lib=macosx10.11
+// XFAIL: with_system_cxx_lib=macosx10.10
+// XFAIL: with_system_cxx_lib=macosx10.9
+// XFAIL: with_system_cxx_lib=macosx10.8
+// XFAIL: with_system_cxx_lib=macosx10.7
+
 // <istream>
 
 // basic_istream<charT,traits>& getline(char_type* s, streamsize n, char_type delim);
@@ -14,6 +22,8 @@
 #include <istream>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class CharT>
 struct testbuf
     : public std::basic_streambuf<CharT>
@@ -59,7 +69,33 @@ int main()
         assert(!is.fail());
         assert(std::string(s) == " ");
         assert(is.gcount() == 1);
+        // Check that even in error case the buffer is properly 0-terminated.
+        is.getline(s, 5, '*');
+        assert( is.eof());
+        assert( is.fail());
+        assert(std::string(s) == "");
+        assert(is.gcount() == 0);
+    }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    {
+        testbuf<char> sb(" ");
+        std::istream is(&sb);
+        char s[5] = "test";
+        is.exceptions(std::istream::eofbit | std::istream::badbit);
+        try
+        {
+            is.getline(s, 5, '*');
+            assert(false);
+        }
+        catch (std::ios_base::failure&)
+        {
+        }
+        assert( is.eof());
+        assert( is.fail());
+        assert(std::string(s) == " ");
+        assert(is.gcount() == 1);
     }
+#endif
     {
         testbuf<wchar_t> sb(L"  *    * ");
         std::wistream is(&sb);
@@ -79,5 +115,31 @@ int main()
         assert(!is.fail());
         assert(std::wstring(s) == L" ");
         assert(is.gcount() == 1);
+        // Check that even in error case the buffer is properly 0-terminated.
+        is.getline(s, 5, L'*');
+        assert( is.eof());
+        assert( is.fail());
+        assert(std::wstring(s) == L"");
+        assert(is.gcount() == 0);
+    }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    {
+        testbuf<wchar_t> sb(L" ");
+        std::wistream is(&sb);
+        wchar_t s[5] = L"test";
+        is.exceptions(std::wistream::eofbit | std::wistream::badbit);
+        try
+        {
+            is.getline(s, 5, L'*');
+            assert(false);
+        }
+        catch (std::ios_base::failure&)
+        {
+        }
+        assert( is.eof());
+        assert( is.fail());
+        assert(std::wstring(s) == L" ");
+        assert(is.gcount() == 1);
     }
+#endif
 }
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp
index fe038a7cc1a9..00332f7739b9 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp
@@ -34,18 +34,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp
index 197e4602ff3a..1ee2c565a915 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp
@@ -34,18 +34,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp
index d31da5a18be6..db64b6603dc7 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp
@@ -34,18 +34,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp
index 1b33280e6693..5e601a90cb2a 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp
@@ -34,18 +34,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp
index 7cf46096d029..125c0800a140 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp
@@ -34,18 +34,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp
index dba3f8a68151..4b235f405eec 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp
@@ -34,18 +34,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp
index 1174a0934ed6..44b189d506f8 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp
@@ -34,18 +34,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp
index f6589397ed88..a8bdaba86ff1 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp
@@ -34,18 +34,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp
index 3b8182c1b621..06b6e5c627f8 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp
@@ -34,18 +34,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp
index 61057f7b3063..e6070ef917fe 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp
@@ -34,18 +34,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp
index 4558993e8e1f..7f8cf4608f8f 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp
@@ -34,18 +34,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp
index 1727b3657ce0..59be66fb6ae0 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp
@@ -34,18 +34,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp
index a42cd5628856..6508f2dab2b0 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp
@@ -34,18 +34,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp
index b778da2240a0..26bfd89dcbb7 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT.pass.cpp
@@ -35,18 +35,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(__c);
+                str_.push_back(ch);
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp
index 29153c1d4241..1f05684b50b7 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_pointer.pass.cpp
@@ -35,18 +35,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(__c);
+                str_.push_back(ch);
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp
index 91ee08cd0563..0fe2c352eeae 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp
@@ -35,18 +35,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp
index 1eb48d378e4c..f5e8ad40d36c 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp
@@ -35,18 +35,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp
index a50e376643c3..09784c034c8d 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.pass.cpp
@@ -35,18 +35,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(__c);
+                str_.push_back(ch);
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp
index 5c900e6ae533..2e40cf406599 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_pointer.pass.cpp
@@ -35,18 +35,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(__c);
+                str_.push_back(ch);
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp
index d57d0e7075b5..8ed0bfbdb436 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp
@@ -35,18 +35,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp
index e51e8815730f..e3ff0470a8f7 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp
@@ -35,18 +35,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp
index 9956f3b0162b..32c044d72728 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp
@@ -35,18 +35,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp
index d87e733c09dd..199c5dfd9383 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp
@@ -35,18 +35,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp
index ef7e292e901a..9d45af0fd1a8 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp
@@ -35,18 +35,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp
index 933e01c66e8d..21260d3649c4 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp
@@ -34,18 +34,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp
index 5c0604b73d4d..d4516d2f8975 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp
@@ -35,18 +35,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp
index a26450ae5bf2..e510825b64ac 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp
@@ -41,18 +41,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp
index 72df6085571f..9e8a5c8f0180 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp
@@ -37,18 +37,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 
     virtual int
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp
index dcded343431a..f372701509b1 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp
@@ -35,18 +35,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp
index 83210c08767a..f04d468ad3c9 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp
@@ -39,18 +39,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp
index 0958f8330236..87a94ed428bb 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp
@@ -34,18 +34,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp
index 0d6eb3f226f9..71f9ad66b6d6 100644
--- a/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp
+++ b/test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp
@@ -34,18 +34,18 @@ public:
 protected:
 
     virtual typename base::int_type
-        overflow(typename base::int_type __c = base::traits_type::eof())
+        overflow(typename base::int_type ch = base::traits_type::eof())
         {
-            if (__c != base::traits_type::eof())
+            if (ch != base::traits_type::eof())
             {
                 int n = static_cast<int>(str_.size());
-                str_.push_back(static_cast<CharT>(__c));
+                str_.push_back(static_cast<CharT>(ch));
                 str_.resize(str_.capacity());
                 base::setp(const_cast<CharT*>(str_.data()),
                            const_cast<CharT*>(str_.data() + str_.size()));
                 base::pbump(n+1);
             }
-            return __c;
+            return ch;
         }
 };
 
diff --git a/test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp b/test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp
index 6b550b5dabe4..5a8369c2c88e 100644
--- a/test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp
+++ b/test/std/input.output/iostream.format/quoted.manip/quoted_char.fail.cpp
@@ -18,7 +18,7 @@
 
 #include "test_macros.h"
 
-//	Test that mismatches between strings and wide streams are diagnosed
+//  Test that mismatches between strings and wide streams are diagnosed
 
 #if TEST_STD_VER > 11
 
diff --git a/test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp b/test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp
index 109674d1660d..9c0d3366c341 100644
--- a/test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp
+++ b/test/std/input.output/iostream.format/quoted.manip/quoted_traits.fail.cpp
@@ -20,7 +20,7 @@
 
 #if TEST_STD_VER > 11
 
-//	Test that mismatches in the traits between the quoted object and the dest string are diagnosed.
+//  Test that mismatches in the traits between the quoted object and the dest string are diagnosed.
 
 template <class charT>
 struct test_traits
diff --git a/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.pass.cpp b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.pass.cpp
new file mode 100644
index 000000000000..e7bdd897c745
--- /dev/null
+++ b/test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.put.area/pbump2gig.pass.cpp
@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <streambuf>
+
+// template <class charT, class traits = char_traits<charT> >
+// class basic_streambuf;
+
+// void pbump(int n);
+//
+// REQUIRES: long_tests
+
+#include <sstream>
+#include <cassert>
+#include "test_macros.h"
+
+struct SB : std::stringbuf
+{
+  SB() : std::stringbuf(std::ios::ate|std::ios::out) { }
+  const char* pubpbase() const { return pbase(); }
+  const char* pubpptr() const { return pptr(); }
+};
+
+int main()
+{
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    try {
+#endif
+    	std::string str(2147483648, 'a');
+		SB sb;
+		sb.str(str);
+		assert(sb.pubpbase() <= sb.pubpptr());
+#ifndef TEST_HAS_NO_EXCEPTIONS
+	}
+	catch (const std::bad_alloc &) {}
+#endif
+}
diff --git a/test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp b/test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp
index 28007c8edf45..af2cccc96373 100644
--- a/test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp
+++ b/test/std/input.output/string.streams/stringbuf/stringbuf.cons/default.pass.cpp
@@ -17,6 +17,21 @@
 #include <sstream>
 #include <cassert>
 
+template<typename CharT>
+struct testbuf
+    : std::basic_stringbuf<CharT>
+{
+    void check()
+    {
+        assert(this->eback() == NULL);
+        assert(this->gptr() == NULL);
+        assert(this->egptr() == NULL);
+        assert(this->pbase() == NULL);
+        assert(this->pptr() == NULL);
+        assert(this->epptr() == NULL);
+    }
+};
+
 int main()
 {
     {
@@ -27,4 +42,12 @@ int main()
         std::wstringbuf buf;
         assert(buf.str() == L"");
     }
+    {
+        testbuf<char> buf;
+        buf.check();
+    }
+    {
+        testbuf<wchar_t> buf;
+        buf.check();
+    }
 }
diff --git a/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp b/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp
index f808bcd14dea..b87f7eb92e5a 100644
--- a/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp
+++ b/test/std/input.output/string.streams/stringstream.cons/string.pass.cpp
@@ -57,12 +57,12 @@ int main()
         assert(ss.str() == L"456 1236 ");
     }
     { // This is https://bugs.llvm.org/show_bug.cgi?id=33727
-		typedef std::basic_string   <char, std::char_traits<char>, NoDefaultAllocator<char> > S;
-		typedef std::basic_stringbuf<char, std::char_traits<char>, NoDefaultAllocator<char> > SB;
+        typedef std::basic_string   <char, std::char_traits<char>, NoDefaultAllocator<char> > S;
+        typedef std::basic_stringbuf<char, std::char_traits<char>, NoDefaultAllocator<char> > SB;
 
-		S s(NoDefaultAllocator<char>(1));
-		SB sb(s);
-	//	This test is not required by the standard, but *where else* could it get the allocator?
-		assert(sb.str().get_allocator() == s.get_allocator());
+        S s(NoDefaultAllocator<char>(1));
+        SB sb(s);
+    //  This test is not required by the standard, but *where else* could it get the allocator?
+        assert(sb.str().get_allocator() == s.get_allocator());
     }
 }
diff --git a/test/std/iterators/iterator.container/data.pass.cpp b/test/std/iterators/iterator.container/data.pass.cpp
index a7a17480235a..09b7c0134962 100644
--- a/test/std/iterators/iterator.container/data.pass.cpp
+++ b/test/std/iterators/iterator.container/data.pass.cpp
@@ -7,51 +7,54 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
 // <iterator>
 // template <class C> constexpr auto data(C& c) -> decltype(c.data());               // C++17
 // template <class C> constexpr auto data(const C& c) -> decltype(c.data());         // C++17
 // template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept;           // C++17
 // template <class E> constexpr const E* data(initializer_list<E> il) noexcept;      // C++17
 
-#include "test_macros.h"
-
-#if TEST_STD_VER <= 14
-int main () {}
-#else
-
 #include <iterator>
 #include <cassert>
 #include <vector>
 #include <array>
 #include <initializer_list>
 
+#include "test_macros.h"
+
 template<typename C>
 void test_const_container( const C& c )
 {
+//  Can't say noexcept here because the container might not be
     assert ( std::data(c)   == c.data());
 }
 
 template<typename T>
 void test_const_container( const std::initializer_list<T>& c )
 {
+    ASSERT_NOEXCEPT(std::data(c));
     assert ( std::data(c)   == c.begin());
 }
 
 template<typename C>
 void test_container( C& c )
 {
+//  Can't say noexcept here because the container might not be
     assert ( std::data(c)   == c.data());
 }
 
 template<typename T>
 void test_container( std::initializer_list<T>& c)
 {
+    ASSERT_NOEXCEPT(std::data(c));
     assert ( std::data(c)   == c.begin());
 }
 
 template<typename T, size_t Sz>
 void test_const_array( const T (&array)[Sz] )
 {
+    ASSERT_NOEXCEPT(std::data(array));
     assert ( std::data(array) == &array[0]);
 }
 
@@ -72,5 +75,3 @@ int main()
     static constexpr int arrA [] { 1, 2, 3 };
     test_const_array ( arrA );
 }
-
-#endif
diff --git a/test/std/iterators/iterator.container/empty.array.fail.cpp b/test/std/iterators/iterator.container/empty.array.fail.cpp
new file mode 100644
index 000000000000..a5925dee79af
--- /dev/null
+++ b/test/std/iterators/iterator.container/empty.array.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <iterator>
+
+// <iterator>
+// template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <vector>
+#include <iterator>
+
+#include "test_macros.h"
+
+int main ()
+{
+    int c[5];
+    std::empty(c);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/iterators/iterator.container/empty.container.fail.cpp b/test/std/iterators/iterator.container/empty.container.fail.cpp
new file mode 100644
index 000000000000..1773b53e7b19
--- /dev/null
+++ b/test/std/iterators/iterator.container/empty.container.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <iterator>
+
+// <iterator>
+// template <class C> constexpr auto empty(const C& c) -> decltype(c.empty());
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <vector>
+#include <iterator>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::vector<int> c;
+    std::empty(c);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/iterators/iterator.container/empty.initializer_list.fail.cpp b/test/std/iterators/iterator.container/empty.initializer_list.fail.cpp
new file mode 100644
index 000000000000..f6657526800e
--- /dev/null
+++ b/test/std/iterators/iterator.container/empty.initializer_list.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <iterator>
+
+// <iterator>
+// template <class E> constexpr bool empty(initializer_list<E> il) noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <initializer_list>
+#include <iterator>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::initializer_list<int> c = { 4 };
+    std::empty(c);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/iterators/iterator.container/empty.pass.cpp b/test/std/iterators/iterator.container/empty.pass.cpp
index f9b8b94a89f9..cd000cc2fe76 100644
--- a/test/std/iterators/iterator.container/empty.pass.cpp
+++ b/test/std/iterators/iterator.container/empty.pass.cpp
@@ -7,17 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
 // <iterator>
 // template <class C> constexpr auto empty(const C& c) -> decltype(c.empty());       // C++17
 // template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept;  // C++17
 // template <class E> constexpr bool empty(initializer_list<E> il) noexcept;         // C++17
 
-#include "test_macros.h"
-
-#if TEST_STD_VER <= 14
-int main () {}
-#else
-
 #include <iterator>
 #include <cassert>
 #include <vector>
@@ -25,9 +21,12 @@ int main () {}
 #include <list>
 #include <initializer_list>
 
+#include "test_macros.h"
+
 template<typename C>
 void test_const_container( const C& c )
 {
+//  Can't say noexcept here because the container might not be
     assert ( std::empty(c)   == c.empty());
 }
 
@@ -40,18 +39,21 @@ void test_const_container( const std::initializer_list<T>& c )
 template<typename C>
 void test_container( C& c )
 {
+//  Can't say noexcept here because the container might not be
     assert ( std::empty(c)   == c.empty());
 }
 
 template<typename T>
 void test_container( std::initializer_list<T>& c )
 {
+    ASSERT_NOEXCEPT(std::empty(c));
     assert ( std::empty(c)   == (c.size() == 0));
 }
 
 template<typename T, size_t Sz>
 void test_const_array( const T (&array)[Sz] )
 {
+    ASSERT_NOEXCEPT(std::empty(array));
     assert (!std::empty(array));
 }
 
@@ -75,5 +77,3 @@ int main()
     static constexpr int arrA [] { 1, 2, 3 };
     test_const_array ( arrA );
 }
-
-#endif
diff --git a/test/std/iterators/iterator.container/size.pass.cpp b/test/std/iterators/iterator.container/size.pass.cpp
index 87b0ef897072..7d443e6e123c 100644
--- a/test/std/iterators/iterator.container/size.pass.cpp
+++ b/test/std/iterators/iterator.container/size.pass.cpp
@@ -7,16 +7,12 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
 // <iterator>
 // template <class C> constexpr auto size(const C& c) -> decltype(c.size());         // C++17
 // template <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept; // C++17
 
-#include "test_macros.h"
-
-#if TEST_STD_VER <= 14
-int main () {}
-#else
-
 #include <iterator>
 #include <cassert>
 #include <vector>
@@ -24,33 +20,42 @@ int main () {}
 #include <list>
 #include <initializer_list>
 
+#include "test_macros.h"
+
 template<typename C>
 void test_const_container( const C& c )
 {
+//  Can't say noexcept here because the container might not be
     assert ( std::size(c)   == c.size());
 }
 
 template<typename T>
 void test_const_container( const std::initializer_list<T>& c)
 {
+//  ASSERT_NOEXCEPT(std::size(c));
+//  For some reason, there isn't a std::size() for initializer lists
     assert ( std::size(c)   == c.size());
 }
 
 template<typename C>
 void test_container( C& c)
 {
+//  Can't say noexcept here because the container might not be
     assert ( std::size(c)   == c.size());
 }
 
 template<typename T>
 void test_container( std::initializer_list<T>& c )
 {
+//  ASSERT_NOEXCEPT(std::size(c));
+//  For some reason, there isn't a std::size() for initializer lists
     assert ( std::size(c)   == c.size());
 }
 
 template<typename T, size_t Sz>
 void test_const_array( const T (&array)[Sz] )
 {
+    ASSERT_NOEXCEPT(std::size(array));
     assert ( std::size(array) == Sz );
 }
 
@@ -74,5 +79,3 @@ int main()
     static constexpr int arrA [] { 1, 2, 3 };
     test_const_array ( arrA );
 }
-
-#endif
diff --git a/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp b/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
index e257b3eaaf31..1743349a5f72 100644
--- a/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp
@@ -24,6 +24,9 @@ void
 test(It i, typename std::iterator_traits<It>::difference_type n, It x)
 {
     assert(std::next(i, n) == x);
+
+    It (*next)(It, typename std::iterator_traits<It>::difference_type) = std::next;
+    assert(next(i, n) == x);
 }
 
 template <class It>
diff --git a/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp b/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
index 1eb91881fe11..554445c188d0 100644
--- a/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp
@@ -22,6 +22,9 @@ void
 test(It i, typename std::iterator_traits<It>::difference_type n, It x)
 {
     assert(std::prev(i, n) == x);
+
+    It (*prev)(It, typename std::iterator_traits<It>::difference_type) = std::prev;
+    assert(prev(i, n) == x);
 }
 
 template <class It>
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp b/test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp
new file mode 100644
index 000000000000..a08f35fe9614
--- /dev/null
+++ b/test/std/iterators/iterator.primitives/iterator.traits/const_volatile_pointer.pass.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <iterator>
+
+// template<class T>
+// struct iterator_traits<const T*>
+
+#include <iterator>
+#include <type_traits>
+
+struct A {};
+
+int main()
+{
+    typedef std::iterator_traits<const volatile A*> It;
+    static_assert((std::is_same<It::difference_type, std::ptrdiff_t>::value), "");
+    static_assert((std::is_same<It::value_type, A>::value), "");
+    static_assert((std::is_same<It::pointer, const volatile A*>::value), "");
+    static_assert((std::is_same<It::reference, const volatile A&>::value), "");
+    static_assert((std::is_same<It::iterator_category, std::random_access_iterator_tag>::value), "");
+}
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp b/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
index e48e44b3777f..179e5e762a90 100644
--- a/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
+++ b/test/std/iterators/iterator.primitives/iterator.traits/empty.pass.cpp
@@ -20,15 +20,15 @@ struct not_an_iterator
 {
 };
 
-template <class _Tp>
+template <class T>
 struct has_value_type
 {
 private:
     struct two {char lx; char lxx;};
-    template <class _Up> static two test(...);
-    template <class _Up> static char test(typename _Up::value_type* = 0);
+    template <class U> static two test(...);
+    template <class U> static char test(typename U::value_type* = 0);
 public:
-    static const bool value = sizeof(test<_Tp>(0)) == 1;
+    static const bool value = sizeof(test<T>(0)) == 1;
 };
 
 int main()
diff --git a/test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp b/test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp
new file mode 100644
index 000000000000..1630feb25eed
--- /dev/null
+++ b/test/std/iterators/iterator.primitives/iterator.traits/volatile_pointer.pass.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <iterator>
+
+// template<class T>
+// struct iterator_traits<const T*>
+
+#include <iterator>
+#include <type_traits>
+
+struct A {};
+
+int main()
+{
+    typedef std::iterator_traits<volatile A*> It;
+    static_assert((std::is_same<It::difference_type, std::ptrdiff_t>::value), "");
+    static_assert((std::is_same<It::value_type, A>::value), "");
+    static_assert((std::is_same<It::pointer, volatile A*>::value), "");
+    static_assert((std::is_same<It::reference, volatile A&>::value), "");
+    static_assert((std::is_same<It::iterator_category, std::random_access_iterator_tag>::value), "");
+}
diff --git a/test/std/iterators/iterator.range/begin-end.fail.cpp b/test/std/iterators/iterator.range/begin-end.fail.cpp
index 94a3d8c2004d..18c5943a46ba 100644
--- a/test/std/iterators/iterator.range/begin-end.fail.cpp
+++ b/test/std/iterators/iterator.range/begin-end.fail.cpp
@@ -26,26 +26,26 @@
 #include <cassert>
 
 namespace Foo {
-	struct FakeContainer {};
-	typedef int FakeIter;
-
-	FakeIter begin(const FakeContainer &)   { return 1; }
-	FakeIter end  (const FakeContainer &)   { return 2; }
-	FakeIter rbegin(const FakeContainer &)  { return 3; }
-	FakeIter rend  (const FakeContainer &)  { return 4; }
-
-	FakeIter cbegin(const FakeContainer &)  { return 11; }
-	FakeIter cend  (const FakeContainer &)  { return 12; }
-	FakeIter crbegin(const FakeContainer &) { return 13; }
-	FakeIter crend  (const FakeContainer &) { return 14; }
+    struct FakeContainer {};
+    typedef int FakeIter;
+
+    FakeIter begin(const FakeContainer &)   { return 1; }
+    FakeIter end  (const FakeContainer &)   { return 2; }
+    FakeIter rbegin(const FakeContainer &)  { return 3; }
+    FakeIter rend  (const FakeContainer &)  { return 4; }
+
+    FakeIter cbegin(const FakeContainer &)  { return 11; }
+    FakeIter cend  (const FakeContainer &)  { return 12; }
+    FakeIter crbegin(const FakeContainer &) { return 13; }
+    FakeIter crend  (const FakeContainer &) { return 14; }
 }
 
 
 int main(){
 // Bug #28927 - shouldn't find these via ADL
-	(void) std::cbegin (Foo::FakeContainer());
-	(void) std::cend   (Foo::FakeContainer());
-	(void) std::crbegin(Foo::FakeContainer());
-	(void) std::crend  (Foo::FakeContainer());
+    TEST_IGNORE_NODISCARD  std::cbegin (Foo::FakeContainer());
+    TEST_IGNORE_NODISCARD  std::cend   (Foo::FakeContainer());
+    TEST_IGNORE_NODISCARD  std::crbegin(Foo::FakeContainer());
+    TEST_IGNORE_NODISCARD  std::crend  (Foo::FakeContainer());
 }
 #endif
diff --git a/test/std/iterators/iterator.range/begin-end.pass.cpp b/test/std/iterators/iterator.range/begin-end.pass.cpp
index 2b5377f486f4..201dd066b86b 100644
--- a/test/std/iterators/iterator.range/begin-end.pass.cpp
+++ b/test/std/iterators/iterator.range/begin-end.pass.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: c++03, c++98
+// XFAIL: c++98, c++03
 
 // <iterator>
 // template <class C> constexpr auto begin(C& c) -> decltype(c.begin());
diff --git a/test/std/iterators/iterators.general/gcc_workaround.pass.cpp b/test/std/iterators/iterators.general/gcc_workaround.pass.cpp
index 6522bd3c7bcb..7578e718231d 100644
--- a/test/std/iterators/iterators.general/gcc_workaround.pass.cpp
+++ b/test/std/iterators/iterators.general/gcc_workaround.pass.cpp
@@ -10,11 +10,12 @@
 // Tests workaround for  https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64816.
 
 #include <string>
+#include "test_macros.h"
 
-void f(const std::string &s) { s.begin(); }
+void f(const std::string &s) { TEST_IGNORE_NODISCARD s.begin(); }
 
 #include <vector>
 
-void AppendTo(const std::vector<char> &v) { v.begin(); }
+void AppendTo(const std::vector<char> &v) { TEST_IGNORE_NODISCARD v.begin(); }
 
 int main() {}
diff --git a/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp b/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp
index 5b61a3895132..e379b30575fc 100644
--- a/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp
+++ b/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/types.pass.cpp
@@ -29,6 +29,7 @@
 #include <iterator>
 #include <type_traits>
 #include <vector>
+#include "test_macros.h"
 
 template <class C>
 struct find_members
@@ -38,7 +39,7 @@ struct find_members
     void test()
     {
         this->container = 0;
-        (void)(this->iter == this->iter);
+        TEST_IGNORE_NODISCARD (this->iter == this->iter);
     }
 };
 
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp
index d2ad79af66fd..99ff9641acdc 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp
@@ -43,8 +43,8 @@ int main()
     }
     {
     int a[] = {1,2,3,4};
-    std::make_move_iterator(a+4);
-    std::make_move_iterator(a); // test for LWG issue 2061
+    TEST_IGNORE_NODISCARD std::make_move_iterator(a+4);
+    TEST_IGNORE_NODISCARD std::make_move_iterator(a); // test for LWG issue 2061
     }
 
 #if TEST_STD_VER > 14
diff --git a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
index ba1406ada288..404e02cd7b1d 100644
--- a/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
+++ b/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp
@@ -25,6 +25,7 @@ void
 test()
 {
     std::move_iterator<It> r;
+    (void)r;
 }
 
 int main()
@@ -38,6 +39,7 @@ int main()
 #if TEST_STD_VER > 14
     {
     constexpr std::move_iterator<const char *> it;
+    (void)it;
     }
 #endif
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
index 855dbd7ba316..88fd0def5a89 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp
@@ -13,7 +13,7 @@
 
 // constexpr reverse_iterator();
 //
-// constexpr in c++17
+// constexpr in C++17
 
 #include <iterator>
 
@@ -25,6 +25,7 @@ void
 test()
 {
     std::reverse_iterator<It> r;
+    (void)r;
 }
 
 int main()
@@ -37,6 +38,7 @@ int main()
 #if TEST_STD_VER > 14
     {
         constexpr std::reverse_iterator<const char *> it;
+        (void)it;
     }
 #endif
 }
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
index 9bded7c5a429..4bf816d28f80 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp
@@ -13,7 +13,7 @@
 
 // explicit constexpr reverse_iterator(Iter x);
 //
-// constexpr in c++17
+// constexpr in C++17
 
 #include <iterator>
 #include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
index 2c15743db506..798f9a805a1f 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp
@@ -15,7 +15,7 @@
 //   requires HasConstructor<Iter, const U&>
 //   constexpr reverse_iterator(const reverse_iterator<U> &u);
 //
-// constexpr in c++17
+// constexpr in C++17
 
 #include <iterator>
 #include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
index cd155988b11b..4cf82179c7d3 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp
@@ -16,7 +16,7 @@
 //   constexpr reverse_iterator<Iterator>
 //     make_reverse_iterator(Iterator i);
 //
-//   constexpr in c++17
+//   constexpr in C++17
 
 #include <iterator>
 #include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp
index f5162a7c5dc3..9c53bbbfedc3 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp
@@ -16,7 +16,7 @@
 //   constexpr bool
 //   operator!=(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
 //
-//   constexpr in c++17
+//   constexpr in C++17
 
 #include <iterator>
 #include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
index 6a2ab2797cab..7d9edd5b00a5 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp
@@ -13,7 +13,7 @@
 
 // constexpr reverse_iterator operator++(int);
 //
-//   constexpr in c++17
+//   constexpr in C++17
 
 #include <iterator>
 #include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
index 510242244444..7e75344ab049 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp
@@ -13,7 +13,7 @@
 
 // constexpr reverse_iterator& operator++();
 //
-// constexpr in c++17
+// constexpr in C++17
 
 #include <iterator>
 #include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
index 0c9682f45c1c..c485b0483743 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp
@@ -14,7 +14,7 @@
 // requires RandomAccessIterator<Iter>
 //   constexpr reverse_iterator operator+(difference_type n) const;
 //
-// constexpr in c++17
+// constexpr in C++17
 
 #include <iterator>
 #include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
index 9148cc117ca0..5c34417c332d 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp
@@ -14,7 +14,7 @@
 // requires RandomAccessIterator<Iter>
 //   constexpr reverse_iterator operator-(difference_type n) const;
 //
-// constexpr in c++17
+// constexpr in C++17
 
 #include <iterator>
 #include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp
index 4e727564ab72..62ca76495f91 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op.star/op_star.pass.cpp
@@ -13,7 +13,7 @@
 
 // constexpr reference operator*() const;
 //
-// constexpr in c++17
+// constexpr in C++17
 
 // Be sure to respect LWG 198:
 //    http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#198
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
index 78f6fc4cb26a..59f721838784 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp
@@ -16,7 +16,7 @@
 //   constexpr reverse_iterator&
 //   operator=(const reverse_iterator<U>& u);
 //
-//   constexpr in c++17
+//   constexpr in C++17
 
 #include <iterator>
 #include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
index 70c9e198519c..1d4d09158556 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp
@@ -16,7 +16,7 @@
 //   constexpr bool
 //   operator==(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
 //
-//   constexpr in c++17
+//   constexpr in C++17
 
 #include <iterator>
 #include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
index 73e49027b0f5..9ef8c30b4002 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp
@@ -16,7 +16,7 @@
 //   constexpr auto operator-(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y)
 //   -> decltype(y.base() - x.base());
 //
-// constexpr in c++17
+// constexpr in C++17
 
 #include <iterator>
 #include <cstddef>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
index b6adcf40ede4..e0e0059ac917 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp
@@ -16,7 +16,7 @@
 //   constexpr bool
 //   operator>(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
 //
-//   constexpr in c++17
+//   constexpr in C++17
 
 #include <iterator>
 #include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
index dc917b29f907..f0ff828b5ddf 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp
@@ -16,7 +16,7 @@
 //   constexpr bool
 //   operator>=(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
 //
-//   constexpr in c++17
+//   constexpr in C++17
 
 #include <iterator>
 #include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
index 668f7d839754..4ff57518d6e9 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp
@@ -16,7 +16,7 @@
 //   constexpr bool
 //   operator<(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
 //
-//   constexpr in c++17
+//   constexpr in C++17
 
 #include <iterator>
 #include <cassert>
diff --git a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
index 5201bc43db2c..9fb6310b9739 100644
--- a/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
+++ b/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp
@@ -16,7 +16,7 @@
 //   constexpr bool
 //   operator<=(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
 //
-//   constexpr in c++17
+//   constexpr in C++17
 
 #include <iterator>
 #include <cassert>
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
index 22f2967f3281..937bb8d3a05d 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.cons/default.pass.cpp
@@ -9,7 +9,7 @@
 
 // Usage of is_trivially_constructible is broken with these compilers.
 // See https://bugs.llvm.org/show_bug.cgi?id=31016
-// XFAIL: clang-3.7, apple-clang-7 && c++1z
+// XFAIL: clang-3.7, apple-clang-7 && c++17
 
 // <iterator>
 
@@ -32,6 +32,7 @@ template <typename T, bool isTrivial = std::is_trivially_default_constructible_v
 struct test_trivial {
 void operator ()() const {
     constexpr std::istream_iterator<T> it;
+    (void)it;
     }
 };
 
@@ -50,6 +51,7 @@ int main()
     assert(it == T());
 #if TEST_STD_VER >= 11
     constexpr T it2;
+    (void)it2;
 #endif
     }
 
diff --git a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp
index 0bee916d50c9..d1824bae6f87 100644
--- a/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp
+++ b/test/std/iterators/stream.iterators/istream.iterator/istream.iterator.ops/equal.pass.cpp
@@ -49,4 +49,7 @@ int main()
 
     assert(i4 == i4);
     assert(i4 == i5);
+
+    assert(std::operator==(i1, i2));
+    assert(std::operator!=(i1, i3));
 }
diff --git a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
index 74aa6f2ab517..c71ee409969a 100644
--- a/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
+++ b/test/std/iterators/stream.iterators/istreambuf.iterator/istreambuf.iterator.cons/default.pass.cpp
@@ -30,6 +30,7 @@ int main()
         assert(it == T());
 #if TEST_STD_VER >= 11
         constexpr T it2;
+        (void)it2;
 #endif
     }
     {
@@ -38,6 +39,7 @@ int main()
         assert(it == T());
 #if TEST_STD_VER >= 11
         constexpr T it2;
+        (void)it2;
 #endif
     }
 }
diff --git a/test/std/language.support/support.dynamic/align_val_t.pass.cpp b/test/std/language.support/support.dynamic/align_val_t.pass.cpp
index 0a19de919f7f..ffb54ab4d2bf 100644
--- a/test/std/language.support/support.dynamic/align_val_t.pass.cpp
+++ b/test/std/language.support/support.dynamic/align_val_t.pass.cpp
@@ -31,4 +31,4 @@ int main() {
     static_assert(b == std::align_val_t(32), "");
     static_assert(static_cast<std::size_t>(c) == (std::size_t)-1, "");
   }
-}
\ No newline at end of file
+}
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
index 36f815a819be..828feabd2127 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/delete_align_val_t_replace.pass.cpp
@@ -36,7 +36,7 @@
 
 #include "test_macros.h"
 
-constexpr auto OverAligned = alignof(std::max_align_t) * 2;
+constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
 
 int unsized_delete_called = 0;
 int unsized_delete_nothrow_called = 0;
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
index 69f5ac8c9774..942f5e778b66 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t.pass.cpp
@@ -38,7 +38,7 @@
 
 #include "test_macros.h"
 
-constexpr auto OverAligned = alignof(std::max_align_t) * 2;
+constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
 
 int new_handler_called = 0;
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
index 36453283caf6..f55ad5bcc84e 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow.pass.cpp
@@ -37,7 +37,7 @@
 
 #include "test_macros.h"
 
-constexpr auto OverAligned = alignof(std::max_align_t) * 2;
+constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
 
 int new_handler_called = 0;
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
index 228d176a27e0..e1ebf86ee176 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_nothrow_replace.pass.cpp
@@ -34,7 +34,7 @@
 
 #include "test_macros.h"
 
-constexpr auto OverAligned = alignof(std::max_align_t) * 2;
+constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
 
 int A_constructed = 0;
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.pass.cpp
index 15bebcbcbcb8..82dc77efe89e 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_align_val_t_replace.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-constexpr auto OverAligned = alignof(std::max_align_t) * 2;
+constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
 
 int A_constructed = 0;
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp
index 53e26c99f92e..ba3f930c5f14 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_nothrow_replace.pass.cpp
@@ -10,6 +10,7 @@
 // test operator new [] nothrow by replacing only operator new
 
 // UNSUPPORTED: sanitizer-new-delete
+// XFAIL: libcpp-no-vcruntime
 
 #include <new>
 #include <cstddef>
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp
index b0820b14f410..3f8122745cc4 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_array_replace.pass.cpp
@@ -10,6 +10,7 @@
 // test operator new[] replacement by replacing only operator new
 
 // UNSUPPORTED: sanitizer-new-delete
+// XFAIL: libcpp-no-vcruntime
 
 
 #include <new>
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.fail.cpp
new file mode 100644
index 000000000000..0dfef2e56fca
--- /dev/null
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.fail.cpp
@@ -0,0 +1,25 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <new>
+
+// void* operator new[](std::size_t);
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <new>
+
+#include "test_macros.h"
+
+int main ()
+{
+    ::operator new[](4);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.fail.cpp
new file mode 100644
index 000000000000..ea041aea16ee
--- /dev/null
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.fail.cpp
@@ -0,0 +1,25 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <new>
+
+// void* operator new[](std::size_t, std::align_val_t);
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <new>
+
+#include "test_macros.h"
+
+int main ()
+{
+    ::operator new[](4, std::align_val_t{4});  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.fail.cpp
new file mode 100644
index 000000000000..99e4f76b312f
--- /dev/null
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.fail.cpp
@@ -0,0 +1,25 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <new>
+
+// void* operator new[](std::size_t, std::align_val_t, std::nothrow_t &);
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <new>
+
+#include "test_macros.h"
+
+int main ()
+{
+    ::operator new[](4, std::align_val_t{4}, std::nothrow);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.fail.cpp
new file mode 100644
index 000000000000..8aae54e83fbe
--- /dev/null
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.fail.cpp
@@ -0,0 +1,25 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <new>
+
+// void* operator new[](std::size_t, std::nothrow_t &);
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <new>
+
+#include "test_macros.h"
+
+int main ()
+{
+    ::operator new[](4, std::nothrow);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array11.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array11.pass.cpp
index 3e41b24d292f..862318d0be7b 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array11.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array11.pass.cpp
@@ -12,7 +12,7 @@
 // Note that sized delete operator definitions below are simply ignored
 // when sized deallocation is not supported, e.g., prior to C++14.
 
-// UNSUPPORTED: c++14, c++1z
+// UNSUPPORTED: c++14, c++17
 // UNSUPPORTED: sanitizer-new-delete
 
 #include <new>
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp
index fb715805083f..d0b7405453cd 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.array/sized_delete_array14.pass.cpp
@@ -11,12 +11,12 @@
 
 // UNSUPPORTED: sanitizer-new-delete, c++98, c++03, c++11
 
-// NOTE: Clang does not enable sized-deallocation in c++14 and beyond by
+// NOTE: Clang does not enable sized-deallocation in C++14 and beyond by
 // default. It is only enabled when -fsized-deallocation is given.
 // (except clang-3.6 which temporarily enabled sized-deallocation)
 // UNSUPPORTED: clang, apple-clang
 
-// NOTE: GCC 4.9.1 does not support sized-deallocation in c++14. However
+// NOTE: GCC 4.9.1 does not support sized-deallocation in C++14. However
 // GCC 5.1 does.
 // XFAIL: gcc-4.7, gcc-4.8, gcc-4.9
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array_ptr.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array_ptr.fail.cpp
new file mode 100644
index 000000000000..83d5e80e87e4
--- /dev/null
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_array_ptr.fail.cpp
@@ -0,0 +1,26 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <new>
+
+// void* operator new[](std::size_t, void *);
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <new>
+
+#include "test_macros.h"
+
+int main ()
+{
+	char buffer[100];
+    ::operator new[](4, buffer);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_ptr.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_ptr.fail.cpp
new file mode 100644
index 000000000000..9d3892cb0a81
--- /dev/null
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.placement/new_ptr.fail.cpp
@@ -0,0 +1,26 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <new>
+
+// void* operator new(std::size_t, void *);
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <new>
+
+#include "test_macros.h"
+
+int main ()
+{
+	char buffer[100];
+    ::operator new(4, buffer);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
index b0e932c96cb0..d64a633007e7 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/delete_align_val_t_replace.pass.cpp
@@ -35,7 +35,7 @@
 
 #include "test_macros.h"
 
-constexpr auto OverAligned = alignof(std::max_align_t) * 2;
+constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
 
 int unsized_delete_called = 0;
 int unsized_delete_nothrow_called = 0;
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
index 22ea5e2fff89..fae5d3676df6 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t.pass.cpp
@@ -37,7 +37,7 @@
 
 #include "test_macros.h"
 
-constexpr auto OverAligned = alignof(std::max_align_t) * 2;
+constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
 
 int new_handler_called = 0;
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
index 2c5c0f80b839..f22c48994355 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow.pass.cpp
@@ -37,7 +37,7 @@
 
 #include "test_macros.h"
 
-constexpr auto OverAligned = alignof(std::max_align_t) * 2;
+constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
 
 int new_handler_called = 0;
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
index b50f49dc6ca7..565ba9b851bb 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_nothrow_replace.pass.cpp
@@ -35,7 +35,7 @@
 
 #include "test_macros.h"
 
-constexpr auto OverAligned = alignof(std::max_align_t) * 2;
+constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
 
 bool A_constructed = false;
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.pass.cpp
index 66bb613adfd0..bace5c036e0c 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_align_val_t_replace.pass.cpp
@@ -24,7 +24,7 @@
 
 #include "test_macros.h"
 
-constexpr auto OverAligned = alignof(std::max_align_t) * 2;
+constexpr auto OverAligned = __STDCPP_DEFAULT_NEW_ALIGNMENT__ * 2;
 
 bool A_constructed = false;
 
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp
index dbc64bace332..31e1901511fa 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_nothrow_replace.pass.cpp
@@ -10,6 +10,7 @@
 // test operator new nothrow by replacing only operator new
 
 // UNSUPPORTED: sanitizer-new-delete
+// XFAIL: libcpp-no-vcruntime
 
 #include <new>
 #include <cstddef>
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.fail.cpp
new file mode 100644
index 000000000000..865cb1ee8375
--- /dev/null
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size.fail.cpp
@@ -0,0 +1,25 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <new>
+
+// void* operator new(std::size_t);
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <new>
+
+#include "test_macros.h"
+
+int main ()
+{
+    ::operator new(4);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.fail.cpp
new file mode 100644
index 000000000000..c3cabbdb79d5
--- /dev/null
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.fail.cpp
@@ -0,0 +1,25 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <new>
+
+// void* operator new(std::size_t, std::align_val_t);
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <new>
+
+#include "test_macros.h"
+
+int main ()
+{
+    ::operator new(4, std::align_val_t{4});  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.fail.cpp
new file mode 100644
index 000000000000..e987a53478b0
--- /dev/null
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.fail.cpp
@@ -0,0 +1,25 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <new>
+
+// void* operator new(std::size_t, std::align_val_t, std::nothrow_t &);
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <new>
+
+#include "test_macros.h"
+
+int main ()
+{
+    ::operator new(4, std::align_val_t{4}, std::nothrow);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.fail.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.fail.cpp
new file mode 100644
index 000000000000..39392691e9bc
--- /dev/null
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_nothrow.fail.cpp
@@ -0,0 +1,25 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <new>
+
+// void* operator new(std::size_t, std::nothrow_t &);
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <new>
+
+#include "test_macros.h"
+
+int main ()
+{
+    ::operator new(4, std::nothrow);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp
index 57fb1eb88b6e..945bf779a893 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp
@@ -12,7 +12,7 @@
 // Note that sized delete operator definitions below are simply ignored
 // when sized deallocation is not supported, e.g., prior to C++14.
 
-// UNSUPPORTED: c++14, c++1z
+// UNSUPPORTED: c++14, c++17
 // UNSUPPORTED: sanitizer-new-delete
 
 #include <new>
diff --git a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp
index b85b670fa2d4..7a76725a9751 100644
--- a/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp
+++ b/test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete14.pass.cpp
@@ -11,12 +11,12 @@
 
 // UNSUPPORTED: sanitizer-new-delete, c++98, c++03, c++11
 
-// NOTE: Clang does not enable sized-deallocation in c++14 and beyond by
+// NOTE: Clang does not enable sized-deallocation in C++14 and beyond by
 // default. It is only enabled when -fsized-deallocation is given.
 // (except clang-3.6 which temporarily enabled sized-deallocation)
 // UNSUPPORTED: clang, apple-clang
 
-// NOTE: GCC 4.9.1 does not support sized-deallocation in c++14. However
+// NOTE: GCC 4.9.1 does not support sized-deallocation in C++14. However
 // GCC 5.1 does.
 // XFAIL: gcc-4.7, gcc-4.8, gcc-4.9
 
diff --git a/test/std/language.support/support.dynamic/ptr.launder/launder.nodiscard.fail.cpp b/test/std/language.support/support.dynamic/ptr.launder/launder.nodiscard.fail.cpp
new file mode 100644
index 000000000000..1c75e561d7c7
--- /dev/null
+++ b/test/std/language.support/support.dynamic/ptr.launder/launder.nodiscard.fail.cpp
@@ -0,0 +1,27 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <new>
+
+// template <class T> constexpr T* launder(T* p) noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <new>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main ()
+{
+    int *p = nullptr;
+    std::launder(p);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/language.support/support.dynamic/ptr.launder/launder.pass.cpp b/test/std/language.support/support.dynamic/ptr.launder/launder.pass.cpp
new file mode 100644
index 000000000000..1aa462957c8b
--- /dev/null
+++ b/test/std/language.support/support.dynamic/ptr.launder/launder.pass.cpp
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <new>
+
+// template <class T> constexpr T* launder(T* p) noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <new>
+#include <cassert>
+
+#include "test_macros.h"
+
+constexpr int gi = 5;
+constexpr float gf = 8.f;
+
+int main() {
+	static_assert(std::launder(&gi) == &gi, "" );
+	static_assert(std::launder(&gf) == &gf, "" );
+
+  	const int *i = &gi;
+  	const float *f = &gf;
+    static_assert(std::is_same<decltype(i), decltype(std::launder(i))>::value, "");
+    static_assert(std::is_same<decltype(f), decltype(std::launder(f))>::value, "");
+
+	assert(std::launder(i) == i);
+	assert(std::launder(f) == f);
+}
diff --git a/test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp b/test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp
new file mode 100644
index 000000000000..71f5e4588b82
--- /dev/null
+++ b/test/std/language.support/support.dynamic/ptr.launder/launder.types.fail.cpp
@@ -0,0 +1,34 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <new>
+
+// template <class T> constexpr T* launder(T* p) noexcept;
+// The program is ill-formed if T is a function type or cv void.
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+#include <new>
+#include <cassert>
+
+#include "test_macros.h"
+
+void foo() {}
+
+int main ()
+{
+    void *p = nullptr;
+    (void) std::launder((               void *) nullptr);
+    (void) std::launder((const          void *) nullptr);
+    (void) std::launder((      volatile void *) nullptr);
+    (void) std::launder((const volatile void *) nullptr);  // expected-error-re@new:* 4 {{static_assert failed{{.*}} "can't launder cv-void"}}
+
+    (void) std::launder(foo);                              // expected-error-re@new:* 1 {{static_assert failed{{.*}} "can't launder functions"}}
+}
diff --git a/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp b/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp
index 88e2253d08c7..43a11bab3fde 100644
--- a/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp
+++ b/test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp
@@ -46,8 +46,8 @@ public:
 class C
 {
 public:
-	virtual ~C() {}
-	C * operator&() const { assert(false); return nullptr; } // should not be called
+    virtual ~C() {}
+    C * operator&() const { assert(false); return nullptr; } // should not be called
 };
 
 class D : private std::nested_exception {};
diff --git a/test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp b/test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp
index f6fd5564f55f..cadae24cb77f 100644
--- a/test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp
+++ b/test/std/language.support/support.initlist/support.initlist.access/access.pass.cpp
@@ -57,5 +57,6 @@ int main()
     A test1 = {3, 2, 1};
 #if TEST_STD_VER > 11
     constexpr B test2 = {3, 2, 1};
+    (void)test2;
 #endif  // TEST_STD_VER > 11
 }
diff --git a/test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp b/test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp
index 102ed64fef9b..abb07dc99772 100644
--- a/test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp
+++ b/test/std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp
@@ -55,5 +55,6 @@ int main()
     A test1 = {3, 2, 1};
 #if TEST_STD_VER > 11
     constexpr B test2 = {3, 2, 1};
+    (void)test2;
 #endif  // TEST_STD_VER > 11
 }
diff --git a/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp b/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp
index 50cfc4674251..6a46c370e750 100644
--- a/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp
+++ b/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp
@@ -37,8 +37,8 @@
         round_style
 */
 
-template <class _Tp>
-void test(const _Tp &) {}
+template <class T>
+void test(const T &) {}
 
 #define TEST_NUMERIC_LIMITS(type) \
   test(std::numeric_limits<type>::is_specialized); \
diff --git a/test/std/language.support/support.types/byteops/and.assign.pass.cpp b/test/std/language.support/support.types/byteops/and.assign.pass.cpp
index ec1c3805a6cb..4aea7909dfaa 100644
--- a/test/std/language.support/support.types/byteops/and.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/and.assign.pass.cpp
@@ -16,24 +16,24 @@
 
 
 constexpr std::byte test(std::byte b1, std::byte b2) {
-	std::byte bret = b1;
-	return bret &= b2;
-	}
+    std::byte bret = b1;
+    return bret &= b2;
+    }
 
 
 int main () {
-	std::byte b;  // not constexpr, just used in noexcept check
-	constexpr std::byte b1{static_cast<std::byte>(1)};
-	constexpr std::byte b8{static_cast<std::byte>(8)};
-	constexpr std::byte b9{static_cast<std::byte>(9)};
+    std::byte b;  // not constexpr, just used in noexcept check
+    constexpr std::byte b1{static_cast<std::byte>(1)};
+    constexpr std::byte b8{static_cast<std::byte>(8)};
+    constexpr std::byte b9{static_cast<std::byte>(9)};
 
-	static_assert(noexcept(b &= b), "" );
+    static_assert(noexcept(b &= b), "" );
 
-	static_assert(std::to_integer<int>(test(b1, b8)) == 0, "");
-	static_assert(std::to_integer<int>(test(b1, b9)) == 1, "");
-	static_assert(std::to_integer<int>(test(b8, b9)) == 8, "");
+    static_assert(std::to_integer<int>(test(b1, b8)) == 0, "");
+    static_assert(std::to_integer<int>(test(b1, b9)) == 1, "");
+    static_assert(std::to_integer<int>(test(b8, b9)) == 8, "");
 
-	static_assert(std::to_integer<int>(test(b8, b1)) == 0, "");
-	static_assert(std::to_integer<int>(test(b9, b1)) == 1, "");
-	static_assert(std::to_integer<int>(test(b9, b8)) == 8, "");
+    static_assert(std::to_integer<int>(test(b8, b1)) == 0, "");
+    static_assert(std::to_integer<int>(test(b9, b1)) == 1, "");
+    static_assert(std::to_integer<int>(test(b9, b8)) == 8, "");
 }
diff --git a/test/std/language.support/support.types/byteops/and.pass.cpp b/test/std/language.support/support.types/byteops/and.pass.cpp
index 6c5419cfc2a2..32c0bdaee842 100644
--- a/test/std/language.support/support.types/byteops/and.pass.cpp
+++ b/test/std/language.support/support.types/byteops/and.pass.cpp
@@ -15,17 +15,17 @@
 // constexpr byte operator&(byte l, byte r) noexcept;
 
 int main () {
-	constexpr std::byte b1{static_cast<std::byte>(1)};
-	constexpr std::byte b8{static_cast<std::byte>(8)};
-	constexpr std::byte b9{static_cast<std::byte>(9)};
+    constexpr std::byte b1{static_cast<std::byte>(1)};
+    constexpr std::byte b8{static_cast<std::byte>(8)};
+    constexpr std::byte b9{static_cast<std::byte>(9)};
 
-	static_assert(noexcept(b1 & b8), "" );
+    static_assert(noexcept(b1 & b8), "" );
 
-	static_assert(std::to_integer<int>(b1 & b8) ==  0, "");
-	static_assert(std::to_integer<int>(b1 & b9) ==  1, "");
-	static_assert(std::to_integer<int>(b8 & b9) ==  8, "");
+    static_assert(std::to_integer<int>(b1 & b8) ==  0, "");
+    static_assert(std::to_integer<int>(b1 & b9) ==  1, "");
+    static_assert(std::to_integer<int>(b8 & b9) ==  8, "");
 
-	static_assert(std::to_integer<int>(b8 & b1) ==  0, "");
-	static_assert(std::to_integer<int>(b9 & b1) ==  1, "");
-	static_assert(std::to_integer<int>(b9 & b8) ==  8, "");
+    static_assert(std::to_integer<int>(b8 & b1) ==  0, "");
+    static_assert(std::to_integer<int>(b9 & b1) ==  1, "");
+    static_assert(std::to_integer<int>(b9 & b8) ==  8, "");
 }
diff --git a/test/std/language.support/support.types/byteops/lshift.assign.fail.cpp b/test/std/language.support/support.types/byteops/lshift.assign.fail.cpp
index 8f6822932ac2..66946b4647bd 100644
--- a/test/std/language.support/support.types/byteops/lshift.assign.fail.cpp
+++ b/test/std/language.support/support.types/byteops/lshift.assign.fail.cpp
@@ -22,10 +22,10 @@
 
 
 constexpr std::byte test(std::byte b) {
-	return b <<= 2.0;
-	}
+    return b <<= 2.0;
+    }
 
 
 int main () {
-	constexpr std::byte b1 = test(std::byte{1});
+    constexpr std::byte b1 = test(std::byte{1});
 }
diff --git a/test/std/language.support/support.types/byteops/lshift.assign.pass.cpp b/test/std/language.support/support.types/byteops/lshift.assign.pass.cpp
index abfeebf2b024..6883dccfb993 100644
--- a/test/std/language.support/support.types/byteops/lshift.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/lshift.assign.pass.cpp
@@ -19,18 +19,18 @@
 
 
 constexpr std::byte test(std::byte b) {
-	return b <<= 2;
-	}
+    return b <<= 2;
+    }
 
 
 int main () {
-	std::byte b;  // not constexpr, just used in noexcept check
-	constexpr std::byte b2{static_cast<std::byte>(2)};
-	constexpr std::byte b3{static_cast<std::byte>(3)};
+    std::byte b;  // not constexpr, just used in noexcept check
+    constexpr std::byte b2{static_cast<std::byte>(2)};
+    constexpr std::byte b3{static_cast<std::byte>(3)};
 
-	static_assert(noexcept(b <<= 2), "" );
+    static_assert(noexcept(b <<= 2), "" );
 
-	static_assert(std::to_integer<int>(test(b2)) ==  8, "" );
-	static_assert(std::to_integer<int>(test(b3)) == 12, "" );
+    static_assert(std::to_integer<int>(test(b2)) ==  8, "" );
+    static_assert(std::to_integer<int>(test(b3)) == 12, "" );
 
 }
diff --git a/test/std/language.support/support.types/byteops/lshift.fail.cpp b/test/std/language.support/support.types/byteops/lshift.fail.cpp
index 707258c6df30..c213935912c2 100644
--- a/test/std/language.support/support.types/byteops/lshift.fail.cpp
+++ b/test/std/language.support/support.types/byteops/lshift.fail.cpp
@@ -18,6 +18,6 @@
 //   is_integral_v<IntegerType> is true.
 
 int main () {
-	constexpr std::byte b1{static_cast<std::byte>(1)};
-	constexpr std::byte b2 = b1 << 2.0f;
+    constexpr std::byte b1{static_cast<std::byte>(1)};
+    constexpr std::byte b2 = b1 << 2.0f;
 }
diff --git a/test/std/language.support/support.types/byteops/lshift.pass.cpp b/test/std/language.support/support.types/byteops/lshift.pass.cpp
index 15ad796cbe9e..a1731b9904cc 100644
--- a/test/std/language.support/support.types/byteops/lshift.pass.cpp
+++ b/test/std/language.support/support.types/byteops/lshift.pass.cpp
@@ -18,13 +18,13 @@
 //   is_integral_v<IntegerType> is true.
 
 int main () {
-	constexpr std::byte b1{static_cast<std::byte>(1)};
-	constexpr std::byte b3{static_cast<std::byte>(3)};
+    constexpr std::byte b1{static_cast<std::byte>(1)};
+    constexpr std::byte b3{static_cast<std::byte>(3)};
 
-	static_assert(noexcept(b3 << 2), "" );
+    static_assert(noexcept(b3 << 2), "" );
 
-	static_assert(std::to_integer<int>(b1 << 1) ==   2, "");
-	static_assert(std::to_integer<int>(b1 << 2) ==   4, "");
-	static_assert(std::to_integer<int>(b3 << 4) ==  48, "");
-	static_assert(std::to_integer<int>(b3 << 6) == 192, "");
+    static_assert(std::to_integer<int>(b1 << 1) ==   2, "");
+    static_assert(std::to_integer<int>(b1 << 2) ==   4, "");
+    static_assert(std::to_integer<int>(b3 << 4) ==  48, "");
+    static_assert(std::to_integer<int>(b3 << 6) == 192, "");
 }
diff --git a/test/std/language.support/support.types/byteops/not.pass.cpp b/test/std/language.support/support.types/byteops/not.pass.cpp
index 53f1d91faf23..2629001e96a2 100644
--- a/test/std/language.support/support.types/byteops/not.pass.cpp
+++ b/test/std/language.support/support.types/byteops/not.pass.cpp
@@ -15,13 +15,13 @@
 // constexpr byte operator~(byte b) noexcept;
 
 int main () {
-	constexpr std::byte b1{static_cast<std::byte>(1)};
-	constexpr std::byte b2{static_cast<std::byte>(2)};
-	constexpr std::byte b8{static_cast<std::byte>(8)};
+    constexpr std::byte b1{static_cast<std::byte>(1)};
+    constexpr std::byte b2{static_cast<std::byte>(2)};
+    constexpr std::byte b8{static_cast<std::byte>(8)};
 
-	static_assert(noexcept(~b1), "" );
+    static_assert(noexcept(~b1), "" );
 
-	static_assert(std::to_integer<int>(~b1) == 254, "");
-	static_assert(std::to_integer<int>(~b2) == 253, "");
-	static_assert(std::to_integer<int>(~b8) == 247, "");
+    static_assert(std::to_integer<int>(~b1) == 254, "");
+    static_assert(std::to_integer<int>(~b2) == 253, "");
+    static_assert(std::to_integer<int>(~b8) == 247, "");
 }
diff --git a/test/std/language.support/support.types/byteops/or.assign.pass.cpp b/test/std/language.support/support.types/byteops/or.assign.pass.cpp
index bb4a84ec6c76..0cceeaaece15 100644
--- a/test/std/language.support/support.types/byteops/or.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/or.assign.pass.cpp
@@ -16,25 +16,25 @@
 
 
 constexpr std::byte test(std::byte b1, std::byte b2) {
-	std::byte bret = b1;
-	return bret |= b2;
-	}
+    std::byte bret = b1;
+    return bret |= b2;
+    }
 
 
 int main () {
-	std::byte b;  // not constexpr, just used in noexcept check
-	constexpr std::byte b1{static_cast<std::byte>(1)};
-	constexpr std::byte b2{static_cast<std::byte>(2)};
-	constexpr std::byte b8{static_cast<std::byte>(8)};
+    std::byte b;  // not constexpr, just used in noexcept check
+    constexpr std::byte b1{static_cast<std::byte>(1)};
+    constexpr std::byte b2{static_cast<std::byte>(2)};
+    constexpr std::byte b8{static_cast<std::byte>(8)};
 
-	static_assert(noexcept(b |= b), "" );
+    static_assert(noexcept(b |= b), "" );
 
-	static_assert(std::to_integer<int>(test(b1, b2)) ==  3, "");
-	static_assert(std::to_integer<int>(test(b1, b8)) ==  9, "");
-	static_assert(std::to_integer<int>(test(b2, b8)) == 10, "");
+    static_assert(std::to_integer<int>(test(b1, b2)) ==  3, "");
+    static_assert(std::to_integer<int>(test(b1, b8)) ==  9, "");
+    static_assert(std::to_integer<int>(test(b2, b8)) == 10, "");
 
-	static_assert(std::to_integer<int>(test(b2, b1)) ==  3, "");
-	static_assert(std::to_integer<int>(test(b8, b1)) ==  9, "");
-	static_assert(std::to_integer<int>(test(b8, b2)) == 10, "");
+    static_assert(std::to_integer<int>(test(b2, b1)) ==  3, "");
+    static_assert(std::to_integer<int>(test(b8, b1)) ==  9, "");
+    static_assert(std::to_integer<int>(test(b8, b2)) == 10, "");
 
 }
diff --git a/test/std/language.support/support.types/byteops/or.pass.cpp b/test/std/language.support/support.types/byteops/or.pass.cpp
index e2b734982c09..62260f27bd24 100644
--- a/test/std/language.support/support.types/byteops/or.pass.cpp
+++ b/test/std/language.support/support.types/byteops/or.pass.cpp
@@ -15,17 +15,17 @@
 // constexpr byte operator|(byte l, byte r) noexcept;
 
 int main () {
-	constexpr std::byte b1{static_cast<std::byte>(1)};
-	constexpr std::byte b2{static_cast<std::byte>(2)};
-	constexpr std::byte b8{static_cast<std::byte>(8)};
+    constexpr std::byte b1{static_cast<std::byte>(1)};
+    constexpr std::byte b2{static_cast<std::byte>(2)};
+    constexpr std::byte b8{static_cast<std::byte>(8)};
 
-	static_assert(noexcept(b1 | b2), "" );
+    static_assert(noexcept(b1 | b2), "" );
 
-	static_assert(std::to_integer<int>(b1 | b2) ==  3, "");
-	static_assert(std::to_integer<int>(b1 | b8) ==  9, "");
-	static_assert(std::to_integer<int>(b2 | b8) == 10, "");
+    static_assert(std::to_integer<int>(b1 | b2) ==  3, "");
+    static_assert(std::to_integer<int>(b1 | b8) ==  9, "");
+    static_assert(std::to_integer<int>(b2 | b8) == 10, "");
 
-	static_assert(std::to_integer<int>(b2 | b1) ==  3, "");
-	static_assert(std::to_integer<int>(b8 | b1) ==  9, "");
-	static_assert(std::to_integer<int>(b8 | b2) == 10, "");
+    static_assert(std::to_integer<int>(b2 | b1) ==  3, "");
+    static_assert(std::to_integer<int>(b8 | b1) ==  9, "");
+    static_assert(std::to_integer<int>(b8 | b2) == 10, "");
 }
diff --git a/test/std/language.support/support.types/byteops/rshift.assign.fail.cpp b/test/std/language.support/support.types/byteops/rshift.assign.fail.cpp
index 44992fa98c33..80f0bd7bcf59 100644
--- a/test/std/language.support/support.types/byteops/rshift.assign.fail.cpp
+++ b/test/std/language.support/support.types/byteops/rshift.assign.fail.cpp
@@ -22,10 +22,10 @@
 
 
 constexpr std::byte test(std::byte b) {
-	return b >>= 2.0;
-	}
+    return b >>= 2.0;
+    }
 
 
 int main () {
-	constexpr std::byte b1 = test(std::byte{1});
+    constexpr std::byte b1 = test(std::byte{1});
 }
diff --git a/test/std/language.support/support.types/byteops/rshift.assign.pass.cpp b/test/std/language.support/support.types/byteops/rshift.assign.pass.cpp
index 82c611cfdfcb..6763995f6d42 100644
--- a/test/std/language.support/support.types/byteops/rshift.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/rshift.assign.pass.cpp
@@ -19,17 +19,17 @@
 
 
 constexpr std::byte test(std::byte b) {
-	return b >>= 2;
-	}
+    return b >>= 2;
+    }
 
 
 int main () {
-	std::byte b;  // not constexpr, just used in noexcept check
-	constexpr std::byte b16{static_cast<std::byte>(16)};
-	constexpr std::byte b192{static_cast<std::byte>(192)};
+    std::byte b;  // not constexpr, just used in noexcept check
+    constexpr std::byte b16{static_cast<std::byte>(16)};
+    constexpr std::byte b192{static_cast<std::byte>(192)};
 
-	static_assert(noexcept(b >>= 2), "" );
+    static_assert(noexcept(b >>= 2), "" );
 
-	static_assert(std::to_integer<int>(test(b16))  ==  4, "" );
-	static_assert(std::to_integer<int>(test(b192)) == 48, "" );
+    static_assert(std::to_integer<int>(test(b16))  ==  4, "" );
+    static_assert(std::to_integer<int>(test(b192)) == 48, "" );
 }
diff --git a/test/std/language.support/support.types/byteops/rshift.fail.cpp b/test/std/language.support/support.types/byteops/rshift.fail.cpp
index 8e142dd90a5c..b78af2eb260f 100644
--- a/test/std/language.support/support.types/byteops/rshift.fail.cpp
+++ b/test/std/language.support/support.types/byteops/rshift.fail.cpp
@@ -18,6 +18,6 @@
 //   is_integral_v<IntegerType> is true.
 
 int main () {
-	constexpr std::byte b1{static_cast<std::byte>(1)};
-	constexpr std::byte b2 = b1 >> 2.0f;
+    constexpr std::byte b1{static_cast<std::byte>(1)};
+    constexpr std::byte b2 = b1 >> 2.0f;
 }
diff --git a/test/std/language.support/support.types/byteops/rshift.pass.cpp b/test/std/language.support/support.types/byteops/rshift.pass.cpp
index 22d399130bbc..eec3ad6839b4 100644
--- a/test/std/language.support/support.types/byteops/rshift.pass.cpp
+++ b/test/std/language.support/support.types/byteops/rshift.pass.cpp
@@ -19,19 +19,19 @@
 
 
 constexpr std::byte test(std::byte b) {
-	return b <<= 2;
-	}
+    return b <<= 2;
+    }
 
 
 int main () {
-	constexpr std::byte b100{static_cast<std::byte>(100)};
-	constexpr std::byte b115{static_cast<std::byte>(115)};
+    constexpr std::byte b100{static_cast<std::byte>(100)};
+    constexpr std::byte b115{static_cast<std::byte>(115)};
 
-	static_assert(noexcept(b100 << 2), "" );
+    static_assert(noexcept(b100 << 2), "" );
 
-	static_assert(std::to_integer<int>(b100 >> 1) ==  50, "");
-	static_assert(std::to_integer<int>(b100 >> 2) ==  25, "");
-	static_assert(std::to_integer<int>(b115 >> 3) ==  14, "");
-	static_assert(std::to_integer<int>(b115 >> 6) ==   1, "");
+    static_assert(std::to_integer<int>(b100 >> 1) ==  50, "");
+    static_assert(std::to_integer<int>(b100 >> 2) ==  25, "");
+    static_assert(std::to_integer<int>(b115 >> 3) ==  14, "");
+    static_assert(std::to_integer<int>(b115 >> 6) ==   1, "");
 
 }
diff --git a/test/std/language.support/support.types/byteops/to_integer.fail.cpp b/test/std/language.support/support.types/byteops/to_integer.fail.cpp
index fb4928956f55..86f2ad95bf17 100644
--- a/test/std/language.support/support.types/byteops/to_integer.fail.cpp
+++ b/test/std/language.support/support.types/byteops/to_integer.fail.cpp
@@ -18,6 +18,6 @@
 //   is_integral_v<IntegerType> is true.
 
 int main () {
-	constexpr std::byte b1{static_cast<std::byte>(1)};
-	auto f = std::to_integer<float>(b1);
+    constexpr std::byte b1{static_cast<std::byte>(1)};
+    auto f = std::to_integer<float>(b1);
 }
diff --git a/test/std/language.support/support.types/byteops/to_integer.pass.cpp b/test/std/language.support/support.types/byteops/to_integer.pass.cpp
index 4f34363447f6..065e6d1278ad 100644
--- a/test/std/language.support/support.types/byteops/to_integer.pass.cpp
+++ b/test/std/language.support/support.types/byteops/to_integer.pass.cpp
@@ -18,14 +18,14 @@
 //   is_integral_v<IntegerType> is true.
 
 int main () {
-	constexpr std::byte b1{static_cast<std::byte>(1)};
-	constexpr std::byte b3{static_cast<std::byte>(3)};
+    constexpr std::byte b1{static_cast<std::byte>(1)};
+    constexpr std::byte b3{static_cast<std::byte>(3)};
 
-	static_assert(noexcept(std::to_integer<int>(b1)), "" );
-	static_assert(std::is_same<int, decltype(std::to_integer<int>(b1))>::value, "" );
-	static_assert(std::is_same<long, decltype(std::to_integer<long>(b1))>::value, "" );
-	static_assert(std::is_same<unsigned short, decltype(std::to_integer<unsigned short>(b1))>::value, "" );
+    static_assert(noexcept(std::to_integer<int>(b1)), "" );
+    static_assert(std::is_same<int, decltype(std::to_integer<int>(b1))>::value, "" );
+    static_assert(std::is_same<long, decltype(std::to_integer<long>(b1))>::value, "" );
+    static_assert(std::is_same<unsigned short, decltype(std::to_integer<unsigned short>(b1))>::value, "" );
 
-	static_assert(std::to_integer<int>(b1) == 1, "");
-	static_assert(std::to_integer<int>(b3) == 3, "");
+    static_assert(std::to_integer<int>(b1) == 1, "");
+    static_assert(std::to_integer<int>(b3) == 3, "");
 }
diff --git a/test/std/language.support/support.types/byteops/xor.assign.pass.cpp b/test/std/language.support/support.types/byteops/xor.assign.pass.cpp
index 6a526da3d714..07727ec9eb1c 100644
--- a/test/std/language.support/support.types/byteops/xor.assign.pass.cpp
+++ b/test/std/language.support/support.types/byteops/xor.assign.pass.cpp
@@ -16,24 +16,24 @@
 
 
 constexpr std::byte test(std::byte b1, std::byte b2) {
-	std::byte bret = b1;
-	return bret ^= b2;
-	}
+    std::byte bret = b1;
+    return bret ^= b2;
+    }
 
 
 int main () {
-	std::byte b;  // not constexpr, just used in noexcept check
-	constexpr std::byte b1{static_cast<std::byte>(1)};
-	constexpr std::byte b8{static_cast<std::byte>(8)};
-	constexpr std::byte b9{static_cast<std::byte>(9)};
+    std::byte b;  // not constexpr, just used in noexcept check
+    constexpr std::byte b1{static_cast<std::byte>(1)};
+    constexpr std::byte b8{static_cast<std::byte>(8)};
+    constexpr std::byte b9{static_cast<std::byte>(9)};
 
-	static_assert(noexcept(b ^= b), "" );
+    static_assert(noexcept(b ^= b), "" );
 
-	static_assert(std::to_integer<int>(test(b1, b8)) == 9, "");
-	static_assert(std::to_integer<int>(test(b1, b9)) == 8, "");
-	static_assert(std::to_integer<int>(test(b8, b9)) == 1, "");
+    static_assert(std::to_integer<int>(test(b1, b8)) == 9, "");
+    static_assert(std::to_integer<int>(test(b1, b9)) == 8, "");
+    static_assert(std::to_integer<int>(test(b8, b9)) == 1, "");
 
-	static_assert(std::to_integer<int>(test(b8, b1)) == 9, "");
-	static_assert(std::to_integer<int>(test(b9, b1)) == 8, "");
-	static_assert(std::to_integer<int>(test(b9, b8)) == 1, "");
+    static_assert(std::to_integer<int>(test(b8, b1)) == 9, "");
+    static_assert(std::to_integer<int>(test(b9, b1)) == 8, "");
+    static_assert(std::to_integer<int>(test(b9, b8)) == 1, "");
 }
diff --git a/test/std/language.support/support.types/byteops/xor.pass.cpp b/test/std/language.support/support.types/byteops/xor.pass.cpp
index e8c3b9875785..d7e18c91b044 100644
--- a/test/std/language.support/support.types/byteops/xor.pass.cpp
+++ b/test/std/language.support/support.types/byteops/xor.pass.cpp
@@ -15,17 +15,17 @@
 // constexpr byte operator^(byte l, byte r) noexcept;
 
 int main () {
-	constexpr std::byte b1{static_cast<std::byte>(1)};
-	constexpr std::byte b8{static_cast<std::byte>(8)};
-	constexpr std::byte b9{static_cast<std::byte>(9)};
+    constexpr std::byte b1{static_cast<std::byte>(1)};
+    constexpr std::byte b8{static_cast<std::byte>(8)};
+    constexpr std::byte b9{static_cast<std::byte>(9)};
 
-	static_assert(noexcept(b1 ^ b8), "" );
+    static_assert(noexcept(b1 ^ b8), "" );
 
-	static_assert(std::to_integer<int>(b1 ^ b8) == 9, "");
-	static_assert(std::to_integer<int>(b1 ^ b9) == 8, "");
-	static_assert(std::to_integer<int>(b8 ^ b9) == 1, "");
+    static_assert(std::to_integer<int>(b1 ^ b8) == 9, "");
+    static_assert(std::to_integer<int>(b1 ^ b9) == 8, "");
+    static_assert(std::to_integer<int>(b8 ^ b9) == 1, "");
 
-	static_assert(std::to_integer<int>(b8 ^ b1) == 9, "");
-	static_assert(std::to_integer<int>(b9 ^ b1) == 8, "");
-	static_assert(std::to_integer<int>(b9 ^ b8) == 1, "");
+    static_assert(std::to_integer<int>(b8 ^ b1) == 9, "");
+    static_assert(std::to_integer<int>(b9 ^ b1) == 8, "");
+    static_assert(std::to_integer<int>(b9 ^ b8) == 1, "");
 }
diff --git a/test/std/language.support/support.types/nullptr_t.pass.cpp b/test/std/language.support/support.types/nullptr_t.pass.cpp
index 2d0ed7410590..ffa0c90d4d86 100644
--- a/test/std/language.support/support.types/nullptr_t.pass.cpp
+++ b/test/std/language.support/support.types/nullptr_t.pass.cpp
@@ -91,7 +91,7 @@ int main()
     {
 #ifdef _LIBCPP_HAS_NO_NULLPTR
         static_assert(!has_less<std::nullptr_t>::value, "");
-        // FIXME: our c++03 nullptr emulation still allows for comparisons
+        // FIXME: our C++03 nullptr emulation still allows for comparisons
         // with other pointer types by way of the conversion operator.
         //static_assert(!has_less<void*>::value, "");
 #else
diff --git a/test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp b/test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp
index 06c171f56da6..c260e34e3aca 100644
--- a/test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp
+++ b/test/std/localization/locale.categories/category.ctype/ctype_base.pass.cpp
@@ -36,8 +36,8 @@
 #include <locale>
 #include <cassert>
 
-template <class _Tp>
-void test(const _Tp &) {}
+template <class T>
+void test(const T &) {}
 
 int main()
 {
diff --git a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
index d7ce1033a8da..5656f73ee9d2 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp
@@ -117,7 +117,7 @@ int main()
             assert(ex == -123456789);
         }
         {   // zero, showbase
-            std::string v = "0,00 \u20ac";  // €
+            std::string v = "0,00 \u20ac";  // EURO SIGN
             showbase(ios);
             typedef input_iterator<const char*> I;
             long double ex;
@@ -129,7 +129,7 @@ int main()
             assert(ex == 0);
         }
         {   // zero, showbase
-            std::string v = "0,00 \u20ac";  // €
+            std::string v = "0,00 \u20ac";  // EURO SIGN
             showbase(ios);
             typedef input_iterator<const char*> I;
             long double ex;
@@ -141,7 +141,7 @@ int main()
             assert(ex == 0);
         }
         {   // negative one, showbase
-            std::string v = "-0,01 \u20ac";
+            std::string v = "-0,01 \u20ac";  // EURO SIGN
             typedef input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
@@ -152,7 +152,7 @@ int main()
             assert(ex == -1);
         }
         {   // negative one, showbase
-            std::string v = "-0,01 \u20ac";
+            std::string v = "-0,01 \u20ac";  // EURO SIGN
             showbase(ios);
             typedef input_iterator<const char*> I;
             long double ex;
@@ -164,7 +164,7 @@ int main()
             assert(ex == -1);
         }
         {   // positive, showbase
-            std::string v = "1 234 567,89 \u20ac";
+            std::string v = "1 234 567,89 \u20ac";  // EURO SIGN
             typedef input_iterator<const char*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
@@ -175,7 +175,7 @@ int main()
             assert(ex == 123456789);
         }
         {   // positive, showbase
-            std::string v = "1 234 567,89 \u20ac";
+            std::string v = "1 234 567,89 \u20ac";  // EURO SIGN
             showbase(ios);
             typedef input_iterator<const char*> I;
             long double ex;
@@ -188,7 +188,7 @@ int main()
             noshowbase(ios);
         }
         {   // negative, showbase
-            std::string v = "-1 234 567,89 \u20ac";
+            std::string v = "-1 234 567,89 \u20ac";  // EURO SIGN
             showbase(ios);
             typedef input_iterator<const char*> I;
             long double ex;
@@ -450,7 +450,7 @@ int main()
             assert(ex == -123456789);
         }
         {   // zero, showbase
-            std::wstring v = L"0,00 \u20ac";
+            std::wstring v = L"0,00 \u20ac";  // EURO SIGN
             showbase(ios);
             typedef input_iterator<const wchar_t*> I;
             long double ex;
@@ -462,7 +462,7 @@ int main()
             assert(ex == 0);
         }
         {   // zero, showbase
-            std::wstring v = L"0,00 \u20ac";
+            std::wstring v = L"0,00 \u20ac";  // EURO SIGN
             showbase(ios);
             typedef input_iterator<const wchar_t*> I;
             long double ex;
@@ -474,7 +474,7 @@ int main()
             assert(ex == 0);
         }
         {   // negative one, showbase
-            std::wstring v = L"-0,01 \u20ac";
+            std::wstring v = L"-0,01 \u20ac";  // EURO SIGN
             typedef input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
@@ -485,7 +485,7 @@ int main()
             assert(ex == -1);
         }
         {   // negative one, showbase
-            std::wstring v = L"-0,01 \u20ac";
+            std::wstring v = L"-0,01 \u20ac";  // EURO SIGN
             showbase(ios);
             typedef input_iterator<const wchar_t*> I;
             long double ex;
@@ -497,7 +497,7 @@ int main()
             assert(ex == -1);
         }
         {   // positive, showbase
-            std::wstring v = L"1 234 567,89 \u20ac";
+            std::wstring v = L"1 234 567,89 \u20ac";  // EURO SIGN
             typedef input_iterator<const wchar_t*> I;
             long double ex;
             std::ios_base::iostate err = std::ios_base::goodbit;
@@ -508,7 +508,7 @@ int main()
             assert(ex == 123456789);
         }
         {   // positive, showbase
-            std::wstring v = L"1 234 567,89 \u20ac";
+            std::wstring v = L"1 234 567,89 \u20ac";  // EURO SIGN
             showbase(ios);
             typedef input_iterator<const wchar_t*> I;
             long double ex;
@@ -521,7 +521,7 @@ int main()
             noshowbase(ios);
         }
         {   // negative, showbase
-            std::wstring v = L"-1 234 567,89 \u20ac";
+            std::wstring v = L"-1 234 567,89 \u20ac";  // EURO SIGN
             showbase(ios);
             typedef input_iterator<const wchar_t*> I;
             long double ex;
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
index 8490b708b6cf..3a9adc4bbc1e 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct.byname/curr_symbol.pass.cpp
@@ -117,7 +117,13 @@ int main()
         // GLIBC <= 2.23 uses currency_symbol="<U0440><U0443><U0431>"
         // GLIBC >= 2.24 uses currency_symbol="<U20BD>"
         // See also: http://www.fileformat.info/info/unicode/char/20bd/index.htm
-#if defined(TEST_GLIBC_PREREQ) && TEST_GLIBC_PREREQ(2, 24)
+#if defined(TEST_GLIBC_PREREQ)
+    #if TEST_GLIBC_PREREQ(2, 24)
+        #define TEST_GLIBC_2_24_CURRENCY_SYMBOL
+    #endif
+#endif
+
+#if defined(TEST_GLIBC_2_24_CURRENCY_SYMBOL)
         assert(f.curr_symbol() == " \u20BD");
 #else
         assert(f.curr_symbol() == " \xD1\x80\xD1\x83\xD0\xB1");
@@ -129,7 +135,7 @@ int main()
     }
     {
         Fwf f(LOCALE_ru_RU_UTF_8, 1);
-#if defined(TEST_GLIBC_PREREQ) && TEST_GLIBC_PREREQ(2, 24)
+#if defined(TEST_GLIBC_2_24_CURRENCY_SYMBOL)
         assert(f.curr_symbol() == L" \u20BD");
 #else
         assert(f.curr_symbol() == L" \x440\x443\x431");
diff --git a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp
index 323d856a3923..8998bf004652 100644
--- a/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp
+++ b/test/std/localization/locale.categories/category.monetary/locale.moneypunct/types.pass.cpp
@@ -27,8 +27,8 @@
 #include <locale>
 #include <type_traits>
 
-template <class _Tp>
-void test(const _Tp &) {}
+template <class T>
+void test(const T &) {}
 
 int main()
 {
diff --git a/test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp b/test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp
index 8fc311a5bd80..dbab8212a736 100644
--- a/test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp
+++ b/test/std/localization/locales/locale/locale.types/locale.category/category.pass.cpp
@@ -20,8 +20,8 @@
 #include <type_traits>
 #include <cassert>
 
-template <class _Tp>
-void test(const _Tp &) {}
+template <class T>
+void test(const T &) {}
 
 
 int main()
diff --git a/test/std/numerics/c.math/ctgmath.pass.cpp b/test/std/numerics/c.math/ctgmath.pass.cpp
index 9e10690e3cac..24908ff03dc7 100644
--- a/test/std/numerics/c.math/ctgmath.pass.cpp
+++ b/test/std/numerics/c.math/ctgmath.pass.cpp
@@ -14,6 +14,7 @@
 int main()
 {
     std::complex<double> cd;
+    (void)cd;
     double x = std::sin(0);
     ((void)x); // Prevent unused warning
 }
diff --git a/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp b/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp
index 4b89414686ba..3e215c8bf3c9 100644
--- a/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp
+++ b/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp
@@ -14,4 +14,5 @@
 int main()
 {
     std::complex<double> d;
+    (void)d;
 }
diff --git a/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
index 1b0cca0d5f69..837734fcde9f 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
@@ -34,7 +34,6 @@ test()
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
diff --git a/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
index f1aece20e6cf..deb056d67dec 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
@@ -34,7 +34,6 @@ test()
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
diff --git a/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
index 2b213094df25..8d7462141d79 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
@@ -34,7 +34,6 @@ test()
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
diff --git a/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
index 011f9d6b4f2e..3da56c32f198 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
@@ -34,7 +34,6 @@ test()
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
diff --git a/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
index 6dc6034ca3c6..37e00c3925a6 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
@@ -34,7 +34,6 @@ test()
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const double pi = std::atan2(+0., -0.);
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
diff --git a/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
index 03ed727cab8c..be9d505b9e27 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
@@ -34,7 +34,6 @@ test()
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
diff --git a/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
index a2c55390f2a8..dad5bd190aa8 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
@@ -34,7 +34,6 @@ test()
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
diff --git a/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
index 7ae59980b09d..0ab8ac275630 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
@@ -34,7 +34,6 @@ test()
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
diff --git a/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
index 491f3fac5738..e310f26dc9b4 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
@@ -34,7 +34,6 @@ test()
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
diff --git a/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp b/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
index 8fa419c2179d..1028836f98da 100644
--- a/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
+++ b/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
@@ -34,7 +34,6 @@ test()
 
 void test_edges()
 {
-    typedef std::complex<double> C;
     const unsigned N = sizeof(testcases) / sizeof(testcases[0]);
     for (unsigned i = 0; i < N; ++i)
     {
diff --git a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
index af5b1f0d3717..5c422300e343 100644
--- a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
+++ b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp
@@ -13,7 +13,7 @@
 // template<class InputIterator, class OutputIterator, class T>
 //     OutputIterator inclusive_scan(InputIterator first, InputIterator last,
 //                                   OutputIterator result, T init);
-// 
+//
 
 #include <numeric>
 #include <vector>
@@ -26,7 +26,7 @@ void
 test(Iter1 first, Iter1 last, Iter2 rFirst, Iter2 rLast)
 {
     std::vector<typename std::iterator_traits<Iter1>::value_type> v;
-    
+
 //  Not in place
     std::inclusive_scan(first, last, std::back_inserter(v));
     assert(std::equal(v.begin(), v.end(), rFirst, rLast));
@@ -35,7 +35,7 @@ test(Iter1 first, Iter1 last, Iter2 rFirst, Iter2 rLast)
     v.clear();
     v.assign(first, last);
     std::inclusive_scan(v.begin(), v.end(), v.begin());
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));  
+    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
 }
 
 
diff --git a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
index 95db56bf67d2..2c6eacc1682f 100644
--- a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp
@@ -13,7 +13,7 @@
 // template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
 //     OutputIterator
 //     inclusive_scan(InputIterator first, InputIterator last,
-//                    OutputIterator result, 
+//                    OutputIterator result,
 //                    BinaryOperation binary_op); // C++17
 
 #include <numeric>
@@ -37,7 +37,7 @@ test(Iter1 first, Iter1 last, Op op, Iter2 rFirst, Iter2 rLast)
     v.clear();
     v.assign(first, last);
     std::inclusive_scan(v.begin(), v.end(), v.begin(), op);
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));  
+    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
 }
 
 
@@ -99,7 +99,7 @@ int main()
 {
 
     basic_tests();
-    
+
 //  All the iterator categories
 //     test<input_iterator        <const int*> >();
 //     test<forward_iterator      <const int*> >();
@@ -109,4 +109,3 @@ int main()
 //     test<      int*>();
 
 }
- 
\ No newline at end of file
diff --git a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
index 04913f904885..653578055c69 100644
--- a/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
+++ b/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp
@@ -13,7 +13,7 @@
 // template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
 //     OutputIterator
 //     inclusive_scan(InputIterator first, InputIterator last,
-//                    OutputIterator result, 
+//                    OutputIterator result,
 //                    BinaryOperation binary_op, T init); // C++17
 
 #include <numeric>
@@ -36,7 +36,7 @@ test(Iter1 first, Iter1 last, Op op, T init, Iter2 rFirst, Iter2 rLast)
     v.clear();
     v.assign(first, last);
     std::inclusive_scan(v.begin(), v.end(), v.begin(), op, init);
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));  
+    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
 }
 
 
@@ -115,7 +115,7 @@ int main()
 {
 
     basic_tests();
-    
+
 //  All the iterator categories
     test<input_iterator        <const int*> >();
     test<forward_iterator      <const int*> >();
@@ -125,4 +125,3 @@ int main()
     test<      int*>();
 
 }
- 
\ No newline at end of file
diff --git a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
index 6bd8a4f1e610..d96ca3225aa3 100644
--- a/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
+++ b/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.pass.cpp
@@ -19,6 +19,7 @@
 #include <cstdint>
 #include <cstdlib>
 #include <type_traits>
+#include "test_macros.h"
 
 constexpr struct {
   int x;
@@ -137,7 +138,7 @@ int main()
 //  LWG#2837
     {
     auto res1 = std::lcm(static_cast<std::int64_t>(1234), INT32_MIN);
-    (void)std::lcm(INT_MIN, 2UL);	// this used to trigger UBSAN
+    TEST_IGNORE_NODISCARD std::lcm(INT_MIN, 2UL);   // this used to trigger UBSAN
     static_assert(std::is_same_v<decltype(res1), std::int64_t>, "");
     assert(res1 == 1324997410816LL);
     }
diff --git a/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp b/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
index e3e2ffe7be0c..cff1b8c0ab4e 100644
--- a/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
+++ b/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp
@@ -65,10 +65,10 @@ int main()
     test<random_access_iterator<const int*> >();
     test<const int*>();
 
-//	Make sure the math is done using the correct type
+//  Make sure the math is done using the correct type
     {
     auto v = {1, 2, 3, 4, 5, 6, 7, 8};
     unsigned res = std::reduce(v.begin(), v.end(), 1U, std::multiplies<>());
-    assert(res == 40320);		// 8! will not fit into a char
+    assert(res == 40320);       // 8! will not fit into a char
     }
 }
diff --git a/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp b/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
index d96d4d6ec439..4964e8e884bd 100644
--- a/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp
@@ -25,20 +25,20 @@
 
 #include "test_iterators.h"
 
-template <class _Tp = void>
-struct identity : std::unary_function<_Tp, _Tp>
+template <class T = void>
+struct identity : std::unary_function<T, T>
 {
-    constexpr const _Tp& operator()(const _Tp& __x) const { return __x;}
+    constexpr const T& operator()(const T& x) const { return x;}
 };
 
 template <>
 struct identity<void>
 {
-    template <class _Tp>
-    constexpr auto operator()(_Tp&& __x) const
-    _NOEXCEPT_(noexcept(_VSTD::forward<_Tp>(__x)))
-    -> decltype        (_VSTD::forward<_Tp>(__x))
-        { return        _VSTD::forward<_Tp>(__x); }
+    template <class T>
+    constexpr auto operator()(T&& x) const
+    _NOEXCEPT_(noexcept(_VSTD::forward<T>(x)))
+    -> decltype        (_VSTD::forward<T>(x))
+        { return        _VSTD::forward<T>(x); }
 };
 
 template <class Iter1, class BOp, class UOp, class T, class Iter2>
diff --git a/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp b/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
index b96218d7da4f..d15defc2cabc 100644
--- a/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp
@@ -1,3 +1,4 @@
+
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
@@ -10,7 +11,7 @@
 // <numeric>
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// template<class InputIterator, class OutputIterator, class T, 
+// template<class InputIterator, class OutputIterator, class T,
 //          class BinaryOperation, class UnaryOperation>
 //   OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
 //                                           OutputIterator result,
@@ -25,20 +26,20 @@
 
 #include "test_iterators.h"
 
-template <class _Tp = void>
-struct identity : std::unary_function<_Tp, _Tp>
+template <class T = void>
+struct identity : std::unary_function<T, T>
 {
-    constexpr const _Tp& operator()(const _Tp& __x) const { return __x;}
+    constexpr const T& operator()(const T& x) const { return x;}
 };
 
 template <>
 struct identity<void>
 {
-    template <class _Tp>
-    constexpr auto operator()(_Tp&& __x) const
-    _NOEXCEPT_(noexcept(_VSTD::forward<_Tp>(__x)))
-    -> decltype        (_VSTD::forward<_Tp>(__x))
-        { return        _VSTD::forward<_Tp>(__x); }
+    template <class T>
+    constexpr auto operator()(T&& x) const
+    _NOEXCEPT_(noexcept(_VSTD::forward<T>(x)))
+    -> decltype        (_VSTD::forward<T>(x))
+        { return        _VSTD::forward<T>(x); }
 };
 
 template <class Iter1, class BOp, class UOp, class Iter2>
@@ -64,7 +65,7 @@ test()
 {
           int ia[]     = {  1,  3,   5,   7,    9};
     const int pResI0[] = {  1,  4,   9,  16,   25};        // with identity
-    const int mResI0[] = {  1,  3,  15, 105,  945};        
+    const int mResI0[] = {  1,  3,  15, 105,  945};
     const int pResN0[] = { -1, -4,  -9, -16,  -25};        // with negate
     const int mResN0[] = { -1,  3, -15, 105, -945};
     const unsigned sa = sizeof(ia) / sizeof(ia[0]);
@@ -90,8 +91,8 @@ void basic_tests()
     std::vector<int> v(10);
     std::fill(v.begin(), v.end(), 3);
     std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), identity<>());
- 	std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
-	std::cout << std::endl;	
+    std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
+    std::cout << std::endl;
     for (size_t i = 0; i < v.size(); ++i)
         assert(v[i] == (int)(i+1) * 3);
     }
@@ -122,7 +123,7 @@ void basic_tests()
 int main()
 {
     basic_tests();
-    
+
 //  All the iterator categories
     test<input_iterator        <const int*> >();
     test<forward_iterator      <const int*> >();
diff --git a/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp b/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
index df68946a5e65..b38b9a5afedf 100644
--- a/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp
@@ -10,7 +10,7 @@
 // <numeric>
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
-// template<class InputIterator, class OutputIterator, class T, 
+// template<class InputIterator, class OutputIterator, class T,
 //          class BinaryOperation, class UnaryOperation>
 //   OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
 //                                           OutputIterator result,
@@ -25,20 +25,20 @@
 
 #include "test_iterators.h"
 
-template <class _Tp = void>
-struct identity : std::unary_function<_Tp, _Tp>
+template <class T = void>
+struct identity : std::unary_function<T, T>
 {
-    constexpr const _Tp& operator()(const _Tp& __x) const { return __x;}
+    constexpr const T& operator()(const T& x) const { return x;}
 };
 
 template <>
 struct identity<void>
 {
-    template <class _Tp>
-    constexpr auto operator()(_Tp&& __x) const
-    _NOEXCEPT_(noexcept(_VSTD::forward<_Tp>(__x)))
-    -> decltype        (_VSTD::forward<_Tp>(__x))
-        { return        _VSTD::forward<_Tp>(__x); }
+    template <class T>
+    constexpr auto operator()(T&& x) const
+    _NOEXCEPT_(noexcept(_VSTD::forward<T>(x)))
+    -> decltype        (_VSTD::forward<T>(x))
+        { return        _VSTD::forward<T>(x); }
 };
 
 template <class Iter1, class BOp, class UOp, class T, class Iter2>
@@ -64,11 +64,11 @@ test()
 {
           int ia[]     = {  1,  3,   5,    7,     9};
     const int pResI0[] = {  1,  4,   9,   16,    25};        // with identity
-    const int mResI0[] = {  0,  0,   0,    0,     0};        
+    const int mResI0[] = {  0,  0,   0,    0,     0};
     const int pResN0[] = { -1, -4,  -9,  -16,   -25};        // with negate
     const int mResN0[] = {  0,  0,   0,    0,     0};
     const int pResI2[] = {  3,  6,  11,   18,    27};        // with identity
-    const int mResI2[] = {  2,  6,  30,  210,  1890};        
+    const int mResI2[] = {  2,  6,  30,  210,  1890};
     const int pResN2[] = {  1, -2,  -7,  -14,   -23};        // with negate
     const int mResN2[] = { -2,  6, -30,  210, -1890};
     const unsigned sa = sizeof(ia) / sizeof(ia[0]);
@@ -149,7 +149,7 @@ void basic_tests()
 int main()
 {
     basic_tests();
-    
+
 //  All the iterator categories
     test<input_iterator        <const int*> >();
     test<forward_iterator      <const int*> >();
diff --git a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
index b05792ddeb55..418c57f7cfca 100644
--- a/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
+++ b/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp
@@ -21,37 +21,37 @@
 
 #include "test_iterators.h"
 
-template <class _Tp = void>
-struct identity : std::unary_function<_Tp, _Tp>
+template <class T = void>
+struct identity : std::unary_function<T, T>
 {
-    constexpr const _Tp& operator()(const _Tp& __x) const { return __x;}
+    constexpr const T& operator()(const T& x) const { return x;}
 };
 
 template <>
 struct identity<void>
 {
-    template <class _Tp>
-    constexpr auto operator()(_Tp&& __x) const
-    _NOEXCEPT_(noexcept(_VSTD::forward<_Tp>(__x)))
-    -> decltype        (_VSTD::forward<_Tp>(__x))
-        { return        _VSTD::forward<_Tp>(__x); }
+    template <class T>
+    constexpr auto operator()(T&& x) const
+    _NOEXCEPT_(noexcept(_VSTD::forward<T>(x)))
+    -> decltype        (_VSTD::forward<T>(x))
+        { return        _VSTD::forward<T>(x); }
 };
 
 
-template <class _Tp = void>
+template <class T = void>
 struct twice
 {
-  	constexpr const _Tp operator()(const _Tp& __x) const noexcept { return 2 * __x; }
+    constexpr const T operator()(const T& x) const noexcept { return 2 * x; }
 };
 
 template <>
 struct twice<void>
 {
-    template <class _Tp>
-    constexpr auto operator()(const _Tp& __x) const
-    _NOEXCEPT_(noexcept(2 * __x))
-    -> decltype        (2 * __x)
-        { return        2 * __x; }
+    template <class T>
+    constexpr auto operator()(const T& x) const
+    _NOEXCEPT_(noexcept(2 * x))
+    -> decltype        (2 * x)
+        { return        2 * x; }
 };
 
 template <class Iter1, class T, class BOp, class UOp>
@@ -115,10 +115,10 @@ int main()
     test<const int*>();
     test<      int*>();
 
-//	Make sure the math is done using the correct type
+//  Make sure the math is done using the correct type
     {
     auto v = {1, 2, 3, 4, 5, 6};
     unsigned res = std::transform_reduce(v.begin(), v.end(), 1U, std::multiplies<>(), twice<>());
-    assert(res == 46080);		// 6! * 64 will not fit into a char
+    assert(res == 46080);       // 6! * 64 will not fit into a char
     }
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/assign.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/assign.pass.cpp
index 18c8947af6ee..5238915ee89f 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/assign.pass.cpp
@@ -22,7 +22,7 @@ test1()
 {
     typedef std::ranlux24 E;
     E e1(2);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
@@ -38,7 +38,7 @@ test2()
 {
     typedef std::ranlux48 E;
     E e1(3);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp
index d6c64fa37dcc..80417e5d6d73 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/copy.pass.cpp
@@ -22,7 +22,7 @@ test1()
 {
     typedef std::ranlux24 E;
     E e1;
-    e1();
+    (void)e1();
     E e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
@@ -37,7 +37,7 @@ test2()
 {
     typedef std::ranlux48 E;
     E e1;
-    e1();
+    (void)e1();
     E e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/discard.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/discard.pass.cpp
index 2dada0d6345f..d10b7c5e8a31 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/discard.pass.cpp
@@ -25,9 +25,9 @@ test1()
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
@@ -39,9 +39,9 @@ test2()
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
index 8cc523e2fc07..5666fdce28d6 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.disc/values.pass.cpp
@@ -28,8 +28,8 @@
 
 #include "test_macros.h"
 
-template <class _Tp>
-void where(const _Tp &) {}
+template <class T>
+void where(const T &) {}
 
 void
 test1()
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp
index e4cd4f7396be..4484b3db4e4e 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp
@@ -22,7 +22,7 @@ test1()
 {
     typedef std::independent_bits_engine<std::ranlux24, 32, unsigned> E;
     E e1(2);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
@@ -38,7 +38,7 @@ test2()
 {
     typedef std::independent_bits_engine<std::ranlux48, 64, unsigned long long> E;
     E e1(3);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp
index e3e497ec8c6e..6a01af4bf39c 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp
@@ -22,7 +22,7 @@ test1()
 {
     typedef std::independent_bits_engine<std::ranlux24, 32, unsigned> E;
     E e1;
-    e1();
+    (void)e1();
     E e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
@@ -37,7 +37,7 @@ test2()
 {
     typedef std::independent_bits_engine<std::ranlux48, 64, unsigned long long> E;
     E e1;
-    e1();
+    (void)e1();
     E e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp
index 2a356a1c80db..a1b4dd7d7aee 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp
@@ -25,9 +25,9 @@ test1()
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
@@ -39,9 +39,9 @@ test2()
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp
index dae8c7c919af..652e6487a4e0 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/assign.pass.cpp
@@ -22,7 +22,7 @@ test1()
 {
     typedef std::knuth_b E;
     E e1(2);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp
index c9e9893dee4b..de26e2dc7861 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/copy.pass.cpp
@@ -22,7 +22,7 @@ test1()
 {
     typedef std::knuth_b E;
     E e1;
-    e1();
+    (void)e1();
     E e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp
index a20c494f334c..e71aa1d893bd 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_copy.pass.cpp
@@ -24,8 +24,10 @@ int main()
         typedef std::knuth_b Adaptor;
         Engine e;
         Adaptor a(e);
-        for (unsigned k = 0; k <= Adaptor::table_size; ++k)
-            e();
+        for (unsigned k = 0; k <= Adaptor::table_size; ++k) {
+            (void)e();
+        }
+
         assert(a.base() == e);
     }
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp
index 9811787821d9..4a347b5d5b8e 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_engine_move.pass.cpp
@@ -25,8 +25,10 @@ int main()
         Engine e;
         Engine e0 = e;
         Adaptor a(std::move(e0));
-        for (unsigned k = 0; k <= Adaptor::table_size; ++k)
-            e();
+        for (unsigned k = 0; k <= Adaptor::table_size; ++k) {
+            (void)e();
+        }
+
         assert(a.base() == e);
     }
 }
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp
index 6e04e26c7e55..b442a76adb63 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/discard.pass.cpp
@@ -25,9 +25,9 @@ test1()
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
diff --git a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
index c592b6df2d6e..ac3f1d7112d1 100644
--- a/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
+++ b/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/values.pass.cpp
@@ -27,8 +27,8 @@
 
 #include "test_macros.h"
 
-template <class _Tp>
-void where(const _Tp &) {}
+template <class T>
+void where(const T &) {}
 
 void
 test1()
diff --git a/test/std/numerics/rand/rand.device/eval.pass.cpp b/test/std/numerics/rand/rand.device/eval.pass.cpp
index b34e40c75273..56690316c129 100644
--- a/test/std/numerics/rand/rand.device/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.device/eval.pass.cpp
@@ -38,7 +38,7 @@ int main()
     try
     {
         std::random_device r("/dev/null");
-        r();
+        (void)r();
         LIBCPP_ASSERT(false);
     }
     catch (const std::system_error&)
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp
index cfaddb73f0b8..82e8ffc77a40 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp
@@ -33,7 +33,6 @@ void
 test1()
 {
     typedef std::lognormal_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d(-1./8192, 0.015625);
@@ -78,7 +77,6 @@ void
 test2()
 {
     typedef std::lognormal_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d(-1./32, 0.25);
@@ -123,7 +121,6 @@ void
 test3()
 {
     typedef std::lognormal_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d(-1./8, 0.5);
@@ -168,7 +165,6 @@ void
 test4()
 {
     typedef std::lognormal_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d;
@@ -213,7 +209,6 @@ void
 test5()
 {
     typedef std::lognormal_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d(-0.78125, 1.25);
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp
index b207eece67d0..6ae2301807d6 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/eval.pass.cpp
@@ -33,7 +33,6 @@ int main()
 {
     {
         typedef std::student_t_distribution<> D;
-        typedef D::param_type P;
         typedef std::minstd_rand G;
         G g;
         D d(5.5);
@@ -69,7 +68,6 @@ int main()
     }
     {
         typedef std::student_t_distribution<> D;
-        typedef D::param_type P;
         typedef std::minstd_rand G;
         G g;
         D d(10);
@@ -105,7 +103,6 @@ int main()
     }
     {
         typedef std::student_t_distribution<> D;
-        typedef D::param_type P;
         typedef std::minstd_rand G;
         G g;
         D d(100);
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp
index 3999cbeccbb7..ecc663c6c90c 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp
@@ -33,7 +33,6 @@ void
 test1()
 {
     typedef std::extreme_value_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d(0.5, 2);
@@ -75,7 +74,6 @@ void
 test2()
 {
     typedef std::extreme_value_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d(1, 2);
@@ -117,7 +115,6 @@ void
 test3()
 {
     typedef std::extreme_value_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d(1.5, 3);
@@ -159,7 +156,6 @@ void
 test4()
 {
     typedef std::extreme_value_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937 G;
     G g;
     D d(3, 4);
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp
index d0ac16298e42..15d3a289b570 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/eval.pass.cpp
@@ -33,7 +33,6 @@ int main()
 {
     {
         typedef std::gamma_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(0.5, 2);
@@ -73,7 +72,6 @@ int main()
     }
     {
         typedef std::gamma_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(1, .5);
@@ -113,7 +111,6 @@ int main()
     }
     {
         typedef std::gamma_distribution<> D;
-        typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
         D d(2, 3);
diff --git a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
index 7da4b9bfb1e5..d97898e5f446 100644
--- a/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
+++ b/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
@@ -44,7 +44,6 @@ void
 test1()
 {
     typedef std::piecewise_linear_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937_64 G;
     G g;
     double b[] = {10, 14, 16, 17};
@@ -97,7 +96,6 @@ void
 test2()
 {
     typedef std::piecewise_linear_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937_64 G;
     G g;
     double b[] = {10, 14, 16, 17};
@@ -150,7 +148,6 @@ void
 test3()
 {
     typedef std::piecewise_linear_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937_64 G;
     G g;
     double b[] = {10, 14, 16, 17};
@@ -203,7 +200,6 @@ void
 test4()
 {
     typedef std::piecewise_linear_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937_64 G;
     G g;
     double b[] = {10, 14, 16};
@@ -257,7 +253,6 @@ void
 test5()
 {
     typedef std::piecewise_linear_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937_64 G;
     G g;
     double b[] = {10, 14};
@@ -312,7 +307,6 @@ void
 test6()
 {
     typedef std::piecewise_linear_distribution<> D;
-    typedef D::param_type P;
     typedef std::mt19937_64 G;
     G g;
     double b[] = {10, 14, 16, 17};
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp
index 9e3372a8c2b4..0a36fcb71a72 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/discard.pass.cpp
@@ -47,13 +47,13 @@ other()
     assert(e1 == e2);
     e1.discard(1);
     assert(e1 != e2);
-    e2();
+    (void)e2();
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
index 2080ac5f41de..72d5854b7655 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
@@ -27,8 +27,8 @@
 
 #include "test_macros.h"
 
-template <class _Tp>
-void where(const _Tp &) {}
+template <class T>
+void where(const T &) {}
 
 template <class T, T a, T c, T m>
 void
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp
index fda5b88de26e..63d7168f5bf4 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp
@@ -24,7 +24,7 @@ test1()
 {
     typedef std::mt19937 E;
     E e1(2);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
@@ -40,7 +40,7 @@ test2()
 {
     typedef std::mt19937_64 E;
     E e1(3);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp
index 57c015ccce1d..a006b33243c9 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp
@@ -24,7 +24,7 @@ test1()
 {
     typedef std::mt19937 E;
     E e1;
-    e1();
+    (void)e1();
     E e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
@@ -39,7 +39,7 @@ test2()
 {
     typedef std::mt19937_64 E;
     E e1;
-    e1();
+    (void)e1();
     E e2(e1);
     assert(e1 == e2);
     assert(e1() == e2());
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp
index d20d661d5891..480260d8bf45 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp
@@ -28,9 +28,9 @@ test1()
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
@@ -42,9 +42,9 @@ test2()
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
index f7834afd4454..08d99b3d8acb 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
@@ -42,8 +42,8 @@
 
 #include "test_macros.h"
 
-template <class _Tp>
-void where(const _Tp &) {}
+template <class T>
+void where(const T &) {}
 
 void
 test1()
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp
index 305d43ad4a22..60fec44629ec 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/assign.pass.cpp
@@ -22,7 +22,7 @@ test1()
 {
     typedef std::ranlux24_base E;
     E e1(2);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
@@ -38,7 +38,7 @@ test2()
 {
     typedef std::ranlux48_base E;
     E e1(3);
-    e1();
+    (void)e1();
     E e2(5);
     e2 = e1;
     assert(e1 == e2);
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp
index 27f88165bcf5..5944716b6ac4 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/copy.pass.cpp
@@ -22,7 +22,7 @@ test1()
 {
     typedef std::ranlux24_base E;
     E e1;
-    e1();
+    (void)e1();
     E e2 = e1;
     assert(e1 == e2);
     assert(e1() == e2());
@@ -37,7 +37,7 @@ test2()
 {
     typedef std::ranlux48_base E;
     E e1;
-    e1();
+    (void)e1();
     E e2(e1);
     assert(e1 == e2);
     assert(e1() == e2());
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp
index 4ba93819ee43..ad33fc15118c 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/discard.pass.cpp
@@ -25,9 +25,9 @@ test1()
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
@@ -39,9 +39,9 @@ test2()
     assert(e1 == e2);
     e1.discard(3);
     assert(e1 != e2);
-    e2();
-    e2();
-    e2();
+    (void)e2();
+    (void)e2();
+    (void)e2();
     assert(e1 == e2);
 }
 
diff --git a/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp b/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
index 6b8b4eed97a9..02f8b222d7d3 100644
--- a/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
+++ b/test/std/numerics/rand/rand.eng/rand.eng.sub/values.pass.cpp
@@ -30,8 +30,8 @@
 
 #include "test_macros.h"
 
-template <class _Tp>
-void where(const _Tp &) {}
+template <class T>
+void where(const T &) {}
 
 void
 test1()
diff --git a/test/std/re/re.alg/re.alg.match/exponential.pass.cpp b/test/std/re/re.alg/re.alg.match/exponential.pass.cpp
new file mode 100644
index 000000000000..f7a6f91efe04
--- /dev/null
+++ b/test/std/re/re.alg/re.alg.match/exponential.pass.cpp
@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <regex>
+// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: c++98, c++03
+
+// template <class BidirectionalIterator, class Allocator, class charT, class traits>
+//     bool
+//     regex_match(BidirectionalIterator first, BidirectionalIterator last,
+//                  match_results<BidirectionalIterator, Allocator>& m,
+//                  const basic_regex<charT, traits>& e,
+//                  regex_constants::match_flag_type flags = regex_constants::match_default);
+
+// Throw exception after spent too many cycles with respect to the length of the input string.
+
+#include <regex>
+#include <cassert>
+
+int main() {
+  for (std::regex_constants::syntax_option_type op :
+       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
+        std::regex::awk}) {
+    try {
+      std::regex_match(
+          "aaaaaaaaaaaaaaaaaaaa",
+          std::regex(
+              "a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa",
+              op));
+      assert(false);
+    } catch (const std::regex_error &e) {
+      assert(e.code() == std::regex_constants::error_complexity);
+    }
+  }
+  std::string s(100000, 'a');
+  for (std::regex_constants::syntax_option_type op :
+       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
+        std::regex::awk}) {
+    assert(std::regex_match(s, std::regex("a*", op)));
+  }
+  return 0;
+}
diff --git a/test/std/re/re.alg/re.alg.search/exponential.pass.cpp b/test/std/re/re.alg/re.alg.search/exponential.pass.cpp
new file mode 100644
index 000000000000..e22aa358b79b
--- /dev/null
+++ b/test/std/re/re.alg/re.alg.search/exponential.pass.cpp
@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <regex>
+// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: c++98, c++03
+
+// template <class BidirectionalIterator, class Allocator, class charT, class traits>
+//     bool
+//     regex_search(BidirectionalIterator first, BidirectionalIterator last,
+//                  match_results<BidirectionalIterator, Allocator>& m,
+//                  const basic_regex<charT, traits>& e,
+//                  regex_constants::match_flag_type flags = regex_constants::match_default);
+
+// Throw exception after spent too many cycles with respect to the length of the input string.
+
+#include <regex>
+#include <cassert>
+
+int main() {
+  for (std::regex_constants::syntax_option_type op :
+       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
+        std::regex::awk}) {
+    try {
+      std::regex_search(
+          "aaaaaaaaaaaaaaaaaaaa",
+          std::regex(
+              "a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaa",
+              op));
+      assert(false);
+    } catch (const std::regex_error &e) {
+      assert(e.code() == std::regex_constants::error_complexity);
+    }
+  }
+  std::string s(100000, 'a');
+  for (std::regex_constants::syntax_option_type op :
+       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
+        std::regex::awk}) {
+    assert(std::regex_search(s, std::regex("a*", op)));
+  }
+  return 0;
+}
diff --git a/test/std/re/re.alg/re.alg.search/grep.pass.cpp b/test/std/re/re.alg/re.alg.search/grep.pass.cpp
index fa4e675c78f0..0040f7bfa089 100644
--- a/test/std/re/re.alg/re.alg.search/grep.pass.cpp
+++ b/test/std/re/re.alg/re.alg.search/grep.pass.cpp
@@ -33,7 +33,7 @@ extern "C" void LLVMFuzzerTestOneInput(const char *data)
             std::regex::flag_type flag = std::regex_constants::grep;
             std::string s((const char *)data, size);
             std::regex re(s, flag);
-            std::regex_match(s, re);
+            TEST_IGNORE_NODISCARD std::regex_match(s, re);
         }
         catch (std::regex_error &) {}
     }
diff --git a/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp b/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp
new file mode 100644
index 000000000000..dd17d3519e3e
--- /dev/null
+++ b/test/std/re/re.alg/re.alg.search/invert_neg_word_search.pass.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <regex>
+
+// template <class BidirectionalIterator, class Allocator, class charT, class traits>
+//     bool
+//     regex_search(BidirectionalIterator first, BidirectionalIterator last,
+//                  match_results<BidirectionalIterator, Allocator>& m,
+//                  const basic_regex<charT, traits>& e,
+//                  regex_constants::match_flag_type flags = regex_constants::match_default);
+
+#include <regex>
+#include <cassert>
+#include "test_macros.h"
+
+// PR34310
+int main()
+{
+  assert(std::regex_search("HelloWorld", std::regex("[^\\W]")));
+  assert(std::regex_search("_", std::regex("[^\\W]")));
+  return 0;
+}
diff --git a/test/std/re/re.grammar/excessive_brace_count.pass.cpp b/test/std/re/re.grammar/excessive_brace_count.pass.cpp
new file mode 100644
index 000000000000..597182e7e096
--- /dev/null
+++ b/test/std/re/re.grammar/excessive_brace_count.pass.cpp
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <regex>
+// UNSUPPORTED: libcpp-no-exceptions
+// UNSUPPORTED: c++03
+
+// the "n" in `a{n}` should be within the numeric limits.
+
+#include <regex>
+#include <cassert>
+#include "test_macros.h"
+
+int main() {
+  for (std::regex_constants::syntax_option_type op :
+       {std::regex::basic, std::regex::grep}) {
+    try {
+      TEST_IGNORE_NODISCARD std::regex("a\\{100000000000000000\\}", op);
+      assert(false);
+    } catch (const std::regex_error &e) {
+      assert(e.code() == std::regex_constants::error_badbrace);
+    }
+  }
+  for (std::regex_constants::syntax_option_type op :
+       {std::regex::ECMAScript, std::regex::extended, std::regex::egrep,
+        std::regex::awk}) {
+    try {
+      TEST_IGNORE_NODISCARD std::regex("a{100000000000000000}", op);
+      assert(false);
+    } catch (const std::regex_error &e) {
+      assert(e.code() == std::regex_constants::error_badbrace);
+    }
+  }
+  return 0;
+}
diff --git a/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp b/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
index 5e3ad4d910e7..f92fd880135e 100644
--- a/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
+++ b/test/std/re/re.iter/re.regiter/re.regiter.incr/post.pass.cpp
@@ -95,7 +95,7 @@ int main()
         assert((*i2).position() == 0);
         assert((*i2).str() == "555-1234");
     }
-    { // http://llvm.org/PR33681
+    { // https://bugs.llvm.org/show_bug.cgi?id=33681
         std::regex rex(".*");
         const char foo[] = "foo";
     //  The -1 is because we don't want the implicit null from the array.
diff --git a/test/std/re/re.regex/re.regex.const/constants.pass.cpp b/test/std/re/re.regex/re.regex.const/constants.pass.cpp
index e699de819b0d..42bc526aed04 100644
--- a/test/std/re/re.regex/re.regex.const/constants.pass.cpp
+++ b/test/std/re/re.regex/re.regex.const/constants.pass.cpp
@@ -29,8 +29,8 @@
 #include <type_traits>
 #include "test_macros.h"
 
-template <class _Tp>
-void where(const _Tp &) {}
+template <class T>
+void where(const T &) {}
 
 template <class CharT>
 void
diff --git a/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp b/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
index e66d3e976db2..8e886cd8d1a7 100644
--- a/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
+++ b/test/std/re/re.regex/re.regex.construct/bad_backref.pass.cpp
@@ -34,6 +34,7 @@ int main()
 {
     assert(error_badbackref_thrown("\\1abc"));      // no references
     assert(error_badbackref_thrown("ab(c)\\2def")); // only one reference
+    assert(error_badbackref_thrown("\\800000000000000000000000000000")); // overflows
 
 //  this should NOT throw, because we only should look at the '1'
 //  See https://bugs.llvm.org/show_bug.cgi?id=31387
diff --git a/test/std/re/re.results/re.results.size/empty.fail.cpp b/test/std/re/re.results/re.results.size/empty.fail.cpp
new file mode 100644
index 000000000000..6f677f3907ab
--- /dev/null
+++ b/test/std/re/re.results/re.results.size/empty.fail.cpp
@@ -0,0 +1,27 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <regex>
+
+// class match_results<BidirectionalIterator, Allocator>
+// bool empty() const;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <regex>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::match_results<const char*> c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/strings/basic.string/string.access/at.pass.cpp b/test/std/strings/basic.string/string.access/at.pass.cpp
index 891648930e3c..16121cbf6bbf 100644
--- a/test/std/strings/basic.string/string.access/at.pass.cpp
+++ b/test/std/strings/basic.string/string.access/at.pass.cpp
@@ -35,7 +35,7 @@ test(S s, typename S::size_type pos)
     {
         try
         {
-            s.at(pos);
+            TEST_IGNORE_NODISCARD s.at(pos);
             assert(false);
         }
         catch (std::out_of_range&)
@@ -44,7 +44,7 @@ test(S s, typename S::size_type pos)
         }
         try
         {
-            cs.at(pos);
+            TEST_IGNORE_NODISCARD cs.at(pos);
             assert(false);
         }
         catch (std::out_of_range&)
diff --git a/test/std/strings/basic.string/string.capacity/empty.fail.cpp b/test/std/strings/basic.string/string.capacity/empty.fail.cpp
new file mode 100644
index 000000000000..addb02ed3cbc
--- /dev/null
+++ b/test/std/strings/basic.string/string.capacity/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// class deque
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <string>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::string c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/strings/basic.string/string.capacity/empty.pass.cpp b/test/std/strings/basic.string/string.capacity/empty.pass.cpp
index fbed5c36c3f4..a61a410a444a 100644
--- a/test/std/strings/basic.string/string.capacity/empty.pass.cpp
+++ b/test/std/strings/basic.string/string.capacity/empty.pass.cpp
@@ -9,17 +9,19 @@
 
 // <string>
 
-// bool empty() const;
+// bool empty() const noexcept;
 
 #include <string>
 #include <cassert>
 
+#include "test_macros.h"
 #include "min_allocator.h"
 
 template <class S>
 void
 test(const S& s)
 {
+    ASSERT_NOEXCEPT(s.empty());
     assert(s.empty() == (s.size() == 0));
 }
 
diff --git a/test/std/strings/basic.string/string.cons/alloc.pass.cpp b/test/std/strings/basic.string/string.cons/alloc.pass.cpp
index 81537ba52bb6..9e3fb0722604 100644
--- a/test/std/strings/basic.string/string.cons/alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/alloc.pass.cpp
@@ -24,9 +24,9 @@ test()
 {
     {
 #if TEST_STD_VER > 14
-	static_assert((noexcept(S{})), "" );
+    static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
-	static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
+    static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
 #endif
     S s;
     LIBCPP_ASSERT(s.__invariants());
@@ -37,9 +37,9 @@ test()
     }
     {
 #if TEST_STD_VER > 14
-	static_assert((noexcept(S{typename S::allocator_type{}})), "" );
+    static_assert((noexcept(S{typename S::allocator_type{}})), "" );
 #elif TEST_STD_VER >= 11
-	static_assert((noexcept(S(typename S::allocator_type())) == std::is_nothrow_copy_constructible<typename S::allocator_type>::value), "" );
+    static_assert((noexcept(S(typename S::allocator_type())) == std::is_nothrow_copy_constructible<typename S::allocator_type>::value), "" );
 #endif
     S s(typename S::allocator_type(5));
     LIBCPP_ASSERT(s.__invariants());
@@ -58,9 +58,9 @@ test2()
 {
     {
 #if TEST_STD_VER > 14
-	static_assert((noexcept(S{})), "" );
+    static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
-	static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
+    static_assert((noexcept(S()) == noexcept(typename S::allocator_type())), "" );
 #endif
     S s;
     LIBCPP_ASSERT(s.__invariants());
@@ -71,9 +71,9 @@ test2()
     }
     {
 #if TEST_STD_VER > 14
-	static_assert((noexcept(S{typename S::allocator_type{}})), "" );
+    static_assert((noexcept(S{typename S::allocator_type{}})), "" );
 #elif TEST_STD_VER >= 11
-	static_assert((noexcept(S(typename S::allocator_type())) == std::is_nothrow_copy_constructible<typename S::allocator_type>::value), "" );
+    static_assert((noexcept(S(typename S::allocator_type())) == std::is_nothrow_copy_constructible<typename S::allocator_type>::value), "" );
 #endif
     S s(typename S::allocator_type{});
     LIBCPP_ASSERT(s.__invariants());
diff --git a/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
index 982bb43289d7..edd5c6e32d56 100644
--- a/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/copy_alloc.pass.cpp
@@ -69,9 +69,9 @@ bool operator!=(const poca_alloc<T>& lhs, const poca_alloc<U>& rhs)
 template <class S>
 void test_assign(S &s1, const S& s2)
 {
-	try { s1 = s2; }
-	catch ( std::bad_alloc &) { return; }
-	assert(false);
+    try { s1 = s2; }
+    catch ( std::bad_alloc &) { return; }
+    assert(false);
 }
 #endif
 
@@ -110,21 +110,21 @@ int main()
     {
     typedef poca_alloc<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
-	const char * p1 = "This is my first string";
-	const char * p2 = "This is my second string";
+    const char * p1 = "This is my first string";
+    const char * p2 = "This is my second string";
 
     alloc_imp<char> imp1;
     alloc_imp<char> imp2;
-	S s1(p1, A(&imp1));
-	S s2(p2, A(&imp2));
+    S s1(p1, A(&imp1));
+    S s2(p2, A(&imp2));
 
-	assert(s1 == p1);
-	assert(s2 == p2);
+    assert(s1 == p1);
+    assert(s2 == p2);
 
-	imp2.deactivate();
-	test_assign(s1, s2);
-	assert(s1 == p1);
-	assert(s2 == p2);
+    imp2.deactivate();
+    test_assign(s1, s2);
+    assert(s1 == p1);
+    assert(s2 == p2);
     }
 #endif
 #endif
diff --git a/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp b/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
index d4866921af7a..bb7bdcd1434f 100644
--- a/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move_alloc.pass.cpp
@@ -41,9 +41,9 @@ int main()
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14
-	static_assert((noexcept(S{})), "" );
+    static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
-	static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
+    static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
 #endif
     test(S(), A(3));
     test(S("1"), A(5));
@@ -55,9 +55,9 @@ int main()
     typedef test_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14
-	static_assert((noexcept(S{})), "" );
+    static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
-	static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
+    static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
 #endif
     S s1 ( "Twas brillig, and the slivy toves did gyre and gymbal in the wabe" );
     S s2 (std::move(s1), A(1));
@@ -67,9 +67,9 @@ int main()
     typedef min_allocator<char> A;
     typedef std::basic_string<char, std::char_traits<char>, A> S;
 #if TEST_STD_VER > 14
-	static_assert((noexcept(S{})), "" );
+    static_assert((noexcept(S{})), "" );
 #elif TEST_STD_VER >= 11
-	static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
+    static_assert((noexcept(S()) == std::is_nothrow_move_constructible<A>::value), "" );
 #endif
     test(S(), A());
     test(S("1"), A());
diff --git a/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp b/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
index 136a60fe627b..0720543420a8 100644
--- a/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.cons/move_assign_noexcept.pass.cpp
@@ -16,7 +16,7 @@
 //         allocator_traits<allocator_type>::propagate_on_container_move_assignment::value ||
 //         allocator_traits<allocator_type>::is_always_equal::value); // C++17
 //
-//	before C++17, we use the conforming extension
+//  before C++17, we use the conforming extension
 //     noexcept(
 //         allocator_type::propagate_on_container_move_assignment::value &&
 //         is_nothrow_move_assignable<allocator_type>::value);
@@ -81,12 +81,12 @@ int main()
     }
 #if TEST_STD_VER > 14
     {
-    //	POCMA is false, always equal
+    //  POCMA is false, always equal
         typedef std::basic_string<char, std::char_traits<char>, some_alloc2<char>> C;
         static_assert( std::is_nothrow_move_assignable<C>::value, "");
     }
     {
-    //	POCMA is false, not always equal
+    //  POCMA is false, not always equal
         typedef std::basic_string<char, std::char_traits<char>, some_alloc3<char>> C;
         static_assert(!std::is_nothrow_move_assignable<C>::value, "");
     }
diff --git a/test/std/strings/basic.string/string.cons/string_view.fail.cpp b/test/std/strings/basic.string/string.cons/string_view.fail.cpp
index 70459b2dcfb4..3d3bf4178fd2 100644
--- a/test/std/strings/basic.string/string.cons/string_view.fail.cpp
+++ b/test/std/strings/basic.string/string.cons/string_view.fail.cpp
@@ -18,6 +18,6 @@ void foo ( const string &s ) {}
 
 int main()
 {
-	std::string_view sv = "ABCDE";
-	foo(sv);	// requires implicit conversion from string_view to string
+    std::string_view sv = "ABCDE";
+    foo(sv);    // requires implicit conversion from string_view to string
 }
diff --git a/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp b/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
new file mode 100644
index 000000000000..1d400b79b1c8
--- /dev/null
+++ b/test/std/strings/basic.string/string.cons/string_view_assignment.pass.cpp
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// basic_string<charT,traits,Allocator>& operator=(basic_string_view<charT, traits> sv);
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S, class SV>
+void
+test(S s1, SV sv)
+{
+    typedef typename S::traits_type T;
+    s1 = sv;
+    LIBCPP_ASSERT(s1.__invariants());
+    assert(s1.size() == sv.size());
+    assert(T::compare(s1.data(), sv.data(), s1.size()) == 0);
+    assert(s1.capacity() >= s1.size());
+}
+
+int main()
+{
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
+    test(S(), SV(""));
+    test(S("1"), SV(""));
+    test(S(), SV("1"));
+    test(S("1"), SV("2"));
+    test(S("1"), SV("2"));
+
+    test(S(),
+         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
+    test(S("123456789"),
+         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
+    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
+         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
+    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
+           "1234567890123456789012345678901234567890123456789012345678901234567890"),
+         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    typedef std::string_view SV;
+    test(S(), SV(""));
+    test(S("1"), SV(""));
+    test(S(), SV("1"));
+    test(S("1"), SV("2"));
+    test(S("1"), SV("2"));
+
+    test(S(),
+         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
+    test(S("123456789"),
+         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
+    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"),
+         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
+    test(S("1234567890123456789012345678901234567890123456789012345678901234567890"
+           "1234567890123456789012345678901234567890123456789012345678901234567890"),
+         SV("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
+    }
+#endif
+}
diff --git a/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp b/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
new file mode 100644
index 000000000000..6091e0c066d3
--- /dev/null
+++ b/test/std/strings/basic.string/string.ends_with/ends_with.char.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+//   bool ends_with(charT x) const noexcept;
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    {
+    typedef std::string S;
+    S  s1 {};
+    S  s2 { "abcde", 5 };
+
+    ASSERT_NOEXCEPT(s1.ends_with('e'));
+
+    assert (!s1.ends_with('e'));
+    assert (!s1.ends_with('x'));
+    assert ( s2.ends_with('e'));
+    assert (!s2.ends_with('x'));
+    }
+}
diff --git a/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp b/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
new file mode 100644
index 000000000000..b1f5fcd50cf3
--- /dev/null
+++ b/test/std/strings/basic.string/string.ends_with/ends_with.ptr.pass.cpp
@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+//   bool ends_with(const CharT *x) const;
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    {
+    typedef std::string S;
+    const char *s = "abcde";
+
+    S   s0;
+    S   s1  { s + 4, 1 };
+    S   s2  { s + 3, 2 };
+//  S   s3  { s + 2, 3 };
+//  S   s4  { s + 1, 4 };
+//  S   s5  { s,     5 };
+    S  sNot { "def", 3 };
+
+    LIBCPP_ASSERT_NOEXCEPT(s0.ends_with(""));
+
+    assert ( s0.ends_with(""));
+    assert (!s0.ends_with("e"));
+
+    assert ( s1.ends_with(""));
+    assert ( s1.ends_with("e"));
+    assert (!s1.ends_with("de"));
+    assert (!s1.ends_with("cde"));
+    assert (!s1.ends_with("bcde"));
+    assert (!s1.ends_with("abcde"));
+    assert (!s1.ends_with("def"));
+
+    assert ( s2.ends_with(""));
+    assert ( s2.ends_with("e"));
+    assert ( s2.ends_with("de"));
+    assert (!s2.ends_with("cde"));
+    assert (!s2.ends_with("bcde"));
+    assert (!s2.ends_with("abcde"));
+    assert (!s2.ends_with("def"));
+
+    assert ( sNot.ends_with(""));
+    assert (!sNot.ends_with("e"));
+    assert (!sNot.ends_with("de"));
+    assert (!sNot.ends_with("cde"));
+    assert (!sNot.ends_with("bcde"));
+    assert (!sNot.ends_with("abcde"));
+    assert ( sNot.ends_with("def"));
+    }
+}
diff --git a/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp b/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
new file mode 100644
index 000000000000..4bbd4bc864b2
--- /dev/null
+++ b/test/std/strings/basic.string/string.ends_with/ends_with.string_view.pass.cpp
@@ -0,0 +1,72 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+//   bool ends_with(basic_string_view x) const noexcept;
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
+    const char *s = "abcde";
+
+    S   s0;
+    S   s1  { s + 4, 1 };
+    S   s2  { s + 3, 2 };
+//  S   s3  { s + 2, 3 };
+//  S   s4  { s + 1, 4 };
+//  S   s5  { s,     5 };
+    S  sNot { "def", 3 };
+
+    SV  sv0;
+    SV  sv1 { s + 4, 1 };
+    SV  sv2 { s + 3, 2 };
+    SV  sv3 { s + 2, 3 };
+    SV  sv4 { s + 1, 4 };
+    SV  sv5 { s    , 5 };
+    SV svNot {"def", 3 };
+
+    ASSERT_NOEXCEPT(s0.ends_with(sv0));
+
+    assert ( s0.ends_with(sv0));
+    assert (!s0.ends_with(sv1));
+
+    assert ( s1.ends_with(sv0));
+    assert ( s1.ends_with(sv1));
+    assert (!s1.ends_with(sv2));
+    assert (!s1.ends_with(sv3));
+    assert (!s1.ends_with(sv4));
+    assert (!s1.ends_with(sv5));
+    assert (!s1.ends_with(svNot));
+
+    assert ( s2.ends_with(sv0));
+    assert ( s2.ends_with(sv1));
+    assert ( s2.ends_with(sv2));
+    assert (!s2.ends_with(sv3));
+    assert (!s2.ends_with(sv4));
+    assert (!s2.ends_with(sv5));
+    assert (!s2.ends_with(svNot));
+
+    assert ( sNot.ends_with(sv0));
+    assert (!sNot.ends_with(sv1));
+    assert (!sNot.ends_with(sv2));
+    assert (!sNot.ends_with(sv3));
+    assert (!sNot.ends_with(sv4));
+    assert (!sNot.ends_with(sv5));
+    assert ( sNot.ends_with(svNot));
+    }
+}
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
index b464291d4c5d..7ed55403927e 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
@@ -32,11 +32,11 @@ template <class S, class It>
 void
 test_exceptions(S s, It first, It last)
 {
-	S aCopy = s;
+    S aCopy = s;
     try {
-    	s.append(first, last);
-    	assert(false);
-    	}
+        s.append(first, last);
+        assert(false);
+        }
     catch (...) {}
     LIBCPP_ASSERT(s.__invariants());
     assert(s == aCopy);
@@ -164,7 +164,7 @@ int main()
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-	{ // test iterator operations that throw
+    { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef input_iterator<TIter> IIter;
@@ -176,33 +176,33 @@ int main()
     test_exceptions(S(), TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());
-	}
+    }
 #endif
 
-	{ // test appending to self
+    { // test appending to self
     typedef std::string S;
-	S s_short = "123/";
-	S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
-
-	s_short.append(s_short.begin(), s_short.end());
-	assert(s_short == "123/123/");
-	s_short.append(s_short.begin(), s_short.end());
-	assert(s_short == "123/123/123/123/");
-	s_short.append(s_short.begin(), s_short.end());
-	assert(s_short == "123/123/123/123/123/123/123/123/");
-
-	s_long.append(s_long.begin(), s_long.end());
-	assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-	}
+    S s_short = "123/";
+    S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
+
+    s_short.append(s_short.begin(), s_short.end());
+    assert(s_short == "123/123/");
+    s_short.append(s_short.begin(), s_short.end());
+    assert(s_short == "123/123/123/123/");
+    s_short.append(s_short.begin(), s_short.end());
+    assert(s_short == "123/123/123/123/123/123/123/123/");
+
+    s_long.append(s_long.begin(), s_long.end());
+    assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+    }
 
-	{ // test appending a different type
+    { // test appending a different type
     typedef std::string S;
-	const uint8_t p[] = "ABCD";
+    const uint8_t p[] = "ABCD";
 
-	S s;
-	s.append(p, p + 4);
-	assert(s == "ABCD");
-	}
+    S s;
+    s.append(p, p + 4);
+    assert(s == "ABCD");
+    }
 
   { // test with a move iterator that returns char&&
     typedef forward_iterator<const char*> It;
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
index eb552ca83928..823905df4a14 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/pointer.pass.cpp
@@ -62,19 +62,19 @@ int main()
     }
 #endif
 
-	{ // test appending to self
+    { // test appending to self
     typedef std::string S;
-	S s_short = "123/";
-	S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
+    S s_short = "123/";
+    S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
-	s_short.append(s_short.c_str());
-	assert(s_short == "123/123/");
-	s_short.append(s_short.c_str());
-	assert(s_short == "123/123/123/123/");
-	s_short.append(s_short.c_str());
-	assert(s_short == "123/123/123/123/123/123/123/123/");
+    s_short.append(s_short.c_str());
+    assert(s_short == "123/123/");
+    s_short.append(s_short.c_str());
+    assert(s_short == "123/123/123/123/");
+    s_short.append(s_short.c_str());
+    assert(s_short == "123/123/123/123/123/123/123/123/");
 
-	s_long.append(s_long.c_str());
-	assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-	}
+    s_long.append(s_long.c_str());
+    assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+    }
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
index fc80d7cccce6..f09ec682e9f9 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/pointer_size.pass.cpp
@@ -71,19 +71,19 @@ int main()
     }
 #endif
 
-	{ // test appending to self
+    { // test appending to self
     typedef std::string S;
-	S s_short = "123/";
-	S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
+    S s_short = "123/";
+    S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
-	s_short.append(s_short.data(), s_short.size());
-	assert(s_short == "123/123/");
-	s_short.append(s_short.data(), s_short.size());
-	assert(s_short == "123/123/123/123/");
-	s_short.append(s_short.data(), s_short.size());
-	assert(s_short == "123/123/123/123/123/123/123/123/");
+    s_short.append(s_short.data(), s_short.size());
+    assert(s_short == "123/123/");
+    s_short.append(s_short.data(), s_short.size());
+    assert(s_short == "123/123/123/123/");
+    s_short.append(s_short.data(), s_short.size());
+    assert(s_short == "123/123/123/123/123/123/123/123/");
 
-	s_long.append(s_long.data(), s_long.size());
-	assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-	}
+    s_long.append(s_long.data(), s_long.size());
+    assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+    }
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
index f2fb8782a21d..5ca5aaf8629c 100644
--- a/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_append/push_back.pass.cpp
@@ -17,6 +17,12 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
+struct veryLarge
+{
+  long long a;
+  char b;
+};
+
 template <class S>
 void
 test(S s, typename S::value_type c, S expected)
@@ -42,4 +48,14 @@ int main()
     test(S("12345678901234567890"), 'a', S("12345678901234567890a"));
     }
 #endif
+#if 0
+    {
+// https://bugs.llvm.org/show_bug.cgi?id=31454
+    std::basic_string<veryLarge> s;
+    veryLarge vl;
+    s.push_back(vl);
+    s.push_back(vl);
+    s.push_back(vl);
+    }
+#endif
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
index e5312e6db6ce..cb83f25d7117 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
@@ -33,10 +33,10 @@ template <class S, class It>
 void
 test_exceptions(S s, It first, It last)
 {
-	S aCopy = s;
+    S aCopy = s;
     try {
-   	    s.assign(first, last);
-    	assert(false);
+        s.assign(first, last);
+        assert(false);
     }
     catch (...) {}
     LIBCPP_ASSERT(s.__invariants());
@@ -165,7 +165,7 @@ int main()
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-	{ // test iterator operations that throw
+    { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef input_iterator<TIter> IIter;
@@ -177,32 +177,32 @@ int main()
     test_exceptions(S(), TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S(), TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), TIter(s, s+10, 6, TIter::TAComparison), TIter());
-	}
+    }
 #endif
 
-	{ // test assigning to self
+    { // test assigning to self
     typedef std::string S;
-	S s_short = "123/";
-	S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
+    S s_short = "123/";
+    S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
-	s_short.assign(s_short.begin(), s_short.end());
-	assert(s_short == "123/");
-	s_short.assign(s_short.begin() + 2, s_short.end());
-	assert(s_short == "3/");
+    s_short.assign(s_short.begin(), s_short.end());
+    assert(s_short == "123/");
+    s_short.assign(s_short.begin() + 2, s_short.end());
+    assert(s_short == "3/");
 
-	s_long.assign(s_long.begin(), s_long.end());
-	assert(s_long == "Lorem ipsum dolor sit amet, consectetur/");
+    s_long.assign(s_long.begin(), s_long.end());
+    assert(s_long == "Lorem ipsum dolor sit amet, consectetur/");
 
-	s_long.assign(s_long.begin() + 30, s_long.end());
-	assert(s_long == "nsectetur/");
-	}
+    s_long.assign(s_long.begin() + 30, s_long.end());
+    assert(s_long == "nsectetur/");
+    }
 
-	{ // test assigning a different type
+    { // test assigning a different type
     typedef std::string S;
-	const uint8_t p[] = "ABCD";
+    const uint8_t p[] = "ABCD";
 
-	S s;
-	s.assign(p, p + 4);
-	assert(s == "ABCD");
-	}
+    S s;
+    s.assign(p, p + 4);
+    assert(s == "ABCD");
+    }
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
index b0876b388d83..b592455a350e 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/pointer.pass.cpp
@@ -62,17 +62,17 @@ int main()
     }
 #endif
 
-	{ // test assignment to self
+    { // test assignment to self
     typedef std::string S;
-	S s_short = "123/";
-	S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
+    S s_short = "123/";
+    S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
-	s_short.assign(s_short.c_str());
-	assert(s_short == "123/");
-	s_short.assign(s_short.c_str() + 2);
-	assert(s_short == "3/");
+    s_short.assign(s_short.c_str());
+    assert(s_short == "123/");
+    s_short.assign(s_short.c_str() + 2);
+    assert(s_short == "3/");
 
-	s_long.assign(s_long.c_str() + 30);
-	assert(s_long == "nsectetur/");
-	}
+    s_long.assign(s_long.c_str() + 30);
+    assert(s_long == "nsectetur/");
+    }
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
index 97a9990f5180..70b00619a913 100644
--- a/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_assign/pointer_size.pass.cpp
@@ -70,20 +70,20 @@ int main()
          S("12345678901234567890"));
     }
 #endif
-	{ // test assign to self
+    { // test assign to self
     typedef std::string S;
-	S s_short = "123/";
-	S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
+    S s_short = "123/";
+    S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
-	s_short.assign(s_short.data(), s_short.size());
-	assert(s_short == "123/");
-	s_short.assign(s_short.data() + 2, s_short.size() - 2);
-	assert(s_short == "3/");
+    s_short.assign(s_short.data(), s_short.size());
+    assert(s_short == "123/");
+    s_short.assign(s_short.data() + 2, s_short.size() - 2);
+    assert(s_short == "3/");
 
-	s_long.assign(s_long.data(), s_long.size());
-	assert(s_long == "Lorem ipsum dolor sit amet, consectetur/");
+    s_long.assign(s_long.data(), s_long.size());
+    assert(s_long == "Lorem ipsum dolor sit amet, consectetur/");
 
-	s_long.assign(s_long.data() + 2, 8 );
-	assert(s_long == "rem ipsu");
-	}
+    s_long.assign(s_long.data() + 2, 8 );
+    assert(s_long == "rem ipsu");
+    }
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
index 2c8b6e4a1882..cb4b40f9e8cf 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
@@ -39,7 +39,7 @@ void
 test_exceptions(S s, typename S::difference_type pos, It first, It last)
 {
     typename S::const_iterator p = s.cbegin() + pos;
-	S aCopy = s;
+    S aCopy = s;
     try {
         s.insert(p, first, last);
         assert(false);
@@ -145,7 +145,7 @@ int main()
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-	{ // test iterator operations that throw
+    { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef input_iterator<TIter> IIter;
@@ -157,7 +157,7 @@ int main()
     test_exceptions(S(), 0, TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S(), 0, TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), 0, TIter(s, s+10, 6, TIter::TAComparison), TIter());
-	}
+    }
 #endif
 #if _LIBCPP_DEBUG >= 1
     {
@@ -170,30 +170,30 @@ int main()
     }
 #endif
 
-	{ // test inserting into self
+    { // test inserting into self
     typedef std::string S;
-	S s_short = "123/";
-	S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
-
-	s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
-	assert(s_short == "123/123/");
-	s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
-	assert(s_short == "123/123/123/123/");
-	s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
-	assert(s_short == "123/123/123/123/123/123/123/123/");
-
-	s_long.insert(s_long.begin(), s_long.begin(), s_long.end());
-	assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-	}
+    S s_short = "123/";
+    S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
+
+    s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
+    assert(s_short == "123/123/");
+    s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
+    assert(s_short == "123/123/123/123/");
+    s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
+    assert(s_short == "123/123/123/123/123/123/123/123/");
+
+    s_long.insert(s_long.begin(), s_long.begin(), s_long.end());
+    assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+    }
 
-	{ // test assigning a different type
+    { // test assigning a different type
     typedef std::string S;
     const uint8_t p[] = "ABCD";
 
     S s;
     s.insert(s.begin(), p, p + 4);
     assert(s == "ABCD");
-	}
+    }
 
   { // test with a move iterator that returns char&&
     typedef input_iterator<const char*> It;
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
index e49f57a7f9ad..b4505a4c1f3e 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer.pass.cpp
@@ -219,19 +219,19 @@ int main()
     }
 #endif
 
-	{ // test inserting into self
+    { // test inserting into self
     typedef std::string S;
-	S s_short = "123/";
-	S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
+    S s_short = "123/";
+    S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
-	s_short.insert(0, s_short.c_str());
-	assert(s_short == "123/123/");
-	s_short.insert(0, s_short.c_str());
-	assert(s_short == "123/123/123/123/");
-	s_short.insert(0, s_short.c_str());
-	assert(s_short == "123/123/123/123/123/123/123/123/");
+    s_short.insert(0, s_short.c_str());
+    assert(s_short == "123/123/");
+    s_short.insert(0, s_short.c_str());
+    assert(s_short == "123/123/123/123/");
+    s_short.insert(0, s_short.c_str());
+    assert(s_short == "123/123/123/123/123/123/123/123/");
 
-	s_long.insert(0, s_long.c_str());
-	assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-	}
+    s_long.insert(0, s_long.c_str());
+    assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+    }
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
index a42a60ddcdb4..ee5991c15966 100644
--- a/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/size_pointer_size.pass.cpp
@@ -700,19 +700,19 @@ int main()
     }
 #endif
 
-	{ // test inserting into self
+    { // test inserting into self
     typedef std::string S;
-	S s_short = "123/";
-	S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
+    S s_short = "123/";
+    S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
-	s_short.insert(0, s_short.data(), s_short.size());
-	assert(s_short == "123/123/");
-	s_short.insert(0, s_short.data(), s_short.size());
-	assert(s_short == "123/123/123/123/");
-	s_short.insert(0, s_short.data(), s_short.size());
-	assert(s_short == "123/123/123/123/123/123/123/123/");
+    s_short.insert(0, s_short.data(), s_short.size());
+    assert(s_short == "123/123/");
+    s_short.insert(0, s_short.data(), s_short.size());
+    assert(s_short == "123/123/123/123/");
+    s_short.insert(0, s_short.data(), s_short.size());
+    assert(s_short == "123/123/123/123/123/123/123/123/");
 
-	s_long.insert(0, s_long.data(), s_long.size());
-	assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-	}
+    s_long.insert(0, s_long.data(), s_long.size());
+    assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+    }
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
new file mode 100644
index 000000000000..970cbcb1756c
--- /dev/null
+++ b/test/std/strings/basic.string/string.modifiers/string_insert/string_view.pass.cpp
@@ -0,0 +1,239 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// basic_string<charT,traits,Allocator>&
+//   insert(size_type pos, string_view sv);
+
+#include <string>
+#include <stdexcept>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S, class SV>
+void
+test(S s, typename S::size_type pos, SV sv, S expected)
+{
+    const typename S::size_type old_size = s.size();
+    S s0 = s;
+    if (pos <= old_size)
+    {
+        s.insert(pos, sv);
+        LIBCPP_ASSERT(s.__invariants());
+        assert(s == expected);
+    }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.insert(pos, sv);
+            assert(false);
+        }
+        catch (std::out_of_range&)
+        {
+            assert(pos > old_size);
+            assert(s == s0);
+        }
+    }
+#endif
+}
+
+int main()
+{
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
+    test(S(""), 0, SV(""), S(""));
+    test(S(""), 0, SV("12345"), S("12345"));
+    test(S(""), 0, SV("1234567890"), S("1234567890"));
+    test(S(""), 0, SV("12345678901234567890"), S("12345678901234567890"));
+    test(S(""), 1, SV(""), S("can't happen"));
+    test(S(""), 1, SV("12345"), S("can't happen"));
+    test(S(""), 1, SV("1234567890"), S("can't happen"));
+    test(S(""), 1, SV("12345678901234567890"), S("can't happen"));
+    test(S("abcde"), 0, SV(""), S("abcde"));
+    test(S("abcde"), 0, SV("12345"), S("12345abcde"));
+    test(S("abcde"), 0, SV("1234567890"), S("1234567890abcde"));
+    test(S("abcde"), 0, SV("12345678901234567890"), S("12345678901234567890abcde"));
+    test(S("abcde"), 1, SV(""), S("abcde"));
+    test(S("abcde"), 1, SV("12345"), S("a12345bcde"));
+    test(S("abcde"), 1, SV("1234567890"), S("a1234567890bcde"));
+    test(S("abcde"), 1, SV("12345678901234567890"), S("a12345678901234567890bcde"));
+    test(S("abcde"), 2, SV(""), S("abcde"));
+    test(S("abcde"), 2, SV("12345"), S("ab12345cde"));
+    test(S("abcde"), 2, SV("1234567890"), S("ab1234567890cde"));
+    test(S("abcde"), 2, SV("12345678901234567890"), S("ab12345678901234567890cde"));
+    test(S("abcde"), 4, SV(""), S("abcde"));
+    test(S("abcde"), 4, SV("12345"), S("abcd12345e"));
+    test(S("abcde"), 4, SV("1234567890"), S("abcd1234567890e"));
+    test(S("abcde"), 4, SV("12345678901234567890"), S("abcd12345678901234567890e"));
+    test(S("abcde"), 5, SV(""), S("abcde"));
+    test(S("abcde"), 5, SV("12345"), S("abcde12345"));
+    test(S("abcde"), 5, SV("1234567890"), S("abcde1234567890"));
+    test(S("abcde"), 5, SV("12345678901234567890"), S("abcde12345678901234567890"));
+    test(S("abcde"), 6, SV(""), S("can't happen"));
+    test(S("abcde"), 6, SV("12345"), S("can't happen"));
+    test(S("abcde"), 6, SV("1234567890"), S("can't happen"));
+    test(S("abcde"), 6, SV("12345678901234567890"), S("can't happen"));
+    test(S("abcdefghij"), 0, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 0, SV("12345"), S("12345abcdefghij"));
+    test(S("abcdefghij"), 0, SV("1234567890"), S("1234567890abcdefghij"));
+    test(S("abcdefghij"), 0, SV("12345678901234567890"), S("12345678901234567890abcdefghij"));
+    test(S("abcdefghij"), 1, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 1, SV("12345"), S("a12345bcdefghij"));
+    test(S("abcdefghij"), 1, SV("1234567890"), S("a1234567890bcdefghij"));
+    test(S("abcdefghij"), 1, SV("12345678901234567890"), S("a12345678901234567890bcdefghij"));
+    test(S("abcdefghij"), 5, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 5, SV("12345"), S("abcde12345fghij"));
+    test(S("abcdefghij"), 5, SV("1234567890"), S("abcde1234567890fghij"));
+    test(S("abcdefghij"), 5, SV("12345678901234567890"), S("abcde12345678901234567890fghij"));
+    test(S("abcdefghij"), 9, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 9, SV("12345"), S("abcdefghi12345j"));
+    test(S("abcdefghij"), 9, SV("1234567890"), S("abcdefghi1234567890j"));
+    test(S("abcdefghij"), 9, SV("12345678901234567890"), S("abcdefghi12345678901234567890j"));
+    test(S("abcdefghij"), 10, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 10, SV("12345"), S("abcdefghij12345"));
+    test(S("abcdefghij"), 10, SV("1234567890"), S("abcdefghij1234567890"));
+    test(S("abcdefghij"), 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
+    test(S("abcdefghij"), 11, SV(""), S("can't happen"));
+    test(S("abcdefghij"), 11, SV("12345"), S("can't happen"));
+    test(S("abcdefghij"), 11, SV("1234567890"), S("can't happen"));
+    test(S("abcdefghij"), 11, SV("12345678901234567890"), S("can't happen"));
+    test(S("abcdefghijklmnopqrst"), 0, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, SV("12345"), S("12345abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, SV("1234567890"), S("1234567890abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), S("12345678901234567890abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, SV("12345"), S("a12345bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), S("a1234567890bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, SV("12345678901234567890"), S("a12345678901234567890bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, SV("12345"), S("abcdefghij12345klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, SV("1234567890"), S("abcdefghij1234567890klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 19, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 19, SV("12345"), S("abcdefghijklmnopqrs12345t"));
+    test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), S("abcdefghijklmnopqrs1234567890t"));
+    test(S("abcdefghijklmnopqrst"), 19, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890t"));
+    test(S("abcdefghijklmnopqrst"), 20, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 20, SV("12345"), S("abcdefghijklmnopqrst12345"));
+    test(S("abcdefghijklmnopqrst"), 20, SV("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+    test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 21, SV(""), S("can't happen"));
+    test(S("abcdefghijklmnopqrst"), 21, SV("12345"), S("can't happen"));
+    test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), S("can't happen"));
+    test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), S("can't happen"));
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    typedef std::string_view SV;
+    test(S(""), 0, SV(""), S(""));
+    test(S(""), 0, SV("12345"), S("12345"));
+    test(S(""), 0, SV("1234567890"), S("1234567890"));
+    test(S(""), 0, SV("12345678901234567890"), S("12345678901234567890"));
+    test(S(""), 1, SV(""), S("can't happen"));
+    test(S(""), 1, SV("12345"), S("can't happen"));
+    test(S(""), 1, SV("1234567890"), S("can't happen"));
+    test(S(""), 1, SV("12345678901234567890"), S("can't happen"));
+    test(S("abcde"), 0, SV(""), S("abcde"));
+    test(S("abcde"), 0, SV("12345"), S("12345abcde"));
+    test(S("abcde"), 0, SV("1234567890"), S("1234567890abcde"));
+    test(S("abcde"), 0, SV("12345678901234567890"), S("12345678901234567890abcde"));
+    test(S("abcde"), 1, SV(""), S("abcde"));
+    test(S("abcde"), 1, SV("12345"), S("a12345bcde"));
+    test(S("abcde"), 1, SV("1234567890"), S("a1234567890bcde"));
+    test(S("abcde"), 1, SV("12345678901234567890"), S("a12345678901234567890bcde"));
+    test(S("abcde"), 2, SV(""), S("abcde"));
+    test(S("abcde"), 2, SV("12345"), S("ab12345cde"));
+    test(S("abcde"), 2, SV("1234567890"), S("ab1234567890cde"));
+    test(S("abcde"), 2, SV("12345678901234567890"), S("ab12345678901234567890cde"));
+    test(S("abcde"), 4, SV(""), S("abcde"));
+    test(S("abcde"), 4, SV("12345"), S("abcd12345e"));
+    test(S("abcde"), 4, SV("1234567890"), S("abcd1234567890e"));
+    test(S("abcde"), 4, SV("12345678901234567890"), S("abcd12345678901234567890e"));
+    test(S("abcde"), 5, SV(""), S("abcde"));
+    test(S("abcde"), 5, SV("12345"), S("abcde12345"));
+    test(S("abcde"), 5, SV("1234567890"), S("abcde1234567890"));
+    test(S("abcde"), 5, SV("12345678901234567890"), S("abcde12345678901234567890"));
+    test(S("abcde"), 6, SV(""), S("can't happen"));
+    test(S("abcde"), 6, SV("12345"), S("can't happen"));
+    test(S("abcde"), 6, SV("1234567890"), S("can't happen"));
+    test(S("abcde"), 6, SV("12345678901234567890"), S("can't happen"));
+    test(S("abcdefghij"), 0, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 0, SV("12345"), S("12345abcdefghij"));
+    test(S("abcdefghij"), 0, SV("1234567890"), S("1234567890abcdefghij"));
+    test(S("abcdefghij"), 0, SV("12345678901234567890"), S("12345678901234567890abcdefghij"));
+    test(S("abcdefghij"), 1, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 1, SV("12345"), S("a12345bcdefghij"));
+    test(S("abcdefghij"), 1, SV("1234567890"), S("a1234567890bcdefghij"));
+    test(S("abcdefghij"), 1, SV("12345678901234567890"), S("a12345678901234567890bcdefghij"));
+    test(S("abcdefghij"), 5, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 5, SV("12345"), S("abcde12345fghij"));
+    test(S("abcdefghij"), 5, SV("1234567890"), S("abcde1234567890fghij"));
+    test(S("abcdefghij"), 5, SV("12345678901234567890"), S("abcde12345678901234567890fghij"));
+    test(S("abcdefghij"), 9, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 9, SV("12345"), S("abcdefghi12345j"));
+    test(S("abcdefghij"), 9, SV("1234567890"), S("abcdefghi1234567890j"));
+    test(S("abcdefghij"), 9, SV("12345678901234567890"), S("abcdefghi12345678901234567890j"));
+    test(S("abcdefghij"), 10, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 10, SV("12345"), S("abcdefghij12345"));
+    test(S("abcdefghij"), 10, SV("1234567890"), S("abcdefghij1234567890"));
+    test(S("abcdefghij"), 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
+    test(S("abcdefghij"), 11, SV(""), S("can't happen"));
+    test(S("abcdefghij"), 11, SV("12345"), S("can't happen"));
+    test(S("abcdefghij"), 11, SV("1234567890"), S("can't happen"));
+    test(S("abcdefghij"), 11, SV("12345678901234567890"), S("can't happen"));
+    test(S("abcdefghijklmnopqrst"), 0, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, SV("12345"), S("12345abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, SV("1234567890"), S("1234567890abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, SV("12345678901234567890"), S("12345678901234567890abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, SV("12345"), S("a12345bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, SV("1234567890"), S("a1234567890bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, SV("12345678901234567890"), S("a12345678901234567890bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, SV("12345"), S("abcdefghij12345klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, SV("1234567890"), S("abcdefghij1234567890klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 19, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 19, SV("12345"), S("abcdefghijklmnopqrs12345t"));
+    test(S("abcdefghijklmnopqrst"), 19, SV("1234567890"), S("abcdefghijklmnopqrs1234567890t"));
+    test(S("abcdefghijklmnopqrst"), 19, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890t"));
+    test(S("abcdefghijklmnopqrst"), 20, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 20, SV("12345"), S("abcdefghijklmnopqrst12345"));
+    test(S("abcdefghijklmnopqrst"), 20, SV("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+    test(S("abcdefghijklmnopqrst"), 20, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 21, SV(""), S("can't happen"));
+    test(S("abcdefghijklmnopqrst"), 21, SV("12345"), S("can't happen"));
+    test(S("abcdefghijklmnopqrst"), 21, SV("1234567890"), S("can't happen"));
+    test(S("abcdefghijklmnopqrst"), 21, SV("12345678901234567890"), S("can't happen"));
+    }
+#endif
+
+    { // test inserting into self
+    typedef std::string S;
+    S s_short = "123/";
+    S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
+
+    s_short.insert(0, s_short.c_str());
+    assert(s_short == "123/123/");
+    s_short.insert(0, s_short.c_str());
+    assert(s_short == "123/123/123/123/");
+    s_short.insert(0, s_short.c_str());
+    assert(s_short == "123/123/123/123/123/123/123/123/");
+
+    s_long.insert(0, s_long.c_str());
+    assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+    }
+}
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
index e456d395220b..f8126bcaf7de 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
@@ -42,12 +42,12 @@ test_exceptions(S s, typename S::size_type pos1, typename S::size_type n1, It f,
 {
     typename S::const_iterator first = s.begin() + pos1;
     typename S::const_iterator last = s.begin() + pos1 + n1;
-	S aCopy = s;
-	try {
-	    s.replace(first, last, f, l);
-	    assert(false);
-	    }
-	catch (...) {}
+    S aCopy = s;
+    try {
+        s.replace(first, last, f, l);
+        assert(false);
+        }
+    catch (...) {}
     LIBCPP_ASSERT(s.__invariants());
     assert(s == aCopy);
 }
@@ -993,7 +993,7 @@ int main()
     }
 #endif
 #ifndef TEST_HAS_NO_EXCEPTIONS
-	{ // test iterator operations that throw
+    { // test iterator operations that throw
     typedef std::string S;
     typedef ThrowingIterator<char> TIter;
     typedef input_iterator<TIter> IIter;
@@ -1005,36 +1005,36 @@ int main()
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S("abcdefghijklmnopqrst"), 10, 5, TIter(s, s+10, 6, TIter::TAComparison), TIter());
-	}
+    }
 #endif
 
-	{ // test replacing into self
+    { // test replacing into self
     typedef std::string S;
-	S s_short = "123/";
-	S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
+    S s_short = "123/";
+    S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
-	s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
-	assert(s_short == "123/123/");
-	s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
-	assert(s_short == "123/123/123/123/");
-	s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
-	assert(s_short == "123/123/123/123/123/123/123/123/");
+    s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
+    assert(s_short == "123/123/");
+    s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
+    assert(s_short == "123/123/123/123/");
+    s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
+    assert(s_short == "123/123/123/123/123/123/123/123/");
 
-	s_long.replace(s_long.begin(), s_long.begin(), s_long.begin(), s_long.end());
-	assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-	}
+    s_long.replace(s_long.begin(), s_long.begin(), s_long.begin(), s_long.end());
+    assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+    }
 
-	{ // test assigning a different type
+    { // test assigning a different type
     typedef std::string S;
-	const uint8_t pc[] = "ABCD";
-	uint8_t        p[] = "EFGH";
+    const uint8_t pc[] = "ABCD";
+    uint8_t        p[] = "EFGH";
 
-	S s;
-	s.replace(s.begin(), s.end(), pc, pc + 4);
-	assert(s == "ABCD");
+    S s;
+    s.replace(s.begin(), s.end(), pc, pc + 4);
+    assert(s == "ABCD");
 
-	s.clear();
-	s.replace(s.begin(), s.end(), p, p + 4);
-	assert(s == "EFGH");
-	}
+    s.clear();
+    s.replace(s.begin(), s.end(), p, p + 4);
+    assert(s == "EFGH");
+    }
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
index f642d3a4f921..a7d6a6e3ce3c 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer.pass.cpp
@@ -283,19 +283,19 @@ int main()
     }
 #endif
 
-	{ // test replacing into self
+    { // test replacing into self
     typedef std::string S;
-	S s_short = "123/";
-	S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
+    S s_short = "123/";
+    S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
-	s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
-	assert(s_short == "123/123/");
-	s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
-	assert(s_short == "123/123/123/123/");
-	s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
-	assert(s_short == "123/123/123/123/123/123/123/123/");
+    s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
+    assert(s_short == "123/123/");
+    s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
+    assert(s_short == "123/123/123/123/");
+    s_short.replace(s_short.begin(), s_short.begin(), s_short.c_str());
+    assert(s_short == "123/123/123/123/123/123/123/123/");
 
-	s_long.replace(s_long.begin(), s_long.begin(), s_long.c_str());
-	assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-	}
+    s_long.replace(s_long.begin(), s_long.begin(), s_long.c_str());
+    assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+    }
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
index 695036807223..6c68b156641f 100644
--- a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_pointer_size.pass.cpp
@@ -973,19 +973,19 @@ int main()
     }
 #endif
 
-	{ // test replacing into self
+    { // test replacing into self
     typedef std::string S;
-	S s_short = "123/";
-	S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
+    S s_short = "123/";
+    S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
-	s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
-	assert(s_short == "123/123/");
-	s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
-	assert(s_short == "123/123/123/123/");
-	s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
-	assert(s_short == "123/123/123/123/123/123/123/123/");
+    s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
+    assert(s_short == "123/123/");
+    s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
+    assert(s_short == "123/123/123/123/");
+    s_short.replace(s_short.begin(), s_short.begin(), s_short.data(), s_short.size());
+    assert(s_short == "123/123/123/123/123/123/123/123/");
 
-	s_long.replace(s_long.begin(), s_long.begin(), s_long.data(), s_long.size());
-	assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
-	}
+    s_long.replace(s_long.begin(), s_long.begin(), s_long.data(), s_long.size());
+    assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
+    }
 }
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
new file mode 100644
index 000000000000..ec81001df663
--- /dev/null
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_string_view.pass.cpp
@@ -0,0 +1,286 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// basic_string<charT,traits,Allocator>&
+//   replace(const_iterator i1, const_iterator i2, basic_string_view<charT,traits> sv);
+
+#include <string>
+#include <algorithm>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S, class SV>
+void
+test(S s, typename S::size_type pos1, typename S::size_type n1, SV sv, S expected)
+{
+    typename S::size_type old_size = s.size();
+    typename S::const_iterator first = s.begin() + pos1;
+    typename S::const_iterator last = s.begin() + pos1 + n1;
+    typename S::size_type xlen = last - first;
+    s.replace(first, last, sv);
+    LIBCPP_ASSERT(s.__invariants());
+    assert(s == expected);
+    typename S::size_type rlen = sv.size();
+    assert(s.size() == old_size - xlen + rlen);
+}
+
+template <class S, class SV>
+void test0()
+{
+    test(S(""), 0, 0, SV(""), S(""));
+    test(S(""), 0, 0, SV("12345"), S("12345"));
+    test(S(""), 0, 0, SV("1234567890"), S("1234567890"));
+    test(S(""), 0, 0, SV("12345678901234567890"), S("12345678901234567890"));
+    test(S("abcde"), 0, 0, SV(""), S("abcde"));
+    test(S("abcde"), 0, 0, SV("12345"), S("12345abcde"));
+    test(S("abcde"), 0, 0, SV("1234567890"), S("1234567890abcde"));
+    test(S("abcde"), 0, 0, SV("12345678901234567890"), S("12345678901234567890abcde"));
+    test(S("abcde"), 0, 1, SV(""), S("bcde"));
+    test(S("abcde"), 0, 1, SV("12345"), S("12345bcde"));
+    test(S("abcde"), 0, 1, SV("1234567890"), S("1234567890bcde"));
+    test(S("abcde"), 0, 1, SV("12345678901234567890"), S("12345678901234567890bcde"));
+    test(S("abcde"), 0, 2, SV(""), S("cde"));
+    test(S("abcde"), 0, 2, SV("12345"), S("12345cde"));
+    test(S("abcde"), 0, 2, SV("1234567890"), S("1234567890cde"));
+    test(S("abcde"), 0, 2, SV("12345678901234567890"), S("12345678901234567890cde"));
+    test(S("abcde"), 0, 4, SV(""), S("e"));
+    test(S("abcde"), 0, 4, SV("12345"), S("12345e"));
+    test(S("abcde"), 0, 4, SV("1234567890"), S("1234567890e"));
+    test(S("abcde"), 0, 4, SV("12345678901234567890"), S("12345678901234567890e"));
+    test(S("abcde"), 0, 5, SV(""), S(""));
+    test(S("abcde"), 0, 5, SV("12345"), S("12345"));
+    test(S("abcde"), 0, 5, SV("1234567890"), S("1234567890"));
+    test(S("abcde"), 0, 5, SV("12345678901234567890"), S("12345678901234567890"));
+    test(S("abcde"), 1, 0, SV(""), S("abcde"));
+    test(S("abcde"), 1, 0, SV("12345"), S("a12345bcde"));
+    test(S("abcde"), 1, 0, SV("1234567890"), S("a1234567890bcde"));
+    test(S("abcde"), 1, 0, SV("12345678901234567890"), S("a12345678901234567890bcde"));
+    test(S("abcde"), 1, 1, SV(""), S("acde"));
+    test(S("abcde"), 1, 1, SV("12345"), S("a12345cde"));
+    test(S("abcde"), 1, 1, SV("1234567890"), S("a1234567890cde"));
+    test(S("abcde"), 1, 1, SV("12345678901234567890"), S("a12345678901234567890cde"));
+    test(S("abcde"), 1, 2, SV(""), S("ade"));
+    test(S("abcde"), 1, 2, SV("12345"), S("a12345de"));
+    test(S("abcde"), 1, 2, SV("1234567890"), S("a1234567890de"));
+    test(S("abcde"), 1, 2, SV("12345678901234567890"), S("a12345678901234567890de"));
+    test(S("abcde"), 1, 3, SV(""), S("ae"));
+    test(S("abcde"), 1, 3, SV("12345"), S("a12345e"));
+    test(S("abcde"), 1, 3, SV("1234567890"), S("a1234567890e"));
+    test(S("abcde"), 1, 3, SV("12345678901234567890"), S("a12345678901234567890e"));
+    test(S("abcde"), 1, 4, SV(""), S("a"));
+    test(S("abcde"), 1, 4, SV("12345"), S("a12345"));
+    test(S("abcde"), 1, 4, SV("1234567890"), S("a1234567890"));
+    test(S("abcde"), 1, 4, SV("12345678901234567890"), S("a12345678901234567890"));
+    test(S("abcde"), 2, 0, SV(""), S("abcde"));
+    test(S("abcde"), 2, 0, SV("12345"), S("ab12345cde"));
+    test(S("abcde"), 2, 0, SV("1234567890"), S("ab1234567890cde"));
+    test(S("abcde"), 2, 0, SV("12345678901234567890"), S("ab12345678901234567890cde"));
+    test(S("abcde"), 2, 1, SV(""), S("abde"));
+    test(S("abcde"), 2, 1, SV("12345"), S("ab12345de"));
+    test(S("abcde"), 2, 1, SV("1234567890"), S("ab1234567890de"));
+    test(S("abcde"), 2, 1, SV("12345678901234567890"), S("ab12345678901234567890de"));
+    test(S("abcde"), 2, 2, SV(""), S("abe"));
+    test(S("abcde"), 2, 2, SV("12345"), S("ab12345e"));
+    test(S("abcde"), 2, 2, SV("1234567890"), S("ab1234567890e"));
+    test(S("abcde"), 2, 2, SV("12345678901234567890"), S("ab12345678901234567890e"));
+    test(S("abcde"), 2, 3, SV(""), S("ab"));
+    test(S("abcde"), 2, 3, SV("12345"), S("ab12345"));
+    test(S("abcde"), 2, 3, SV("1234567890"), S("ab1234567890"));
+    test(S("abcde"), 2, 3, SV("12345678901234567890"), S("ab12345678901234567890"));
+    test(S("abcde"), 4, 0, SV(""), S("abcde"));
+    test(S("abcde"), 4, 0, SV("12345"), S("abcd12345e"));
+    test(S("abcde"), 4, 0, SV("1234567890"), S("abcd1234567890e"));
+    test(S("abcde"), 4, 0, SV("12345678901234567890"), S("abcd12345678901234567890e"));
+    test(S("abcde"), 4, 1, SV(""), S("abcd"));
+    test(S("abcde"), 4, 1, SV("12345"), S("abcd12345"));
+    test(S("abcde"), 4, 1, SV("1234567890"), S("abcd1234567890"));
+    test(S("abcde"), 4, 1, SV("12345678901234567890"), S("abcd12345678901234567890"));
+    test(S("abcde"), 5, 0, SV(""), S("abcde"));
+    test(S("abcde"), 5, 0, SV("12345"), S("abcde12345"));
+    test(S("abcde"), 5, 0, SV("1234567890"), S("abcde1234567890"));
+    test(S("abcde"), 5, 0, SV("12345678901234567890"), S("abcde12345678901234567890"));
+    test(S("abcdefghij"), 0, 0, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 0, 0, SV("12345"), S("12345abcdefghij"));
+    test(S("abcdefghij"), 0, 0, SV("1234567890"), S("1234567890abcdefghij"));
+    test(S("abcdefghij"), 0, 0, SV("12345678901234567890"), S("12345678901234567890abcdefghij"));
+    test(S("abcdefghij"), 0, 1, SV(""), S("bcdefghij"));
+    test(S("abcdefghij"), 0, 1, SV("12345"), S("12345bcdefghij"));
+    test(S("abcdefghij"), 0, 1, SV("1234567890"), S("1234567890bcdefghij"));
+    test(S("abcdefghij"), 0, 1, SV("12345678901234567890"), S("12345678901234567890bcdefghij"));
+    test(S("abcdefghij"), 0, 5, SV(""), S("fghij"));
+    test(S("abcdefghij"), 0, 5, SV("12345"), S("12345fghij"));
+    test(S("abcdefghij"), 0, 5, SV("1234567890"), S("1234567890fghij"));
+    test(S("abcdefghij"), 0, 5, SV("12345678901234567890"), S("12345678901234567890fghij"));
+    test(S("abcdefghij"), 0, 9, SV(""), S("j"));
+    test(S("abcdefghij"), 0, 9, SV("12345"), S("12345j"));
+    test(S("abcdefghij"), 0, 9, SV("1234567890"), S("1234567890j"));
+    test(S("abcdefghij"), 0, 9, SV("12345678901234567890"), S("12345678901234567890j"));
+    test(S("abcdefghij"), 0, 10, SV(""), S(""));
+    test(S("abcdefghij"), 0, 10, SV("12345"), S("12345"));
+    test(S("abcdefghij"), 0, 10, SV("1234567890"), S("1234567890"));
+    test(S("abcdefghij"), 0, 10, SV("12345678901234567890"), S("12345678901234567890"));
+    test(S("abcdefghij"), 1, 0, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 1, 0, SV("12345"), S("a12345bcdefghij"));
+    test(S("abcdefghij"), 1, 0, SV("1234567890"), S("a1234567890bcdefghij"));
+    test(S("abcdefghij"), 1, 0, SV("12345678901234567890"), S("a12345678901234567890bcdefghij"));
+    test(S("abcdefghij"), 1, 1, SV(""), S("acdefghij"));
+    test(S("abcdefghij"), 1, 1, SV("12345"), S("a12345cdefghij"));
+    test(S("abcdefghij"), 1, 1, SV("1234567890"), S("a1234567890cdefghij"));
+    test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), S("a12345678901234567890cdefghij"));
+}
+
+template <class S, class SV>
+void test1()
+{
+    test(S("abcdefghij"), 1, 4, SV(""), S("afghij"));
+    test(S("abcdefghij"), 1, 4, SV("12345"), S("a12345fghij"));
+    test(S("abcdefghij"), 1, 4, SV("1234567890"), S("a1234567890fghij"));
+    test(S("abcdefghij"), 1, 4, SV("12345678901234567890"), S("a12345678901234567890fghij"));
+    test(S("abcdefghij"), 1, 8, SV(""), S("aj"));
+    test(S("abcdefghij"), 1, 8, SV("12345"), S("a12345j"));
+    test(S("abcdefghij"), 1, 8, SV("1234567890"), S("a1234567890j"));
+    test(S("abcdefghij"), 1, 8, SV("12345678901234567890"), S("a12345678901234567890j"));
+    test(S("abcdefghij"), 1, 9, SV(""), S("a"));
+    test(S("abcdefghij"), 1, 9, SV("12345"), S("a12345"));
+    test(S("abcdefghij"), 1, 9, SV("1234567890"), S("a1234567890"));
+    test(S("abcdefghij"), 1, 9, SV("12345678901234567890"), S("a12345678901234567890"));
+    test(S("abcdefghij"), 5, 0, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 5, 0, SV("12345"), S("abcde12345fghij"));
+    test(S("abcdefghij"), 5, 0, SV("1234567890"), S("abcde1234567890fghij"));
+    test(S("abcdefghij"), 5, 0, SV("12345678901234567890"), S("abcde12345678901234567890fghij"));
+    test(S("abcdefghij"), 5, 1, SV(""), S("abcdeghij"));
+    test(S("abcdefghij"), 5, 1, SV("12345"), S("abcde12345ghij"));
+    test(S("abcdefghij"), 5, 1, SV("1234567890"), S("abcde1234567890ghij"));
+    test(S("abcdefghij"), 5, 1, SV("12345678901234567890"), S("abcde12345678901234567890ghij"));
+    test(S("abcdefghij"), 5, 2, SV(""), S("abcdehij"));
+    test(S("abcdefghij"), 5, 2, SV("12345"), S("abcde12345hij"));
+    test(S("abcdefghij"), 5, 2, SV("1234567890"), S("abcde1234567890hij"));
+    test(S("abcdefghij"), 5, 2, SV("12345678901234567890"), S("abcde12345678901234567890hij"));
+    test(S("abcdefghij"), 5, 4, SV(""), S("abcdej"));
+    test(S("abcdefghij"), 5, 4, SV("12345"), S("abcde12345j"));
+    test(S("abcdefghij"), 5, 4, SV("1234567890"), S("abcde1234567890j"));
+    test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), S("abcde12345678901234567890j"));
+    test(S("abcdefghij"), 5, 5, SV(""), S("abcde"));
+    test(S("abcdefghij"), 5, 5, SV("12345"), S("abcde12345"));
+    test(S("abcdefghij"), 5, 5, SV("1234567890"), S("abcde1234567890"));
+    test(S("abcdefghij"), 5, 5, SV("12345678901234567890"), S("abcde12345678901234567890"));
+    test(S("abcdefghij"), 9, 0, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 9, 0, SV("12345"), S("abcdefghi12345j"));
+    test(S("abcdefghij"), 9, 0, SV("1234567890"), S("abcdefghi1234567890j"));
+    test(S("abcdefghij"), 9, 0, SV("12345678901234567890"), S("abcdefghi12345678901234567890j"));
+    test(S("abcdefghij"), 9, 1, SV(""), S("abcdefghi"));
+    test(S("abcdefghij"), 9, 1, SV("12345"), S("abcdefghi12345"));
+    test(S("abcdefghij"), 9, 1, SV("1234567890"), S("abcdefghi1234567890"));
+    test(S("abcdefghij"), 9, 1, SV("12345678901234567890"), S("abcdefghi12345678901234567890"));
+    test(S("abcdefghij"), 10, 0, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 10, 0, SV("12345"), S("abcdefghij12345"));
+    test(S("abcdefghij"), 10, 0, SV("1234567890"), S("abcdefghij1234567890"));
+    test(S("abcdefghij"), 10, 0, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 0, SV("12345"), S("12345abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 0, SV("1234567890"), S("1234567890abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 0, SV("12345678901234567890"), S("12345678901234567890abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 1, SV(""), S("bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345"), S("12345bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 1, SV("1234567890"), S("1234567890bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345678901234567890"), S("12345678901234567890bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 10, SV(""), S("klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345"), S("12345klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 10, SV("1234567890"), S("1234567890klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345678901234567890"), S("12345678901234567890klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 19, SV(""), S("t"));
+    test(S("abcdefghijklmnopqrst"), 0, 19, SV("12345"), S("12345t"));
+    test(S("abcdefghijklmnopqrst"), 0, 19, SV("1234567890"), S("1234567890t"));
+    test(S("abcdefghijklmnopqrst"), 0, 19, SV("12345678901234567890"), S("12345678901234567890t"));
+    test(S("abcdefghijklmnopqrst"), 0, 20, SV(""), S(""));
+    test(S("abcdefghijklmnopqrst"), 0, 20, SV("12345"), S("12345"));
+    test(S("abcdefghijklmnopqrst"), 0, 20, SV("1234567890"), S("1234567890"));
+    test(S("abcdefghijklmnopqrst"), 0, 20, SV("12345678901234567890"), S("12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 1, 0, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345"), S("a12345bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 0, SV("1234567890"), S("a1234567890bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), S("a12345678901234567890bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 1, SV(""), S("acdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 1, SV("12345"), S("a12345cdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 1, SV("1234567890"), S("a1234567890cdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 1, SV("12345678901234567890"), S("a12345678901234567890cdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 9, SV(""), S("aklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345"), S("a12345klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 9, SV("1234567890"), S("a1234567890klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345678901234567890"), S("a12345678901234567890klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 18, SV(""), S("at"));
+    test(S("abcdefghijklmnopqrst"), 1, 18, SV("12345"), S("a12345t"));
+    test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), S("a1234567890t"));
+    test(S("abcdefghijklmnopqrst"), 1, 18, SV("12345678901234567890"), S("a12345678901234567890t"));
+    test(S("abcdefghijklmnopqrst"), 1, 19, SV(""), S("a"));
+    test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345"), S("a12345"));
+    test(S("abcdefghijklmnopqrst"), 1, 19, SV("1234567890"), S("a1234567890"));
+    test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), S("a12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 10, 0, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), S("abcdefghij12345klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 0, SV("1234567890"), S("abcdefghij1234567890klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345678901234567890"), S("abcdefghij12345678901234567890klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 1, SV(""), S("abcdefghijlmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 1, SV("12345"), S("abcdefghij12345lmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), S("abcdefghij1234567890lmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 1, SV("12345678901234567890"), S("abcdefghij12345678901234567890lmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 5, SV(""), S("abcdefghijpqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345"), S("abcdefghij12345pqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 5, SV("1234567890"), S("abcdefghij1234567890pqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), S("abcdefghij12345678901234567890pqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 9, SV(""), S("abcdefghijt"));
+    test(S("abcdefghijklmnopqrst"), 10, 9, SV("12345"), S("abcdefghij12345t"));
+    test(S("abcdefghijklmnopqrst"), 10, 9, SV("1234567890"), S("abcdefghij1234567890t"));
+    test(S("abcdefghijklmnopqrst"), 10, 9, SV("12345678901234567890"), S("abcdefghij12345678901234567890t"));
+}
+
+template <class S, class SV>
+void test2()
+{
+    test(S("abcdefghijklmnopqrst"), 10, 10, SV(""), S("abcdefghij"));
+    test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), S("abcdefghij12345"));
+    test(S("abcdefghijklmnopqrst"), 10, 10, SV("1234567890"), S("abcdefghij1234567890"));
+    test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 19, 0, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345"), S("abcdefghijklmnopqrs12345t"));
+    test(S("abcdefghijklmnopqrst"), 19, 0, SV("1234567890"), S("abcdefghijklmnopqrs1234567890t"));
+    test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890t"));
+    test(S("abcdefghijklmnopqrst"), 19, 1, SV(""), S("abcdefghijklmnopqrs"));
+    test(S("abcdefghijklmnopqrst"), 19, 1, SV("12345"), S("abcdefghijklmnopqrs12345"));
+    test(S("abcdefghijklmnopqrst"), 19, 1, SV("1234567890"), S("abcdefghijklmnopqrs1234567890"));
+    test(S("abcdefghijklmnopqrst"), 19, 1, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 20, 0, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345"), S("abcdefghijklmnopqrst12345"));
+    test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+    test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
+}
+
+int main()
+{
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
+    test0<S, SV>();
+    test1<S, SV>();
+    test2<S, SV>();
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    typedef std::string_view SV;
+    test0<S, SV>();
+    test1<S, SV>();
+    test2<S, SV>();
+    }
+#endif
+}
diff --git a/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
new file mode 100644
index 000000000000..60ecd67f1f7d
--- /dev/null
+++ b/test/std/strings/basic.string/string.modifiers/string_replace/size_size_string_view.pass.cpp
@@ -0,0 +1,384 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <string>
+
+// basic_string<charT,traits,Allocator>&
+//   replace(size_type pos1, size_type n1, basic_string_view<charT,traits> sv);
+
+#include <string>
+#include <stdexcept>
+#include <algorithm>
+#include <cassert>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+template <class S, class SV>
+void
+test(S s, typename S::size_type pos1, typename S::size_type n1, SV sv, S expected)
+{
+    const typename S::size_type old_size = s.size();
+    S s0 = s;
+    if (pos1 <= old_size)
+    {
+        s.replace(pos1, n1, sv);
+        LIBCPP_ASSERT(s.__invariants());
+        assert(s == expected);
+        typename S::size_type xlen = std::min(n1, old_size - pos1);
+        typename S::size_type rlen = sv.size();
+        assert(s.size() == old_size - xlen + rlen);
+    }
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    else
+    {
+        try
+        {
+            s.replace(pos1, n1, sv);
+            assert(false);
+        }
+        catch (std::out_of_range&)
+        {
+            assert(pos1 > old_size);
+            assert(s == s0);
+        }
+    }
+#endif
+}
+
+template <class S, class SV>
+void test0()
+{
+    test(S(""), 0, 0, SV(""), S(""));
+    test(S(""), 0, 0, SV("12345"), S("12345"));
+    test(S(""), 0, 0, SV("1234567890"), S("1234567890"));
+    test(S(""), 0, 0, SV("12345678901234567890"), S("12345678901234567890"));
+    test(S(""), 0, 1, SV(""), S(""));
+    test(S(""), 0, 1, SV("12345"), S("12345"));
+    test(S(""), 0, 1, SV("1234567890"), S("1234567890"));
+    test(S(""), 0, 1, SV("12345678901234567890"), S("12345678901234567890"));
+    test(S(""), 1, 0, SV(""), S("can't happen"));
+    test(S(""), 1, 0, SV("12345"), S("can't happen"));
+    test(S(""), 1, 0, SV("1234567890"), S("can't happen"));
+    test(S(""), 1, 0, SV("12345678901234567890"), S("can't happen"));
+    test(S("abcde"), 0, 0, SV(""), S("abcde"));
+    test(S("abcde"), 0, 0, SV("12345"), S("12345abcde"));
+    test(S("abcde"), 0, 0, SV("1234567890"), S("1234567890abcde"));
+    test(S("abcde"), 0, 0, SV("12345678901234567890"), S("12345678901234567890abcde"));
+    test(S("abcde"), 0, 1, SV(""), S("bcde"));
+    test(S("abcde"), 0, 1, SV("12345"), S("12345bcde"));
+    test(S("abcde"), 0, 1, SV("1234567890"), S("1234567890bcde"));
+    test(S("abcde"), 0, 1, SV("12345678901234567890"), S("12345678901234567890bcde"));
+    test(S("abcde"), 0, 2, SV(""), S("cde"));
+    test(S("abcde"), 0, 2, SV("12345"), S("12345cde"));
+    test(S("abcde"), 0, 2, SV("1234567890"), S("1234567890cde"));
+    test(S("abcde"), 0, 2, SV("12345678901234567890"), S("12345678901234567890cde"));
+    test(S("abcde"), 0, 4, SV(""), S("e"));
+    test(S("abcde"), 0, 4, SV("12345"), S("12345e"));
+    test(S("abcde"), 0, 4, SV("1234567890"), S("1234567890e"));
+    test(S("abcde"), 0, 4, SV("12345678901234567890"), S("12345678901234567890e"));
+    test(S("abcde"), 0, 5, SV(""), S(""));
+    test(S("abcde"), 0, 5, SV("12345"), S("12345"));
+    test(S("abcde"), 0, 5, SV("1234567890"), S("1234567890"));
+    test(S("abcde"), 0, 5, SV("12345678901234567890"), S("12345678901234567890"));
+    test(S("abcde"), 0, 6, SV(""), S(""));
+    test(S("abcde"), 0, 6, SV("12345"), S("12345"));
+    test(S("abcde"), 0, 6, SV("1234567890"), S("1234567890"));
+    test(S("abcde"), 0, 6, SV("12345678901234567890"), S("12345678901234567890"));
+    test(S("abcde"), 1, 0, SV(""), S("abcde"));
+    test(S("abcde"), 1, 0, SV("12345"), S("a12345bcde"));
+    test(S("abcde"), 1, 0, SV("1234567890"), S("a1234567890bcde"));
+    test(S("abcde"), 1, 0, SV("12345678901234567890"), S("a12345678901234567890bcde"));
+    test(S("abcde"), 1, 1, SV(""), S("acde"));
+    test(S("abcde"), 1, 1, SV("12345"), S("a12345cde"));
+    test(S("abcde"), 1, 1, SV("1234567890"), S("a1234567890cde"));
+    test(S("abcde"), 1, 1, SV("12345678901234567890"), S("a12345678901234567890cde"));
+    test(S("abcde"), 1, 2, SV(""), S("ade"));
+    test(S("abcde"), 1, 2, SV("12345"), S("a12345de"));
+    test(S("abcde"), 1, 2, SV("1234567890"), S("a1234567890de"));
+    test(S("abcde"), 1, 2, SV("12345678901234567890"), S("a12345678901234567890de"));
+    test(S("abcde"), 1, 3, SV(""), S("ae"));
+    test(S("abcde"), 1, 3, SV("12345"), S("a12345e"));
+    test(S("abcde"), 1, 3, SV("1234567890"), S("a1234567890e"));
+    test(S("abcde"), 1, 3, SV("12345678901234567890"), S("a12345678901234567890e"));
+    test(S("abcde"), 1, 4, SV(""), S("a"));
+    test(S("abcde"), 1, 4, SV("12345"), S("a12345"));
+    test(S("abcde"), 1, 4, SV("1234567890"), S("a1234567890"));
+    test(S("abcde"), 1, 4, SV("12345678901234567890"), S("a12345678901234567890"));
+    test(S("abcde"), 1, 5, SV(""), S("a"));
+    test(S("abcde"), 1, 5, SV("12345"), S("a12345"));
+    test(S("abcde"), 1, 5, SV("1234567890"), S("a1234567890"));
+    test(S("abcde"), 1, 5, SV("12345678901234567890"), S("a12345678901234567890"));
+    test(S("abcde"), 2, 0, SV(""), S("abcde"));
+    test(S("abcde"), 2, 0, SV("12345"), S("ab12345cde"));
+    test(S("abcde"), 2, 0, SV("1234567890"), S("ab1234567890cde"));
+    test(S("abcde"), 2, 0, SV("12345678901234567890"), S("ab12345678901234567890cde"));
+    test(S("abcde"), 2, 1, SV(""), S("abde"));
+    test(S("abcde"), 2, 1, SV("12345"), S("ab12345de"));
+    test(S("abcde"), 2, 1, SV("1234567890"), S("ab1234567890de"));
+    test(S("abcde"), 2, 1, SV("12345678901234567890"), S("ab12345678901234567890de"));
+    test(S("abcde"), 2, 2, SV(""), S("abe"));
+    test(S("abcde"), 2, 2, SV("12345"), S("ab12345e"));
+    test(S("abcde"), 2, 2, SV("1234567890"), S("ab1234567890e"));
+    test(S("abcde"), 2, 2, SV("12345678901234567890"), S("ab12345678901234567890e"));
+    test(S("abcde"), 2, 3, SV(""), S("ab"));
+    test(S("abcde"), 2, 3, SV("12345"), S("ab12345"));
+    test(S("abcde"), 2, 3, SV("1234567890"), S("ab1234567890"));
+    test(S("abcde"), 2, 3, SV("12345678901234567890"), S("ab12345678901234567890"));
+    test(S("abcde"), 2, 4, SV(""), S("ab"));
+    test(S("abcde"), 2, 4, SV("12345"), S("ab12345"));
+    test(S("abcde"), 2, 4, SV("1234567890"), S("ab1234567890"));
+    test(S("abcde"), 2, 4, SV("12345678901234567890"), S("ab12345678901234567890"));
+    test(S("abcde"), 4, 0, SV(""), S("abcde"));
+    test(S("abcde"), 4, 0, SV("12345"), S("abcd12345e"));
+    test(S("abcde"), 4, 0, SV("1234567890"), S("abcd1234567890e"));
+    test(S("abcde"), 4, 0, SV("12345678901234567890"), S("abcd12345678901234567890e"));
+    test(S("abcde"), 4, 1, SV(""), S("abcd"));
+    test(S("abcde"), 4, 1, SV("12345"), S("abcd12345"));
+    test(S("abcde"), 4, 1, SV("1234567890"), S("abcd1234567890"));
+    test(S("abcde"), 4, 1, SV("12345678901234567890"), S("abcd12345678901234567890"));
+    test(S("abcde"), 4, 2, SV(""), S("abcd"));
+    test(S("abcde"), 4, 2, SV("12345"), S("abcd12345"));
+    test(S("abcde"), 4, 2, SV("1234567890"), S("abcd1234567890"));
+    test(S("abcde"), 4, 2, SV("12345678901234567890"), S("abcd12345678901234567890"));
+    test(S("abcde"), 5, 0, SV(""), S("abcde"));
+    test(S("abcde"), 5, 0, SV("12345"), S("abcde12345"));
+    test(S("abcde"), 5, 0, SV("1234567890"), S("abcde1234567890"));
+    test(S("abcde"), 5, 0, SV("12345678901234567890"), S("abcde12345678901234567890"));
+    test(S("abcde"), 5, 1, SV(""), S("abcde"));
+    test(S("abcde"), 5, 1, SV("12345"), S("abcde12345"));
+    test(S("abcde"), 5, 1, SV("1234567890"), S("abcde1234567890"));
+    test(S("abcde"), 5, 1, SV("12345678901234567890"), S("abcde12345678901234567890"));
+}
+
+template <class S, class SV>
+void test1()
+{
+    test(S("abcde"), 6, 0, SV(""), S("can't happen"));
+    test(S("abcde"), 6, 0, SV("12345"), S("can't happen"));
+    test(S("abcde"), 6, 0, SV("1234567890"), S("can't happen"));
+    test(S("abcde"), 6, 0, SV("12345678901234567890"), S("can't happen"));
+    test(S("abcdefghij"), 0, 0, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 0, 0, SV("12345"), S("12345abcdefghij"));
+    test(S("abcdefghij"), 0, 0, SV("1234567890"), S("1234567890abcdefghij"));
+    test(S("abcdefghij"), 0, 0, SV("12345678901234567890"), S("12345678901234567890abcdefghij"));
+    test(S("abcdefghij"), 0, 1, SV(""), S("bcdefghij"));
+    test(S("abcdefghij"), 0, 1, SV("12345"), S("12345bcdefghij"));
+    test(S("abcdefghij"), 0, 1, SV("1234567890"), S("1234567890bcdefghij"));
+    test(S("abcdefghij"), 0, 1, SV("12345678901234567890"), S("12345678901234567890bcdefghij"));
+    test(S("abcdefghij"), 0, 5, SV(""), S("fghij"));
+    test(S("abcdefghij"), 0, 5, SV("12345"), S("12345fghij"));
+    test(S("abcdefghij"), 0, 5, SV("1234567890"), S("1234567890fghij"));
+    test(S("abcdefghij"), 0, 5, SV("12345678901234567890"), S("12345678901234567890fghij"));
+    test(S("abcdefghij"), 0, 9, SV(""), S("j"));
+    test(S("abcdefghij"), 0, 9, SV("12345"), S("12345j"));
+    test(S("abcdefghij"), 0, 9, SV("1234567890"), S("1234567890j"));
+    test(S("abcdefghij"), 0, 9, SV("12345678901234567890"), S("12345678901234567890j"));
+    test(S("abcdefghij"), 0, 10, SV(""), S(""));
+    test(S("abcdefghij"), 0, 10, SV("12345"), S("12345"));
+    test(S("abcdefghij"), 0, 10, SV("1234567890"), S("1234567890"));
+    test(S("abcdefghij"), 0, 10, SV("12345678901234567890"), S("12345678901234567890"));
+    test(S("abcdefghij"), 0, 11, SV(""), S(""));
+    test(S("abcdefghij"), 0, 11, SV("12345"), S("12345"));
+    test(S("abcdefghij"), 0, 11, SV("1234567890"), S("1234567890"));
+    test(S("abcdefghij"), 0, 11, SV("12345678901234567890"), S("12345678901234567890"));
+    test(S("abcdefghij"), 1, 0, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 1, 0, SV("12345"), S("a12345bcdefghij"));
+    test(S("abcdefghij"), 1, 0, SV("1234567890"), S("a1234567890bcdefghij"));
+    test(S("abcdefghij"), 1, 0, SV("12345678901234567890"), S("a12345678901234567890bcdefghij"));
+    test(S("abcdefghij"), 1, 1, SV(""), S("acdefghij"));
+    test(S("abcdefghij"), 1, 1, SV("12345"), S("a12345cdefghij"));
+    test(S("abcdefghij"), 1, 1, SV("1234567890"), S("a1234567890cdefghij"));
+    test(S("abcdefghij"), 1, 1, SV("12345678901234567890"), S("a12345678901234567890cdefghij"));
+    test(S("abcdefghij"), 1, 4, SV(""), S("afghij"));
+    test(S("abcdefghij"), 1, 4, SV("12345"), S("a12345fghij"));
+    test(S("abcdefghij"), 1, 4, SV("1234567890"), S("a1234567890fghij"));
+    test(S("abcdefghij"), 1, 4, SV("12345678901234567890"), S("a12345678901234567890fghij"));
+    test(S("abcdefghij"), 1, 8, SV(""), S("aj"));
+    test(S("abcdefghij"), 1, 8, SV("12345"), S("a12345j"));
+    test(S("abcdefghij"), 1, 8, SV("1234567890"), S("a1234567890j"));
+    test(S("abcdefghij"), 1, 8, SV("12345678901234567890"), S("a12345678901234567890j"));
+    test(S("abcdefghij"), 1, 9, SV(""), S("a"));
+    test(S("abcdefghij"), 1, 9, SV("12345"), S("a12345"));
+    test(S("abcdefghij"), 1, 9, SV("1234567890"), S("a1234567890"));
+    test(S("abcdefghij"), 1, 9, SV("12345678901234567890"), S("a12345678901234567890"));
+    test(S("abcdefghij"), 1, 10, SV(""), S("a"));
+    test(S("abcdefghij"), 1, 10, SV("12345"), S("a12345"));
+    test(S("abcdefghij"), 1, 10, SV("1234567890"), S("a1234567890"));
+    test(S("abcdefghij"), 1, 10, SV("12345678901234567890"), S("a12345678901234567890"));
+    test(S("abcdefghij"), 5, 0, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 5, 0, SV("12345"), S("abcde12345fghij"));
+    test(S("abcdefghij"), 5, 0, SV("1234567890"), S("abcde1234567890fghij"));
+    test(S("abcdefghij"), 5, 0, SV("12345678901234567890"), S("abcde12345678901234567890fghij"));
+    test(S("abcdefghij"), 5, 1, SV(""), S("abcdeghij"));
+    test(S("abcdefghij"), 5, 1, SV("12345"), S("abcde12345ghij"));
+    test(S("abcdefghij"), 5, 1, SV("1234567890"), S("abcde1234567890ghij"));
+    test(S("abcdefghij"), 5, 1, SV("12345678901234567890"), S("abcde12345678901234567890ghij"));
+    test(S("abcdefghij"), 5, 2, SV(""), S("abcdehij"));
+    test(S("abcdefghij"), 5, 2, SV("12345"), S("abcde12345hij"));
+    test(S("abcdefghij"), 5, 2, SV("1234567890"), S("abcde1234567890hij"));
+    test(S("abcdefghij"), 5, 2, SV("12345678901234567890"), S("abcde12345678901234567890hij"));
+    test(S("abcdefghij"), 5, 4, SV(""), S("abcdej"));
+    test(S("abcdefghij"), 5, 4, SV("12345"), S("abcde12345j"));
+    test(S("abcdefghij"), 5, 4, SV("1234567890"), S("abcde1234567890j"));
+    test(S("abcdefghij"), 5, 4, SV("12345678901234567890"), S("abcde12345678901234567890j"));
+    test(S("abcdefghij"), 5, 5, SV(""), S("abcde"));
+    test(S("abcdefghij"), 5, 5, SV("12345"), S("abcde12345"));
+    test(S("abcdefghij"), 5, 5, SV("1234567890"), S("abcde1234567890"));
+    test(S("abcdefghij"), 5, 5, SV("12345678901234567890"), S("abcde12345678901234567890"));
+    test(S("abcdefghij"), 5, 6, SV(""), S("abcde"));
+    test(S("abcdefghij"), 5, 6, SV("12345"), S("abcde12345"));
+    test(S("abcdefghij"), 5, 6, SV("1234567890"), S("abcde1234567890"));
+    test(S("abcdefghij"), 5, 6, SV("12345678901234567890"), S("abcde12345678901234567890"));
+    test(S("abcdefghij"), 9, 0, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 9, 0, SV("12345"), S("abcdefghi12345j"));
+    test(S("abcdefghij"), 9, 0, SV("1234567890"), S("abcdefghi1234567890j"));
+    test(S("abcdefghij"), 9, 0, SV("12345678901234567890"), S("abcdefghi12345678901234567890j"));
+    test(S("abcdefghij"), 9, 1, SV(""), S("abcdefghi"));
+    test(S("abcdefghij"), 9, 1, SV("12345"), S("abcdefghi12345"));
+    test(S("abcdefghij"), 9, 1, SV("1234567890"), S("abcdefghi1234567890"));
+    test(S("abcdefghij"), 9, 1, SV("12345678901234567890"), S("abcdefghi12345678901234567890"));
+    test(S("abcdefghij"), 9, 2, SV(""), S("abcdefghi"));
+    test(S("abcdefghij"), 9, 2, SV("12345"), S("abcdefghi12345"));
+    test(S("abcdefghij"), 9, 2, SV("1234567890"), S("abcdefghi1234567890"));
+    test(S("abcdefghij"), 9, 2, SV("12345678901234567890"), S("abcdefghi12345678901234567890"));
+    test(S("abcdefghij"), 10, 0, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 10, 0, SV("12345"), S("abcdefghij12345"));
+    test(S("abcdefghij"), 10, 0, SV("1234567890"), S("abcdefghij1234567890"));
+    test(S("abcdefghij"), 10, 0, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
+    test(S("abcdefghij"), 10, 1, SV(""), S("abcdefghij"));
+    test(S("abcdefghij"), 10, 1, SV("12345"), S("abcdefghij12345"));
+    test(S("abcdefghij"), 10, 1, SV("1234567890"), S("abcdefghij1234567890"));
+    test(S("abcdefghij"), 10, 1, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
+    test(S("abcdefghij"), 11, 0, SV(""), S("can't happen"));
+    test(S("abcdefghij"), 11, 0, SV("12345"), S("can't happen"));
+    test(S("abcdefghij"), 11, 0, SV("1234567890"), S("can't happen"));
+    test(S("abcdefghij"), 11, 0, SV("12345678901234567890"), S("can't happen"));
+}
+
+template <class S, class SV>
+void test2()
+{
+    test(S("abcdefghijklmnopqrst"), 0, 0, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 0, SV("12345"), S("12345abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 0, SV("1234567890"), S("1234567890abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 0, SV("12345678901234567890"), S("12345678901234567890abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 1, SV(""), S("bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345"), S("12345bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 1, SV("1234567890"), S("1234567890bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 1, SV("12345678901234567890"), S("12345678901234567890bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 10, SV(""), S("klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345"), S("12345klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 10, SV("1234567890"), S("1234567890klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 10, SV("12345678901234567890"), S("12345678901234567890klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 0, 19, SV(""), S("t"));
+    test(S("abcdefghijklmnopqrst"), 0, 19, SV("12345"), S("12345t"));
+    test(S("abcdefghijklmnopqrst"), 0, 19, SV("1234567890"), S("1234567890t"));
+    test(S("abcdefghijklmnopqrst"), 0, 19, SV("12345678901234567890"), S("12345678901234567890t"));
+    test(S("abcdefghijklmnopqrst"), 0, 20, SV(""), S(""));
+    test(S("abcdefghijklmnopqrst"), 0, 20, SV("12345"), S("12345"));
+    test(S("abcdefghijklmnopqrst"), 0, 20, SV("1234567890"), S("1234567890"));
+    test(S("abcdefghijklmnopqrst"), 0, 20, SV("12345678901234567890"), S("12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 0, 21, SV(""), S(""));
+    test(S("abcdefghijklmnopqrst"), 0, 21, SV("12345"), S("12345"));
+    test(S("abcdefghijklmnopqrst"), 0, 21, SV("1234567890"), S("1234567890"));
+    test(S("abcdefghijklmnopqrst"), 0, 21, SV("12345678901234567890"), S("12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 1, 0, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345"), S("a12345bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 0, SV("1234567890"), S("a1234567890bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 0, SV("12345678901234567890"), S("a12345678901234567890bcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 1, SV(""), S("acdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 1, SV("12345"), S("a12345cdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 1, SV("1234567890"), S("a1234567890cdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 1, SV("12345678901234567890"), S("a12345678901234567890cdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 9, SV(""), S("aklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345"), S("a12345klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 9, SV("1234567890"), S("a1234567890klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 9, SV("12345678901234567890"), S("a12345678901234567890klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 1, 18, SV(""), S("at"));
+    test(S("abcdefghijklmnopqrst"), 1, 18, SV("12345"), S("a12345t"));
+    test(S("abcdefghijklmnopqrst"), 1, 18, SV("1234567890"), S("a1234567890t"));
+    test(S("abcdefghijklmnopqrst"), 1, 18, SV("12345678901234567890"), S("a12345678901234567890t"));
+    test(S("abcdefghijklmnopqrst"), 1, 19, SV(""), S("a"));
+    test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345"), S("a12345"));
+    test(S("abcdefghijklmnopqrst"), 1, 19, SV("1234567890"), S("a1234567890"));
+    test(S("abcdefghijklmnopqrst"), 1, 19, SV("12345678901234567890"), S("a12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 1, 20, SV(""), S("a"));
+    test(S("abcdefghijklmnopqrst"), 1, 20, SV("12345"), S("a12345"));
+    test(S("abcdefghijklmnopqrst"), 1, 20, SV("1234567890"), S("a1234567890"));
+    test(S("abcdefghijklmnopqrst"), 1, 20, SV("12345678901234567890"), S("a12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 10, 0, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345"), S("abcdefghij12345klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 0, SV("1234567890"), S("abcdefghij1234567890klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 0, SV("12345678901234567890"), S("abcdefghij12345678901234567890klmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 1, SV(""), S("abcdefghijlmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 1, SV("12345"), S("abcdefghij12345lmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 1, SV("1234567890"), S("abcdefghij1234567890lmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 1, SV("12345678901234567890"), S("abcdefghij12345678901234567890lmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 5, SV(""), S("abcdefghijpqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345"), S("abcdefghij12345pqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 5, SV("1234567890"), S("abcdefghij1234567890pqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 5, SV("12345678901234567890"), S("abcdefghij12345678901234567890pqrst"));
+    test(S("abcdefghijklmnopqrst"), 10, 9, SV(""), S("abcdefghijt"));
+    test(S("abcdefghijklmnopqrst"), 10, 9, SV("12345"), S("abcdefghij12345t"));
+    test(S("abcdefghijklmnopqrst"), 10, 9, SV("1234567890"), S("abcdefghij1234567890t"));
+    test(S("abcdefghijklmnopqrst"), 10, 9, SV("12345678901234567890"), S("abcdefghij12345678901234567890t"));
+    test(S("abcdefghijklmnopqrst"), 10, 10, SV(""), S("abcdefghij"));
+    test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345"), S("abcdefghij12345"));
+    test(S("abcdefghijklmnopqrst"), 10, 10, SV("1234567890"), S("abcdefghij1234567890"));
+    test(S("abcdefghijklmnopqrst"), 10, 10, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 10, 11, SV(""), S("abcdefghij"));
+    test(S("abcdefghijklmnopqrst"), 10, 11, SV("12345"), S("abcdefghij12345"));
+    test(S("abcdefghijklmnopqrst"), 10, 11, SV("1234567890"), S("abcdefghij1234567890"));
+    test(S("abcdefghijklmnopqrst"), 10, 11, SV("12345678901234567890"), S("abcdefghij12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 19, 0, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345"), S("abcdefghijklmnopqrs12345t"));
+    test(S("abcdefghijklmnopqrst"), 19, 0, SV("1234567890"), S("abcdefghijklmnopqrs1234567890t"));
+    test(S("abcdefghijklmnopqrst"), 19, 0, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890t"));
+    test(S("abcdefghijklmnopqrst"), 19, 1, SV(""), S("abcdefghijklmnopqrs"));
+    test(S("abcdefghijklmnopqrst"), 19, 1, SV("12345"), S("abcdefghijklmnopqrs12345"));
+    test(S("abcdefghijklmnopqrst"), 19, 1, SV("1234567890"), S("abcdefghijklmnopqrs1234567890"));
+    test(S("abcdefghijklmnopqrst"), 19, 1, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 19, 2, SV(""), S("abcdefghijklmnopqrs"));
+    test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345"), S("abcdefghijklmnopqrs12345"));
+    test(S("abcdefghijklmnopqrst"), 19, 2, SV("1234567890"), S("abcdefghijklmnopqrs1234567890"));
+    test(S("abcdefghijklmnopqrst"), 19, 2, SV("12345678901234567890"), S("abcdefghijklmnopqrs12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 20, 0, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345"), S("abcdefghijklmnopqrst12345"));
+    test(S("abcdefghijklmnopqrst"), 20, 0, SV("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+    test(S("abcdefghijklmnopqrst"), 20, 0, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 20, 1, SV(""), S("abcdefghijklmnopqrst"));
+    test(S("abcdefghijklmnopqrst"), 20, 1, SV("12345"), S("abcdefghijklmnopqrst12345"));
+    test(S("abcdefghijklmnopqrst"), 20, 1, SV("1234567890"), S("abcdefghijklmnopqrst1234567890"));
+    test(S("abcdefghijklmnopqrst"), 20, 1, SV("12345678901234567890"), S("abcdefghijklmnopqrst12345678901234567890"));
+    test(S("abcdefghijklmnopqrst"), 21, 0, SV(""), S("can't happen"));
+    test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345"), S("can't happen"));
+    test(S("abcdefghijklmnopqrst"), 21, 0, SV("1234567890"), S("can't happen"));
+    test(S("abcdefghijklmnopqrst"), 21, 0, SV("12345678901234567890"), S("can't happen"));
+}
+
+int main()
+{
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
+    test0<S, SV>();
+    test1<S, SV>();
+    test2<S, SV>();
+    }
+#if TEST_STD_VER >= 11
+    {
+    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+    typedef std::string_view SV;
+    test0<S, SV>();
+    test1<S, SV>();
+    test2<S, SV>();
+    }
+#endif
+}
diff --git a/test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp b/test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp
index 88c1bee32512..73727198f28e 100644
--- a/test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp
+++ b/test/std/strings/basic.string/string.nonmembers/string.special/swap_noexcept.pass.cpp
@@ -68,7 +68,7 @@ int main()
     {
         typedef std::basic_string<char, std::char_traits<char>, some_alloc<char>> C;
 #if TEST_STD_VER >= 14
-    //  In c++14, if POCS is set, swapping the allocator is required not to throw
+    //  In C++14, if POCS is set, swapping the allocator is required not to throw
         static_assert( noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
 #else
         static_assert(!noexcept(swap(std::declval<C&>(), std::declval<C&>())), "");
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
index bc2bf656db01..94f7890ddfdb 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_T_size_size.pass.cpp
@@ -45,7 +45,7 @@ test(const S& s, typename S::size_type pos1, typename S::size_type n1,
     {
         try
         {
-            s.compare(pos1, n1, sv, pos2, n2);
+            TEST_IGNORE_NODISCARD s.compare(pos1, n1, sv, pos2, n2);
             assert(false);
         }
         catch (const std::out_of_range&)
@@ -69,7 +69,7 @@ test_npos(const S& s, typename S::size_type pos1, typename S::size_type n1,
     {
         try
         {
-            s.compare(pos1, n1, sv, pos2);
+            TEST_IGNORE_NODISCARD s.compare(pos1, n1, sv, pos2);
             assert(false);
         }
         catch (const std::out_of_range&)
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
index 13f6c5a1cd7a..55af081a7261 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer.pass.cpp
@@ -40,7 +40,7 @@ test(const S& s, typename S::size_type pos1, typename S::size_type n1,
     {
         try
         {
-            s.compare(pos1, n1, str);
+            TEST_IGNORE_NODISCARD s.compare(pos1, n1, str);
             assert(false);
         }
         catch (std::out_of_range&)
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
index fc811c84671b..2fcecc7556a1 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_pointer_size.pass.cpp
@@ -40,7 +40,7 @@ test(const S& s, typename S::size_type pos, typename S::size_type n1,
     {
         try
         {
-            s.compare(pos, n1, str, n2);
+            TEST_IGNORE_NODISCARD s.compare(pos, n1, str, n2);
             assert(false);
         }
         catch (std::out_of_range&)
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
index b3d7da29fb1f..0ddbf2e2f99f 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_string.pass.cpp
@@ -40,7 +40,7 @@ test(const S& s, typename S::size_type pos1, typename S::size_type n1,
     {
         try
         {
-            s.compare(pos1, n1, str);
+            TEST_IGNORE_NODISCARD s.compare(pos1, n1, str);
             assert(false);
         }
         catch (std::out_of_range&)
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
index 42bba9d5eb2b..590a1518812f 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_string_size_size.pass.cpp
@@ -42,7 +42,7 @@ test(const S& s,   typename S::size_type pos1, typename S::size_type n1,
     {
         try
         {
-            s.compare(pos1, n1, str, pos2, n2);
+            TEST_IGNORE_NODISCARD s.compare(pos1, n1, str, pos2, n2);
             assert(false);
         }
         catch (const std::out_of_range&)
@@ -65,7 +65,7 @@ test_npos(const S& s,   typename S::size_type pos1, typename S::size_type n1,
     {
         try
         {
-            s.compare(pos1, n1, str, pos2);
+            TEST_IGNORE_NODISCARD s.compare(pos1, n1, str, pos2);
             assert(false);
         }
         catch (const std::out_of_range&)
diff --git a/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp b/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
index 6a5ba22cdc8d..53114f37c0e8 100644
--- a/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_compare/size_size_string_view.pass.cpp
@@ -40,7 +40,7 @@ test(const S& s, typename S::size_type pos1, typename S::size_type n1,
     {
         try
         {
-            s.compare(pos1, n1, sv);
+            TEST_IGNORE_NODISCARD s.compare(pos1, n1, sv);
             assert(false);
         }
         catch (std::out_of_range&)
diff --git a/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp b/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
index 59d216df09b4..7e46ff74a9ec 100644
--- a/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
+++ b/test/std/strings/basic.string/string.ops/string_find.last.not.of/string_view_size.pass.cpp
@@ -150,8 +150,8 @@ int main()
     }
 #if TEST_STD_VER >= 11
     {
-    typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
-    typedef std::string_view SV;
+//     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
+//     typedef std::string_view SV;
 //     test0<S, SV>();
 //     test1<S, SV>();
     }
diff --git a/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp b/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
new file mode 100644
index 000000000000..4be35a76596c
--- /dev/null
+++ b/test/std/strings/basic.string/string.starts_with/starts_with.char.pass.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+//   bool starts_with(charT x) const noexcept;
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    {
+    typedef std::string S;
+    S  s1 {};
+    S  s2 { "abcde", 5 };
+
+    ASSERT_NOEXCEPT(s1.starts_with('e'));
+
+    assert (!s1.starts_with('a'));
+    assert (!s1.starts_with('x'));
+    assert ( s2.starts_with('a'));
+    assert (!s2.starts_with('x'));
+    }
+}
diff --git a/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp b/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
new file mode 100644
index 000000000000..5dec2156ed0a
--- /dev/null
+++ b/test/std/strings/basic.string/string.starts_with/starts_with.ptr.pass.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+//   bool starts_with(const CharT *x) const;
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    {
+    typedef std::string S;
+    const char *s = "abcde";
+    S  s0 {};
+    S  s1 { s, 1 };
+    S  s2 { s, 2 };
+//     S  s3 { s, 3 };
+//     S  s4 { s, 4 };
+//     S  s5 { s, 5 };
+    S  sNot {"def", 3 };
+
+    LIBCPP_ASSERT_NOEXCEPT(s0.starts_with(""));
+
+    assert ( s0.starts_with(""));
+    assert (!s0.starts_with("a"));
+
+    assert ( s1.starts_with(""));
+    assert ( s1.starts_with("a"));
+    assert (!s1.starts_with("ab"));
+    assert (!s1.starts_with("abc"));
+    assert (!s1.starts_with("abcd"));
+    assert (!s1.starts_with("abcde"));
+    assert (!s1.starts_with("def"));
+
+    assert ( s2.starts_with(""));
+    assert ( s2.starts_with("a"));
+    assert ( s2.starts_with("ab"));
+    assert (!s2.starts_with("abc"));
+    assert (!s2.starts_with("abcd"));
+    assert (!s2.starts_with("abcde"));
+    assert (!s2.starts_with("def"));
+
+    assert ( sNot.starts_with(""));
+    assert (!sNot.starts_with("a"));
+    assert (!sNot.starts_with("ab"));
+    assert (!sNot.starts_with("abc"));
+    assert (!sNot.starts_with("abcd"));
+    assert (!sNot.starts_with("abcde"));
+    assert ( sNot.starts_with("def"));
+    }
+}
diff --git a/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp b/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
new file mode 100644
index 000000000000..d542d3d79e13
--- /dev/null
+++ b/test/std/strings/basic.string/string.starts_with/starts_with.string_view.pass.cpp
@@ -0,0 +1,72 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string>
+
+//   bool starts_with(string_view x) const noexcept;
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    {
+    typedef std::string S;
+    typedef std::string_view SV;
+    const char *s = "abcde";
+
+    S   s0;
+    S   s1  { s, 1 };
+    S   s2  { s, 2 };
+//  S   s3  { s, 3 };
+//  S   s4  { s, 4 };
+//  S   s5  { s, 5 };
+    S  sNot { "def", 3 };
+
+    SV  sv0;
+    SV  sv1 { s, 1 };
+    SV  sv2 { s, 2 };
+    SV  sv3 { s, 3 };
+    SV  sv4 { s, 4 };
+    SV  sv5 { s, 5 };
+    SV svNot {"def", 3 };
+
+    ASSERT_NOEXCEPT(s0.starts_with(sv0));
+
+    assert ( s0.starts_with(sv0));
+    assert (!s0.starts_with(sv1));
+
+    assert ( s1.starts_with(sv0));
+    assert ( s1.starts_with(sv1));
+    assert (!s1.starts_with(sv2));
+    assert (!s1.starts_with(sv3));
+    assert (!s1.starts_with(sv4));
+    assert (!s1.starts_with(sv5));
+    assert (!s1.starts_with(svNot));
+
+    assert ( s2.starts_with(sv0));
+    assert ( s2.starts_with(sv1));
+    assert ( s2.starts_with(sv2));
+    assert (!s2.starts_with(sv3));
+    assert (!s2.starts_with(sv4));
+    assert (!s2.starts_with(sv5));
+    assert (!s2.starts_with(svNot));
+
+    assert ( sNot.starts_with(sv0));
+    assert (!sNot.starts_with(sv1));
+    assert (!sNot.starts_with(sv2));
+    assert (!sNot.starts_with(sv3));
+    assert (!sNot.starts_with(sv4));
+    assert (!sNot.starts_with(sv5));
+    assert ( sNot.starts_with(svNot));
+    }
+}
diff --git a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp
index 9b552347fe9e..4cf2b0adce02 100644
--- a/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp
+++ b/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char/lt.pass.cpp
@@ -1,6 +1,6 @@
 //===----------------------------------------------------------------------===//
 //
-//					   The LLVM Compiler Infrastructure
+//                     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.
@@ -18,16 +18,16 @@
 
 int main()
 {
-	assert( std::char_traits<char>::lt('\0', 'A'));
-	assert(!std::char_traits<char>::lt('A', '\0'));
+    assert( std::char_traits<char>::lt('\0', 'A'));
+    assert(!std::char_traits<char>::lt('A', '\0'));
 
-	assert(!std::char_traits<char>::lt('a', 'a'));
-	assert( std::char_traits<char>::lt('A', 'a'));
-	assert(!std::char_traits<char>::lt('a', 'A'));
+    assert(!std::char_traits<char>::lt('a', 'a'));
+    assert( std::char_traits<char>::lt('A', 'a'));
+    assert(!std::char_traits<char>::lt('a', 'A'));
 
-	assert( std::char_traits<char>::lt('a', 'z'));
-	assert( std::char_traits<char>::lt('A', 'Z'));
+    assert( std::char_traits<char>::lt('a', 'z'));
+    assert( std::char_traits<char>::lt('A', 'Z'));
 
-	assert( std::char_traits<char>::lt(' ', 'A'));
-	assert( std::char_traits<char>::lt('A', '~'));
+    assert( std::char_traits<char>::lt(' ', 'A'));
+    assert( std::char_traits<char>::lt('A', '~'));
 }
diff --git a/test/std/strings/string.view/string.view.access/at.pass.cpp b/test/std/strings/string.view/string.view.access/at.pass.cpp
index 6df879898f44..7d5cf241e66b 100644
--- a/test/std/strings/string.view/string.view.access/at.pass.cpp
+++ b/test/std/strings/string.view/string.view.access/at.pass.cpp
@@ -32,7 +32,7 @@ void test ( const CharT *s, size_t len ) {
     }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
-    try { sv.at(len); } catch ( const std::out_of_range & ) { return ; }
+    try { (void)sv.at(len); } catch ( const std::out_of_range & ) { return ; }
     assert ( false );
 #endif
 }
diff --git a/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp b/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp
index d36c27886295..bb733c4fb13d 100644
--- a/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp
+++ b/test/std/strings/string.view/string.view.capacity/capacity.pass.cpp
@@ -35,6 +35,10 @@ void test1 () {
 
     {
     SV sv1;
+    ASSERT_NOEXCEPT(sv1.size());
+    ASSERT_NOEXCEPT(sv1.empty());
+    ASSERT_NOEXCEPT(sv1.max_size());
+    ASSERT_NOEXCEPT(sv1.length());
     assert ( sv1.size() == 0 );
     assert ( sv1.empty());
     assert ( sv1.size() == sv1.length());
diff --git a/test/std/strings/string.view/string.view.capacity/empty.fail.cpp b/test/std/strings/string.view/string.view.capacity/empty.fail.cpp
new file mode 100644
index 000000000000..da1a67b0844d
--- /dev/null
+++ b/test/std/strings/string.view/string.view.capacity/empty.fail.cpp
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <string_view>
+
+// class string_view
+
+// bool empty() const noexcept;
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <string_view>
+
+#include "test_macros.h"
+
+int main ()
+{
+    std::string_view c;
+    c.empty();  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/strings/string.view/string.view.cons/default.pass.cpp b/test/std/strings/string.view/string.view.cons/default.pass.cpp
index ca332801ead9..79fadf619f25 100644
--- a/test/std/strings/string.view/string.view.cons/default.pass.cpp
+++ b/test/std/strings/string.view/string.view.cons/default.pass.cpp
@@ -21,6 +21,8 @@ template<typename T>
 void test () {
 #if TEST_STD_VER > 11
     {
+    ASSERT_NOEXCEPT(T());
+
     constexpr T sv1;
     static_assert ( sv1.size() == 0, "" );
     static_assert ( sv1.empty(), "");
diff --git a/test/std/strings/string.view/string.view.cons/from_literal.pass.cpp b/test/std/strings/string.view/string.view.cons/from_literal.pass.cpp
index 6c9939340ce2..c98a8bd674b4 100644
--- a/test/std/strings/string.view/string.view.cons/from_literal.pass.cpp
+++ b/test/std/strings/string.view/string.view.cons/from_literal.pass.cpp
@@ -30,7 +30,11 @@ size_t StrLen ( const CharT *s ) {
 
 template<typename CharT>
 void test ( const CharT *s ) {
-    std::basic_string_view<CharT> sv1 ( s );
+    typedef std::basic_string_view<CharT> SV;
+//  I'd love to do this, but it would require traits::length() to be noexcept
+//  LIBCPP_ASSERT_NOEXCEPT(SV(s));
+
+    SV sv1 ( s );
     assert ( sv1.size() == StrLen( s ));
     assert ( sv1.data() == s );
     }
diff --git a/test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp b/test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp
index da4d264ae371..2e4faab95005 100644
--- a/test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp
+++ b/test/std/strings/string.view/string.view.cons/from_ptr_len.pass.cpp
@@ -23,7 +23,10 @@
 template<typename CharT>
 void test ( const CharT *s, size_t sz ) {
     {
-    std::basic_string_view<CharT> sv1 ( s, sz );
+    typedef std::basic_string_view<CharT> SV;
+    LIBCPP_ASSERT_NOEXCEPT(SV(s, sz));
+
+    SV sv1 ( s, sz );
     assert ( sv1.size() == sz );
     assert ( sv1.data() == s );
     }
diff --git a/test/std/strings/string.view/string.view.cons/from_string.pass.cpp b/test/std/strings/string.view/string.view.cons/from_string.pass.cpp
index 3ca6ea16f5b8..5fad2bfaab14 100644
--- a/test/std/strings/string.view/string.view.cons/from_string.pass.cpp
+++ b/test/std/strings/string.view/string.view.cons/from_string.pass.cpp
@@ -24,7 +24,10 @@ struct dummy_char_traits : public std::char_traits<char> {};
 
 template<typename CharT, typename Traits>
 void test ( const std::basic_string<CharT, Traits> &str ) {
-    std::basic_string_view<CharT, Traits> sv1 ( str );
+    typedef std::basic_string_view<CharT, Traits> SV;
+    ASSERT_NOEXCEPT(SV(str));
+
+    SV sv1 ( str );
     assert ( sv1.size() == str.size());
     assert ( sv1.data() == str.data());
 }
diff --git a/test/std/strings/string.view/string.view.cons/from_string1.fail.cpp b/test/std/strings/string.view/string.view.cons/from_string1.fail.cpp
index 0f33dd87bca0..006bea7498ac 100644
--- a/test/std/strings/string.view/string.view.cons/from_string1.fail.cpp
+++ b/test/std/strings/string.view/string.view.cons/from_string1.fail.cpp
@@ -29,4 +29,4 @@ int main () {
     assert ( sv1.size() == s.size());
     assert ( sv1.data() == s.data());
     }
-}
\ No newline at end of file
+}
diff --git a/test/std/strings/string.view/string.view.template/ends_with.char.pass.cpp b/test/std/strings/string.view/string.view.template/ends_with.char.pass.cpp
new file mode 100644
index 000000000000..1511f014b18d
--- /dev/null
+++ b/test/std/strings/string.view/string.view.template/ends_with.char.pass.cpp
@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string_view>
+
+//   constexpr bool ends_with(charT x) const noexcept;
+
+#include <string_view>
+#include <cassert>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.hpp"
+
+int main()
+{
+    {
+    typedef std::string_view SV;
+    SV  sv1 {};
+    SV  sv2 { "abcde", 5 };
+
+    ASSERT_NOEXCEPT(sv1.ends_with('e'));
+
+    assert (!sv1.ends_with('e'));
+    assert (!sv1.ends_with('x'));
+    assert ( sv2.ends_with('e'));
+    assert (!sv2.ends_with('x'));
+    }
+
+#if TEST_STD_VER > 11
+    {
+    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
+    constexpr SV  sv1 {};
+    constexpr SV  sv2 { "abcde", 5 };
+    static_assert (!sv1.ends_with('e'), "" );
+    static_assert (!sv1.ends_with('x'), "" );
+    static_assert ( sv2.ends_with('e'), "" );
+    static_assert (!sv2.ends_with('x'), "" );
+    }
+#endif
+}
diff --git a/test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp b/test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp
new file mode 100644
index 000000000000..544cddd84076
--- /dev/null
+++ b/test/std/strings/string.view/string.view.template/ends_with.ptr.pass.cpp
@@ -0,0 +1,104 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string_view>
+
+//   constexpr bool starts_with(const CharT *x) const;
+
+#include <string_view>
+#include <cassert>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.hpp"
+
+int main()
+{
+    {
+    typedef std::string_view SV;
+    const char *s = "abcde";
+    SV  sv0 {};
+    SV  sv1 { s + 4, 1 };
+    SV  sv2 { s + 3, 2 };
+//     SV  sv3 { s + 2, 3 };
+//     SV  sv4 { s + 1, 4 };
+//     SV  sv5 { s    , 5 };
+    SV  svNot {"def", 3 };
+
+    LIBCPP_ASSERT_NOEXCEPT(sv0.ends_with(""));
+
+    assert ( sv0.ends_with(""));
+    assert (!sv0.ends_with("e"));
+
+    assert ( sv1.ends_with(""));
+    assert ( sv1.ends_with("e"));
+    assert (!sv1.ends_with("de"));
+    assert (!sv1.ends_with("cde"));
+    assert (!sv1.ends_with("bcde"));
+    assert (!sv1.ends_with("abcde"));
+    assert (!sv1.ends_with("def"));
+
+    assert ( sv2.ends_with(""));
+    assert ( sv2.ends_with("e"));
+    assert ( sv2.ends_with("de"));
+    assert (!sv2.ends_with("cde"));
+    assert (!sv2.ends_with("bcde"));
+    assert (!sv2.ends_with("abcde"));
+    assert (!sv2.ends_with("def"));
+
+    assert ( svNot.ends_with(""));
+    assert (!svNot.ends_with("e"));
+    assert (!svNot.ends_with("de"));
+    assert (!svNot.ends_with("cde"));
+    assert (!svNot.ends_with("bcde"));
+    assert (!svNot.ends_with("abcde"));
+    assert ( svNot.ends_with("def"));
+    }
+
+#if TEST_STD_VER > 11
+    {
+    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
+    constexpr const char *s = "abcde";
+    constexpr SV  sv0 {};
+    constexpr SV  sv1 { s + 4, 1 };
+    constexpr SV  sv2 { s + 3, 2 };
+//     constexpr SV  sv3 { s + 2, 3 };
+//     constexpr SV  sv4 { s + 1, 4 };
+//     constexpr SV  sv5 { s,     5 };
+    constexpr SV  svNot {"def", 3 };
+
+    static_assert ( sv0.ends_with(""), "" );
+    static_assert (!sv0.ends_with("e"), "" );
+
+    static_assert ( sv1.ends_with(""), "" );
+    static_assert ( sv1.ends_with("e"), "" );
+    static_assert (!sv1.ends_with("de"), "" );
+    static_assert (!sv1.ends_with("cde"), "" );
+    static_assert (!sv1.ends_with("bcde"), "" );
+    static_assert (!sv1.ends_with("abcde"), "" );
+    static_assert (!sv1.ends_with("def"), "" );
+
+    static_assert ( sv2.ends_with(""), "" );
+    static_assert ( sv2.ends_with("e"), "" );
+    static_assert ( sv2.ends_with("de"), "" );
+    static_assert (!sv2.ends_with("cde"), "" );
+    static_assert (!sv2.ends_with("bcde"), "" );
+    static_assert (!sv2.ends_with("abcde"), "" );
+    static_assert (!sv2.ends_with("def"), "" );
+
+    static_assert ( svNot.ends_with(""), "" );
+    static_assert (!svNot.ends_with("e"), "" );
+    static_assert (!svNot.ends_with("de"), "" );
+    static_assert (!svNot.ends_with("cde"), "" );
+    static_assert (!svNot.ends_with("bcde"), "" );
+    static_assert (!svNot.ends_with("abcde"), "" );
+    static_assert ( svNot.ends_with("def"), "" );
+    }
+#endif
+}
diff --git a/test/std/strings/string.view/string.view.template/ends_with.string_view.pass.cpp b/test/std/strings/string.view/string.view.template/ends_with.string_view.pass.cpp
new file mode 100644
index 000000000000..61ea807ba37e
--- /dev/null
+++ b/test/std/strings/string.view/string.view.template/ends_with.string_view.pass.cpp
@@ -0,0 +1,104 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string_view>
+
+//   constexpr bool ends_with(string_view x) const noexcept;
+
+#include <string_view>
+#include <cassert>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.hpp"
+
+int main()
+{
+    {
+    typedef std::string_view SV;
+    const char *s = "abcde";
+    SV  sv0;
+    SV  sv1 { s + 4, 1 };
+    SV  sv2 { s + 3, 2 };
+    SV  sv3 { s + 2, 3 };
+    SV  sv4 { s + 1, 4 };
+    SV  sv5 { s    , 5 };
+    SV  svNot {"def", 3 };
+
+    ASSERT_NOEXCEPT(sv0.ends_with(sv0));
+
+    assert ( sv0.ends_with(sv0));
+    assert (!sv0.ends_with(sv1));
+
+    assert ( sv1.ends_with(sv0));
+    assert ( sv1.ends_with(sv1));
+    assert (!sv1.ends_with(sv2));
+    assert (!sv1.ends_with(sv3));
+    assert (!sv1.ends_with(sv4));
+    assert (!sv1.ends_with(sv5));
+    assert (!sv1.ends_with(svNot));
+
+    assert ( sv2.ends_with(sv0));
+    assert ( sv2.ends_with(sv1));
+    assert ( sv2.ends_with(sv2));
+    assert (!sv2.ends_with(sv3));
+    assert (!sv2.ends_with(sv4));
+    assert (!sv2.ends_with(sv5));
+    assert (!sv2.ends_with(svNot));
+
+    assert ( svNot.ends_with(sv0));
+    assert (!svNot.ends_with(sv1));
+    assert (!svNot.ends_with(sv2));
+    assert (!svNot.ends_with(sv3));
+    assert (!svNot.ends_with(sv4));
+    assert (!svNot.ends_with(sv5));
+    assert ( svNot.ends_with(svNot));
+    }
+
+#if TEST_STD_VER > 11
+    {
+    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
+    constexpr const char *s = "abcde";
+    constexpr SV  sv0 {};
+    constexpr SV  sv1 { s + 4, 1 };
+    constexpr SV  sv2 { s + 3, 2 };
+    constexpr SV  sv3 { s + 2, 3 };
+    constexpr SV  sv4 { s + 1, 4 };
+    constexpr SV  sv5 { s,     5 };
+    constexpr SV  svNot {"def", 3 };
+
+    static_assert ( sv0.ends_with(sv0), "" );
+    static_assert (!sv0.ends_with(sv1), "" );
+
+    static_assert ( sv1.ends_with(sv0), "" );
+    static_assert ( sv1.ends_with(sv1), "" );
+    static_assert (!sv1.ends_with(sv2), "" );
+    static_assert (!sv1.ends_with(sv3), "" );
+    static_assert (!sv1.ends_with(sv4), "" );
+    static_assert (!sv1.ends_with(sv5), "" );
+    static_assert (!sv1.ends_with(svNot), "" );
+
+    static_assert ( sv2.ends_with(sv0), "" );
+    static_assert ( sv2.ends_with(sv1), "" );
+    static_assert ( sv2.ends_with(sv2), "" );
+    static_assert (!sv2.ends_with(sv3), "" );
+    static_assert (!sv2.ends_with(sv4), "" );
+    static_assert (!sv2.ends_with(sv5), "" );
+    static_assert (!sv2.ends_with(svNot), "" );
+
+    static_assert ( svNot.ends_with(sv0), "" );
+    static_assert (!svNot.ends_with(sv1), "" );
+    static_assert (!svNot.ends_with(sv2), "" );
+    static_assert (!svNot.ends_with(sv3), "" );
+    static_assert (!svNot.ends_with(sv4), "" );
+    static_assert (!svNot.ends_with(sv5), "" );
+    static_assert ( svNot.ends_with(svNot), "" );
+    }
+#endif
+}
diff --git a/test/std/strings/string.view/string.view.template/starts_with.char.pass.cpp b/test/std/strings/string.view/string.view.template/starts_with.char.pass.cpp
new file mode 100644
index 000000000000..042aea601b8d
--- /dev/null
+++ b/test/std/strings/string.view/string.view.template/starts_with.char.pass.cpp
@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string_view>
+
+//   constexpr bool starts_with(charT x) const noexcept;
+
+#include <string_view>
+#include <cassert>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.hpp"
+
+int main()
+{
+    {
+    typedef std::string_view SV;
+    SV  sv1 {};
+    SV  sv2 { "abcde", 5 };
+
+    ASSERT_NOEXCEPT(sv1.starts_with('e'));
+
+    assert (!sv1.starts_with('a'));
+    assert (!sv1.starts_with('x'));
+    assert ( sv2.starts_with('a'));
+    assert (!sv2.starts_with('x'));
+    }
+
+#if TEST_STD_VER > 11
+    {
+    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
+    constexpr SV  sv1 {};
+    constexpr SV  sv2 { "abcde", 5 };
+    static_assert (!sv1.starts_with('a'), "" );
+    static_assert (!sv1.starts_with('x'), "" );
+    static_assert ( sv2.starts_with('a'), "" );
+    static_assert (!sv2.starts_with('x'), "" );
+    }
+#endif
+}
diff --git a/test/std/strings/string.view/string.view.template/starts_with.ptr.pass.cpp b/test/std/strings/string.view/string.view.template/starts_with.ptr.pass.cpp
new file mode 100644
index 000000000000..baaa4c973bb1
--- /dev/null
+++ b/test/std/strings/string.view/string.view.template/starts_with.ptr.pass.cpp
@@ -0,0 +1,104 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string_view>
+
+//   constexpr bool starts_with(string_view x) const noexcept;
+
+#include <string_view>
+#include <cassert>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.hpp"
+
+int main()
+{
+    {
+    typedef std::string_view SV;
+    const char *s = "abcde";
+    SV  sv0 {};
+    SV  sv1 { s, 1 };
+    SV  sv2 { s, 2 };
+//     SV  sv3 { s, 3 };
+//     SV  sv4 { s, 4 };
+//     SV  sv5 { s, 5 };
+    SV  svNot {"def", 3 };
+
+    LIBCPP_ASSERT_NOEXCEPT(sv0.starts_with(""));
+
+    assert ( sv0.starts_with(""));
+    assert (!sv0.starts_with("a"));
+
+    assert ( sv1.starts_with(""));
+    assert ( sv1.starts_with("a"));
+    assert (!sv1.starts_with("ab"));
+    assert (!sv1.starts_with("abc"));
+    assert (!sv1.starts_with("abcd"));
+    assert (!sv1.starts_with("abcde"));
+    assert (!sv1.starts_with("def"));
+
+    assert ( sv2.starts_with(s + 5));
+    assert ( sv2.starts_with("a"));
+    assert ( sv2.starts_with("ab"));
+    assert (!sv2.starts_with("abc"));
+    assert (!sv2.starts_with("abcd"));
+    assert (!sv2.starts_with("abcde"));
+    assert (!sv2.starts_with("def"));
+
+    assert ( svNot.starts_with(""));
+    assert (!svNot.starts_with("a"));
+    assert (!svNot.starts_with("ab"));
+    assert (!svNot.starts_with("abc"));
+    assert (!svNot.starts_with("abcd"));
+    assert (!svNot.starts_with("abcde"));
+    assert ( svNot.starts_with("def"));
+    }
+
+#if TEST_STD_VER > 11
+    {
+    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
+    constexpr const char *s = "abcde";
+    constexpr SV  sv0 {};
+    constexpr SV  sv1 { s, 1 };
+    constexpr SV  sv2 { s, 2 };
+//     constexpr SV  sv3 { s, 3 };
+//     constexpr SV  sv4 { s, 4 };
+//     constexpr SV  sv5 { s, 5 };
+    constexpr SV  svNot {"def", 3 };
+
+    static_assert ( sv0.starts_with(""), "" );
+    static_assert (!sv0.starts_with("a"), "" );
+
+    static_assert ( sv1.starts_with(""), "" );
+    static_assert ( sv1.starts_with("a"), "" );
+    static_assert (!sv1.starts_with("ab"), "" );
+    static_assert (!sv1.starts_with("abc"), "" );
+    static_assert (!sv1.starts_with("abcd"), "" );
+    static_assert (!sv1.starts_with("abcde"), "" );
+    static_assert (!sv1.starts_with("def"), "" );
+
+    static_assert ( sv2.starts_with(s + 5), "" );
+    static_assert ( sv2.starts_with("a"), "" );
+    static_assert ( sv2.starts_with("ab"), "" );
+    static_assert (!sv2.starts_with("abc"), "" );
+    static_assert (!sv2.starts_with("abcd"), "" );
+    static_assert (!sv2.starts_with("abcde"), "" );
+    static_assert (!sv2.starts_with("def"), "" );
+
+    static_assert ( svNot.starts_with(""), "" );
+    static_assert (!svNot.starts_with("a"), "" );
+    static_assert (!svNot.starts_with("ab"), "" );
+    static_assert (!svNot.starts_with("abc"), "" );
+    static_assert (!svNot.starts_with("abcd"), "" );
+    static_assert (!svNot.starts_with("abcde"), "" );
+    static_assert ( svNot.starts_with("def"), "" );
+    }
+#endif
+}
diff --git a/test/std/strings/string.view/string.view.template/starts_with.string_view.pass.cpp b/test/std/strings/string.view/string.view.template/starts_with.string_view.pass.cpp
new file mode 100644
index 000000000000..7501926af4d9
--- /dev/null
+++ b/test/std/strings/string.view/string.view.template/starts_with.string_view.pass.cpp
@@ -0,0 +1,104 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <string_view>
+
+//   constexpr bool starts_with(string_view x) const noexcept;
+
+#include <string_view>
+#include <cassert>
+
+#include "test_macros.h"
+#include "constexpr_char_traits.hpp"
+
+int main()
+{
+    {
+    typedef std::string_view SV;
+    const char *s = "abcde";
+    SV  sv0 {};
+    SV  sv1 { s, 1 };
+    SV  sv2 { s, 2 };
+    SV  sv3 { s, 3 };
+    SV  sv4 { s, 4 };
+    SV  sv5 { s, 5 };
+    SV  svNot {"def", 3 };
+
+    ASSERT_NOEXCEPT(sv0.starts_with(sv0));
+
+    assert ( sv0.starts_with(sv0));
+    assert (!sv0.starts_with(sv1));
+
+    assert ( sv1.starts_with(sv0));
+    assert ( sv1.starts_with(sv1));
+    assert (!sv1.starts_with(sv2));
+    assert (!sv1.starts_with(sv3));
+    assert (!sv1.starts_with(sv4));
+    assert (!sv1.starts_with(sv5));
+    assert (!sv1.starts_with(svNot));
+
+    assert ( sv2.starts_with(sv0));
+    assert ( sv2.starts_with(sv1));
+    assert ( sv2.starts_with(sv2));
+    assert (!sv2.starts_with(sv3));
+    assert (!sv2.starts_with(sv4));
+    assert (!sv2.starts_with(sv5));
+    assert (!sv2.starts_with(svNot));
+
+    assert ( svNot.starts_with(sv0));
+    assert (!svNot.starts_with(sv1));
+    assert (!svNot.starts_with(sv2));
+    assert (!svNot.starts_with(sv3));
+    assert (!svNot.starts_with(sv4));
+    assert (!svNot.starts_with(sv5));
+    assert ( svNot.starts_with(svNot));
+    }
+
+#if TEST_STD_VER > 11
+    {
+    typedef std::basic_string_view<char, constexpr_char_traits<char>> SV;
+    constexpr const char *s = "abcde";
+    constexpr SV  sv0 {};
+    constexpr SV  sv1 { s, 1 };
+    constexpr SV  sv2 { s, 2 };
+    constexpr SV  sv3 { s, 3 };
+    constexpr SV  sv4 { s, 4 };
+    constexpr SV  sv5 { s, 5 };
+    constexpr SV  svNot {"def", 3 };
+
+    static_assert ( sv0.starts_with(sv0), "" );
+    static_assert (!sv0.starts_with(sv1), "" );
+
+    static_assert ( sv1.starts_with(sv0), "" );
+    static_assert ( sv1.starts_with(sv1), "" );
+    static_assert (!sv1.starts_with(sv2), "" );
+    static_assert (!sv1.starts_with(sv3), "" );
+    static_assert (!sv1.starts_with(sv4), "" );
+    static_assert (!sv1.starts_with(sv5), "" );
+    static_assert (!sv1.starts_with(svNot), "" );
+
+    static_assert ( sv2.starts_with(sv0), "" );
+    static_assert ( sv2.starts_with(sv1), "" );
+    static_assert ( sv2.starts_with(sv2), "" );
+    static_assert (!sv2.starts_with(sv3), "" );
+    static_assert (!sv2.starts_with(sv4), "" );
+    static_assert (!sv2.starts_with(sv5), "" );
+    static_assert (!sv2.starts_with(svNot), "" );
+
+    static_assert ( svNot.starts_with(sv0), "" );
+    static_assert (!svNot.starts_with(sv1), "" );
+    static_assert (!svNot.starts_with(sv2), "" );
+    static_assert (!svNot.starts_with(sv3), "" );
+    static_assert (!svNot.starts_with(sv4), "" );
+    static_assert (!svNot.starts_with(sv5), "" );
+    static_assert ( svNot.starts_with(svNot), "" );
+    }
+#endif
+}
diff --git a/test/std/strings/string.view/string_view.literals/literal.pass.cpp b/test/std/strings/string.view/string_view.literals/literal.pass.cpp
index 710009cc51ee..79fe355289d1 100644
--- a/test/std/strings/string.view/string_view.literals/literal.pass.cpp
+++ b/test/std/strings/string.view/string_view.literals/literal.pass.cpp
@@ -54,4 +54,10 @@ int main()
     static_assert( L"ABC"sv.size() == 3, "");
     static_assert( u"ABC"sv.size() == 3, "");
     static_assert( U"ABC"sv.size() == 3, "");
+
+    static_assert(noexcept(  "ABC"sv), "");
+    static_assert(noexcept(u8"ABC"sv), "");
+    static_assert(noexcept( L"ABC"sv), "");
+    static_assert(noexcept( u"ABC"sv), "");
+    static_assert(noexcept( U"ABC"sv), "");
 }
diff --git a/test/std/thread/futures/futures.async/async.fail.cpp b/test/std/thread/futures/futures.async/async.fail.cpp
new file mode 100644
index 000000000000..594c67f52699
--- /dev/null
+++ b/test/std/thread/futures/futures.async/async.fail.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+// <future>
+
+// template <class F, class... Args>
+//     future<typename result_of<F(Args...)>::type>
+//     async(F&& f, Args&&... args);
+
+// template <class F, class... Args>
+//     future<typename result_of<F(Args...)>::type>
+//     async(launch policy, F&& f, Args&&... args);
+
+
+#include <future>
+#include <atomic>
+#include <memory>
+#include <cassert>
+
+#include "test_macros.h"
+
+int foo (int x) { return x; }
+
+int main ()
+{
+	std::async(                    foo, 3); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+	std::async(std::launch::async, foo, 3); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
\ No newline at end of file
diff --git a/test/std/thread/futures/futures.async/async_race.pass.cpp b/test/std/thread/futures/futures.async/async_race.pass.cpp
index 9acdd1abc485..1189f3550b72 100644
--- a/test/std/thread/futures/futures.async/async_race.pass.cpp
+++ b/test/std/thread/futures/futures.async/async_race.pass.cpp
@@ -21,7 +21,7 @@
 //     async(launch policy, F&& f, Args&&... args);
 
 // This test is designed to cause and allow TSAN to detect the race condition
-// reported in PR23293. (http://llvm.org/PR23293).
+// reported in PR23293: https://bugs.llvm.org/show_bug.cgi?id=23293
 
 #include <future>
 #include <chrono>
diff --git a/test/std/thread/futures/futures.shared_future/wait_until.pass.cpp b/test/std/thread/futures/futures.shared_future/wait_until.pass.cpp
index 9cdc2e431f45..0ddbd0b08936 100644
--- a/test/std/thread/futures/futures.shared_future/wait_until.pass.cpp
+++ b/test/std/thread/futures/futures.shared_future/wait_until.pass.cpp
@@ -1,130 +1,130 @@
- //===----------------------------------------------------------------------===//
- //
- //                     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.
- //
- //===----------------------------------------------------------------------===//
- //
- // UNSUPPORTED: libcpp-has-no-threads
- // UNSUPPORTED: c++98, c++03
-
- // <future>
-
- // class shared_future<R>
-
- // template <class Clock, class Duration>
- //   future_status
- //   wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
-
- #include <future>
- #include <atomic>
- #include <cassert>
-
- enum class WorkerThreadState { Uninitialized, AllowedToRun, Exiting };
- typedef std::chrono::milliseconds ms;
-
- std::atomic<WorkerThreadState> thread_state(WorkerThreadState::Uninitialized);
-
- void set_worker_thread_state(WorkerThreadState state)
- {
-     thread_state.store(state, std::memory_order_relaxed);
- }
-
- void wait_for_worker_thread_state(WorkerThreadState state)
- {
-     while (thread_state.load(std::memory_order_relaxed) != state);
- }
-
- void func1(std::promise<int> p)
- {
-     wait_for_worker_thread_state(WorkerThreadState::AllowedToRun);
-     p.set_value(3);
-     set_worker_thread_state(WorkerThreadState::Exiting);
- }
-
- int j = 0;
-
- void func3(std::promise<int&> p)
- {
-     wait_for_worker_thread_state(WorkerThreadState::AllowedToRun);
-     j = 5;
-     p.set_value(j);
-     set_worker_thread_state(WorkerThreadState::Exiting);
- }
-
- void func5(std::promise<void> p)
- {
-     wait_for_worker_thread_state(WorkerThreadState::AllowedToRun);
-     p.set_value();
-     set_worker_thread_state(WorkerThreadState::Exiting);
- }
-
- int main()
- {
-     typedef std::chrono::high_resolution_clock Clock;
-     {
-         typedef int T;
-         std::promise<T> p;
-         std::shared_future<T> f = p.get_future();
-         std::thread(func1, std::move(p)).detach();
-         assert(f.valid());
-         assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::timeout);
-         assert(f.valid());
-
-         // allow the worker thread to produce the result and wait until the worker is done
-         set_worker_thread_state(WorkerThreadState::AllowedToRun);
-         wait_for_worker_thread_state(WorkerThreadState::Exiting);
-
-         assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::ready);
-         assert(f.valid());
-         Clock::time_point t0 = Clock::now();
-         f.wait();
-         Clock::time_point t1 = Clock::now();
-         assert(f.valid());
-         assert(t1-t0 < ms(5));
-     }
-     {
-         typedef int& T;
-         std::promise<T> p;
-         std::shared_future<T> f = p.get_future();
-         std::thread(func3, std::move(p)).detach();
-         assert(f.valid());
-         assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::timeout);
-         assert(f.valid());
-
-         // allow the worker thread to produce the result and wait until the worker is done
-         set_worker_thread_state(WorkerThreadState::AllowedToRun);
-         wait_for_worker_thread_state(WorkerThreadState::Exiting);
-
-         assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::ready);
-         assert(f.valid());
-         Clock::time_point t0 = Clock::now();
-         f.wait();
-         Clock::time_point t1 = Clock::now();
-         assert(f.valid());
-         assert(t1-t0 < ms(5));
-     }
-     {
-         typedef void T;
-         std::promise<T> p;
-         std::shared_future<T> f = p.get_future();
-         std::thread(func5, std::move(p)).detach();
-         assert(f.valid());
-         assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::timeout);
-         assert(f.valid());
-
-         // allow the worker thread to produce the result and wait until the worker is done
-         set_worker_thread_state(WorkerThreadState::AllowedToRun);
-         wait_for_worker_thread_state(WorkerThreadState::Exiting);
-
-         assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::ready);
-         assert(f.valid());
-         Clock::time_point t0 = Clock::now();
-         f.wait();
-         Clock::time_point t1 = Clock::now();
-         assert(f.valid());
-         assert(t1-t0 < ms(5));
-     }
- }
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: c++98, c++03
+
+// <future>
+
+// class shared_future<R>
+
+// template <class Clock, class Duration>
+//   future_status
+//   wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
+
+#include <future>
+#include <atomic>
+#include <cassert>
+
+enum class WorkerThreadState { Uninitialized, AllowedToRun, Exiting };
+typedef std::chrono::milliseconds ms;
+
+std::atomic<WorkerThreadState> thread_state(WorkerThreadState::Uninitialized);
+
+void set_worker_thread_state(WorkerThreadState state)
+{
+    thread_state.store(state, std::memory_order_relaxed);
+}
+
+void wait_for_worker_thread_state(WorkerThreadState state)
+{
+    while (thread_state.load(std::memory_order_relaxed) != state);
+}
+
+void func1(std::promise<int> p)
+{
+    wait_for_worker_thread_state(WorkerThreadState::AllowedToRun);
+    p.set_value(3);
+    set_worker_thread_state(WorkerThreadState::Exiting);
+}
+
+int j = 0;
+
+void func3(std::promise<int&> p)
+{
+    wait_for_worker_thread_state(WorkerThreadState::AllowedToRun);
+    j = 5;
+    p.set_value(j);
+    set_worker_thread_state(WorkerThreadState::Exiting);
+}
+
+void func5(std::promise<void> p)
+{
+    wait_for_worker_thread_state(WorkerThreadState::AllowedToRun);
+    p.set_value();
+    set_worker_thread_state(WorkerThreadState::Exiting);
+}
+
+int main()
+{
+    typedef std::chrono::high_resolution_clock Clock;
+    {
+        typedef int T;
+        std::promise<T> p;
+        std::shared_future<T> f = p.get_future();
+        std::thread(func1, std::move(p)).detach();
+        assert(f.valid());
+        assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::timeout);
+        assert(f.valid());
+
+        // allow the worker thread to produce the result and wait until the worker is done
+        set_worker_thread_state(WorkerThreadState::AllowedToRun);
+        wait_for_worker_thread_state(WorkerThreadState::Exiting);
+
+        assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::ready);
+        assert(f.valid());
+        Clock::time_point t0 = Clock::now();
+        f.wait();
+        Clock::time_point t1 = Clock::now();
+        assert(f.valid());
+        assert(t1-t0 < ms(5));
+    }
+    {
+        typedef int& T;
+        std::promise<T> p;
+        std::shared_future<T> f = p.get_future();
+        std::thread(func3, std::move(p)).detach();
+        assert(f.valid());
+        assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::timeout);
+        assert(f.valid());
+
+        // allow the worker thread to produce the result and wait until the worker is done
+        set_worker_thread_state(WorkerThreadState::AllowedToRun);
+        wait_for_worker_thread_state(WorkerThreadState::Exiting);
+
+        assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::ready);
+        assert(f.valid());
+        Clock::time_point t0 = Clock::now();
+        f.wait();
+        Clock::time_point t1 = Clock::now();
+        assert(f.valid());
+        assert(t1-t0 < ms(5));
+    }
+    {
+        typedef void T;
+        std::promise<T> p;
+        std::shared_future<T> f = p.get_future();
+        std::thread(func5, std::move(p)).detach();
+        assert(f.valid());
+        assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::timeout);
+        assert(f.valid());
+
+        // allow the worker thread to produce the result and wait until the worker is done
+        set_worker_thread_state(WorkerThreadState::AllowedToRun);
+        wait_for_worker_thread_state(WorkerThreadState::Exiting);
+
+        assert(f.wait_until(Clock::now() + ms(10)) == std::future_status::ready);
+        assert(f.valid());
+        Clock::time_point t0 = Clock::now();
+        f.wait();
+        Clock::time_point t1 = Clock::now();
+        assert(f.valid());
+        assert(t1-t0 < ms(5));
+    }
+}
diff --git a/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp b/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
index 7cac21d48aef..14b29715ef4f 100644
--- a/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.members/ctor_func_alloc.pass.cpp
@@ -9,6 +9,8 @@
 //
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++98, c++03
+// REQUIRES: c++11 || c++14
+// packaged_task allocator support was removed in C++17 (LWG 2921)
 
 // <future>
 
diff --git a/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp b/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
index bbe75de7f8a9..31ed57e221fc 100644
--- a/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
+++ b/test/std/thread/futures/futures.task/futures.task.nonmembers/uses_allocator.pass.cpp
@@ -16,6 +16,8 @@
 // XFAIL: c++98, c++03
 
 // <future>
+// REQUIRES: c++11 || c++14
+// packaged_task allocator support was removed in C++17 (LWG 2976)
 
 // class packaged_task<R(ArgTypes...)>
 
diff --git a/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp
index 4ad7a3ac2853..0f5f5591f918 100644
--- a/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock.algorithm/try_lock.pass.cpp
@@ -102,7 +102,7 @@ int main()
         L2 l1;
         try
         {
-            std::try_lock(l0, l1);
+            (void)std::try_lock(l0, l1);
             assert(false);
         }
         catch (int)
@@ -116,7 +116,7 @@ int main()
         L0 l1;
         try
         {
-            std::try_lock(l0, l1);
+            (void)std::try_lock(l0, l1);
             assert(false);
         }
         catch (int)
@@ -152,7 +152,7 @@ int main()
         L2 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
@@ -206,7 +206,7 @@ int main()
         L2 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
@@ -222,7 +222,7 @@ int main()
         L0 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
@@ -238,7 +238,7 @@ int main()
         L0 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
@@ -301,7 +301,7 @@ int main()
         L1 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
@@ -317,7 +317,7 @@ int main()
         L0 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
@@ -333,7 +333,7 @@ int main()
         L2 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
@@ -349,7 +349,7 @@ int main()
         L2 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
@@ -365,7 +365,7 @@ int main()
         L1 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
@@ -381,7 +381,7 @@ int main()
         L2 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
@@ -406,7 +406,7 @@ int main()
         L1 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
@@ -440,7 +440,7 @@ int main()
         L1 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
@@ -456,7 +456,7 @@ int main()
         L0 l2;
         try
         {
-            std::try_lock(l0, l1, l2);
+            (void)std::try_lock(l0, l1, l2);
             assert(false);
         }
         catch (int)
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp
index bd707bb90ce1..ee36e84c0a50 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp
@@ -25,8 +25,8 @@ int main()
 {
     {
     typedef std::shared_timed_mutex M;
-	M m0;
-	M m1;
+    M m0;
+    M m1;
     std::shared_lock<M> lk0(m0);
     std::shared_lock<M> lk1(m1);
     lk1 = std::move(lk0);
@@ -37,8 +37,8 @@ int main()
     }
     {
     typedef nasty_mutex M;
-	M m0;
-	M m1;
+    M m0;
+    M m1;
     std::shared_lock<M> lk0(m0);
     std::shared_lock<M> lk1(m1);
     lk1 = std::move(lk0);
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp
index 947b1ad012ec..06dc11742ffb 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock.pass.cpp
@@ -44,7 +44,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock();
+        TEST_IGNORE_NODISCARD lk.try_lock();
         assert(false);
     }
     catch (std::system_error& e)
@@ -60,7 +60,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock();
+        TEST_IGNORE_NODISCARD lk.try_lock();
         assert(false);
     }
     catch (std::system_error& e)
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp
index 5cb805412563..7feb7139072f 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_for.pass.cpp
@@ -49,7 +49,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock_for(ms(5));
+        TEST_IGNORE_NODISCARD lk.try_lock_for(ms(5));
         assert(false);
     }
     catch (std::system_error& e)
@@ -65,7 +65,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock_for(ms(5));
+        TEST_IGNORE_NODISCARD lk.try_lock_for(ms(5));
         assert(false);
     }
     catch (std::system_error& e)
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp
index 3ba4128d719c..836a9ae50b6d 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.locking/try_lock_until.pass.cpp
@@ -49,7 +49,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock_until(Clock::now());
+        TEST_IGNORE_NODISCARD lk.try_lock_until(Clock::now());
         assert(false);
     }
     catch (std::system_error& e)
@@ -65,7 +65,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock_until(Clock::now());
+        TEST_IGNORE_NODISCARD lk.try_lock_until(Clock::now());
         assert(false);
     }
     catch (std::system_error& e)
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp
index 8d864ea8e7da..4ecd6c0415ca 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp
@@ -20,8 +20,8 @@ int main()
 {
     {
     typedef std::mutex M;
-	M m0;
-	M m1;
+    M m0;
+    M m1;
     std::unique_lock<M> lk0(m0);
     std::unique_lock<M> lk1(m1);
     lk1 = lk0;
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp
index 6f17383298fd..2d5feabf8d29 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp
@@ -23,8 +23,8 @@ int main()
 {
     {
     typedef std::mutex M;
-	M m0;
-	M m1;
+    M m0;
+    M m1;
     std::unique_lock<M> lk0(m0);
     std::unique_lock<M> lk1(m1);
     lk1 = std::move(lk0);
@@ -35,8 +35,8 @@ int main()
     }
     {
     typedef nasty_mutex M;
-	M m0;
-	M m1;
+    M m0;
+    M m1;
     std::unique_lock<M> lk0(m0);
     std::unique_lock<M> lk1(m1);
     lk1 = std::move(lk0);
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
index ca8bc6982253..dcfdfd11a7e1 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex.pass.cpp
@@ -54,7 +54,7 @@ int main()
     t.join();
 
 #ifdef __cpp_deduction_guides
-	std::unique_lock ul(m);
+    std::unique_lock ul(m);
     static_assert((std::is_same<decltype(ul), std::unique_lock<decltype(m)>>::value), "" );
 #endif
 }
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp
index 709c56978af8..3f7bd25a5e84 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock.pass.cpp
@@ -43,7 +43,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock();
+        TEST_IGNORE_NODISCARD lk.try_lock();
         assert(false);
     }
     catch (std::system_error& e)
@@ -59,7 +59,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock();
+        TEST_IGNORE_NODISCARD lk.try_lock();
         assert(false);
     }
     catch (std::system_error& e)
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp
index 6c981787d4b4..b73590441025 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_for.pass.cpp
@@ -48,7 +48,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock_for(ms(5));
+        TEST_IGNORE_NODISCARD lk.try_lock_for(ms(5));
         assert(false);
     }
     catch (std::system_error& e)
@@ -64,7 +64,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock_for(ms(5));
+        TEST_IGNORE_NODISCARD lk.try_lock_for(ms(5));
         assert(false);
     }
     catch (std::system_error& e)
diff --git a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp
index 57231b207a72..c8d0aad6f82f 100644
--- a/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/try_lock_until.pass.cpp
@@ -48,7 +48,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock_until(Clock::now());
+        TEST_IGNORE_NODISCARD lk.try_lock_until(Clock::now());
         assert(false);
     }
     catch (std::system_error& e)
@@ -64,7 +64,7 @@ int main()
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try
     {
-        lk.try_lock_until(Clock::now());
+        TEST_IGNORE_NODISCARD lk.try_lock_until(Clock::now());
         assert(false);
     }
     catch (std::system_error& e)
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp
index c61a93aa0c7f..3ac901520978 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/default.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // <shared_mutex>
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp
index 0a6d6e3683ed..efc4d3254a0f 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // FLAKY_TEST.
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp
index b7edc50978d2..72f74d551aa0 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/lock_shared.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // FLAKY_TEST.
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
index 6f3ca24a4558..f22f44c6d19d 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // <shared_mutex>
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp
index f615981bc94d..d2d486a8b079 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.shared_mutex.requirements/thread.shared_mutex.class/try_lock_shared.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11, c++14
+// UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // FLAKY_TEST.
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp
index 45cd563f9407..a4e7670e796a 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/default.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
 
 // <shared_mutex>
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp
index 83979d4c4e51..0e173b0a1672 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
 
 // FLAKY_TEST.
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp
index 516f43192580..753d65d12f89 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/lock_shared.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
 
 // FLAKY_TEST.
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp
index 61900ba83342..fbe3cdcd5350 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
 
 // <shared_mutex>
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp
index 3d36911889b1..e562c99e382b 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_for.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
 
 // FLAKY_TEST.
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp
index 452fc3c19d65..b5fdbdec32ba 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
 
 // FLAKY_TEST.
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp
index f478a29367a1..69d71bf48153 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_for.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
 
 // FLAKY_TEST.
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp
index f33edfc1a534..ba135a95732b 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_shared_until.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
 
 // FLAKY_TEST.
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp
index d5715c76f458..559cf8f266c5 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
 
 // FLAKY_TEST.
 
diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp
index ed288099c979..0caea1d09241 100644
--- a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
-// UNSUPPORTED: c++03, c++98, c++11
+// UNSUPPORTED: c++98, c++03, c++11
 
 // <shared_mutex>
 
diff --git a/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp b/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
index 21011ed17cd9..62f1b784b7d9 100644
--- a/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
+++ b/test/std/thread/thread.mutex/thread.once/thread.once.onceflag/default.pass.cpp
@@ -20,10 +20,12 @@ int main()
 {
     {
     std::once_flag f;
+    (void)f;
     }
 #if TEST_STD_VER >= 11
     {
     constexpr std::once_flag f;
+    (void)f;
     }
 #endif
 }
diff --git a/test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp b/test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp
index 9f3941b93adf..6b622029365c 100644
--- a/test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp
+++ b/test/std/thread/thread.threads/thread.thread.this/sleep_until.pass.cpp
@@ -22,7 +22,6 @@ int main()
 {
     typedef std::chrono::system_clock Clock;
     typedef Clock::time_point time_point;
-    typedef Clock::duration duration;
     std::chrono::milliseconds ms(500);
     time_point t0 = Clock::now();
     std::this_thread::sleep_until(t0 + ms);
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.fail.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.fail.cpp
new file mode 100644
index 000000000000..c5244a0d1bbd
--- /dev/null
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size.fail.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+// <memory>
+
+// template <class OuterAlloc, class... InnerAllocs>
+//   class scoped_allocator_adaptor
+
+// pointer allocate(size_type n);
+
+#include <scoped_allocator>
+#include <cassert>
+
+#include "allocators.h"
+
+int main()
+{
+    std::scoped_allocator_adaptor<A1<int>> a;
+    a.allocate(10);  // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.fail.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.fail.cpp
new file mode 100644
index 000000000000..622147c9cf21
--- /dev/null
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/allocate_size_hint.fail.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+// <memory>
+
+// template <class OuterAlloc, class... InnerAllocs>
+//   class scoped_allocator_adaptor
+
+// pointer allocate(size_type n, const_void_pointer hint);
+
+#include <scoped_allocator>
+#include <cassert>
+
+#include "allocators.h"
+
+int main()
+{
+    std::scoped_allocator_adaptor<A1<int>> a;
+    a.allocate(10, (const void*)0); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
index 8568c7380b6d..71421464df2b 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
@@ -26,7 +26,7 @@
 #include "uses_alloc_types.hpp"
 #include "controlled_allocators.hpp"
 
-// — If uses_allocator_v<T, inner_allocator_type> is false and
+// - If uses_allocator_v<T, inner_allocator_type> is false and
 //   is_constructible_v<T, Args...> is true, calls
 //   OUTERMOST_ALLOC_TRAITS(*this)::construct(
 //      OUTERMOST (*this), p, std::forward<Args>(args)...).
diff --git a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
index f8a9ea0f9eca..44e8709a8e30 100644
--- a/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
+++ b/test/std/utilities/allocator.adaptor/allocator.adaptor.types/is_always_equal.pass.cpp
@@ -26,12 +26,12 @@ int main()
 {
     // sanity checks
     static_assert( (std::is_same<
-    		std::allocator_traits<A1<int>>::is_always_equal, std::false_type>::value
-    		), "" );
+            std::allocator_traits<A1<int>>::is_always_equal, std::false_type>::value
+            ), "" );
 
     static_assert( (std::is_same<
-    		std::allocator_traits<min_allocator<int>>::is_always_equal, std::true_type>::value
-    		), "" );
+            std::allocator_traits<min_allocator<int>>::is_always_equal, std::true_type>::value
+            ), "" );
 
     // wrapping one allocator
     static_assert(
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
index ed04a91ca406..419fd1a40cf8 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp
@@ -80,7 +80,7 @@ void checkThrows(any& a)
 {
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
     try {
-        any_cast<Type>(a);
+        TEST_IGNORE_NODISCARD any_cast<Type>(a);
         assert(false);
     } catch (bad_any_cast const &) {
             // do nothing
@@ -89,7 +89,7 @@ void checkThrows(any& a)
     }
 
     try {
-        any_cast<ConstT>(static_cast<any const&>(a));
+        TEST_IGNORE_NODISCARD any_cast<ConstT>(static_cast<any const&>(a));
         assert(false);
     } catch (bad_any_cast const &) {
             // do nothing
@@ -103,7 +103,7 @@ void checkThrows(any& a)
             typename std::remove_reference<Type>::type&&,
             Type
         >::type;
-        any_cast<RefType>(static_cast<any&&>(a));
+        TEST_IGNORE_NODISCARD any_cast<RefType>(static_cast<any&&>(a));
         assert(false);
     } catch (bad_any_cast const &) {
             // do nothing
@@ -111,13 +111,13 @@ void checkThrows(any& a)
         assert(false);
     }
 #else
-    ((void)a);
+    (TEST_IGNORE_NODISCARD a);
 #endif
 }
 
 void test_cast_empty() {
     // None of these operations should allocate.
-    DisableAllocationGuard g; ((void)g);
+    DisableAllocationGuard g; (TEST_IGNORE_NODISCARD g);
     any a;
     checkThrows<int>(a);
 }
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp
index 07578a28e82f..9638521260a9 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp
@@ -25,12 +25,12 @@ using std::any_cast;
 void test_const_lvalue_cast_request_non_const_lvalue()
 {
     const any a;
-    // expected-error@any:* {{static_assert failed "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     // expected-error@any:* {{binding value of type 'const TestType' to reference to type 'TestType' drops 'const' qualifier}}
     any_cast<TestType &>(a); // expected-note {{requested here}}
 
     const any a2(42);
-    // expected-error@any:* {{static_assert failed "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     // expected-error@any:* {{binding value of type 'const int' to reference to type 'int' drops 'const' qualifier}}
     any_cast<int&>(a2); // expected-note {{requested here}}
 }
@@ -38,22 +38,22 @@ void test_const_lvalue_cast_request_non_const_lvalue()
 void test_lvalue_any_cast_request_rvalue()
 {
     any a;
-    // expected-error@any:* {{static_assert failed "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
     any_cast<TestType &&>(a); // expected-note {{requested here}}
 
     any a2(42);
-    // expected-error@any:* {{static_assert failed "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
     any_cast<int&&>(a2); // expected-note {{requested here}}
 }
 
 void test_rvalue_any_cast_request_lvalue()
 {
     any a;
-    // expected-error@any:* {{static_assert failed "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
     // expected-error@any:* {{non-const lvalue reference to type 'TestType' cannot bind to a temporary}}
     any_cast<TestType &>(std::move(a)); // expected-note {{requested here}}
 
-    // expected-error@any:* {{static_assert failed "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
     // expected-error@any:* {{non-const lvalue reference to type 'int' cannot bind to a temporary}}
     any_cast<int&>(42);
 }
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp b/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
index 3f6955a8cbce..bad229dac886 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
@@ -29,18 +29,18 @@ int main()
     any a;
 
     // expected-error@any:* {{binding value of type 'const TestType' to reference to type 'TestType' drops 'const' qualifier}}
-    // expected-error@any:* {{static_assert failed "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     any_cast<TestType &>(static_cast<any const&>(a)); // expected-note {{requested here}}
 
     // expected-error@any:* {{cannot cast from lvalue of type 'const TestType' to rvalue reference type 'TestType &&'; types are not compatible}}
-    // expected-error@any:* {{static_assert failed "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     any_cast<TestType &&>(static_cast<any const&>(a)); // expected-note {{requested here}}
 
     // expected-error@any:* {{binding value of type 'const TestType2' to reference to type 'TestType2' drops 'const' qualifier}}
-    // expected-error@any:* {{static_assert failed "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     any_cast<TestType2 &>(static_cast<any const&&>(a)); // expected-note {{requested here}}
 
     // expected-error@any:* {{cannot cast from lvalue of type 'const TestType2' to rvalue reference type 'TestType2 &&'; types are not compatible}}
-    // expected-error@any:* {{static_assert failed "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     any_cast<TestType2 &&>(static_cast<any const&&>(a)); // expected-note {{requested here}}
 }
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp b/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
index ed4b96d644d2..2d18cf4ba090 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
@@ -42,17 +42,17 @@ struct no_move {
 
 int main() {
     any a;
-    // expected-error@any:* {{static_assert failed "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
     // expected-error@any:* {{static_cast from 'no_copy' to 'no_copy' uses deleted function}}
     any_cast<no_copy>(static_cast<any&>(a)); // expected-note {{requested here}}
 
-    // expected-error@any:* {{static_assert failed "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     // expected-error@any:* {{static_cast from 'const no_copy' to 'no_copy' uses deleted function}}
     any_cast<no_copy>(static_cast<any const&>(a)); // expected-note {{requested here}}
 
     any_cast<no_copy>(static_cast<any &&>(a)); // OK
 
-    // expected-error@any:* {{static_assert failed "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
+    // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
     // expected-error@any:* {{static_cast from 'typename remove_reference<no_move &>::type' (aka 'no_move') to 'no_move' uses deleted function}}
     any_cast<no_move>(static_cast<any &&>(a));
 }
diff --git a/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp b/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp
index bbc135051ef8..204c5c0d6af9 100644
--- a/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp
+++ b/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp
@@ -26,29 +26,29 @@ int main()
 {
     any a(1);
 
-    // expected-error@any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+    // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
     any_cast<int &>(&a); // expected-note {{requested here}}
 
-    // expected-error@any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+    // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
     any_cast<int &&>(&a); // expected-note {{requested here}}
 
-    // expected-error@any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+    // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
     any_cast<int const &>(&a); // expected-note {{requested here}}
 
-    // expected-error@any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+    // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
     any_cast<int const&&>(&a); // expected-note {{requested here}}
 
     any const& a2 = a;
 
-    // expected-error@any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+    // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
     any_cast<int &>(&a2); // expected-note {{requested here}}
 
-    // expected-error@any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+    // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
     any_cast<int &&>(&a2); // expected-note {{requested here}}
 
-    // expected-error@any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+    // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
     any_cast<int const &>(&a2); // expected-note {{requested here}}
 
-    // expected-error@any:* 1 {{static_assert failed "_ValueType may not be a reference."}}
+    // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
     any_cast<int const &&>(&a2); // expected-note {{requested here}}
 }
diff --git a/test/std/utilities/any/any.nonmembers/make_any.pass.cpp b/test/std/utilities/any/any.nonmembers/make_any.pass.cpp
index 5a4a3c3c189f..9850851fc6ed 100644
--- a/test/std/utilities/any/any.nonmembers/make_any.pass.cpp
+++ b/test/std/utilities/any/any.nonmembers/make_any.pass.cpp
@@ -115,14 +115,14 @@ void test_make_any_throws()
 {
     {
         try {
-            std::make_any<Type>(101);
+            TEST_IGNORE_NODISCARD std::make_any<Type>(101);
             assert(false);
         } catch (int const&) {
         }
     }
     {
         try {
-            std::make_any<Type>({1, 2, 3}, 101);
+            TEST_IGNORE_NODISCARD std::make_any<Type>({1, 2, 3}, 101);
             assert(false);
         } catch (int const&) {
         }
diff --git a/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp b/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
index b85f439ba7a0..fce826f4215d 100644
--- a/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/arithmetic.operations/transparent.pass.cpp
@@ -11,15 +11,15 @@
 #include <functional>
 #include <string>
 
-template <class _Tp>
+template <class T>
 struct is_transparent
 {
 private:
-    struct __two {char __lx; char __lxx;};
-    template <class _Up> static __two __test(...);
-    template <class _Up> static char __test(typename _Up::is_transparent* = 0);
+    struct two {char lx; char lxx;};
+    template <class U> static two test(...);
+    template <class U> static char test(typename U::is_transparent* = 0);
 public:
-    static const bool value = sizeof(__test<_Tp>(0)) == 1;
+    static const bool value = sizeof(test<T>(0)) == 1;
 };
 
 
diff --git a/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp b/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
index db7168c44f8b..bcd353eba1e2 100644
--- a/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/bitwise.operations/transparent.pass.cpp
@@ -11,15 +11,15 @@
 #include <functional>
 #include <string>
 
-template <class _Tp>
+template <class T>
 struct is_transparent
 {
 private:
-    struct __two {char __lx; char __lxx;};
-    template <class _Up> static __two __test(...);
-    template <class _Up> static char __test(typename _Up::is_transparent* = 0);
+    struct two {char lx; char lxx;};
+    template <class U> static two test(...);
+    template <class U> static char test(typename U::is_transparent* = 0);
 public:
-    static const bool value = sizeof(__test<_Tp>(0)) == 1;
+    static const bool value = sizeof(test<T>(0)) == 1;
 };
 
 
diff --git a/test/std/utilities/function.objects/comparisons/transparent.pass.cpp b/test/std/utilities/function.objects/comparisons/transparent.pass.cpp
index f353fe7a72a6..ebae262b2423 100644
--- a/test/std/utilities/function.objects/comparisons/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/comparisons/transparent.pass.cpp
@@ -11,15 +11,15 @@
 #include <functional>
 #include <string>
 
-template <class _Tp>
+template <class T>
 struct is_transparent
 {
 private:
-    struct __two {char __lx; char __lxx;};
-    template <class _Up> static __two __test(...);
-    template <class _Up> static char __test(typename _Up::is_transparent* = 0);
+    struct two {char lx; char lxx;};
+    template <class U> static two test(...);
+    template <class U> static char test(typename U::is_transparent* = 0);
 public:
-    static const bool value = sizeof(__test<_Tp>(0)) == 1;
+    static const bool value = sizeof(test<T>(0)) == 1;
 };
 
 
diff --git a/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp b/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp
index aaac98474fcb..9c3f24262ef0 100644
--- a/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp
+++ b/test/std/utilities/function.objects/func.invoke/invoke_feature_test_macro.pass.cpp
@@ -36,4 +36,4 @@ int main() {
 #if defined(__cpp_lib_invoke)
   assert(std::invoke(foo, 101) == 42);
 #endif
-}
\ No newline at end of file
+}
diff --git a/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp b/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
index aa8eb3916db9..7601ff9d147d 100644
--- a/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
+++ b/test/std/utilities/function.objects/func.not_fn/not_fn.pass.cpp
@@ -438,26 +438,26 @@ void throws_in_constructor_test()
 void call_operator_sfinae_test() {
     { // wrong number of arguments
         using T = decltype(std::not_fn(returns_true));
-        static_assert(std::is_callable<T()>::value, ""); // callable only with no args
-        static_assert(!std::is_callable<T(bool)>::value, "");
+        static_assert(std::is_invocable<T>::value, ""); // callable only with no args
+        static_assert(!std::is_invocable<T, bool>::value, "");
     }
     { // violates const correctness (member function pointer)
         using T = decltype(std::not_fn(&MemFunCallable::return_value_nc));
-        static_assert(std::is_callable<T(MemFunCallable&)>::value, "");
-        static_assert(!std::is_callable<T(const MemFunCallable&)>::value, "");
+        static_assert(std::is_invocable<T, MemFunCallable&>::value, "");
+        static_assert(!std::is_invocable<T, const MemFunCallable&>::value, "");
     }
     { // violates const correctness (call object)
         using Obj = CopyCallable<bool>;
         using NCT = decltype(std::not_fn(Obj{true}));
         using CT = const NCT;
-        static_assert(std::is_callable<NCT()>::value, "");
-        static_assert(!std::is_callable<CT()>::value, "");
+        static_assert(std::is_invocable<NCT>::value, "");
+        static_assert(!std::is_invocable<CT>::value, "");
     }
     { // returns bad type with no operator!
         auto fn = [](auto x) { return x; };
         using T = decltype(std::not_fn(fn));
-        static_assert(std::is_callable<T(bool)>::value, "");
-        static_assert(!std::is_callable<T(std::string)>::value, "");
+        static_assert(std::is_invocable<T, bool>::value, "");
+        static_assert(!std::is_invocable<T, std::string>::value, "");
     }
 }
 
@@ -587,7 +587,7 @@ void call_operator_noexcept_test()
 }
 
 void test_lwg2767() {
-    // See http://wg21.link/LWG2767
+    // See https://cplusplus.github.io/LWG/lwg-defects.html#2767
     struct Abstract { virtual void f() const = 0; };
     struct Derived : public Abstract { void f() const {} };
     struct F { bool operator()(Abstract&&) { return false; } };
diff --git a/test/std/utilities/function.objects/func.require/binary_function.pass.cpp b/test/std/utilities/function.objects/func.require/binary_function.pass.cpp
index fa7afb2e7b9c..93463190374e 100644
--- a/test/std/utilities/function.objects/func.require/binary_function.pass.cpp
+++ b/test/std/utilities/function.objects/func.require/binary_function.pass.cpp
@@ -8,6 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 // <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
+// binary_function was removed in C++17
 
 // binary_function
 
diff --git a/test/std/utilities/function.objects/func.require/unary_function.pass.cpp b/test/std/utilities/function.objects/func.require/unary_function.pass.cpp
index f14b2d3a2ce5..40a9d480b183 100644
--- a/test/std/utilities/function.objects/func.require/unary_function.pass.cpp
+++ b/test/std/utilities/function.objects/func.require/unary_function.pass.cpp
@@ -8,6 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 // <functional>
+// REQUIRES: c++98 || c++03 || c++11 || c++14
+// unary_function was removed in C++17
 
 // unary_function
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp
index 812f6fc502d9..7d3a5dec4ef6 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/derive_from.pass.cpp
@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03
-// REQUIRES: c++11 || c++14
 
 // <functional>
 
@@ -25,5 +24,7 @@ struct S : public std::function<void()> { using function::function; };
 int main() {
     S s( [](){} );
     S f1( s );
+#if TEST_STD_VER <= 14
     S f2(std::allocator_arg, std::allocator<int>{}, s);
+#endif
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp
index 24f7fceb877b..b23153465168 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.fail.cpp
@@ -25,5 +25,5 @@ void foo(int) {}
 
 int main()
 {
-	std::function<void(int)> f(std::allocator_arg, std::allocator<int>(), foo);
+    std::function<void(int)> f(std::allocator_arg, std::allocator<int>(), foo);
 }
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
index 4c1a1ca95ff4..8a2a12e0f789 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 // <functional>
-// REQUIRES: c++98 || c++03 || c++11 ||c++14
+// REQUIRES: c++98 || c++03 || c++11 || c++14
 
 // class function<R(ArgTypes...)>
 
diff --git a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp
index 9967457ff821..2e4633b11693 100644
--- a/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp
+++ b/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.fail.cpp
@@ -24,7 +24,7 @@
 
 int main()
 {
-	typedef std::function<void(int)> F;
-	F f1;
-	F f2(std::allocator_arg, std::allocator<int>(), f1);
+    typedef std::function<void(int)> F;
+    F f1;
+    F f2(std::allocator_arg, std::allocator<int>(), f1);
 }
diff --git a/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp b/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
index 00e513ec546f..d64c02f97cd4 100644
--- a/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
+++ b/test/std/utilities/function.objects/logical.operations/transparent.pass.cpp
@@ -11,15 +11,15 @@
 #include <functional>
 #include <string>
 
-template <class _Tp>
+template <class T>
 struct is_transparent
 {
 private:
-    struct __two {char __lx; char __lxx;};
-    template <class _Up> static __two __test(...);
-    template <class _Up> static char __test(typename _Up::is_transparent* = 0);
+    struct two {char lx; char lxx;};
+    template <class U> static two test(...);
+    template <class U> static char test(typename U::is_transparent* = 0);
 public:
-    static const bool value = sizeof(__test<_Tp>(0)) == 1;
+    static const bool value = sizeof(test<T>(0)) == 1;
 };
 
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp
index df0b55a5d060..fede2538a851 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.access/conversion.pass.cpp
@@ -17,7 +17,6 @@
 #include <cassert>
 
 class functor1
-    : public std::unary_function<int, char>
 {
 };
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
index 122716a23a8b..ba3c71e48260 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.assign/copy_assign.pass.cpp
@@ -17,7 +17,6 @@
 #include <cassert>
 
 class functor1
-    : public std::unary_function<int, char>
 {
 };
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp
index 721a442d4431..d9f05b4e57a9 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.const/copy_ctor.pass.cpp
@@ -17,7 +17,6 @@
 #include <cassert>
 
 class functor1
-    : public std::unary_function<int, char>
 {
 };
 
diff --git a/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp b/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
index 564a3f77433c..d0dabd2643e5 100644
--- a/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/refwrap.const/type_ctor.pass.cpp
@@ -17,7 +17,6 @@
 #include <cassert>
 
 class functor1
-    : public std::unary_function<int, char>
 {
 };
 
diff --git a/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp b/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp
index 609094dae406..7ce4c846e923 100644
--- a/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp
+++ b/test/std/utilities/function.objects/refwrap/weak_result.pass.cpp
@@ -16,27 +16,42 @@
 #include <functional>
 #include <type_traits>
 
+template <class Arg, class Result>
+struct my_unary_function
+{ // std::unary_function was removed in C++17
+    typedef Arg argument_type;
+    typedef Result result_type;
+};
+
+template <class Arg1, class Arg2, class Result>
+struct my_binary_function
+{ // std::binary_function was removed in C++17
+    typedef Arg1 first_argument_type;
+    typedef Arg2 second_argument_type;
+    typedef Result result_type;
+};
+
 class functor1
-    : public std::unary_function<int, char>
+    : public my_unary_function<int, char>
 {
 };
 
 class functor2
-    : public std::binary_function<char, int, double>
+    : public my_binary_function<char, int, double>
 {
 };
 
 class functor3
-    : public std::unary_function<char, int>,
-      public std::binary_function<char, int, double>
+    : public my_unary_function<char, int>,
+      public my_binary_function<char, int, double>
 {
 public:
     typedef float result_type;
 };
 
 class functor4
-    : public std::unary_function<char, int>,
-      public std::binary_function<char, int, double>
+    : public my_unary_function<char, int>,
+      public my_binary_function<char, int, double>
 {
 public:
 };
diff --git a/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp b/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp
index ed173f280d05..7b427b9ac1e4 100644
--- a/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/non_enum.pass.cpp
@@ -13,7 +13,7 @@
 
 //  Hashing a struct w/o a defined hash should *not* fail, but it should
 // create a type that is not constructible and not callable.
-// See also: http://cplusplus.github.io/LWG/lwg-active.html#2543
+// See also: https://cplusplus.github.io/LWG/lwg-defects.html#2543
 
 #include <functional>
 #include <cassert>
@@ -32,7 +32,7 @@ int main()
     static_assert(!std::is_copy_assignable<H>::value, "");
     static_assert(!std::is_move_assignable<H>::value, "");
 #if TEST_STD_VER > 14
-    static_assert(!std::is_callable<H(X&)>::value, "");
-    static_assert(!std::is_callable<H(X const&)>::value, "");
+    static_assert(!std::is_invocable<H, X&>::value, "");
+    static_assert(!std::is_invocable<H, X const&>::value, "");
 #endif
 }
diff --git a/test/std/utilities/function.objects/unord.hash/pointer.pass.cpp b/test/std/utilities/function.objects/unord.hash/pointer.pass.cpp
index 36280a38e0a7..f1c56aed78b8 100644
--- a/test/std/utilities/function.objects/unord.hash/pointer.pass.cpp
+++ b/test/std/utilities/function.objects/unord.hash/pointer.pass.cpp
@@ -41,7 +41,7 @@ test()
     assert(h(&i) != h(&j));
 }
 
-// can't hash nullptr_t until c++17
+// can't hash nullptr_t until C++17
 void test_nullptr()
 {
 #if TEST_STD_VER > 14
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.fail.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.fail.cpp
new file mode 100644
index 000000000000..71201f0ef0d9
--- /dev/null
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.fail.cpp
@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// template <class Alloc>
+// struct allocator_traits
+// {
+//     static pointer allocate(allocator_type& a, size_type n);
+//     ...
+// };
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <memory>
+#include <cstdint>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <class T>
+struct A
+{
+    typedef T value_type;
+
+    value_type* allocate(std::size_t n)
+    {
+        assert(n == 12);
+        return reinterpret_cast<value_type*>(static_cast<std::uintptr_t>(0xEEADBEEF));
+    }
+    value_type* allocate(std::size_t n, const void* p)
+    {
+        assert(n == 11);
+        assert(p == 0);
+        return reinterpret_cast<value_type*>(static_cast<std::uintptr_t>(0xFEADBEEF));
+    }
+};
+
+int main()
+{
+    A<int> a;
+    std::allocator_traits<A<int> >::allocate(a, 10);          // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    std::allocator_traits<A<int> >::allocate(a, 10, nullptr); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp
index ab8179c5ab4d..292d68de9786 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.pass.cpp
@@ -20,6 +20,8 @@
 #include <cstdint>
 #include <cassert>
 
+#include "incomplete_type_helper.h"
+
 template <class T>
 struct A
 {
@@ -34,6 +36,14 @@ struct A
 
 int main()
 {
+  {
     A<int> a;
     assert(std::allocator_traits<A<int> >::allocate(a, 10) == reinterpret_cast<int*>(static_cast<std::uintptr_t>(0xDEADBEEF)));
+  }
+  {
+    typedef IncompleteHolder* VT;
+    typedef A<VT> Alloc;
+    Alloc a;
+    assert(std::allocator_traits<Alloc >::allocate(a, 10) == reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xDEADBEEF)));
+  }
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
index 808284261f7d..90a9154e1840 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp
@@ -21,6 +21,7 @@
 #include <cassert>
 
 #include "test_macros.h"
+#include "incomplete_type_helper.h"
 
 template <class T>
 struct A
@@ -52,12 +53,29 @@ struct B
     }
 };
 
+
 int main()
 {
 #if TEST_STD_VER >= 11
+  {
     A<int> a;
     assert(std::allocator_traits<A<int> >::allocate(a, 10, nullptr) == reinterpret_cast<int*>(static_cast<std::uintptr_t>(0xDEADBEEF)));
+  }
+  {
+    typedef IncompleteHolder* VT;
+    typedef A<VT> Alloc;
+    Alloc a;
+    assert(std::allocator_traits<Alloc >::allocate(a, 10, nullptr) == reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xDEADBEEF)));
+  }
 #endif
+  {
     B<int> b;
     assert(std::allocator_traits<B<int> >::allocate(b, 11, nullptr) == reinterpret_cast<int*>(static_cast<std::uintptr_t>(0xFEADBEEF)));
+  }
+  {
+    typedef IncompleteHolder* VT;
+    typedef B<VT> Alloc;
+    Alloc b;
+    assert(std::allocator_traits<Alloc >::allocate(b, 11, nullptr) == reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xFEADBEEF)));
+  }
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
index 46075f62c6c1..e4aceffdd6b6 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp
@@ -23,6 +23,7 @@
 #include <cassert>
 
 #include "test_macros.h"
+#include "incomplete_type_helper.h"
 
 template <class T>
 struct A
@@ -107,6 +108,13 @@ int main()
         std::allocator_traits<A<int> >::construct(a, (A2*)&a2, 'd', 5);
         assert(A2::count == 1);
     }
+    {
+      typedef IncompleteHolder* VT;
+      typedef A<VT> Alloc;
+      Alloc a;
+      std::aligned_storage<sizeof(VT)>::type store;
+      std::allocator_traits<Alloc>::construct(a, (VT*)&store, nullptr);
+    }
 #if TEST_STD_VER >= 11
     {
         A0::count = 0;
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp
index 8176d8b3767a..ecb67adb58e9 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp
@@ -20,6 +20,8 @@
 #include <cstdint>
 #include <cassert>
 
+#include "incomplete_type_helper.h"
+
 int called = 0;
 
 template <class T>
@@ -37,7 +39,17 @@ struct A
 
 int main()
 {
+  {
     A<int> a;
     std::allocator_traits<A<int> >::deallocate(a, reinterpret_cast<int*>(static_cast<std::uintptr_t>(0xDEADBEEF)), 10);
     assert(called == 1);
+  }
+  called = 0;
+  {
+    typedef IncompleteHolder* VT;
+    typedef A<VT> Alloc;
+    Alloc a;
+    std::allocator_traits<Alloc >::deallocate(a, reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xDEADBEEF)), 10);
+    assert(called == 1);
+  }
 }
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
index 2ee64b8b4a07..1a812876bf0c 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp
@@ -23,6 +23,7 @@
 #include <cassert>
 
 #include "test_macros.h"
+#include "incomplete_type_helper.h"
 
 template <class T>
 struct A
@@ -65,6 +66,13 @@ int main()
         std::allocator_traits<A<int> >::destroy(a, (A0*)&a0);
         assert(A0::count == 1);
     }
+    {
+      typedef IncompleteHolder* VT;
+      typedef A<VT> Alloc;
+      Alloc a;
+      std::aligned_storage<sizeof(VT)>::type store;
+      std::allocator_traits<Alloc>::destroy(a, (VT*)&store);
+    }
 #if TEST_STD_VER >= 11
     {
         A0::count = 0;
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/incomplete_type_helper.h b/test/std/utilities/memory/allocator.traits/allocator.traits.members/incomplete_type_helper.h
new file mode 100644
index 000000000000..7662338d73c4
--- /dev/null
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/incomplete_type_helper.h
@@ -0,0 +1,14 @@
+#ifndef TEST_INCOMPLETE_TYPE_HELPER_H
+#define TEST_INCOMPLETE_TYPE_HELPER_H
+
+#include "min_allocator.h"
+
+namespace NS {
+  struct Incomplete;
+}
+
+template <class T> struct Holder { T value; };
+
+typedef Holder<NS::Incomplete> IncompleteHolder;
+
+#endif
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
index d2c9a9826e14..12c0d02227fa 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.pass.cpp
@@ -22,6 +22,7 @@
 #include <cassert>
 
 #include "test_macros.h"
+#include "incomplete_type_helper.h"
 
 template <class T>
 struct A
@@ -51,6 +52,12 @@ int main()
         const B<int> b = {};
         assert(std::allocator_traits<B<int> >::max_size(b) == 100);
     }
+    {
+        typedef IncompleteHolder* VT;
+        typedef B<VT> Alloc;
+        Alloc a;
+        assert(std::allocator_traits<Alloc >::max_size(a) == 100);
+    }
 #if TEST_STD_VER >= 11
     {
         A<int> a;
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
index 2e9703037894..8355db18276a 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.pass.cpp
@@ -23,6 +23,7 @@
 #include <cassert>
 
 #include "test_macros.h"
+#include "incomplete_type_helper.h"
 
 template <class T>
 struct A
@@ -57,6 +58,12 @@ int main()
         const A<int> a(0);
         assert(std::allocator_traits<A<int> >::select_on_container_copy_construction(a).id == 0);
     }
+    {
+        typedef IncompleteHolder* VT;
+        typedef A<VT> Alloc;
+        Alloc a;
+        assert(std::allocator_traits<Alloc>::select_on_container_copy_construction(a).id == 0);
+    }
 #if TEST_STD_VER >= 11
     {
         B<int> b;
diff --git a/test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp b/test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp
index 31a0f171d33d..7f7b155c35c8 100644
--- a/test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp
+++ b/test/std/utilities/memory/allocator.traits/allocator.traits.types/is_always_equal.pass.cpp
@@ -37,7 +37,7 @@ template <class T>
 struct C
 {
     typedef T value_type;
-	int not_empty_;  // some random member variable
+    int not_empty_;  // some random member variable
 };
 
 int main()
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp b/test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp
new file mode 100644
index 000000000000..490309eddd6e
--- /dev/null
+++ b/test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// allocator:
+// pointer allocate(size_type n, allocator<void>::const_pointer hint=0);
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
+#include <memory>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    std::allocator<int> a;
+    a.allocate(3);          // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+    a.allocate(3, nullptr); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
diff --git a/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp b/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp
index 768d41878437..34cbb8dc5377 100644
--- a/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp
+++ b/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp
@@ -23,7 +23,7 @@ void test_max(size_t count)
 {
     std::allocator<T> a;
     try {
-        a.allocate(count);
+        TEST_IGNORE_NODISCARD a.allocate(count);
         assert(false);
     } catch (const std::exception &) {
     }
diff --git a/test/std/utilities/memory/pointer.conversion/to_address.pass.cpp b/test/std/utilities/memory/pointer.conversion/to_address.pass.cpp
new file mode 100644
index 000000000000..64a5c73affe1
--- /dev/null
+++ b/test/std/utilities/memory/pointer.conversion/to_address.pass.cpp
@@ -0,0 +1,120 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// template <class T> constexpr T* to_address(T* p) noexcept;
+// template <class Ptr> auto to_address(const Ptr& p) noexcept;
+
+#include <memory>
+#include <cassert>
+#include "test_macros.h"
+
+class P1
+{
+public:
+    using element_type = int;
+
+    explicit P1(int* p)
+    : p_(p) { }
+
+    int* operator->() const noexcept
+    { return p_; }
+
+private:
+    int* p_;
+};
+
+class P2
+{
+public:
+    using element_type = int;
+
+    explicit P2(int* p)
+    : p_(p) { }
+
+    P1 operator->() const noexcept
+    { return p_; }
+
+private:
+    P1 p_;
+};
+
+class P3
+{
+public:
+    explicit P3(int* p)
+    : p_(p) { }
+
+    int* get() const noexcept
+    { return p_; }
+
+private:
+    int* p_;
+};
+
+namespace std
+{
+template<>
+struct pointer_traits<::P3>
+{
+    static int* to_address(const ::P3& p) noexcept
+    { return p.get(); }
+};
+}
+
+class P4
+{
+public:
+    explicit P4(int* p)
+    : p_(p) { }
+
+    int* operator->() const noexcept
+    { return nullptr; }
+
+    int* get() const noexcept
+    { return p_; }
+
+private:
+    int* p_;
+};
+
+namespace std
+{
+template<>
+struct pointer_traits<::P4>
+{
+    static int* to_address(const ::P4& p) noexcept
+    { return p.get(); }
+};
+}
+
+int n = 0;
+static_assert(std::to_address(&n) == &n);
+
+int main()
+{
+    int i = 0;
+    ASSERT_NOEXCEPT(std::to_address(&i));
+    assert(std::to_address(&i) == &i);
+    P1 p1(&i);
+    ASSERT_NOEXCEPT(std::to_address(p1));
+    assert(std::to_address(p1) == &i);
+    P2 p2(&i);
+    ASSERT_NOEXCEPT(std::to_address(p2));
+    assert(std::to_address(p2) == &i);
+    P3 p3(&i);
+    ASSERT_NOEXCEPT(std::to_address(p3));
+    assert(std::to_address(p3) == &i);
+    P4 p4(&i);
+    ASSERT_NOEXCEPT(std::to_address(p4));
+    assert(std::to_address(p4) == &i);
+}
diff --git a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp
index 81f49eaac39b..3ff32df11338 100644
--- a/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/specialized.addressof/addressof.temp.fail.cpp
@@ -19,7 +19,7 @@
 int main()
 {
 #if TEST_STD_VER > 14
-	const int *p = std::addressof<const int>(0);
+    const int *p = std::addressof<const int>(0);
 #else
 #error
 #endif
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
index ad6a51500e36..319df229668f 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp
@@ -112,4 +112,4 @@ int main()
 {
     test_counted();
     test_value_initialized();
-}
\ No newline at end of file
+}
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp
index 1829dff354d3..2f387a4cef97 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.pass.cpp
@@ -71,7 +71,7 @@ int main()
     std::uninitialized_copy(b, b+2, bp);
     for (int i = 0; i < 2; ++i)
         assert(bp[i].data_ == 1);
-	assert(B::population_ == N + 2);
+    assert(B::population_ == N + 2);
     }
 
     {
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
index 6c535250fd1f..d914129f2a4a 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp
@@ -111,4 +111,4 @@ void test_counted()
 int main() {
     test_counted();
     test_ctor_throws();
-}
\ No newline at end of file
+}
diff --git a/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp b/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
index 4175c6bce688..4083bc367cf2 100644
--- a/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
+++ b/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp
@@ -114,4 +114,4 @@ int main()
 {
     test_counted();
     test_ctor_throws();
-}
\ No newline at end of file
+}
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.fail.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.fail.cpp
new file mode 100644
index 000000000000..48c90f7b9661
--- /dev/null
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.fail.cpp
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+//  Because we don't have a functioning decltype in C++03
+
+// <memory>
+
+// unique_ptr
+
+// template<class CharT, class Traits, class Y, class D>
+//   basic_ostream<CharT, Traits>&
+//   operator<<(basic_ostream<CharT, Traits>& os, const unique_ptr<Y, D>& p);
+
+//   -?- Remarks: This function shall not participate in overload resolution unless os << p.get() is a valid expression.
+
+#include <memory>
+#include <sstream>
+#include <cassert>
+
+class A {};
+
+int main()
+{
+    std::unique_ptr<A> p(new A);
+    std::ostringstream os;
+    os << p;
+}
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.pass.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.pass.cpp
new file mode 100644
index 000000000000..1166a01e8198
--- /dev/null
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.pass.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+//  Because we don't have a functioning decltype in C++03
+
+// <memory>
+
+// unique_ptr
+
+// template<class CharT, class Traits, class Y, class D>
+//   basic_ostream<CharT, Traits>&
+//   operator<<(basic_ostream<CharT, Traits>& os, const unique_ptr<Y, D>& p);
+
+#include <memory>
+#include <sstream>
+#include <cassert>
+
+int main()
+{
+    std::unique_ptr<int> p(new int(3));
+    std::ostringstream os;
+    assert(os.str().empty());
+    os << p;
+    assert(!os.str().empty());
+}
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp
index eb0d0a955fc5..8bd8993e5bec 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.enab/enable_shared_from_this.pass.cpp
@@ -41,7 +41,7 @@ void nullDeleter(void*) {}
 
 struct Foo : virtual public std::enable_shared_from_this<Foo>
 {
-	virtual ~Foo() {}
+    virtual ~Foo() {}
 };
 
 struct Bar : public Foo {
@@ -80,12 +80,11 @@ int main()
     }
     {
       typedef std::shared_ptr<PrivateBase> APtr;
-      typedef std::weak_ptr<PrivateBase> WeakAPtr;
       APtr a1 = std::make_shared<PrivateBase>();
       assert(a1.use_count() == 1);
     }
     // Test LWG issue 2529. Only reset '__weak_ptr_' when it's already expired.
-    // http://cplusplus.github.io/LWG/lwg-active.html#2529.
+    // https://cplusplus.github.io/LWG/lwg-defects.html#2529
     // Test two different ways:
     // * Using 'weak_from_this().expired()' in C++17.
     // * Using 'shared_from_this()' in all dialects.
@@ -135,7 +134,7 @@ int main()
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try {
-            ptr->shared_from_this();
+            TEST_IGNORE_NODISCARD ptr->shared_from_this();
             assert(false);
         } catch (std::bad_weak_ptr const&) {
         } catch (...) { assert(false); }
diff --git a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/nothing_to_do.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.fail.cpp
index b58f5c55b643..7f304054bda0 100644
--- a/test/std/diagnostics/syserr/syserr.errcondition/syserr.errcondition.overview/nothing_to_do.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.fail.cpp
@@ -7,6 +7,23 @@
 //
 //===----------------------------------------------------------------------===//
 
+// <memory>
+
+// shared_ptr
+
+// template<class T, class... Args> shared_ptr<T> make_shared(Args&&... args);
+
+#include <memory>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct S {
+private:
+   S () {};  // ctor is private
+};
+
 int main()
 {
+    std::shared_ptr<S> p = std::make_shared<S>();
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp
new file mode 100644
index 000000000000..0eeeed4e88c9
--- /dev/null
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp
@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// shared_ptr
+
+// template<class T, class... Args> shared_ptr<T> make_shared(Args&&... args);
+
+#include <memory>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct S {
+protected:
+   S () {};  // ctor is protected
+};
+
+int main()
+{
+    std::shared_ptr<S> p = std::make_shared<S>();  // expected-error-re@memory:* {{static_assert failed{{.*}} "Can't construct object in make_shared"}}
+}
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp
index 501844a1d6ce..b7ea8d4dc6d3 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.ownerless/owner_less.pass.cpp
@@ -74,14 +74,14 @@ int main()
     assert(!cs(p2, p1));
     assert(cs(p1 ,p3) || cs(p3, p1));
     assert(cs(p3, p1) == cs(p3, p2));
-	ASSERT_NOEXCEPT(cs(p1, p1));
+    ASSERT_NOEXCEPT(cs(p1, p1));
 
     assert(!cs(p1, w2));
     assert(!cs(p2, w1));
     assert(cs(p1, w3) || cs(p3, w1));
     assert(cs(p3, w1) == cs(p3, w2));
-	ASSERT_NOEXCEPT(cs(p1, w1));
-	ASSERT_NOEXCEPT(cs(w1, p1));
+    ASSERT_NOEXCEPT(cs(p1, w1));
+    ASSERT_NOEXCEPT(cs(w1, p1));
     }
     {
     typedef std::owner_less<std::weak_ptr<int> > CS;
@@ -95,14 +95,14 @@ int main()
     assert(!cs(w2, w1));
     assert(cs(w1, w3) || cs(w3, w1));
     assert(cs(w3, w1) == cs(w3, w2));
-	ASSERT_NOEXCEPT(cs(w1, w1));
+    ASSERT_NOEXCEPT(cs(w1, w1));
 
     assert(!cs(w1, p2));
     assert(!cs(w2, p1));
     assert(cs(w1, p3) || cs(w3, p1));
     assert(cs(w3, p1) == cs(w3, p2));
-	ASSERT_NOEXCEPT(cs(w1, p1));
-	ASSERT_NOEXCEPT(cs(p1, w1));
+    ASSERT_NOEXCEPT(cs(w1, p1));
+    ASSERT_NOEXCEPT(cs(p1, w1));
     }
 #if TEST_STD_VER > 14
     {
@@ -112,21 +112,21 @@ int main()
     std::weak_ptr<int> wp1;
 
     std::owner_less<> cmp;
-    cmp(sp1, sp2);
-    cmp(sp1, wp1);
-    cmp(sp1, sp3);
-    cmp(wp1, sp1);
-    cmp(wp1, wp1);
-	ASSERT_NOEXCEPT(cmp(sp1, sp1));
-	ASSERT_NOEXCEPT(cmp(sp1, wp1));
-	ASSERT_NOEXCEPT(cmp(wp1, sp1));
-	ASSERT_NOEXCEPT(cmp(wp1, wp1));
+    assert(!cmp(sp1, sp2));
+    assert(!cmp(sp1, wp1));
+    assert(!cmp(sp1, sp3));
+    assert(!cmp(wp1, sp1));
+    assert(!cmp(wp1, wp1));
+    ASSERT_NOEXCEPT(cmp(sp1, sp1));
+    ASSERT_NOEXCEPT(cmp(sp1, wp1));
+    ASSERT_NOEXCEPT(cmp(wp1, sp1));
+    ASSERT_NOEXCEPT(cmp(wp1, wp1));
     }
     {
     // test heterogeneous lookups
     std::set<std::shared_ptr<X>, std::owner_less<>> s;
     std::shared_ptr<void> vp;
-    s.find(vp);
+    assert(s.find(vp) == s.end());
     }
 #endif
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp
index 458f8a11ed12..23df0d8e68ed 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_shared_ptr.pass.cpp
@@ -29,6 +29,5 @@ int main()
     assert(!w2.owner_before(p1));
     assert(w1.owner_before(p3) || w3.owner_before(p1));
     assert(w3.owner_before(p1) == w3.owner_before(p2));
-//  change to 'ASSERT_NOEXCEPT' when LWG2942 is adopted
-    LIBCPP_ASSERT_NOEXCEPT(w1.owner_before(p2));
+    ASSERT_NOEXCEPT(w1.owner_before(p2));
 }
diff --git a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp
index 5cd171a53021..a38bf67c2e03 100644
--- a/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp
+++ b/test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.obs/owner_before_weak_ptr.pass.cpp
@@ -29,6 +29,5 @@ int main()
     assert(!w2.owner_before(w1));
     assert(w1.owner_before(w3) || w3.owner_before(w1));
     assert(w3.owner_before(w1) == w3.owner_before(w2));
-//  change to 'ASSERT_NOEXCEPT' when LWG2942 is adopted
-    LIBCPP_ASSERT_NOEXCEPT(w1.owner_before(w2));
+    ASSERT_NOEXCEPT(w1.owner_before(w2));
 }
diff --git a/test/std/utilities/meta/meta.rel/is_callable.pass.cpp b/test/std/utilities/meta/meta.rel/is_callable.pass.cpp
deleted file mode 100644
index 4c85f440b0bf..000000000000
--- a/test/std/utilities/meta/meta.rel/is_callable.pass.cpp
+++ /dev/null
@@ -1,160 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11, c++14
-
-// type_traits
-
-// is_callable
-
-// Most testing of is_callable is done within the [meta.trans.other] result_of
-// tests.
-
-#include <type_traits>
-#include <functional>
-#include <memory>
-
-#include "test_macros.h"
-
-struct Tag {};
-struct DerFromTag : Tag {};
-
-struct Implicit {
-  Implicit(int) {}
-};
-
-struct Explicit {
-  explicit Explicit(int) {}
-};
-
-struct NotCallableWithInt {
-  int operator()(int) = delete;
-  int operator()(Tag) { return 42; }
-};
-
-int main()
-{
-    {
-        using Fn = int(Tag::*)(int);
-        using RFn = int(Tag::*)(int) &&;
-        // INVOKE bullet 1, 2 and 3
-        {
-            // Bullet 1
-            static_assert(std::is_callable<Fn(Tag&, int)>::value, "");
-            static_assert(std::is_callable<Fn(DerFromTag&, int)>::value, "");
-            static_assert(std::is_callable<RFn(Tag&&, int)>::value, "");
-            static_assert(!std::is_callable<RFn(Tag&, int)>::value, "");
-            static_assert(!std::is_callable<Fn(Tag&)>::value, "");
-            static_assert(!std::is_callable<Fn(Tag const&, int)>::value, "");
-        }
-        {
-            // Bullet 2
-            using T = std::reference_wrapper<Tag>;
-            using DT = std::reference_wrapper<DerFromTag>;
-            using CT = std::reference_wrapper<const Tag>;
-            static_assert(std::is_callable<Fn(T&, int)>::value, "");
-            static_assert(std::is_callable<Fn(DT&, int)>::value, "");
-            static_assert(std::is_callable<Fn(const T&, int)>::value, "");
-            static_assert(std::is_callable<Fn(T&&, int)>::value, "");
-            static_assert(!std::is_callable<Fn(CT&, int)>::value, "");
-            static_assert(!std::is_callable<RFn(T, int)>::value, "");
-        }
-        {
-            // Bullet 3
-            using T = Tag*;
-            using DT = DerFromTag*;
-            using CT = const Tag*;
-            using ST = std::unique_ptr<Tag>;
-            static_assert(std::is_callable<Fn(T&, int)>::value, "");
-            static_assert(std::is_callable<Fn(DT&, int)>::value, "");
-            static_assert(std::is_callable<Fn(const T&, int)>::value, "");
-            static_assert(std::is_callable<Fn(T&&, int)>::value, "");
-            static_assert(std::is_callable<Fn(ST, int)>::value, "");
-            static_assert(!std::is_callable<Fn(CT&, int)>::value, "");
-            static_assert(!std::is_callable<RFn(T, int)>::value, "");
-        }
-    }
-    {
-        // Bullets 4, 5 and 6
-        using Fn = int (Tag::*);
-        static_assert(!std::is_callable<Fn()>::value, "");
-        {
-            // Bullet 4
-            static_assert(std::is_callable<Fn(Tag&)>::value, "");
-            static_assert(std::is_callable<Fn(DerFromTag&)>::value, "");
-            static_assert(std::is_callable<Fn(Tag&&)>::value, "");
-            static_assert(std::is_callable<Fn(Tag const&)>::value, "");
-        }
-        {
-            // Bullet 5
-            using T = std::reference_wrapper<Tag>;
-            using DT = std::reference_wrapper<DerFromTag>;
-            using CT = std::reference_wrapper<const Tag>;
-            static_assert(std::is_callable<Fn(T&)>::value, "");
-            static_assert(std::is_callable<Fn(DT&)>::value, "");
-            static_assert(std::is_callable<Fn(const T&)>::value, "");
-            static_assert(std::is_callable<Fn(T&&)>::value, "");
-            static_assert(std::is_callable<Fn(CT&)>::value, "");
-        }
-        {
-            // Bullet 6
-            using T = Tag*;
-            using DT = DerFromTag*;
-            using CT = const Tag*;
-            using ST = std::unique_ptr<Tag>;
-            static_assert(std::is_callable<Fn(T&)>::value, "");
-            static_assert(std::is_callable<Fn(DT&)>::value, "");
-            static_assert(std::is_callable<Fn(const T&)>::value, "");
-            static_assert(std::is_callable<Fn(T&&)>::value, "");
-            static_assert(std::is_callable<Fn(ST)>::value, "");
-            static_assert(std::is_callable<Fn(CT&)>::value, "");
-        }
-    }
-    {
-        // INVOKE bullet 7
-        {
-            // Function pointer
-            using Fp = void(*)(Tag&, int);
-            static_assert(std::is_callable<Fp(Tag&, int)>::value, "");
-            static_assert(std::is_callable<Fp(DerFromTag&, int)>::value, "");
-            static_assert(!std::is_callable<Fp(const Tag&, int)>::value, "");
-            static_assert(!std::is_callable<Fp()>::value, "");
-            static_assert(!std::is_callable<Fp(Tag&)>::value, "");
-        }
-        {
-            // Function reference
-            using Fp = void(&)(Tag&, int);
-            static_assert(std::is_callable<Fp(Tag&, int)>::value, "");
-            static_assert(std::is_callable<Fp(DerFromTag&, int)>::value, "");
-            static_assert(!std::is_callable<Fp(const Tag&, int)>::value, "");
-            static_assert(!std::is_callable<Fp()>::value, "");
-            static_assert(!std::is_callable<Fp(Tag&)>::value, "");
-        }
-        {
-            // Function object
-            using Fn = NotCallableWithInt;
-            static_assert(std::is_callable<Fn(Tag)>::value, "");
-            static_assert(!std::is_callable<Fn(int)>::value, "");
-        }
-    }
-    {
-        // Check that the conversion to the return type is properly checked
-        using Fn = int(*)();
-        static_assert(std::is_callable<Fn(), Implicit>::value, "");
-        static_assert(std::is_callable<Fn(), double>::value, "");
-        static_assert(std::is_callable<Fn(), const volatile void>::value, "");
-        static_assert(!std::is_callable<Fn(), Explicit>::value, "");
-    }
-    {
-        // Check for is_callable_v
-        using Fn = void(*)();
-        static_assert(std::is_callable_v<Fn()>, "");
-        static_assert(!std::is_callable_v<Fn(int)>, "");
-    }
-}
diff --git a/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp b/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
new file mode 100644
index 000000000000..1b2a9286f949
--- /dev/null
+++ b/test/std/utilities/meta/meta.rel/is_invocable.pass.cpp
@@ -0,0 +1,166 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// type_traits
+
+// is_invocable
+
+// Most testing of is_invocable is done within the [meta.trans.other] result_of
+// tests.
+
+#include <type_traits>
+#include <functional>
+#include <memory>
+
+#include "test_macros.h"
+
+struct Tag {};
+struct DerFromTag : Tag {};
+
+struct Implicit {
+  Implicit(int) {}
+};
+
+struct Explicit {
+  explicit Explicit(int) {}
+};
+
+struct NotCallableWithInt {
+  int operator()(int) = delete;
+  int operator()(Tag) { return 42; }
+};
+
+int main()
+{
+    {
+        using Fn = int(Tag::*)(int);
+        using RFn = int(Tag::*)(int) &&;
+        // INVOKE bullet 1, 2 and 3
+        {
+            // Bullet 1
+            static_assert(std::is_invocable<Fn, Tag&, int>::value, "");
+            static_assert(std::is_invocable<Fn, DerFromTag&, int>::value, "");
+            static_assert(std::is_invocable<RFn, Tag&&, int>::value, "");
+            static_assert(!std::is_invocable<RFn, Tag&, int>::value, "");
+            static_assert(!std::is_invocable<Fn, Tag&>::value, "");
+            static_assert(!std::is_invocable<Fn, Tag const&, int>::value, "");
+        }
+        {
+            // Bullet 2
+            using T = std::reference_wrapper<Tag>;
+            using DT = std::reference_wrapper<DerFromTag>;
+            using CT = std::reference_wrapper<const Tag>;
+            static_assert(std::is_invocable<Fn, T&, int>::value, "");
+            static_assert(std::is_invocable<Fn, DT&, int>::value, "");
+            static_assert(std::is_invocable<Fn, const T&, int>::value, "");
+            static_assert(std::is_invocable<Fn, T&&, int>::value, "");
+            static_assert(!std::is_invocable<Fn, CT&, int>::value, "");
+            static_assert(!std::is_invocable<RFn, T, int>::value, "");
+        }
+        {
+            // Bullet 3
+            using T = Tag*;
+            using DT = DerFromTag*;
+            using CT = const Tag*;
+            using ST = std::unique_ptr<Tag>;
+            static_assert(std::is_invocable<Fn, T&, int>::value, "");
+            static_assert(std::is_invocable<Fn, DT&, int>::value, "");
+            static_assert(std::is_invocable<Fn, const T&, int>::value, "");
+            static_assert(std::is_invocable<Fn, T&&, int>::value, "");
+            static_assert(std::is_invocable<Fn, ST, int>::value, "");
+            static_assert(!std::is_invocable<Fn, CT&, int>::value, "");
+            static_assert(!std::is_invocable<RFn, T, int>::value, "");
+        }
+    }
+    {
+        // Bullets 4, 5 and 6
+        using Fn = int (Tag::*);
+        static_assert(!std::is_invocable<Fn>::value, "");
+        {
+            // Bullet 4
+            static_assert(std::is_invocable<Fn, Tag&>::value, "");
+            static_assert(std::is_invocable<Fn, DerFromTag&>::value, "");
+            static_assert(std::is_invocable<Fn, Tag&&>::value, "");
+            static_assert(std::is_invocable<Fn, Tag const&>::value, "");
+        }
+        {
+            // Bullet 5
+            using T = std::reference_wrapper<Tag>;
+            using DT = std::reference_wrapper<DerFromTag>;
+            using CT = std::reference_wrapper<const Tag>;
+            static_assert(std::is_invocable<Fn, T&>::value, "");
+            static_assert(std::is_invocable<Fn, DT&>::value, "");
+            static_assert(std::is_invocable<Fn, const T&>::value, "");
+            static_assert(std::is_invocable<Fn, T&&>::value, "");
+            static_assert(std::is_invocable<Fn, CT&>::value, "");
+        }
+        {
+            // Bullet 6
+            using T = Tag*;
+            using DT = DerFromTag*;
+            using CT = const Tag*;
+            using ST = std::unique_ptr<Tag>;
+            static_assert(std::is_invocable<Fn, T&>::value, "");
+            static_assert(std::is_invocable<Fn, DT&>::value, "");
+            static_assert(std::is_invocable<Fn, const T&>::value, "");
+            static_assert(std::is_invocable<Fn, T&&>::value, "");
+            static_assert(std::is_invocable<Fn, ST>::value, "");
+            static_assert(std::is_invocable<Fn, CT&>::value, "");
+        }
+    }
+    {
+        // INVOKE bullet 7
+        {
+            // Function pointer
+            using Fp = void(*)(Tag&, int);
+            static_assert(std::is_invocable<Fp, Tag&, int>::value, "");
+            static_assert(std::is_invocable<Fp, DerFromTag&, int>::value, "");
+            static_assert(!std::is_invocable<Fp, const Tag&, int>::value, "");
+            static_assert(!std::is_invocable<Fp>::value, "");
+            static_assert(!std::is_invocable<Fp, Tag&>::value, "");
+        }
+        {
+            // Function reference
+            using Fp = void(&)(Tag&, int);
+            static_assert(std::is_invocable<Fp, Tag&, int>::value, "");
+            static_assert(std::is_invocable<Fp, DerFromTag&, int>::value, "");
+            static_assert(!std::is_invocable<Fp, const Tag&, int>::value, "");
+            static_assert(!std::is_invocable<Fp>::value, "");
+            static_assert(!std::is_invocable<Fp, Tag&>::value, "");
+        }
+        {
+            // Function object
+            using Fn = NotCallableWithInt;
+            static_assert(std::is_invocable<Fn, Tag>::value, "");
+            static_assert(!std::is_invocable<Fn, int>::value, "");
+        }
+    }
+    {
+        // Check that the conversion to the return type is properly checked
+        using Fn = int(*)();
+        static_assert(std::is_invocable_r<Implicit, Fn>::value, "");
+        static_assert(std::is_invocable_r<double, Fn>::value, "");
+        static_assert(std::is_invocable_r<const volatile void, Fn>::value, "");
+        static_assert(!std::is_invocable_r<Explicit, Fn>::value, "");
+    }
+    {
+        // Check for is_invocable_v
+        using Fn = void(*)();
+        static_assert(std::is_invocable_v<Fn>, "");
+        static_assert(!std::is_invocable_v<Fn, int>, "");
+    }
+    {
+        // Check for is_invocable_r_v
+        using Fn = void(*)();
+        static_assert(std::is_invocable_r_v<void, Fn>, "");
+        static_assert(!std::is_invocable_r_v<int, Fn>, "");
+    }
+}
diff --git a/test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp b/test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp
deleted file mode 100644
index eefa6d1f22b1..000000000000
--- a/test/std/utilities/meta/meta.rel/is_nothrow_callable.pass.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11, c++14
-
-// type_traits
-
-// is_nothrow_callable
-
-#include <type_traits>
-#include <functional>
-
-#include "test_macros.h"
-
-struct Tag {};
-
-struct Implicit {
-  Implicit(int) noexcept {}
-};
-
-struct ThrowsImplicit {
-  ThrowsImplicit(int) {}
-};
-
-struct Explicit {
-  explicit Explicit(int) noexcept {}
-};
-
-template <bool IsNoexcept, class Ret, class ...Args>
-struct CallObject {
-  Ret operator()(Args&&...) const noexcept(IsNoexcept);
-};
-
-template <class Fn>
-constexpr bool throws_callable() {
-    return std::is_callable<Fn>::value &&
-        !std::is_nothrow_callable<Fn>::value;
-}
-
-template <class Fn, class Ret>
-constexpr bool throws_callable() {
-    return std::is_callable<Fn, Ret>::value &&
-        !std::is_nothrow_callable<Fn, Ret>::value;
-}
-
-// FIXME(EricWF) Don't test the where noexcept is *not* part of the type system
-// once implementations have caught up.
-void test_noexcept_function_pointers()
-{
-    struct Dummy { void foo() noexcept {} static void bar() noexcept {} };
-#if !defined(__cpp_noexcept_function_type)
-    {
-        // Check that PMF's and function pointers *work*. is_nothrow_callable will always
-        // return false because 'noexcept' is not part of the function type.
-        static_assert(throws_callable<decltype(&Dummy::foo)(Dummy&)>(), "");
-        static_assert(throws_callable<decltype(&Dummy::bar)()>(), "");
-    }
-#else
-    {
-        // Check that PMF's and function pointers actually work and that
-        // is_nothrow_callable returns true for noexcept PMF's and function
-        // pointers.
-        static_assert(std::is_nothrow_callable<decltype(&Dummy::foo)(Dummy&)>::value, "");
-        static_assert(std::is_nothrow_callable<decltype(&Dummy::bar)()>::value, "");
-    }
-#endif
-}
-
-int main()
-{
-    {
-        // Check that the conversion to the return type is properly checked
-        using Fn = CallObject<true, int>;
-        static_assert(std::is_nothrow_callable<Fn(), Implicit>::value, "");
-        static_assert(std::is_nothrow_callable<Fn(), double>::value, "");
-        static_assert(std::is_nothrow_callable<Fn(), const volatile void>::value, "");
-        static_assert(throws_callable<Fn(), ThrowsImplicit>(), "");
-        static_assert(!std::is_nothrow_callable<Fn(), Explicit>(), "");
-    }
-    {
-        // Check that the conversion to the parameters is properly checked
-        using Fn = CallObject<true, void, const Implicit&, const ThrowsImplicit&>;
-        static_assert(std::is_nothrow_callable<Fn(Implicit&, ThrowsImplicit&)>::value, "");
-        static_assert(std::is_nothrow_callable<Fn(int, ThrowsImplicit&)>::value, "");
-        static_assert(throws_callable<Fn(int, int)>(), "");
-        static_assert(!std::is_nothrow_callable<Fn()>::value, "");
-    }
-    {
-        // Check that the noexcept-ness of function objects is checked.
-        using Fn = CallObject<true, void>;
-        using Fn2 = CallObject<false, void>;
-        static_assert(std::is_nothrow_callable<Fn()>::value, "");
-        static_assert(throws_callable<Fn2()>(), "");
-    }
-    {
-        // Check that PMD derefs are noexcept
-        using Fn = int (Tag::*);
-        static_assert(std::is_nothrow_callable<Fn(Tag&)>::value, "");
-        static_assert(std::is_nothrow_callable<Fn(Tag&), Implicit>::value, "");
-        static_assert(throws_callable<Fn(Tag&), ThrowsImplicit>(), "");
-    }
-    {
-        // Check for is_nothrow_callable_v
-        using Fn = CallObject<true, int>;
-        static_assert(std::is_nothrow_callable_v<Fn()>, "");
-        static_assert(!std::is_nothrow_callable_v<Fn(int)>, "");
-    }
-    test_noexcept_function_pointers();
-}
diff --git a/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp b/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
new file mode 100644
index 000000000000..3be3d46f295b
--- /dev/null
+++ b/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp
@@ -0,0 +1,121 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// type_traits
+
+// is_nothrow_invocable
+
+#include <type_traits>
+#include <functional>
+
+#include "test_macros.h"
+
+struct Tag {};
+
+struct Implicit {
+  Implicit(int) noexcept {}
+};
+
+struct ThrowsImplicit {
+  ThrowsImplicit(int) {}
+};
+
+struct Explicit {
+  explicit Explicit(int) noexcept {}
+};
+
+template <bool IsNoexcept, class Ret, class ...Args>
+struct CallObject {
+  Ret operator()(Args&&...) const noexcept(IsNoexcept);
+};
+
+template <class Fn, class ...Args>
+constexpr bool throws_invocable() {
+    return std::is_invocable<Fn, Args...>::value &&
+        !std::is_nothrow_invocable<Fn, Args...>::value;
+}
+
+template <class Ret, class Fn, class ...Args>
+constexpr bool throws_invocable_r() {
+    return std::is_invocable_r<Ret, Fn, Args...>::value &&
+        !std::is_nothrow_invocable_r<Ret, Fn, Args...>::value;
+}
+
+// FIXME(EricWF) Don't test the where noexcept is *not* part of the type system
+// once implementations have caught up.
+void test_noexcept_function_pointers()
+{
+    struct Dummy { void foo() noexcept {} static void bar() noexcept {} };
+#if !defined(__cpp_noexcept_function_type)
+    {
+        // Check that PMF's and function pointers *work*. is_nothrow_invocable will always
+        // return false because 'noexcept' is not part of the function type.
+        static_assert(throws_invocable<decltype(&Dummy::foo), Dummy&>(), "");
+        static_assert(throws_invocable<decltype(&Dummy::bar)>(), "");
+    }
+#else
+    {
+        // Check that PMF's and function pointers actually work and that
+        // is_nothrow_invocable returns true for noexcept PMF's and function
+        // pointers.
+        static_assert(std::is_nothrow_invocable<decltype(&Dummy::foo), Dummy&>::value, "");
+        static_assert(std::is_nothrow_invocable<decltype(&Dummy::bar)>::value, "");
+    }
+#endif
+}
+
+int main()
+{
+    {
+        // Check that the conversion to the return type is properly checked
+        using Fn = CallObject<true, int>;
+        static_assert(std::is_nothrow_invocable_r<Implicit, Fn>::value, "");
+        static_assert(std::is_nothrow_invocable_r<double, Fn>::value, "");
+        static_assert(std::is_nothrow_invocable_r<const volatile void, Fn>::value, "");
+        static_assert(throws_invocable_r<ThrowsImplicit, Fn>(), "");
+        static_assert(!std::is_nothrow_invocable<Fn(), Explicit>(), "");
+    }
+    {
+        // Check that the conversion to the parameters is properly checked
+        using Fn = CallObject<true, void, const Implicit&, const ThrowsImplicit&>;
+        static_assert(std::is_nothrow_invocable<Fn, Implicit&, ThrowsImplicit&>::value, "");
+        static_assert(std::is_nothrow_invocable<Fn, int, ThrowsImplicit&>::value, "");
+        static_assert(throws_invocable<Fn, int, int>(), "");
+        static_assert(!std::is_nothrow_invocable<Fn>::value, "");
+    }
+    {
+        // Check that the noexcept-ness of function objects is checked.
+        using Fn = CallObject<true, void>;
+        using Fn2 = CallObject<false, void>;
+        static_assert(std::is_nothrow_invocable<Fn>::value, "");
+        static_assert(throws_invocable<Fn2>(), "");
+    }
+    {
+        // Check that PMD derefs are noexcept
+        using Fn = int (Tag::*);
+        static_assert(std::is_nothrow_invocable<Fn, Tag&>::value, "");
+        static_assert(std::is_nothrow_invocable_r<Implicit, Fn, Tag&>::value, "");
+        static_assert(throws_invocable_r<ThrowsImplicit, Fn, Tag&>(), "");
+    }
+    {
+        // Check for is_nothrow_invocable_v
+        using Fn = CallObject<true, int>;
+        static_assert(std::is_nothrow_invocable_v<Fn>, "");
+        static_assert(!std::is_nothrow_invocable_v<Fn, int>, "");
+    }
+    {
+        // Check for is_nothrow_invocable_r_v
+        using Fn = CallObject<true, int>;
+        static_assert(std::is_nothrow_invocable_r_v<void, Fn>, "");
+        static_assert(!std::is_nothrow_invocable_r_v<int, Fn, int>, "");
+    }
+    test_noexcept_function_pointers();
+}
diff --git a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/nothing_to_do.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.fail.cpp
index b58f5c55b643..efee5064cf59 100644
--- a/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.overview/nothing_to_do.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.fail.cpp
@@ -7,6 +7,17 @@
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03
+
+// type_traits
+
+// aligned_union<size_t Len, class ...Types>
+
+#include <type_traits>
+
+class A; // Incomplete
+
 int main()
 {
+    typedef std::aligned_union<10, A>::type T1;
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
index 4f45a0340a91..c0aece771f0c 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/decay.pass.cpp
@@ -34,9 +34,9 @@ int main()
     test_decay<const int[3], const int*>();
     test_decay<void(), void (*)()>();
 #if TEST_STD_VER > 11
-	test_decay<int(int) const, int(int) const>();
-	test_decay<int(int) volatile, int(int) volatile>();
-	test_decay<int(int)  &, int(int)  &>();
-	test_decay<int(int) &&, int(int) &&>();
+    test_decay<int(int) const, int(int) const>();
+    test_decay<int(int) volatile, int(int) volatile>();
+    test_decay<int(int)  &, int(int)  &>();
+    test_decay<int(int) &&, int(int) &&>();
 #endif
 }
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/remove_cvref.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/remove_cvref.pass.cpp
new file mode 100644
index 000000000000..e06229f7e975
--- /dev/null
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/remove_cvref.pass.cpp
@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// type_traits
+
+// remove_cvref
+
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class T, class U>
+void test_remove_cvref()
+{
+    static_assert((std::is_same<typename std::remove_cvref<T>::type, U>::value), "");
+    static_assert((std::is_same<         std::remove_cvref_t<T>,     U>::value), "");
+}
+
+int main()
+{
+    test_remove_cvref<void, void>();
+    test_remove_cvref<int, int>();
+    test_remove_cvref<const int, int>();
+    test_remove_cvref<const volatile int, int>();
+    test_remove_cvref<volatile int, int>();
+
+//	Doesn't decay
+    test_remove_cvref<int[3],                 int[3]>();
+    test_remove_cvref<int const [3],          int[3]>();
+    test_remove_cvref<int volatile [3],       int[3]>();
+    test_remove_cvref<int const volatile [3], int[3]>();
+    test_remove_cvref<void(), void ()>();
+
+    test_remove_cvref<int &, int>();
+    test_remove_cvref<const int &, int>();
+    test_remove_cvref<const volatile int &, int>();
+    test_remove_cvref<volatile int &, int>();
+
+    test_remove_cvref<int*, int*>();
+    test_remove_cvref<int(int) const, int(int) const>();
+    test_remove_cvref<int(int) volatile, int(int) volatile>();
+    test_remove_cvref<int(int)  &, int(int)  &>();
+    test_remove_cvref<int(int) &&, int(int) &&>();
+}
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
index fc01b22c36ab..24231526b2bf 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.pass.cpp
@@ -42,16 +42,46 @@ struct HasType : std::false_type {};
 template <class T>
 struct HasType<T, typename Voider<typename T::type>::type> : std::true_type {};
 
+#if TEST_STD_VER > 14
+template <typename T, typename U>
+struct test_invoke_result;
+
+template <typename Fn, typename ...Args, typename Ret>
+struct test_invoke_result<Fn(Args...), Ret>
+{
+    static void call()
+    {
+        static_assert(std::is_invocable<Fn, Args...>::value, "");
+        static_assert(std::is_invocable_r<Ret, Fn, Args...>::value, "");
+        static_assert((std::is_same<typename std::invoke_result<Fn, Args...>::type, Ret>::value), "");
+    }
+};
+#endif
+
 template <class T, class U>
 void test_result_of()
 {
+    static_assert((std::is_same<typename std::result_of<T>::type, U>::value), "");
 #if TEST_STD_VER > 14
-    static_assert(std::is_callable<T>::value, "");
-    static_assert(std::is_callable<T, U>::value, "");
+    test_invoke_result<T, U>::call();
 #endif
-    static_assert((std::is_same<typename std::result_of<T>::type, U>::value), "");
 }
 
+#if TEST_STD_VER > 14
+template <typename T>
+struct test_invoke_no_result;
+
+template <typename Fn, typename ...Args>
+struct test_invoke_no_result<Fn(Args...)>
+{
+    static void call()
+    {
+        static_assert(std::is_invocable<Fn, Args...>::value == false, "");
+        static_assert((!HasType<std::invoke_result<Fn, Args...> >::value), "");
+    }
+};
+#endif
+
 template <class T>
 void test_no_result()
 {
@@ -59,7 +89,7 @@ void test_no_result()
     static_assert((!HasType<std::result_of<T> >::value), "");
 #endif
 #if TEST_STD_VER > 14
-    static_assert(std::is_callable<T>::value == false, "");
+    test_invoke_no_result<T>::call();
 #endif
 }
 
diff --git a/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp b/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp
index eac4e4a089fe..2b8cd709677b 100644
--- a/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp
+++ b/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp
@@ -27,6 +27,23 @@ struct wat
 struct F {};
 struct FD : public F {};
 
+#if TEST_STD_VER > 14
+template <typename T, typename U>
+struct test_invoke_result;
+
+template <typename Fn, typename ...Args, typename Ret>
+struct test_invoke_result<Fn(Args...), Ret>
+{
+    static void call()
+    {
+        static_assert(std::is_invocable<Fn, Args...>::value, "");
+        static_assert(std::is_invocable_r<Ret, Fn, Args...>::value, "");
+        static_assert((std::is_same<typename std::invoke_result<Fn, Args...>::type, Ret>::value), "");
+        static_assert((std::is_same<std::invoke_result_t<Fn, Args...>, Ret>::value), "");
+    }
+};
+#endif
+
 template <class T, class U>
 void test_result_of_imp()
 {
@@ -35,8 +52,7 @@ void test_result_of_imp()
     static_assert((std::is_same<std::result_of_t<T>, U>::value), "");
 #endif
 #if TEST_STD_VER > 14
-    static_assert(std::is_callable<T>::value, "");
-    static_assert(std::is_callable<T, U>::value, "");
+    test_invoke_result<T, U>::call();
 #endif
 }
 
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
index 4e875fa94520..23d5176127a1 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.cat/is_function.pass.cpp
@@ -77,11 +77,11 @@ typedef void (*FunctionPtr)();
 
 int main()
 {
-	test_is_function<void(void)>();
-	test_is_function<int(int)>();
-	test_is_function<int(int, double)>();
-	test_is_function<int(Abstract *)>();
-	test_is_function<void(...)>();
+    test_is_function<void(void)>();
+    test_is_function<int(int)>();
+    test_is_function<int(int, double)>();
+    test_is_function<int(Abstract *)>();
+    test_is_function<void(...)>();
 
   test_is_not_function<std::nullptr_t>();
   test_is_not_function<void>();
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp
index f776196dd7a9..052b0b9851d6 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.comp/is_fundamental.pass.cpp
@@ -91,11 +91,11 @@ int main()
     test_is_fundamental<unsigned char>();
     test_is_fundamental<wchar_t>();
     test_is_fundamental<double>();
-	test_is_fundamental<float>();
-	test_is_fundamental<double>();
-	test_is_fundamental<long double>();
-	test_is_fundamental<char16_t>();
-	test_is_fundamental<char32_t>();
+    test_is_fundamental<float>();
+    test_is_fundamental<double>();
+    test_is_fundamental<long double>();
+    test_is_fundamental<char16_t>();
+    test_is_fundamental<char32_t>();
 
     test_is_not_fundamental<char[3]>();
     test_is_not_fundamental<char[]>();
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
index 3955d4bc3306..8d63a23494b9 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp
@@ -81,5 +81,5 @@ int main()
     test_is_not_assignable<int(), int> ();
 
 //  pointer to incomplete template type
-	test_is_assignable<X<D>*&, X<D>*> ();
+    test_is_assignable<X<D>*&, X<D>*> ();
 }
diff --git a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
index 9d2ec5edea58..1f7c32a8cc07 100644
--- a/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
+++ b/test/std/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
@@ -9,7 +9,7 @@
 
 // type_traits
 // XFAIL: apple-clang-6.0
-//	The Apple-6 compiler gets is_constructible<void ()> wrong.
+//  The Apple-6 compiler gets is_constructible<void ()> wrong.
 
 // template <class T, class... Args>
 //   struct is_constructible;
diff --git a/test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp b/test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp
index f9ea7b47911f..c97bebe29c3c 100644
--- a/test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp
+++ b/test/std/utilities/optional/optional.nullopt/nullopt_t.fail.cpp
@@ -11,17 +11,15 @@
 // <optional>
 
 // struct nullopt_t{see below};
-// constexpr nullopt_t nullopt(unspecified);
+// inline constexpr nullopt_t nullopt(unspecified);
 
 // [optional.nullopt]/2:
-//   Type nullopt_t shall not have a default constructor or an initializer-list constructor.
-//   It shall not be an aggregate and shall be a literal type.
-//   Constant nullopt shall be initialized with an argument of literal type.
+//   Type nullopt_t shall not have a default constructor or an initializer-list
+//   constructor, and shall not be an aggregate.
 
 #include <optional>
-#include "test_macros.h"
 
 int main()
 {
-	std::nullopt_t n = {};
+    std::nullopt_t n = {};
 }
diff --git a/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp b/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp
index 9b752a665a83..247fce58fe97 100644
--- a/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp
+++ b/test/std/utilities/optional/optional.nullopt/nullopt_t.pass.cpp
@@ -11,33 +11,30 @@
 // <optional>
 
 // struct nullopt_t{see below};
-// constexpr nullopt_t nullopt(unspecified);
+// inline constexpr nullopt_t nullopt(unspecified);
 
 // [optional.nullopt]/2:
-//   Type nullopt_t shall not have a default constructor or an initializer-list constructor.
-//   It shall not be an aggregate and shall be a literal type.
-//   Constant nullopt shall be initialized with an argument of literal type.
+//   Type nullopt_t shall not have a default constructor or an initializer-list
+//   constructor, and shall not be an aggregate.
 
 #include <optional>
 #include <type_traits>
 
-using std::optional;
 using std::nullopt_t;
 using std::nullopt;
 
-constexpr
-int
-test(const nullopt_t&)
+constexpr bool test()
 {
-    return 3;
+    nullopt_t foo{nullopt};
+    (void)foo;
+    return true;
 }
 
 int main()
 {
-    static_assert(( std::is_class<nullopt_t>::value), "");
-    static_assert(( std::is_empty<nullopt_t>::value), "");
-    static_assert(( std::is_literal_type<nullopt_t>::value), "");
-    static_assert((!std::is_default_constructible<nullopt_t>::value), "");
+    static_assert(std::is_empty_v<nullopt_t>);
+    static_assert(!std::is_default_constructible_v<nullopt_t>);
 
-    static_assert(test(nullopt) == 3, "");
+    static_assert(std::is_same_v<const nullopt_t, decltype(nullopt)>);
+    static_assert(test());
 }
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/copy.fail.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/copy.fail.cpp
index 3224c1bac756..77e411b2e3b5 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/copy.fail.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/copy.fail.cpp
@@ -21,11 +21,11 @@
 #include "test_macros.h"
 
 struct S {
-	constexpr S()   : v_(0) {}
-	S(int v)        : v_(v) {}
-	S(const S &rhs) : v_(rhs.v_) {}  // make it not trivially copyable
-	int v_;
-	};
+    constexpr S()   : v_(0) {}
+    S(int v)        : v_(v) {}
+    S(const S &rhs) : v_(rhs.v_) {}  // make it not trivially copyable
+    int v_;
+    };
 
 
 int main()
diff --git a/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp b/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
index fb2e139ad591..4e3991c18487 100644
--- a/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.ctor/move.fail.cpp
@@ -21,12 +21,12 @@
 #include "test_macros.h"
 
 struct S {
-	constexpr S()   : v_(0) {}
-	S(int v)        : v_(v) {}
-	constexpr S(const S  &rhs) : v_(rhs.v_) {} // not trivially moveable
-	constexpr S(const S &&rhs) : v_(rhs.v_) {} // not trivially moveable
-	int v_;
-	};
+    constexpr S()   : v_(0) {}
+    S(int v)        : v_(v) {}
+    constexpr S(const S  &rhs) : v_(rhs.v_) {} // not trivially moveable
+    constexpr S(const S &&rhs) : v_(rhs.v_) {} // not trivially moveable
+    int v_;
+    };
 
 
 int main()
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
index 44e6e7305901..bbc70014f099 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value.pass.cpp
@@ -69,7 +69,7 @@ int main()
         optional<X> opt;
         try
         {
-            opt.value();
+            (void)opt.value();
             assert(false);
         }
         catch (const bad_optional_access&)
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
index e2d48ec99302..c644fb9d6696 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp
@@ -61,7 +61,7 @@ int main()
         const optional<X> opt;
         try
         {
-            opt.value();
+            (void)opt.value();
             assert(false);
         }
         catch (const bad_optional_access&)
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
index 874a5441a4c2..5347d3f558bb 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_const_rvalue.pass.cpp
@@ -61,7 +61,7 @@ int main()
         const optional<X> opt;
         try
         {
-            std::move(opt).value();
+            (void)std::move(opt).value();
             assert(false);
         }
         catch (const bad_optional_access&)
diff --git a/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp b/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
index 60cab7d27c64..1a577e68b99e 100644
--- a/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
+++ b/test/std/utilities/optional/optional.object/optional.object.observe/value_rvalue.pass.cpp
@@ -67,7 +67,7 @@ int main()
         optional<X> opt;
         try
         {
-            std::move(opt).value();
+            (void)std::move(opt).value();
             assert(false);
         }
         catch (const bad_optional_access&)
diff --git a/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp b/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp
index 8a2c77af0ec1..11ddcb7c0028 100644
--- a/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp
+++ b/test/std/utilities/optional/optional.object/optional_requires_destructible_object.fail.cpp
@@ -26,22 +26,22 @@ int main()
 {
     using std::optional;
     {
-        // expected-error@optional:* 2 {{static_assert failed "instantiation of optional with a reference type is ill-formed}}
+        // expected-error-re@optional:* 2 {{static_assert failed{{.*}} "instantiation of optional with a reference type is ill-formed}}
         optional<int&> opt1;
         optional<int&&> opt2;
     }
     {
-        // expected-error@optional:* {{static_assert failed "instantiation of optional with a non-destructible type is ill-formed"}}
+        // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a non-destructible type is ill-formed"}}
         optional<X> opt3;
     }
     {
-        // expected-error@optional:* {{static_assert failed "instantiation of optional with a non-object type is undefined behavior"}}
-        // expected-error@optional:* {{static_assert failed "instantiation of optional with a non-destructible type is ill-formed}}
+        // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a non-object type is undefined behavior"}}
+        // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a non-destructible type is ill-formed}}
         optional<void()> opt4;
     }
     {
-        // expected-error@optional:* {{static_assert failed "instantiation of optional with a non-object type is undefined behavior"}}
-        // expected-error@optional:* {{static_assert failed "instantiation of optional with a non-destructible type is ill-formed}}
+        // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a non-object type is undefined behavior"}}
+        // expected-error-re@optional:* {{static_assert failed{{.*}} "instantiation of optional with a non-destructible type is ill-formed}}
         // expected-error@optional:* 1+ {{cannot form a reference to 'void'}}
         optional<const void> opt4;
     }
diff --git a/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp b/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp
index 687625e8b673..57903020fedb 100644
--- a/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp
+++ b/test/std/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp
@@ -19,4 +19,5 @@ int main()
     using std::optional;
 
     std::initializer_list<int> list;
+    (void)list;
 }
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp
index 4e2a6dfa3dd1..d747483a9d5a 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.ctor/move_convert.single.pass.cpp
@@ -14,7 +14,7 @@
 
 // Test unique_ptr converting move ctor
 
-// NOTE: unique_ptr does not provide converting constructors in c++03
+// NOTE: unique_ptr does not provide converting constructors in C++03
 // UNSUPPORTED: c++98, c++03
 
 #include <memory>
diff --git a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
index b05fb71cdc67..50058a6208a5 100644
--- a/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
+++ b/test/std/utilities/smartptr/unique.ptr/unique.ptr.class/unique.ptr.observers/dereference.runtime.fail.cpp
@@ -19,6 +19,6 @@
 int main() {
   std::unique_ptr<int[]> p(new int(3));
   const std::unique_ptr<int[]>& cp = p;
-  (void)(*p);  // expected-error {{indirection requires pointer operand ('std::unique_ptr<int []>' invalid)}}
-  (void)(*cp); // expected-error {{indirection requires pointer operand ('const std::unique_ptr<int []>' invalid)}}
+  TEST_IGNORE_NODISCARD (*p);  // expected-error {{indirection requires pointer operand ('std::unique_ptr<int []>' invalid)}}
+  TEST_IGNORE_NODISCARD (*cp); // expected-error {{indirection requires pointer operand ('const std::unique_ptr<int []>' invalid)}}
 }
diff --git a/test/std/utilities/template.bitset/bitset.members/to_ullong.pass.cpp b/test/std/utilities/template.bitset/bitset.members/to_ullong.pass.cpp
index a2c9df6b4a22..20578511c8cf 100644
--- a/test/std/utilities/template.bitset/bitset.members/to_ullong.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/to_ullong.pass.cpp
@@ -36,11 +36,18 @@ void test_to_ullong()
         std::bitset<N> v(j);
         assert(j == v.to_ullong());
     }
+    { // test values bigger than can fit into the bitset
+    const unsigned long long val = 0x55AAAAFFFFAAAA55ULL;
+    const bool canFit = N < sizeof(unsigned long long) * CHAR_BIT;
+    const unsigned long long mask = canFit ? (1ULL << (canFit ? N : 0)) - 1 : (unsigned long long)(-1); // avoid compiler warnings
+    std::bitset<N> v(val);
+    assert(v.to_ullong() == (val & mask)); // we shouldn't return bit patterns from outside the limits of the bitset.
+    }
 }
 
 int main()
 {
-    test_to_ullong<0>();
+//     test_to_ullong<0>();
     test_to_ullong<1>();
     test_to_ullong<31>();
     test_to_ullong<32>();
diff --git a/test/std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp b/test/std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp
index 7cabd06e5f32..0872d77bca91 100644
--- a/test/std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp
+++ b/test/std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp
@@ -37,6 +37,14 @@ void test_to_ulong()
         std::bitset<N> v(j);
         assert(j == v.to_ulong());
     }
+
+    { // test values bigger than can fit into the bitset
+    const unsigned long val = 0x5AFFFFA5UL;
+    const bool canFit = N < sizeof(unsigned long) * CHAR_BIT;
+    const unsigned long mask = canFit ? (1UL << (canFit ? N : 0)) - 1 : (unsigned long)(-1); // avoid compiler warnings
+    std::bitset<N> v(val);
+    assert(v.to_ulong() == (val & mask)); // we shouldn't return bit patterns from outside the limits of the bitset.
+    }
 }
 
 int main()
diff --git a/test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp b/test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp
index 24847dd70f86..2f8a707bfa2f 100644
--- a/test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.hires/consistency.pass.cpp
@@ -24,8 +24,8 @@
 
 #include <chrono>
 
-template <class _Tp>
-void test(const _Tp &) {}
+template <class T>
+void test(const T &) {}
 
 int main()
 {
diff --git a/test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp b/test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp
index cdb38dfce3f5..4458d6f213fa 100644
--- a/test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.steady/consistency.pass.cpp
@@ -26,8 +26,8 @@
 
 #include <chrono>
 
-template <class _Tp>
-void test(const _Tp &) {}
+template <class T>
+void test(const T &) {}
 
 int main()
 {
diff --git a/test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp b/test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp
index dfc08a3bca69..deb4615fa5a1 100644
--- a/test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp
+++ b/test/std/utilities/time/time.clock/time.clock.system/consistency.pass.cpp
@@ -24,8 +24,8 @@
 
 #include <chrono>
 
-template <class _Tp>
-void test(const _Tp &) {}
+template <class T>
+void test(const T &) {}
 
 int main()
 {
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp
index 702c38d2d4a9..416a8db8ae5b 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp
@@ -11,7 +11,7 @@
 
 // duration
 
-// constexpr duration& operator++();  // constexpr in c++17
+// constexpr duration& operator++();  // constexpr in C++17
 
 #include <chrono>
 #include <cassert>
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp
index 49b8c76ee8ee..deb4daa8d86b 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp
@@ -11,7 +11,7 @@
 
 // duration
 
-// constexpr duration operator++(int);  // constexpr in c++17
+// constexpr duration operator++(int);  // constexpr in C++17
 
 #include <chrono>
 #include <cassert>
diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp
index bec8effbe220..b74011a3b27b 100644
--- a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp
+++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp
@@ -11,7 +11,7 @@
 
 // duration
 
-// constexpr duration& operator+=(const duration& d); // constexpr in c++17
+// constexpr duration& operator+=(const duration& d); // constexpr in C++17
 
 #include <chrono>
 #include <cassert>
diff --git a/test/std/utilities/tuple/tuple.general/ignore.pass.cpp b/test/std/utilities/tuple/tuple.general/ignore.pass.cpp
index 8dae3a5dcb0e..a7a0904cf492 100644
--- a/test/std/utilities/tuple/tuple.general/ignore.pass.cpp
+++ b/test/std/utilities/tuple/tuple.general/ignore.pass.cpp
@@ -48,9 +48,7 @@ int main() {
     {
         static_assert(test_ignore_constexpr(), "");
     }
-#if defined(_LIBCPP_VERSION)
     {
-        static_assert(std::is_trivial<decltype(std::ignore)>::value, "");
+        LIBCPP_STATIC_ASSERT(std::is_trivial<decltype(std::ignore)>::value, "");
     }
-#endif
 }
diff --git a/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp b/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
index d1b974c50753..811dfc03ba11 100644
--- a/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
+++ b/test/std/utilities/tuple/tuple.general/tuple.smartptr.pass.cpp
@@ -29,5 +29,5 @@ int main () {
     }
     // Smart pointers of type 'T[N]' are not tested here since they are not
     // supported by the standard nor by libc++'s implementation.
-    // See http://reviews.llvm.org/D21320 for more information.
+    // See https://reviews.llvm.org/D21320 for more information.
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp
index 06284df56642..fed27aa84ff6 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.pass.cpp
@@ -147,6 +147,7 @@ int main()
 #if TEST_STD_VER > 11
     {
         constexpr std::tuple<Empty> t0{Empty()};
+        (void)t0;
     }
     {
         constexpr std::tuple<A, A> t(3, 2);
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp
index b262f3cacecf..bf66da1626a0 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.pass.cpp
@@ -102,6 +102,8 @@ int main()
         using T = NonDefaultConstructible<>;
         T v(42);
         std::tuple<T, T> t(v, v);
+        (void)t;
         std::tuple<T, T> t2(42, 42);
+        (void)t2;
     }
 }
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp
index fa2f116f7718..731946608bab 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.pass.cpp
@@ -49,6 +49,7 @@ int main()
 {
     {
         std::tuple<> t;
+        (void)t;
     }
     {
         std::tuple<int> t;
@@ -88,6 +89,7 @@ int main()
     }
     {
         constexpr std::tuple<> t;
+        (void)t;
     }
     {
         constexpr std::tuple<int> t;
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
index 7b9c061b3ae8..85036b59186d 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
@@ -15,10 +15,11 @@
 // against libstdc++.
 // XFAIL: gcc
 
-// <string>
+// <tuple>
 
-// Test that the constructors offered by std::basic_string are formulated
-// so they're compatible with implicit deduction guides.
+// Test that the constructors offered by std::tuple are formulated
+// so they're compatible with implicit deduction guides, or if that's not
+// possible that they provide explicit guides to make it work.
 
 #include <tuple>
 #include <memory>
diff --git a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp b/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp
index 74e6efd983bd..af9424806752 100644
--- a/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp
+++ b/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.fail.cpp
@@ -11,17 +11,18 @@
 
 #include <tuple>
 #include <string>
+#include "test_macros.h"
 
 struct UserType {};
 
 void test_bad_index() {
     std::tuple<long, long, char, std::string, char, UserType, char> t1;
-    (void)std::get<int>(t1); // expected-error@tuple:* {{type not found}}
-    (void)std::get<long>(t1); // expected-note {{requested here}}
-    (void)std::get<char>(t1); // expected-note {{requested here}}
+    TEST_IGNORE_NODISCARD std::get<int>(t1); // expected-error@tuple:* {{type not found}}
+    TEST_IGNORE_NODISCARD std::get<long>(t1); // expected-note {{requested here}}
+    TEST_IGNORE_NODISCARD std::get<char>(t1); // expected-note {{requested here}}
         // expected-error@tuple:* 2 {{type occurs more than once}}
     std::tuple<> t0;
-    (void)std::get<char*>(t0); // expected-node {{requested here}}
+    TEST_IGNORE_NODISCARD std::get<char*>(t0); // expected-node {{requested here}}
         // expected-error@tuple:* 1 {{type not in empty type list}}
 }
 
diff --git a/test/std/utilities/utility/as_const/as_const.fail.cpp b/test/std/utilities/utility/as_const/as_const.fail.cpp
index 6334e1460259..c28957cfc505 100644
--- a/test/std/utilities/utility/as_const/as_const.fail.cpp
+++ b/test/std/utilities/utility/as_const/as_const.fail.cpp
@@ -18,5 +18,5 @@ struct S {int i;};
 
 int main()
 {
-	std::as_const(S{});
+    std::as_const(S{});
 }
diff --git a/test/std/utilities/utility/as_const/as_const.pass.cpp b/test/std/utilities/utility/as_const/as_const.pass.cpp
index 7bb5849d0bd0..268f2d1b04ee 100644
--- a/test/std/utilities/utility/as_const/as_const.pass.cpp
+++ b/test/std/utilities/utility/as_const/as_const.pass.cpp
@@ -37,10 +37,10 @@ void test(T& t)
 
 int main()
 {
-	int i = 3;
-	double d = 4.0;
-	S s{2};
-	test(i);
-	test(d);
-	test(s);
+    int i = 3;
+    double d = 4.0;
+    S s{2};
+    test(i);
+    test(d);
+    test(s);
 }
diff --git a/test/std/utilities/utility/forward/forward.fail.cpp b/test/std/utilities/utility/forward/forward.fail.cpp
index a3bb890482ef..c845216d86dc 100644
--- a/test/std/utilities/utility/forward/forward.fail.cpp
+++ b/test/std/utilities/utility/forward/forward.fail.cpp
@@ -25,7 +25,7 @@ int main()
 #if TEST_STD_VER >= 11
     {
         std::forward<A&>(source());  // expected-note {{requested here}}
-        // expected-error@type_traits:* 1 {{static_assert failed "can not forward an rvalue as an lvalue"}}
+        // expected-error-re@type_traits:* 1 {{static_assert failed{{.*}} "can not forward an rvalue as an lvalue"}}
     }
 #else
     {
diff --git a/test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp b/test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp
index 8e994126cc0d..4ca31f7debe8 100644
--- a/test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp
+++ b/test/std/utilities/utility/pairs/pair.astuple/tuple_element.fail.cpp
@@ -18,5 +18,5 @@
 int main()
 {
     typedef std::pair<int, short> T;
-    typename std::tuple_element<2, T>::type foo; // expected-error@utility:* {{Index out of bounds in std::tuple_element<std::pair<T1, T2>>}}
+    std::tuple_element<2, T>::type foo; // expected-error@utility:* {{Index out of bounds in std::tuple_element<std::pair<T1, T2>>}}
 }
diff --git a/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
index ade8130d7822..715b65537761 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/const_pair_U_V.pass.cpp
@@ -71,7 +71,7 @@ int main()
         P1 p1(42, 101);
         P2 p2(p1);
         assert(p2.first == 42);
-        assert(p2.second = 101);
+        assert(p2.second == 101);
     }
     {
         test_pair_const<AllCtors, AllCtors>(); // copy construction
diff --git a/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp
new file mode 100644
index 000000000000..7933dd99c1f4
--- /dev/null
+++ b/test/std/utilities/utility/pairs/pairs.pair/implicit_deduction_guides.pass.cpp
@@ -0,0 +1,80 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// UNSUPPORTED: libcpp-no-deduction-guides
+
+// GCC's implementation of class template deduction is still immature and runs
+// into issues with libc++. However GCC accepts this code when compiling
+// against libstdc++.
+// XFAIL: gcc
+
+// <utility>
+
+// Test that the constructors offered by std::pair are formulated
+// so they're compatible with implicit deduction guides, or if that's not
+// possible that they provide explicit guides to make it work.
+
+#include <utility>
+#include <memory>
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+#include "archetypes.hpp"
+
+
+// Overloads
+// ---------------
+// (1)  pair(const T1&, const T2&) -> pair<T1, T2>
+// (2)  explicit pair(const T1&, const T2&) -> pair<T1, T2>
+// (3)  pair(pair const& t) -> decltype(t)
+// (4)  pair(pair&& t) -> decltype(t)
+// (5)  pair(pair<U1, U2> const&) -> pair<U1, U2>
+// (6)  explicit pair(pair<U1, U2> const&) -> pair<U1, U2>
+// (7)  pair(pair<U1, U2> &&) -> pair<U1, U2>
+// (8)  explicit pair(pair<U1, U2> &&) -> pair<U1, U2>
+int main()
+{
+  using E = ExplicitTestTypes::TestType;
+  static_assert(!std::is_convertible<E const&, E>::value, "");
+  { // Testing (1)
+    int const x = 42;
+    std::pair t1("abc", x);
+    ASSERT_SAME_TYPE(decltype(t1), std::pair<const char*, int>);
+  }
+  { // Testing (2)
+    std::pair p1(E{}, 42);
+    ASSERT_SAME_TYPE(decltype(p1), std::pair<E, int>);
+
+    const E t{};
+    std::pair p2(t, E{});
+    ASSERT_SAME_TYPE(decltype(p2), std::pair<E, E>);
+  }
+  { // Testing (3, 5)
+    std::pair<double, decltype(nullptr)> const p(0.0, nullptr);
+    std::pair p1(p);
+    ASSERT_SAME_TYPE(decltype(p1), std::pair<double, decltype(nullptr)>);
+  }
+  { // Testing (3, 6)
+    std::pair<E, decltype(nullptr)> const p(E{}, nullptr);
+    std::pair p1(p);
+    ASSERT_SAME_TYPE(decltype(p1), std::pair<E, decltype(nullptr)>);
+  }
+  { // Testing (4, 7)
+    std::pair<std::string, void*> p("abc", nullptr);
+    std::pair p1(std::move(p));
+    ASSERT_SAME_TYPE(decltype(p1), std::pair<std::string, void*>);
+  }
+  { // Testing (4, 8)
+    std::pair<std::string, E> p("abc", E{});
+    std::pair p1(std::move(p));
+    ASSERT_SAME_TYPE(decltype(p1), std::pair<std::string, E>);
+  }
+}
diff --git a/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp b/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
index 2856190841c0..f5d3bb621deb 100644
--- a/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
+++ b/test/std/utilities/utility/pairs/pairs.pair/rv_pair_U_V.pass.cpp
@@ -81,7 +81,7 @@ int main()
         P1 p1(42, 101);
         P2 p2(std::move(p1));
         assert(p2.first == 42);
-        assert(p2.second = 101);
+        assert(p2.second == 101);
     }
     {
         test_pair_rv<AllCtors, AllCtors>();
diff --git a/test/std/utilities/utility/synopsis.pass.cpp b/test/std/utilities/utility/synopsis.pass.cpp
index 5f5b4eeaad52..009b65cbbe53 100644
--- a/test/std/utilities/utility/synopsis.pass.cpp
+++ b/test/std/utilities/utility/synopsis.pass.cpp
@@ -17,5 +17,6 @@
 int main()
 {
     std::initializer_list<int> x;
+    (void)x;
 }
 
diff --git a/test/std/utilities/variant/variant.get/get_index.pass.cpp b/test/std/utilities/variant/variant.get/get_index.pass.cpp
index 4f04f4a399d7..f52dc5556466 100644
--- a/test/std/utilities/variant/variant.get/get_index.pass.cpp
+++ b/test/std/utilities/variant/variant.get/get_index.pass.cpp
@@ -259,7 +259,7 @@ void test_throws_for_all_value_categories() {
   auto test = [](auto idx, auto &&v) {
     using Idx = decltype(idx);
     try {
-      std::get<Idx::value>(std::forward<decltype(v)>(v));
+      TEST_IGNORE_NODISCARD std::get<Idx::value>(std::forward<decltype(v)>(v));
     } catch (const std::bad_variant_access &) {
       return true;
     } catch (...) { /* ... */
diff --git a/test/std/utilities/variant/variant.get/get_type.pass.cpp b/test/std/utilities/variant/variant.get/get_type.pass.cpp
index 63221f69c8f8..0a2222cbf277 100644
--- a/test/std/utilities/variant/variant.get/get_type.pass.cpp
+++ b/test/std/utilities/variant/variant.get/get_type.pass.cpp
@@ -259,7 +259,7 @@ void test_throws_for_all_value_categories() {
   auto test = [](auto idx, auto &&v) {
     using Idx = decltype(idx);
     try {
-      std::get<typename Idx::type>(std::forward<decltype(v)>(v));
+      TEST_IGNORE_NODISCARD std::get<typename Idx::type>(std::forward<decltype(v)>(v));
     } catch (const std::bad_variant_access &) {
       return true;
     } catch (...) { /* ... */
diff --git a/test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp b/test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp
index cbaa2a568d5b..31521dae223c 100644
--- a/test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp
+++ b/test/std/utilities/variant/variant.helpers/variant_alternative.fail.cpp
@@ -28,5 +28,5 @@
 
 int main() {
     using V = std::variant<int, void *, const void *, long double>;
-    typename std::variant_alternative<4, V>::type foo;  // expected-error@variant:* {{Index out of bounds in std::variant_alternative<>}}
+    std::variant_alternative<4, V>::type foo;  // expected-error@variant:* {{Index out of bounds in std::variant_alternative<>}}
 }
diff --git a/test/std/utilities/variant/variant.visit/visit.pass.cpp b/test/std/utilities/variant/variant.visit/visit.pass.cpp
index 316f2d22b01d..c0db967933b0 100644
--- a/test/std/utilities/variant/variant.visit/visit.pass.cpp
+++ b/test/std/utilities/variant/variant.visit/visit.pass.cpp
@@ -300,7 +300,7 @@ void test_exceptions() {
 #endif
 }
 
-// See http://llvm.org/PR31916
+// See https://bugs.llvm.org/show_bug.cgi?id=31916
 void test_caller_accepts_nonconst() {
   struct A {};
   struct Visitor {
diff --git a/test/support/any_helpers.h b/test/support/any_helpers.h
index a720ecd7c82f..afc85c97ff46 100644
--- a/test/support/any_helpers.h
+++ b/test/support/any_helpers.h
@@ -24,13 +24,13 @@ namespace std { namespace experimental {} }
 #define RTTI_ASSERT(X)
 #endif
 
-template <class _Tp>
+template <class T>
   struct IsSmallObject
     : public std::integral_constant<bool
-        , sizeof(_Tp) <= (sizeof(void*)*3)
+        , sizeof(T) <= (sizeof(void*)*3)
           && std::alignment_of<void*>::value
-             % std::alignment_of<_Tp>::value == 0
-          && std::is_nothrow_move_constructible<_Tp>::value
+             % std::alignment_of<T>::value == 0
+          && std::is_nothrow_move_constructible<T>::value
         >
   {};
 
diff --git a/test/support/container_test_types.h b/test/support/container_test_types.h
index b8422ec4602d..1c4625b9f771 100644
--- a/test/support/container_test_types.h
+++ b/test/support/container_test_types.h
@@ -167,8 +167,10 @@ struct AllocatorConstructController {
   // Return true if the construction was expected and false otherwise.
   // This should only be called by 'Allocator.construct'.
   bool check(detail::TypeID const& tid) {
-    if (!m_expected_args)
+    if (!m_expected_args) {
       assert(m_allow_unchecked);
+      return m_allow_unchecked;
+    }
     bool res = *m_expected_args == tid;
     if (m_expected_count == -1 || --m_expected_count == -1)
       m_expected_args = nullptr;
diff --git a/test/support/counting_predicates.hpp b/test/support/counting_predicates.hpp
index 2bd1426934e5..050b51b75bb1 100644
--- a/test/support/counting_predicates.hpp
+++ b/test/support/counting_predicates.hpp
@@ -12,8 +12,11 @@
 
 
 template <typename Predicate, typename Arg>
-struct unary_counting_predicate : public std::unary_function<Arg, bool>  {
+struct unary_counting_predicate {
 public:
+    typedef Arg argument_type;
+    typedef bool result_type;
+
     unary_counting_predicate(Predicate p) : p_(p), count_(0) {}
     ~unary_counting_predicate() {}
 
@@ -28,8 +31,11 @@ private:
 
 
 template <typename Predicate, typename Arg1, typename Arg2=Arg1>
-struct binary_counting_predicate : public std::binary_function<Arg1, Arg2, bool> {
+struct binary_counting_predicate {
 public:
+    typedef Arg1 first_argument_type;
+    typedef Arg2 second_argument_type;
+    typedef bool result_type;
 
     binary_counting_predicate ( Predicate p ) : p_(p), count_(0) {}
     ~binary_counting_predicate() {}
diff --git a/test/support/emplace_constructible.h b/test/support/emplace_constructible.h
index f2bc0ec6a367..f0d11ba76c87 100644
--- a/test/support/emplace_constructible.h
+++ b/test/support/emplace_constructible.h
@@ -7,7 +7,7 @@
 template <class T>
 struct EmplaceConstructible {
   T value;
-  explicit EmplaceConstructible(T value) : value(value) {}
+  explicit EmplaceConstructible(T xvalue) : value(xvalue) {}
   EmplaceConstructible(EmplaceConstructible const&) = delete;
 };
 
@@ -15,7 +15,7 @@ template <class T>
 struct EmplaceConstructibleAndMoveInsertable {
   int copied = 0;
   T value;
-  explicit EmplaceConstructibleAndMoveInsertable(T value) : value(value) {}
+  explicit EmplaceConstructibleAndMoveInsertable(T xvalue) : value(xvalue) {}
 
   EmplaceConstructibleAndMoveInsertable(
       EmplaceConstructibleAndMoveInsertable&& Other)
@@ -27,7 +27,7 @@ struct EmplaceConstructibleAndMoveable {
   int copied = 0;
   int assigned = 0;
   T value;
-  explicit EmplaceConstructibleAndMoveable(T value) noexcept : value(value) {}
+  explicit EmplaceConstructibleAndMoveable(T xvalue) noexcept : value(xvalue) {}
 
   EmplaceConstructibleAndMoveable(EmplaceConstructibleAndMoveable&& Other)
       noexcept : copied(Other.copied + 1),
@@ -47,8 +47,8 @@ struct EmplaceConstructibleMoveableAndAssignable {
   int copied = 0;
   int assigned = 0;
   T value;
-  explicit EmplaceConstructibleMoveableAndAssignable(T value) noexcept
-      : value(value) {}
+  explicit EmplaceConstructibleMoveableAndAssignable(T xvalue) noexcept
+      : value(xvalue) {}
 
   EmplaceConstructibleMoveableAndAssignable(
       EmplaceConstructibleMoveableAndAssignable&& Other) noexcept
diff --git a/test/support/experimental_any_helpers.h b/test/support/experimental_any_helpers.h
index 9c906e6bf76a..f7bc0e33e168 100644
--- a/test/support/experimental_any_helpers.h
+++ b/test/support/experimental_any_helpers.h
@@ -22,13 +22,13 @@
 #define RTTI_ASSERT(X)
 #endif
 
-template <class _Tp>
+template <class T>
   struct IsSmallObject
     : public std::integral_constant<bool
-        , sizeof(_Tp) <= (sizeof(void*)*3)
+        , sizeof(T) <= (sizeof(void*)*3)
           && std::alignment_of<void*>::value
-             % std::alignment_of<_Tp>::value == 0
-          && std::is_nothrow_move_constructible<_Tp>::value
+             % std::alignment_of<T>::value == 0
+          && std::is_nothrow_move_constructible<T>::value
         >
   {};
 
diff --git a/test/support/msvc_stdlib_force_include.hpp b/test/support/msvc_stdlib_force_include.hpp
index 954cf513ef2d..83120c7eb52b 100644
--- a/test/support/msvc_stdlib_force_include.hpp
+++ b/test/support/msvc_stdlib_force_include.hpp
@@ -54,6 +54,7 @@ const AssertionDialogAvoider assertion_dialog_avoider{};
 
     // Silence compiler warnings.
     #pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored
+    #pragma warning(disable: 4324) // structure was padded due to alignment specifier
     #pragma warning(disable: 4521) // multiple copy constructors specified
     #pragma warning(disable: 4702) // unreachable code
     #pragma warning(disable: 28251) // Inconsistent annotation for 'new': this instance has no annotations.
@@ -69,11 +70,6 @@ const AssertionDialogAvoider assertion_dialog_avoider{};
     // atomic_is_lock_free.pass.cpp needs this VS 2015 Update 2 fix.
     #define _ENABLE_ATOMIC_ALIGNMENT_FIX
 
-    // Enable features that /std:c++latest removes by default.
-    #define _HAS_AUTO_PTR_ETC          1
-    #define _HAS_FUNCTION_ASSIGN       1
-    #define _HAS_OLD_IOSTREAMS_MEMBERS 1
-
     // Silence warnings about raw pointers and other unchecked iterators.
     #define _SCL_SECURE_NO_WARNINGS
 
diff --git a/test/support/nasty_containers.hpp b/test/support/nasty_containers.hpp
index 99e91d617f6d..b52263a97b4e 100644
--- a/test/support/nasty_containers.hpp
+++ b/test/support/nasty_containers.hpp
@@ -291,9 +291,9 @@ public:
      nasty_mutex() TEST_NOEXCEPT {}
      ~nasty_mutex() {}
 
-	nasty_mutex *operator& ()   { assert(false); return nullptr; }
-	template <typename T>
-	void operator, (const T &) { assert(false); }
+    nasty_mutex *operator& ()   { assert(false); return nullptr; }
+    template <typename T>
+    void operator, (const T &) { assert(false); }
 
 private:
     nasty_mutex(const nasty_mutex&)            { assert(false); }
diff --git a/test/support/nasty_macros.hpp b/test/support/nasty_macros.hpp
index ff141f7954c8..76d8ab0e720f 100644
--- a/test/support/nasty_macros.hpp
+++ b/test/support/nasty_macros.hpp
@@ -52,4 +52,7 @@
 #define __out NASTY_MACRO
 #endif
 
+#define __output NASTY_MACRO
+#define __input NASTY_MACRO
+
 #endif // SUPPORT_NASTY_MACROS_HPP
diff --git a/test/support/platform_support.h b/test/support/platform_support.h
index a9b5b98a3668..020cdbf98e20 100644
--- a/test/support/platform_support.h
+++ b/test/support/platform_support.h
@@ -18,7 +18,7 @@
 // locale names
 #ifdef _WIN32
 // WARNING: Windows does not support UTF-8 codepages.
-// Locales are "converted" using http://docs.moodle.org/dev/Table_of_locales
+// Locales are "converted" using https://docs.moodle.org/dev/Table_of_locales
 #define LOCALE_en_US           "en-US"
 #define LOCALE_en_US_UTF_8     "en-US"
 #define LOCALE_cs_CZ_ISO8859_2 "cs-CZ"
diff --git a/test/support/test_convertible.hpp b/test/support/test_convertible.hpp
index 787cef6568f2..e0d42f74ab84 100644
--- a/test/support/test_convertible.hpp
+++ b/test/support/test_convertible.hpp
@@ -39,4 +39,4 @@ template <class Tp, class ...Args>
 constexpr bool test_convertible()
 { return detail::test_convertible_imp<Tp, Args...>(0); }
 
-#endif // SUPPORT_TEST_CONVERTIBLE_HPP
\ No newline at end of file
+#endif // SUPPORT_TEST_CONVERTIBLE_HPP
diff --git a/test/support/test_macros.h b/test/support/test_macros.h
index 95270e437905..257875a35ed2 100644
--- a/test/support/test_macros.h
+++ b/test/support/test_macros.h
@@ -189,6 +189,8 @@
 #define LIBCPP_ONLY(...) ((void)0)
 #endif
 
+#define TEST_IGNORE_NODISCARD (void)
+
 namespace test_macros_detail {
 template <class T, class U>
 struct is_same { enum { value = 0};} ;
diff --git a/utils/libcxx/compiler.py b/utils/libcxx/compiler.py
index e908e26089b0..70022d7a43a0 100644
--- a/utils/libcxx/compiler.py
+++ b/utils/libcxx/compiler.py
@@ -204,7 +204,7 @@ class CXXCompiler(object):
         flags = ['-dM'] + flags
         cmd, out, err, rc = self.preprocess(source_files, flags=flags, cwd=cwd)
         if rc != 0:
-            return None
+            return cmd, out, err, rc
         parsed_macros = {}
         lines = [l.strip() for l in out.split('\n') if l.strip()]
         for l in lines:
diff --git a/utils/libcxx/test/config.py b/utils/libcxx/test/config.py
index 2ee41924fe13..199ff3566d30 100644
--- a/utils/libcxx/test/config.py
+++ b/utils/libcxx/test/config.py
@@ -259,6 +259,16 @@ class Configuration(object):
                            compile_flags=compile_flags,
                            link_flags=link_flags)
 
+    def _dump_macros_verbose(self, *args, **kwargs):
+        macros_or_error = self.cxx.dumpMacros(*args, **kwargs)
+        if isinstance(macros_or_error, tuple):
+            cmd, out, err, rc = macros_or_error
+            report = libcxx.util.makeReport(cmd, out, err, rc)
+            report += "Compiler failed unexpectedly when dumping macros!"
+            self.lit_config.fatal(report)
+            return None
+        assert isinstance(macros_or_error, dict)
+        return macros_or_error
 
     def configure_src_root(self):
         self.libcxx_src_root = self.get_lit_conf(
@@ -446,7 +456,7 @@ class Configuration(object):
         if self.get_lit_bool('has_libatomic', False):
             self.config.available_features.add('libatomic')
 
-        macros = self.cxx.dumpMacros()
+        macros = self._dump_macros_verbose()
         if '__cpp_if_constexpr' not in macros:
             self.config.available_features.add('libcpp-no-if-constexpr')
 
@@ -469,7 +479,7 @@ class Configuration(object):
         # Attempt to detect the glibc version by querying for __GLIBC__
         # in 'features.h'.
         macros = self.cxx.dumpMacros(flags=['-include', 'features.h'])
-        if macros is not None and '__GLIBC__' in macros:
+        if isinstance(macros, dict) and '__GLIBC__' in macros:
             maj_v, min_v = (macros['__GLIBC__'], macros['__GLIBC_MINOR__'])
             self.config.available_features.add('glibc')
             self.config.available_features.add('glibc-%s' % maj_v)
@@ -507,7 +517,8 @@ class Configuration(object):
         std = self.get_lit_conf('std')
         if not std:
             # Choose the newest possible language dialect if none is given.
-            possible_stds = ['c++1z', 'c++14', 'c++11', 'c++03']
+            possible_stds = ['c++2a', 'c++17', 'c++1z', 'c++14', 'c++11',
+                             'c++03']
             if self.cxx.type == 'gcc':
                 maj_v, _, _ = self.cxx.version
                 maj_v = int(maj_v)
@@ -528,7 +539,9 @@ class Configuration(object):
                     'Failed to infer a supported language dialect from one of %r'
                     % possible_stds)
         self.cxx.compile_flags += ['-std={0}'.format(std)]
-        self.config.available_features.add(std.replace('gnu++', 'c++'))
+        std_feature = std.replace('gnu++', 'c++')
+        std_feature = std.replace('1z', '17')
+        self.config.available_features.add(std_feature)
         # Configure include paths
         self.configure_compile_flags_header_includes()
         self.target_info.add_cxx_compile_flags(self.cxx.compile_flags)
@@ -566,6 +579,9 @@ class Configuration(object):
         # Disable availability unless explicitely requested
         if not self.with_availability:
             self.cxx.flags += ['-D_LIBCPP_DISABLE_AVAILABILITY']
+        # FIXME(EricWF): variant_size.pass.cpp requires a slightly larger
+        # template depth with older Clang versions.
+        self.cxx.addFlagIfSupported('-ftemplate-depth=270')
 
     def configure_compile_flags_header_includes(self):
         support_path = os.path.join(self.libcxx_src_root, 'test', 'support')
@@ -627,8 +643,8 @@ class Configuration(object):
         """
         # Parse the macro contents of __config_site by dumping the macros
         # using 'c++ -dM -E' and filtering the predefines.
-        predefines = self.cxx.dumpMacros()
-        macros = self.cxx.dumpMacros(header)
+        predefines = self._dump_macros_verbose()
+        macros = self._dump_macros_verbose(header)
         feature_macros_keys = set(macros.keys()) - set(predefines.keys())
         feature_macros = {}
         for k in feature_macros_keys:
@@ -658,7 +674,10 @@ class Configuration(object):
                 self.config.available_features.add('libcpp-abi-version-v%s'
                     % feature_macros[m])
                 continue
-            assert m.startswith('_LIBCPP_HAS_') or m == '_LIBCPP_ABI_UNSTABLE'
+            if m == '_LIBCPP_NO_VCRUNTIME':
+                self.config.available_features.add('libcpp-no-vcruntime')
+                continue
+            assert m.startswith('_LIBCPP_HAS_') or m.startswith('_LIBCPP_ABI_')
             m = m.lower()[1:].replace('_', '-')
             self.config.available_features.add(m)
         return feature_macros
@@ -873,7 +892,7 @@ class Configuration(object):
         # Turn on warnings by default for Clang based compilers when C++ >= 11
         default_enable_warnings = self.cxx.type in ['clang', 'apple-clang'] \
             and len(self.config.available_features.intersection(
-                ['c++11', 'c++14', 'c++1z'])) != 0
+                ['c++11', 'c++14', 'c++17', 'c++2a'])) != 0
         enable_warnings = self.get_lit_bool('enable_warnings',
                                             default_enable_warnings)
         self.cxx.useWarnings(enable_warnings)
@@ -980,7 +999,7 @@ class Configuration(object):
 
     def configure_coroutines(self):
         if self.cxx.hasCompileFlag('-fcoroutines-ts'):
-            macros = self.cxx.dumpMacros(flags=['-fcoroutines-ts'])
+            macros = self._dump_macros_verbose(flags=['-fcoroutines-ts'])
             if '__cpp_coroutines' not in macros:
                 self.lit_config.warning('-fcoroutines-ts is supported but '
                     '__cpp_coroutines is not defined')
diff --git a/utils/libcxx/test/target_info.py b/utils/libcxx/test/target_info.py
index e6fde900cf70..670aea7ae630 100644
--- a/utils/libcxx/test/target_info.py
+++ b/utils/libcxx/test/target_info.py
@@ -190,12 +190,14 @@ class LinuxLocalTI(DefaultTargetInfo):
 
     def platform_name(self):
         name, _, _ = platform.linux_distribution()
-        name = name.lower().strip()
+        # Some distros have spaces, e.g. 'SUSE Linux Enterprise Server'
+        # lit features can't have spaces
+        name = name.lower().strip().replace(' ', '-')
         return name # Permitted to be None
 
     def platform_ver(self):
         _, ver, _ = platform.linux_distribution()
-        ver = ver.lower().strip()
+        ver = ver.lower().strip().replace(' ', '-')
         return ver # Permitted to be None.
 
     def add_locale_features(self, features):
diff --git a/utils/merge_archives.py b/utils/merge_archives.py
index 856dd3bfae90..58d92f0e21e1 100755
--- a/utils/merge_archives.py
+++ b/utils/merge_archives.py
@@ -94,12 +94,18 @@ def main():
         help='Paths to search for the libraries along', action='append',
         nargs=1)
     parser.add_argument(
+        '--ar', dest='ar_exe', required=False,
+        help='The ar executable to use, finds \'ar\' in the path if not given',
+        type=str, action='store')
+    parser.add_argument(
         'archives', metavar='archives',  nargs='+',
         help='The archives to merge')
 
     args = parser.parse_args()
 
-    ar_exe = distutils.spawn.find_executable('ar')
+    ar_exe = args.ar_exe
+    if not ar_exe:
+        ar_exe = distutils.spawn.find_executable('ar')
     if not ar_exe:
         print_and_exit("failed to find 'ar' executable")
 
@@ -115,13 +121,13 @@ def main():
     temp_directory_root = tempfile.mkdtemp('.libcxx.merge.archives')
 
     for arc in archives:
-        execute_command_verbose([ar_exe, '-x', arc], cwd=temp_directory_root,
+        execute_command_verbose([ar_exe, 'x', arc], cwd=temp_directory_root,
                                 verbose=args.verbose)
 
-    files = glob.glob(os.path.join(temp_directory_root, '*.o'))
+    files = glob.glob(os.path.join(temp_directory_root, '*.o*'))
     if not files:
-        print_and_exit('Failed to glob for %s' % glob_path)
-    cmd = [ar_exe, '-qc', args.output] + files
+        print_and_exit('Failed to glob for %s' % temp_directory_root)
+    cmd = [ar_exe, 'qcs', args.output] + files
     execute_command_verbose(cmd, cwd=temp_directory_root, verbose=args.verbose)
 
 
diff --git a/www/atomic_design.html b/www/atomic_design.html
index ab5ed6eb5f29..1c6627aadfb3 100644
--- a/www/atomic_design.html
+++ b/www/atomic_design.html
@@ -12,7 +12,7 @@
 <body>
 <div id="menu">
   <div>
-    <a href="http://llvm.org/">LLVM Home</a>
+    <a href="https://llvm.org/">LLVM Home</a>
   </div>
 
   <div class="submenu">
@@ -22,11 +22,11 @@
 
   <div class="submenu">
     <label>Quick Links</label>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="http://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
   </div>
 </div>
 
diff --git a/www/atomic_design_a.html b/www/atomic_design_a.html
index 8175469b3515..589ca83c15e5 100644
--- a/www/atomic_design_a.html
+++ b/www/atomic_design_a.html
@@ -12,7 +12,7 @@
 <body>
 <div id="menu">
   <div>
-    <a href="http://llvm.org/">LLVM Home</a>
+    <a href="https://llvm.org/">LLVM Home</a>
   </div>
 
   <div class="submenu">
@@ -22,11 +22,11 @@
 
   <div class="submenu">
     <label>Quick Links</label>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="http://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
   </div>
 </div>
 
diff --git a/www/atomic_design_b.html b/www/atomic_design_b.html
index 78c7abd5127a..7f81f8b7ccf8 100644
--- a/www/atomic_design_b.html
+++ b/www/atomic_design_b.html
@@ -12,7 +12,7 @@
 <body>
 <div id="menu">
   <div>
-    <a href="http://llvm.org/">LLVM Home</a>
+    <a href="https://llvm.org/">LLVM Home</a>
   </div>
 
   <div class="submenu">
@@ -22,11 +22,11 @@
 
   <div class="submenu">
     <label>Quick Links</label>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="http://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
   </div>
 </div>
 
diff --git a/www/atomic_design_c.html b/www/atomic_design_c.html
index b4319174aba8..82cc80f7f75d 100644
--- a/www/atomic_design_c.html
+++ b/www/atomic_design_c.html
@@ -12,7 +12,7 @@
 <body>
 <div id="menu">
   <div>
-    <a href="http://llvm.org/">LLVM Home</a>
+    <a href="https://llvm.org/">LLVM Home</a>
   </div>
 
   <div class="submenu">
@@ -22,11 +22,11 @@
 
   <div class="submenu">
     <label>Quick Links</label>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="http://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
   </div>
 </div>
 
@@ -115,7 +115,7 @@ __has_feature(__atomic_flag) == 1
 __has_feature(__atomic_exchange_seq_cst_j) == 1
 __has_feature(__atomic_store_seq_cst_j) == 1
 
-typedef unsigned int __atomic_flag__; 
+typedef unsigned int __atomic_flag__;
 
 unsigned int __atomic_exchange_seq_cst(unsigned int volatile*, unsigned int)
 {
@@ -328,7 +328,7 @@ void __atomic_signal_fence_seq_cst()
 
 <p>
 One should consult the (currently draft)
-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3126.pdf">C++ standard</a>
+<a href="https://wg21.link/n3126">C++ standard</a>
 for the details of the definitions for these operations.  For example
 <tt>__atomic_compare_exchange_weak_seq_cst_seq_cst</tt> is allowed to fail
 spuriously while <tt>__atomic_compare_exchange_strong_seq_cst_seq_cst</tt> is
@@ -370,7 +370,7 @@ memory_order_relaxed
 
 <p>
 (See the
-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3126.pdf">C++ standard</a>
+<a href="https://wg21.link/n3126">C++ standard</a>
 for the detailed definitions of each of these orderings).
 </p>
 
diff --git a/www/cxx1y_status.html b/www/cxx1y_status.html
index 28fd23973896..0bcd179de4c0 100644
--- a/www/cxx1y_status.html
+++ b/www/cxx1y_status.html
@@ -12,7 +12,7 @@
 <body>
 <div id="menu">
   <div>
-    <a href="http://llvm.org/">LLVM Home</a>
+    <a href="https://llvm.org/">LLVM Home</a>
   </div>
 
   <div class="submenu">
@@ -22,11 +22,11 @@
 
   <div class="submenu">
     <label>Quick Links</label>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="http://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
   </div>
 </div>
 
@@ -37,7 +37,7 @@
 
   <p>In April 2013, the C++ standard committee approved the draft for the next version of the C++ standard, known as "C++1Y" (probably to be C++14)</p>
   <p>The draft standard includes papers and issues that were voted on at the previous three meetings (Kona, Portland, and Bristol)</p>
-  <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="http://clang.llvm.org/cxx_status.html">here</a>.</p>
+  <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="https://clang.llvm.org/cxx_status.html">here</a>.</p>
 
   <p>The groups that have contributed papers:
   <ul>
@@ -46,22 +46,22 @@
     <li>SG1 - Study group #1 (Concurrency working group)</li>
   </ul>
   </p>
-  
+
   <h3>Paper Status</h3>
   <table id="papers" border="1">
 	<tr><th>Paper #</th><th>Group</th><th>Paper Name</th><th>Meeting</th><th>Status</th><th>First released version</th></tr>
 
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3346.pdf">3346</a></td><td>LWG</td><td>Terminology for Container Element Requirements - Rev 1</td><td>Kona</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3346">3346</a></td><td>LWG</td><td>Terminology for Container Element Requirements - Rev 1</td><td>Kona</td><td>Complete</td><td>3.4</td></tr>
 	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
 
 <!-- 	<tr><td>3323</td><td>CWG</td><td>A Proposal to Tweak Certain C++ Contextual Conversions, v3</td><td>Portland</td><td></td><td></td></tr> -->
-	
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3421.htm">3421</a></td><td>LWG</td><td>Making Operator Functors greater&lt;&gt;</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3462.html">3462</a></td><td>LWG</td><td>std::result_of and SFINAE</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3469.html">3469</a></td><td>LWG</td><td>Constexpr Library Additions: chrono, v3</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3470.html">3470</a></td><td>LWG</td><td>Constexpr Library Additions: containers, v2</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3471.html">3471</a></td><td>LWG</td><td>Constexpr Library Additions: utilities, v3</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3302.html">3302</a></td><td>LWG</td><td>Constexpr Library Additions: complex, v2</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
+
+	<tr><td><a href="https://wg21.link/n3421">3421</a></td><td>LWG</td><td>Making Operator Functors greater&lt;&gt;</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3462">3462</a></td><td>LWG</td><td>std::result_of and SFINAE</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3469">3469</a></td><td>LWG</td><td>Constexpr Library Additions: chrono, v3</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3470">3470</a></td><td>LWG</td><td>Constexpr Library Additions: containers, v2</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3471">3471</a></td><td>LWG</td><td>Constexpr Library Additions: utilities, v3</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3302">3302</a></td><td>LWG</td><td>Constexpr Library Additions: complex, v2</td><td>Portland</td><td>Complete</td><td>3.4</td></tr>
 	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
 
 <!-- 	<tr><td>3472</td><td>CWG</td><td>Binary Literals in the C++ Core Language</td><td>Bristol</td><td></td><td></td></tr> -->
@@ -75,32 +75,32 @@
 <!-- 	<tr><td>3664</td><td>CWG</td><td>Clarifying Memory Allocation</td><td>Bristol</td><td></td><td></td></tr> -->
 <!-- 	<tr><td>3651</td><td>CWG</td><td>Variable Templates (Revision 1)</td><td>Bristol</td><td></td><td></td></tr> -->
 <!-- 	<tr><td>3649</td><td>CWG</td><td>Generic (Polymorphic) Lambda Expressions (Revision 3)</td><td>Bristol</td><td></td><td></td></tr> -->
-	
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3545.pdf">3545</a></td><td>LWG</td><td>An Incremental Improvement to integral_constant</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3644.pdf">3644</a></td><td>LWG</td><td>Null Forward Iterators</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3668.html">3668</a></td><td>LWG</td><td>std::exchange()</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3658.html">3658</a></td><td>LWG</td><td>Compile-time integer sequences</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3670.html">3670</a></td><td>LWG</td><td>Addressing Tuples by Type</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3671.html">3671</a></td><td>LWG</td><td>Making non-modifying sequence operations more robust</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3656.htm">3656</a></td><td>LWG</td><td>make_unique</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3654.html">3654</a></td><td>LWG</td><td>Quoted Strings</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3642.pdf">3642</a></td><td>LWG</td><td>User-defined Literals</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3655.pdf">3655</a></td><td>LWG</td><td>TransformationTraits Redux (excluding part 4)</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3657.htm">3657</a></td><td>LWG</td><td>Adding heterogeneous comparison lookup to associative containers</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3672.html">3672</a></td><td>LWG</td><td>A proposal to add a utility class to represent optional objects</td><td>Bristol</td><td><I>Removed from Draft Standard</I></td><td>n/a</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3669.pdf">3669</a></td><td>LWG</td><td>Fixing constexpr member functions without const</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3662.html">3662</a></td><td>LWG</td><td>C++ Dynamic Arrays (dynarray)</td><td>Bristol</td><td><I>Removed from Draft Standard</I></td><td>n/a</td></tr>
-	
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3659.html">3659</a></td><td>SG1</td><td>Shared Locking in C++</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+
+	<tr><td><a href="https://wg21.link/n3545">3545</a></td><td>LWG</td><td>An Incremental Improvement to integral_constant</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3644">3644</a></td><td>LWG</td><td>Null Forward Iterators</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3668">3668</a></td><td>LWG</td><td>std::exchange()</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3658">3658</a></td><td>LWG</td><td>Compile-time integer sequences</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3670">3670</a></td><td>LWG</td><td>Addressing Tuples by Type</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3671">3671</a></td><td>LWG</td><td>Making non-modifying sequence operations more robust</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3656">3656</a></td><td>LWG</td><td>make_unique</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3654">3654</a></td><td>LWG</td><td>Quoted Strings</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3642">3642</a></td><td>LWG</td><td>User-defined Literals</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3655">3655</a></td><td>LWG</td><td>TransformationTraits Redux (excluding part 4)</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3657">3657</a></td><td>LWG</td><td>Adding heterogeneous comparison lookup to associative containers</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3672">3672</a></td><td>LWG</td><td>A proposal to add a utility class to represent optional objects</td><td>Bristol</td><td><I>Removed from Draft Standard</I></td><td>n/a</td></tr>
+	<tr><td><a href="https://wg21.link/n3669">3669</a></td><td>LWG</td><td>Fixing constexpr member functions without const</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3662">3662</a></td><td>LWG</td><td>C++ Dynamic Arrays (dynarray)</td><td>Bristol</td><td><I>Removed from Draft Standard</I></td><td>n/a</td></tr>
+
+	<tr><td><a href="https://wg21.link/n3659">3659</a></td><td>SG1</td><td>Shared Locking in C++</td><td>Bristol</td><td>Complete</td><td>3.4</td></tr>
 
  	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3779.pdf">3779</a></td><td>LWG</td><td>User-defined Literals for std::complex</td><td>Chicago</td><td>Complete</td><td>3.4</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3789.htm">3789</a></td><td>LWG</td><td>Constexpr Library Additions: functional</td><td>Chicago</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3779">3779</a></td><td>LWG</td><td>User-defined Literals for std::complex</td><td>Chicago</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3789">3789</a></td><td>LWG</td><td>Constexpr Library Additions: functional</td><td>Chicago</td><td>Complete</td><td>3.4</td></tr>
  	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
 
-	<tr><td><a href="http://isocpp.org/files/papers/N3924.pdf">3924</a></td><td>LWG</td><td>Discouraging rand() in C++14</td><td>Issaquah</td><td>Complete</td><td>3.5</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3887">3887</a></td><td>LWG</td><td>Consistent Metafunction Aliases</td><td>Issaquah</td><td>Complete</td><td>3.5</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3891">3891</a></td><td>SG1</td><td>A proposal to rename shared_mutex to shared_timed_mutex</td><td>Issaquah</td><td>Complete</td><td>3.5</td></tr>
+	<tr><td><a href="https://wg21.link/n3924">3924</a></td><td>LWG</td><td>Discouraging rand() in C++14</td><td>Issaquah</td><td>Complete</td><td>3.5</td></tr>
+	<tr><td><a href="https://wg21.link/n3887">3887</a></td><td>LWG</td><td>Consistent Metafunction Aliases</td><td>Issaquah</td><td>Complete</td><td>3.5</td></tr>
+	<tr><td><a href="https://wg21.link/n3891">3891</a></td><td>SG1</td><td>A proposal to rename shared_mutex to shared_timed_mutex</td><td>Issaquah</td><td>Complete</td><td>3.5</td></tr>
 
 <!--  	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr> -->
   </table>
@@ -109,165 +109,165 @@
 <!--   <I>Note: "NAD" means that the issue was deemed "Not a defect"</I> -->
   <table id="issues" border="1">
 	<tr><th>Issue #</th><th>Issue Name</th><th>Meeting</th><th>Status</th></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2009">2009</a></td><td>Reporting out-of-bound values on numeric string conversions</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2010">2010</a></td><td>is_* traits for binding operations can't be meaningfully specialized</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2015">2015</a></td><td>Incorrect pre-conditions for some type traits</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2021">2021</a></td><td>Further incorrect usages of result_of</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2028">2028</a></td><td>messages_base::catalog overspecified</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2033">2033</a></td><td>Preconditions of reserve, shrink_to_fit, and resize functions</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2039">2039</a></td><td>Issues with std::reverse and std::copy_if</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2044">2044</a></td><td>No definition of "Stable" for copy algorithms</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2045">2045</a></td><td>forward_list::merge and forward_list::splice_after with unequal allocators</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2047">2047</a></td><td>Incorrect "mixed" move-assignment semantics of unique_ptr</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2050">2050</a></td><td>Unordered associative containers do not use allocator_traits to define member types</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2053">2053</a></td><td>Errors in regex bitmask types</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2061">2061</a></td><td>make_move_iterator and arrays</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2064">2064</a></td><td>More noexcept issues in basic_string</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2065">2065</a></td><td>Minimal allocator interface</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2067">2067</a></td><td>packaged_task should have deleted copy c'tor with const parameter</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2069">2069</a></td><td>Inconsistent exception spec for basic_string move constructor</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2096">2096</a></td><td>Incorrect constraints of future::get in regard to MoveAssignable</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2102">2102</a></td><td>Why is std::launch an implementation-defined type?</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2009">2009</a></td><td>Reporting out-of-bound values on numeric string conversions</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2010">2010</a></td><td>is_* traits for binding operations can't be meaningfully specialized</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2015">2015</a></td><td>Incorrect pre-conditions for some type traits</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2021">2021</a></td><td>Further incorrect usages of result_of</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2028">2028</a></td><td>messages_base::catalog overspecified</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2033">2033</a></td><td>Preconditions of reserve, shrink_to_fit, and resize functions</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2039">2039</a></td><td>Issues with std::reverse and std::copy_if</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2044">2044</a></td><td>No definition of "Stable" for copy algorithms</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2045">2045</a></td><td>forward_list::merge and forward_list::splice_after with unequal allocators</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2047">2047</a></td><td>Incorrect "mixed" move-assignment semantics of unique_ptr</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2050">2050</a></td><td>Unordered associative containers do not use allocator_traits to define member types</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2053">2053</a></td><td>Errors in regex bitmask types</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2061">2061</a></td><td>make_move_iterator and arrays</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2064">2064</a></td><td>More noexcept issues in basic_string</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2065">2065</a></td><td>Minimal allocator interface</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2067">2067</a></td><td>packaged_task should have deleted copy c'tor with const parameter</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2069">2069</a></td><td>Inconsistent exception spec for basic_string move constructor</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2096">2096</a></td><td>Incorrect constraints of future::get in regard to MoveAssignable</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2102">2102</a></td><td>Why is std::launch an implementation-defined type?</td><td>Kona</td><td>Complete</td></tr>
   <tr><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2071">2071</a></td><td>std::valarray move-assignment</td><td>Portland</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2074">2074</a></td><td>Off by one error in std::reverse_copy</td><td>Portland</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2081">2081</a></td><td>Allocator requirements should include CopyConstructible</td><td>Portland</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2083">2083</a></td><td>const-qualification on weak_ptr::owner_before</td><td>Portland</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2086">2086</a></td><td>Overly generic type support for math functions</td><td>Portland</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2099">2099</a></td><td>Unnecessary constraints of va_start() usage</td><td>Portland</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2103">2103</a></td><td>std::allocator_traits&lt;std::allocator&lt;T&gt;&gt;::propagate_on_container_move_assignment</td><td>Portland</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2105">2105</a></td><td>Inconsistent requirements on const_iterator's value_type</td><td>Portland</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2110">2110</a></td><td>remove can't swap but note says it might</td><td>Portland</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2123">2123</a></td><td>merge() allocator requirements for lists versus forward lists</td><td>Portland</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2005">2005</a></td><td>unordered_map::insert(T&&) protection should apply to map too</td><td>Portland</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2011">2011</a></td><td>Unexpected output required of strings</td><td>Portland</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2048">2048</a></td><td>Unnecessary mem_fn overloads</td><td>Portland</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2049">2049</a></td><td>is_destructible is underspecified</td><td>Portland</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2056">2056</a></td><td>future_errc enums start with value 0 (invalid value for broken_promise)</td><td>Portland</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2058">2058</a></td><td>valarray and begin/end</td><td>Portland</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2071">2071</a></td><td>std::valarray move-assignment</td><td>Portland</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2074">2074</a></td><td>Off by one error in std::reverse_copy</td><td>Portland</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2081">2081</a></td><td>Allocator requirements should include CopyConstructible</td><td>Portland</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2083">2083</a></td><td>const-qualification on weak_ptr::owner_before</td><td>Portland</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2086">2086</a></td><td>Overly generic type support for math functions</td><td>Portland</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2099">2099</a></td><td>Unnecessary constraints of va_start() usage</td><td>Portland</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2103">2103</a></td><td>std::allocator_traits&lt;std::allocator&lt;T&gt;&gt;::propagate_on_container_move_assignment</td><td>Portland</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2105">2105</a></td><td>Inconsistent requirements on const_iterator's value_type</td><td>Portland</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2110">2110</a></td><td>remove can't swap but note says it might</td><td>Portland</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2123">2123</a></td><td>merge() allocator requirements for lists versus forward lists</td><td>Portland</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2005">2005</a></td><td>unordered_map::insert(T&&) protection should apply to map too</td><td>Portland</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2011">2011</a></td><td>Unexpected output required of strings</td><td>Portland</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2048">2048</a></td><td>Unnecessary mem_fn overloads</td><td>Portland</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2049">2049</a></td><td>is_destructible is underspecified</td><td>Portland</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2056">2056</a></td><td>future_errc enums start with value 0 (invalid value for broken_promise)</td><td>Portland</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2058">2058</a></td><td>valarray and begin/end</td><td>Portland</td><td>Complete</td></tr>
   <tr><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2091">2091</a></td><td>Misplaced effect in m.try_lock_for()</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2092">2092</a></td><td>Vague Wording for condition_variable_any</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2093">2093</a></td><td>Throws clause of condition_variable::wait with predicate</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2094">2094</a></td><td>duration conversion overflow shouldn't participate in overload resolution</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2122">2122</a></td><td>merge() stability for lists versus forward lists</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2128">2128</a></td><td>Absence of global functions cbegin/cend</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2145">2145</a></td><td>error_category default constructor</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2147">2147</a></td><td>Unclear hint type in Allocator's allocate function</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2148">2148</a></td><td>Hashing enums should be supported directly by std::hash</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2149">2149</a></td><td>Concerns about 20.8/5</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2162">2162</a></td><td>allocator_traits::max_size missing noexcept</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2163">2163</a></td><td>nth_element requires inconsistent post-conditions</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2169">2169</a></td><td>Missing reset() requirements in unique_ptr specialization</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2172">2172</a></td><td>Does atomic_compare_exchange_* accept v == nullptr arguments?</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2080">2080</a></td><td>Specify when once_flag becomes invalid</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2098">2098</a></td><td>promise throws clauses</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2109">2109</a></td><td>Incorrect requirements for hash specializations</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2130">2130</a></td><td>missing ordering constraints for fences</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2138">2138</a></td><td>atomic_flag::clear ordering constraints</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2140">2140</a></td><td>notify_all_at_thread_exit synchronization</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2144">2144</a></td><td>Missing noexcept specification in type_index</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2174">2174</a></td><td>wstring_convert::converted() should be noexcept</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2175">2175</a></td><td>string_convert and wbuffer_convert validity</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2176">2176</a></td><td>Special members for wstring_convert and wbuffer_convert</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2177">2177</a></td><td>Requirements on Copy/MoveInsertable</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2185">2185</a></td><td>Missing throws clause for future/shared_future::wait_for/wait_until</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2187">2187</a></td><td>vector&lt;bool&gt; is missing emplace and emplace_back member functions</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2190">2190</a></td><td>ordering of condition variable operations, reflects Posix discussion</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2196">2196</a></td><td>Specification of is_*[copy/move]_[constructible/assignable] unclear for non-referencable types</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2197">2197</a></td><td>Specification of is_[un]signed unclear for non-arithmetic types</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2200">2200</a></td><td>Data race avoidance for all containers, not only for sequences</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2203">2203</a></td><td>scoped_allocator_adaptor uses wrong argument types for piecewise construction</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2207">2207</a></td><td>basic_string::at should not have a Requires clause</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2209">2209</a></td><td>assign() overspecified for sequence containers</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2210">2210</a></td><td>Missing allocator-extended constructor for allocator-aware containers</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2211">2211</a></td><td>Replace ambiguous use of "Allocator" in container requirements</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2222">2222</a></td><td>Inconsistency in description of forward_list::splice_after single-element overload</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2225">2225</a></td><td>Unrealistic header inclusion checks required</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2229">2229</a></td><td>Standard code conversion facets underspecified</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2231">2231</a></td><td>DR 704 removes complexity guarantee for clear()</td><td>Bristol</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2235">2235</a></td><td>Undefined behavior without proper requirements on basic_string constructors</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2091">2091</a></td><td>Misplaced effect in m.try_lock_for()</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2092">2092</a></td><td>Vague Wording for condition_variable_any</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2093">2093</a></td><td>Throws clause of condition_variable::wait with predicate</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2094">2094</a></td><td>duration conversion overflow shouldn't participate in overload resolution</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2122">2122</a></td><td>merge() stability for lists versus forward lists</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2128">2128</a></td><td>Absence of global functions cbegin/cend</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2145">2145</a></td><td>error_category default constructor</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2147">2147</a></td><td>Unclear hint type in Allocator's allocate function</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2148">2148</a></td><td>Hashing enums should be supported directly by std::hash</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2149">2149</a></td><td>Concerns about 20.8/5</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2162">2162</a></td><td>allocator_traits::max_size missing noexcept</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2163">2163</a></td><td>nth_element requires inconsistent post-conditions</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2169">2169</a></td><td>Missing reset() requirements in unique_ptr specialization</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2172">2172</a></td><td>Does atomic_compare_exchange_* accept v == nullptr arguments?</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2080">2080</a></td><td>Specify when once_flag becomes invalid</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2098">2098</a></td><td>promise throws clauses</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2109">2109</a></td><td>Incorrect requirements for hash specializations</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2130">2130</a></td><td>missing ordering constraints for fences</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2138">2138</a></td><td>atomic_flag::clear ordering constraints</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2140">2140</a></td><td>notify_all_at_thread_exit synchronization</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2144">2144</a></td><td>Missing noexcept specification in type_index</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2174">2174</a></td><td>wstring_convert::converted() should be noexcept</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2175">2175</a></td><td>string_convert and wbuffer_convert validity</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2176">2176</a></td><td>Special members for wstring_convert and wbuffer_convert</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2177">2177</a></td><td>Requirements on Copy/MoveInsertable</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2185">2185</a></td><td>Missing throws clause for future/shared_future::wait_for/wait_until</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2187">2187</a></td><td>vector&lt;bool&gt; is missing emplace and emplace_back member functions</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2190">2190</a></td><td>ordering of condition variable operations, reflects Posix discussion</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2196">2196</a></td><td>Specification of is_*[copy/move]_[constructible/assignable] unclear for non-referencable types</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2197">2197</a></td><td>Specification of is_[un]signed unclear for non-arithmetic types</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2200">2200</a></td><td>Data race avoidance for all containers, not only for sequences</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2203">2203</a></td><td>scoped_allocator_adaptor uses wrong argument types for piecewise construction</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2207">2207</a></td><td>basic_string::at should not have a Requires clause</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2209">2209</a></td><td>assign() overspecified for sequence containers</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2210">2210</a></td><td>Missing allocator-extended constructor for allocator-aware containers</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2211">2211</a></td><td>Replace ambiguous use of "Allocator" in container requirements</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2222">2222</a></td><td>Inconsistency in description of forward_list::splice_after single-element overload</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2225">2225</a></td><td>Unrealistic header inclusion checks required</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2229">2229</a></td><td>Standard code conversion facets underspecified</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2231">2231</a></td><td>DR 704 removes complexity guarantee for clear()</td><td>Bristol</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2235">2235</a></td><td>Undefined behavior without proper requirements on basic_string constructors</td><td>Bristol</td><td>Complete</td></tr>
     <tr><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2141">2141</a></td><td>common_type trait produces reference types</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2246">2246</a></td><td>unique_ptr assignment effects w.r.t. deleter</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2247">2247</a></td><td>Type traits and std::nullptr_t</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2085">2085</a></td><td>Wrong description of effect 1 of basic_istream::ignore</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2087">2087</a></td><td>iostream_category() and noexcept</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2143">2143</a></td><td>ios_base::xalloc should be thread-safe</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2150">2150</a></td><td>Unclear specification of find_end</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2180">2180</a></td><td>Exceptions from std::seed_seq operations</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2194">2194</a></td><td>Impossible container requirements for adaptor types</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2013">2013</a></td><td>Do library implementers have the freedom to add constexpr?</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2018">2018</a></td><td>regex_traits::isctype Returns clause is wrong</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2078">2078</a></td><td>Throw specification of async() incomplete</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2097">2097</a></td><td>packaged_task constructors should be constrained</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2100">2100</a></td><td>Timed waiting functions cannot timeout if launch::async policy used</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2120">2120</a></td><td>What should async do if neither 'async' nor 'deferred' is set in policy?</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2159">2159</a></td><td>atomic_flag initialization</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2275">2275</a></td><td>Why is forward_as_tuple not constexpr?</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2284">2284</a></td><td>Inconsistency in allocator_traits::max_size</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2298">2298</a></td><td>is_nothrow_constructible is always false because of create&lt;&gt;</td><td>Chicago</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2300">2300</a></td><td>Redundant sections for map and multimap members should be removed</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2141">2141</a></td><td>common_type trait produces reference types</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2246">2246</a></td><td>unique_ptr assignment effects w.r.t. deleter</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2247">2247</a></td><td>Type traits and std::nullptr_t</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2085">2085</a></td><td>Wrong description of effect 1 of basic_istream::ignore</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2087">2087</a></td><td>iostream_category() and noexcept</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2143">2143</a></td><td>ios_base::xalloc should be thread-safe</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2150">2150</a></td><td>Unclear specification of find_end</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2180">2180</a></td><td>Exceptions from std::seed_seq operations</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2194">2194</a></td><td>Impossible container requirements for adaptor types</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2013">2013</a></td><td>Do library implementers have the freedom to add constexpr?</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2018">2018</a></td><td>regex_traits::isctype Returns clause is wrong</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2078">2078</a></td><td>Throw specification of async() incomplete</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2097">2097</a></td><td>packaged_task constructors should be constrained</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2100">2100</a></td><td>Timed waiting functions cannot timeout if launch::async policy used</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2120">2120</a></td><td>What should async do if neither 'async' nor 'deferred' is set in policy?</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2159">2159</a></td><td>atomic_flag initialization</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2275">2275</a></td><td>Why is forward_as_tuple not constexpr?</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2284">2284</a></td><td>Inconsistency in allocator_traits::max_size</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2298">2298</a></td><td>is_nothrow_constructible is always false because of create&lt;&gt;</td><td>Chicago</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2300">2300</a></td><td>Redundant sections for map and multimap members should be removed</td><td>Chicago</td><td>Complete</td></tr>
 	<tr><td>NB comment: GB9</td>                                                                     <td>Remove gets from C++14</td><td>Chicago</td><td>Complete</td></tr>
     <tr><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2135">2135</a></td><td>Unclear requirement for exceptions thrown in condition_variable::wait()</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2291">2291</a></td><td>std::hash is vulnerable to collision DoS attack</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2142">2142</a></td><td>packaged_task::operator() synchronization too broad?</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2240">2240</a></td><td>Probable misuse of term "function scope" in [thread.condition]</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2252">2252</a></td><td>Strong guarantee on vector::push_back() still broken with C++11?</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2257">2257</a></td><td>Simplify container requirements with the new algorithms</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2268">2268</a></td><td>Setting a default argument in the declaration of a member function assign of std::basic_string</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2271">2271</a></td><td>regex_traits::lookup_classname specification unclear</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2272">2272</a></td><td>quoted should use char_traits::eq for character comparison</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2278">2278</a></td><td>User-defined literals for Standard Library types</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2280">2280</a></td><td>begin / end for arrays should be constexpr and noexcept</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2285">2285</a></td><td>make_reverse_iterator</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2135">2135</a></td><td>Unclear requirement for exceptions thrown in condition_variable::wait()</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2291">2291</a></td><td>std::hash is vulnerable to collision DoS attack</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2142">2142</a></td><td>packaged_task::operator() synchronization too broad?</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2240">2240</a></td><td>Probable misuse of term "function scope" in [thread.condition]</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2252">2252</a></td><td>Strong guarantee on vector::push_back() still broken with C++11?</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2257">2257</a></td><td>Simplify container requirements with the new algorithms</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2268">2268</a></td><td>Setting a default argument in the declaration of a member function assign of std::basic_string</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2271">2271</a></td><td>regex_traits::lookup_classname specification unclear</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2272">2272</a></td><td>quoted should use char_traits::eq for character comparison</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2278">2278</a></td><td>User-defined literals for Standard Library types</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2280">2280</a></td><td>begin / end for arrays should be constexpr and noexcept</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2285">2285</a></td><td>make_reverse_iterator</td><td>Issaquah</td><td>Complete</td></tr>
 
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2299">2299</a></td><td>Effects of inaccessible key_compare::is_transparent type are not clear</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2299">2299</a></td><td>Effects of inaccessible key_compare::is_transparent type are not clear</td><td>Issaquah</td><td>Complete</td></tr>
 
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#1450">1450</a></td><td>Contradiction in regex_constants</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2003">2003</a></td><td>String exception inconsistency in erase.</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2112">2112</a></td><td>User-defined classes that cannot be derived from</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2132">2132</a></td><td>std::function ambiguity</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2182">2182</a></td><td>Container::[const_]reference types are misleadingly specified</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2188">2188</a></td><td>Reverse iterator does not fully support targets that overload operator&</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2193">2193</a></td><td>Default constructors for standard library containers are explicit</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2205">2205</a></td><td>Problematic postconditions of regex_match and regex_search</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2213">2213</a></td><td>Return value of std::regex_replace</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg1450">1450</a></td><td>Contradiction in regex_constants</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2003">2003</a></td><td>String exception inconsistency in erase.</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2112">2112</a></td><td>User-defined classes that cannot be derived from</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2132">2132</a></td><td>std::function ambiguity</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2182">2182</a></td><td>Container::[const_]reference types are misleadingly specified</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2188">2188</a></td><td>Reverse iterator does not fully support targets that overload operator&</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2193">2193</a></td><td>Default constructors for standard library containers are explicit</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2205">2205</a></td><td>Problematic postconditions of regex_match and regex_search</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2213">2213</a></td><td>Return value of std::regex_replace</td><td>Issaquah</td><td>Complete</td></tr>
 
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2258">2258</a></td><td>a.erase(q1, q2) unable to directly return q2</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2263">2263</a></td><td>Comparing iterators and allocator pointers with different const-character</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2293">2293</a></td><td>Wrong facet used by num_put::do_put</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2301">2301</a></td><td>Why is std::tie not constexpr?</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2304">2304</a></td><td>Complexity of count in unordered associative containers</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2306">2306</a></td><td>match_results::reference should be value_type&, not const value_type&</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2308">2308</a></td><td>Clarify container destructor requirements w.r.t. std::array</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2313">2313</a></td><td>tuple_size should always derive from integral_constant<size_t, N></td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2314">2314</a></td><td>apply() should return decltype(auto) and use decay_t before tuple_size</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2315">2315</a></td><td>weak_ptr should be movable</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2316">2316</a></td><td>weak_ptr::lock() should be atomic</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2317">2317</a></td><td>The type property queries should be UnaryTypeTraits returning size_t</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2320">2320</a></td><td>select_on_container_copy_construction() takes allocators, not containers</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2322">2322</a></td><td>Associative(initializer_list, stuff) constructors are underspecified</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2323">2323</a></td><td>vector::resize(n, t)'s specification should be simplified</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2324">2324</a></td><td>Insert iterator constructors should use addressof()</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2329">2329</a></td><td>regex_match()/regex_search() with match_results should forbid temporary strings</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2330">2330</a></td><td>regex("meow", regex::icase) is technically forbidden but should be permitted</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2332">2332</a></td><td>regex_iterator/regex_token_iterator should forbid temporary regexes</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2339">2339</a></td><td>Wording issue in nth_element</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2341">2341</a></td><td>Inconsistency between basic_ostream::seekp(pos) and basic_ostream::seekp(off, dir)</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2344">2344</a></td><td>quoted()'s interaction with padding is unclear</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2346">2346</a></td><td>integral_constant's member functions should be marked noexcept</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2350">2350</a></td><td>min, max, and minmax should be constexpr</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2356">2356</a></td><td>Stability of erasure in unordered associative containers</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2357">2357</a></td><td>Remaining "Assignable" requirement</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2359">2359</a></td><td>How does regex_constants::nosubs affect basic_regex::mark_count()?</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2360">2360</a></td><td>reverse_iterator::operator*() is unimplementable</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2104">2104</a></td><td>unique_lock move-assignment should not be noexcept</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2186">2186</a></td><td>Incomplete action on async/launch::deferred</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2075">2075</a></td><td>Progress guarantees, lock-free property, and scheduling assumptions</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://cplusplus.github.io/LWG/lwg-defects.html#2288">2288</a></td><td>Inconsistent requirements for shared mutexes</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2258">2258</a></td><td>a.erase(q1, q2) unable to directly return q2</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2263">2263</a></td><td>Comparing iterators and allocator pointers with different const-character</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2293">2293</a></td><td>Wrong facet used by num_put::do_put</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2301">2301</a></td><td>Why is std::tie not constexpr?</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2304">2304</a></td><td>Complexity of count in unordered associative containers</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2306">2306</a></td><td>match_results::reference should be value_type&, not const value_type&</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2308">2308</a></td><td>Clarify container destructor requirements w.r.t. std::array</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2313">2313</a></td><td>tuple_size should always derive from integral_constant<size_t, N></td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2314">2314</a></td><td>apply() should return decltype(auto) and use decay_t before tuple_size</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2315">2315</a></td><td>weak_ptr should be movable</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2316">2316</a></td><td>weak_ptr::lock() should be atomic</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2317">2317</a></td><td>The type property queries should be UnaryTypeTraits returning size_t</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2320">2320</a></td><td>select_on_container_copy_construction() takes allocators, not containers</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2322">2322</a></td><td>Associative(initializer_list, stuff) constructors are underspecified</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2323">2323</a></td><td>vector::resize(n, t)'s specification should be simplified</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2324">2324</a></td><td>Insert iterator constructors should use addressof()</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2329">2329</a></td><td>regex_match()/regex_search() with match_results should forbid temporary strings</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2330">2330</a></td><td>regex("meow", regex::icase) is technically forbidden but should be permitted</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2332">2332</a></td><td>regex_iterator/regex_token_iterator should forbid temporary regexes</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2339">2339</a></td><td>Wording issue in nth_element</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2341">2341</a></td><td>Inconsistency between basic_ostream::seekp(pos) and basic_ostream::seekp(off, dir)</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2344">2344</a></td><td>quoted()'s interaction with padding is unclear</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2346">2346</a></td><td>integral_constant's member functions should be marked noexcept</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2350">2350</a></td><td>min, max, and minmax should be constexpr</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2356">2356</a></td><td>Stability of erasure in unordered associative containers</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2357">2357</a></td><td>Remaining "Assignable" requirement</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2359">2359</a></td><td>How does regex_constants::nosubs affect basic_regex::mark_count()?</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2360">2360</a></td><td>reverse_iterator::operator*() is unimplementable</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2104">2104</a></td><td>unique_lock move-assignment should not be noexcept</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2186">2186</a></td><td>Incomplete action on async/launch::deferred</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2075">2075</a></td><td>Progress guarantees, lock-free property, and scheduling assumptions</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/lwg2288">2288</a></td><td>Inconsistent requirements for shared mutexes</td><td>Issaquah</td><td>Complete</td></tr>
 <!-- 	<tr><td></td><td></td><td></td><td></td></tr> -->
   </table>
 
diff --git a/www/cxx1z_status.html b/www/cxx1z_status.html
index 601c6e7d2f46..4665eb22bd3c 100644
--- a/www/cxx1z_status.html
+++ b/www/cxx1z_status.html
@@ -12,7 +12,7 @@
 <body>
 <div id="menu">
   <div>
-    <a href="http://llvm.org/">LLVM Home</a>
+    <a href="https://llvm.org/">LLVM Home</a>
   </div>
 
   <div class="submenu">
@@ -22,11 +22,11 @@
 
   <div class="submenu">
     <label>Quick Links</label>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="http://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
   </div>
 </div>
 
@@ -37,7 +37,7 @@
 
   <p>In November 2014, the C++ standard committee created a draft for the next version of the C++ standard, known here as "C++1z" (probably to be C++17).</p>
   <p>In February 2017, the C++ standard committee approved this draft, and sent it to ISO for approval as C++17</p>
-  <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="http://clang.llvm.org/cxx_status.html#cxx17">here</a>.</p>
+  <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="https://clang.llvm.org/cxx_status.html#cxx17">here</a>.</p>
 
   <p>Reminder: Features in unreleased drafts of the standard are subject to change.</p>
 
@@ -53,119 +53,120 @@
   <table id="papers" border="1">
 	<tr><th>Paper #</th><th>Group</th><th>Paper Name</th><th>Meeting</th><th>Status</th><th>First released version</th></tr>
 <!--
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3346.pdf">3346</a></td><td>LWG</td><td>Terminology for Container Element Requirements - Rev 1</td><td>Kona</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3346">3346</a></td><td>LWG</td><td>Terminology for Container Element Requirements - Rev 1</td><td>Kona</td><td>Complete</td><td>3.4</td></tr>
 -->
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3911">N3911</a></td><td>LWG</td></td><td>TransformationTrait Alias <code>void_t</code>.</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4089">N4089</a></td><td>LWG</td></td><td>Safe conversions in <code>unique_ptr&lt;T[]&gt;</code>.</td><td>Urbana</td><td>In progress</td><td>3.9</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4169">N4169</a></td><td>LWG</td></td><td>A proposal to add invoke function template</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4190">N4190</a></td></td><td>LWG</td><td>Removing auto_ptr, random_shuffle(), And Old <functional> Stuff.</td><td>Urbana</td><td>In progress</td><td></td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4258">N4258</a></td><td>LWG</td></td><td>Cleaning-up noexcept in the Library.</td><td>Urbana</td><td>In progress</td><td>3.7</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4259">N4259</a></td><td>CWG</td></td><td>Wording for std::uncaught_exceptions</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4277">N4277</a></td><td>LWG</td></td><td>TriviallyCopyable <code>reference_wrapper</code>.</td><td>Urbana</td><td>Complete</td><td>3.2</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4279">N4279</a></td><td>LWG</td></td><td>Improved insertion interface for unique-key maps.</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4280">N4280</a></td><td>LWG</td></td><td>Non-member size() and more</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4284">N4284</a></td><td>LWG</td></td><td>Contiguous Iterators.</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4285">N4285</a></td><td>CWG</td></td><td>Cleanup for exception-specification and throw-expression.</td><td>Urbana</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/n3911">N3911</a></td><td>LWG</td></td><td>TransformationTrait Alias <code>void_t</code>.</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
+	<tr><td><a href="https://wg21.link/n4089">N4089</a></td><td>LWG</td></td><td>Safe conversions in <code>unique_ptr&lt;T[]&gt;</code>.</td><td>Urbana</td><td>In progress</td><td>3.9</td></tr>
+	<tr><td><a href="https://wg21.link/n4169">N4169</a></td><td>LWG</td></td><td>A proposal to add invoke function template</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
+	<tr><td><a href="https://wg21.link/n4190">N4190</a></td></td><td>LWG</td><td>Removing auto_ptr, random_shuffle(), And Old <functional> Stuff.</td><td>Urbana</td><td>In progress</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/n4258">N4258</a></td><td>LWG</td></td><td>Cleaning-up noexcept in the Library.</td><td>Urbana</td><td>In progress</td><td>3.7</td></tr>
+	<tr><td><a href="https://wg21.link/n4259">N4259</a></td><td>CWG</td></td><td>Wording for std::uncaught_exceptions</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
+	<tr><td><a href="https://wg21.link/n4277">N4277</a></td><td>LWG</td></td><td>TriviallyCopyable <code>reference_wrapper</code>.</td><td>Urbana</td><td>Complete</td><td>3.2</td></tr>
+	<tr><td><a href="https://wg21.link/n4279">N4279</a></td><td>LWG</td></td><td>Improved insertion interface for unique-key maps.</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
+	<tr><td><a href="https://wg21.link/n4280">N4280</a></td><td>LWG</td></td><td>Non-member size() and more</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
+	<tr><td><a href="https://wg21.link/n4284">N4284</a></td><td>LWG</td></td><td>Contiguous Iterators.</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
+	<tr><td><a href="https://wg21.link/n4285">N4285</a></td><td>CWG</td></td><td>Cleanup for exception-specification and throw-expression.</td><td>Urbana</td><td>Complete</td><td>4.0</td></tr>
   	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4387">N4387</a></td><td>LWG</td></td><td>improving pair and tuple</td><td>Lenexa</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4389">N4389</a></td><td>LWG</td></td><td>bool_constant</td><td>Lenexa</td><td>Complete</td><td>3.7</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4508">N4508</a></td><td>LWG</td></td><td>shared_mutex for C++17</td><td>Lenexa</td><td>Complete</td><td>3.7</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4366">N4366</a></td><td>LWG</td></td><td>LWG 2228 missing SFINAE rule</td><td>Lenexa</td><td>Complete</td><td>3.1</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4510">N4510</a></td><td>LWG</td></td><td>Minimal incomplete type support for standard containers, revision 4</td><td>Lenexa</td><td>Complete</td><td>3.6</td></tr>
+	<tr><td><a href="https://wg21.link/n4387">N4387</a></td><td>LWG</td></td><td>improving pair and tuple</td><td>Lenexa</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/n4389">N4389</a></td><td>LWG</td></td><td>bool_constant</td><td>Lenexa</td><td>Complete</td><td>3.7</td></tr>
+	<tr><td><a href="https://wg21.link/n4508">N4508</a></td><td>LWG</td></td><td>shared_mutex for C++17</td><td>Lenexa</td><td>Complete</td><td>3.7</td></tr>
+	<tr><td><a href="https://wg21.link/n4366">N4366</a></td><td>LWG</td></td><td>LWG 2228 missing SFINAE rule</td><td>Lenexa</td><td>Complete</td><td>3.1</td></tr>
+	<tr><td><a href="https://wg21.link/n4510">N4510</a></td><td>LWG</td></td><td>Minimal incomplete type support for standard containers, revision 4</td><td>Lenexa</td><td>Complete</td><td>3.6</td></tr>
   	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0004r1.html">P0004R1</a></td><td>LWG</td><td>Remove Deprecated iostreams aliases.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0006r0.html">P0006R0</a></td><td>LWG</td><td>Adopt Type Traits Variable Templates for C++17.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0092r1.html">P0092R1</a></td><td>LWG</td><td>Polishing &lt;chrono&gt;</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0007r1.html">P0007R1</a></td><td>LWG</td><td>Constant View: A proposal for a <tt>std::as_const</tt> helper function template.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0156r0.html" >P0156R0</a></td><td>LWG</td><td>Variadic lock_guard(rev 3).</td><td>Kona</td><td><I>Reverted in Kona</I></td><td>3.9</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0074r0.html">P0074R0</a></td><td>LWG</td><td>Making <tt>std::owner_less</tt> more flexible</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0013r1.html">P0013R1</a></td><td>LWG</td><td>Logical type traits rev 2</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
+	<tr><td><a href="https://wg21.link/p0004r1">P0004R1</a></td><td>LWG</td><td>Remove Deprecated iostreams aliases.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
+	<tr><td><a href="https://wg21.link/p0006r0">P0006R0</a></td><td>LWG</td><td>Adopt Type Traits Variable Templates for C++17.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
+	<tr><td><a href="https://wg21.link/p0092r1">P0092R1</a></td><td>LWG</td><td>Polishing &lt;chrono&gt;</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
+	<tr><td><a href="https://wg21.link/p0007r1">P0007R1</a></td><td>LWG</td><td>Constant View: A proposal for a <tt>std::as_const</tt> helper function template.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
+	<tr><td><a href="https://wg21.link/p0156r0">P0156R0</a></td><td>LWG</td><td>Variadic lock_guard(rev 3).</td><td>Kona</td><td><I>Reverted in Kona</I></td><td>3.9</td></tr>
+	<tr><td><a href="https://wg21.link/p0074r0">P0074R0</a></td><td>LWG</td><td>Making <tt>std::owner_less</tt> more flexible</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
+	<tr><td><a href="https://wg21.link/p0013r1">P0013R1</a></td><td>LWG</td><td>Logical type traits rev 2</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
   	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0024R2">P0024R2</a></td><td>LWG</td><td>The Parallelism TS Should be Standardized</td><td>Jacksonville</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0226R1">P0226R1</a></td><td>LWG</td><td>Mathematical Special Functions for C++17</td><td>Jacksonville</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0220R1">P0220R1</a></td><td>LWG</td><td>Adopt Library Fundamentals V1 TS Components for C++17</td><td>Jacksonville</td><td>In Progress</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0218R1">P0218R1</a></td><td>LWG</td><td>Adopt the File System TS for C++17</td><td>Jacksonville</td><td>In Progress</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0033R1">P0033R1</a></td><td>LWG</td><td>Re-enabling shared_from_this</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-	<tr><td><a href="http://wg21.link/P0005R4">P0005R4</a></td><td>LWG</td><td>Adopt not_fn from Library Fundamentals 2 for C++17</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-	<tr><td><a href="http://wg21.link/P0152R1">P0152R1</a></td><td>LWG</td><td>constexpr atomic::is_always_lock_free</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-	<tr><td><a href="http://wg21.link/P0185R1">P0185R1</a></td><td>LWG</td><td>Adding [nothrow-]swappable traits</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-	<tr><td><a href="http://wg21.link/P0253R1">P0253R1</a></td><td>LWG</td><td>Fixing a design mistake in the searchers interface</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-	<tr><td><a href="http://wg21.link/P0025R0">P0025R0</a></td><td>LWG</td><td>An algorithm to "clamp" a value between a pair of boundary values</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-	<tr><td><a href="http://wg21.link/P0154R1">P0154R1</a></td><td>LWG</td><td>constexpr std::hardware_{constructive,destructive}_interference_size</td><td>Jacksonville</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0030R1">P0030R1</a></td><td>LWG</td><td>Proposal to Introduce a 3-Argument Overload to std::hypot</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-	<tr><td><a href="http://wg21.link/P0031R0">P0031R0</a></td><td>LWG</td><td>A Proposal to Add Constexpr Modifiers to reverse_iterator, move_iterator, array and Range Access</td><td>Jacksonville</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0272R1">P0272R1</a></td><td>LWG</td><td>Give <tt>std::string</tt> a non-const <tt>.data()</tt> member function</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
-	<tr><td><a href="http://wg21.link/P0077R2">P0077R2</a></td><td>LWG</td><td><tt>is_callable</tt>, the missing INVOKE related trait</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="https://wg21.link/P0024R2">P0024R2</a></td><td>LWG</td><td>The Parallelism TS Should be Standardized</td><td>Jacksonville</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0226R1">P0226R1</a></td><td>LWG</td><td>Mathematical Special Functions for C++17</td><td>Jacksonville</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0220R1">P0220R1</a></td><td>LWG</td><td>Adopt Library Fundamentals V1 TS Components for C++17</td><td>Jacksonville</td><td>In Progress</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0218R1">P0218R1</a></td><td>LWG</td><td>Adopt the File System TS for C++17</td><td>Jacksonville</td><td>In Progress</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0033R1">P0033R1</a></td><td>LWG</td><td>Re-enabling shared_from_this</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="https://wg21.link/P0005R4">P0005R4</a></td><td>LWG</td><td>Adopt not_fn from Library Fundamentals 2 for C++17</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="https://wg21.link/P0152R1">P0152R1</a></td><td>LWG</td><td>constexpr atomic::is_always_lock_free</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="https://wg21.link/P0185R1">P0185R1</a></td><td>LWG</td><td>Adding [nothrow-]swappable traits</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="https://wg21.link/P0253R1">P0253R1</a></td><td>LWG</td><td>Fixing a design mistake in the searchers interface</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="https://wg21.link/P0025R0">P0025R0</a></td><td>LWG</td><td>An algorithm to "clamp" a value between a pair of boundary values</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="https://wg21.link/P0154R1">P0154R1</a></td><td>LWG</td><td>constexpr std::hardware_{constructive,destructive}_interference_size</td><td>Jacksonville</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0030R1">P0030R1</a></td><td>LWG</td><td>Proposal to Introduce a 3-Argument Overload to std::hypot</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="https://wg21.link/P0031R0">P0031R0</a></td><td>LWG</td><td>A Proposal to Add Constexpr Modifiers to reverse_iterator, move_iterator, array and Range Access</td><td>Jacksonville</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0272R1">P0272R1</a></td><td>LWG</td><td>Give <tt>std::string</tt> a non-const <tt>.data()</tt> member function</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="https://wg21.link/P0077R2">P0077R2</a></td><td>LWG</td><td><tt>is_callable</tt>, the missing INVOKE related trait</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
   	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/p0032r3">p0032r3</a></td><td>LWG</td><td>Homogeneous interface for variant, any and optional</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/p0040r3">p0040r3</a></td><td>LWG</td><td>Extending memory management tools</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/p0063r3">p0063r3</a></td><td>LWG</td><td>C++17 should refer to C11 instead of C99</td><td>Oulu</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
-	<tr><td><a href="http://wg21.link/p0067r3">p0067r3</a></td><td>LWG</td><td>Elementary string conversions</td><td>Oulu</td><td>Now <a href="http://wg21.link/P0067R5">P0067R5</a></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/p0083r3">p0083r3</a></td><td>LWG</td><td>Splicing Maps and Sets</td><td>Oulu</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/p0084r2">p0084r2</a></td><td>LWG</td><td>Emplace Return Type</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/p0088r3">p0088r3</a></td><td>LWG</td><td>Variant: a type-safe union for C++17</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/p0163r0">p0163r0</a></td><td>LWG</td><td>shared_ptr::weak_type</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
-	<tr><td><a href="http://wg21.link/p0174r2">p0174r2</a></td><td>LWG</td><td>Deprecating Vestigial Library Parts in C++17</td><td>Oulu</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/p0175r1">p0175r1</a></td><td>LWG</td><td>Synopses for the C library</td><td>Oulu</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/p0180r2">p0180r2</a></td><td>LWG</td><td>Reserve a New Library Namespace for Future Standardization</td><td>Oulu</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
-	<tr><td><a href="http://wg21.link/p0181r1">p0181r1</a></td><td>LWG</td><td>Ordered by Default</td><td>Oulu</td><td><i>Removed in Kona</i></td><td>n/a</td></tr>
-	<tr><td><a href="http://wg21.link/p0209r2">p0209r2</a></td><td>LWG</td><td>make_from_tuple: apply for construction</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
-	<tr><td><a href="http://wg21.link/p0219r1">p0219r1</a></td><td>LWG</td><td>Relative Paths for Filesystem</td><td>Oulu</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/p0254r2">p0254r2</a></td><td>LWG</td><td>Integrating std::string_view and std::string</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/p0258r2">p0258r2</a></td><td>LWG</td><td>has_unique_object_representations</td><td>Oulu</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/p0295r0">p0295r0</a></td><td>LWG</td><td>Adopt Selected Library Fundamentals V2 Components for C++17</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/p0302r1">p0302r1</a></td><td>LWG</td><td>Removing Allocator Support in std::function</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/p0307r2">p0307r2</a></td><td>LWG</td><td>Making Optional Greater Equal Again</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/p0336r1">p0336r1</a></td><td>LWG</td><td>Better Names for Parallel Execution Policies in C++17</td><td>Oulu</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/p0337r0">p0337r0</a></td><td>LWG</td><td>Delete operator= for polymorphic_allocator</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
-	<tr><td><a href="http://wg21.link/p0346r1">p0346r1</a></td><td>LWG</td><td>A &lt;random&gt; Nomenclature Tweak</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
-	<tr><td><a href="http://wg21.link/p0358r1">p0358r1</a></td><td>LWG</td><td>Fixes for not_fn</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
-	<tr><td><a href="http://wg21.link/p0371r1">p0371r1</a></td><td>LWG</td><td>Temporarily discourage memory_order_consume</td><td>Oulu</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
-	<tr><td><a href="http://wg21.link/p0392r0">p0392r0</a></td><td>LWG</td><td>Adapting string_view by filesystem paths</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/p0393r3">p0393r3</a></td><td>LWG</td><td>Making Variant Greater Equal</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0394r4">P0394r4</a></td><td>LWG</td><td>Hotel Parallelifornia: terminate() for Parallel Algorithms Exception Handling</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/p0032r3">p0032r3</a></td><td>LWG</td><td>Homogeneous interface for variant, any and optional</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/p0040r3">p0040r3</a></td><td>LWG</td><td>Extending memory management tools</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/p0063r3">p0063r3</a></td><td>LWG</td><td>C++17 should refer to C11 instead of C99</td><td>Oulu</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
+	<tr><td><a href="https://wg21.link/p0067r3">p0067r3</a></td><td>LWG</td><td>Elementary string conversions</td><td>Oulu</td><td>Now <a href="https://wg21.link/P0067R5">P0067R5</a></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/p0083r3">p0083r3</a></td><td>LWG</td><td>Splicing Maps and Sets</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/p0084r2">p0084r2</a></td><td>LWG</td><td>Emplace Return Type</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/p0088r3">p0088r3</a></td><td>LWG</td><td>Variant: a type-safe union for C++17</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/p0137r1">p0137r1</a></td><td>CWG</td><td>Core Issue 1776: Replacement of class objects containing reference members</td><td>Oulu</td><td>Complete</td><td>6.0</td></tr>
+	<tr><td><a href="https://wg21.link/p0163r0">p0163r0</a></td><td>LWG</td><td>shared_ptr::weak_type</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="https://wg21.link/p0174r2">p0174r2</a></td><td>LWG</td><td>Deprecating Vestigial Library Parts in C++17</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/p0175r1">p0175r1</a></td><td>LWG</td><td>Synopses for the C library</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/p0180r2">p0180r2</a></td><td>LWG</td><td>Reserve a New Library Namespace for Future Standardization</td><td>Oulu</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
+	<tr><td><a href="https://wg21.link/p0181r1">p0181r1</a></td><td>LWG</td><td>Ordered by Default</td><td>Oulu</td><td><i>Removed in Kona</i></td><td>n/a</td></tr>
+	<tr><td><a href="https://wg21.link/p0209r2">p0209r2</a></td><td>LWG</td><td>make_from_tuple: apply for construction</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="https://wg21.link/p0219r1">p0219r1</a></td><td>LWG</td><td>Relative Paths for Filesystem</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/p0254r2">p0254r2</a></td><td>LWG</td><td>Integrating std::string_view and std::string</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/p0258r2">p0258r2</a></td><td>LWG</td><td>has_unique_object_representations</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/p0295r0">p0295r0</a></td><td>LWG</td><td>Adopt Selected Library Fundamentals V2 Components for C++17</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/p0302r1">p0302r1</a></td><td>LWG</td><td>Removing Allocator Support in std::function</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/p0307r2">p0307r2</a></td><td>LWG</td><td>Making Optional Greater Equal Again</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/p0336r1">p0336r1</a></td><td>LWG</td><td>Better Names for Parallel Execution Policies in C++17</td><td>Oulu</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/p0337r0">p0337r0</a></td><td>LWG</td><td>Delete operator= for polymorphic_allocator</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="https://wg21.link/p0346r1">p0346r1</a></td><td>LWG</td><td>A &lt;random&gt; Nomenclature Tweak</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="https://wg21.link/p0358r1">p0358r1</a></td><td>LWG</td><td>Fixes for not_fn</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
+	<tr><td><a href="https://wg21.link/p0371r1">p0371r1</a></td><td>LWG</td><td>Temporarily discourage memory_order_consume</td><td>Oulu</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
+	<tr><td><a href="https://wg21.link/p0392r0">p0392r0</a></td><td>LWG</td><td>Adapting string_view by filesystem paths</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/p0393r3">p0393r3</a></td><td>LWG</td><td>Making Variant Greater Equal</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0394r4">P0394r4</a></td><td>LWG</td><td>Hotel Parallelifornia: terminate() for Parallel Algorithms Exception Handling</td><td>Oulu</td><td></td><td></td></tr>
   	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0003R5">P0003R5</a></td><td>LWG</td><td>Removing Deprecated Exception Specifications from C++17</td><td>Issaquah</td><td>Complete</td><td>5.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0067R5">P0067R5</a></td><td>LWG</td><td>Elementary string conversions, revision 5</td><td>Issaquah</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0403R1">P0403R1</a></td><td>LWG</td><td>Literal suffixes for <tt>basic_string_view</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0414R2">P0414R2</a></td><td>LWG</td><td>Merging shared_ptr changes from Library Fundamentals to C++17</td><td>Issaquah</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0418R2">P0418R2</a></td><td>LWG</td><td>Fail or succeed: there is no atomic lattice</td><td>Issaquah</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0426R1">P0426R1</a></td><td>LWG</td><td>Constexpr for <tt>std::char_traits</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0435R1">P0435R1</a></td><td>LWG</td><td>Resolving LWG Issues re <tt>common_type</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0502R0">P0502R0</a></td><td>LWG</td><td>Throwing out of a parallel algorithm terminates - but how?</td><td>Issaquah</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0503R0">P0503R0</a></td><td>LWG</td><td>Correcting library usage of "literal type"</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0504R0">P0504R0</a></td><td>LWG</td><td>Revisiting in-place tag types for any/optional/variant</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0505R0">P0505R0</a></td><td>LWG</td><td>Wording for GB 50 - constexpr for chrono</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0508R0">P0508R0</a></td><td>LWG</td><td>Wording for GB 58 - structured bindings for node_handles</td><td>Issaquah</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0509R1">P0509R1</a></td><td>LWG</td><td>Updating “Restrictions on exception handling”</td><td>Issaquah</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
-	<tr><td><a href="http://wg21.link/P0510R0">P0510R0</a></td><td>LWG</td><td>Disallowing references, incomplete types, arrays, and empty variants</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0513R0">P0513R0</a></td><td>LWG</td><td>Poisoning the Hash</td><td>Issaquah</td><td>Complete</td><td>5.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0516R0">P0516R0</a></td><td>LWG</td><td>Clarify That shared_future’s Copy Operations have Wide Contracts</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0517R0">P0517R0</a></td><td>LWG</td><td>Make future_error Constructible</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0521R0">P0521R0</a></td><td>LWG</td><td>Proposed Resolution for CA 14 (shared_ptr use_count/unique)</td><td>Issaquah</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
+	<tr><td><a href="https://wg21.link/P0003R5">P0003R5</a></td><td>LWG</td><td>Removing Deprecated Exception Specifications from C++17</td><td>Issaquah</td><td>Complete</td><td>5.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0067R5">P0067R5</a></td><td>LWG</td><td>Elementary string conversions, revision 5</td><td>Issaquah</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0403R1">P0403R1</a></td><td>LWG</td><td>Literal suffixes for <tt>basic_string_view</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0414R2">P0414R2</a></td><td>LWG</td><td>Merging shared_ptr changes from Library Fundamentals to C++17</td><td>Issaquah</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0418R2">P0418R2</a></td><td>LWG</td><td>Fail or succeed: there is no atomic lattice</td><td>Issaquah</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0426R1">P0426R1</a></td><td>LWG</td><td>Constexpr for <tt>std::char_traits</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0435R1">P0435R1</a></td><td>LWG</td><td>Resolving LWG Issues re <tt>common_type</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0502R0">P0502R0</a></td><td>LWG</td><td>Throwing out of a parallel algorithm terminates - but how?</td><td>Issaquah</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0503R0">P0503R0</a></td><td>LWG</td><td>Correcting library usage of "literal type"</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0504R0">P0504R0</a></td><td>LWG</td><td>Revisiting in-place tag types for any/optional/variant</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0505R0">P0505R0</a></td><td>LWG</td><td>Wording for GB 50 - constexpr for chrono</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0508R0">P0508R0</a></td><td>LWG</td><td>Wording for GB 58 - structured bindings for node_handles</td><td>Issaquah</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0509R1">P0509R1</a></td><td>LWG</td><td>Updating “Restrictions on exception handling”</td><td>Issaquah</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
+	<tr><td><a href="https://wg21.link/P0510R0">P0510R0</a></td><td>LWG</td><td>Disallowing references, incomplete types, arrays, and empty variants</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0513R0">P0513R0</a></td><td>LWG</td><td>Poisoning the Hash</td><td>Issaquah</td><td>Complete</td><td>5.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0516R0">P0516R0</a></td><td>LWG</td><td>Clarify That shared_future’s Copy Operations have Wide Contracts</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0517R0">P0517R0</a></td><td>LWG</td><td>Make future_error Constructible</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0521R0">P0521R0</a></td><td>LWG</td><td>Proposed Resolution for CA 14 (shared_ptr use_count/unique)</td><td>Issaquah</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
   	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0156R2">P0156R2</a></td><td>LWG</td><td>Variadic Lock guard(rev 5)</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0270R3">P0270R3</a></td><td>CWG</td><td>Removing C dependencies from signal handler wording</td><td>Kona</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0298R3">P0298R3</a></td><td>CWG</td><td>A byte type definition</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0317R1">P0317R1</a></td><td>LWG</td><td>Directory Entry Caching for Filesystem</td><td>Kona</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0430R2">P0430R2</a></td><td>LWG</td><td>File system library on non-POSIX-like operating systems</td><td>Kona</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0433R2">P0433R2</a></td><td>LWG</td><td>Toward a resolution of US7 and US14: Integrating template deduction for class templates into the standard library</td><td>Kona</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0452R1">P0452R1</a></td><td>LWG</td><td>Unifying &lt;numeric&gt; Parallel Algorithms</td><td>Kona</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0467R2">P0467R2</a></td><td>LWG</td><td>Iterator Concerns for Parallel Algorithms</td><td>Kona</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0492R2">P0492R2</a></td><td>LWG</td><td>Proposed Resolution of C++17 National Body Comments for Filesystems</td><td>Kona</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0518R1">P0518R1</a></td><td>LWG</td><td>Allowing copies as arguments to function objects given to parallel algorithms in response to CH11</td><td>Kona</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0523R1">P0523R1</a></td><td>LWG</td><td>Wording for CH 10: Complexity of parallel algorithms</td><td>Kona</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0548R1">P0548R1</a></td><td>LWG</td><td>common_type and duration</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0558R1">P0558R1</a></td><td>LWG</td><td>Resolving atomic&lt;T&gt; named base class inconsistencies</td><td>Kona</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0574R1">P0574R1</a></td><td>LWG</td><td>Algorithm Complexity Constraints and Parallel Overloads</td><td>Kona</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0599R1">P0599R1</a></td><td>LWG</td><td>noexcept for hash functions</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
-	<tr><td><a href="http://wg21.link/P0604R0">P0604R0</a></td><td>LWG</td><td>Resolving GB 55, US 84, US 85, US 86</td><td>Kona</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0607R0">P0607R0</a></td><td>LWG</td><td>Inline Variables for the Standard Library</td><td>Kona</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0618R0">P0618R0</a></td><td>LWG</td><td>Deprecating &lt;codecvt&gt;</td><td>Kona</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0623R0">P0623R0</a></td><td>LWG</td><td>Final C++17 Parallel Algorithms Fixes</td><td>Kona</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0156R2">P0156R2</a></td><td>LWG</td><td>Variadic Lock guard(rev 5)</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0270R3">P0270R3</a></td><td>CWG</td><td>Removing C dependencies from signal handler wording</td><td>Kona</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0298R3">P0298R3</a></td><td>CWG</td><td>A byte type definition</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0317R1">P0317R1</a></td><td>LWG</td><td>Directory Entry Caching for Filesystem</td><td>Kona</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0430R2">P0430R2</a></td><td>LWG</td><td>File system library on non-POSIX-like operating systems</td><td>Kona</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0433R2">P0433R2</a></td><td>LWG</td><td>Toward a resolution of US7 and US14: Integrating template deduction for class templates into the standard library</td><td>Kona</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0452R1">P0452R1</a></td><td>LWG</td><td>Unifying &lt;numeric&gt; Parallel Algorithms</td><td>Kona</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0467R2">P0467R2</a></td><td>LWG</td><td>Iterator Concerns for Parallel Algorithms</td><td>Kona</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0492R2">P0492R2</a></td><td>LWG</td><td>Proposed Resolution of C++17 National Body Comments for Filesystems</td><td>Kona</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0518R1">P0518R1</a></td><td>LWG</td><td>Allowing copies as arguments to function objects given to parallel algorithms in response to CH11</td><td>Kona</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0523R1">P0523R1</a></td><td>LWG</td><td>Wording for CH 10: Complexity of parallel algorithms</td><td>Kona</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0548R1">P0548R1</a></td><td>LWG</td><td>common_type and duration</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0558R1">P0558R1</a></td><td>LWG</td><td>Resolving atomic&lt;T&gt; named base class inconsistencies</td><td>Kona</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0574R1">P0574R1</a></td><td>LWG</td><td>Algorithm Complexity Constraints and Parallel Overloads</td><td>Kona</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0599R1">P0599R1</a></td><td>LWG</td><td>noexcept for hash functions</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0604R0">P0604R0</a></td><td>LWG</td><td>Resolving GB 55, US 84, US 85, US 86</td><td>Kona</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0607R0">P0607R0</a></td><td>LWG</td><td>Inline Variables for the Standard Library</td><td>Kona</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0618R0">P0618R0</a></td><td>LWG</td><td>Deprecating &lt;codecvt&gt;</td><td>Kona</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0623R0">P0623R0</a></td><td>LWG</td><td>Final C++17 Parallel Algorithms Fixes</td><td>Kona</td><td></td><td></td></tr>
   	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0682R1">P0682R1</a></td><td>LWG</td><td>Repairing elementary string conversions</td><td>Toronto</td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/P0739R0">P0739R0</a></td><td>LWG</td><td>Some improvements to class template argument deduction integration into the standard library</td><td>Toronto</td><td>Complete</td><td>5.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0682R1">P0682R1</a></td><td>LWG</td><td>Repairing elementary string conversions</td><td>Toronto</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0739R0">P0739R0</a></td><td>LWG</td><td>Some improvements to class template argument deduction integration into the standard library</td><td>Toronto</td><td>Complete</td><td>5.0</td></tr>
 
 <!--  	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr> -->
   </table>
@@ -176,325 +177,326 @@
 <!--   <I>Note: "NAD" means that the issue was deemed "Not a defect"</I> -->
   <table id="issues" border="1">
 	<tr><th>Issue #</th><th>Issue Name</th><th>Meeting</th><th>Status</th></tr>
-	<tr><td><a href="http://wg21.link/LWG2016">2016</a></td><td>Allocators must be no-throw swappable</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2376">2118</td><td><code>unique_ptr</code> for array does not support cv qualification conversion of actual argument</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2170">2170</a></td><td>Aggregates cannot be <code>DefaultConstructible</code></td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2308">2308</td><td>Clarify container destructor requirements w.r.t. <code>std::array</code></td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2340">2340</a></td><td>Replacement allocation functions declared as inline</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2354">2354</a></td><td>Unnecessary copying when inserting into maps with braced-init syntax</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2377">2377</a></td><td><code>std::align</code> requirements overly strict</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2396">2396</a></td><td><code>underlying_type</code> doesn't say what to do for an incomplete enumeration type</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2399">2399</a></td><td><code>shared_ptr</code>'s constructor from <code>unique_ptr</code> should be constrained</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2400">2400</a></td><td><code>shared_ptr</code>'s <code>get_deleter()</code> should use <code>addressof()</code></td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2401">2401</a></td><td><code>std::function</code> needs more noexcept</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2404">2404</a></td><td><code>mismatch()</code>'s complexity needs to be updated</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2408">2408</a></td><td>SFINAE-friendly <code>common_type</code> / <code>iterator_traits</code> is missing in C++14</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2016">2016</a></td><td>Allocators must be no-throw swappable</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2376">2118</td><td><code>unique_ptr</code> for array does not support cv qualification conversion of actual argument</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2170">2170</a></td><td>Aggregates cannot be <code>DefaultConstructible</code></td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2308">2308</td><td>Clarify container destructor requirements w.r.t. <code>std::array</code></td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2340">2340</a></td><td>Replacement allocation functions declared as inline</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2354">2354</a></td><td>Unnecessary copying when inserting into maps with braced-init syntax</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2377">2377</a></td><td><code>std::align</code> requirements overly strict</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2396">2396</a></td><td><code>underlying_type</code> doesn't say what to do for an incomplete enumeration type</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2399">2399</a></td><td><code>shared_ptr</code>'s constructor from <code>unique_ptr</code> should be constrained</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2400">2400</a></td><td><code>shared_ptr</code>'s <code>get_deleter()</code> should use <code>addressof()</code></td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2401">2401</a></td><td><code>std::function</code> needs more noexcept</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2404">2404</a></td><td><code>mismatch()</code>'s complexity needs to be updated</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2408">2408</a></td><td>SFINAE-friendly <code>common_type</code> / <code>iterator_traits</code> is missing in C++14</td><td>Urbana</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2106">2106</td><td><code>move_iterator</code> wrapping iterators returning prvalues</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2129">2129</td><td>User specializations of <code>std::initializer_list</code></td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2212">2212</td><td><code>tuple_size</code> for <code>const pair</code> request <tuple> header</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2217">2217</td><td><code>operator==(sub_match, string)</code> slices on embedded '\0's</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2230">2230</td><td>"see below" for <code>initializer_list</code> constructors of unordered containers</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2233">2233</td><td><code>bad_function_call::what()</code> unhelpful</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2266">2266</td><td><code>vector</code> and <code>deque</code> have incorrect insert requirements</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2325">2325</td><td><code>minmax_element()</code>'s behavior differing from <code>max_element()</code>'s should be noted</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2361">2361</td><td>Apply 2299 resolution throughout library</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2365">2365</td><td>Missing noexcept in <code>shared_ptr::shared_ptr(nullptr_t)</code></td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2376">2376</td><td><code>bad_weak_ptr::what()</code> overspecified</td><td>Urbana</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2387">2387</td><td>More nested types that must be accessible and unambiguous</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2106">2106</td><td><code>move_iterator</code> wrapping iterators returning prvalues</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2129">2129</td><td>User specializations of <code>std::initializer_list</code></td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2212">2212</td><td><code>tuple_size</code> for <code>const pair</code> request <tuple> header</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2217">2217</td><td><code>operator==(sub_match, string)</code> slices on embedded '\0's</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2230">2230</td><td>"see below" for <code>initializer_list</code> constructors of unordered containers</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2233">2233</td><td><code>bad_function_call::what()</code> unhelpful</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2266">2266</td><td><code>vector</code> and <code>deque</code> have incorrect insert requirements</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2325">2325</td><td><code>minmax_element()</code>'s behavior differing from <code>max_element()</code>'s should be noted</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2361">2361</td><td>Apply 2299 resolution throughout library</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2365">2365</td><td>Missing noexcept in <code>shared_ptr::shared_ptr(nullptr_t)</code></td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2376">2376</td><td><code>bad_weak_ptr::what()</code> overspecified</td><td>Urbana</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2387">2387</td><td>More nested types that must be accessible and unambiguous</td><td>Urbana</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2059">2059</td><td>C++0x ambiguity problem with map::erase</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2063">2063</td><td>Contradictory requirements for string move assignment</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2076">2076</td><td>Bad CopyConstructible requirement in set constructors</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2160">2160</td><td>Unintended destruction ordering-specification of resize</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2168">2168</td><td>Inconsistent specification of uniform_real_distribution constructor</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2239">2239</td><td>min/max/minmax requirements</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2364">2364</td><td>deque and vector pop_back don't specify iterator invalidation requirements</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2369">2369</td><td>constexpr max(initializer_list) vs max_element</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2378">2378</td><td>Behaviour of standard exception types</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2403">2403</td><td>stof() should call strtof() and wcstof()</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2406">2406</td><td>negative_binomial_distribution should reject p == 1</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2407">2407</td><td>packaged_task(allocator_arg_t, const Allocator&, F&&) should neither be constrained nor explicit</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2411">2411</td><td>shared_ptr is only contextually convertible to bool</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2415">2415</td><td>Inconsistency between unique_ptr and shared_ptr</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2420">2420</td><td>function<void(ArgTypes...)> does not discard the return value of the target object</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2425">2425</td><td>operator delete(void*, size_t) doesn't invalidate pointers sufficiently</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2427">2427</td><td>Container adaptors as sequence containers, redux</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2428">2428</td><td>"External declaration" used without being defined</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2433">2433</td><td>uninitialized_copy()/etc. should tolerate overloaded operator&</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2434">2434</td><td>shared_ptr::use_count() is efficient</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2437">2437</td><td>iterator_traits::reference can and can't be void</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2438">2438</td><td>std::iterator inheritance shouldn't be mandated</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2439">2439</td><td>unique_copy() sometimes can't fall back to reading its output</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2440">2440</td><td>seed_seq::size() should be noexcept</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2442">2442</td><td>call_once() shouldn't DECAY_COPY()</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2448">2448</td><td>Non-normative Container destructor specification</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2454">2454</td><td>Add raw_storage_iterator::base() member</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2455">2455</td><td>Allocator default construction should be allowed to throw</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2458">2458</td><td>N3778 and new library deallocation signatures</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2459">2459</td><td>std::polar should require a non-negative rho</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2464">2464</td><td>try_emplace and insert_or_assign misspecified</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2467">2467</td><td>is_always_equal has slightly inconsistent default</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2470">2470</td><td>Allocator's destroy function should be allowed to fail to instantiate</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2482">2482</td><td>[c.strings] Table 73 mentions nonexistent functions</td><td>Lenexa</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2488">2488</td><td>Placeholders should be allowed and encouraged to be constexpr</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2059">2059</td><td>C++0x ambiguity problem with map::erase</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2063">2063</td><td>Contradictory requirements for string move assignment</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2076">2076</td><td>Bad CopyConstructible requirement in set constructors</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2160">2160</td><td>Unintended destruction ordering-specification of resize</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2168">2168</td><td>Inconsistent specification of uniform_real_distribution constructor</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2239">2239</td><td>min/max/minmax requirements</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2364">2364</td><td>deque and vector pop_back don't specify iterator invalidation requirements</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2369">2369</td><td>constexpr max(initializer_list) vs max_element</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2378">2378</td><td>Behaviour of standard exception types</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2403">2403</td><td>stof() should call strtof() and wcstof()</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2406">2406</td><td>negative_binomial_distribution should reject p == 1</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2407">2407</td><td>packaged_task(allocator_arg_t, const Allocator&, F&&) should neither be constrained nor explicit</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2411">2411</td><td>shared_ptr is only contextually convertible to bool</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2415">2415</td><td>Inconsistency between unique_ptr and shared_ptr</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2420">2420</td><td>function<void(ArgTypes...)> does not discard the return value of the target object</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2425">2425</td><td>operator delete(void*, size_t) doesn't invalidate pointers sufficiently</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2427">2427</td><td>Container adaptors as sequence containers, redux</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2428">2428</td><td>"External declaration" used without being defined</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2433">2433</td><td>uninitialized_copy()/etc. should tolerate overloaded operator&</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2434">2434</td><td>shared_ptr::use_count() is efficient</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2437">2437</td><td>iterator_traits::reference can and can't be void</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2438">2438</td><td>std::iterator inheritance shouldn't be mandated</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2439">2439</td><td>unique_copy() sometimes can't fall back to reading its output</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2440">2440</td><td>seed_seq::size() should be noexcept</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2442">2442</td><td>call_once() shouldn't DECAY_COPY()</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2448">2448</td><td>Non-normative Container destructor specification</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2454">2454</td><td>Add raw_storage_iterator::base() member</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2455">2455</td><td>Allocator default construction should be allowed to throw</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2458">2458</td><td>N3778 and new library deallocation signatures</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2459">2459</td><td>std::polar should require a non-negative rho</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2464">2464</td><td>try_emplace and insert_or_assign misspecified</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2467">2467</td><td>is_always_equal has slightly inconsistent default</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2470">2470</td><td>Allocator's destroy function should be allowed to fail to instantiate</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2482">2482</td><td>[c.strings] Table 73 mentions nonexistent functions</td><td>Lenexa</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2488">2488</td><td>Placeholders should be allowed and encouraged to be constexpr</td><td>Lenexa</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG1169">1169</a></td><td><tt>num_get</tt> not fully compatible with <tt>strto*</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2072">2072</a></td><td>Unclear wording about capacity of temporary buffers</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2101">2101</a></td><td>Some transformation types can produce impossible types</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2111">2111</a></td><td>Which <tt>unexpected</tt>&#47;<tt>terminate</tt> handler is called from the exception handling runtime?</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2119">2119</a></td><td>Missing <tt>hash</tt> specializations for extended integer types</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2127">2127</a></td><td>Move-construction with <tt>raw_storage_iterator</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2133">2133</a></td><td>Attitude to overloaded comma for iterators</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2156">2156</a></td><td>Unordered containers' <tt>reserve(n)</tt> reserves for <tt>n-1</tt> elements</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2218">2218</a></td><td>Unclear how containers use <tt>allocator_traits::construct()</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2219">2219</a></td><td><tt><i>INVOKE</i></tt>-ing a pointer to member with a <tt>reference_wrapper</tt> as the object expression</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2224">2224</a></td><td>Ambiguous status of access to non-live objects</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2234">2234</a></td><td><tt>assert()</tt> should allow usage in constant expressions</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2244">2244</a></td><td>Issue on <tt>basic_istream::seekg</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2250">2250</a></td><td>Follow-up On Library Issue 2207</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2259">2259</a></td><td>Issues in 17.6.5.5 rules for member functions</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2273">2273</a></td><td><tt>regex_match</tt> ambiguity</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2336">2336</a></td><td><tt>is_trivially_constructible/is_trivially_assignable</tt> traits are always false</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2353">2353</a></td><td><tt>std::next</tt> is over-constrained</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2367">2367</a></td><td><tt>pair</tt> and <tt>tuple</tt> are not correctly implemented for <tt>is_constructible</tt> with no args</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2380">2380</a></td><td>May <tt>&lt;cstdlib&gt;</tt> provide <tt>long ::abs(long)</tt> and <tt>long long ::abs(long long)</tt>?</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2384">2384</a></td><td>Allocator's <tt>deallocate</tt> function needs better specification</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2385">2385</a></td><td><tt>function::assign</tt> allocator argument doesn't make sense</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2435">2435</a></td><td><tt>reference_wrapper::operator()</tt>'s Remark should be deleted</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2447">2447</a></td><td>Allocators and <tt>volatile</tt>-qualified value types</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2462">2462</a></td><td><tt>std::ios_base::failure</tt> is overspecified</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2466">2466</a></td><td><tt>allocator_traits::max_size()</tt> default behavior is incorrect</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2469">2469</a></td><td>Wrong specification of Requires clause of <tt>operator[]</tt> for <tt>map</tt> and <tt>unordered_map</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2473">2473</a></td><td><tt>basic_filebuf</tt>'s relation to C <tt>FILE</tt> semantics</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2476">2476</a></td><td><tt>scoped_allocator_adaptor</tt> is not assignable</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2477">2477</a></td><td>Inconsistency of wordings in <tt>std::vector::erase()</tt> and <tt>std::deque::erase()</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2483">2483</a></td><td><tt>throw_with_nested()</tt> should use <tt>is_final</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2484">2484</a></td><td><tt>rethrow_if_nested()</tt> is doubly unimplementable</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2485">2485</a></td><td><tt>get()</tt> should be overloaded for <tt>const tuple&amp;&amp;</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2486">2486</a></td><td><tt>mem_fn()</tt> should be required to use perfect forwarding</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2487">2487</a></td><td><tt>bind()</tt> should be <tt>const</tt>-overloaded, not <i>cv</i>-overloaded</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2489">2489</a></td><td><tt>mem_fn()</tt> should be <tt>noexcept</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2492">2492</a></td><td>Clarify requirements for <tt>comp</tt></td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2495">2495</a></td><td>There is no such thing as an Exception Safety element</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG1169">1169</a></td><td><tt>num_get</tt> not fully compatible with <tt>strto*</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2072">2072</a></td><td>Unclear wording about capacity of temporary buffers</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2101">2101</a></td><td>Some transformation types can produce impossible types</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2111">2111</a></td><td>Which <tt>unexpected</tt>&#47;<tt>terminate</tt> handler is called from the exception handling runtime?</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2119">2119</a></td><td>Missing <tt>hash</tt> specializations for extended integer types</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2127">2127</a></td><td>Move-construction with <tt>raw_storage_iterator</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2133">2133</a></td><td>Attitude to overloaded comma for iterators</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2156">2156</a></td><td>Unordered containers' <tt>reserve(n)</tt> reserves for <tt>n-1</tt> elements</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2218">2218</a></td><td>Unclear how containers use <tt>allocator_traits::construct()</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2219">2219</a></td><td><tt><i>INVOKE</i></tt>-ing a pointer to member with a <tt>reference_wrapper</tt> as the object expression</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2224">2224</a></td><td>Ambiguous status of access to non-live objects</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2234">2234</a></td><td><tt>assert()</tt> should allow usage in constant expressions</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2244">2244</a></td><td>Issue on <tt>basic_istream::seekg</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2250">2250</a></td><td>Follow-up On Library Issue 2207</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2259">2259</a></td><td>Issues in 17.6.5.5 rules for member functions</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2273">2273</a></td><td><tt>regex_match</tt> ambiguity</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2336">2336</a></td><td><tt>is_trivially_constructible/is_trivially_assignable</tt> traits are always false</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2353">2353</a></td><td><tt>std::next</tt> is over-constrained</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2367">2367</a></td><td><tt>pair</tt> and <tt>tuple</tt> are not correctly implemented for <tt>is_constructible</tt> with no args</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2380">2380</a></td><td>May <tt>&lt;cstdlib&gt;</tt> provide <tt>long ::abs(long)</tt> and <tt>long long ::abs(long long)</tt>?</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2384">2384</a></td><td>Allocator's <tt>deallocate</tt> function needs better specification</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2385">2385</a></td><td><tt>function::assign</tt> allocator argument doesn't make sense</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2435">2435</a></td><td><tt>reference_wrapper::operator()</tt>'s Remark should be deleted</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2447">2447</a></td><td>Allocators and <tt>volatile</tt>-qualified value types</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2462">2462</a></td><td><tt>std::ios_base::failure</tt> is overspecified</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2466">2466</a></td><td><tt>allocator_traits::max_size()</tt> default behavior is incorrect</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2469">2469</a></td><td>Wrong specification of Requires clause of <tt>operator[]</tt> for <tt>map</tt> and <tt>unordered_map</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2473">2473</a></td><td><tt>basic_filebuf</tt>'s relation to C <tt>FILE</tt> semantics</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2476">2476</a></td><td><tt>scoped_allocator_adaptor</tt> is not assignable</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2477">2477</a></td><td>Inconsistency of wordings in <tt>std::vector::erase()</tt> and <tt>std::deque::erase()</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2483">2483</a></td><td><tt>throw_with_nested()</tt> should use <tt>is_final</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2484">2484</a></td><td><tt>rethrow_if_nested()</tt> is doubly unimplementable</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2485">2485</a></td><td><tt>get()</tt> should be overloaded for <tt>const tuple&amp;&amp;</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2486">2486</a></td><td><tt>mem_fn()</tt> should be required to use perfect forwarding</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2487">2487</a></td><td><tt>bind()</tt> should be <tt>const</tt>-overloaded, not <i>cv</i>-overloaded</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2489">2489</a></td><td><tt>mem_fn()</tt> should be <tt>noexcept</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2492">2492</a></td><td>Clarify requirements for <tt>comp</tt></td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2495">2495</a></td><td>There is no such thing as an Exception Safety element</td><td>Kona</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2192">2192</a></td><td>Validity and return type of <tt>std::abs(0u)</tt> is unclear</td><td>Jacksonville</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2276">2276</a></td><td>Missing requirement on <tt>std::promise::set_exception</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2296">2296</a></td><td><tt>std::addressof</tt> should be <tt>constexpr</td><td>Jacksonville</td><td>Complete (Clang Only)</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2450">2450</a></td><td><tt>(greater|less|greater_equal|less_equal)&lt;void&gt;</tt> do not yield a total order for pointers</td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2520">2520</a></td><td>N4089 broke initializing <tt>unique_ptr&lt;T[]&gt;</tt> from a <tt>nullptr</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2522">2522</a></td><td>[fund.ts.v2] Contradiction in <tt>set_default_resource</tt> specification</td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2523">2523</a></td><td><tt>std::promise</tt> synopsis shows two <tt>set_value_at_thread_exit()</tt>'s for no apparent reason</td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2537">2537</a></td><td>Constructors for <code>priority_queue</code> taking allocators should call <code>make_heap</code></td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2539">2539</a></td><td>[fund.ts.v2] <tt>invocation_trait</tt> definition definition doesn't work for surrogate call functions</td><td>Jacksonville</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2545">2545</a></td><td>Simplify wording for <tt>bind</tt> without explicitly specified return type</td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2557">2557</a></td><td>Logical operator traits are broken in the zero-argument case</td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2558">2558</a></td><td>[fund.ts.v2] Logical operator traits are broken in the zero-argument case</td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2559">2559</a></td><td>Error in LWG 2234's resolution</td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2560">2560</a></td><td><tt>is_constructible</tt> underspecified when applied to a function type</td><td>Jacksonville</td><td>Broken in 3.6; See r261653.</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2565">2565</a></td><td><tt>std::function</tt>'s move constructor should guarantee nothrow for <tt>reference_wrapper</tt>s and function pointers</td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2566">2566</a></td><td>Requirements on the first template parameter of container adaptors</td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2571">2571</a></td><td>&sect;[map.modifiers]/2 imposes nonsensical requirement on <tt>insert(InputIterator, InputIterator)</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2572">2572</a></td><td>The remarks for <tt>shared_ptr::operator*</tt> should apply to <i>cv</i>-qualified <tt>void</tt> as well</td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2574">2574</a></td><td>[fund.ts.v2] <tt>std::experimental::function::operator=(F&amp;&amp;)</tt> should be constrained</td><td>Jacksonville</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2575">2575</a></td><td>[fund.ts.v2] <tt>experimental::function::assign</tt> should be removed</td><td>Jacksonville</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2576">2576</a></td><td><tt>istream_iterator</tt> and <tt>ostream_iterator</tt> should use <tt>std::addressof</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2577">2577</a></td><td><tt>{shared,unique}_lock</tt> should use <tt>std::addressof</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2579">2579</a></td><td>Inconsistency wrt Allocators in <tt>basic_string</tt> assignment vs. <tt>basic_string::assign</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2581">2581</a></td><td>Specialization of <tt>&lt;type_traits&gt;</tt> variable templates should be prohibited</td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2582">2582</a></td><td>&sect;[res.on.functions]/2's prohibition against incomplete types shouldn't apply to type traits</td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2583">2583</a></td><td>There is no way to supply an allocator for <tt>basic_string(str, pos)</tt></td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2585">2585</a></td><td><tt>forward_list::resize(size_type, const value_type&amp;)</tt> effects incorrect</td><td>Jacksonville</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2586">2586</a></td><td>Wrong value category used in <tt>scoped_allocator_adaptor::construct()</tt></td><td>Jacksonville</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2590">2590</a></td><td>Aggregate initialization for <tt>std::array</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2192">2192</a></td><td>Validity and return type of <tt>std::abs(0u)</tt> is unclear</td><td>Jacksonville</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2276">2276</a></td><td>Missing requirement on <tt>std::promise::set_exception</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2296">2296</a></td><td><tt>std::addressof</tt> should be <tt>constexpr</td><td>Jacksonville</td><td>Complete (Clang Only)</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2450">2450</a></td><td><tt>(greater|less|greater_equal|less_equal)&lt;void&gt;</tt> do not yield a total order for pointers</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2520">2520</a></td><td>N4089 broke initializing <tt>unique_ptr&lt;T[]&gt;</tt> from a <tt>nullptr</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2522">2522</a></td><td>[fund.ts.v2] Contradiction in <tt>set_default_resource</tt> specification</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2523">2523</a></td><td><tt>std::promise</tt> synopsis shows two <tt>set_value_at_thread_exit()</tt>'s for no apparent reason</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2537">2537</a></td><td>Constructors for <code>priority_queue</code> taking allocators should call <code>make_heap</code></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2539">2539</a></td><td>[fund.ts.v2] <tt>invocation_trait</tt> definition definition doesn't work for surrogate call functions</td><td>Jacksonville</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2545">2545</a></td><td>Simplify wording for <tt>bind</tt> without explicitly specified return type</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2557">2557</a></td><td>Logical operator traits are broken in the zero-argument case</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2558">2558</a></td><td>[fund.ts.v2] Logical operator traits are broken in the zero-argument case</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2559">2559</a></td><td>Error in LWG 2234's resolution</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2560">2560</a></td><td><tt>is_constructible</tt> underspecified when applied to a function type</td><td>Jacksonville</td><td>Broken in 3.6; See r261653.</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2565">2565</a></td><td><tt>std::function</tt>'s move constructor should guarantee nothrow for <tt>reference_wrapper</tt>s and function pointers</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2566">2566</a></td><td>Requirements on the first template parameter of container adaptors</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2571">2571</a></td><td>&sect;[map.modifiers]/2 imposes nonsensical requirement on <tt>insert(InputIterator, InputIterator)</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2572">2572</a></td><td>The remarks for <tt>shared_ptr::operator*</tt> should apply to <i>cv</i>-qualified <tt>void</tt> as well</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2574">2574</a></td><td>[fund.ts.v2] <tt>std::experimental::function::operator=(F&amp;&amp;)</tt> should be constrained</td><td>Jacksonville</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2575">2575</a></td><td>[fund.ts.v2] <tt>experimental::function::assign</tt> should be removed</td><td>Jacksonville</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2576">2576</a></td><td><tt>istream_iterator</tt> and <tt>ostream_iterator</tt> should use <tt>std::addressof</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2577">2577</a></td><td><tt>{shared,unique}_lock</tt> should use <tt>std::addressof</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2579">2579</a></td><td>Inconsistency wrt Allocators in <tt>basic_string</tt> assignment vs. <tt>basic_string::assign</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2581">2581</a></td><td>Specialization of <tt>&lt;type_traits&gt;</tt> variable templates should be prohibited</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2582">2582</a></td><td>&sect;[res.on.functions]/2's prohibition against incomplete types shouldn't apply to type traits</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2583">2583</a></td><td>There is no way to supply an allocator for <tt>basic_string(str, pos)</tt></td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2585">2585</a></td><td><tt>forward_list::resize(size_type, const value_type&amp;)</tt> effects incorrect</td><td>Jacksonville</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2586">2586</a></td><td>Wrong value category used in <tt>scoped_allocator_adaptor::construct()</tt></td><td>Jacksonville</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2590">2590</a></td><td>Aggregate initialization for <tt>std::array</tt></td><td>Jacksonville</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2181">2181</a></td><td>Exceptions from seed sequence operations</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2309">2309</a></td><td>mutex::lock() should not throw device_or_resource_busy</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2310">2310</a></td><td>Public exposition only member in std::array</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2312">2312</a></td><td>tuple's constructor constraints need to be phrased more precisely</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2328">2328</a></td><td>Rvalue stream extraction should use perfect forwarding</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2393">2393</a></td><td>std::function's Callable definition is broken</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2422">2422</a></td><td>std::numeric_limits&lt;T&gt;::is_modulo description: "most machines" errata</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2426">2426</a></td><td>Issue about compare_exchange</td><td>Oulu</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2436">2436</a></td><td>Comparators for associative containers should always be CopyConstructible</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2441">2441</a></td><td>Exact-width atomic typedefs should be provided</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2451">2451</a></td><td>[fund.ts.v2] optional should 'forward' T's implicit conversions</td><td>Oulu</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2509">2509</a></td><td>[fund.ts.v2] any_cast doesn't work with rvalue reference targets and cannot move with a value target</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2516">2516</a></td><td>[fund.ts.v2] Public "exposition only" members in observer_ptr</td><td>Oulu</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2542">2542</a></td><td>Missing const requirements for associative containers</td><td>Oulu</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2549">2549</a></td><td>Tuple EXPLICIT constructor templates that take tuple parameters end up taking references to temporaries and will create dangling references</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2550">2550</a></td><td>Wording of unordered container's clear() method complexity</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2551">2551</a></td><td>[fund.ts.v2] "Exception safety" cleanup in library fundamentals required</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2555">2555</a></td><td>[fund.ts.v2] No handling for over-aligned types in optional</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2573">2573</a></td><td>[fund.ts.v2] std::hash&lt;std::experimental::shared_ptr&gt; does not work for arrays</td><td>Oulu</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2596">2596</a></td><td>vector::data() should use addressof</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2667">2667</a></td><td>path::root_directory() description is confusing</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2669">2669</a></td><td>recursive_directory_iterator effects refers to non-existent functions</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2670">2670</a></td><td>system_complete refers to undefined variable 'base'</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2671">2671</a></td><td>Errors in Copy</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2673">2673</a></td><td>status() effects cannot be implemented as specified</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2674">2674</a></td><td>Bidirectional iterator requirement on path::iterator is very expensive</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2683">2683</a></td><td>filesystem::copy() says "no effects"</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2684">2684</a></td><td>priority_queue lacking comparator typedef</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2685">2685</a></td><td>shared_ptr deleters must not throw on move construction</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2687">2687</a></td><td>{inclusive,exclusive}_scan misspecified</td><td>Oulu</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2688">2688</a></td><td>clamp misses preconditions and has extraneous condition on result</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2689">2689</a></td><td>Parallel versions of std::copy and std::move shouldn't be in order</td><td>Oulu</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2698">2698</a></td><td>Effect of assign() on iterators/pointers/references</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2704">2704</a></td><td>recursive_directory_iterator's members should require '*this is dereferenceable'</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2706">2706</a></td><td>Error reporting for recursive_directory_iterator::pop() is under-specified</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2707">2707</a></td><td>path construction and assignment should have "string_type&&" overloads</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2709">2709</a></td><td>offsetof is unnecessarily imprecise</td><td>Oulu</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2710">2710</a></td><td>"Effects: Equivalent to ..." doesn't count "Synchronization:" as determined semantics</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2711">2711</a></td><td>path is convertible from approximately everything under the sun</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2716">2716</a></td><td>Specification of shuffle and sample disallows lvalue URNGs</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2718">2718</a></td><td>Parallelism bug in [algorithms.parallel.exec] p2</td><td>Oulu</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2719">2719</a></td><td>permissions function should not be noexcept due to narrow contract</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2720">2720</a></td><td>permissions function incorrectly specified for symlinks</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2721">2721</a></td><td>remove_all has incorrect post conditions</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2723">2723</a></td><td>Do directory_iterator and recursive_directory_iterator become the end iterator upon error?</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2724">2724</a></td><td>The protected virtual member functions of memory_resource should be private</td><td>Oulu</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2725">2725</a></td><td>filesystem::exists(const path&, error_code&) error reporting</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2726">2726</a></td><td>[recursive_]directory_iterator::increment(error_code&) is underspecified</td><td>Oulu</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2727">2727</a></td><td>Parallel algorithms with constexpr specifier</td><td>Oulu</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2728">2728</a></td><td>status(p).permissions() and symlink_status(p).permissions() are not specified</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2181">2181</a></td><td>Exceptions from seed sequence operations</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2309">2309</a></td><td>mutex::lock() should not throw device_or_resource_busy</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2310">2310</a></td><td>Public exposition only member in std::array</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2312">2312</a></td><td>tuple's constructor constraints need to be phrased more precisely</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2328">2328</a></td><td>Rvalue stream extraction should use perfect forwarding</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2393">2393</a></td><td>std::function's Callable definition is broken</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2422">2422</a></td><td>std::numeric_limits&lt;T&gt;::is_modulo description: "most machines" errata</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2426">2426</a></td><td>Issue about compare_exchange</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2436">2436</a></td><td>Comparators for associative containers should always be CopyConstructible</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2441">2441</a></td><td>Exact-width atomic typedefs should be provided</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2451">2451</a></td><td>[fund.ts.v2] optional should 'forward' T's implicit conversions</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2509">2509</a></td><td>[fund.ts.v2] any_cast doesn't work with rvalue reference targets and cannot move with a value target</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2516">2516</a></td><td>[fund.ts.v2] Public "exposition only" members in observer_ptr</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2542">2542</a></td><td>Missing const requirements for associative containers</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2549">2549</a></td><td>Tuple EXPLICIT constructor templates that take tuple parameters end up taking references to temporaries and will create dangling references</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2550">2550</a></td><td>Wording of unordered container's clear() method complexity</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2551">2551</a></td><td>[fund.ts.v2] "Exception safety" cleanup in library fundamentals required</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2555">2555</a></td><td>[fund.ts.v2] No handling for over-aligned types in optional</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2573">2573</a></td><td>[fund.ts.v2] std::hash&lt;std::experimental::shared_ptr&gt; does not work for arrays</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2596">2596</a></td><td>vector::data() should use addressof</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2667">2667</a></td><td>path::root_directory() description is confusing</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2669">2669</a></td><td>recursive_directory_iterator effects refers to non-existent functions</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2670">2670</a></td><td>system_complete refers to undefined variable 'base'</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2671">2671</a></td><td>Errors in Copy</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2673">2673</a></td><td>status() effects cannot be implemented as specified</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2674">2674</a></td><td>Bidirectional iterator requirement on path::iterator is very expensive</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2683">2683</a></td><td>filesystem::copy() says "no effects"</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2684">2684</a></td><td>priority_queue lacking comparator typedef</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2685">2685</a></td><td>shared_ptr deleters must not throw on move construction</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2687">2687</a></td><td>{inclusive,exclusive}_scan misspecified</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2688">2688</a></td><td>clamp misses preconditions and has extraneous condition on result</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2689">2689</a></td><td>Parallel versions of std::copy and std::move shouldn't be in order</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2698">2698</a></td><td>Effect of assign() on iterators/pointers/references</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2704">2704</a></td><td>recursive_directory_iterator's members should require '*this is dereferenceable'</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2706">2706</a></td><td>Error reporting for recursive_directory_iterator::pop() is under-specified</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2707">2707</a></td><td>path construction and assignment should have "string_type&&" overloads</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2709">2709</a></td><td>offsetof is unnecessarily imprecise</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2710">2710</a></td><td>"Effects: Equivalent to ..." doesn't count "Synchronization:" as determined semantics</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2711">2711</a></td><td>path is convertible from approximately everything under the sun</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2716">2716</a></td><td>Specification of shuffle and sample disallows lvalue URNGs</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2718">2718</a></td><td>Parallelism bug in [algorithms.parallel.exec] p2</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2719">2719</a></td><td>permissions function should not be noexcept due to narrow contract</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2720">2720</a></td><td>permissions function incorrectly specified for symlinks</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2721">2721</a></td><td>remove_all has incorrect post conditions</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2723">2723</a></td><td>Do directory_iterator and recursive_directory_iterator become the end iterator upon error?</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2724">2724</a></td><td>The protected virtual member functions of memory_resource should be private</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2725">2725</a></td><td>filesystem::exists(const path&, error_code&) error reporting</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2726">2726</a></td><td>[recursive_]directory_iterator::increment(error_code&) is underspecified</td><td>Oulu</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2727">2727</a></td><td>Parallel algorithms with constexpr specifier</td><td>Oulu</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2728">2728</a></td><td>status(p).permissions() and symlink_status(p).permissions() are not specified</td><td>Oulu</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2062">2062</a></td><td>Effect contradictions w/o no-throw guarantee of std::function swaps</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2166">2166</a></td><td>Heap property underspecified?</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2221">2221</a></td><td>No formatted output operator for nullptr</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2223">2223</a></td><td>shrink_to_fit effect on iterator validity</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2261">2261</a></td><td>Are containers required to use their 'pointer' type internally?</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2394">2394</a></td><td>locale::name specification unclear - what is implementation-defined?</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2460">2460</a></td><td>LWG issue 2408 and value categories</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2468">2468</a></td><td>Self-move-assignment of library types</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2475">2475</a></td><td>Allow overwriting of std::basic_string terminator with charT() to allow cleaner interoperation with legacy APIs</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2503">2503</a></td><td>multiline option should be added to syntax_option_type</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2510">2510</a></td><td>Tag types should not be DefaultConstructible</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2514">2514</a></td><td>Type traits must not be final</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2518">2518</a></td><td>[fund.ts.v2] Non-member swap for propagate_const should call member swap</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2519">2519</a></td><td>Iterator operator-= has gratuitous undefined behaviour</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2521">2521</a></td><td>[fund.ts.v2] weak_ptr's converting move constructor should be modified as well for array support</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2525">2525</a></td><td>[fund.ts.v2] get_memory_resource should be const and noexcept</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2527">2527</a></td><td>[fund.ts.v2] ALLOCATOR_OF for function::operator= has incorrect default</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2531">2531</a></td><td>future::get should explicitly state that the shared state is released</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2534">2534</a></td><td>Constrain rvalue stream operators</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2536">2536</a></td><td>What should &lt;complex.h&gt; do?</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2540">2540</a></td><td>unordered_multimap::insert hint iterator</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2543">2543</a></td><td>LWG 2148 (hash support for enum types) seems under-specified</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2544">2544</a></td><td>istreambuf_iterator(basic_streambuf<charT, traits>* s) effects unclear when s is 0</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2556">2556</a></td><td>Wide contract for future::share()</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2562">2562</a></td><td>Consistent total ordering of pointers by comparison functors</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2567">2567</a></td><td>Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2568">2568</a></td><td>[fund.ts.v2] Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2569">2569</a></td><td>conjunction and disjunction requirements are too strict</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2570">2570</a></td><td>[fund.ts.v2] conjunction and disjunction requirements are too strict</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2578">2578</a></td><td>Iterator requirements should reference iterator traits</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2584">2584</a></td><td><regex> ECMAScript IdentityEscape is ambiguous</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2588">2588</a></td><td>[fund.ts.v2] "Convertible to bool" requirement in conjunction and disjunction</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2589">2589</a></td><td>match_results can't satisfy the requirements of a container</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2591">2591</a></td><td>std::function's member template target() should not lead to undefined behaviour</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2598">2598</a></td><td>addressof works on temporaries</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2664">2664</a></td><td>operator/ (and other append) semantics not useful if argument has root</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2665">2665</a></td><td>remove_filename() post condition is incorrect</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2672">2672</a></td><td>Should is_empty use error_code in its specification?</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2678">2678</a></td><td>std::filesystem enum classes overspecified</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2679">2679</a></td><td>Inconsistent Use of Effects and Equivalent To</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2680">2680</a></td><td>Add "Equivalent to" to filesystem</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2681">2681</a></td><td>filesystem::copy() cannot copy symlinks</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2682">2682</a></td><td>filesystem::copy() won't create a symlink to a directory</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2686">2686</a></td><td>Why is std::hash specialized for error_code, but not error_condition?</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2694">2694</a></td><td>Application of LWG 436 accidentally deleted definition of "facet"</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2696">2696</a></td><td>Interaction between make_shared and enable_shared_from_this is underspecified</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2699">2699</a></td><td>Missing restriction in [numeric.requirements]</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2712">2712</a></td><td>copy_file(from, to, ...) has a number of unspecified error conditions</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2722">2722</a></td><td>equivalent incorrectly specifies throws clause</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2729">2729</a></td><td>Missing SFINAE on std::pair::operator=</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2732">2732</a></td><td>Questionable specification of path::operator/= and path::append</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2733">2733</a></td><td>[fund.ts.v2] gcd / lcm and bool</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2735">2735</a></td><td>std::abs(short), std::abs(signed char) and others should return int instead of double in order to be compatible with C++98 and C</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2736">2736</a></td><td>nullopt_t insufficiently constrained</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2738">2738</a></td><td>is_constructible with void types</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2739">2739</a></td><td>Issue with time_point non-member subtraction with an unsigned duration</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2740">2740</a></td><td>constexpr optional<T>::operator-></td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2742">2742</a></td><td>Inconsistent string interface taking string_view</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2744">2744</a></td><td>any's in_place constructors</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2745">2745</a></td><td>[fund.ts.v2] Implementability of LWG 2451</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2747">2747</a></td><td>Possibly redundant std::move in [alg.foreach]</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2748">2748</a></td><td>swappable traits for optionals</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2749">2749</a></td><td>swappable traits for variants</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2750">2750</a></td><td>[fund.ts.v2] LWG 2451 conversion constructor constraint</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2752">2752</a></td><td>"Throws:" clauses of async and packaged_task are unimplementable</td><td>Issaquah</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2755">2755</a></td><td>[string.view.io] uses non-existent basic_string_view::to_string function</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2756">2756</a></td><td>C++ WP optional<T> should 'forward' T's implicit conversions</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2758">2758</a></td><td>std::string{}.assign("ABCDE", 0, 1) is ambiguous</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2759">2759</a></td><td>gcd / lcm and bool for the WP</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2760">2760</a></td><td>non-const basic_string::data should not invalidate iterators</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2765">2765</a></td><td>Did LWG 1123 go too far?</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2767">2767</a></td><td>not_fn call_wrapper can form invalid types</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2769">2769</a></td><td>Redundant const in the return type of any_cast(const any&)</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2771">2771</a></td><td>Broken Effects of some basic_string::compare functions in terms of basic_string_view</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2773">2773</a></td><td>Making std::ignore constexpr</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2777">2777</a></td><td>basic_string_view::copy should use char_traits::copy</td><td>Issaquah</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2778">2778</a></td><td>basic_string_view is missing constexpr</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2062">2062</a></td><td>Effect contradictions w/o no-throw guarantee of std::function swaps</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2166">2166</a></td><td>Heap property underspecified?</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2221">2221</a></td><td>No formatted output operator for nullptr</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2223">2223</a></td><td>shrink_to_fit effect on iterator validity</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2261">2261</a></td><td>Are containers required to use their 'pointer' type internally?</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2394">2394</a></td><td>locale::name specification unclear - what is implementation-defined?</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2460">2460</a></td><td>LWG issue 2408 and value categories</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2468">2468</a></td><td>Self-move-assignment of library types</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2475">2475</a></td><td>Allow overwriting of std::basic_string terminator with charT() to allow cleaner interoperation with legacy APIs</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2503">2503</a></td><td>multiline option should be added to syntax_option_type</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2510">2510</a></td><td>Tag types should not be DefaultConstructible</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2514">2514</a></td><td>Type traits must not be final</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2518">2518</a></td><td>[fund.ts.v2] Non-member swap for propagate_const should call member swap</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2519">2519</a></td><td>Iterator operator-= has gratuitous undefined behaviour</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2521">2521</a></td><td>[fund.ts.v2] weak_ptr's converting move constructor should be modified as well for array support</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2525">2525</a></td><td>[fund.ts.v2] get_memory_resource should be const and noexcept</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2527">2527</a></td><td>[fund.ts.v2] ALLOCATOR_OF for function::operator= has incorrect default</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2531">2531</a></td><td>future::get should explicitly state that the shared state is released</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2534">2534</a></td><td>Constrain rvalue stream operators</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2536">2536</a></td><td>What should &lt;complex.h&gt; do?</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2540">2540</a></td><td>unordered_multimap::insert hint iterator</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2543">2543</a></td><td>LWG 2148 (hash support for enum types) seems under-specified</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2544">2544</a></td><td>istreambuf_iterator(basic_streambuf<charT, traits>* s) effects unclear when s is 0</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2556">2556</a></td><td>Wide contract for future::share()</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2562">2562</a></td><td>Consistent total ordering of pointers by comparison functors</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2567">2567</a></td><td>Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2568">2568</a></td><td>[fund.ts.v2] Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2569">2569</a></td><td>conjunction and disjunction requirements are too strict</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2570">2570</a></td><td>[fund.ts.v2] conjunction and disjunction requirements are too strict</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2578">2578</a></td><td>Iterator requirements should reference iterator traits</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2584">2584</a></td><td><regex> ECMAScript IdentityEscape is ambiguous</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2587">2587</a></td><td>"Convertible to bool" requirement in conjunction and disjunction</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2588">2588</a></td><td>[fund.ts.v2] "Convertible to bool" requirement in conjunction and disjunction</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2589">2589</a></td><td>match_results can't satisfy the requirements of a container</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2591">2591</a></td><td>std::function's member template target() should not lead to undefined behaviour</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2598">2598</a></td><td>addressof works on temporaries</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2664">2664</a></td><td>operator/ (and other append) semantics not useful if argument has root</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2665">2665</a></td><td>remove_filename() post condition is incorrect</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2672">2672</a></td><td>Should is_empty use error_code in its specification?</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2678">2678</a></td><td>std::filesystem enum classes overspecified</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2679">2679</a></td><td>Inconsistent Use of Effects and Equivalent To</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2680">2680</a></td><td>Add "Equivalent to" to filesystem</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2681">2681</a></td><td>filesystem::copy() cannot copy symlinks</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2682">2682</a></td><td>filesystem::copy() won't create a symlink to a directory</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2686">2686</a></td><td>Why is std::hash specialized for error_code, but not error_condition?</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2694">2694</a></td><td>Application of LWG 436 accidentally deleted definition of "facet"</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2696">2696</a></td><td>Interaction between make_shared and enable_shared_from_this is underspecified</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2699">2699</a></td><td>Missing restriction in [numeric.requirements]</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2712">2712</a></td><td>copy_file(from, to, ...) has a number of unspecified error conditions</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2722">2722</a></td><td>equivalent incorrectly specifies throws clause</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2729">2729</a></td><td>Missing SFINAE on std::pair::operator=</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2732">2732</a></td><td>Questionable specification of path::operator/= and path::append</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2733">2733</a></td><td>[fund.ts.v2] gcd / lcm and bool</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2735">2735</a></td><td>std::abs(short), std::abs(signed char) and others should return int instead of double in order to be compatible with C++98 and C</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2736">2736</a></td><td>nullopt_t insufficiently constrained</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2738">2738</a></td><td>is_constructible with void types</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2739">2739</a></td><td>Issue with time_point non-member subtraction with an unsigned duration</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2740">2740</a></td><td>constexpr optional<T>::operator-></td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2742">2742</a></td><td>Inconsistent string interface taking string_view</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2744">2744</a></td><td>any's in_place constructors</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2745">2745</a></td><td>[fund.ts.v2] Implementability of LWG 2451</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2747">2747</a></td><td>Possibly redundant std::move in [alg.foreach]</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2748">2748</a></td><td>swappable traits for optionals</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2749">2749</a></td><td>swappable traits for variants</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2750">2750</a></td><td>[fund.ts.v2] LWG 2451 conversion constructor constraint</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2752">2752</a></td><td>"Throws:" clauses of async and packaged_task are unimplementable</td><td>Issaquah</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2755">2755</a></td><td>[string.view.io] uses non-existent basic_string_view::to_string function</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2756">2756</a></td><td>C++ WP optional<T> should 'forward' T's implicit conversions</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2758">2758</a></td><td>std::string{}.assign("ABCDE", 0, 1) is ambiguous</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2759">2759</a></td><td>gcd / lcm and bool for the WP</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2760">2760</a></td><td>non-const basic_string::data should not invalidate iterators</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2765">2765</a></td><td>Did LWG 1123 go too far?</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2767">2767</a></td><td>not_fn call_wrapper can form invalid types</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2769">2769</a></td><td>Redundant const in the return type of any_cast(const any&)</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2771">2771</a></td><td>Broken Effects of some basic_string::compare functions in terms of basic_string_view</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2773">2773</a></td><td>Making std::ignore constexpr</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2777">2777</a></td><td>basic_string_view::copy should use char_traits::copy</td><td>Issaquah</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2778">2778</a></td><td>basic_string_view is missing constexpr</td><td>Issaquah</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2260">2260</a></td><td>Missing requirement for Allocator::pointer</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2676">2676</a></td><td>Provide filesystem::path overloads for File-based streams</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2768">2768</a></td><td>any_cast and move semantics</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2769">2769</a></td><td>Redundant const in the return type of any_cast(const any&amp;)</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2781">2781</a></td><td>Contradictory requirements for std::function and std::reference_wrapper</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2782">2782</a></td><td>scoped_allocator_adaptor constructors must be constrained</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2784">2784</a></td><td>Resolution to LWG 2484 is missing "otherwise, no effects" and is hard to parse</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2785">2785</a></td><td>quoted should work with basic_string_view</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2786">2786</a></td><td>Annex C should mention shared_ptr changes for array support</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2787">2787</a></td><td>&sect;[file_status.cons] doesn't match class definition</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2788">2788</a></td><td>basic_string range mutators unintentionally require a default constructible allocator</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2789">2789</a></td><td>Equivalence of contained objects</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2790">2790</a></td><td>Missing specification of istreambuf_iterator::operator-&gt;</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2794">2794</a></td><td>Missing requirements for allocator pointers</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2795">2795</a></td><td>&sect;[global.functions] provides incorrect example of ADL use</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2796">2796</a></td><td>tuple should be a literal type</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2801">2801</a></td><td>Default-constructibility of unique_ptr</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2802">2802</a></td><td>shared_ptr constructor requirements for a deleter</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2804">2804</a></td><td>Unconditional constexpr default constructor for istream_iterator</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2806">2806</a></td><td>Base class of bad_optional_access</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2807">2807</a></td><td>std::invoke should use std::is_nothrow_callable</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2812">2812</a></td><td>Range access is available with &lt;string_view&gt;</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2824">2824</a></td><td>list::sort should say that the order of elements is unspecified if an exception is thrown</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2826">2826</a></td><td>string_view iterators use old wording</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2834">2834</a></td><td>Resolution LWG 2223 is missing wording about end iterators</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2835">2835</a></td><td>LWG 2536 seems to misspecify &lt;tgmath.h&gt;</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2837">2837</a></td><td>gcd and lcm should support a wider range of input values</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2838">2838</a></td><td>is_literal_type specification needs a little cleanup</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2842">2842</a></td><td>in_place_t check for optional::optional(U&amp;&amp;) should decay U</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2850">2850</a></td><td>std::function move constructor does unnecessary work</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2853">2853</a></td><td>Possible inconsistency in specification of erase in [vector.modifiers]</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2855">2855</a></td><td>std::throw_with_nested("string_literal")</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2857">2857</a></td><td>{variant,optional,any}::emplace should return the constructed value</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2861">2861</a></td><td>basic_string should require that charT match traits::char_type</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2866">2866</a></td><td>Incorrect derived classes constraints</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2868">2868</a></td><td>Missing specification of bad_any_cast::what()</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2872">2872</a></td><td>Add definition for direct-non-list-initialization</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2873">2873</a></td><td>Add noexcept to several shared_ptr related functions</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2874">2874</a></td><td>Constructor shared_ptr::shared_ptr(Y*) should be constrained</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2875">2875</a></td><td>shared_ptr::shared_ptr(Y*, D, [&hellip;]) constructors should be constrained</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2876">2876</a></td><td>shared_ptr::shared_ptr(const weak_ptr&lt;Y&gt;&amp;) constructor should be constrained</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2878">2878</a></td><td>Missing DefaultConstructible requirement for istream_iterator default constructor</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2890">2890</a></td><td>The definition of 'object state' applies only to class types</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2900">2900</a></td><td>The copy and move constructors of optional are not constexpr</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2903">2903</a></td><td>The form of initialization for the emplace-constructors is not specified</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2904">2904</a></td><td>Make variant move-assignment more exception safe</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2905">2905</a></td><td>is_constructible_v&lt;unique_ptr&lt;P, D&gt;, P, D const &amp;&gt; should be false when D is not copy constructible</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2908">2908</a></td><td>The less-than operator for shared pointers could do more</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2911">2911</a></td><td>An is_aggregate type trait is needed</td><td>Kona</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2921">2921</a></td><td>packaged_task and type-erased allocators</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2934">2934</a></td><td>optional&lt;const T&gt; doesn't compare with T</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2260">2260</a></td><td>Missing requirement for Allocator::pointer</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2676">2676</a></td><td>Provide filesystem::path overloads for File-based streams</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2768">2768</a></td><td>any_cast and move semantics</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2769">2769</a></td><td>Redundant const in the return type of any_cast(const any&amp;)</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2781">2781</a></td><td>Contradictory requirements for std::function and std::reference_wrapper</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2782">2782</a></td><td>scoped_allocator_adaptor constructors must be constrained</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2784">2784</a></td><td>Resolution to LWG 2484 is missing "otherwise, no effects" and is hard to parse</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2785">2785</a></td><td>quoted should work with basic_string_view</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2786">2786</a></td><td>Annex C should mention shared_ptr changes for array support</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2787">2787</a></td><td>&sect;[file_status.cons] doesn't match class definition</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2788">2788</a></td><td>basic_string range mutators unintentionally require a default constructible allocator</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2789">2789</a></td><td>Equivalence of contained objects</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2790">2790</a></td><td>Missing specification of istreambuf_iterator::operator-&gt;</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2794">2794</a></td><td>Missing requirements for allocator pointers</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2795">2795</a></td><td>&sect;[global.functions] provides incorrect example of ADL use</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2796">2796</a></td><td>tuple should be a literal type</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2801">2801</a></td><td>Default-constructibility of unique_ptr</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2802">2802</a></td><td>shared_ptr constructor requirements for a deleter</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2804">2804</a></td><td>Unconditional constexpr default constructor for istream_iterator</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2806">2806</a></td><td>Base class of bad_optional_access</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2807">2807</a></td><td>std::invoke should use std::is_nothrow_callable</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2812">2812</a></td><td>Range access is available with &lt;string_view&gt;</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2824">2824</a></td><td>list::sort should say that the order of elements is unspecified if an exception is thrown</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2826">2826</a></td><td>string_view iterators use old wording</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2834">2834</a></td><td>Resolution LWG 2223 is missing wording about end iterators</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2835">2835</a></td><td>LWG 2536 seems to misspecify &lt;tgmath.h&gt;</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2837">2837</a></td><td>gcd and lcm should support a wider range of input values</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2838">2838</a></td><td>is_literal_type specification needs a little cleanup</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2842">2842</a></td><td>in_place_t check for optional::optional(U&amp;&amp;) should decay U</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2850">2850</a></td><td>std::function move constructor does unnecessary work</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2853">2853</a></td><td>Possible inconsistency in specification of erase in [vector.modifiers]</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2855">2855</a></td><td>std::throw_with_nested("string_literal")</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2857">2857</a></td><td>{variant,optional,any}::emplace should return the constructed value</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2861">2861</a></td><td>basic_string should require that charT match traits::char_type</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2866">2866</a></td><td>Incorrect derived classes constraints</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2868">2868</a></td><td>Missing specification of bad_any_cast::what()</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2872">2872</a></td><td>Add definition for direct-non-list-initialization</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2873">2873</a></td><td>Add noexcept to several shared_ptr related functions</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2874">2874</a></td><td>Constructor shared_ptr::shared_ptr(Y*) should be constrained</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2875">2875</a></td><td>shared_ptr::shared_ptr(Y*, D, [&hellip;]) constructors should be constrained</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2876">2876</a></td><td>shared_ptr::shared_ptr(const weak_ptr&lt;Y&gt;&amp;) constructor should be constrained</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2878">2878</a></td><td>Missing DefaultConstructible requirement for istream_iterator default constructor</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2890">2890</a></td><td>The definition of 'object state' applies only to class types</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2900">2900</a></td><td>The copy and move constructors of optional are not constexpr</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2903">2903</a></td><td>The form of initialization for the emplace-constructors is not specified</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2904">2904</a></td><td>Make variant move-assignment more exception safe</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2905">2905</a></td><td>is_constructible_v&lt;unique_ptr&lt;P, D&gt;, P, D const &amp;&gt; should be false when D is not copy constructible</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2908">2908</a></td><td>The less-than operator for shared pointers could do more</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2911">2911</a></td><td>An is_aggregate type trait is needed</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2921">2921</a></td><td>packaged_task and type-erased allocators</td><td>Kona</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2934">2934</a></td><td>optional&lt;const T&gt; doesn't compare with T</td><td>Kona</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2901">2901</a></td><td>Variants cannot properly support allocators</td><td>Toronto</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2955">2955</a></td><td><tt>to_chars / from_chars</tt> depend on <tt>std::string</tt></td><td>Toronto</td><td>Resolved by <a href="https://wg21.link/P0682R1">P0682R1</a></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2956">2956</a></td><td><tt>filesystem::canonical()</tt> still defined in terms of <tt>absolute(p, base)</tt></td><td>Toronto</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2901">2901</a></td><td>Variants cannot properly support allocators</td><td>Toronto</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2955">2955</a></td><td><tt>to_chars / from_chars</tt> depend on <tt>std::string</tt></td><td>Toronto</td><td>Resolved by <a href="https://wg21.link/P0682R1">P0682R1</a></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2956">2956</a></td><td><tt>filesystem::canonical()</tt> still defined in terms of <tt>absolute(p, base)</tt></td><td>Toronto</td><td>Complete</td></tr>
 
 <!--
-	<tr><td><a href="http://wg21.link/LWG1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Urbana</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Urbana</td><td></td></tr>
 -->
 <!-- 	<tr><td></td><td></td><td></td><td></td></tr> -->
   </table>
diff --git a/www/cxx2a_status.html b/www/cxx2a_status.html
index 7a17b784af98..1ff36a70e1e9 100644
--- a/www/cxx2a_status.html
+++ b/www/cxx2a_status.html
@@ -12,7 +12,7 @@
 <body>
 <div id="menu">
   <div>
-    <a href="http://llvm.org/">LLVM Home</a>
+    <a href="https://llvm.org/">LLVM Home</a>
   </div>
 
   <div class="submenu">
@@ -22,11 +22,11 @@
 
   <div class="submenu">
     <label>Quick Links</label>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="http://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
   </div>
 </div>
 
@@ -36,7 +36,7 @@
   <!--*********************************************************************-->
 
   <p>In July 2017, the C++ standard committee created a draft for the next version of the C++ standard, known here as "C++2a" (probably to be C++20).</p>
-  <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="http://clang.llvm.org/cxx_status.html#cxx2a">here</a>.</p>
+  <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="https://clang.llvm.org/cxx_status.html#cxx2a">here</a>.</p>
 
   <p>Reminder: Features in unreleased drafts of the standard are subject to change.</p>
 
@@ -52,36 +52,82 @@
   <table id="papers" border="1">
 	<tr><th>Paper #</th><th>Group</th><th>Paper Name</th><th>Meeting</th><th>Status</th><th>First released version</th></tr>
 <!--
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3346.pdf">3346</a></td><td>LWG</td><td>Terminology for Container Element Requirements - Rev 1</td><td>Kona</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/n3346">3346</a></td><td>LWG</td><td>Terminology for Container Element Requirements - Rev 1</td><td>Kona</td><td>Complete</td><td>3.4</td></tr>
 -->
-	<tr><td><a href="https://wg21.link/P0463R1">P0463R1</a></td><td>LWG</td><td>Endian just Endian</td><td>Toronto</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0463R1">P0463R1</a></td><td>LWG</td><td>Endian just Endian</td><td>Toronto</td><td>In progress</td><td></td></tr>
 	<tr><td><a href="https://wg21.link/P0674R1">P0674R1</a></td><td>LWG</td><td>Extending make_shared to Support Arrays</td><td>Toronto</td><td></td><td></td></tr>
 
+  	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0020R6">P0020R6</a></td><td>LWG</td><td>Floating Point Atomic</td><td>Albuquerque</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0053R7">P0053R7</a></td><td>LWG</td><td>C++ Synchronized Buffered Ostream</td><td>Albuquerque</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0202R3">P0202R3</a></td><td>LWG</td><td>Add constexpr modifiers to functions in &lt;algorithm&gt; and &lt;utility&gt; Headers</td><td>Albuquerque</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0415R1">P0415R1</a></td><td>LWG</td><td>Constexpr for <tt>std::complex</tt></td><td>Albuquerque</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0439R0">P0439R0</a></td><td>LWG</td><td>Make <tt>std::memory_order</tt> a scoped enumeration</td><td>Albuquerque</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0457R2">P0457R2</a></td><td>LWG</td><td>String Prefix and Suffix Checking</td><td>Albuquerque</td><td>Complete</td><td>6.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0550R2">P0550R2</a></td><td>LWG</td><td>Transformation Trait <tt>remove_cvref</tt></td><td>Albuquerque</td><td>Complete</td><td>6.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0600R1">P0600R1</a></td><td>LWG</td><td>nodiscard in the Library</td><td>Albuquerque</td><td><I>In Progress</I></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0616R0">P0616R0</a></td><td>LWG</td><td>de-pessimize legacy <numeric> algorithms with std::move</td><td>Albuquerque</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0653R2">P0653R2</a></td><td>LWG</td><td>Utility to convert a pointer to a raw pointer</td><td>Albuquerque</td><td>Complete</td><td>6.0</td></tr>
+	<tr><td><a href="https://wg21.link/P0718R2">P0718R2</a></td><td>LWG</td><td>Atomic shared_ptr</td><td>Albuquerque</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0767R1">P0767R1</a></td><td>CWG</td><td>Deprecate POD</td><td>Albuquerque</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0768R1">P0768R1</a></td><td>CWG</td><td>Library Support for the Spaceship (Comparison) Operator</td><td>Albuquerque</td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/P0777R1">P0777R1</a></td><td>LWG</td><td>Treating Unnecessary <tt>decay</tt></td><td>Albuquerque</td><td></td><td></td></tr>
+
 <!--  	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr> -->
   </table>
 
 <p><i>[ Note: "Nothing to do" means that no library changes were needed to implement this change -- end note]</i></p>
 
+<p><i>The missing bits in P0600 are in [mem.res.class], [mem.poly.allocator.class], and [container.node.overview]</i></p>
+
   <h3>Library Working group Issues Status</h3>
 <!--   <I>Note: "NAD" means that the issue was deemed "Not a defect"</I> -->
   <table id="issues" border="1">
 	<tr><th>Issue #</th><th>Issue Name</th><th>Meeting</th><th>Status</th></tr>
 <!--
-	<tr><td><a href="http://wg21.link/LWG1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Urbana</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Urbana</td><td></td></tr>
 -->
-	<tr><td><a href="http://wg21.link/LWG2070">2070</a></td><td><tt>allocate_shared</tt> should use <tt>allocator_traits&lt;A&gt;::construct</tt></td><td>Toronto</td><td>Resolved by <a href="https://wg21.link/P0674R1">P0674R1</a></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2444">2444</a></td><td>Inconsistent complexity for <tt>std::sort_heap</tt></td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2593">2593</a></td><td>Moved-from state of Allocators</td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2597">2597</a></td><td><tt>std::log</tt> misspecified for complex numbers</td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2783">2783</a></td><td><tt>stack::emplace()</tt> and <tt>queue::emplace()</tt> should return <tt>decltype(auto)</tt></td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2932">2932</a></td><td>Constraints on parallel algorithm implementations are underspecified</td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2937">2937</a></td><td>Is <tt>equivalent("existing_thing", "not_existing_thing")</tt> an error</td><td>Toronto</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2940">2940</a></td><td><tt>result_of</tt> specification also needs a little cleanup</td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2942">2942</a></td><td>LWG 2873's resolution missed <tt>weak_ptr::owner_before</tt></td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2954">2954</a></td><td>Specialization of the convenience variable templates should be prohibited</td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2961">2961</a></td><td>Bad postcondition for <tt>set_default_resource</tt></td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2966">2966</a></td><td>Incomplete resolution of US 74</td><td>Toronto</td><td><i>Nothing to do</i></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2974">2974</a></td><td>Diagnose out of bounds <tt>tuple_element/variant_alternative</tt></td><td>Toronto</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2070">2070</a></td><td><tt>allocate_shared</tt> should use <tt>allocator_traits&lt;A&gt;::construct</tt></td><td>Toronto</td><td>Resolved by <a href="https://wg21.link/P0674R1">P0674R1</a></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2444">2444</a></td><td>Inconsistent complexity for <tt>std::sort_heap</tt></td><td>Toronto</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2593">2593</a></td><td>Moved-from state of Allocators</td><td>Toronto</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2597">2597</a></td><td><tt>std::log</tt> misspecified for complex numbers</td><td>Toronto</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2783">2783</a></td><td><tt>stack::emplace()</tt> and <tt>queue::emplace()</tt> should return <tt>decltype(auto)</tt></td><td>Toronto</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2932">2932</a></td><td>Constraints on parallel algorithm implementations are underspecified</td><td>Toronto</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2937">2937</a></td><td>Is <tt>equivalent("existing_thing", "not_existing_thing")</tt> an error</td><td>Toronto</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2940">2940</a></td><td><tt>result_of</tt> specification also needs a little cleanup</td><td>Toronto</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2942">2942</a></td><td>LWG 2873's resolution missed <tt>weak_ptr::owner_before</tt></td><td>Toronto</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2954">2954</a></td><td>Specialization of the convenience variable templates should be prohibited</td><td>Toronto</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2961">2961</a></td><td>Bad postcondition for <tt>set_default_resource</tt></td><td>Toronto</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2966">2966</a></td><td>Incomplete resolution of US 74</td><td>Toronto</td><td><i>Nothing to do</i></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2974">2974</a></td><td>Diagnose out of bounds <tt>tuple_element/variant_alternative</tt></td><td>Toronto</td><td>Complete</td></tr>
+
+ 	<tr><td></td><td></td><td></td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2779">2779</a></td><td>[networking.ts] Relax requirements on buffer sequence iterators</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2870">2870</a></td><td>Default value of parameter theta of polar should be dependent</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2935">2935</a></td><td>What should create_directories do when p already exists but is not a directory?</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2941">2941</a></td><td>[thread.req.timing] wording should apply to both member and namespace-level functions</td><td>Albuquerque</td><td><i>Nothing to do</i></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2944">2944</a></td><td>LWG 2905 accidentally removed requirement that construction of the deleter doesn't throw an exception</td><td>Albuquerque</td><td><i>Nothing to do</i></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2945">2945</a></td><td>Order of template parameters in optional comparisons</td><td>Albuquerque</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2948">2948</a></td><td>unique_ptr does not define operator<< for stream output</td><td>Albuquerque</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2950">2950</a></td><td>std::byte operations are misspecified</td><td>Albuquerque</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2952">2952</a></td><td>iterator_traits should work for pointers to cv T</td><td>Albuquerque</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2953">2953</a></td><td>LWG 2853 should apply to deque::erase too</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2958">2958</a></td><td>Moves improperly defined as deleted</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2964">2964</a></td><td>Apparently redundant requirement for dynamic_pointer_cast</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2965">2965</a></td><td>Non-existing path::native_string() in filesystem_error::what() specification</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2972">2972</a></td><td>What is is_trivially_destructible_v<int>?</td><td>Albuquerque</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2976">2976</a></td><td>Dangling uses_allocator specialization for packaged_task</td><td>Albuquerque</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2977">2977</a></td><td>unordered_meow::merge() has incorrect Throws: clause</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2978">2978</a></td><td>Hash support for pmr::string and friends</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2979">2979</a></td><td>aligned_union should require complete object types</td><td>Albuquerque</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2980">2980</a></td><td>Cannot compare_exchange empty pointers</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2981">2981</a></td><td>Remove redundant deduction guides from standard library</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2982">2982</a></td><td>Making size_type consistent in associative container deduction guides</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2988">2988</a></td><td>Clause 32 cleanup missed one typename</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2993">2993</a></td><td>reference_wrapper<T> conversion from T&&</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2998">2998</a></td><td>Requirements on function objects passed to {forward_,}list-specific algorithms</td><td>Albuquerque</td><td><i>Nothing to do</i></td></tr>
+	<tr><td><a href="https://wg21.link/LWG3001">3001</a></td><td>weak_ptr::element_type needs remove_extent_t</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG3024">3024</a></td><td>variant's copies must be deleted instead of disabled via SFINAE</td><td>Albuquerque</td><td></td></tr>
 
 <!-- 	<tr><td></td><td></td><td></td><td></td></tr> -->
   </table>
diff --git a/www/index.html b/www/index.html
index 2e707dcb2137..eca48ced11cb 100644
--- a/www/index.html
+++ b/www/index.html
@@ -12,7 +12,7 @@
 <body>
 <div id="menu">
   <div>
-    <a href="http://llvm.org/">LLVM Home</a>
+    <a href="https://llvm.org/">LLVM Home</a>
   </div>
 
   <div class="submenu">
@@ -22,11 +22,11 @@
 
   <div class="submenu">
     <label>Quick Links</label>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="http://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
   </div>
 </div>
 
@@ -39,7 +39,7 @@
      C++11.</p>
 
   <p>All of the code in libc++ is <a
-     href="http://llvm.org/docs/DeveloperPolicy.html#license">dual licensed</a>
+     href="https://llvm.org/docs/DeveloperPolicy.html#license">dual licensed</a>
      under the MIT license and the UIUC License (a BSD-like license).</p>
 
   <!--=====================================================================-->
@@ -49,7 +49,7 @@
   <p> Looking for documentation on how to use, build and test libc++? If so
       checkout the new libc++ documentation.</p>
 
-  <p><a href="http://libcxx.llvm.org/docs/">
+  <p><a href="https://libcxx.llvm.org/docs/">
       Click here for the new libc++ documentation.</a></p>
 
   <!--=====================================================================-->
@@ -161,17 +161,17 @@
   <!--=====================================================================-->
 
   <p>First please review our
-     <a href="http://llvm.org/docs/DeveloperPolicy.html">Developer's Policy</a>.
+     <a href="https://llvm.org/docs/DeveloperPolicy.html">Developer's Policy</a>.
 
     The documentation for building and using libc++ can be found below.
     <ul>
-      <li><a href="http://libcxx.llvm.org/docs/UsingLibcxx.html">
+      <li><a href="https://libcxx.llvm.org/docs/UsingLibcxx.html">
         <b>Using libc++</b></a>
           Documentation on using the library in your programs</li>
-      <li><a href="http://libcxx.llvm.org/docs/BuildingLibcxx.html">
+      <li><a href="https://libcxx.llvm.org/docs/BuildingLibcxx.html">
         <b>Building libc++</b></a>
           Documentation on building the library using CMake</li>
-      <li><a href="http://libcxx.llvm.org/docs/TestingLibcxx.html">
+      <li><a href="https://libcxx.llvm.org/docs/TestingLibcxx.html">
         <b>Testing libc++</b></a>
           Documentation for developers wishing to test the library</li>
     </ul>
@@ -195,7 +195,7 @@
   </p>
 
   <p>Send discussions to the
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">clang mailing list</a>.</p>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">clang mailing list</a>.</p>
 
   <!--=====================================================================-->
   <h2>Bug reports and patches</h2>
@@ -203,14 +203,14 @@
 
   <p>
   If you think you've found a bug in libc++, please report it using
-  the <a href="http://llvm.org/bugs">LLVM Bugzilla</a>. If you're not sure, you
-  can post a message to the <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a> 
+  the <a href="https://bugs.llvm.org/">LLVM Bugzilla</a>. If you're not sure, you
+  can post a message to the <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
   mailing list or on IRC. Please include "libc++" in your subject.
   </p>
 
   <p>
   If you want to contribute a patch to libc++, the best place for that is
-  <a href="http://llvm.org/docs/Phabricator.html">Phabricator</a>. Please
+  <a href="https://llvm.org/docs/Phabricator.html">Phabricator</a>. Please
   include [libc++] in the subject and add cfe-commits as a subscriber.
   </p>
 
@@ -221,7 +221,7 @@
 <ul>
 <li><a href="atomic_design.html"><tt>&lt;atomic&gt;</tt></a></li>
 <li><a href="type_traits_design.html"><tt>&lt;type_traits&gt;</tt></a></li>
-<li><a href="http://cplusplusmusings.wordpress.com/2012/07/05/clang-and-standard-libraries-on-mac-os-x/">Excellent notes by Marshall Clow</a></li>
+<li><a href="https://cplusplusmusings.wordpress.com/2012/07/05/clang-and-standard-libraries-on-mac-os-x/">Excellent notes by Marshall Clow</a></li>
 </ul>
 
 </div>
diff --git a/www/ts1z_status.html b/www/ts1z_status.html
index 48ce4542d38c..22ad0d450c17 100644
--- a/www/ts1z_status.html
+++ b/www/ts1z_status.html
@@ -12,7 +12,7 @@
 <body>
 <div id="menu">
   <div>
-    <a href="http://llvm.org/">LLVM Home</a>
+    <a href="https://llvm.org/">LLVM Home</a>
   </div>
 
   <div class="submenu">
@@ -22,11 +22,11 @@
 
   <div class="submenu">
     <label>Quick Links</label>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="http://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
   </div>
 </div>
 
@@ -37,20 +37,20 @@
 
   <p>In November 2014, the C++ standard committee approved the draft for the next version of the C++ standard, known as "C++1z" (probably to be C++17)</p>
   <p>In addition, there are several "Technical Specifications", that consist of new features that are proposed, but not yet accepted for C++1z.</p>
-  <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="http://clang.llvm.org/cxx_status.html">here</a>.</p>
+  <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="https://clang.llvm.org/cxx_status.html">here</a>.</p>
 
   <h3>Technical Specifications</h3>
   <table id="TS" border="1">
 	<tr><th>Paper Number</th><th>Paper Title</th><th>TS</th></tr>
 
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4023.html">4023</a></td><td>C++ Extensions for Library Fundamentals</td><td>Library Fundamentals 1</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3940.html">3940</a></td><td>Technical Specification - File System</td><td>File System</td></tr>
+	<tr><td><a href="https://wg21.link/n4023">4023</a></td><td>C++ Extensions for Library Fundamentals</td><td>Library Fundamentals 1</td></tr>
+	<tr><td><a href="https://wg21.link/n3940">3940</a></td><td>Technical Specification - File System</td><td>File System</td></tr>
 	<tr><td></td><td></td><td></td></tr>
 
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4273">4273</a></td><td>Uniform Container Erasure.</td><td>Library Fundamentals 2</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4061">4061</a></td><td>Greatest Common Divisor and Least Common Multiple.</td><td>Library Fundamentals 2</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4257">4257</a></td><td>Delimited iterators.</td><td>Library Fundamentals 2</td></tr>
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4282">4282</a></td><td>The World's Dumbest Smart Pointer.</td><td>Library Fundamentals 2</td></tr>
+	<tr><td><a href="https://wg21.link/n4273">4273</a></td><td>Uniform Container Erasure.</td><td>Library Fundamentals 2</td></tr>
+	<tr><td><a href="https://wg21.link/n4061">4061</a></td><td>Greatest Common Divisor and Least Common Multiple.</td><td>Library Fundamentals 2</td></tr>
+	<tr><td><a href="https://wg21.link/n4257">4257</a></td><td>Delimited iterators.</td><td>Library Fundamentals 2</td></tr>
+	<tr><td><a href="https://wg21.link/n4282">4282</a></td><td>The World's Dumbest Smart Pointer.</td><td>Library Fundamentals 2</td></tr>
 	<tr><td></td><td></td><td></td></tr>
 
   </table>
@@ -95,7 +95,7 @@
 <!--  <tr><td></td><td></td></tr> -->
 
   </table>
-  
+
   <h3>Features in Filesystem</h3>
   <table id="Features" border="1">
 	<tr><th>Feature Name</th><th>Status</th><th>First released version</th></tr>
diff --git a/www/type_traits_design.html b/www/type_traits_design.html
index 2c7f73b500ef..1cab2936d5bb 100644
--- a/www/type_traits_design.html
+++ b/www/type_traits_design.html
@@ -12,7 +12,7 @@
 <body>
 <div id="menu">
   <div>
-    <a href="http://llvm.org/">LLVM Home</a>
+    <a href="https://llvm.org/">LLVM Home</a>
   </div>
 
   <div class="submenu">
@@ -22,11 +22,11 @@
 
   <div class="submenu">
     <label>Quick Links</label>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="http://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
   </div>
 </div>
 
@@ -39,7 +39,7 @@
 This is a survey of the type traits intrinsics clang has, and those needed.
 The names and definitions of several of the needed type traits has recently
 changed.  Please see:
-<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html">N3142</a>.
+<a href="https://wg21.link/n3142">N3142</a>.
 </p>
 
 <blockquote>
diff --git a/www/upcoming_meeting.html b/www/upcoming_meeting.html
index f90f4661266d..2723c8b6766a 100644
--- a/www/upcoming_meeting.html
+++ b/www/upcoming_meeting.html
@@ -12,7 +12,7 @@
 <body>
 <div id="menu">
   <div>
-    <a href="http://llvm.org/">LLVM Home</a>
+    <a href="https://llvm.org/">LLVM Home</a>
   </div>
 
   <div class="submenu">
@@ -22,21 +22,21 @@
 
   <div class="submenu">
     <label>Quick Links</label>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
-    <a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
+    <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
-    <a href="http://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
-    <a href="http://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
+    <a href="https://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
+    <a href="https://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
-  <h1>libc++ Issaquah Status</h1>
+  <h1>libc++ Upcoming Metting Status</h1>
   <!--*********************************************************************-->
 
-  <p>This is a temporary page; please check the c++1z status <a href="http://libcxx.llvm.org/cxx1z_status.html">here</a></p>
-  <p>This page shows the status of the papers and issues that are expected to be adopted in Toronto.</p>
+  <p>This is a temporary page; please check the c++1z status <a href="cxx1z_status.html">here</a></p>
+  <p>This page shows the status of the papers and issues that are expected to be adopted in the next WG21 Meeting.</p>
 
   <p>The groups that have contributed papers:
   <ul>
@@ -50,7 +50,7 @@
   <table id="papers" border="1">
 	<tr><th>Paper #</th><th>Group</th><th>Paper Name</th><th>Meeting</th><th>Status</th><th>First released version</th></tr>
 <!--
-	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3346.pdf">3346</a></td><td>LWG</td><td>Terminology for Container Element Requirements - Rev 1</td><td>Kona</td><td>Complete</td><td>3.4</td></tr>
+	<tr><td><a href="https://wg21.link/LWGn3346">3346</a></td><td>LWG</td><td>Terminology for Container Element Requirements - Rev 1</td><td>Kona</td><td>Complete</td><td>3.4</td></tr>
 -->
 <!--  	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr> -->
   </table>
@@ -59,42 +59,61 @@
   <table id="issues" border="1">
 	<tr><th>Issue #</th><th>Issue Name</th><th>Meeting</th><th>Status</th></tr>
 
-	<tr><td><a href="http://wg21.link/LWG2444">2444</a></td><td>Inconsistent complexity for std::sort_heap</td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2593">2593</a></td><td>Moved-from state of Allocators</td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2597">2597</a></td><td>std::log misspecified for complex numbers</td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2783">2783</a></td><td>stack::emplace() and queue::emplace() should return decltype(auto)</td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2932">2932</a></td><td>Constraints on parallel algorithm implementations are underspecified</td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2937">2937</a></td><td>Is equivalent("existing_thing", "not_existing_thing") an error?</td><td>Toronto</td><td>Complete</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2940">2940</a></td><td>result_of specification also needs a little cleanup</td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2942">2942</a></td><td>LWG 2873's resolution missed weak_ptr::owner_before</td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2954">2954</a></td><td>Specialization of the convenience variable templates should be prohibited</td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2961">2961</a></td><td>Bad postcondition for set_default_resource</td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2966">2966</a></td><td>Incomplete resolution of US 74</td><td>Toronto</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2974">2974</a></td><td>Diagnose out of bounds tuple_element/variant_alternative</td><td>Toronto</td><td></td></tr>
-
-	<tr><td></td><td><center><b>Priority 1 Bugs</b></center></td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2665">2665</a></td><td>remove_filename() post condition is incorrect</td><td>Toronto</td><td>We do this already</td></tr>
-
-	<tr><td></td><td><center><b>Immediate Issues in Toronto</b></center></td><td></td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2901">2901</a></td><td>Variants cannot properly support allocators</td><td>Toronto</td><td>We do this already</td></tr>
-	<tr><td><a href="http://wg21.link/LWG2956">2956</a></td><td><tt>filesystem::canonical()</tt> still defined in terms of <tt>absolute(p, base)</tt></td><td>Toronto</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2779">2779</a></td><td>[networking.ts] Relax requirements on buffer sequence iterators</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2870">2870</a></td><td>Default value of parameter theta of polar should be dependent</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2935">2935</a></td><td>What should create_directories do when p already exists but is not a directory?</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2941">2941</a></td><td>[thread.req.timing] wording should apply to both member and namespace-level functions</td><td>Albuquerque</td><td>Nothing to do</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2944">2944</a></td><td>LWG 2905 accidentally removed requirement that construction of the deleter doesn't throw an exception</td><td>Albuquerque</td><td>Nothing to do</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2945">2945</a></td><td>Order of template parameters in optional comparisons</td><td>Albuquerque</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2948">2948</a></td><td>unique_ptr does not define operator<< for stream output</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2950">2950</a></td><td>std::byte operations are misspecified</td><td>Albuquerque</td><td>Patch Ready</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2952">2952</a></td><td>iterator_traits should work for pointers to cv T</td><td>Albuquerque</td><td>Patch ready</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2953">2953</a></td><td>LWG 2853 should apply to deque::erase too</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2964">2964</a></td><td>Apparently redundant requirement for dynamic_pointer_cast</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2965">2965</a></td><td>Non-existing path::native_string() in filesystem_error::what() specification</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2972">2972</a></td><td>What is is_trivially_destructible_v<int>?</td><td>Albuquerque</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2976">2976</a></td><td>Dangling uses_allocator specialization for packaged_task</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2977">2977</a></td><td>unordered_meow::merge() has incorrect Throws: clause</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2978">2978</a></td><td>Hash support for pmr::string and friends</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2979">2979</a></td><td>aligned_union should require complete object types</td><td>Albuquerque</td><td>Complete</td></tr>
+	<tr><td><a href="https://wg21.link/LWG2980">2980</a></td><td>Cannot compare_exchange empty pointers</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2981">2981</a></td><td>Remove redundant deduction guides from standard library</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2982">2982</a></td><td>Making size_type consistent in associative container deduction guides</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2988">2988</a></td><td>Clause 32 cleanup missed one typename</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2993">2993</a></td><td>reference_wrapper<T> conversion from T&&</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG2998">2998</a></td><td>Requirements on function objects passed to {forward_,}list-specific algorithms</td><td>Albuquerque</td><td>Nothing to do</td></tr>
+	<tr><td><a href="https://wg21.link/LWG3001">3001</a></td><td>weak_ptr::element_type needs remove_extent_t</td><td>Albuquerque</td><td></td></tr>
+	<tr><td><a href="https://wg21.link/LWG3024">3024</a></td><td>variant's copies must be deleted instead of disabled via SFINAE</td><td>Albuquerque</td><td></td></tr>
 
   </table>
 
 <h3>Comments about the issues</h3>
 <ul>
-<li>2444 - </li>
-<li>2593 - </li>
-<li>2597 - I think we do this already; probably needs tests</li>
-<li>2783 - should be easy to change; needs tests</li>
-<li>2932 - We're not doing the parallel algorithms yet.</li>
-<li>2937 - Implemented with tests. The PR LGTM (Eric)</li>
-<li>2940 - We haven't implemented result_of yet, but I don't think that this will require any changes.</li>
-<li>2942 - all of our owner_before overloads are already noexcept; just need to update the tests.</li>
-<li>2954 - I don't think there's anything to do here.</li>
-<li>2961 - We haven't implemented the PMR stuff yet.</li>
-<li>2966 - Wording cleanup; no code or test changes needed.</li>
-<li>2974 - I did this in r305196. Tests added in 306580</li>
+<li>2779 - </li>
+<li>2870 - We already default to <tt>T(0)</tt>; but the PR says <tt>T()</tt>. Later - this makes no difference at all; since T has to be float/double/long double</li>
+<li>2935 - Eric? </li>
+<li>2941 - Wording cleanup; nothing to do.</li>
+<li>2944 - Wording cleanup; nothing to do. </li>
+<li>2945 - Synopsis was wrong; code was fine. <i>Fixed in r317063</i></li>
+<li>2948 - </li>
+<li>2950 - Patch ready</li>
+<li>2952 - Patch ready</li>
+<li>2953 - Probably just wording; check to be sure.</li>
+<li>2964 - At the very least, it needs a test.</li>
+<li>2965 - Eric? </li>
+<li>2972 - We already do this</li>
+<li>2976 - Looks simple. </li>
+<li>2977 - We haven't implemented p0083r3 yet (Splicing Maps and Sets), so we don't have <tt>merge</tt> for those containers yet</li>
+<li>2978 - Straightforward. </li>
+<li>2979 - <i>Test added in revision 316969</i></li>
+<li>2980 - Needs code changes and tests</li>
+<li>2981 - We need to finish the deduction guides before doing this</li>
+<li>2982 - We need to finish the deduction guides before doing this</li>
+<li>2988 - Simple; once we rewrite &lt;atomic&gt; </li>
+<li>2993 - </li>
+<li>2998 - Wording cleanup; nothing to do. </li>
+<li>3001 - Looks simple. </li>
+<li>3024 - </li>
 </ul>
 
 <p>Last Updated: 28-Jun-2017</p>