No OneTemporary
Actions

Size

4 MB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	Index: projects/clang700-import/contrib/libc++/include/__bsd_locale_defaults.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/__bsd_locale_defaults.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/__bsd_locale_defaults.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/include/__bsd_locale_defaults.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/__bsd_locale_fallbacks.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/__bsd_locale_fallbacks.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/__bsd_locale_fallbacks.h (revision 337135)
	@@ -1,140 +1,140 @@
	// -- C++ --
	//===---------------------- __bsd_locale_fallbacks.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.
	//
	//===----------------------------------------------------------------------===//
	// The BSDs have lots of *_l functions. This file provides reimplementations
	// of those functions for non-BSD platforms.
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP_BSD_LOCALE_FALLBACKS_DEFAULTS_H
	#define _LIBCPP_BSD_LOCALE_FALLBACKS_DEFAULTS_H

	#include <stdlib.h>
	#include <stdarg.h>
	#include <memory>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	decltype(MB_CUR_MAX) __libcpp_mb_cur_max_l(locale_t __l)
	{
	__libcpp_locale_guard __current(__l);
	return MB_CUR_MAX;
	}

	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	wint_t __libcpp_btowc_l(int __c, locale_t __l)
	{
	__libcpp_locale_guard __current(__l);
	return btowc(__c);
	}

	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	int __libcpp_wctob_l(wint_t __c, locale_t __l)
	{
	__libcpp_locale_guard __current(__l);
	return wctob(__c);
	}

	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	size_t __libcpp_wcsnrtombs_l(char __dest, const wchar_t *__src, size_t __nwc,
	size_t __len, mbstate_t *__ps, locale_t __l)
	{
	__libcpp_locale_guard __current(__l);
	return wcsnrtombs(__dest, __src, __nwc, __len, __ps);
	}

	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	size_t __libcpp_wcrtomb_l(char __s, wchar_t __wc, mbstate_t __ps, locale_t __l)
	{
	__libcpp_locale_guard __current(__l);
	return wcrtomb(__s, __wc, __ps);
	}

	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	size_t __libcpp_mbsnrtowcs_l(wchar_t * __dest, const char **__src, size_t __nms,
	size_t __len, mbstate_t *__ps, locale_t __l)
	{
	__libcpp_locale_guard __current(__l);
	return mbsnrtowcs(__dest, __src, __nms, __len, __ps);
	}

	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	size_t __libcpp_mbrtowc_l(wchar_t __pwc, const char __s, size_t __n,
	mbstate_t *__ps, locale_t __l)
	{
	__libcpp_locale_guard __current(__l);
	return mbrtowc(__pwc, __s, __n, __ps);
	}

	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	int __libcpp_mbtowc_l(wchar_t __pwc, const char __pmb, size_t __max, locale_t __l)
	{
	__libcpp_locale_guard __current(__l);
	return mbtowc(__pwc, __pmb, __max);
	}

	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	size_t __libcpp_mbrlen_l(const char __s, size_t __n, mbstate_t __ps, locale_t __l)
	{
	__libcpp_locale_guard __current(__l);
	return mbrlen(__s, __n, __ps);
	}

	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	lconv *__libcpp_localeconv_l(locale_t __l)
	{
	__libcpp_locale_guard __current(__l);
	return localeconv();
	}

	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	size_t __libcpp_mbsrtowcs_l(wchar_t __dest, const char *__src, size_t __len,
	mbstate_t *__ps, locale_t __l)
	{
	__libcpp_locale_guard __current(__l);
	return mbsrtowcs(__dest, __src, __len, __ps);
	}

	inline
	int __libcpp_snprintf_l(char __s, size_t __n, locale_t __l, const char __format, ...) {
	va_list __va;
	va_start(__va, __format);
	__libcpp_locale_guard __current(__l);
	int __res = vsnprintf(__s, __n, __format, __va);
	va_end(__va);
	return __res;
	}

	inline
	int __libcpp_asprintf_l(char *__s, locale_t __l, const char __format, ...) {
	va_list __va;
	va_start(__va, __format);
	__libcpp_locale_guard __current(__l);
	int __res = vasprintf(__s, __format, __va);
	va_end(__va);
	return __res;
	}

	inline
	int __libcpp_sscanf_l(const char __s, locale_t __l, const char __format, ...) {
	va_list __va;
	va_start(__va, __format);
	__libcpp_locale_guard __current(__l);
	int __res = vsscanf(__s, __format, __va);
	va_end(__va);
	return __res;
	}

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_BSD_LOCALE_FALLBACKS_DEFAULTS_H

	Property changes on: projects/clang700-import/contrib/libc++/include/__bsd_locale_fallbacks.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/__config
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/__config (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/__config (revision 337135)
	@@ -1,1289 +1,1352 @@
	// -- C++ --
	//===--------------------------- __config ---------------------------------===//
	//
	// 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_CONFIG
	#define _LIBCPP_CONFIG

	#if defined(_MSC_VER) && !defined(__clang__)
	-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	-#define _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
	+# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	+# define _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
	+# endif
	#endif
	-#endif

	#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
	#pragma GCC system_header
	#endif

	#ifdef __cplusplus

	#ifdef __GNUC__
	-#define _GNUC_VER (__GNUC__ * 100 + __GNUC_MINOR__)
	+# define _GNUC_VER (__GNUC__ * 100 + __GNUC_MINOR__)
	// The _GNUC_VER_NEW macro better represents the new GCC versioning scheme
	// introduced in GCC 5.0.
	-#define _GNUC_VER_NEW (_GNUC_VER * 10 + __GNUC_PATCHLEVEL__)
	+# define _GNUC_VER_NEW (_GNUC_VER * 10 + __GNUC_PATCHLEVEL__)
	#else
	-#define _GNUC_VER 0
	-#define _GNUC_VER_NEW 0
	+# define _GNUC_VER 0
	+# define _GNUC_VER_NEW 0
	#endif

	-#define _LIBCPP_VERSION 6000
	+#define _LIBCPP_VERSION 7000

	#ifndef _LIBCPP_ABI_VERSION
	-#define _LIBCPP_ABI_VERSION 1
	+# ifdef __Fuchsia__
	+# define _LIBCPP_ABI_VERSION 2
	+# else
	+# define _LIBCPP_ABI_VERSION 1
	+# endif
	#endif

	+#ifndef _LIBCPP_STD_VER
	+# if __cplusplus <= 201103L
	+# define _LIBCPP_STD_VER 11
	+# elif __cplusplus <= 201402L
	+# define _LIBCPP_STD_VER 14
	+# elif __cplusplus <= 201703L
	+# define _LIBCPP_STD_VER 17
	+# else
	+# define _LIBCPP_STD_VER 18 // current year, or date of c++2a ratification
	+# endif
	+#endif // _LIBCPP_STD_VER
	+
	#if defined(__ELF__)
	-#define _LIBCPP_OBJECT_FORMAT_ELF 1
	+# define _LIBCPP_OBJECT_FORMAT_ELF 1
	#elif defined(__MACH__)
	-#define _LIBCPP_OBJECT_FORMAT_MACHO 1
	+# define _LIBCPP_OBJECT_FORMAT_MACHO 1
	#elif defined(_WIN32)
	-#define _LIBCPP_OBJECT_FORMAT_COFF 1
	+# define _LIBCPP_OBJECT_FORMAT_COFF 1
	#elif defined(__wasm__)
	-#define _LIBCPP_OBJECT_FORMAT_WASM 1
	+# define _LIBCPP_OBJECT_FORMAT_WASM 1
	#else
	-#error Unknown object file format
	+# error Unknown object file format
	#endif

	#if defined(_LIBCPP_ABI_UNSTABLE) \|\| _LIBCPP_ABI_VERSION >= 2
	// Change short string representation so that string data starts at offset 0,
	// improving its alignment in some cases.
	-#define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
	+# define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
	// Fix deque iterator type in order to support incomplete types.
	-#define _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE
	+# define _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE
	// Fix undefined behavior in how std::list stores its linked nodes.
	-#define _LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB
	+# 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
	+# define _LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB
	// 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
	+# 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
	// Don't use a nullptr_t simulation type in C++03 instead using C++11 nullptr
	// provided under the alternate keyword __nullptr, which changes the mangling
	// of nullptr_t. This option is ABI incompatible with GCC in C++03 mode.
	-#define _LIBCPP_ABI_ALWAYS_USE_CXX11_NULLPTR
	+# define _LIBCPP_ABI_ALWAYS_USE_CXX11_NULLPTR
	// Define the `pointer_safety` enum as a C++11 strongly typed enumeration
	// instead of as a class simulating an enum. If this option is enabled
	// `pointer_safety` and `get_pointer_safety()` will no longer be available
	// in C++03.
	-#define _LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE
	+# define _LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE
	// Define a key function for `bad_function_call` in the library, to centralize
	// 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
	+# 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
	+# 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
	+# define _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION
	#elif _LIBCPP_ABI_VERSION == 1
	-#if !defined(_LIBCPP_OBJECT_FORMAT_COFF)
	+# if !defined(_LIBCPP_OBJECT_FORMAT_COFF)
	// Enable compiling copies of now inline methods into the dylib to support
	// applications compiled against older libraries. This is unnecessary with
	// COFF dllexport semantics, since dllexport forces a non-inline definition
	// of inline functions to be emitted anyway. Our own non-inline copy would
	// conflict with the dllexport-emitted copy, so we disable it.
	-#define _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
	-#endif
	+# define _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
	+# endif
	// Feature macros for disabling pre ABI v1 features. All of these options
	// are deprecated.
	-#if defined(__FreeBSD__)
	-#define _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR
	+# if defined(__FreeBSD__)
	+# define _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR
	+# endif
	#endif
	-#endif

	#ifdef _LIBCPP_TRIVIAL_PAIR_COPY_CTOR
	#error "_LIBCPP_TRIVIAL_PAIR_COPY_CTOR" is no longer supported. \
	use _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR instead
	#endif

	#define _LIBCPP_CONCAT1(_LIBCPP_X,_LIBCPP_Y) _LIBCPP_X##_LIBCPP_Y
	#define _LIBCPP_CONCAT(_LIBCPP_X,_LIBCPP_Y) _LIBCPP_CONCAT1(_LIBCPP_X,_LIBCPP_Y)

	#define _LIBCPP_NAMESPACE _LIBCPP_CONCAT(__,_LIBCPP_ABI_VERSION)

	#if __cplusplus < 201103L
	#define _LIBCPP_CXX03_LANG
	#endif

	#ifndef __has_attribute
	#define __has_attribute(__x) 0
	#endif
	+
	#ifndef __has_builtin
	#define __has_builtin(__x) 0
	#endif
	+
	#ifndef __has_extension
	#define __has_extension(__x) 0
	#endif
	+
	#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
	#define __is_identifier(__x) 1
	#endif
	+
	#ifndef __has_declspec_attribute
	#define __has_declspec_attribute(__x) 0
	#endif

	#define __has_keyword(__x) !(__is_identifier(__x))

	-#ifdef __has_include
	-#define __libcpp_has_include(__x) __has_include(__x)
	-#else
	-#define __libcpp_has_include(__x) 0
	+#ifndef __has_include
	+#define __has_include(...) 0
	#endif

	#if defined(__clang__)
	-#define _LIBCPP_COMPILER_CLANG
	-# ifndef __apple_build_version__
	-# define _LIBCPP_CLANG_VER (__clang_major__ * 100 + __clang_minor__)
	-# endif
	+# define _LIBCPP_COMPILER_CLANG
	+# ifndef __apple_build_version__
	+# define _LIBCPP_CLANG_VER (__clang_major__ * 100 + __clang_minor__)
	+# endif
	#elif defined(__GNUC__)
	-#define _LIBCPP_COMPILER_GCC
	+# define _LIBCPP_COMPILER_GCC
	#elif defined(_MSC_VER)
	-#define _LIBCPP_COMPILER_MSVC
	+# define _LIBCPP_COMPILER_MSVC
	#elif defined(__IBMCPP__)
	-#define _LIBCPP_COMPILER_IBM
	+# define _LIBCPP_COMPILER_IBM
	#endif

	#ifndef _LIBCPP_CLANG_VER
	#define _LIBCPP_CLANG_VER 0
	#endif

	// 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,
	// 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"
	+# 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
	+# define _LIBCPP_ABI_ITANIUM
	#elif defined(_LIBCPP_ABI_FORCE_MICROSOFT)
	-# define _LIBCPP_ABI_MICROSOFT
	-#else
	-# if defined(_WIN32) && defined(_MSC_VER)
	# define _LIBCPP_ABI_MICROSOFT
	-# else
	-# define _LIBCPP_ABI_ITANIUM
	-# endif
	+#else
	+# 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.
	#if defined(__linux__)
	-#include <features.h>
	-#if !defined(__GLIBC_PREREQ)
	-#define __GLIBC_PREREQ(a, b) 0
	-#endif // !defined(__GLIBC_PREREQ)
	+# include <features.h>
	+# if defined(__GLIBC_PREREQ)
	+# define _LIBCPP_GLIBC_PREREQ(a, b) __GLIBC_PREREQ(a, b)
	+# else
	+# define _LIBCPP_GLIBC_PREREQ(a, b) 0
	+# endif // defined(__GLIBC_PREREQ)
	#endif // defined(__linux__)

	#ifdef __LITTLE_ENDIAN__
	-#if __LITTLE_ENDIAN__
	-#define _LIBCPP_LITTLE_ENDIAN
	+# if __LITTLE_ENDIAN__
	+# define _LIBCPP_LITTLE_ENDIAN
	+# endif // __LITTLE_ENDIAN__
	#endif // __LITTLE_ENDIAN__
	-#endif // __LITTLE_ENDIAN__

	#ifdef __BIG_ENDIAN__
	-#if __BIG_ENDIAN__
	-#define _LIBCPP_BIG_ENDIAN
	+# if __BIG_ENDIAN__
	+# define _LIBCPP_BIG_ENDIAN
	+# endif // __BIG_ENDIAN__
	#endif // __BIG_ENDIAN__
	-#endif // __BIG_ENDIAN__

	#ifdef __BYTE_ORDER__
	-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
	-#define _LIBCPP_LITTLE_ENDIAN
	-#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
	-#define _LIBCPP_BIG_ENDIAN
	-#endif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
	+# if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
	+# define _LIBCPP_LITTLE_ENDIAN
	+# elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
	+# define _LIBCPP_BIG_ENDIAN
	+# endif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
	#endif // __BYTE_ORDER__

	#ifdef __FreeBSD__
	-# include <sys/endian.h>
	+# include <sys/endian.h>
	# if _BYTE_ORDER == _LITTLE_ENDIAN
	-# define _LIBCPP_LITTLE_ENDIAN
	-# else // _BYTE_ORDER == _LITTLE_ENDIAN
	-# define _LIBCPP_BIG_ENDIAN
	-# endif // _BYTE_ORDER == _LITTLE_ENDIAN
	-# ifndef __LONG_LONG_SUPPORTED
	-# define _LIBCPP_HAS_NO_LONG_LONG
	-# endif // __LONG_LONG_SUPPORTED
	+# define _LIBCPP_LITTLE_ENDIAN
	+# else // _BYTE_ORDER == _LITTLE_ENDIAN
	+# define _LIBCPP_BIG_ENDIAN
	+# endif // _BYTE_ORDER == _LITTLE_ENDIAN
	+# ifndef __LONG_LONG_SUPPORTED
	+# define _LIBCPP_HAS_NO_LONG_LONG
	+# endif // __LONG_LONG_SUPPORTED
	#endif // __FreeBSD__

	#ifdef __NetBSD__
	-# include <sys/endian.h>
	+# include <sys/endian.h>
	# if _BYTE_ORDER == _LITTLE_ENDIAN
	-# define _LIBCPP_LITTLE_ENDIAN
	-# else // _BYTE_ORDER == _LITTLE_ENDIAN
	-# define _LIBCPP_BIG_ENDIAN
	-# endif // _BYTE_ORDER == _LITTLE_ENDIAN
	-# define _LIBCPP_HAS_QUICK_EXIT
	+# define _LIBCPP_LITTLE_ENDIAN
	+# else // _BYTE_ORDER == _LITTLE_ENDIAN
	+# 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
	# define _LIBCPP_SHORT_WCHAR 1
	// Both MinGW and native MSVC provide a "MSVC"-like enviroment
	# define _LIBCPP_MSVCRT_LIKE
	// If mingw not explicitly detected, assume using MS C runtime only if
	// a MS compatibility version is specified.
	# if defined(_MSC_VER) && !defined(__MINGW32__)
	# define _LIBCPP_MSVCRT // Using Microsoft's C Runtime library
	# endif
	# if (defined(_M_AMD64) \|\| defined(__x86_64__)) \|\| (defined(_M_ARM) \|\| defined(__arm__))
	# define _LIBCPP_HAS_BITSCAN64
	# endif
	-# if defined(_LIBCPP_MSVCRT)
	-# define _LIBCPP_HAS_QUICK_EXIT
	-# endif
	+# define _LIBCPP_HAS_OPEN_WITH_WCHAR
	+# if defined(_LIBCPP_MSVCRT)
	+# define _LIBCPP_HAS_QUICK_EXIT
	+# endif

	// Some CRT APIs are unavailable to store apps
	-#if defined(WINAPI_FAMILY)
	-#include <winapifamily.h>
	-#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && \
	- (!defined(WINAPI_PARTITION_SYSTEM) \|\| \
	- !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_SYSTEM))
	-#define _LIBCPP_WINDOWS_STORE_APP
	-#endif
	-#endif
	+# if defined(WINAPI_FAMILY)
	+# include <winapifamily.h>
	+# if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && \
	+ (!defined(WINAPI_PARTITION_SYSTEM) \|\| \
	+ !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_SYSTEM))
	+# define _LIBCPP_WINDOWS_STORE_APP
	+# endif
	+# endif
	#endif // defined(_WIN32)

	#ifdef __sun__
	-# include <sys/isa_defs.h>
	-# ifdef _LITTLE_ENDIAN
	-# define _LIBCPP_LITTLE_ENDIAN
	-# else
	-# define _LIBCPP_BIG_ENDIAN
	-# endif
	+# include <sys/isa_defs.h>
	+# ifdef _LITTLE_ENDIAN
	+# define _LIBCPP_LITTLE_ENDIAN
	+# else
	+# define _LIBCPP_BIG_ENDIAN
	+# endif
	#endif // __sun__

	#if defined(__CloudABI__)
	- // Certain architectures provide arc4random(). Prefer using
	- // arc4random() over /dev/{u,}random to make it possible to obtain
	- // random data even when using sandboxing mechanisms such as chroots,
	- // Capsicum, etc.
	-# define _LIBCPP_USING_ARC4_RANDOM
	+ // Certain architectures provide arc4random(). Prefer using
	+ // arc4random() over /dev/{u,}random to make it possible to obtain
	+ // random data even when using sandboxing mechanisms such as chroots,
	+ // Capsicum, etc.
	+# define _LIBCPP_USING_ARC4_RANDOM
	#elif defined(__Fuchsia__)
	-# define _LIBCPP_USING_GETENTROPY
	+# 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
	- // std::random_device is instead exposed through a NaCl syscall.
	-# define _LIBCPP_USING_NACL_RANDOM
	+ // NaCl's sandbox (which PNaCl also runs in) doesn't allow filesystem access,
	+ // including accesses to the special files under /dev. C++11's
	+ // std::random_device is instead exposed through a NaCl syscall.
	+# define _LIBCPP_USING_NACL_RANDOM
	#elif defined(_LIBCPP_WIN32API)
	-# define _LIBCPP_USING_WIN32_RANDOM
	+# define _LIBCPP_USING_WIN32_RANDOM
	#else
	-# define _LIBCPP_USING_DEV_RANDOM
	+# define _LIBCPP_USING_DEV_RANDOM
	#endif

	#if !defined(_LIBCPP_LITTLE_ENDIAN) && !defined(_LIBCPP_BIG_ENDIAN)
	-# include <endian.h>
	-# if __BYTE_ORDER == __LITTLE_ENDIAN
	-# define _LIBCPP_LITTLE_ENDIAN
	-# elif __BYTE_ORDER == __BIG_ENDIAN
	-# define _LIBCPP_BIG_ENDIAN
	-# else // __BYTE_ORDER == __BIG_ENDIAN
	-# error unable to determine endian
	-# endif
	+# include <endian.h>
	+# if __BYTE_ORDER == __LITTLE_ENDIAN
	+# define _LIBCPP_LITTLE_ENDIAN
	+# elif __BYTE_ORDER == __BIG_ENDIAN
	+# define _LIBCPP_BIG_ENDIAN
	+# else // __BYTE_ORDER == __BIG_ENDIAN
	+# error unable to determine endian
	+# endif
	#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")))
	+# define _LIBCPP_NO_CFI __attribute__((__no_sanitize__("cfi")))
	#else
	-#define _LIBCPP_NO_CFI
	+# define _LIBCPP_NO_CFI
	#endif

	#if defined(_LIBCPP_COMPILER_CLANG)

	// _LIBCPP_ALTERNATE_STRING_LAYOUT is an old name for
	// _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT left here for backward compatibility.
	#if (defined(__APPLE__) && !defined(__i386__) && !defined(__x86_64__) && \
	(!defined(__arm__) \|\| __ARM_ARCH_7K__ >= 2)) \|\| \
	defined(_LIBCPP_ALTERNATE_STRING_LAYOUT)
	#define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
	#endif

	#if __has_feature(cxx_alignas)
	# define _ALIGNAS_TYPE(x) alignas(x)
	# define _ALIGNAS(x) alignas(x)
	#else
	# define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
	# define _ALIGNAS(x) __attribute__((__aligned__(x)))
	#endif

	#if __cplusplus < 201103L
	typedef __char16_t char16_t;
	typedef __char32_t char32_t;
	#endif

	#if !(__has_feature(cxx_exceptions)) && !defined(_LIBCPP_NO_EXCEPTIONS)
	#define _LIBCPP_NO_EXCEPTIONS
	#endif

	#if !(__has_feature(cxx_rtti)) && !defined(_LIBCPP_NO_RTTI)
	#define _LIBCPP_NO_RTTI
	#endif

	#if !(__has_feature(cxx_strong_enums))
	#define _LIBCPP_HAS_NO_STRONG_ENUMS
	#endif

	#if !(__has_feature(cxx_decltype))
	#define _LIBCPP_HAS_NO_DECLTYPE
	#endif

	#if __has_feature(cxx_attributes)
	# define _LIBCPP_NORETURN [[noreturn]]
	#else
	# define _LIBCPP_NORETURN __attribute__ ((noreturn))
	#endif

	#if !(__has_feature(cxx_lambdas))
	#define _LIBCPP_HAS_NO_LAMBDAS
	#endif

	#if !(__has_feature(cxx_nullptr))
	-# if (__has_extension(cxx_nullptr) \|\| __has_keyword(__nullptr)) && defined(_LIBCPP_ABI_ALWAYS_USE_CXX11_NULLPTR)
	-# define nullptr __nullptr
	-# else
	-# define _LIBCPP_HAS_NO_NULLPTR
	-# endif
	+# if (__has_extension(cxx_nullptr) \|\| __has_keyword(__nullptr)) && defined(_LIBCPP_ABI_ALWAYS_USE_CXX11_NULLPTR)
	+# define nullptr __nullptr
	+# else
	+# define _LIBCPP_HAS_NO_NULLPTR
	+# endif
	#endif

	#if !(__has_feature(cxx_rvalue_references))
	#define _LIBCPP_HAS_NO_RVALUE_REFERENCES
	#endif

	#if !(__has_feature(cxx_auto_type))
	#define _LIBCPP_HAS_NO_AUTO_TYPE
	#endif

	#if !(__has_feature(cxx_variadic_templates))
	#define _LIBCPP_HAS_NO_VARIADICS
	#endif

	#if !(__has_feature(cxx_generalized_initializers))
	#define _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
	#endif

	#if __has_feature(is_base_of)
	-# define _LIBCPP_HAS_IS_BASE_OF
	+#define _LIBCPP_HAS_IS_BASE_OF
	#endif

	#if __has_feature(is_final)
	-# define _LIBCPP_HAS_IS_FINAL
	+#define _LIBCPP_HAS_IS_FINAL
	#endif

	// Objective-C++ features (opt-in)
	#if __has_feature(objc_arc)
	#define _LIBCPP_HAS_OBJC_ARC
	#endif

	#if __has_feature(objc_arc_weak)
	#define _LIBCPP_HAS_OBJC_ARC_WEAK
	#endif

	#if !(__has_feature(cxx_constexpr))
	#define _LIBCPP_HAS_NO_CONSTEXPR
	#endif

	#if !(__has_feature(cxx_relaxed_constexpr))
	#define _LIBCPP_HAS_NO_CXX14_CONSTEXPR
	#endif

	#if !(__has_feature(cxx_variable_templates))
	#define _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
	#endif

	#if __ISO_C_VISIBLE >= 2011 \|\| __cplusplus >= 201103L
	-#if defined(__FreeBSD__)
	-#define _LIBCPP_HAS_QUICK_EXIT
	-#define _LIBCPP_HAS_C11_FEATURES
	-#elif defined(__Fuchsia__)
	-#define _LIBCPP_HAS_QUICK_EXIT
	-#define _LIBCPP_HAS_C11_FEATURES
	-#elif defined(__linux__)
	-#if !defined(_LIBCPP_HAS_MUSL_LIBC)
	-#if __GLIBC_PREREQ(2, 15) \|\| defined(__BIONIC__)
	-#define _LIBCPP_HAS_QUICK_EXIT
	+# if defined(__FreeBSD__)
	+# define _LIBCPP_HAS_QUICK_EXIT
	+# define _LIBCPP_HAS_C11_FEATURES
	+# elif defined(__Fuchsia__)
	+# define _LIBCPP_HAS_QUICK_EXIT
	+# define _LIBCPP_HAS_C11_FEATURES
	+# elif defined(__linux__)
	+# if !defined(_LIBCPP_HAS_MUSL_LIBC)
	+# if _LIBCPP_GLIBC_PREREQ(2, 15) \|\| defined(__BIONIC__)
	+# define _LIBCPP_HAS_QUICK_EXIT
	+# endif
	+# if _LIBCPP_GLIBC_PREREQ(2, 17)
	+# define _LIBCPP_HAS_C11_FEATURES
	+# endif
	+# else // defined(_LIBCPP_HAS_MUSL_LIBC)
	+# define _LIBCPP_HAS_QUICK_EXIT
	+# define _LIBCPP_HAS_C11_FEATURES
	+# endif
	+# endif // __linux__
	#endif
	-#if __GLIBC_PREREQ(2, 17)
	-#define _LIBCPP_HAS_C11_FEATURES
	-#endif
	-#else // defined(_LIBCPP_HAS_MUSL_LIBC)
	-#define _LIBCPP_HAS_QUICK_EXIT
	-#define _LIBCPP_HAS_C11_FEATURES
	-#endif
	-#endif // __linux__
	-#endif

	#if !(__has_feature(cxx_noexcept))
	#define _LIBCPP_HAS_NO_NOEXCEPT
	#endif

	#if __has_feature(underlying_type)
	-# define _LIBCPP_UNDERLYING_TYPE(T) __underlying_type(T)
	+#define _LIBCPP_UNDERLYING_TYPE(T) __underlying_type(T)
	#endif

	#if __has_feature(is_literal)
	-# define _LIBCPP_IS_LITERAL(T) __is_literal(T)
	+#define _LIBCPP_IS_LITERAL(T) __is_literal(T)
	#endif

	// Inline namespaces are available in Clang regardless of C++ dialect.
	#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {inline namespace _LIBCPP_NAMESPACE {
	#define _LIBCPP_END_NAMESPACE_STD } }
	#define _VSTD std::_LIBCPP_NAMESPACE

	namespace std {
	inline namespace _LIBCPP_NAMESPACE {
	}
	}

	#if !defined(_LIBCPP_HAS_NO_ASAN) && !__has_feature(address_sanitizer)
	#define _LIBCPP_HAS_NO_ASAN
	#endif

	// Allow for build-time disabling of unsigned integer sanitization
	#if !defined(_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK) && __has_attribute(no_sanitize)
	#define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK __attribute__((__no_sanitize__("unsigned-integer-overflow")))
	-#endif
	+#endif

	#if __has_builtin(__builtin_launder)
	#define _LIBCPP_COMPILER_HAS_BUILTIN_LAUNDER
	#endif

	#if !__is_identifier(__has_unique_object_representations)
	#define _LIBCPP_HAS_UNIQUE_OBJECT_REPRESENTATIONS
	#endif

	+#define _LIBCPP_ALWAYS_INLINE __attribute__ ((__always_inline__))
	+
	#elif defined(_LIBCPP_COMPILER_GCC)

	#define _ALIGNAS(x) __attribute__((__aligned__(x)))
	#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))

	#define _LIBCPP_NORETURN __attribute__((noreturn))

	#if _GNUC_VER >= 407
	#define _LIBCPP_UNDERLYING_TYPE(T) __underlying_type(T)
	#define _LIBCPP_IS_LITERAL(T) __is_literal_type(T)
	#define _LIBCPP_HAS_IS_FINAL
	#endif

	#if defined(__GNUC__) && _GNUC_VER >= 403
	-# define _LIBCPP_HAS_IS_BASE_OF
	+#define _LIBCPP_HAS_IS_BASE_OF
	#endif

	#if !__EXCEPTIONS
	#define _LIBCPP_NO_EXCEPTIONS
	#endif

	// constexpr was added to GCC in 4.6.
	#if _GNUC_VER < 406
	-#define _LIBCPP_HAS_NO_CONSTEXPR
	+# define _LIBCPP_HAS_NO_CONSTEXPR
	// Can only use constexpr in c++11 mode.
	#elif !defined(__GXX_EXPERIMENTAL_CXX0X__) && __cplusplus < 201103L
	-#define _LIBCPP_HAS_NO_CONSTEXPR
	+# define _LIBCPP_HAS_NO_CONSTEXPR
	#endif

	// Determine if GCC supports relaxed constexpr
	#if !defined(__cpp_constexpr) \|\| __cpp_constexpr < 201304L
	#define _LIBCPP_HAS_NO_CXX14_CONSTEXPR
	#endif

	// GCC 5 will support variable templates
	#if !defined(__cpp_variable_templates) \|\| __cpp_variable_templates < 201304L
	#define _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
	#endif

	#ifndef __GXX_EXPERIMENTAL_CXX0X__
	+
	#define _LIBCPP_HAS_NO_DECLTYPE
	#define _LIBCPP_HAS_NO_NULLPTR
	#define _LIBCPP_HAS_NO_UNICODE_CHARS
	#define _LIBCPP_HAS_NO_VARIADICS
	#define _LIBCPP_HAS_NO_RVALUE_REFERENCES
	#define _LIBCPP_HAS_NO_STRONG_ENUMS
	#define _LIBCPP_HAS_NO_NOEXCEPT

	#else // __GXX_EXPERIMENTAL_CXX0X__

	#if _GNUC_VER < 403
	#define _LIBCPP_HAS_NO_RVALUE_REFERENCES
	#endif


	#if _GNUC_VER < 404
	#define _LIBCPP_HAS_NO_DECLTYPE
	#define _LIBCPP_HAS_NO_UNICODE_CHARS
	#define _LIBCPP_HAS_NO_VARIADICS
	#define _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
	#endif // _GNUC_VER < 404

	#if _GNUC_VER < 406
	#define _LIBCPP_HAS_NO_NOEXCEPT
	#define _LIBCPP_HAS_NO_NULLPTR
	#endif

	#endif // __GXX_EXPERIMENTAL_CXX0X__

	#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std { inline namespace _LIBCPP_NAMESPACE {
	#define _LIBCPP_END_NAMESPACE_STD } }
	#define _VSTD std::_LIBCPP_NAMESPACE

	namespace std {
	inline namespace _LIBCPP_NAMESPACE {
	}
	}

	#if !defined(_LIBCPP_HAS_NO_ASAN) && !defined(__SANITIZE_ADDRESS__)
	#define _LIBCPP_HAS_NO_ASAN
	#endif

	#if _GNUC_VER >= 700
	#define _LIBCPP_COMPILER_HAS_BUILTIN_LAUNDER
	#endif

	#if _GNUC_VER >= 700
	#define _LIBCPP_HAS_UNIQUE_OBJECT_REPRESENTATIONS
	#endif

	+#define _LIBCPP_ALWAYS_INLINE __attribute__ ((__always_inline__))
	+
	#elif defined(_LIBCPP_COMPILER_MSVC)

	#define _LIBCPP_TOSTRING2(x) #x
	#define _LIBCPP_TOSTRING(x) _LIBCPP_TOSTRING2(x)
	#define _LIBCPP_WARNING(x) __pragma(message(__FILE__ "(" _LIBCPP_TOSTRING(__LINE__) ") : warning note: " x))

	#if _MSC_VER < 1900
	#error "MSVC versions prior to Visual Studio 2015 are not supported"
	#endif

	#define _LIBCPP_HAS_IS_BASE_OF
	#define _LIBCPP_HAS_NO_CONSTEXPR
	#define _LIBCPP_HAS_NO_CXX14_CONSTEXPR
	#define _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
	-#if _MSC_VER <= 1800
	-#define _LIBCPP_HAS_NO_UNICODE_CHARS
	-#endif
	#define _LIBCPP_HAS_NO_NOEXCEPT
	#define __alignof__ __alignof
	#define _LIBCPP_NORETURN __declspec(noreturn)
	#define _ALIGNAS(x) __declspec(align(x))
	+#define _ALIGNAS_TYPE(x) alignas(x)
	#define _LIBCPP_HAS_NO_VARIADICS

	#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {
	#define _LIBCPP_END_NAMESPACE_STD }
	#define _VSTD std

	-# define _LIBCPP_WEAK
	namespace std {
	}

	+#define _LIBCPP_WEAK
	+
	#define _LIBCPP_HAS_NO_ASAN

	+#define _LIBCPP_ALWAYS_INLINE __forceinline
	+
	#elif defined(_LIBCPP_COMPILER_IBM)

	#define _ALIGNAS(x) __attribute__((__aligned__(x)))
	#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
	#define _ATTRIBUTE(x) __attribute__((x))
	#define _LIBCPP_NORETURN __attribute__((noreturn))

	#define _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
	#define _LIBCPP_HAS_NO_NOEXCEPT
	#define _LIBCPP_HAS_NO_NULLPTR
	#define _LIBCPP_HAS_NO_UNICODE_CHARS
	#define _LIBCPP_HAS_IS_BASE_OF
	#define _LIBCPP_HAS_IS_FINAL
	#define _LIBCPP_HAS_NO_VARIABLE_TEMPLATES

	#if defined(_AIX)
	#define __MULTILOCALE_API
	#endif

	#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {inline namespace _LIBCPP_NAMESPACE {
	#define _LIBCPP_END_NAMESPACE_STD } }
	#define _VSTD std::_LIBCPP_NAMESPACE

	namespace std {
	inline namespace _LIBCPP_NAMESPACE {
	}
	}

	#define _LIBCPP_HAS_NO_ASAN

	+#define _LIBCPP_ALWAYS_INLINE __attribute__ ((__always_inline__))
	+
	#endif // _LIBCPP_COMPILER_[CLANG\|GCC\|MSVC\|IBM]

	+#if _LIBCPP_STD_VER >= 17
	+#define _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM \
	+ _LIBCPP_BEGIN_NAMESPACE_STD inline namespace __fs { namespace filesystem {
	+#else
	+#define _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM \
	+ _LIBCPP_BEGIN_NAMESPACE_STD namespace __fs { namespace filesystem {
	+#endif
	+
	+#define _LIBCPP_END_NAMESPACE_FILESYSTEM \
	+ _LIBCPP_END_NAMESPACE_STD } }
	+
	+#define _VSTD_FS _VSTD::__fs::filesystem
	+
	+
	#if defined(_LIBCPP_OBJECT_FORMAT_COFF)
	+
	+#ifdef _DLL
	+# define _LIBCPP_CRT_FUNC __declspec(dllimport)
	+#else
	+# define _LIBCPP_CRT_FUNC
	+#endif
	+
	#if defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
	-# define _LIBCPP_DLL_VIS
	-# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS
	-# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
	-# define _LIBCPP_OVERRIDABLE_FUNC_VIS
	+# define _LIBCPP_DLL_VIS
	+# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS
	+# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
	+# define _LIBCPP_OVERRIDABLE_FUNC_VIS
	#elif defined(_LIBCPP_BUILDING_LIBRARY)
	-# define _LIBCPP_DLL_VIS __declspec(dllexport)
	-# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS
	-# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS _LIBCPP_DLL_VIS
	-# define _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_DLL_VIS
	+# define _LIBCPP_DLL_VIS __declspec(dllexport)
	+# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS
	+# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS _LIBCPP_DLL_VIS
	+# define _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_DLL_VIS
	#else
	-# define _LIBCPP_DLL_VIS __declspec(dllimport)
	-# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS _LIBCPP_DLL_VIS
	-# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
	-# define _LIBCPP_OVERRIDABLE_FUNC_VIS
	+# define _LIBCPP_DLL_VIS __declspec(dllimport)
	+# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS _LIBCPP_DLL_VIS
	+# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
	+# define _LIBCPP_OVERRIDABLE_FUNC_VIS
	#endif

	#define _LIBCPP_TYPE_VIS _LIBCPP_DLL_VIS
	#define _LIBCPP_FUNC_VIS _LIBCPP_DLL_VIS
	#define _LIBCPP_EXTERN_VIS _LIBCPP_DLL_VIS
	#define _LIBCPP_EXCEPTION_ABI _LIBCPP_DLL_VIS
	#define _LIBCPP_HIDDEN
	#define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	#define _LIBCPP_TEMPLATE_VIS
	#define _LIBCPP_ENUM_VIS

	#if defined(_LIBCPP_COMPILER_MSVC)
	-# define _LIBCPP_INLINE_VISIBILITY __forceinline
	-# define _LIBCPP_ALWAYS_INLINE __forceinline
	-# define _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY __forceinline
	+# define _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY __forceinline
	#else
	-# define _LIBCPP_INLINE_VISIBILITY __attribute__ ((__always_inline__))
	-# define _LIBCPP_ALWAYS_INLINE __attribute__ ((__always_inline__))
	-# define _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY __attribute__ ((__always_inline__))
	+# define _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY __attribute__ ((__always_inline__))
	#endif
	+
	#endif // defined(_LIBCPP_OBJECT_FORMAT_COFF)

	#ifndef _LIBCPP_HIDDEN
	-#if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
	-#define _LIBCPP_HIDDEN __attribute__ ((__visibility__("hidden")))
	-#else
	-#define _LIBCPP_HIDDEN
	+# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
	+# define _LIBCPP_HIDDEN __attribute__ ((__visibility__("hidden")))
	+# else
	+# define _LIBCPP_HIDDEN
	+# endif
	#endif
	-#endif

	#ifndef _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	-#if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
	+# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
	// The inline should be removed once PR32114 is resolved
	-#define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS inline _LIBCPP_HIDDEN
	-#else
	-#define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+# define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS inline _LIBCPP_HIDDEN
	+# else
	+# define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+# endif
	#endif
	-#endif

	#ifndef _LIBCPP_FUNC_VIS
	-#if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
	-#define _LIBCPP_FUNC_VIS __attribute__ ((__visibility__("default")))
	-#else
	-#define _LIBCPP_FUNC_VIS
	+# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
	+# define _LIBCPP_FUNC_VIS __attribute__ ((__visibility__("default")))
	+# else
	+# define _LIBCPP_FUNC_VIS
	+# endif
	#endif
	-#endif

	#ifndef _LIBCPP_TYPE_VIS
	# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
	# define _LIBCPP_TYPE_VIS __attribute__ ((__visibility__("default")))
	# else
	# define _LIBCPP_TYPE_VIS
	# endif
	#endif

	#ifndef _LIBCPP_TEMPLATE_VIS
	# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
	# if __has_attribute(__type_visibility__)
	# define _LIBCPP_TEMPLATE_VIS __attribute__ ((__type_visibility__("default")))
	# else
	# define _LIBCPP_TEMPLATE_VIS __attribute__ ((__visibility__("default")))
	# endif
	# else
	# define _LIBCPP_TEMPLATE_VIS
	# endif
	#endif

	#ifndef _LIBCPP_EXTERN_VIS
	-# define _LIBCPP_EXTERN_VIS
	+#define _LIBCPP_EXTERN_VIS
	#endif

	#ifndef _LIBCPP_OVERRIDABLE_FUNC_VIS
	-# define _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_FUNC_VIS
	+#define _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_FUNC_VIS
	#endif

	#ifndef _LIBCPP_EXCEPTION_ABI
	-#if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
	-#define _LIBCPP_EXCEPTION_ABI __attribute__ ((__visibility__("default")))
	-#else
	-#define _LIBCPP_EXCEPTION_ABI
	+# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
	+# define _LIBCPP_EXCEPTION_ABI __attribute__ ((__visibility__("default")))
	+# else
	+# define _LIBCPP_EXCEPTION_ABI
	+# endif
	#endif
	-#endif

	#ifndef _LIBCPP_ENUM_VIS
	# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS) && __has_attribute(__type_visibility__)
	# define _LIBCPP_ENUM_VIS __attribute__ ((__type_visibility__("default")))
	# else
	# define _LIBCPP_ENUM_VIS
	# endif
	#endif

	#ifndef _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS
	# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS) && __has_attribute(__type_visibility__)
	# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __attribute__ ((__visibility__("default")))
	# else
	# define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS
	# endif
	#endif

	#ifndef _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
	-# define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
	+#define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
	#endif

	-#ifndef _LIBCPP_INLINE_VISIBILITY
	-#if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
	-#define _LIBCPP_INLINE_VISIBILITY __attribute__ ((__visibility__("hidden"), __always_inline__))
	+#if __has_attribute(internal_linkage)
	+# define _LIBCPP_INTERNAL_LINKAGE __attribute__ ((internal_linkage))
	#else
	-#define _LIBCPP_INLINE_VISIBILITY __attribute__ ((__always_inline__))
	+# define _LIBCPP_INTERNAL_LINKAGE _LIBCPP_ALWAYS_INLINE
	#endif
	-#endif

	-#ifndef _LIBCPP_ALWAYS_INLINE
	-#if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
	-#define _LIBCPP_ALWAYS_INLINE __attribute__ ((__visibility__("hidden"), __always_inline__))
	-#else
	-#define _LIBCPP_ALWAYS_INLINE __attribute__ ((__always_inline__))
	+#ifndef _LIBCPP_HIDE_FROM_ABI
	+# define _LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDDEN _LIBCPP_INTERNAL_LINKAGE
	#endif
	-#endif

	+// Just so we can migrate to _LIBCPP_HIDE_FROM_ABI gradually.
	+#define _LIBCPP_INLINE_VISIBILITY _LIBCPP_HIDE_FROM_ABI
	+
	#ifndef _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	-# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
	-# define _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY __attribute__((__visibility__("default"), __always_inline__))
	-# else
	-# define _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY __attribute__((__always_inline__))
	-# endif
	+# if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
	+# define _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY __attribute__((__visibility__("default"), __always_inline__))
	+# else
	+# define _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY __attribute__((__always_inline__))
	+# endif
	#endif

	#ifndef _LIBCPP_PREFERRED_OVERLOAD
	# if __has_attribute(__enable_if__)
	# define _LIBCPP_PREFERRED_OVERLOAD __attribute__ ((__enable_if__(true, "")))
	# endif
	#endif

	#ifndef _LIBCPP_HAS_NO_NOEXCEPT
	# define _NOEXCEPT noexcept
	# define _NOEXCEPT_(x) noexcept(x)
	#else
	# define _NOEXCEPT throw()
	# define _NOEXCEPT_(x)
	#endif

	#if defined(_LIBCPP_DEBUG_USE_EXCEPTIONS)
	-# if !defined(_LIBCPP_DEBUG)
	-# error cannot use _LIBCPP_DEBUG_USE_EXCEPTIONS unless _LIBCPP_DEBUG is defined
	-# endif
	-# define _NOEXCEPT_DEBUG noexcept(false)
	-# define _NOEXCEPT_DEBUG_(x) noexcept(false)
	+# if !defined(_LIBCPP_DEBUG)
	+# error cannot use _LIBCPP_DEBUG_USE_EXCEPTIONS unless _LIBCPP_DEBUG is defined
	+# endif
	+# ifdef _LIBCPP_HAS_NO_NOEXCEPT
	+# define _NOEXCEPT_DEBUG
	+# define _NOEXCEPT_DEBUG_(x)
	+# else
	+# define _NOEXCEPT_DEBUG noexcept(false)
	+# define _NOEXCEPT_DEBUG_(x) noexcept(false)
	+# endif
	#else
	-# define _NOEXCEPT_DEBUG _NOEXCEPT
	-# define _NOEXCEPT_DEBUG_(x) _NOEXCEPT_(x)
	+# define _NOEXCEPT_DEBUG _NOEXCEPT
	+# define _NOEXCEPT_DEBUG_(x) _NOEXCEPT_(x)
	#endif

	#ifdef _LIBCPP_HAS_NO_UNICODE_CHARS
	typedef unsigned short char16_t;
	typedef unsigned int char32_t;
	#endif // _LIBCPP_HAS_NO_UNICODE_CHARS

	#ifndef __SIZEOF_INT128__
	#define _LIBCPP_HAS_NO_INT128
	#endif

	#ifdef _LIBCPP_CXX03_LANG
	-# if __has_extension(c_static_assert)
	-# define static_assert(__b, __m) _Static_assert(__b, __m)
	-# else
	+# if __has_extension(c_static_assert)
	+# define static_assert(__b, __m) _Static_assert(__b, __m)
	+# else
	extern "C++" {
	template <bool> struct __static_assert_test;
	template <> struct __static_assert_test<true> {};
	template <unsigned> struct __static_assert_check {};
	}
	-#define static_assert(__b, __m) \
	- typedef __static_assert_check<sizeof(__static_assert_test<(__b)>)> \
	- _LIBCPP_CONCAT(__t, __LINE__)
	-# endif // __has_extension(c_static_assert)
	+# define static_assert(__b, __m) \
	+ typedef __static_assert_check<sizeof(__static_assert_test<(__b)>)> \
	+ _LIBCPP_CONCAT(__t, __LINE__)
	+# endif // __has_extension(c_static_assert)
	#endif // _LIBCPP_CXX03_LANG

	#ifdef _LIBCPP_HAS_NO_DECLTYPE
	// GCC 4.6 provides __decltype in all standard modes.
	-#if __has_keyword(__decltype) \|\| _LIBCPP_CLANG_VER >= 304 \|\| _GNUC_VER >= 406
	-# define decltype(__x) __decltype(__x)
	-#else
	-# define decltype(__x) __typeof__(__x)
	+# if __has_keyword(__decltype) \|\| _LIBCPP_CLANG_VER >= 304 \|\| _GNUC_VER >= 406
	+# define decltype(__x) __decltype(__x)
	+# else
	+# define decltype(__x) __typeof__(__x)
	+# endif
	#endif
	-#endif

	#ifdef _LIBCPP_HAS_NO_CONSTEXPR
	-#define _LIBCPP_CONSTEXPR
	+# define _LIBCPP_CONSTEXPR
	#else
	-#define _LIBCPP_CONSTEXPR constexpr
	+# define _LIBCPP_CONSTEXPR constexpr
	#endif

	#ifdef _LIBCPP_CXX03_LANG
	-#define _LIBCPP_DEFAULT {}
	+# define _LIBCPP_DEFAULT {}
	#else
	-#define _LIBCPP_DEFAULT = default;
	+# define _LIBCPP_DEFAULT = default;
	#endif

	#ifdef _LIBCPP_CXX03_LANG
	-#define _LIBCPP_EQUAL_DELETE
	+# define _LIBCPP_EQUAL_DELETE
	#else
	-#define _LIBCPP_EQUAL_DELETE = delete
	+# define _LIBCPP_EQUAL_DELETE = delete
	#endif

	#ifdef __GNUC__
	-#define _NOALIAS __attribute__((__malloc__))
	+# define _NOALIAS __attribute__((__malloc__))
	#else
	-#define _NOALIAS
	+# define _NOALIAS
	#endif

	#if __has_feature(cxx_explicit_conversions) \|\| defined(__IBMCPP__) \|\| \
	(!defined(_LIBCPP_CXX03_LANG) && defined(__GNUC__)) // All supported GCC versions
	-# define _LIBCPP_EXPLICIT explicit
	+# define _LIBCPP_EXPLICIT explicit
	#else
	-# define _LIBCPP_EXPLICIT
	+# define _LIBCPP_EXPLICIT
	#endif

	#if !__has_builtin(__builtin_operator_new) \|\| !__has_builtin(__builtin_operator_delete)
	-# define _LIBCPP_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE
	+#define _LIBCPP_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE
	#endif

	#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
	-#define _LIBCPP_DECLARE_STRONG_ENUM(x) struct _LIBCPP_TYPE_VIS x { enum __lx
	-#define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x) \
	- __lx __v_; \
	- _LIBCPP_ALWAYS_INLINE x(__lx __v) : __v_(__v) {} \
	- _LIBCPP_ALWAYS_INLINE explicit x(int __v) : __v_(static_cast<__lx>(__v)) {} \
	- _LIBCPP_ALWAYS_INLINE operator int() const {return __v_;} \
	- };
	+# define _LIBCPP_DECLARE_STRONG_ENUM(x) struct _LIBCPP_TYPE_VIS x { enum __lx
	+# define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x) \
	+ __lx __v_; \
	+ _LIBCPP_INLINE_VISIBILITY x(__lx __v) : __v_(__v) {} \
	+ _LIBCPP_INLINE_VISIBILITY explicit x(int __v) : __v_(static_cast<__lx>(__v)) {} \
	+ _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;} \
	+ };
	#else // _LIBCPP_HAS_NO_STRONG_ENUMS
	-#define _LIBCPP_DECLARE_STRONG_ENUM(x) enum class _LIBCPP_ENUM_VIS x
	-#define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x)
	+# define _LIBCPP_DECLARE_STRONG_ENUM(x) enum class _LIBCPP_ENUM_VIS x
	+# define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x)
	#endif // _LIBCPP_HAS_NO_STRONG_ENUMS

	#ifdef _LIBCPP_DEBUG
	-# if _LIBCPP_DEBUG == 0
	-# define _LIBCPP_DEBUG_LEVEL 1
	-# elif _LIBCPP_DEBUG == 1
	-# define _LIBCPP_DEBUG_LEVEL 2
	-# else
	-# error Supported values for _LIBCPP_DEBUG are 0 and 1
	-# endif
	-# if !defined(_LIBCPP_BUILDING_LIBRARY)
	-# define _LIBCPP_EXTERN_TEMPLATE(...)
	-# endif
	+# if _LIBCPP_DEBUG == 0
	+# define _LIBCPP_DEBUG_LEVEL 1
	+# elif _LIBCPP_DEBUG == 1
	+# define _LIBCPP_DEBUG_LEVEL 2
	+# else
	+# error Supported values for _LIBCPP_DEBUG are 0 and 1
	+# endif
	+# if !defined(_LIBCPP_BUILDING_LIBRARY)
	+# define _LIBCPP_EXTERN_TEMPLATE(...)
	+# endif
	#endif

	#ifdef _LIBCPP_DISABLE_EXTERN_TEMPLATE
	#define _LIBCPP_EXTERN_TEMPLATE(...)
	#define _LIBCPP_EXTERN_TEMPLATE2(...)
	#endif

	#ifndef _LIBCPP_EXTERN_TEMPLATE
	#define _LIBCPP_EXTERN_TEMPLATE(...) extern template __VA_ARGS__;
	#endif

	#ifndef _LIBCPP_EXTERN_TEMPLATE2
	#define _LIBCPP_EXTERN_TEMPLATE2(...) extern template __VA_ARGS__;
	#endif

	#if defined(__APPLE__) && defined(__LP64__) && !defined(__x86_64__)
	#define _LIBCPP_NONUNIQUE_RTTI_BIT (1ULL << 63)
	#endif

	#if defined(__APPLE__) \|\| defined(__FreeBSD__) \|\| defined(_LIBCPP_MSVCRT_LIKE) \|\| \
	defined(__sun__) \|\| defined(__NetBSD__) \|\| defined(__CloudABI__)
	#define _LIBCPP_LOCALE__L_EXTENSIONS 1
	#endif

	#if defined(__unix__) \|\| (defined(__APPLE__) && defined(__MACH__))
	// Most unix variants have catopen. These are the specific ones that don't.
	-#if !defined(__BIONIC__) && !defined(_NEWLIB_VERSION)
	-#define _LIBCPP_HAS_CATOPEN 1
	+# if !defined(__BIONIC__) && !defined(_NEWLIB_VERSION)
	+# define _LIBCPP_HAS_CATOPEN 1
	+# endif
	#endif
	-#endif

	#ifdef __FreeBSD__
	#define _DECLARE_C99_LDBL_MATH 1
	#endif

	+// If we are getting operator new from the MSVC CRT, then allocation overloads
	+// for align_val_t were added in 19.12, aka VS 2017 version 15.3.
	+#if defined(_LIBCPP_MSVCRT) && defined(_MSC_VER) && _MSC_VER < 1912
	+#define _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
	+#endif
	+
	#if defined(__APPLE__)
	-# if !defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && \
	- defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
	-# define __MAC_OS_X_VERSION_MIN_REQUIRED __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
	-# endif
	-# if defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
	-# if __MAC_OS_X_VERSION_MIN_REQUIRED < 1060
	-# define _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
	-# endif
	-# endif
	+# if !defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && \
	+ defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
	+# define __MAC_OS_X_VERSION_MIN_REQUIRED __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
	+# endif
	+# if defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
	+# if __MAC_OS_X_VERSION_MIN_REQUIRED < 1060
	+# define _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
	+# endif
	+# endif
	#endif // defined(__APPLE__)

	+
	#if defined(__APPLE__) \|\| defined(__FreeBSD__)
	#define _LIBCPP_HAS_DEFAULTRUNELOCALE
	#endif

	#if defined(__APPLE__) \|\| defined(__FreeBSD__) \|\| defined(__sun__)
	#define _LIBCPP_WCTYPE_IS_MASK
	#endif

	-#ifndef _LIBCPP_STD_VER
	-# if __cplusplus <= 201103L
	-# define _LIBCPP_STD_VER 11
	-# elif __cplusplus <= 201402L
	-# define _LIBCPP_STD_VER 14
	-# elif __cplusplus <= 201703L
	-# define _LIBCPP_STD_VER 17
	-# else
	-# define _LIBCPP_STD_VER 18 // current year, or date of c++2a ratification
	-# endif
	-#endif // _LIBCPP_STD_VER
	-
	#if _LIBCPP_STD_VER > 11
	-#define _LIBCPP_DEPRECATED [[deprecated]]
	+# define _LIBCPP_DEPRECATED [[deprecated]]
	#else
	-#define _LIBCPP_DEPRECATED
	+# define _LIBCPP_DEPRECATED
	#endif

	#if _LIBCPP_STD_VER <= 11
	-#define _LIBCPP_EXPLICIT_AFTER_CXX11
	-#define _LIBCPP_DEPRECATED_AFTER_CXX11
	+# define _LIBCPP_EXPLICIT_AFTER_CXX11
	+# define _LIBCPP_DEPRECATED_AFTER_CXX11
	#else
	-#define _LIBCPP_EXPLICIT_AFTER_CXX11 explicit
	-#define _LIBCPP_DEPRECATED_AFTER_CXX11 [[deprecated]]
	+# define _LIBCPP_EXPLICIT_AFTER_CXX11 explicit
	+# define _LIBCPP_DEPRECATED_AFTER_CXX11 [[deprecated]]
	#endif

	#if _LIBCPP_STD_VER > 11 && !defined(_LIBCPP_HAS_NO_CXX14_CONSTEXPR)
	-#define _LIBCPP_CONSTEXPR_AFTER_CXX11 constexpr
	+# define _LIBCPP_CONSTEXPR_AFTER_CXX11 constexpr
	#else
	-#define _LIBCPP_CONSTEXPR_AFTER_CXX11
	+# define _LIBCPP_CONSTEXPR_AFTER_CXX11
	#endif

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_CXX14_CONSTEXPR)
	-#define _LIBCPP_CONSTEXPR_AFTER_CXX14 constexpr
	+# define _LIBCPP_CONSTEXPR_AFTER_CXX14 constexpr
	#else
	-#define _LIBCPP_CONSTEXPR_AFTER_CXX14
	+# define _LIBCPP_CONSTEXPR_AFTER_CXX14
	#endif

	#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CXX14_CONSTEXPR)
	-#define _LIBCPP_CONSTEXPR_AFTER_CXX17 constexpr
	+# define _LIBCPP_CONSTEXPR_AFTER_CXX17 constexpr
	#else
	-#define _LIBCPP_CONSTEXPR_AFTER_CXX17
	+# 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]]
	+# define _LIBCPP_NODISCARD_AFTER_CXX17 [[nodiscard]]
	#else
	-#define _LIBCPP_NODISCARD_AFTER_CXX17
	+# define _LIBCPP_NODISCARD_AFTER_CXX17
	#endif

	#if _LIBCPP_STD_VER > 14 && defined(__cpp_inline_variables) && (__cpp_inline_variables >= 201606L)
	-# define _LIBCPP_INLINE_VAR inline
	+# define _LIBCPP_INLINE_VAR inline
	#else
	-# define _LIBCPP_INLINE_VAR
	+# define _LIBCPP_INLINE_VAR
	#endif

	#ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	# define _LIBCPP_EXPLICIT_MOVE(x) _VSTD::move(x)
	#else
	# define _LIBCPP_EXPLICIT_MOVE(x) (x)
	#endif

	+#ifndef _LIBCPP_CONSTEXPR_IF_NODEBUG
	+#if defined(_LIBCPP_DEBUG) \|\| defined(_LIBCPP_HAS_NO_CXX14_CONSTEXPR)
	+#define _LIBCPP_CONSTEXPR_IF_NODEBUG
	+#else
	+#define _LIBCPP_CONSTEXPR_IF_NODEBUG constexpr
	+#endif
	+#endif
	+
	#ifndef _LIBCPP_HAS_NO_ASAN
	_LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container(
	const void , const void , const void , const void );
	#endif

	// Try to find out if RTTI is disabled.
	// g++ and cl.exe have RTTI on by default and define a macro when it is.
	// g++ only defines the macro in 4.3.2 and onwards.
	#if !defined(_LIBCPP_NO_RTTI)
	-# if defined(__GNUC__) && ((__GNUC__ >= 5) \|\| (__GNUC__ == 4 && \
	- (__GNUC_MINOR__ >= 3 \|\| __GNUC_PATCHLEVEL__ >= 2))) && !defined(__GXX_RTTI)
	+# if defined(__GNUC__) && \
	+ ((__GNUC__ >= 5) \|\| \
	+ (__GNUC__ == 4 && (__GNUC_MINOR__ >= 3 \|\| __GNUC_PATCHLEVEL__ >= 2))) && \
	+ !defined(__GXX_RTTI)
	# define _LIBCPP_NO_RTTI
	# elif defined(_LIBCPP_COMPILER_MSVC) && !defined(_CPPRTTI)
	# define _LIBCPP_NO_RTTI
	# endif
	#endif

	#ifndef _LIBCPP_WEAK
	-# define _LIBCPP_WEAK __attribute__((__weak__))
	+#define _LIBCPP_WEAK __attribute__((__weak__))
	#endif

	// Thread API
	#if !defined(_LIBCPP_HAS_NO_THREADS) && \
	!defined(_LIBCPP_HAS_THREAD_API_PTHREAD) && \
	!defined(_LIBCPP_HAS_THREAD_API_WIN32) && \
	!defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
	-# if defined(__FreeBSD__) \|\| \
	- defined(__Fuchsia__) \|\| \
	- defined(__NetBSD__) \|\| \
	- defined(__linux__) \|\| \
	- defined(__APPLE__) \|\| \
	- defined(__CloudABI__) \|\| \
	- defined(__sun__) \|\| \
	- (defined(__MINGW32__) && __libcpp_has_include(<pthread.h>))
	-# define _LIBCPP_HAS_THREAD_API_PTHREAD
	-# elif defined(_LIBCPP_WIN32API)
	-# define _LIBCPP_HAS_THREAD_API_WIN32
	-# else
	-# error "No thread API"
	-# endif // _LIBCPP_HAS_THREAD_API
	+# if defined(__FreeBSD__) \|\| \
	+ defined(__Fuchsia__) \|\| \
	+ defined(__NetBSD__) \|\| \
	+ defined(__linux__) \|\| \
	+ defined(__APPLE__) \|\| \
	+ defined(__CloudABI__) \|\| \
	+ defined(__sun__) \|\| \
	+ (defined(__MINGW32__) && __has_include(<pthread.h>))
	+# define _LIBCPP_HAS_THREAD_API_PTHREAD
	+# elif defined(_LIBCPP_WIN32API)
	+# define _LIBCPP_HAS_THREAD_API_WIN32
	+# else
	+# error "No thread API"
	+# endif // _LIBCPP_HAS_THREAD_API
	#endif // _LIBCPP_HAS_NO_THREADS

	#if defined(_LIBCPP_HAS_NO_THREADS) && defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
	-# error _LIBCPP_HAS_THREAD_API_PTHREAD may only be defined when \
	- _LIBCPP_HAS_NO_THREADS is not defined.
	+#error _LIBCPP_HAS_THREAD_API_PTHREAD may only be defined when \
	+ _LIBCPP_HAS_NO_THREADS is not defined.
	#endif

	#if defined(_LIBCPP_HAS_NO_THREADS) && defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
	-# error _LIBCPP_HAS_THREAD_API_EXTERNAL may not be defined when \
	- _LIBCPP_HAS_NO_THREADS is defined.
	+#error _LIBCPP_HAS_THREAD_API_EXTERNAL may not be defined when \
	+ _LIBCPP_HAS_NO_THREADS is defined.
	#endif

	#if defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK) && !defined(_LIBCPP_HAS_NO_THREADS)
	-# error _LIBCPP_HAS_NO_MONOTONIC_CLOCK may only be defined when \
	- _LIBCPP_HAS_NO_THREADS is defined.
	+#error _LIBCPP_HAS_NO_MONOTONIC_CLOCK may only be defined when \
	+ _LIBCPP_HAS_NO_THREADS is defined.
	#endif

	// Systems that use capability-based security (FreeBSD with Capsicum,
	// Nuxi CloudABI) may only provide local filesystem access (using *at()).
	// Functions like open(), rename(), unlink() and stat() should not be
	// used, as they attempt to access the global filesystem namespace.
	#ifdef __CloudABI__
	#define _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
	#endif

	// CloudABI is intended for running networked services. Processes do not
	// have standard input and output channels.
	#ifdef __CloudABI__
	#define _LIBCPP_HAS_NO_STDIN
	#define _LIBCPP_HAS_NO_STDOUT
	#endif

	#if defined(__BIONIC__) \|\| defined(__CloudABI__) \|\| \
	defined(__Fuchsia__) \|\| defined(_LIBCPP_HAS_MUSL_LIBC)
	#define _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
	#endif

	// Thread-unsafe functions such as strtok() and localtime()
	// are not available.
	#ifdef __CloudABI__
	#define _LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
	#endif

	#if __has_feature(cxx_atomic) \|\| __has_extension(c_atomic) \|\| __has_keyword(_Atomic)
	-#define _LIBCPP_HAS_C_ATOMIC_IMP
	+# define _LIBCPP_HAS_C_ATOMIC_IMP
	#elif _GNUC_VER > 407
	-#define _LIBCPP_HAS_GCC_ATOMIC_IMP
	+# define _LIBCPP_HAS_GCC_ATOMIC_IMP
	#endif

	#if (!defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_GCC_ATOMIC_IMP)) \
	\|\| defined(_LIBCPP_HAS_NO_THREADS)
	#define _LIBCPP_HAS_NO_ATOMIC_HEADER
	#endif

	#ifndef _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
	#define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
	#endif

	#if defined(_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS)
	-#if defined(__clang__) && __has_attribute(acquire_capability)
	+# if defined(__clang__) && __has_attribute(acquire_capability)
	// Work around the attribute handling in clang. When both __declspec and
	// __attribute__ are present, the processing goes awry preventing the definition
	// of the types.
	-#if !defined(_LIBCPP_OBJECT_FORMAT_COFF)
	-#define _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS
	+# if !defined(_LIBCPP_OBJECT_FORMAT_COFF)
	+# define _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS
	+# endif
	+# endif
	#endif
	-#endif
	-#endif

	#if __has_attribute(require_constant_initialization)
	-#define _LIBCPP_SAFE_STATIC __attribute__((__require_constant_initialization__))
	+# define _LIBCPP_SAFE_STATIC __attribute__((__require_constant_initialization__))
	#else
	-#define _LIBCPP_SAFE_STATIC
	+# define _LIBCPP_SAFE_STATIC
	#endif

	#if !__has_builtin(__builtin_addressof) && _GNUC_VER < 700
	-# define _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
	+#define _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
	#endif

	#if !defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
	-#if defined(_LIBCPP_MSVCRT) \|\| defined(_NEWLIB_VERSION)
	-#define _LIBCPP_HAS_NO_OFF_T_FUNCTIONS
	+# if defined(_LIBCPP_MSVCRT) \|\| defined(_NEWLIB_VERSION)
	+# define _LIBCPP_HAS_NO_OFF_T_FUNCTIONS
	+# endif
	#endif
	-#endif

	#if __has_attribute(diagnose_if) && !defined(_LIBCPP_DISABLE_ADDITIONAL_DIAGNOSTICS)
	-# define _LIBCPP_DIAGNOSE_WARNING(...) \
	- __attribute__((diagnose_if(__VA_ARGS__, "warning")))
	-# define _LIBCPP_DIAGNOSE_ERROR(...) \
	- __attribute__((diagnose_if(__VA_ARGS__, "error")))
	+# define _LIBCPP_DIAGNOSE_WARNING(...) \
	+ __attribute__((diagnose_if(__VA_ARGS__, "warning")))
	+# define _LIBCPP_DIAGNOSE_ERROR(...) \
	+ __attribute__((diagnose_if(__VA_ARGS__, "error")))
	#else
	-# define _LIBCPP_DIAGNOSE_WARNING(...)
	-# define _LIBCPP_DIAGNOSE_ERROR(...)
	+# define _LIBCPP_DIAGNOSE_WARNING(...)
	+# define _LIBCPP_DIAGNOSE_ERROR(...)
	#endif

	#if __has_attribute(fallthough) \|\| _GNUC_VER >= 700
	// Use a function like macro to imply that it must be followed by a semicolon
	-#define _LIBCPP_FALLTHROUGH() __attribute__((__fallthrough__))
	+# define _LIBCPP_FALLTHROUGH() __attribute__((__fallthrough__))
	#else
	-#define _LIBCPP_FALLTHROUGH() ((void)0)
	+# define _LIBCPP_FALLTHROUGH() ((void)0)
	#endif

	#if defined(_LIBCPP_ABI_MICROSOFT) && \
	- (defined(_LIBCPP_COMPILER_MSVC) \|\| __has_declspec_attribute(empty_bases))
	-# define _LIBCPP_DECLSPEC_EMPTY_BASES __declspec(empty_bases)
	+ (defined(_LIBCPP_COMPILER_MSVC) \|\| __has_declspec_attribute(empty_bases))
	+# define _LIBCPP_DECLSPEC_EMPTY_BASES __declspec(empty_bases)
	#else
	-# define _LIBCPP_DECLSPEC_EMPTY_BASES
	+# define _LIBCPP_DECLSPEC_EMPTY_BASES
	#endif

	#if defined(_LIBCPP_ENABLE_CXX17_REMOVED_FEATURES)
	-# define _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
	-# define _LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS
	-# define _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
	-# define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
	+#define _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
	+#define _LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS
	+#define _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
	+#define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
	#endif // _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES

	#if !defined(__cpp_deduction_guides) \|\| __cpp_deduction_guides < 201611
	-# define _LIBCPP_HAS_NO_DEDUCTION_GUIDES
	+#define _LIBCPP_HAS_NO_DEDUCTION_GUIDES
	#endif

	#if !__has_keyword(__is_aggregate) && (_GNUC_VER_NEW < 7001)
	-# define _LIBCPP_HAS_NO_IS_AGGREGATE
	+#define _LIBCPP_HAS_NO_IS_AGGREGATE
	#endif

	#if !defined(__cpp_coroutines) \|\| __cpp_coroutines < 201703L
	-# define _LIBCPP_HAS_NO_COROUTINES
	+#define _LIBCPP_HAS_NO_COROUTINES
	#endif

	+// FIXME: Correct this macro when either (A) a feature test macro for the
	+// spaceship operator is provided, or (B) a compiler provides a complete
	+// implementation.
	+#define _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
	+
	// Decide whether to use availability macros.
	#if !defined(_LIBCPP_BUILDING_LIBRARY) && \
	!defined(_LIBCPP_DISABLE_AVAILABILITY) && \
	__has_feature(attribute_availability_with_strict) && \
	__has_feature(attribute_availability_in_templates)
	-#ifdef __APPLE__
	-#define _LIBCPP_USE_AVAILABILITY_APPLE
	+# ifdef __APPLE__
	+# define _LIBCPP_USE_AVAILABILITY_APPLE
	+# endif
	#endif
	-#endif

	// Define availability macros.
	#if defined(_LIBCPP_USE_AVAILABILITY_APPLE)
	-#define _LIBCPP_AVAILABILITY_SHARED_MUTEX \
	- __attribute__((availability(macosx,strict,introduced=10.12))) \
	- __attribute__((availability(ios,strict,introduced=10.0))) \
	- __attribute__((availability(tvos,strict,introduced=10.0))) \
	- __attribute__((availability(watchos,strict,introduced=3.0)))
	-#define _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS __attribute__((unavailable))
	-#define _LIBCPP_AVAILABILITY_BAD_ARRAY_LENGTH __attribute__((unavailable))
	-#define _LIBCPP_AVAILABILITY_BAD_ANY_CAST __attribute__((unavailable))
	-#define _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS \
	- __attribute__((availability(macosx,strict,introduced=10.12))) \
	- __attribute__((availability(ios,strict,introduced=10.0))) \
	- __attribute__((availability(tvos,strict,introduced=10.0))) \
	- __attribute__((availability(watchos,strict,introduced=3.0)))
	-#define _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE \
	- __attribute__((availability(macosx,strict,introduced=10.12))) \
	- __attribute__((availability(ios,strict,introduced=10.0))) \
	- __attribute__((availability(tvos,strict,introduced=10.0))) \
	- __attribute__((availability(watchos,strict,introduced=3.0)))
	-#define _LIBCPP_AVAILABILITY_FUTURE_ERROR \
	- __attribute__((availability(ios,strict,introduced=6.0)))
	-#define _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE \
	- __attribute__((availability(macosx,strict,introduced=10.9))) \
	- __attribute__((availability(ios,strict,introduced=7.0)))
	-#define _LIBCPP_AVAILABILITY_LOCALE_CATEGORY \
	- __attribute__((availability(macosx,strict,introduced=10.9))) \
	- __attribute__((availability(ios,strict,introduced=7.0)))
	-#define _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR \
	- __attribute__((availability(macosx,strict,introduced=10.9))) \
	- __attribute__((availability(ios,strict,introduced=7.0)))
	+# define _LIBCPP_AVAILABILITY_SHARED_MUTEX \
	+ __attribute__((availability(macosx,strict,introduced=10.12))) \
	+ __attribute__((availability(ios,strict,introduced=10.0))) \
	+ __attribute__((availability(tvos,strict,introduced=10.0))) \
	+ __attribute__((availability(watchos,strict,introduced=3.0)))
	+# define _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS __attribute__((unavailable))
	+# define _LIBCPP_AVAILABILITY_BAD_ARRAY_LENGTH __attribute__((unavailable))
	+# define _LIBCPP_AVAILABILITY_BAD_ANY_CAST __attribute__((unavailable))
	+# define _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS \
	+ __attribute__((availability(macosx,strict,introduced=10.12))) \
	+ __attribute__((availability(ios,strict,introduced=10.0))) \
	+ __attribute__((availability(tvos,strict,introduced=10.0))) \
	+ __attribute__((availability(watchos,strict,introduced=3.0)))
	+# define _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE \
	+ __attribute__((availability(macosx,strict,introduced=10.12))) \
	+ __attribute__((availability(ios,strict,introduced=10.0))) \
	+ __attribute__((availability(tvos,strict,introduced=10.0))) \
	+ __attribute__((availability(watchos,strict,introduced=3.0)))
	+# define _LIBCPP_AVAILABILITY_FUTURE_ERROR \
	+ __attribute__((availability(ios,strict,introduced=6.0)))
	+# define _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE \
	+ __attribute__((availability(macosx,strict,introduced=10.9))) \
	+ __attribute__((availability(ios,strict,introduced=7.0)))
	+# define _LIBCPP_AVAILABILITY_LOCALE_CATEGORY \
	+ __attribute__((availability(macosx,strict,introduced=10.9))) \
	+ __attribute__((availability(ios,strict,introduced=7.0)))
	+# define _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR \
	+ __attribute__((availability(macosx,strict,introduced=10.9))) \
	+ __attribute__((availability(ios,strict,introduced=7.0)))
	#else
	-#define _LIBCPP_AVAILABILITY_SHARED_MUTEX
	-#define _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
	-#define _LIBCPP_AVAILABILITY_BAD_ARRAY_LENGTH
	-#define _LIBCPP_AVAILABILITY_BAD_ANY_CAST
	-#define _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS
	-#define _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE
	-#define _LIBCPP_AVAILABILITY_FUTURE_ERROR
	-#define _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE
	-#define _LIBCPP_AVAILABILITY_LOCALE_CATEGORY
	-#define _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
	+# define _LIBCPP_AVAILABILITY_SHARED_MUTEX
	+# define _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
	+# define _LIBCPP_AVAILABILITY_BAD_ARRAY_LENGTH
	+# define _LIBCPP_AVAILABILITY_BAD_ANY_CAST
	+# define _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS
	+# define _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE
	+# define _LIBCPP_AVAILABILITY_FUTURE_ERROR
	+# define _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE
	+# define _LIBCPP_AVAILABILITY_LOCALE_CATEGORY
	+# define _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
	#endif

	// Define availability that depends on _LIBCPP_NO_EXCEPTIONS.
	#ifdef _LIBCPP_NO_EXCEPTIONS
	-#define _LIBCPP_AVAILABILITY_DYNARRAY
	-#define _LIBCPP_AVAILABILITY_FUTURE
	-#define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
	+# define _LIBCPP_AVAILABILITY_DYNARRAY
	+# define _LIBCPP_AVAILABILITY_FUTURE
	+# define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
	#else
	-#define _LIBCPP_AVAILABILITY_DYNARRAY _LIBCPP_AVAILABILITY_BAD_ARRAY_LENGTH
	-#define _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_AVAILABILITY_FUTURE_ERROR
	-#define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST \
	- _LIBCPP_AVAILABILITY_BAD_ANY_CAST
	+# define _LIBCPP_AVAILABILITY_DYNARRAY _LIBCPP_AVAILABILITY_BAD_ARRAY_LENGTH
	+# define _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_AVAILABILITY_FUTURE_ERROR
	+# define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST \
	+ _LIBCPP_AVAILABILITY_BAD_ANY_CAST
	#endif

	// Availability of stream API in the dylib got dropped and re-added. The
	// extern template should effectively be available at:
	// availability(macosx,introduced=10.9)
	// availability(ios,introduced=7.0)
	#if defined(_LIBCPP_USE_AVAILABILITY_APPLE) && \
	((defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && \
	__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 1090) \|\| \
	(defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && \
	__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 70000))
	#define _LIBCPP_AVAILABILITY_NO_STREAMS_EXTERN_TEMPLATE
	#endif

	#if defined(_LIBCPP_COMPILER_IBM)
	#define _LIBCPP_HAS_NO_PRAGMA_PUSH_POP_MACRO
	#endif

	#if defined(_LIBCPP_HAS_NO_PRAGMA_PUSH_POP_MACRO)
	-# define _LIBCPP_PUSH_MACROS
	-# define _LIBCPP_POP_MACROS
	+# define _LIBCPP_PUSH_MACROS
	+# define _LIBCPP_POP_MACROS
	#else
	// Don't warn about macro conflicts when we can restore them at the
	// end of the header.
	-# ifndef _LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS
	-# define _LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS
	-# endif
	-# if defined(_LIBCPP_COMPILER_MSVC)
	-# define _LIBCPP_PUSH_MACROS \
	- __pragma(push_macro("min")) \
	- __pragma(push_macro("max"))
	-# define _LIBCPP_POP_MACROS \
	- __pragma(pop_macro("min")) \
	- __pragma(pop_macro("max"))
	-# else
	-# define _LIBCPP_PUSH_MACROS \
	- _Pragma("push_macro(\"min\")") \
	- _Pragma("push_macro(\"max\")")
	-# define _LIBCPP_POP_MACROS \
	- _Pragma("pop_macro(\"min\")") \
	- _Pragma("pop_macro(\"max\")")
	-# endif
	+# ifndef _LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS
	+# define _LIBCPP_DISABLE_MACRO_CONFLICT_WARNINGS
	+# endif
	+# if defined(_LIBCPP_COMPILER_MSVC)
	+# define _LIBCPP_PUSH_MACROS \
	+ __pragma(push_macro("min")) \
	+ __pragma(push_macro("max"))
	+# define _LIBCPP_POP_MACROS \
	+ __pragma(pop_macro("min")) \
	+ __pragma(pop_macro("max"))
	+# else
	+# define _LIBCPP_PUSH_MACROS \
	+ _Pragma("push_macro(\"min\")") \
	+ _Pragma("push_macro(\"max\")")
	+# define _LIBCPP_POP_MACROS \
	+ _Pragma("pop_macro(\"min\")") \
	+ _Pragma("pop_macro(\"max\")")
	+# 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)
	+#ifndef _LIBCPP_NO_AUTO_LINK
	+# if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_BUILDING_LIBRARY)
	+# if defined(_DLL)
	+# pragma comment(lib, "c++.lib")
	+# else
	+# pragma comment(lib, "libc++.lib")
	+# endif
	+# endif // defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_BUILDING_LIBRARY)
	+#endif // _LIBCPP_NO_AUTO_LINK

	#endif // __cplusplus

	#endif // _LIBCPP_CONFIG
	Index: projects/clang700-import/contrib/libc++/include/__errc
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/__errc (nonexistent)
	+++ projects/clang700-import/contrib/libc++/include/__errc (revision 337135)
	@@ -0,0 +1,218 @@
	+// -- C++ --
	+//===---------------------------- __errc ----------------------------------===//
	+//
	+// 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___ERRC
	+#define _LIBCPP___ERRC
	+
	+/*
	+ system_error synopsis
	+
	+namespace std
	+{
	+
	+enum class errc
	+{
	+ address_family_not_supported, // EAFNOSUPPORT
	+ address_in_use, // EADDRINUSE
	+ address_not_available, // EADDRNOTAVAIL
	+ already_connected, // EISCONN
	+ argument_list_too_long, // E2BIG
	+ argument_out_of_domain, // EDOM
	+ bad_address, // EFAULT
	+ bad_file_descriptor, // EBADF
	+ bad_message, // EBADMSG
	+ broken_pipe, // EPIPE
	+ connection_aborted, // ECONNABORTED
	+ connection_already_in_progress, // EALREADY
	+ connection_refused, // ECONNREFUSED
	+ connection_reset, // ECONNRESET
	+ cross_device_link, // EXDEV
	+ destination_address_required, // EDESTADDRREQ
	+ device_or_resource_busy, // EBUSY
	+ directory_not_empty, // ENOTEMPTY
	+ executable_format_error, // ENOEXEC
	+ file_exists, // EEXIST
	+ file_too_large, // EFBIG
	+ filename_too_long, // ENAMETOOLONG
	+ function_not_supported, // ENOSYS
	+ host_unreachable, // EHOSTUNREACH
	+ identifier_removed, // EIDRM
	+ illegal_byte_sequence, // EILSEQ
	+ inappropriate_io_control_operation, // ENOTTY
	+ interrupted, // EINTR
	+ invalid_argument, // EINVAL
	+ invalid_seek, // ESPIPE
	+ io_error, // EIO
	+ is_a_directory, // EISDIR
	+ message_size, // EMSGSIZE
	+ network_down, // ENETDOWN
	+ network_reset, // ENETRESET
	+ network_unreachable, // ENETUNREACH
	+ no_buffer_space, // ENOBUFS
	+ no_child_process, // ECHILD
	+ no_link, // ENOLINK
	+ no_lock_available, // ENOLCK
	+ no_message_available, // ENODATA
	+ no_message, // ENOMSG
	+ no_protocol_option, // ENOPROTOOPT
	+ no_space_on_device, // ENOSPC
	+ no_stream_resources, // ENOSR
	+ no_such_device_or_address, // ENXIO
	+ no_such_device, // ENODEV
	+ no_such_file_or_directory, // ENOENT
	+ no_such_process, // ESRCH
	+ not_a_directory, // ENOTDIR
	+ not_a_socket, // ENOTSOCK
	+ not_a_stream, // ENOSTR
	+ not_connected, // ENOTCONN
	+ not_enough_memory, // ENOMEM
	+ not_supported, // ENOTSUP
	+ operation_canceled, // ECANCELED
	+ operation_in_progress, // EINPROGRESS
	+ operation_not_permitted, // EPERM
	+ operation_not_supported, // EOPNOTSUPP
	+ operation_would_block, // EWOULDBLOCK
	+ owner_dead, // EOWNERDEAD
	+ permission_denied, // EACCES
	+ protocol_error, // EPROTO
	+ protocol_not_supported, // EPROTONOSUPPORT
	+ read_only_file_system, // EROFS
	+ resource_deadlock_would_occur, // EDEADLK
	+ resource_unavailable_try_again, // EAGAIN
	+ result_out_of_range, // ERANGE
	+ state_not_recoverable, // ENOTRECOVERABLE
	+ stream_timeout, // ETIME
	+ text_file_busy, // ETXTBSY
	+ timed_out, // ETIMEDOUT
	+ too_many_files_open_in_system, // ENFILE
	+ too_many_files_open, // EMFILE
	+ too_many_links, // EMLINK
	+ too_many_symbolic_link_levels, // ELOOP
	+ value_too_large, // EOVERFLOW
	+ wrong_protocol_type // EPROTOTYPE
	+};
	+
	+*/
	+
	+#include <__config>
	+#include <cerrno>
	+
	+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	+#pragma GCC system_header
	+#endif
	+
	+_LIBCPP_BEGIN_NAMESPACE_STD
	+
	+// Some error codes are not present on all platforms, so we provide equivalents
	+// for them:
	+
	+//enum class errc
	+_LIBCPP_DECLARE_STRONG_ENUM(errc)
	+{
	+ address_family_not_supported = EAFNOSUPPORT,
	+ address_in_use = EADDRINUSE,
	+ address_not_available = EADDRNOTAVAIL,
	+ already_connected = EISCONN,
	+ argument_list_too_long = E2BIG,
	+ argument_out_of_domain = EDOM,
	+ bad_address = EFAULT,
	+ bad_file_descriptor = EBADF,
	+ bad_message = EBADMSG,
	+ broken_pipe = EPIPE,
	+ connection_aborted = ECONNABORTED,
	+ connection_already_in_progress = EALREADY,
	+ connection_refused = ECONNREFUSED,
	+ connection_reset = ECONNRESET,
	+ cross_device_link = EXDEV,
	+ destination_address_required = EDESTADDRREQ,
	+ device_or_resource_busy = EBUSY,
	+ directory_not_empty = ENOTEMPTY,
	+ executable_format_error = ENOEXEC,
	+ file_exists = EEXIST,
	+ file_too_large = EFBIG,
	+ filename_too_long = ENAMETOOLONG,
	+ function_not_supported = ENOSYS,
	+ host_unreachable = EHOSTUNREACH,
	+ identifier_removed = EIDRM,
	+ illegal_byte_sequence = EILSEQ,
	+ inappropriate_io_control_operation = ENOTTY,
	+ interrupted = EINTR,
	+ invalid_argument = EINVAL,
	+ invalid_seek = ESPIPE,
	+ io_error = EIO,
	+ is_a_directory = EISDIR,
	+ message_size = EMSGSIZE,
	+ network_down = ENETDOWN,
	+ network_reset = ENETRESET,
	+ network_unreachable = ENETUNREACH,
	+ no_buffer_space = ENOBUFS,
	+ no_child_process = ECHILD,
	+ no_link = ENOLINK,
	+ no_lock_available = ENOLCK,
	+#ifdef ENODATA
	+ no_message_available = ENODATA,
	+#else
	+ no_message_available = ENOMSG,
	+#endif
	+ no_message = ENOMSG,
	+ no_protocol_option = ENOPROTOOPT,
	+ no_space_on_device = ENOSPC,
	+#ifdef ENOSR
	+ no_stream_resources = ENOSR,
	+#else
	+ no_stream_resources = ENOMEM,
	+#endif
	+ no_such_device_or_address = ENXIO,
	+ no_such_device = ENODEV,
	+ no_such_file_or_directory = ENOENT,
	+ no_such_process = ESRCH,
	+ not_a_directory = ENOTDIR,
	+ not_a_socket = ENOTSOCK,
	+#ifdef ENOSTR
	+ not_a_stream = ENOSTR,
	+#else
	+ not_a_stream = EINVAL,
	+#endif
	+ not_connected = ENOTCONN,
	+ not_enough_memory = ENOMEM,
	+ not_supported = ENOTSUP,
	+ operation_canceled = ECANCELED,
	+ operation_in_progress = EINPROGRESS,
	+ operation_not_permitted = EPERM,
	+ operation_not_supported = EOPNOTSUPP,
	+ operation_would_block = EWOULDBLOCK,
	+ owner_dead = EOWNERDEAD,
	+ permission_denied = EACCES,
	+ protocol_error = EPROTO,
	+ protocol_not_supported = EPROTONOSUPPORT,
	+ read_only_file_system = EROFS,
	+ resource_deadlock_would_occur = EDEADLK,
	+ resource_unavailable_try_again = EAGAIN,
	+ result_out_of_range = ERANGE,
	+ state_not_recoverable = ENOTRECOVERABLE,
	+#ifdef ETIME
	+ stream_timeout = ETIME,
	+#else
	+ stream_timeout = ETIMEDOUT,
	+#endif
	+ text_file_busy = ETXTBSY,
	+ timed_out = ETIMEDOUT,
	+ too_many_files_open_in_system = ENFILE,
	+ too_many_files_open = EMFILE,
	+ too_many_links = EMLINK,
	+ too_many_symbolic_link_levels = ELOOP,
	+ value_too_large = EOVERFLOW,
	+ wrong_protocol_type = EPROTOTYPE
	+};
	+_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(errc)
	+
	+_LIBCPP_END_NAMESPACE_STD
	+
	+#endif // _LIBCPP___ERRC
	Index: projects/clang700-import/contrib/libc++/include/__functional_03
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/__functional_03 (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/__functional_03 (revision 337135)
	@@ -1,1576 +1,1592 @@
	// -- 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.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP_FUNCTIONAL_03
	#define _LIBCPP_FUNCTIONAL_03

	// manual variadic expansion for <functional>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	namespace __function {

	template<class _Fp> class __base;

	template<class _Rp>
	class __base<_Rp()>
	{
	__base(const __base&);
	__base& operator=(const __base&);
	public:
	__base() {}
	virtual ~__base() {}
	virtual __base* __clone() const = 0;
	virtual void __clone(__base*) const = 0;
	virtual void destroy() = 0;
	virtual void destroy_deallocate() = 0;
	virtual _Rp operator()() = 0;
	#ifndef _LIBCPP_NO_RTTI
	virtual const void* target(const type_info&) const = 0;
	virtual const std::type_info& target_type() const = 0;
	#endif // _LIBCPP_NO_RTTI
	};

	template<class _Rp, class _A0>
	class __base<_Rp(_A0)>
	{
	__base(const __base&);
	__base& operator=(const __base&);
	public:
	__base() {}
	virtual ~__base() {}
	virtual __base* __clone() const = 0;
	virtual void __clone(__base*) const = 0;
	virtual void destroy() = 0;
	virtual void destroy_deallocate() = 0;
	virtual _Rp operator()(_A0) = 0;
	#ifndef _LIBCPP_NO_RTTI
	virtual const void* target(const type_info&) const = 0;
	virtual const std::type_info& target_type() const = 0;
	#endif // _LIBCPP_NO_RTTI
	};

	template<class _Rp, class _A0, class _A1>
	class __base<_Rp(_A0, _A1)>
	{
	__base(const __base&);
	__base& operator=(const __base&);
	public:
	__base() {}
	virtual ~__base() {}
	virtual __base* __clone() const = 0;
	virtual void __clone(__base*) const = 0;
	virtual void destroy() = 0;
	virtual void destroy_deallocate() = 0;
	virtual _Rp operator()(_A0, _A1) = 0;
	#ifndef _LIBCPP_NO_RTTI
	virtual const void* target(const type_info&) const = 0;
	virtual const std::type_info& target_type() const = 0;
	#endif // _LIBCPP_NO_RTTI
	};

	template<class _Rp, class _A0, class _A1, class _A2>
	class __base<_Rp(_A0, _A1, _A2)>
	{
	__base(const __base&);
	__base& operator=(const __base&);
	public:
	__base() {}
	virtual ~__base() {}
	virtual __base* __clone() const = 0;
	virtual void __clone(__base*) const = 0;
	virtual void destroy() = 0;
	virtual void destroy_deallocate() = 0;
	virtual _Rp operator()(_A0, _A1, _A2) = 0;
	#ifndef _LIBCPP_NO_RTTI
	virtual const void* target(const type_info&) const = 0;
	virtual const std::type_info& target_type() const = 0;
	#endif // _LIBCPP_NO_RTTI
	};

	template<class _FD, class _Alloc, class _FB> class __func;

	template<class _Fp, class _Alloc, class _Rp>
	class __func<_Fp, _Alloc, _Rp()>
	: public __base<_Rp()>
	{
	__compressed_pair<_Fp, _Alloc> __f_;
	public:
	explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {}
	explicit __func(_Fp __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
	virtual __base<_Rp()>* __clone() const;
	virtual void __clone(__base<_Rp()>*) const;
	virtual void destroy();
	virtual void destroy_deallocate();
	virtual _Rp operator()();
	#ifndef _LIBCPP_NO_RTTI
	virtual const void* target(const type_info&) const;
	virtual const std::type_info& target_type() const;
	#endif // _LIBCPP_NO_RTTI
	};

	template<class _Fp, class _Alloc, class _Rp>
	__base<_Rp()>*
	__func<_Fp, _Alloc, _Rp()>::__clone() const
	{
	typedef allocator_traits<_Alloc> __alloc_traits;
	typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
	_Ap __a(__f_.second());
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (__hold.get()) __func(__f_.first(), _Alloc(__a));
	return __hold.release();
	}

	template<class _Fp, class _Alloc, class _Rp>
	void
	__func<_Fp, _Alloc, _Rp()>::__clone(__base<_Rp()>* __p) const
	{
	::new (__p) __func(__f_.first(), __f_.second());
	}

	template<class _Fp, class _Alloc, class _Rp>
	void
	__func<_Fp, _Alloc, _Rp()>::destroy()
	{
	__f_.~__compressed_pair<_Fp, _Alloc>();
	}

	template<class _Fp, class _Alloc, class _Rp>
	void
	__func<_Fp, _Alloc, _Rp()>::destroy_deallocate()
	{
	typedef allocator_traits<_Alloc> __alloc_traits;
	typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
	_Ap __a(__f_.second());
	__f_.~__compressed_pair<_Fp, _Alloc>();
	__a.deallocate(this, 1);
	}

	template<class _Fp, class _Alloc, class _Rp>
	_Rp
	__func<_Fp, _Alloc, _Rp()>::operator()()
	{
	typedef __invoke_void_return_wrapper<_Rp> _Invoker;
	return _Invoker::__call(__f_.first());
	}

	#ifndef _LIBCPP_NO_RTTI

	template<class _Fp, class _Alloc, class _Rp>
	const void*
	__func<_Fp, _Alloc, _Rp()>::target(const type_info& __ti) const
	{
	if (__ti == typeid(_Fp))
	return &__f_.first();
	return (const void*)0;
	}

	template<class _Fp, class _Alloc, class _Rp>
	const std::type_info&
	__func<_Fp, _Alloc, _Rp()>::target_type() const
	{
	return typeid(_Fp);
	}

	#endif // _LIBCPP_NO_RTTI

	template<class _Fp, class _Alloc, class _Rp, class _A0>
	class __func<_Fp, _Alloc, _Rp(_A0)>
	: public __base<_Rp(_A0)>
	{
	__compressed_pair<_Fp, _Alloc> __f_;
	public:
	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {}
	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a)
	: __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
	virtual __base<_Rp(_A0)>* __clone() const;
	virtual void __clone(__base<_Rp(_A0)>*) const;
	virtual void destroy();
	virtual void destroy_deallocate();
	virtual _Rp operator()(_A0);
	#ifndef _LIBCPP_NO_RTTI
	virtual const void* target(const type_info&) const;
	virtual const std::type_info& target_type() const;
	#endif // _LIBCPP_NO_RTTI
	};

	template<class _Fp, class _Alloc, class _Rp, class _A0>
	__base<_Rp(_A0)>*
	__func<_Fp, _Alloc, _Rp(_A0)>::__clone() const
	{
	typedef allocator_traits<_Alloc> __alloc_traits;
	typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
	_Ap __a(__f_.second());
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (__hold.get()) __func(__f_.first(), _Alloc(__a));
	return __hold.release();
	}

	template<class _Fp, class _Alloc, class _Rp, class _A0>
	void
	__func<_Fp, _Alloc, _Rp(_A0)>::__clone(__base<_Rp(_A0)>* __p) const
	{
	::new (__p) __func(__f_.first(), __f_.second());
	}

	template<class _Fp, class _Alloc, class _Rp, class _A0>
	void
	__func<_Fp, _Alloc, _Rp(_A0)>::destroy()
	{
	__f_.~__compressed_pair<_Fp, _Alloc>();
	}

	template<class _Fp, class _Alloc, class _Rp, class _A0>
	void
	__func<_Fp, _Alloc, _Rp(_A0)>::destroy_deallocate()
	{
	typedef allocator_traits<_Alloc> __alloc_traits;
	typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
	_Ap __a(__f_.second());
	__f_.~__compressed_pair<_Fp, _Alloc>();
	__a.deallocate(this, 1);
	}

	template<class _Fp, class _Alloc, class _Rp, class _A0>
	_Rp
	__func<_Fp, _Alloc, _Rp(_A0)>::operator()(_A0 __a0)
	{
	typedef __invoke_void_return_wrapper<_Rp> _Invoker;
	return _Invoker::__call(__f_.first(), __a0);
	}

	#ifndef _LIBCPP_NO_RTTI

	template<class _Fp, class _Alloc, class _Rp, class _A0>
	const void*
	__func<_Fp, _Alloc, _Rp(_A0)>::target(const type_info& __ti) const
	{
	if (__ti == typeid(_Fp))
	return &__f_.first();
	return (const void*)0;
	}

	template<class _Fp, class _Alloc, class _Rp, class _A0>
	const std::type_info&
	__func<_Fp, _Alloc, _Rp(_A0)>::target_type() const
	{
	return typeid(_Fp);
	}

	#endif // _LIBCPP_NO_RTTI

	template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1>
	class __func<_Fp, _Alloc, _Rp(_A0, _A1)>
	: public __base<_Rp(_A0, _A1)>
	{
	__compressed_pair<_Fp, _Alloc> __f_;
	public:
	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {}
	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a)
	: __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
	virtual __base<_Rp(_A0, _A1)>* __clone() const;
	virtual void __clone(__base<_Rp(_A0, _A1)>*) const;
	virtual void destroy();
	virtual void destroy_deallocate();
	virtual _Rp operator()(_A0, _A1);
	#ifndef _LIBCPP_NO_RTTI
	virtual const void* target(const type_info&) const;
	virtual const std::type_info& target_type() const;
	#endif // _LIBCPP_NO_RTTI
	};

	template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1>
	__base<_Rp(_A0, _A1)>*
	__func<_Fp, _Alloc, _Rp(_A0, _A1)>::__clone() const
	{
	typedef allocator_traits<_Alloc> __alloc_traits;
	typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
	_Ap __a(__f_.second());
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (__hold.get()) __func(__f_.first(), _Alloc(__a));
	return __hold.release();
	}

	template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1>
	void
	__func<_Fp, _Alloc, _Rp(_A0, _A1)>::__clone(__base<_Rp(_A0, _A1)>* __p) const
	{
	::new (__p) __func(__f_.first(), __f_.second());
	}

	template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1>
	void
	__func<_Fp, _Alloc, _Rp(_A0, _A1)>::destroy()
	{
	__f_.~__compressed_pair<_Fp, _Alloc>();
	}

	template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1>
	void
	__func<_Fp, _Alloc, _Rp(_A0, _A1)>::destroy_deallocate()
	{
	typedef allocator_traits<_Alloc> __alloc_traits;
	typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
	_Ap __a(__f_.second());
	__f_.~__compressed_pair<_Fp, _Alloc>();
	__a.deallocate(this, 1);
	}

	template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1>
	_Rp
	__func<_Fp, _Alloc, _Rp(_A0, _A1)>::operator()(_A0 __a0, _A1 __a1)
	{
	typedef __invoke_void_return_wrapper<_Rp> _Invoker;
	return _Invoker::__call(__f_.first(), __a0, __a1);
	}

	#ifndef _LIBCPP_NO_RTTI

	template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1>
	const void*
	__func<_Fp, _Alloc, _Rp(_A0, _A1)>::target(const type_info& __ti) const
	{
	if (__ti == typeid(_Fp))
	return &__f_.first();
	return (const void*)0;
	}

	template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1>
	const std::type_info&
	__func<_Fp, _Alloc, _Rp(_A0, _A1)>::target_type() const
	{
	return typeid(_Fp);
	}

	#endif // _LIBCPP_NO_RTTI

	template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2>
	class __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>
	: public __base<_Rp(_A0, _A1, _A2)>
	{
	__compressed_pair<_Fp, _Alloc> __f_;
	public:
	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {}
	_LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a)
	: __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
	virtual __base<_Rp(_A0, _A1, _A2)>* __clone() const;
	virtual void __clone(__base<_Rp(_A0, _A1, _A2)>*) const;
	virtual void destroy();
	virtual void destroy_deallocate();
	virtual _Rp operator()(_A0, _A1, _A2);
	#ifndef _LIBCPP_NO_RTTI
	virtual const void* target(const type_info&) const;
	virtual const std::type_info& target_type() const;
	#endif // _LIBCPP_NO_RTTI
	};

	template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2>
	__base<_Rp(_A0, _A1, _A2)>*
	__func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::__clone() const
	{
	typedef allocator_traits<_Alloc> __alloc_traits;
	typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
	_Ap __a(__f_.second());
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (__hold.get()) __func(__f_.first(), _Alloc(__a));
	return __hold.release();
	}

	template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2>
	void
	__func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::__clone(__base<_Rp(_A0, _A1, _A2)>* __p) const
	{
	::new (__p) __func(__f_.first(), __f_.second());
	}

	template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2>
	void
	__func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::destroy()
	{
	__f_.~__compressed_pair<_Fp, _Alloc>();
	}

	template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2>
	void
	__func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::destroy_deallocate()
	{
	typedef allocator_traits<_Alloc> __alloc_traits;
	typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
	_Ap __a(__f_.second());
	__f_.~__compressed_pair<_Fp, _Alloc>();
	__a.deallocate(this, 1);
	}

	template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2>
	_Rp
	__func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::operator()(_A0 __a0, _A1 __a1, _A2 __a2)
	{
	typedef __invoke_void_return_wrapper<_Rp> _Invoker;
	return _Invoker::__call(__f_.first(), __a0, __a1, __a2);
	}

	#ifndef _LIBCPP_NO_RTTI

	template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2>
	const void*
	__func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::target(const type_info& __ti) const
	{
	if (__ti == typeid(_Fp))
	return &__f_.first();
	return (const void*)0;
	}

	template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2>
	const std::type_info&
	__func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::target_type() const
	{
	return typeid(_Fp);
	}

	#endif // _LIBCPP_NO_RTTI

	} // __function

	template<class _Rp>
	class _LIBCPP_TEMPLATE_VIS function<_Rp()>
	{
	typedef __function::__base<_Rp()> __base;
	aligned_storage<3sizeof(void)>::type __buf_;
	__base* __f_;

	public:
	typedef _Rp result_type;

	// 20.7.16.2.1, construct/copy/destroy:
	_LIBCPP_INLINE_VISIBILITY explicit function() : __f_(0) {}
	_LIBCPP_INLINE_VISIBILITY function(nullptr_t) : __f_(0) {}
	function(const function&);
	template<class _Fp>
	function(_Fp,
	typename enable_if<!is_integral<_Fp>::value>::type* = 0);

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

	function& operator=(const function&);
	function& operator=(nullptr_t);
	template<class _Fp>
	typename enable_if
	<
	!is_integral<_Fp>::value,
	function&
	>::type
	operator=(_Fp);

	~function();

	// 20.7.16.2.2, function modifiers:
	void swap(function&);
	template<class _Fp, class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	void assign(_Fp __f, const _Alloc& __a)
	{function(allocator_arg, __a, __f).swap(*this);}

	// 20.7.16.2.3, function capacity:
	_LIBCPP_INLINE_VISIBILITY operator bool() const {return __f_;}

	private:
	// deleted overloads close possible hole in the type system
	template<class _R2>
	bool operator==(const function<_R2()>&) const;// = delete;
	template<class _R2>
	bool operator!=(const function<_R2()>&) const;// = delete;
	public:
	// 20.7.16.2.4, function invocation:
	_Rp operator()() const;

	#ifndef _LIBCPP_NO_RTTI
	// 20.7.16.2.5, function target access:
	const std::type_info& target_type() const;
	template <typename _Tp> _Tp* target();
	template <typename _Tp> const _Tp* target() const;
	#endif // _LIBCPP_NO_RTTI
	};

	template<class _Rp>
	function<_Rp()>::function(const function& __f)
	{
	if (__f.__f_ == 0)
	__f_ = 0;
	else if (__f.__f_ == (const __base*)&__f.__buf_)
	{
	__f_ = (__base*)&__buf_;
	__f.__f_->__clone(__f_);
	}
	else
	__f_ = __f.__f_->__clone();
	}

	template<class _Rp>
	template<class _Alloc>
	function<_Rp()>::function(allocator_arg_t, const _Alloc&, const function& __f)
	{
	if (__f.__f_ == 0)
	__f_ = 0;
	else if (__f.__f_ == (const __base*)&__f.__buf_)
	{
	__f_ = (__base*)&__buf_;
	__f.__f_->__clone(__f_);
	}
	else
	__f_ = __f.__f_->__clone();
	}

	template<class _Rp>
	template <class _Fp>
	function<_Rp()>::function(_Fp __f,
	typename enable_if<!is_integral<_Fp>::value>::type*)
	: __f_(0)
	{
	if (__function::__not_null(__f))
	{
	typedef __function::__func<_Fp, allocator<_Fp>, _Rp()> _FF;
	if (sizeof(_FF) <= sizeof(__buf_))
	{
	__f_ = (__base*)&__buf_;
	::new (__f_) _FF(__f);
	}
	else
	{
	typedef allocator<_FF> _Ap;
	_Ap __a;
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (__hold.get()) _FF(__f, allocator<_Fp>(__a));
	__f_ = __hold.release();
	}
	}
	}

	template<class _Rp>
	template <class _Fp, class _Alloc>
	function<_Rp()>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f,
	typename enable_if<!is_integral<_Fp>::value>::type*)
	: __f_(0)
	{
	typedef allocator_traits<_Alloc> __alloc_traits;
	if (__function::__not_null(__f))
	{
	typedef __function::__func<_Fp, _Alloc, _Rp()> _FF;
	if (sizeof(_FF) <= sizeof(__buf_))
	{
	__f_ = (__base*)&__buf_;
	::new (__f_) _FF(__f, __a0);
	}
	else
	{
	typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap;
	_Ap __a(__a0);
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (__hold.get()) _FF(__f, _Alloc(__a));
	__f_ = __hold.release();
	}
	}
	}

	template<class _Rp>
	function<_Rp()>&
	function<_Rp()>::operator=(const function& __f)
	{
	- function(__f).swap(*this);
	+ if (__f)
	+ function(__f).swap(*this);
	+ else
	+ *this = nullptr;
	return *this;
	}

	template<class _Rp>
	function<_Rp()>&
	function<_Rp()>::operator=(nullptr_t)
	{
	- if (__f_ == (__base*)&__buf_)
	- __f_->destroy();
	- else if (__f_)
	- __f_->destroy_deallocate();
	+ __base* __t = __f_;
	__f_ = 0;
	+ if (__t == (__base*)&__buf_)
	+ __t->destroy();
	+ else if (__t)
	+ __t->destroy_deallocate();
	return *this;
	}

	template<class _Rp>
	template <class _Fp>
	typename enable_if
	<
	!is_integral<_Fp>::value,
	function<_Rp()>&
	>::type
	function<_Rp()>::operator=(_Fp __f)
	{
	function(_VSTD::move(__f)).swap(*this);
	return *this;
	}

	template<class _Rp>
	function<_Rp()>::~function()
	{
	if (__f_ == (__base*)&__buf_)
	__f_->destroy();
	else if (__f_)
	__f_->destroy_deallocate();
	}

	template<class _Rp>
	void
	function<_Rp()>::swap(function& __f)
	{
	if (_VSTD::addressof(__f) == this)
	return;
	if (__f_ == (__base)&__buf_ && __f.__f_ == (__base)&__f.__buf_)
	{
	typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
	__base* __t = (__base*)&__tempbuf;
	__f_->__clone(__t);
	__f_->destroy();
	__f_ = 0;
	__f.__f_->__clone((__base*)&__buf_);
	__f.__f_->destroy();
	__f.__f_ = 0;
	__f_ = (__base*)&__buf_;
	__t->__clone((__base*)&__f.__buf_);
	__t->destroy();
	__f.__f_ = (__base*)&__f.__buf_;
	}
	else if (__f_ == (__base*)&__buf_)
	{
	__f_->__clone((__base*)&__f.__buf_);
	__f_->destroy();
	__f_ = __f.__f_;
	__f.__f_ = (__base*)&__f.__buf_;
	}
	else if (__f.__f_ == (__base*)&__f.__buf_)
	{
	__f.__f_->__clone((__base*)&__buf_);
	__f.__f_->destroy();
	__f.__f_ = __f_;
	__f_ = (__base*)&__buf_;
	}
	else
	_VSTD::swap(__f_, __f.__f_);
	}

	template<class _Rp>
	_Rp
	function<_Rp()>::operator()() const
	{
	if (__f_ == 0)
	__throw_bad_function_call();
	return (*__f_)();
	}

	#ifndef _LIBCPP_NO_RTTI

	template<class _Rp>
	const std::type_info&
	function<_Rp()>::target_type() const
	{
	if (__f_ == 0)
	return typeid(void);
	return __f_->target_type();
	}

	template<class _Rp>
	template <typename _Tp>
	_Tp*
	function<_Rp()>::target()
	{
	if (__f_ == 0)
	return (_Tp*)0;
	return (_Tp) const_cast<void >(__f_->target(typeid(_Tp)));
	}

	template<class _Rp>
	template <typename _Tp>
	const _Tp*
	function<_Rp()>::target() const
	{
	if (__f_ == 0)
	return (const _Tp*)0;
	return (const _Tp*)__f_->target(typeid(_Tp));
	}

	#endif // _LIBCPP_NO_RTTI

	template<class _Rp, class _A0>
	class _LIBCPP_TEMPLATE_VIS function<_Rp(_A0)>
	: public unary_function<_A0, _Rp>
	{
	typedef __function::__base<_Rp(_A0)> __base;
	aligned_storage<3sizeof(void)>::type __buf_;
	__base* __f_;

	public:
	typedef _Rp result_type;

	// 20.7.16.2.1, construct/copy/destroy:
	_LIBCPP_INLINE_VISIBILITY explicit function() : __f_(0) {}
	_LIBCPP_INLINE_VISIBILITY function(nullptr_t) : __f_(0) {}
	function(const function&);
	template<class _Fp>
	function(_Fp,
	typename enable_if<!is_integral<_Fp>::value>::type* = 0);

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

	function& operator=(const function&);
	function& operator=(nullptr_t);
	template<class _Fp>
	typename enable_if
	<
	!is_integral<_Fp>::value,
	function&
	>::type
	operator=(_Fp);

	~function();

	// 20.7.16.2.2, function modifiers:
	void swap(function&);
	template<class _Fp, class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	void assign(_Fp __f, const _Alloc& __a)
	{function(allocator_arg, __a, __f).swap(*this);}

	// 20.7.16.2.3, function capacity:
	_LIBCPP_INLINE_VISIBILITY operator bool() const {return __f_;}

	private:
	// deleted overloads close possible hole in the type system
	template<class _R2, class _B0>
	bool operator==(const function<_R2(_B0)>&) const;// = delete;
	template<class _R2, class _B0>
	bool operator!=(const function<_R2(_B0)>&) const;// = delete;
	public:
	// 20.7.16.2.4, function invocation:
	_Rp operator()(_A0) const;

	#ifndef _LIBCPP_NO_RTTI
	// 20.7.16.2.5, function target access:
	const std::type_info& target_type() const;
	template <typename _Tp> _Tp* target();
	template <typename _Tp> const _Tp* target() const;
	#endif // _LIBCPP_NO_RTTI
	};

	template<class _Rp, class _A0>
	function<_Rp(_A0)>::function(const function& __f)
	{
	if (__f.__f_ == 0)
	__f_ = 0;
	else if (__f.__f_ == (const __base*)&__f.__buf_)
	{
	__f_ = (__base*)&__buf_;
	__f.__f_->__clone(__f_);
	}
	else
	__f_ = __f.__f_->__clone();
	}

	template<class _Rp, class _A0>
	template<class _Alloc>
	function<_Rp(_A0)>::function(allocator_arg_t, const _Alloc&, const function& __f)
	{
	if (__f.__f_ == 0)
	__f_ = 0;
	else if (__f.__f_ == (const __base*)&__f.__buf_)
	{
	__f_ = (__base*)&__buf_;
	__f.__f_->__clone(__f_);
	}
	else
	__f_ = __f.__f_->__clone();
	}

	template<class _Rp, class _A0>
	template <class _Fp>
	function<_Rp(_A0)>::function(_Fp __f,
	typename enable_if<!is_integral<_Fp>::value>::type*)
	: __f_(0)
	{
	if (__function::__not_null(__f))
	{
	typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_A0)> _FF;
	if (sizeof(_FF) <= sizeof(__buf_))
	{
	__f_ = (__base*)&__buf_;
	::new (__f_) _FF(__f);
	}
	else
	{
	typedef allocator<_FF> _Ap;
	_Ap __a;
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (__hold.get()) _FF(__f, allocator<_Fp>(__a));
	__f_ = __hold.release();
	}
	}
	}

	template<class _Rp, class _A0>
	template <class _Fp, class _Alloc>
	function<_Rp(_A0)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f,
	typename enable_if<!is_integral<_Fp>::value>::type*)
	: __f_(0)
	{
	typedef allocator_traits<_Alloc> __alloc_traits;
	if (__function::__not_null(__f))
	{
	typedef __function::__func<_Fp, _Alloc, _Rp(_A0)> _FF;
	if (sizeof(_FF) <= sizeof(__buf_))
	{
	__f_ = (__base*)&__buf_;
	::new (__f_) _FF(__f, __a0);
	}
	else
	{
	typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap;
	_Ap __a(__a0);
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (__hold.get()) _FF(__f, _Alloc(__a));
	__f_ = __hold.release();
	}
	}
	}

	template<class _Rp, class _A0>
	function<_Rp(_A0)>&
	function<_Rp(_A0)>::operator=(const function& __f)
	{
	- function(__f).swap(*this);
	+ if (__f)
	+ function(__f).swap(*this);
	+ else
	+ *this = nullptr;
	return *this;
	}

	template<class _Rp, class _A0>
	function<_Rp(_A0)>&
	function<_Rp(_A0)>::operator=(nullptr_t)
	{
	- if (__f_ == (__base*)&__buf_)
	- __f_->destroy();
	- else if (__f_)
	- __f_->destroy_deallocate();
	+ __base* __t = __f_;
	__f_ = 0;
	+ if (__t == (__base*)&__buf_)
	+ __t->destroy();
	+ else if (__t)
	+ __t->destroy_deallocate();
	return *this;
	}

	template<class _Rp, class _A0>
	template <class _Fp>
	typename enable_if
	<
	!is_integral<_Fp>::value,
	function<_Rp(_A0)>&
	>::type
	function<_Rp(_A0)>::operator=(_Fp __f)
	{
	function(_VSTD::move(__f)).swap(*this);
	return *this;
	}

	template<class _Rp, class _A0>
	function<_Rp(_A0)>::~function()
	{
	if (__f_ == (__base*)&__buf_)
	__f_->destroy();
	else if (__f_)
	__f_->destroy_deallocate();
	}

	template<class _Rp, class _A0>
	void
	function<_Rp(_A0)>::swap(function& __f)
	{
	if (_VSTD::addressof(__f) == this)
	return;
	if (__f_ == (__base)&__buf_ && __f.__f_ == (__base)&__f.__buf_)
	{
	typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
	__base* __t = (__base*)&__tempbuf;
	__f_->__clone(__t);
	__f_->destroy();
	__f_ = 0;
	__f.__f_->__clone((__base*)&__buf_);
	__f.__f_->destroy();
	__f.__f_ = 0;
	__f_ = (__base*)&__buf_;
	__t->__clone((__base*)&__f.__buf_);
	__t->destroy();
	__f.__f_ = (__base*)&__f.__buf_;
	}
	else if (__f_ == (__base*)&__buf_)
	{
	__f_->__clone((__base*)&__f.__buf_);
	__f_->destroy();
	__f_ = __f.__f_;
	__f.__f_ = (__base*)&__f.__buf_;
	}
	else if (__f.__f_ == (__base*)&__f.__buf_)
	{
	__f.__f_->__clone((__base*)&__buf_);
	__f.__f_->destroy();
	__f.__f_ = __f_;
	__f_ = (__base*)&__buf_;
	}
	else
	_VSTD::swap(__f_, __f.__f_);
	}

	template<class _Rp, class _A0>
	_Rp
	function<_Rp(_A0)>::operator()(_A0 __a0) const
	{
	if (__f_ == 0)
	__throw_bad_function_call();
	return (*__f_)(__a0);
	}

	#ifndef _LIBCPP_NO_RTTI

	template<class _Rp, class _A0>
	const std::type_info&
	function<_Rp(_A0)>::target_type() const
	{
	if (__f_ == 0)
	return typeid(void);
	return __f_->target_type();
	}

	template<class _Rp, class _A0>
	template <typename _Tp>
	_Tp*
	function<_Rp(_A0)>::target()
	{
	if (__f_ == 0)
	return (_Tp*)0;
	return (_Tp) const_cast<void >(__f_->target(typeid(_Tp)));
	}

	template<class _Rp, class _A0>
	template <typename _Tp>
	const _Tp*
	function<_Rp(_A0)>::target() const
	{
	if (__f_ == 0)
	return (const _Tp*)0;
	return (const _Tp*)__f_->target(typeid(_Tp));
	}

	#endif // _LIBCPP_NO_RTTI

	template<class _Rp, class _A0, class _A1>
	class _LIBCPP_TEMPLATE_VIS function<_Rp(_A0, _A1)>
	: public binary_function<_A0, _A1, _Rp>
	{
	typedef __function::__base<_Rp(_A0, _A1)> __base;
	aligned_storage<3sizeof(void)>::type __buf_;
	__base* __f_;

	public:
	typedef _Rp result_type;

	// 20.7.16.2.1, construct/copy/destroy:
	_LIBCPP_INLINE_VISIBILITY explicit function() : __f_(0) {}
	_LIBCPP_INLINE_VISIBILITY function(nullptr_t) : __f_(0) {}
	function(const function&);
	template<class _Fp>
	function(_Fp,
	typename enable_if<!is_integral<_Fp>::value>::type* = 0);

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

	function& operator=(const function&);
	function& operator=(nullptr_t);
	template<class _Fp>
	typename enable_if
	<
	!is_integral<_Fp>::value,
	function&
	>::type
	operator=(_Fp);

	~function();

	// 20.7.16.2.2, function modifiers:
	void swap(function&);
	template<class _Fp, class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	void assign(_Fp __f, const _Alloc& __a)
	{function(allocator_arg, __a, __f).swap(*this);}

	// 20.7.16.2.3, function capacity:
	operator bool() const {return __f_;}

	private:
	// deleted overloads close possible hole in the type system
	template<class _R2, class _B0, class _B1>
	bool operator==(const function<_R2(_B0, _B1)>&) const;// = delete;
	template<class _R2, class _B0, class _B1>
	bool operator!=(const function<_R2(_B0, _B1)>&) const;// = delete;
	public:
	// 20.7.16.2.4, function invocation:
	_Rp operator()(_A0, _A1) const;

	#ifndef _LIBCPP_NO_RTTI
	// 20.7.16.2.5, function target access:
	const std::type_info& target_type() const;
	template <typename _Tp> _Tp* target();
	template <typename _Tp> const _Tp* target() const;
	#endif // _LIBCPP_NO_RTTI
	};

	template<class _Rp, class _A0, class _A1>
	function<_Rp(_A0, _A1)>::function(const function& __f)
	{
	if (__f.__f_ == 0)
	__f_ = 0;
	else if (__f.__f_ == (const __base*)&__f.__buf_)
	{
	__f_ = (__base*)&__buf_;
	__f.__f_->__clone(__f_);
	}
	else
	__f_ = __f.__f_->__clone();
	}

	template<class _Rp, class _A0, class _A1>
	template<class _Alloc>
	function<_Rp(_A0, _A1)>::function(allocator_arg_t, const _Alloc&, const function& __f)
	{
	if (__f.__f_ == 0)
	__f_ = 0;
	else if (__f.__f_ == (const __base*)&__f.__buf_)
	{
	__f_ = (__base*)&__buf_;
	__f.__f_->__clone(__f_);
	}
	else
	__f_ = __f.__f_->__clone();
	}

	template<class _Rp, class _A0, class _A1>
	template <class _Fp>
	function<_Rp(_A0, _A1)>::function(_Fp __f,
	typename enable_if<!is_integral<_Fp>::value>::type*)
	: __f_(0)
	{
	if (__function::__not_null(__f))
	{
	typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_A0, _A1)> _FF;
	if (sizeof(_FF) <= sizeof(__buf_))
	{
	__f_ = (__base*)&__buf_;
	::new (__f_) _FF(__f);
	}
	else
	{
	typedef allocator<_FF> _Ap;
	_Ap __a;
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (__hold.get()) _FF(__f, allocator<_Fp>(__a));
	__f_ = __hold.release();
	}
	}
	}

	template<class _Rp, class _A0, class _A1>
	template <class _Fp, class _Alloc>
	function<_Rp(_A0, _A1)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f,
	typename enable_if<!is_integral<_Fp>::value>::type*)
	: __f_(0)
	{
	typedef allocator_traits<_Alloc> __alloc_traits;
	if (__function::__not_null(__f))
	{
	typedef __function::__func<_Fp, _Alloc, _Rp(_A0, _A1)> _FF;
	if (sizeof(_FF) <= sizeof(__buf_))
	{
	__f_ = (__base*)&__buf_;
	::new (__f_) _FF(__f, __a0);
	}
	else
	{
	typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap;
	_Ap __a(__a0);
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (__hold.get()) _FF(__f, _Alloc(__a));
	__f_ = __hold.release();
	}
	}
	}

	template<class _Rp, class _A0, class _A1>
	function<_Rp(_A0, _A1)>&
	function<_Rp(_A0, _A1)>::operator=(const function& __f)
	{
	- function(__f).swap(*this);
	+ if (__f)
	+ function(__f).swap(*this);
	+ else
	+ *this = nullptr;
	return *this;
	}

	template<class _Rp, class _A0, class _A1>
	function<_Rp(_A0, _A1)>&
	function<_Rp(_A0, _A1)>::operator=(nullptr_t)
	{
	- if (__f_ == (__base*)&__buf_)
	- __f_->destroy();
	- else if (__f_)
	- __f_->destroy_deallocate();
	+ __base* __t = __f_;
	__f_ = 0;
	+ if (__t == (__base*)&__buf_)
	+ __t->destroy();
	+ else if (__t)
	+ __t->destroy_deallocate();
	return *this;
	}

	template<class _Rp, class _A0, class _A1>
	template <class _Fp>
	typename enable_if
	<
	!is_integral<_Fp>::value,
	function<_Rp(_A0, _A1)>&
	>::type
	function<_Rp(_A0, _A1)>::operator=(_Fp __f)
	{
	function(_VSTD::move(__f)).swap(*this);
	return *this;
	}

	template<class _Rp, class _A0, class _A1>
	function<_Rp(_A0, _A1)>::~function()
	{
	if (__f_ == (__base*)&__buf_)
	__f_->destroy();
	else if (__f_)
	__f_->destroy_deallocate();
	}

	template<class _Rp, class _A0, class _A1>
	void
	function<_Rp(_A0, _A1)>::swap(function& __f)
	{
	if (_VSTD::addressof(__f) == this)
	return;
	if (__f_ == (__base)&__buf_ && __f.__f_ == (__base)&__f.__buf_)
	{
	typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
	__base* __t = (__base*)&__tempbuf;
	__f_->__clone(__t);
	__f_->destroy();
	__f_ = 0;
	__f.__f_->__clone((__base*)&__buf_);
	__f.__f_->destroy();
	__f.__f_ = 0;
	__f_ = (__base*)&__buf_;
	__t->__clone((__base*)&__f.__buf_);
	__t->destroy();
	__f.__f_ = (__base*)&__f.__buf_;
	}
	else if (__f_ == (__base*)&__buf_)
	{
	__f_->__clone((__base*)&__f.__buf_);
	__f_->destroy();
	__f_ = __f.__f_;
	__f.__f_ = (__base*)&__f.__buf_;
	}
	else if (__f.__f_ == (__base*)&__f.__buf_)
	{
	__f.__f_->__clone((__base*)&__buf_);
	__f.__f_->destroy();
	__f.__f_ = __f_;
	__f_ = (__base*)&__buf_;
	}
	else
	_VSTD::swap(__f_, __f.__f_);
	}

	template<class _Rp, class _A0, class _A1>
	_Rp
	function<_Rp(_A0, _A1)>::operator()(_A0 __a0, _A1 __a1) const
	{
	if (__f_ == 0)
	__throw_bad_function_call();
	return (*__f_)(__a0, __a1);
	}

	#ifndef _LIBCPP_NO_RTTI

	template<class _Rp, class _A0, class _A1>
	const std::type_info&
	function<_Rp(_A0, _A1)>::target_type() const
	{
	if (__f_ == 0)
	return typeid(void);
	return __f_->target_type();
	}

	template<class _Rp, class _A0, class _A1>
	template <typename _Tp>
	_Tp*
	function<_Rp(_A0, _A1)>::target()
	{
	if (__f_ == 0)
	return (_Tp*)0;
	return (_Tp) const_cast<void >(__f_->target(typeid(_Tp)));
	}

	template<class _Rp, class _A0, class _A1>
	template <typename _Tp>
	const _Tp*
	function<_Rp(_A0, _A1)>::target() const
	{
	if (__f_ == 0)
	return (const _Tp*)0;
	return (const _Tp*)__f_->target(typeid(_Tp));
	}

	#endif // _LIBCPP_NO_RTTI

	template<class _Rp, class _A0, class _A1, class _A2>
	class _LIBCPP_TEMPLATE_VIS function<_Rp(_A0, _A1, _A2)>
	{
	typedef __function::__base<_Rp(_A0, _A1, _A2)> __base;
	aligned_storage<3sizeof(void)>::type __buf_;
	__base* __f_;

	public:
	typedef _Rp result_type;

	// 20.7.16.2.1, construct/copy/destroy:
	_LIBCPP_INLINE_VISIBILITY explicit function() : __f_(0) {}
	_LIBCPP_INLINE_VISIBILITY function(nullptr_t) : __f_(0) {}
	function(const function&);
	template<class _Fp>
	function(_Fp,
	typename enable_if<!is_integral<_Fp>::value>::type* = 0);

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

	function& operator=(const function&);
	function& operator=(nullptr_t);
	template<class _Fp>
	typename enable_if
	<
	!is_integral<_Fp>::value,
	function&
	>::type
	operator=(_Fp);

	~function();

	// 20.7.16.2.2, function modifiers:
	void swap(function&);
	template<class _Fp, class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	void assign(_Fp __f, const _Alloc& __a)
	{function(allocator_arg, __a, __f).swap(*this);}

	// 20.7.16.2.3, function capacity:
	_LIBCPP_INLINE_VISIBILITY operator bool() const {return __f_;}

	private:
	// deleted overloads close possible hole in the type system
	template<class _R2, class _B0, class _B1, class _B2>
	bool operator==(const function<_R2(_B0, _B1, _B2)>&) const;// = delete;
	template<class _R2, class _B0, class _B1, class _B2>
	bool operator!=(const function<_R2(_B0, _B1, _B2)>&) const;// = delete;
	public:
	// 20.7.16.2.4, function invocation:
	_Rp operator()(_A0, _A1, _A2) const;

	#ifndef _LIBCPP_NO_RTTI
	// 20.7.16.2.5, function target access:
	const std::type_info& target_type() const;
	template <typename _Tp> _Tp* target();
	template <typename _Tp> const _Tp* target() const;
	#endif // _LIBCPP_NO_RTTI
	};

	template<class _Rp, class _A0, class _A1, class _A2>
	function<_Rp(_A0, _A1, _A2)>::function(const function& __f)
	{
	if (__f.__f_ == 0)
	__f_ = 0;
	else if (__f.__f_ == (const __base*)&__f.__buf_)
	{
	__f_ = (__base*)&__buf_;
	__f.__f_->__clone(__f_);
	}
	else
	__f_ = __f.__f_->__clone();
	}

	template<class _Rp, class _A0, class _A1, class _A2>
	template<class _Alloc>
	function<_Rp(_A0, _A1, _A2)>::function(allocator_arg_t, const _Alloc&,
	const function& __f)
	{
	if (__f.__f_ == 0)
	__f_ = 0;
	else if (__f.__f_ == (const __base*)&__f.__buf_)
	{
	__f_ = (__base*)&__buf_;
	__f.__f_->__clone(__f_);
	}
	else
	__f_ = __f.__f_->__clone();
	}

	template<class _Rp, class _A0, class _A1, class _A2>
	template <class _Fp>
	function<_Rp(_A0, _A1, _A2)>::function(_Fp __f,
	typename enable_if<!is_integral<_Fp>::value>::type*)
	: __f_(0)
	{
	if (__function::__not_null(__f))
	{
	typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_A0, _A1, _A2)> _FF;
	if (sizeof(_FF) <= sizeof(__buf_))
	{
	__f_ = (__base*)&__buf_;
	::new (__f_) _FF(__f);
	}
	else
	{
	typedef allocator<_FF> _Ap;
	_Ap __a;
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (__hold.get()) _FF(__f, allocator<_Fp>(__a));
	__f_ = __hold.release();
	}
	}
	}

	template<class _Rp, class _A0, class _A1, class _A2>
	template <class _Fp, class _Alloc>
	function<_Rp(_A0, _A1, _A2)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f,
	typename enable_if<!is_integral<_Fp>::value>::type*)
	: __f_(0)
	{
	typedef allocator_traits<_Alloc> __alloc_traits;
	if (__function::__not_null(__f))
	{
	typedef __function::__func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)> _FF;
	if (sizeof(_FF) <= sizeof(__buf_))
	{
	__f_ = (__base*)&__buf_;
	::new (__f_) _FF(__f, __a0);
	}
	else
	{
	typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap;
	_Ap __a(__a0);
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (__hold.get()) _FF(__f, _Alloc(__a));
	__f_ = __hold.release();
	}
	}
	}

	template<class _Rp, class _A0, class _A1, class _A2>
	function<_Rp(_A0, _A1, _A2)>&
	function<_Rp(_A0, _A1, _A2)>::operator=(const function& __f)
	{
	- function(__f).swap(*this);
	+ if (__f)
	+ function(__f).swap(*this);
	+ else
	+ *this = nullptr;
	return *this;
	}

	template<class _Rp, class _A0, class _A1, class _A2>
	function<_Rp(_A0, _A1, _A2)>&
	function<_Rp(_A0, _A1, _A2)>::operator=(nullptr_t)
	{
	- if (__f_ == (__base*)&__buf_)
	- __f_->destroy();
	- else if (__f_)
	- __f_->destroy_deallocate();
	+ __base* __t = __f_;
	__f_ = 0;
	+ if (__t == (__base*)&__buf_)
	+ __t->destroy();
	+ else if (__t)
	+ __t->destroy_deallocate();
	return *this;
	}

	template<class _Rp, class _A0, class _A1, class _A2>
	template <class _Fp>
	typename enable_if
	<
	!is_integral<_Fp>::value,
	function<_Rp(_A0, _A1, _A2)>&
	>::type
	function<_Rp(_A0, _A1, _A2)>::operator=(_Fp __f)
	{
	function(_VSTD::move(__f)).swap(*this);
	return *this;
	}

	template<class _Rp, class _A0, class _A1, class _A2>
	function<_Rp(_A0, _A1, _A2)>::~function()
	{
	if (__f_ == (__base*)&__buf_)
	__f_->destroy();
	else if (__f_)
	__f_->destroy_deallocate();
	}

	template<class _Rp, class _A0, class _A1, class _A2>
	void
	function<_Rp(_A0, _A1, _A2)>::swap(function& __f)
	{
	if (_VSTD::addressof(__f) == this)
	return;
	if (__f_ == (__base)&__buf_ && __f.__f_ == (__base)&__f.__buf_)
	{
	typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
	__base* __t = (__base*)&__tempbuf;
	__f_->__clone(__t);
	__f_->destroy();
	__f_ = 0;
	__f.__f_->__clone((__base*)&__buf_);
	__f.__f_->destroy();
	__f.__f_ = 0;
	__f_ = (__base*)&__buf_;
	__t->__clone((__base*)&__f.__buf_);
	__t->destroy();
	__f.__f_ = (__base*)&__f.__buf_;
	}
	else if (__f_ == (__base*)&__buf_)
	{
	__f_->__clone((__base*)&__f.__buf_);
	__f_->destroy();
	__f_ = __f.__f_;
	__f.__f_ = (__base*)&__f.__buf_;
	}
	else if (__f.__f_ == (__base*)&__f.__buf_)
	{
	__f.__f_->__clone((__base*)&__buf_);
	__f.__f_->destroy();
	__f.__f_ = __f_;
	__f_ = (__base*)&__buf_;
	}
	else
	_VSTD::swap(__f_, __f.__f_);
	}

	template<class _Rp, class _A0, class _A1, class _A2>
	_Rp
	function<_Rp(_A0, _A1, _A2)>::operator()(_A0 __a0, _A1 __a1, _A2 __a2) const
	{
	if (__f_ == 0)
	__throw_bad_function_call();
	return (*__f_)(__a0, __a1, __a2);
	}

	#ifndef _LIBCPP_NO_RTTI

	template<class _Rp, class _A0, class _A1, class _A2>
	const std::type_info&
	function<_Rp(_A0, _A1, _A2)>::target_type() const
	{
	if (__f_ == 0)
	return typeid(void);
	return __f_->target_type();
	}

	template<class _Rp, class _A0, class _A1, class _A2>
	template <typename _Tp>
	_Tp*
	function<_Rp(_A0, _A1, _A2)>::target()
	{
	if (__f_ == 0)
	return (_Tp*)0;
	return (_Tp) const_cast<void >(__f_->target(typeid(_Tp)));
	}

	template<class _Rp, class _A0, class _A1, class _A2>
	template <typename _Tp>
	const _Tp*
	function<_Rp(_A0, _A1, _A2)>::target() const
	{
	if (__f_ == 0)
	return (const _Tp*)0;
	return (const _Tp*)__f_->target(typeid(_Tp));
	}

	#endif // _LIBCPP_NO_RTTI

	template <class _Fp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const function<_Fp>& __f, nullptr_t) {return !__f;}

	template <class _Fp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(nullptr_t, const function<_Fp>& __f) {return !__f;}

	template <class _Fp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const function<_Fp>& __f, nullptr_t) {return (bool)__f;}

	template <class _Fp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(nullptr_t, const function<_Fp>& __f) {return (bool)__f;}

	template <class _Fp>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(function<_Fp>& __x, function<_Fp>& __y)
	{return __x.swap(__y);}

	#endif // _LIBCPP_FUNCTIONAL_03
	Index: projects/clang700-import/contrib/libc++/include/__functional_base
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/__functional_base (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/__functional_base (revision 337135)
	@@ -1,663 +1,653 @@
	// -- 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.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP_FUNCTIONAL_BASE
	#define _LIBCPP_FUNCTIONAL_BASE

	#include <__config>
	#include <type_traits>
	#include <typeinfo>
	#include <exception>
	#include <new>
	#include <utility>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _Arg1, class _Arg2, class _Result>
	struct _LIBCPP_TEMPLATE_VIS binary_function
	{
	typedef _Arg1 first_argument_type;
	typedef _Arg2 second_argument_type;
	typedef _Result result_type;
	};

	template <class _Tp>
	struct __has_result_type
	{
	private:
	struct __two {char __lx; char __lxx;};
	template <class _Up> static __two __test(...);
	template <class _Up> static char __test(typename _Up::result_type* = 0);
	public:
	static const bool value = sizeof(__test<_Tp>(0)) == 1;
	};

	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS less : binary_function<_Tp, _Tp, bool>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Tp& __x, const _Tp& __y) const
	{return __x < __y;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS less<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

	// __weak_result_type

	template <class _Tp>
	struct __derives_from_unary_function
	{
	private:
	struct __two {char __lx; char __lxx;};
	static __two __test(...);
	template <class _Ap, class _Rp>
	static unary_function<_Ap, _Rp>
	__test(const volatile unary_function<_Ap, _Rp>*);
	public:
	static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
	typedef decltype(__test((_Tp*)0)) type;
	};

	template <class _Tp>
	struct __derives_from_binary_function
	{
	private:
	struct __two {char __lx; char __lxx;};
	static __two __test(...);
	template <class _A1, class _A2, class _Rp>
	static binary_function<_A1, _A2, _Rp>
	__test(const volatile binary_function<_A1, _A2, _Rp>*);
	public:
	static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
	typedef decltype(__test((_Tp*)0)) type;
	};

	template <class _Tp, bool = __derives_from_unary_function<_Tp>::value>
	struct __maybe_derive_from_unary_function // bool is true
	: public __derives_from_unary_function<_Tp>::type
	{
	};

	template <class _Tp>
	struct __maybe_derive_from_unary_function<_Tp, false>
	{
	};

	template <class _Tp, bool = __derives_from_binary_function<_Tp>::value>
	struct __maybe_derive_from_binary_function // bool is true
	: public __derives_from_binary_function<_Tp>::type
	{
	};

	template <class _Tp>
	struct __maybe_derive_from_binary_function<_Tp, false>
	{
	};

	template <class _Tp, bool = __has_result_type<_Tp>::value>
	struct __weak_result_type_imp // bool is true
	: public __maybe_derive_from_unary_function<_Tp>,
	public __maybe_derive_from_binary_function<_Tp>
	{
	typedef typename _Tp::result_type result_type;
	};

	template <class _Tp>
	struct __weak_result_type_imp<_Tp, false>
	: public __maybe_derive_from_unary_function<_Tp>,
	public __maybe_derive_from_binary_function<_Tp>
	{
	};

	template <class _Tp>
	struct __weak_result_type
	: public __weak_result_type_imp<_Tp>
	{
	};

	// 0 argument case

	template <class _Rp>
	struct __weak_result_type<_Rp ()>
	{
	typedef _Rp result_type;
	};

	template <class _Rp>
	struct __weak_result_type<_Rp (&)()>
	{
	typedef _Rp result_type;
	};

	template <class _Rp>
	struct __weak_result_type<_Rp (*)()>
	{
	typedef _Rp result_type;
	};

	// 1 argument case

	template <class _Rp, class _A1>
	struct __weak_result_type<_Rp (_A1)>
	: public unary_function<_A1, _Rp>
	{
	};

	template <class _Rp, class _A1>
	struct __weak_result_type<_Rp (&)(_A1)>
	: public unary_function<_A1, _Rp>
	{
	};

	template <class _Rp, class _A1>
	struct __weak_result_type<_Rp (*)(_A1)>
	: public unary_function<_A1, _Rp>
	{
	};

	template <class _Rp, class _Cp>
	struct __weak_result_type<_Rp (_Cp::*)()>
	: public unary_function<_Cp*, _Rp>
	{
	};

	template <class _Rp, class _Cp>
	struct __weak_result_type<_Rp (_Cp::*)() const>
	: public unary_function<const _Cp*, _Rp>
	{
	};

	template <class _Rp, class _Cp>
	struct __weak_result_type<_Rp (_Cp::*)() volatile>
	: public unary_function<volatile _Cp*, _Rp>
	{
	};

	template <class _Rp, class _Cp>
	struct __weak_result_type<_Rp (_Cp::*)() const volatile>
	: public unary_function<const volatile _Cp*, _Rp>
	{
	};

	// 2 argument case

	template <class _Rp, class _A1, class _A2>
	struct __weak_result_type<_Rp (_A1, _A2)>
	: public binary_function<_A1, _A2, _Rp>
	{
	};

	template <class _Rp, class _A1, class _A2>
	struct __weak_result_type<_Rp (*)(_A1, _A2)>
	: public binary_function<_A1, _A2, _Rp>
	{
	};

	template <class _Rp, class _A1, class _A2>
	struct __weak_result_type<_Rp (&)(_A1, _A2)>
	: public binary_function<_A1, _A2, _Rp>
	{
	};

	template <class _Rp, class _Cp, class _A1>
	struct __weak_result_type<_Rp (_Cp::*)(_A1)>
	: public binary_function<_Cp*, _A1, _Rp>
	{
	};

	template <class _Rp, class _Cp, class _A1>
	struct __weak_result_type<_Rp (_Cp::*)(_A1) const>
	: public binary_function<const _Cp*, _A1, _Rp>
	{
	};

	template <class _Rp, class _Cp, class _A1>
	struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile>
	: public binary_function<volatile _Cp*, _A1, _Rp>
	{
	};

	template <class _Rp, class _Cp, class _A1>
	struct __weak_result_type<_Rp (_Cp::*)(_A1) const volatile>
	: public binary_function<const volatile _Cp*, _A1, _Rp>
	{
	};


	#ifndef _LIBCPP_CXX03_LANG
	// 3 or more arguments

	template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
	struct __weak_result_type<_Rp (_A1, _A2, _A3, _A4...)>
	{
	typedef _Rp result_type;
	};

	template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
	struct __weak_result_type<_Rp (&)(_A1, _A2, _A3, _A4...)>
	{
	typedef _Rp result_type;
	};

	template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
	struct __weak_result_type<_Rp (*)(_A1, _A2, _A3, _A4...)>
	{
	typedef _Rp result_type;
	};

	template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
	struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...)>
	{
	typedef _Rp result_type;
	};

	template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
	struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const>
	{
	typedef _Rp result_type;
	};

	template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
	struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) volatile>
	{
	typedef _Rp result_type;
	};

	template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
	struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const volatile>
	{
	typedef _Rp result_type;
	};

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

	#else // defined(_LIBCPP_CXX03_LANG)

	#include <__functional_base_03>

	#endif // !defined(_LIBCPP_CXX03_LANG)


	template <class _Ret>
	struct __invoke_void_return_wrapper
	{
	#ifndef _LIBCPP_CXX03_LANG
	template <class ..._Args>
	static _Ret __call(_Args&&... __args) {
	return __invoke(_VSTD::forward<_Args>(__args)...);
	}
	#else
	template <class _Fn>
	static _Ret __call(_Fn __f) {
	return __invoke(__f);
	}

	template <class _Fn, class _A0>
	static _Ret __call(_Fn __f, _A0& __a0) {
	return __invoke(__f, __a0);
	}

	template <class _Fn, class _A0, class _A1>
	static _Ret __call(_Fn __f, _A0& __a0, _A1& __a1) {
	return __invoke(__f, __a0, __a1);
	}

	template <class _Fn, class _A0, class _A1, class _A2>
	static _Ret __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2){
	return __invoke(__f, __a0, __a1, __a2);
	}
	#endif
	};

	template <>
	struct __invoke_void_return_wrapper<void>
	{
	#ifndef _LIBCPP_CXX03_LANG
	template <class ..._Args>
	static void __call(_Args&&... __args) {
	__invoke(_VSTD::forward<_Args>(__args)...);
	}
	#else
	template <class _Fn>
	static void __call(_Fn __f) {
	__invoke(__f);
	}

	template <class _Fn, class _A0>
	static void __call(_Fn __f, _A0& __a0) {
	__invoke(__f, __a0);
	}

	template <class _Fn, class _A0, class _A1>
	static void __call(_Fn __f, _A0& __a0, _A1& __a1) {
	__invoke(__f, __a0, __a1);
	}

	template <class _Fn, class _A0, class _A1, class _A2>
	static void __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2) {
	__invoke(__f, __a0, __a1, __a2);
	}
	#endif
	};

	template <class _Tp>
	class _LIBCPP_TEMPLATE_VIS reference_wrapper
	: public __weak_result_type<_Tp>
	{
	public:
	// types
	typedef _Tp type;
	private:
	type* __f_;

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

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

	#ifndef _LIBCPP_CXX03_LANG
	// invoke
	template <class... _ArgTypes>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_of<type&, _ArgTypes...>::type
	operator() (_ArgTypes&&... __args) const {
	return __invoke(get(), _VSTD::forward<_ArgTypes>(__args)...);
	}
	#else

	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return<type>::type
	operator() () const {
	return __invoke(get());
	}

	template <class _A0>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return0<type, _A0>::type
	operator() (_A0& __a0) const {
	return __invoke(get(), __a0);
	}

	template <class _A0>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return0<type, _A0 const>::type
	operator() (_A0 const& __a0) const {
	return __invoke(get(), __a0);
	}

	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return1<type, _A0, _A1>::type
	operator() (_A0& __a0, _A1& __a1) const {
	return __invoke(get(), __a0, __a1);
	}

	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return1<type, _A0 const, _A1>::type
	operator() (_A0 const& __a0, _A1& __a1) const {
	return __invoke(get(), __a0, __a1);
	}

	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return1<type, _A0, _A1 const>::type
	operator() (_A0& __a0, _A1 const& __a1) const {
	return __invoke(get(), __a0, __a1);
	}

	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return1<type, _A0 const, _A1 const>::type
	operator() (_A0 const& __a0, _A1 const& __a1) const {
	return __invoke(get(), __a0, __a1);
	}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return2<type, _A0, _A1, _A2>::type
	operator() (_A0& __a0, _A1& __a1, _A2& __a2) const {
	return __invoke(get(), __a0, __a1, __a2);
	}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return2<type, _A0 const, _A1, _A2>::type
	operator() (_A0 const& __a0, _A1& __a1, _A2& __a2) const {
	return __invoke(get(), __a0, __a1, __a2);
	}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return2<type, _A0, _A1 const, _A2>::type
	operator() (_A0& __a0, _A1 const& __a1, _A2& __a2) const {
	return __invoke(get(), __a0, __a1, __a2);
	}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return2<type, _A0, _A1, _A2 const>::type
	operator() (_A0& __a0, _A1& __a1, _A2 const& __a2) const {
	return __invoke(get(), __a0, __a1, __a2);
	}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return2<type, _A0 const, _A1 const, _A2>::type
	operator() (_A0 const& __a0, _A1 const& __a1, _A2& __a2) const {
	return __invoke(get(), __a0, __a1, __a2);
	}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return2<type, _A0 const, _A1, _A2 const>::type
	operator() (_A0 const& __a0, _A1& __a1, _A2 const& __a2) const {
	return __invoke(get(), __a0, __a1, __a2);
	}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return2<type, _A0, _A1 const, _A2 const>::type
	operator() (_A0& __a0, _A1 const& __a1, _A2 const& __a2) const {
	return __invoke(get(), __a0, __a1, __a2);
	}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return2<type, _A0 const, _A1 const, _A2 const>::type
	operator() (_A0 const& __a0, _A1 const& __a1, _A2 const& __a2) const {
	return __invoke(get(), __a0, __a1, __a2);
	}
	#endif // _LIBCPP_CXX03_LANG
	};


	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	reference_wrapper<_Tp>
	ref(_Tp& __t) _NOEXCEPT
	{
	return reference_wrapper<_Tp>(__t);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	reference_wrapper<_Tp>
	ref(reference_wrapper<_Tp> __t) _NOEXCEPT
	{
	return ref(__t.get());
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	reference_wrapper<const _Tp>
	cref(const _Tp& __t) _NOEXCEPT
	{
	return reference_wrapper<const _Tp>(__t);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	reference_wrapper<const _Tp>
	cref(reference_wrapper<_Tp> __t) _NOEXCEPT
	{
	return cref(__t.get());
	}

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Tp> void ref(const _Tp&&) = delete;
	template <class _Tp> void cref(const _Tp&&) = delete;
	#endif

	#if _LIBCPP_STD_VER > 11
	template <class _Tp, class, class = void>
	struct __is_transparent : false_type {};

	template <class _Tp, class _Up>
	struct __is_transparent<_Tp, _Up,
	typename __void_t<typename _Tp::is_transparent>::type>
	: true_type {};
	#endif

	// allocator_arg_t

	struct _LIBCPP_TEMPLATE_VIS allocator_arg_t { };

	#if defined(_LIBCPP_CXX03_LANG) \|\| defined(_LIBCPP_BUILDING_MEMORY)
	extern const allocator_arg_t allocator_arg;
	#else
	/* _LIBCPP_INLINE_VAR */ constexpr allocator_arg_t allocator_arg = allocator_arg_t();
	#endif

	// uses_allocator

	template <class _Tp>
	struct __has_allocator_type
	{
	private:
	struct __two {char __lx; char __lxx;};
	template <class _Up> static __two __test(...);
	template <class _Up> static char __test(typename _Up::allocator_type* = 0);
	public:
	static const bool value = sizeof(__test<_Tp>(0)) == 1;
	};

	template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value>
	struct __uses_allocator
	: public integral_constant<bool,
	is_convertible<_Alloc, typename _Tp::allocator_type>::value>
	{
	};

	template <class _Tp, class _Alloc>
	struct __uses_allocator<_Tp, _Alloc, false>
	: public false_type
	{
	};

	template <class _Tp, class _Alloc>
	struct _LIBCPP_TEMPLATE_VIS uses_allocator
	: public __uses_allocator<_Tp, _Alloc>
	{
	};

	#if _LIBCPP_STD_VER > 14
	template <class _Tp, class _Alloc>
	_LIBCPP_INLINE_VAR constexpr size_t uses_allocator_v = uses_allocator<_Tp, _Alloc>::value;
	#endif

	#ifndef _LIBCPP_CXX03_LANG

	// allocator construction

	template <class _Tp, class _Alloc, class ..._Args>
	struct __uses_alloc_ctor_imp
	{
	typedef typename __uncvref<_Alloc>::type _RawAlloc;
	static const bool __ua = uses_allocator<_Tp, _RawAlloc>::value;
	static const bool __ic =
	is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
	static const int value = __ua ? 2 - __ic : 0;
	};

	template <class _Tp, class _Alloc, class ..._Args>
	struct __uses_alloc_ctor
	: integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value>
	{};

	template <class _Tp, class _Allocator, class... _Args>
	inline _LIBCPP_INLINE_VISIBILITY
	void __user_alloc_construct_impl (integral_constant<int, 0>, _Tp *__storage, const _Allocator &, _Args &&... __args )
	{
	new (__storage) _Tp (_VSTD::forward<_Args>(__args)...);
	}

	// FIXME: This should have a version which takes a non-const alloc.
	template <class _Tp, class _Allocator, class... _Args>
	inline _LIBCPP_INLINE_VISIBILITY
	void __user_alloc_construct_impl (integral_constant<int, 1>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
	{
	new (__storage) _Tp (allocator_arg, __a, _VSTD::forward<_Args>(__args)...);
	}

	// FIXME: This should have a version which takes a non-const alloc.
	template <class _Tp, class _Allocator, class... _Args>
	inline _LIBCPP_INLINE_VISIBILITY
	void __user_alloc_construct_impl (integral_constant<int, 2>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
	{
	new (__storage) _Tp (_VSTD::forward<_Args>(__args)..., __a);
	}

	-// FIXME: Theis should have a version which takes a non-const alloc.
	-template <class _Tp, class _Allocator, class... _Args>
	-inline _LIBCPP_INLINE_VISIBILITY
	-void __user_alloc_construct (_Tp *__storage, const _Allocator &__a, _Args &&... __args)
	-{
	- __user_alloc_construct_impl(
	- __uses_alloc_ctor<_Tp, _Allocator>(),
	- __storage, __a, _VSTD::forward<_Args>(__args)...
	- );
	-}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_FUNCTIONAL_BASE
	Index: projects/clang700-import/contrib/libc++/include/__hash_table
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/__hash_table (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/__hash_table (revision 337135)
	@@ -1,2676 +1,2670 @@
	// -- 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.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP__HASH_TABLE
	#define _LIBCPP__HASH_TABLE

	#include <__config>
	#include <initializer_list>
	#include <memory>
	#include <iterator>
	#include <algorithm>
	#include <cmath>
	#include <utility>
	#include <type_traits>

	#include <__debug>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_STD

	-#ifndef _LIBCPP_CXX03_LANG
	template <class _Key, class _Tp>
	-union __hash_value_type;
	-#else
	-template <class _Key, class _Tp>
	struct __hash_value_type;
	-#endif

	template <class _Key, class _Cp, class _Hash,
	bool = is_empty<_Hash>::value && !__libcpp_is_final<_Hash>::value>
	class __unordered_map_hasher;

	template <class _Key, class _Cp, class _Pred,
	bool = is_empty<_Pred>::value && !__libcpp_is_final<_Pred>::value
	>
	class __unordered_map_equal;

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Tp>
	struct __is_hash_value_type_imp : false_type {};

	template <class _Key, class _Value>
	struct __is_hash_value_type_imp<__hash_value_type<_Key, _Value>> : true_type {};

	template <class ..._Args>
	struct __is_hash_value_type : false_type {};

	template <class _One>
	struct __is_hash_value_type<_One> : __is_hash_value_type_imp<typename __uncvref<_One>::type> {};
	#endif

	_LIBCPP_FUNC_VIS
	size_t __next_prime(size_t __n);

	template <class _NodePtr>
	struct __hash_node_base
	{
	typedef typename pointer_traits<_NodePtr>::element_type __node_type;
	typedef __hash_node_base __first_node;
	typedef typename __rebind_pointer<_NodePtr, __first_node>::type __node_base_pointer;
	typedef _NodePtr __node_pointer;

	#if defined(_LIBCPP_ABI_FIX_UNORDERED_NODE_POINTER_UB)
	typedef __node_base_pointer __next_pointer;
	#else
	typedef typename conditional<
	is_pointer<__node_pointer>::value,
	__node_base_pointer,
	__node_pointer>::type __next_pointer;
	#endif

	__next_pointer __next_;

	_LIBCPP_INLINE_VISIBILITY
	__next_pointer __ptr() _NOEXCEPT {
	return static_cast<__next_pointer>(
	pointer_traits<__node_base_pointer>::pointer_to(*this));
	}

	_LIBCPP_INLINE_VISIBILITY
	__node_pointer __upcast() _NOEXCEPT {
	return static_cast<__node_pointer>(
	pointer_traits<__node_base_pointer>::pointer_to(*this));
	}

	_LIBCPP_INLINE_VISIBILITY
	size_t __hash() const _NOEXCEPT {
	return static_cast<__node_type const&>(*this).__hash_;
	}

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

	template <class _Tp, class _VoidPtr>
	struct __hash_node
	: public __hash_node_base
	<
	typename __rebind_pointer<_VoidPtr, __hash_node<_Tp, _VoidPtr> >::type
	>
	{
	typedef _Tp __node_value_type;

	size_t __hash_;
	__node_value_type __value_;
	};

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	__is_hash_power2(size_t __bc)
	{
	return __bc > 2 && !(__bc & (__bc - 1));
	}

	inline _LIBCPP_INLINE_VISIBILITY
	size_t
	__constrain_hash(size_t __h, size_t __bc)
	{
	return !(__bc & (__bc - 1)) ? __h & (__bc - 1) :
	(__h < __bc ? __h : __h % __bc);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	size_t
	__next_hash_pow2(size_t __n)
	{
	return __n < 2 ? __n : (size_t(1) << (std::numeric_limits<size_t>::digits - __clz(__n-1)));
	}


	template <class _Tp, class _Hash, class _Equal, class _Alloc> class __hash_table;

	template <class _NodePtr> class _LIBCPP_TEMPLATE_VIS __hash_iterator;
	template <class _ConstNodePtr> class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
	template <class _NodePtr> class _LIBCPP_TEMPLATE_VIS __hash_local_iterator;
	template <class _ConstNodePtr> class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
	template <class _HashIterator> class _LIBCPP_TEMPLATE_VIS __hash_map_iterator;
	template <class _HashIterator> class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;

	template <class _Tp>
	struct __hash_key_value_types {
	static_assert(!is_reference<_Tp>::value && !is_const<_Tp>::value, "");
	typedef _Tp key_type;
	typedef _Tp __node_value_type;
	typedef _Tp __container_value_type;
	static const bool __is_map = false;

	_LIBCPP_INLINE_VISIBILITY
	static key_type const& __get_key(_Tp const& __v) {
	return __v;
	}
	_LIBCPP_INLINE_VISIBILITY
	static __container_value_type const& __get_value(__node_value_type const& __v) {
	return __v;
	}
	_LIBCPP_INLINE_VISIBILITY
	static __container_value_type* __get_ptr(__node_value_type& __n) {
	return _VSTD::addressof(__n);
	}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	- static __container_value_type&& __move(__node_value_type& __v) {
	+ static __container_value_type&& __move(__node_value_type& __v) {
	return _VSTD::move(__v);
	}
	#endif
	};

	template <class _Key, class _Tp>
	struct __hash_key_value_types<__hash_value_type<_Key, _Tp> > {
	typedef _Key key_type;
	typedef _Tp mapped_type;
	typedef __hash_value_type<_Key, _Tp> __node_value_type;
	typedef pair<const _Key, _Tp> __container_value_type;
	- typedef pair<_Key, _Tp> __nc_value_type;
	typedef __container_value_type __map_value_type;
	static const bool __is_map = true;

	_LIBCPP_INLINE_VISIBILITY
	static key_type const& __get_key(__container_value_type const& __v) {
	return __v.first;
	}

	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY
	static typename enable_if<__is_same_uncvref<_Up, __node_value_type>::value,
	__container_value_type const&>::type
	__get_value(_Up& __t) {
	- return __t.__cc;
	+ return __t.__get_value();
	}

	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY
	static typename enable_if<__is_same_uncvref<_Up, __container_value_type>::value,
	__container_value_type const&>::type
	__get_value(_Up& __t) {
	return __t;
	}

	_LIBCPP_INLINE_VISIBILITY
	static __container_value_type* __get_ptr(__node_value_type& __n) {
	- return _VSTD::addressof(__n.__cc);
	+ return _VSTD::addressof(__n.__get_value());
	}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	- static __nc_value_type&& __move(__node_value_type& __v) {
	- return _VSTD::move(__v.__nc);
	+ static pair<key_type&&, mapped_type&&> __move(__node_value_type& __v) {
	+ return __v.__move();
	}
	#endif

	};

	template <class _Tp, class _AllocPtr, class _KVTypes = __hash_key_value_types<_Tp>,
	bool = _KVTypes::__is_map>
	struct __hash_map_pointer_types {};

	template <class _Tp, class _AllocPtr, class _KVTypes>
	struct __hash_map_pointer_types<_Tp, _AllocPtr, _KVTypes, true> {
	typedef typename _KVTypes::__map_value_type _Mv;
	typedef typename __rebind_pointer<_AllocPtr, _Mv>::type
	__map_value_type_pointer;
	typedef typename __rebind_pointer<_AllocPtr, const _Mv>::type
	__const_map_value_type_pointer;
	};

	template <class _NodePtr, class _NodeT = typename pointer_traits<_NodePtr>::element_type>
	struct __hash_node_types;

	template <class _NodePtr, class _Tp, class _VoidPtr>
	struct __hash_node_types<_NodePtr, __hash_node<_Tp, _VoidPtr> >
	: public __hash_key_value_types<_Tp>, __hash_map_pointer_types<_Tp, _VoidPtr>

	{
	typedef __hash_key_value_types<_Tp> __base;

	public:
	typedef ptrdiff_t difference_type;
	typedef size_t size_type;

	typedef typename __rebind_pointer<_NodePtr, void>::type __void_pointer;

	typedef typename pointer_traits<_NodePtr>::element_type __node_type;
	typedef _NodePtr __node_pointer;

	typedef __hash_node_base<__node_pointer> __node_base_type;
	typedef typename __rebind_pointer<_NodePtr, __node_base_type>::type
	__node_base_pointer;

	typedef typename __node_base_type::__next_pointer __next_pointer;

	typedef _Tp __node_value_type;
	typedef typename __rebind_pointer<_VoidPtr, __node_value_type>::type
	__node_value_type_pointer;
	typedef typename __rebind_pointer<_VoidPtr, const __node_value_type>::type
	__const_node_value_type_pointer;

	private:
	static_assert(!is_const<__node_type>::value,
	"_NodePtr should never be a pointer to const");
	static_assert((is_same<typename pointer_traits<_VoidPtr>::element_type, void>::value),
	"_VoidPtr does not point to unqualified void type");
	static_assert((is_same<typename __rebind_pointer<_VoidPtr, __node_type>::type,
	_NodePtr>::value), "_VoidPtr does not rebind to _NodePtr.");
	};

	template <class _HashIterator>
	struct __hash_node_types_from_iterator;
	template <class _NodePtr>
	struct __hash_node_types_from_iterator<__hash_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {};
	template <class _NodePtr>
	struct __hash_node_types_from_iterator<__hash_const_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {};
	template <class _NodePtr>
	struct __hash_node_types_from_iterator<__hash_local_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {};
	template <class _NodePtr>
	struct __hash_node_types_from_iterator<__hash_const_local_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {};


	template <class _NodeValueTp, class _VoidPtr>
	struct __make_hash_node_types {
	typedef __hash_node<_NodeValueTp, _VoidPtr> _NodeTp;
	typedef typename __rebind_pointer<_VoidPtr, _NodeTp>::type _NodePtr;
	typedef __hash_node_types<_NodePtr> type;
	};

	template <class _NodePtr>
	class _LIBCPP_TEMPLATE_VIS __hash_iterator
	{
	typedef __hash_node_types<_NodePtr> _NodeTypes;
	typedef _NodePtr __node_pointer;
	typedef typename _NodeTypes::__next_pointer __next_pointer;

	__next_pointer __node_;

	public:
	typedef forward_iterator_tag iterator_category;
	typedef typename _NodeTypes::__node_value_type value_type;
	typedef typename _NodeTypes::difference_type difference_type;
	typedef value_type& reference;
	typedef typename _NodeTypes::__node_value_type_pointer pointer;

	_LIBCPP_INLINE_VISIBILITY __hash_iterator() _NOEXCEPT : __node_(nullptr) {
	_LIBCPP_DEBUG_MODE(__get_db()->__insert_i(this));
	}

	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_INLINE_VISIBILITY
	__hash_iterator(const __hash_iterator& __i)
	: __node_(__i.__node_)
	{
	__get_db()->__iterator_copy(this, &__i);
	}

	_LIBCPP_INLINE_VISIBILITY
	~__hash_iterator()
	{
	__get_db()->__erase_i(this);
	}

	_LIBCPP_INLINE_VISIBILITY
	__hash_iterator& operator=(const __hash_iterator& __i)
	{
	if (this != &__i)
	{
	__get_db()->__iterator_copy(this, &__i);
	__node_ = __i.__node_;
	}
	return *this;
	}
	#endif // _LIBCPP_DEBUG_LEVEL >= 2

	_LIBCPP_INLINE_VISIBILITY
	reference operator*() const {
	_LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to dereference a non-dereferenceable unordered container iterator");
	return __node_->__upcast()->__value_;
	}

	_LIBCPP_INLINE_VISIBILITY
	pointer operator->() const {
	_LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to dereference a non-dereferenceable unordered container iterator");
	return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__value_);
	}

	_LIBCPP_INLINE_VISIBILITY
	__hash_iterator& operator++() {
	_LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to increment non-incrementable unordered container iterator");
	__node_ = __node_->__next_;
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	__hash_iterator operator++(int)
	{
	__hash_iterator __t(*this);
	++(*this);
	return __t;
	}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const __hash_iterator& __x, const __hash_iterator& __y)
	{
	return __x.__node_ == __y.__node_;
	}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const __hash_iterator& __x, const __hash_iterator& __y)
	{return !(__x == __y);}

	private:
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_INLINE_VISIBILITY
	__hash_iterator(__next_pointer __node, const void* __c) _NOEXCEPT
	: __node_(__node)
	{
	__get_db()->__insert_ic(this, __c);
	}
	#else
	_LIBCPP_INLINE_VISIBILITY
	__hash_iterator(__next_pointer __node) _NOEXCEPT
	: __node_(__node)
	{}
	#endif
	template <class, class, class, class> friend class __hash_table;
	template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
	template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_iterator;
	template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
	template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
	};

	template <class _NodePtr>
	class _LIBCPP_TEMPLATE_VIS __hash_const_iterator
	{
	static_assert(!is_const<typename pointer_traits<_NodePtr>::element_type>::value, "");
	typedef __hash_node_types<_NodePtr> _NodeTypes;
	typedef _NodePtr __node_pointer;
	typedef typename _NodeTypes::__next_pointer __next_pointer;

	__next_pointer __node_;

	public:
	typedef __hash_iterator<_NodePtr> __non_const_iterator;

	typedef forward_iterator_tag iterator_category;
	typedef typename _NodeTypes::__node_value_type value_type;
	typedef typename _NodeTypes::difference_type difference_type;
	typedef const value_type& reference;
	typedef typename _NodeTypes::__const_node_value_type_pointer pointer;


	_LIBCPP_INLINE_VISIBILITY __hash_const_iterator() _NOEXCEPT : __node_(nullptr) {
	_LIBCPP_DEBUG_MODE(__get_db()->__insert_i(this));
	}

	_LIBCPP_INLINE_VISIBILITY
	__hash_const_iterator(const __non_const_iterator& __x) _NOEXCEPT
	: __node_(__x.__node_)
	{
	_LIBCPP_DEBUG_MODE(__get_db()->__iterator_copy(this, &__x));
	}

	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_INLINE_VISIBILITY
	__hash_const_iterator(const __hash_const_iterator& __i)
	: __node_(__i.__node_)
	{
	__get_db()->__iterator_copy(this, &__i);
	}

	_LIBCPP_INLINE_VISIBILITY
	~__hash_const_iterator()
	{
	__get_db()->__erase_i(this);
	}

	_LIBCPP_INLINE_VISIBILITY
	__hash_const_iterator& operator=(const __hash_const_iterator& __i)
	{
	if (this != &__i)
	{
	__get_db()->__iterator_copy(this, &__i);
	__node_ = __i.__node_;
	}
	return *this;
	}
	#endif // _LIBCPP_DEBUG_LEVEL >= 2

	_LIBCPP_INLINE_VISIBILITY
	reference operator*() const {
	_LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to dereference a non-dereferenceable unordered container const_iterator");
	return __node_->__upcast()->__value_;
	}
	_LIBCPP_INLINE_VISIBILITY
	pointer operator->() const {
	_LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to dereference a non-dereferenceable unordered container const_iterator");
	return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__value_);
	}

	_LIBCPP_INLINE_VISIBILITY
	__hash_const_iterator& operator++() {
	_LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to increment non-incrementable unordered container const_iterator");
	__node_ = __node_->__next_;
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	__hash_const_iterator operator++(int)
	{
	__hash_const_iterator __t(*this);
	++(*this);
	return __t;
	}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const __hash_const_iterator& __x, const __hash_const_iterator& __y)
	{
	return __x.__node_ == __y.__node_;
	}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const __hash_const_iterator& __x, const __hash_const_iterator& __y)
	{return !(__x == __y);}

	private:
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_INLINE_VISIBILITY
	__hash_const_iterator(__next_pointer __node, const void* __c) _NOEXCEPT
	: __node_(__node)
	{
	__get_db()->__insert_ic(this, __c);
	}
	#else
	_LIBCPP_INLINE_VISIBILITY
	__hash_const_iterator(__next_pointer __node) _NOEXCEPT
	: __node_(__node)
	{}
	#endif
	template <class, class, class, class> friend class __hash_table;
	template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
	template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
	template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
	};

	template <class _NodePtr>
	class _LIBCPP_TEMPLATE_VIS __hash_local_iterator
	{
	typedef __hash_node_types<_NodePtr> _NodeTypes;
	typedef _NodePtr __node_pointer;
	typedef typename _NodeTypes::__next_pointer __next_pointer;

	__next_pointer __node_;
	size_t __bucket_;
	size_t __bucket_count_;

	public:
	typedef forward_iterator_tag iterator_category;
	typedef typename _NodeTypes::__node_value_type value_type;
	typedef typename _NodeTypes::difference_type difference_type;
	typedef value_type& reference;
	typedef typename _NodeTypes::__node_value_type_pointer pointer;

	_LIBCPP_INLINE_VISIBILITY __hash_local_iterator() _NOEXCEPT : __node_(nullptr) {
	_LIBCPP_DEBUG_MODE(__get_db()->__insert_i(this));
	}

	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_INLINE_VISIBILITY
	__hash_local_iterator(const __hash_local_iterator& __i)
	: __node_(__i.__node_),
	__bucket_(__i.__bucket_),
	__bucket_count_(__i.__bucket_count_)
	{
	__get_db()->__iterator_copy(this, &__i);
	}

	_LIBCPP_INLINE_VISIBILITY
	~__hash_local_iterator()
	{
	__get_db()->__erase_i(this);
	}

	_LIBCPP_INLINE_VISIBILITY
	__hash_local_iterator& operator=(const __hash_local_iterator& __i)
	{
	if (this != &__i)
	{
	__get_db()->__iterator_copy(this, &__i);
	__node_ = __i.__node_;
	__bucket_ = __i.__bucket_;
	__bucket_count_ = __i.__bucket_count_;
	}
	return *this;
	}
	#endif // _LIBCPP_DEBUG_LEVEL >= 2

	_LIBCPP_INLINE_VISIBILITY
	reference operator*() const {
	_LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to dereference a non-dereferenceable unordered container local_iterator");
	return __node_->__upcast()->__value_;
	}

	_LIBCPP_INLINE_VISIBILITY
	pointer operator->() const {
	_LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to dereference a non-dereferenceable unordered container local_iterator");
	return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__value_);
	}

	_LIBCPP_INLINE_VISIBILITY
	__hash_local_iterator& operator++() {
	_LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to increment non-incrementable unordered container local_iterator");
	__node_ = __node_->__next_;
	if (__node_ != nullptr && __constrain_hash(__node_->__hash(), __bucket_count_) != __bucket_)
	__node_ = nullptr;
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	__hash_local_iterator operator++(int)
	{
	__hash_local_iterator __t(*this);
	++(*this);
	return __t;
	}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const __hash_local_iterator& __x, const __hash_local_iterator& __y)
	{
	return __x.__node_ == __y.__node_;
	}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const __hash_local_iterator& __x, const __hash_local_iterator& __y)
	{return !(__x == __y);}

	private:
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_INLINE_VISIBILITY
	__hash_local_iterator(__next_pointer __node, size_t __bucket,
	size_t __bucket_count, const void* __c) _NOEXCEPT
	: __node_(__node),
	__bucket_(__bucket),
	__bucket_count_(__bucket_count)
	{
	__get_db()->__insert_ic(this, __c);
	if (__node_ != nullptr)
	__node_ = __node_->__next_;
	}
	#else
	_LIBCPP_INLINE_VISIBILITY
	__hash_local_iterator(__next_pointer __node, size_t __bucket,
	size_t __bucket_count) _NOEXCEPT
	: __node_(__node),
	__bucket_(__bucket),
	__bucket_count_(__bucket_count)
	{
	if (__node_ != nullptr)
	__node_ = __node_->__next_;
	}
	#endif
	template <class, class, class, class> friend class __hash_table;
	template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
	template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_iterator;
	};

	template <class _ConstNodePtr>
	class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator
	{
	typedef __hash_node_types<_ConstNodePtr> _NodeTypes;
	typedef _ConstNodePtr __node_pointer;
	typedef typename _NodeTypes::__next_pointer __next_pointer;

	__next_pointer __node_;
	size_t __bucket_;
	size_t __bucket_count_;

	typedef pointer_traits<__node_pointer> __pointer_traits;
	typedef typename __pointer_traits::element_type __node;
	typedef typename remove_const<__node>::type __non_const_node;
	typedef typename __rebind_pointer<__node_pointer, __non_const_node>::type
	__non_const_node_pointer;
	public:
	typedef __hash_local_iterator<__non_const_node_pointer>
	__non_const_iterator;

	typedef forward_iterator_tag iterator_category;
	typedef typename _NodeTypes::__node_value_type value_type;
	typedef typename _NodeTypes::difference_type difference_type;
	typedef const value_type& reference;
	typedef typename _NodeTypes::__const_node_value_type_pointer pointer;


	_LIBCPP_INLINE_VISIBILITY __hash_const_local_iterator() _NOEXCEPT : __node_(nullptr) {
	_LIBCPP_DEBUG_MODE(__get_db()->__insert_i(this));
	}

	_LIBCPP_INLINE_VISIBILITY
	__hash_const_local_iterator(const __non_const_iterator& __x) _NOEXCEPT
	: __node_(__x.__node_),
	__bucket_(__x.__bucket_),
	__bucket_count_(__x.__bucket_count_)
	{
	_LIBCPP_DEBUG_MODE(__get_db()->__iterator_copy(this, &__x));
	}

	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_INLINE_VISIBILITY
	__hash_const_local_iterator(const __hash_const_local_iterator& __i)
	: __node_(__i.__node_),
	__bucket_(__i.__bucket_),
	__bucket_count_(__i.__bucket_count_)
	{
	__get_db()->__iterator_copy(this, &__i);
	}

	_LIBCPP_INLINE_VISIBILITY
	~__hash_const_local_iterator()
	{
	__get_db()->__erase_i(this);
	}

	_LIBCPP_INLINE_VISIBILITY
	__hash_const_local_iterator& operator=(const __hash_const_local_iterator& __i)
	{
	if (this != &__i)
	{
	__get_db()->__iterator_copy(this, &__i);
	__node_ = __i.__node_;
	__bucket_ = __i.__bucket_;
	__bucket_count_ = __i.__bucket_count_;
	}
	return *this;
	}
	#endif // _LIBCPP_DEBUG_LEVEL >= 2

	_LIBCPP_INLINE_VISIBILITY
	reference operator*() const {
	_LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
	return __node_->__upcast()->__value_;
	}

	_LIBCPP_INLINE_VISIBILITY
	pointer operator->() const {
	_LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
	return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__value_);
	}

	_LIBCPP_INLINE_VISIBILITY
	__hash_const_local_iterator& operator++() {
	_LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to increment non-incrementable unordered container const_local_iterator");
	__node_ = __node_->__next_;
	if (__node_ != nullptr && __constrain_hash(__node_->__hash(), __bucket_count_) != __bucket_)
	__node_ = nullptr;
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	__hash_const_local_iterator operator++(int)
	{
	__hash_const_local_iterator __t(*this);
	++(*this);
	return __t;
	}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const __hash_const_local_iterator& __x, const __hash_const_local_iterator& __y)
	{
	return __x.__node_ == __y.__node_;
	}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const __hash_const_local_iterator& __x, const __hash_const_local_iterator& __y)
	{return !(__x == __y);}

	private:
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_INLINE_VISIBILITY
	__hash_const_local_iterator(__next_pointer __node, size_t __bucket,
	size_t __bucket_count, const void* __c) _NOEXCEPT
	: __node_(__node),
	__bucket_(__bucket),
	__bucket_count_(__bucket_count)
	{
	__get_db()->__insert_ic(this, __c);
	if (__node_ != nullptr)
	__node_ = __node_->__next_;
	}
	#else
	_LIBCPP_INLINE_VISIBILITY
	__hash_const_local_iterator(__next_pointer __node, size_t __bucket,
	size_t __bucket_count) _NOEXCEPT
	: __node_(__node),
	__bucket_(__bucket),
	__bucket_count_(__bucket_count)
	{
	if (__node_ != nullptr)
	__node_ = __node_->__next_;
	}
	#endif
	template <class, class, class, class> friend class __hash_table;
	template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
	};

	template <class _Alloc>
	class __bucket_list_deallocator
	{
	typedef _Alloc allocator_type;
	typedef allocator_traits<allocator_type> __alloc_traits;
	typedef typename __alloc_traits::size_type size_type;

	__compressed_pair<size_type, allocator_type> __data_;
	public:
	typedef typename __alloc_traits::pointer pointer;

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

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

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	__bucket_list_deallocator(__bucket_list_deallocator&& __x)
	_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
	: __data_(_VSTD::move(__x.__data_))
	{
	__x.size() = 0;
	}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	size_type& size() _NOEXCEPT {return __data_.first();}
	_LIBCPP_INLINE_VISIBILITY
	size_type size() const _NOEXCEPT {return __data_.first();}

	_LIBCPP_INLINE_VISIBILITY
	allocator_type& __alloc() _NOEXCEPT {return __data_.second();}
	_LIBCPP_INLINE_VISIBILITY
	const allocator_type& __alloc() const _NOEXCEPT {return __data_.second();}

	_LIBCPP_INLINE_VISIBILITY
	void operator()(pointer __p) _NOEXCEPT
	{
	__alloc_traits::deallocate(__alloc(), __p, size());
	}
	};

	template <class _Alloc> class __hash_map_node_destructor;

	template <class _Alloc>
	class __hash_node_destructor
	{
	typedef _Alloc allocator_type;
	typedef allocator_traits<allocator_type> __alloc_traits;

	public:
	typedef typename __alloc_traits::pointer pointer;
	private:
	typedef __hash_node_types<pointer> _NodeTypes;

	allocator_type& __na_;

	__hash_node_destructor& operator=(const __hash_node_destructor&);

	public:
	bool __value_constructed;

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

	_LIBCPP_INLINE_VISIBILITY
	void operator()(pointer __p) _NOEXCEPT
	{
	if (__value_constructed)
	__alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__value_));
	if (__p)
	__alloc_traits::deallocate(__na_, __p, 1);
	}

	template <class> friend class __hash_map_node_destructor;
	};


	#ifndef _LIBCPP_CXX03_LANG
	template <class _Key, class _Hash, class _Equal, class _Alloc>
	struct __diagnose_hash_table_helper {
	static constexpr bool __trigger_diagnostics()
	_LIBCPP_DIAGNOSE_WARNING(__check_hash_requirements<_Key, _Hash>::value
	&& !__invokable<_Hash const&, _Key const&>::value,
	"the specified hash functor does not provide a const call operator")
	_LIBCPP_DIAGNOSE_WARNING(is_copy_constructible<_Equal>::value
	&& !__invokable<_Equal const&, _Key const&, _Key const&>::value,
	"the specified comparator type does not provide a const call operator")
	{
	static_assert(__check_hash_requirements<_Key, _Hash>::value,
	"the specified hash does not meet the Hash requirements");
	static_assert(is_copy_constructible<_Equal>::value,
	"the specified comparator is required to be copy constructible");
	return true;
	}
	};

	template <class _Key, class _Value, class _Hash, class _Equal, class _Alloc>
	struct __diagnose_hash_table_helper<
	__hash_value_type<_Key, _Value>,
	__unordered_map_hasher<_Key, __hash_value_type<_Key, _Value>, _Hash>,
	__unordered_map_equal<_Key, __hash_value_type<_Key, _Value>, _Equal>,
	_Alloc>
	: __diagnose_hash_table_helper<_Key, _Hash, _Equal, _Alloc>
	{
	};
	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	class __hash_table
	{
	public:
	typedef _Tp value_type;
	typedef _Hash hasher;
	typedef _Equal key_equal;
	typedef _Alloc allocator_type;

	private:
	typedef allocator_traits<allocator_type> __alloc_traits;
	typedef typename
	__make_hash_node_types<value_type, typename __alloc_traits::void_pointer>::type
	_NodeTypes;
	public:

	typedef typename _NodeTypes::__node_value_type __node_value_type;
	typedef typename _NodeTypes::__container_value_type __container_value_type;
	typedef typename _NodeTypes::key_type key_type;
	typedef value_type& reference;
	typedef const value_type& const_reference;
	typedef typename __alloc_traits::pointer pointer;
	typedef typename __alloc_traits::const_pointer const_pointer;
	#ifndef _LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE
	typedef typename __alloc_traits::size_type size_type;
	#else
	typedef typename _NodeTypes::size_type size_type;
	#endif
	typedef typename _NodeTypes::difference_type difference_type;
	public:
	// Create __node

	typedef typename _NodeTypes::__node_type __node;
	typedef typename __rebind_alloc_helper<__alloc_traits, __node>::type __node_allocator;
	typedef allocator_traits<__node_allocator> __node_traits;
	typedef typename _NodeTypes::__void_pointer __void_pointer;
	typedef typename _NodeTypes::__node_pointer __node_pointer;
	typedef typename _NodeTypes::__node_pointer __node_const_pointer;
	typedef typename _NodeTypes::__node_base_type __first_node;
	typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;
	typedef typename _NodeTypes::__next_pointer __next_pointer;

	private:
	// check for sane allocator pointer rebinding semantics. Rebinding the
	// allocator for a new pointer type should be exactly the same as rebinding
	// the pointer using 'pointer_traits'.
	static_assert((is_same<__node_pointer, typename __node_traits::pointer>::value),
	"Allocator does not rebind pointers in a sane manner.");
	typedef typename __rebind_alloc_helper<__node_traits, __first_node>::type
	__node_base_allocator;
	typedef allocator_traits<__node_base_allocator> __node_base_traits;
	static_assert((is_same<__node_base_pointer, typename __node_base_traits::pointer>::value),
	"Allocator does not rebind pointers in a sane manner.");

	private:

	typedef typename __rebind_alloc_helper<__node_traits, __next_pointer>::type __pointer_allocator;
	typedef __bucket_list_deallocator<__pointer_allocator> __bucket_list_deleter;
	typedef unique_ptr<__next_pointer[], __bucket_list_deleter> __bucket_list;
	typedef allocator_traits<__pointer_allocator> __pointer_alloc_traits;
	typedef typename __bucket_list_deleter::pointer __node_pointer_pointer;

	#ifndef _LIBCPP_CXX03_LANG
	static_assert(__diagnose_hash_table_helper<_Tp, _Hash, _Equal, _Alloc>::__trigger_diagnostics(), "");
	#endif

	// --- Member data begin ---
	__bucket_list __bucket_list_;
	__compressed_pair<__first_node, __node_allocator> __p1_;
	__compressed_pair<size_type, hasher> __p2_;
	__compressed_pair<float, key_equal> __p3_;
	// --- Member data end ---

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

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

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

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

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

	public:
	typedef __hash_iterator<__node_pointer> iterator;
	typedef __hash_const_iterator<__node_pointer> const_iterator;
	typedef __hash_local_iterator<__node_pointer> local_iterator;
	typedef __hash_const_local_iterator<__node_pointer> const_local_iterator;

	_LIBCPP_INLINE_VISIBILITY
	__hash_table()
	_NOEXCEPT_(
	is_nothrow_default_constructible<__bucket_list>::value &&
	is_nothrow_default_constructible<__first_node>::value &&
	is_nothrow_default_constructible<__node_allocator>::value &&
	is_nothrow_default_constructible<hasher>::value &&
	is_nothrow_default_constructible<key_equal>::value);
	_LIBCPP_INLINE_VISIBILITY
	__hash_table(const hasher& __hf, const key_equal& __eql);
	__hash_table(const hasher& __hf, const key_equal& __eql,
	const allocator_type& __a);
	explicit __hash_table(const allocator_type& __a);
	__hash_table(const __hash_table& __u);
	__hash_table(const __hash_table& __u, const allocator_type& __a);
	#ifndef _LIBCPP_CXX03_LANG
	__hash_table(__hash_table&& __u)
	_NOEXCEPT_(
	is_nothrow_move_constructible<__bucket_list>::value &&
	is_nothrow_move_constructible<__first_node>::value &&
	is_nothrow_move_constructible<__node_allocator>::value &&
	is_nothrow_move_constructible<hasher>::value &&
	is_nothrow_move_constructible<key_equal>::value);
	__hash_table(__hash_table&& __u, const allocator_type& __a);
	#endif // _LIBCPP_CXX03_LANG
	~__hash_table();

	__hash_table& operator=(const __hash_table& __u);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	__hash_table& operator=(__hash_table&& __u)
	_NOEXCEPT_(
	__node_traits::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<__node_allocator>::value &&
	is_nothrow_move_assignable<hasher>::value &&
	is_nothrow_move_assignable<key_equal>::value);
	#endif
	template <class _InputIterator>
	void __assign_unique(_InputIterator __first, _InputIterator __last);
	template <class _InputIterator>
	void __assign_multi(_InputIterator __first, _InputIterator __last);

	_LIBCPP_INLINE_VISIBILITY
	size_type max_size() const _NOEXCEPT
	{
	return std::min<size_type>(
	__node_traits::max_size(__node_alloc()),
	numeric_limits<difference_type >::max()
	);
	}

	pair<iterator, bool> __node_insert_unique(__node_pointer __nd);
	iterator __node_insert_multi(__node_pointer __nd);
	iterator __node_insert_multi(const_iterator __p,
	__node_pointer __nd);

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Key, class ..._Args>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> __emplace_unique_key_args(_Key const& __k, _Args&&... __args);

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> __emplace_unique_impl(_Args&&... __args);

	template <class _Pp>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> __emplace_unique(_Pp&& __x) {
	return __emplace_unique_extract_key(_VSTD::forward<_Pp>(__x),
	__can_extract_key<_Pp, key_type>());
	}

	template <class _First, class _Second>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<
	__can_extract_map_key<_First, key_type, __container_value_type>::value,
	pair<iterator, bool>
	>::type __emplace_unique(_First&& __f, _Second&& __s) {
	return __emplace_unique_key_args(__f, _VSTD::forward<_First>(__f),
	_VSTD::forward<_Second>(__s));
	}

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> __emplace_unique(_Args&&... __args) {
	return __emplace_unique_impl(_VSTD::forward<_Args>(__args)...);
	}

	template <class _Pp>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool>
	__emplace_unique_extract_key(_Pp&& __x, __extract_key_fail_tag) {
	return __emplace_unique_impl(_VSTD::forward<_Pp>(__x));
	}
	template <class _Pp>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool>
	__emplace_unique_extract_key(_Pp&& __x, __extract_key_self_tag) {
	return __emplace_unique_key_args(__x, _VSTD::forward<_Pp>(__x));
	}
	template <class _Pp>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool>
	__emplace_unique_extract_key(_Pp&& __x, __extract_key_first_tag) {
	return __emplace_unique_key_args(__x.first, _VSTD::forward<_Pp>(__x));
	}

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	iterator __emplace_multi(_Args&&... __args);
	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	iterator __emplace_hint_multi(const_iterator __p, _Args&&... __args);


	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool>
	__insert_unique(__container_value_type&& __x) {
	return __emplace_unique_key_args(_NodeTypes::__get_key(__x), _VSTD::move(__x));
	}

	template <class _Pp, class = typename enable_if<
	!__is_same_uncvref<_Pp, __container_value_type>::value
	>::type>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> __insert_unique(_Pp&& __x) {
	return __emplace_unique(_VSTD::forward<_Pp>(__x));
	}

	template <class _Pp>
	_LIBCPP_INLINE_VISIBILITY
	iterator __insert_multi(_Pp&& __x) {
	return __emplace_multi(_VSTD::forward<_Pp>(__x));
	}

	template <class _Pp>
	_LIBCPP_INLINE_VISIBILITY
	iterator __insert_multi(const_iterator __p, _Pp&& __x) {
	return __emplace_hint_multi(__p, _VSTD::forward<_Pp>(__x));
	}

	#else // !defined(_LIBCPP_CXX03_LANG)
	template <class _Key, class _Args>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> __emplace_unique_key_args(_Key const&, _Args& __args);

	iterator __insert_multi(const __container_value_type& __x);
	iterator __insert_multi(const_iterator __p, const __container_value_type& __x);
	#endif

	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> __insert_unique(const __container_value_type& __x) {
	return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x);
	}

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

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

	_LIBCPP_INLINE_VISIBILITY
	iterator begin() _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	iterator end() _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	const_iterator begin() const _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	const_iterator end() const _NOEXCEPT;

	template <class _Key>
	_LIBCPP_INLINE_VISIBILITY
	size_type bucket(const _Key& __k) const
	{
	_LIBCPP_ASSERT(bucket_count() > 0,
	"unordered container::bucket(key) called when bucket_count() == 0");
	return __constrain_hash(hash_function()(__k), bucket_count());
	}

	template <class _Key>
	iterator find(const _Key& __x);
	template <class _Key>
	const_iterator find(const _Key& __x) const;

	typedef __hash_node_destructor<__node_allocator> _Dp;
	typedef unique_ptr<__node, _Dp> __node_holder;

	iterator erase(const_iterator __p);
	iterator erase(const_iterator __first, const_iterator __last);
	template <class _Key>
	size_type __erase_unique(const _Key& __k);
	template <class _Key>
	size_type __erase_multi(const _Key& __k);
	__node_holder remove(const_iterator __p) _NOEXCEPT;

	template <class _Key>
	_LIBCPP_INLINE_VISIBILITY
	size_type __count_unique(const _Key& __k) const;
	template <class _Key>
	size_type __count_multi(const _Key& __k) const;

	template <class _Key>
	pair<iterator, iterator>
	__equal_range_unique(const _Key& __k);
	template <class _Key>
	pair<const_iterator, const_iterator>
	__equal_range_unique(const _Key& __k) const;

	template <class _Key>
	pair<iterator, iterator>
	__equal_range_multi(const _Key& __k);
	template <class _Key>
	pair<const_iterator, const_iterator>
	__equal_range_multi(const _Key& __k) const;

	void swap(__hash_table& __u)
	#if _LIBCPP_STD_VER <= 11
	_NOEXCEPT_DEBUG_(
	__is_nothrow_swappable<hasher>::value && __is_nothrow_swappable<key_equal>::value
	&& (!allocator_traits<__pointer_allocator>::propagate_on_container_swap::value
	\|\| __is_nothrow_swappable<__pointer_allocator>::value)
	&& (!__node_traits::propagate_on_container_swap::value
	\|\| __is_nothrow_swappable<__node_allocator>::value)
	);
	#else
	_NOEXCEPT_DEBUG_(__is_nothrow_swappable<hasher>::value && __is_nothrow_swappable<key_equal>::value);
	#endif

	_LIBCPP_INLINE_VISIBILITY
	size_type max_bucket_count() const _NOEXCEPT
	{return max_size(); }
	size_type bucket_size(size_type __n) const;
	_LIBCPP_INLINE_VISIBILITY float load_factor() const _NOEXCEPT
	{
	size_type __bc = bucket_count();
	return __bc != 0 ? (float)size() / __bc : 0.f;
	}
	_LIBCPP_INLINE_VISIBILITY void max_load_factor(float __mlf) _NOEXCEPT
	{
	_LIBCPP_ASSERT(__mlf > 0,
	"unordered container::max_load_factor(lf) called with lf <= 0");
	max_load_factor() = _VSTD::max(__mlf, load_factor());
	}

	_LIBCPP_INLINE_VISIBILITY
	local_iterator
	begin(size_type __n)
	{
	_LIBCPP_ASSERT(__n < bucket_count(),
	"unordered container::begin(n) called with n >= bucket_count()");
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return local_iterator(__bucket_list_[__n], __n, bucket_count(), this);
	#else
	return local_iterator(__bucket_list_[__n], __n, bucket_count());
	#endif
	}

	_LIBCPP_INLINE_VISIBILITY
	local_iterator
	end(size_type __n)
	{
	_LIBCPP_ASSERT(__n < bucket_count(),
	"unordered container::end(n) called with n >= bucket_count()");
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return local_iterator(nullptr, __n, bucket_count(), this);
	#else
	return local_iterator(nullptr, __n, bucket_count());
	#endif
	}

	_LIBCPP_INLINE_VISIBILITY
	const_local_iterator
	cbegin(size_type __n) const
	{
	_LIBCPP_ASSERT(__n < bucket_count(),
	"unordered container::cbegin(n) called with n >= bucket_count()");
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return const_local_iterator(__bucket_list_[__n], __n, bucket_count(), this);
	#else
	return const_local_iterator(__bucket_list_[__n], __n, bucket_count());
	#endif
	}

	_LIBCPP_INLINE_VISIBILITY
	const_local_iterator
	cend(size_type __n) const
	{
	_LIBCPP_ASSERT(__n < bucket_count(),
	"unordered container::cend(n) called with n >= bucket_count()");
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return const_local_iterator(nullptr, __n, bucket_count(), this);
	#else
	return const_local_iterator(nullptr, __n, bucket_count());
	#endif
	}

	#if _LIBCPP_DEBUG_LEVEL >= 2

	bool __dereferenceable(const const_iterator* __i) const;
	bool __decrementable(const const_iterator* __i) const;
	bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
	bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;

	#endif // _LIBCPP_DEBUG_LEVEL >= 2

	private:
	void __rehash(size_type __n);

	#ifndef _LIBCPP_CXX03_LANG
	template <class ..._Args>
	__node_holder __construct_node(_Args&& ...__args);

	template <class _First, class ..._Rest>
	__node_holder __construct_node_hash(size_t __hash, _First&& __f, _Rest&&... __rest);
	#else // _LIBCPP_CXX03_LANG
	__node_holder __construct_node(const __container_value_type& __v);
	__node_holder __construct_node_hash(size_t __hash, const __container_value_type& __v);
	#endif


	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const __hash_table& __u)
	{__copy_assign_alloc(__u, integral_constant<bool,
	__node_traits::propagate_on_container_copy_assignment::value>());}
	void __copy_assign_alloc(const __hash_table& __u, true_type);
	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const __hash_table&, false_type) {}

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

	void __deallocate_node(__next_pointer __np) _NOEXCEPT;
	__next_pointer __detach() _NOEXCEPT;

	template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
	template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
	};

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	inline
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table()
	_NOEXCEPT_(
	is_nothrow_default_constructible<__bucket_list>::value &&
	is_nothrow_default_constructible<__first_node>::value &&
	is_nothrow_default_constructible<__node_allocator>::value &&
	is_nothrow_default_constructible<hasher>::value &&
	is_nothrow_default_constructible<key_equal>::value)
	: __p2_(0),
	__p3_(1.0f)
	{
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	inline
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const hasher& __hf,
	const key_equal& __eql)
	: __bucket_list_(nullptr, __bucket_list_deleter()),
	__p1_(),
	__p2_(0, __hf),
	__p3_(1.0f, __eql)
	{
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const hasher& __hf,
	const key_equal& __eql,
	const allocator_type& __a)
	: __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
	__p1_(__second_tag(), __node_allocator(__a)),
	__p2_(0, __hf),
	__p3_(1.0f, __eql)
	{
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const allocator_type& __a)
	: __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
	__p1_(__second_tag(), __node_allocator(__a)),
	__p2_(0),
	__p3_(1.0f)
	{
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u)
	: __bucket_list_(nullptr,
	__bucket_list_deleter(allocator_traits<__pointer_allocator>::
	select_on_container_copy_construction(
	__u.__bucket_list_.get_deleter().__alloc()), 0)),
	__p1_(__second_tag(), allocator_traits<__node_allocator>::
	select_on_container_copy_construction(__u.__node_alloc())),
	__p2_(0, __u.hash_function()),
	__p3_(__u.__p3_)
	{
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u,
	const allocator_type& __a)
	: __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
	__p1_(__second_tag(), __node_allocator(__a)),
	__p2_(0, __u.hash_function()),
	__p3_(__u.__p3_)
	{
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u)
	_NOEXCEPT_(
	is_nothrow_move_constructible<__bucket_list>::value &&
	is_nothrow_move_constructible<__first_node>::value &&
	is_nothrow_move_constructible<__node_allocator>::value &&
	is_nothrow_move_constructible<hasher>::value &&
	is_nothrow_move_constructible<key_equal>::value)
	: __bucket_list_(_VSTD::move(__u.__bucket_list_)),
	__p1_(_VSTD::move(__u.__p1_)),
	__p2_(_VSTD::move(__u.__p2_)),
	__p3_(_VSTD::move(__u.__p3_))
	{
	if (size() > 0)
	{
	__bucket_list_[__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
	__p1_.first().__ptr();
	__u.__p1_.first().__next_ = nullptr;
	__u.size() = 0;
	}
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u,
	const allocator_type& __a)
	: __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
	__p1_(__second_tag(), __node_allocator(__a)),
	__p2_(0, _VSTD::move(__u.hash_function())),
	__p3_(_VSTD::move(__u.__p3_))
	{
	if (__a == allocator_type(__u.__node_alloc()))
	{
	__bucket_list_.reset(__u.__bucket_list_.release());
	__bucket_list_.get_deleter().size() = __u.__bucket_list_.get_deleter().size();
	__u.__bucket_list_.get_deleter().size() = 0;
	if (__u.size() > 0)
	{
	__p1_.first().__next_ = __u.__p1_.first().__next_;
	__u.__p1_.first().__next_ = nullptr;
	__bucket_list_[__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
	__p1_.first().__ptr();
	size() = __u.size();
	__u.size() = 0;
	}
	}
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::~__hash_table()
	{
	#if defined(_LIBCPP_CXX03_LANG)
	static_assert((is_copy_constructible<key_equal>::value),
	"Predicate must be copy-constructible.");
	static_assert((is_copy_constructible<hasher>::value),
	"Hasher must be copy-constructible.");
	#endif

	__deallocate_node(__p1_.first().__next_);
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__erase_c(this);
	#endif
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	void
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__copy_assign_alloc(
	const __hash_table& __u, true_type)
	{
	if (__node_alloc() != __u.__node_alloc())
	{
	clear();
	__bucket_list_.reset();
	__bucket_list_.get_deleter().size() = 0;
	}
	__bucket_list_.get_deleter().__alloc() = __u.__bucket_list_.get_deleter().__alloc();
	__node_alloc() = __u.__node_alloc();
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	__hash_table<_Tp, _Hash, _Equal, _Alloc>&
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(const __hash_table& __u)
	{
	if (this != &__u)
	{
	__copy_assign_alloc(__u);
	hash_function() = __u.hash_function();
	key_eq() = __u.key_eq();
	max_load_factor() = __u.max_load_factor();
	__assign_multi(__u.begin(), __u.end());
	}
	return *this;
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	void
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate_node(__next_pointer __np)
	_NOEXCEPT
	{
	__node_allocator& __na = __node_alloc();
	while (__np != nullptr)
	{
	__next_pointer __next = __np->__next_;
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__c_node* __c = __get_db()->__find_c_and_lock(this);
	for (__i_node** __p = __c->end_; __p != __c->beg_; )
	{
	--__p;
	iterator* __i = static_cast<iterator>((__p)->__i_);
	if (__i->__node_ == __np)
	{
	(*__p)->__c_ = nullptr;
	if (--__c->end_ != __p)
	memmove(__p, __p+1, (__c->end_ - __p)sizeof(__i_node));
	}
	}
	__get_db()->unlock();
	#endif
	__node_pointer __real_np = __np->__upcast();
	__node_traits::destroy(__na, _NodeTypes::__get_ptr(__real_np->__value_));
	__node_traits::deallocate(__na, __real_np, 1);
	__np = __next;
	}
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__next_pointer
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__detach() _NOEXCEPT
	{
	size_type __bc = bucket_count();
	for (size_type __i = 0; __i < __bc; ++__i)
	__bucket_list_[__i] = nullptr;
	size() = 0;
	__next_pointer __cache = __p1_.first().__next_;
	__p1_.first().__next_ = nullptr;
	return __cache;
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	void
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
	__hash_table& __u, true_type)
	_NOEXCEPT_(
	is_nothrow_move_assignable<__node_allocator>::value &&
	is_nothrow_move_assignable<hasher>::value &&
	is_nothrow_move_assignable<key_equal>::value)
	{
	clear();
	__bucket_list_.reset(__u.__bucket_list_.release());
	__bucket_list_.get_deleter().size() = __u.__bucket_list_.get_deleter().size();
	__u.__bucket_list_.get_deleter().size() = 0;
	__move_assign_alloc(__u);
	size() = __u.size();
	hash_function() = _VSTD::move(__u.hash_function());
	max_load_factor() = __u.max_load_factor();
	key_eq() = _VSTD::move(__u.key_eq());
	__p1_.first().__next_ = __u.__p1_.first().__next_;
	if (size() > 0)
	{
	__bucket_list_[__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
	__p1_.first().__ptr();
	__u.__p1_.first().__next_ = nullptr;
	__u.size() = 0;
	}
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->swap(this, &__u);
	#endif
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	void
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
	__hash_table& __u, false_type)
	{
	if (__node_alloc() == __u.__node_alloc())
	__move_assign(__u, true_type());
	else
	{
	hash_function() = _VSTD::move(__u.hash_function());
	key_eq() = _VSTD::move(__u.key_eq());
	max_load_factor() = __u.max_load_factor();
	if (bucket_count() != 0)
	{
	__next_pointer __cache = __detach();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	const_iterator __i = __u.begin();
	while (__cache != nullptr && __u.size() != 0)
	{
	__cache->__upcast()->__value_ =
	_VSTD::move(__u.remove(__i++)->__value_);
	__next_pointer __next = __cache->__next_;
	__node_insert_multi(__cache->__upcast());
	__cache = __next;
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__deallocate_node(__cache);
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	__deallocate_node(__cache);
	}
	const_iterator __i = __u.begin();
	while (__u.size() != 0)
	{
	__node_holder __h = __construct_node(_NodeTypes::__move(__u.remove(__i++)->__value_));
	__node_insert_multi(__h.get());
	__h.release();
	}
	}
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	inline
	__hash_table<_Tp, _Hash, _Equal, _Alloc>&
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(__hash_table&& __u)
	_NOEXCEPT_(
	__node_traits::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<__node_allocator>::value &&
	is_nothrow_move_assignable<hasher>::value &&
	is_nothrow_move_assignable<key_equal>::value)
	{
	__move_assign(__u, integral_constant<bool,
	__node_traits::propagate_on_container_move_assignment::value>());
	return *this;
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class _InputIterator>
	void
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_unique(_InputIterator __first,
	_InputIterator __last)
	{
	typedef iterator_traits<_InputIterator> _ITraits;
	typedef typename _ITraits::value_type _ItValueType;
	static_assert((is_same<_ItValueType, __container_value_type>::value),
	"__assign_unique may only be called with the containers value type");

	if (bucket_count() != 0)
	{
	__next_pointer __cache = __detach();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (; __cache != nullptr && __first != __last; ++__first)
	{
	__cache->__upcast()->__value_ = *__first;
	__next_pointer __next = __cache->__next_;
	__node_insert_unique(__cache->__upcast());
	__cache = __next;
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__deallocate_node(__cache);
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	__deallocate_node(__cache);
	}
	for (; __first != __last; ++__first)
	__insert_unique(*__first);
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class _InputIterator>
	void
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first,
	_InputIterator __last)
	{
	typedef iterator_traits<_InputIterator> _ITraits;
	typedef typename _ITraits::value_type _ItValueType;
	static_assert((is_same<_ItValueType, __container_value_type>::value \|\|
	is_same<_ItValueType, __node_value_type>::value),
	"__assign_multi may only be called with the containers value type"
	" or the nodes value type");
	if (bucket_count() != 0)
	{
	__next_pointer __cache = __detach();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (; __cache != nullptr && __first != __last; ++__first)
	{
	__cache->__upcast()->__value_ = *__first;
	__next_pointer __next = __cache->__next_;
	__node_insert_multi(__cache->__upcast());
	__cache = __next;
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__deallocate_node(__cache);
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	__deallocate_node(__cache);
	}
	for (; __first != __last; ++__first)
	__insert_multi(_NodeTypes::__get_value(*__first));
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	inline
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() _NOEXCEPT
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return iterator(__p1_.first().__next_, this);
	#else
	return iterator(__p1_.first().__next_);
	#endif
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	inline
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::end() _NOEXCEPT
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return iterator(nullptr, this);
	#else
	return iterator(nullptr);
	#endif
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	inline
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() const _NOEXCEPT
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return const_iterator(__p1_.first().__next_, this);
	#else
	return const_iterator(__p1_.first().__next_);
	#endif
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	inline
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::end() const _NOEXCEPT
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return const_iterator(nullptr, this);
	#else
	return const_iterator(nullptr);
	#endif
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	void
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::clear() _NOEXCEPT
	{
	if (size() > 0)
	{
	__deallocate_node(__p1_.first().__next_);
	__p1_.first().__next_ = nullptr;
	size_type __bc = bucket_count();
	for (size_type __i = 0; __i < __bc; ++__i)
	__bucket_list_[__i] = nullptr;
	size() = 0;
	}
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique(__node_pointer __nd)
	{
	__nd->__hash_ = hash_function()(__nd->__value_);
	size_type __bc = bucket_count();
	bool __inserted = false;
	__next_pointer __ndptr;
	size_t __chash;
	if (__bc != 0)
	{
	__chash = __constrain_hash(__nd->__hash_, __bc);
	__ndptr = __bucket_list_[__chash];
	if (__ndptr != nullptr)
	{
	for (__ndptr = __ndptr->__next_; __ndptr != nullptr &&
	__constrain_hash(__ndptr->__hash(), __bc) == __chash;
	__ndptr = __ndptr->__next_)
	{
	if (key_eq()(__ndptr->__upcast()->__value_, __nd->__value_))
	goto __done;
	}
	}
	}
	{
	if (size()+1 > __bc * max_load_factor() \|\| __bc == 0)
	{
	rehash(_VSTD::max<size_type>(2 * __bc + !__is_hash_power2(__bc),
	size_type(ceil(float(size() + 1) / max_load_factor()))));
	__bc = bucket_count();
	__chash = __constrain_hash(__nd->__hash_, __bc);
	}
	// insert_after __bucket_list_[__chash], or __first_node if bucket is null
	__next_pointer __pn = __bucket_list_[__chash];
	if (__pn == nullptr)
	{
	__pn =__p1_.first().__ptr();
	__nd->__next_ = __pn->__next_;
	__pn->__next_ = __nd->__ptr();
	// fix up __bucket_list_
	__bucket_list_[__chash] = __pn;
	if (__nd->__next_ != nullptr)
	__bucket_list_[__constrain_hash(__nd->__next_->__hash(), __bc)] = __nd->__ptr();
	}
	else
	{
	__nd->__next_ = __pn->__next_;
	__pn->__next_ = __nd->__ptr();
	}
	__ndptr = __nd->__ptr();
	// increment size
	++size();
	__inserted = true;
	}
	__done:
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return pair<iterator, bool>(iterator(__ndptr, this), __inserted);
	#else
	return pair<iterator, bool>(iterator(__ndptr), __inserted);
	#endif
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(__node_pointer __cp)
	{
	__cp->__hash_ = hash_function()(__cp->__value_);
	size_type __bc = bucket_count();
	if (size()+1 > __bc * max_load_factor() \|\| __bc == 0)
	{
	rehash(_VSTD::max<size_type>(2 * __bc + !__is_hash_power2(__bc),
	size_type(ceil(float(size() + 1) / max_load_factor()))));
	__bc = bucket_count();
	}
	size_t __chash = __constrain_hash(__cp->__hash_, __bc);
	__next_pointer __pn = __bucket_list_[__chash];
	if (__pn == nullptr)
	{
	__pn =__p1_.first().__ptr();
	__cp->__next_ = __pn->__next_;
	__pn->__next_ = __cp->__ptr();
	// fix up __bucket_list_
	__bucket_list_[__chash] = __pn;
	if (__cp->__next_ != nullptr)
	__bucket_list_[__constrain_hash(__cp->__next_->__hash(), __bc)]
	= __cp->__ptr();
	}
	else
	{
	for (bool __found = false; __pn->__next_ != nullptr &&
	__constrain_hash(__pn->__next_->__hash(), __bc) == __chash;
	__pn = __pn->__next_)
	{
	// __found key_eq() action
	// false false loop
	// true true loop
	// false true set __found to true
	// true false break
	if (__found != (__pn->__next_->__hash() == __cp->__hash_ &&
	key_eq()(__pn->__next_->__upcast()->__value_, __cp->__value_)))
	{
	if (!__found)
	__found = true;
	else
	break;
	}
	}
	__cp->__next_ = __pn->__next_;
	__pn->__next_ = __cp->__ptr();
	if (__cp->__next_ != nullptr)
	{
	size_t __nhash = __constrain_hash(__cp->__next_->__hash(), __bc);
	if (__nhash != __chash)
	__bucket_list_[__nhash] = __cp->__ptr();
	}
	}
	++size();
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return iterator(__cp->__ptr(), this);
	#else
	return iterator(__cp->__ptr());
	#endif
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(
	const_iterator __p, __node_pointer __cp)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"unordered container::emplace_hint(const_iterator, args...) called with an iterator not"
	" referring to this unordered container");
	#endif
	if (__p != end() && key_eq()(*__p, __cp->__value_))
	{
	__next_pointer __np = __p.__node_;
	__cp->__hash_ = __np->__hash();
	size_type __bc = bucket_count();
	if (size()+1 > __bc * max_load_factor() \|\| __bc == 0)
	{
	rehash(_VSTD::max<size_type>(2 * __bc + !__is_hash_power2(__bc),
	size_type(ceil(float(size() + 1) / max_load_factor()))));
	__bc = bucket_count();
	}
	size_t __chash = __constrain_hash(__cp->__hash_, __bc);
	__next_pointer __pp = __bucket_list_[__chash];
	while (__pp->__next_ != __np)
	__pp = __pp->__next_;
	__cp->__next_ = __np;
	__pp->__next_ = static_cast<__next_pointer>(__cp);
	++size();
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return iterator(static_cast<__next_pointer>(__cp), this);
	#else
	return iterator(static_cast<__next_pointer>(__cp));
	#endif
	}
	return __node_insert_multi(__cp);
	}



	#ifndef _LIBCPP_CXX03_LANG
	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class _Key, class ..._Args>
	pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique_key_args(_Key const& __k, _Args&&... __args)
	#else
	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class _Key, class _Args>
	pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique_key_args(_Key const& __k, _Args& __args)
	#endif
	{

	size_t __hash = hash_function()(__k);
	size_type __bc = bucket_count();
	bool __inserted = false;
	__next_pointer __nd;
	size_t __chash;
	if (__bc != 0)
	{
	__chash = __constrain_hash(__hash, __bc);
	__nd = __bucket_list_[__chash];
	if (__nd != nullptr)
	{
	for (__nd = __nd->__next_; __nd != nullptr &&
	(__nd->__hash() == __hash \|\| __constrain_hash(__nd->__hash(), __bc) == __chash);
	__nd = __nd->__next_)
	{
	if (key_eq()(__nd->__upcast()->__value_, __k))
	goto __done;
	}
	}
	}
	{
	#ifndef _LIBCPP_CXX03_LANG
	__node_holder __h = __construct_node_hash(__hash, _VSTD::forward<_Args>(__args)...);
	#else
	__node_holder __h = __construct_node_hash(__hash, __args);
	#endif
	if (size()+1 > __bc * max_load_factor() \|\| __bc == 0)
	{
	rehash(_VSTD::max<size_type>(2 * __bc + !__is_hash_power2(__bc),
	size_type(ceil(float(size() + 1) / max_load_factor()))));
	__bc = bucket_count();
	__chash = __constrain_hash(__hash, __bc);
	}
	// insert_after __bucket_list_[__chash], or __first_node if bucket is null
	__next_pointer __pn = __bucket_list_[__chash];
	if (__pn == nullptr)
	{
	__pn = __p1_.first().__ptr();
	__h->__next_ = __pn->__next_;
	__pn->__next_ = __h.get()->__ptr();
	// fix up __bucket_list_
	__bucket_list_[__chash] = __pn;
	if (__h->__next_ != nullptr)
	__bucket_list_[__constrain_hash(__h->__next_->__hash(), __bc)]
	= __h.get()->__ptr();
	}
	else
	{
	__h->__next_ = __pn->__next_;
	__pn->__next_ = static_cast<__next_pointer>(__h.get());
	}
	__nd = static_cast<__next_pointer>(__h.release());
	// increment size
	++size();
	__inserted = true;
	}
	__done:
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return pair<iterator, bool>(iterator(__nd, this), __inserted);
	#else
	return pair<iterator, bool>(iterator(__nd), __inserted);
	#endif
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class... _Args>
	pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique_impl(_Args&&... __args)
	{
	__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
	pair<iterator, bool> __r = __node_insert_unique(__h.get());
	if (__r.second)
	__h.release();
	return __r;
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class... _Args>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_multi(_Args&&... __args)
	{
	__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
	iterator __r = __node_insert_multi(__h.get());
	__h.release();
	return __r;
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class... _Args>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_hint_multi(
	const_iterator __p, _Args&&... __args)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"unordered container::emplace_hint(const_iterator, args...) called with an iterator not"
	" referring to this unordered container");
	#endif
	__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
	iterator __r = __node_insert_multi(__p, __h.get());
	__h.release();
	return __r;
	}

	#else // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(const __container_value_type& __x)
	{
	__node_holder __h = __construct_node(__x);
	iterator __r = __node_insert_multi(__h.get());
	__h.release();
	return __r;
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(const_iterator __p,
	const __container_value_type& __x)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"unordered container::insert(const_iterator, lvalue) called with an iterator not"
	" referring to this unordered container");
	#endif
	__node_holder __h = __construct_node(__x);
	iterator __r = __node_insert_multi(__p, __h.get());
	__h.release();
	return __r;
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	void
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::rehash(size_type __n)
	{
	if (__n == 1)
	__n = 2;
	else if (__n & (__n - 1))
	__n = __next_prime(__n);
	size_type __bc = bucket_count();
	if (__n > __bc)
	__rehash(__n);
	else if (__n < __bc)
	{
	__n = _VSTD::max<size_type>
	(
	__n,
	__is_hash_power2(__bc) ? __next_hash_pow2(size_t(ceil(float(size()) / max_load_factor()))) :
	__next_prime(size_t(ceil(float(size()) / max_load_factor())))
	);
	if (__n < __bc)
	__rehash(__n);
	}
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	void
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__rehash(size_type __nbc)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__invalidate_all(this);
	#endif // _LIBCPP_DEBUG_LEVEL >= 2
	__pointer_allocator& __npa = __bucket_list_.get_deleter().__alloc();
	__bucket_list_.reset(__nbc > 0 ?
	__pointer_alloc_traits::allocate(__npa, __nbc) : nullptr);
	__bucket_list_.get_deleter().size() = __nbc;
	if (__nbc > 0)
	{
	for (size_type __i = 0; __i < __nbc; ++__i)
	__bucket_list_[__i] = nullptr;
	__next_pointer __pp = __p1_.first().__ptr();
	__next_pointer __cp = __pp->__next_;
	if (__cp != nullptr)
	{
	size_type __chash = __constrain_hash(__cp->__hash(), __nbc);
	__bucket_list_[__chash] = __pp;
	size_type __phash = __chash;
	for (__pp = __cp, __cp = __cp->__next_; __cp != nullptr;
	__cp = __pp->__next_)
	{
	__chash = __constrain_hash(__cp->__hash(), __nbc);
	if (__chash == __phash)
	__pp = __cp;
	else
	{
	if (__bucket_list_[__chash] == nullptr)
	{
	__bucket_list_[__chash] = __pp;
	__pp = __cp;
	__phash = __chash;
	}
	else
	{
	__next_pointer __np = __cp;
	for (; __np->__next_ != nullptr &&
	key_eq()(__cp->__upcast()->__value_,
	__np->__next_->__upcast()->__value_);
	__np = __np->__next_)
	;
	__pp->__next_ = __np->__next_;
	__np->__next_ = __bucket_list_[__chash]->__next_;
	__bucket_list_[__chash]->__next_ = __cp;

	}
	}
	}
	}
	}
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class _Key>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::find(const _Key& __k)
	{
	size_t __hash = hash_function()(__k);
	size_type __bc = bucket_count();
	if (__bc != 0)
	{
	size_t __chash = __constrain_hash(__hash, __bc);
	__next_pointer __nd = __bucket_list_[__chash];
	if (__nd != nullptr)
	{
	for (__nd = __nd->__next_; __nd != nullptr &&
	(__nd->__hash() == __hash
	\|\| __constrain_hash(__nd->__hash(), __bc) == __chash);
	__nd = __nd->__next_)
	{
	if ((__nd->__hash() == __hash)
	&& key_eq()(__nd->__upcast()->__value_, __k))
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return iterator(__nd, this);
	#else
	return iterator(__nd);
	#endif
	}
	}
	}
	return end();
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class _Key>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::find(const _Key& __k) const
	{
	size_t __hash = hash_function()(__k);
	size_type __bc = bucket_count();
	if (__bc != 0)
	{
	size_t __chash = __constrain_hash(__hash, __bc);
	__next_pointer __nd = __bucket_list_[__chash];
	if (__nd != nullptr)
	{
	for (__nd = __nd->__next_; __nd != nullptr &&
	(__hash == __nd->__hash()
	\|\| __constrain_hash(__nd->__hash(), __bc) == __chash);
	__nd = __nd->__next_)
	{
	if ((__nd->__hash() == __hash)
	&& key_eq()(__nd->__upcast()->__value_, __k))
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return const_iterator(__nd, this);
	#else
	return const_iterator(__nd);
	#endif
	}
	}

	}
	return end();
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class ..._Args>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(_Args&& ...__args)
	{
	static_assert(!__is_hash_value_type<_Args...>::value,
	"Construct cannot be called with a hash value type");
	__node_allocator& __na = __node_alloc();
	__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
	__node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), _VSTD::forward<_Args>(__args)...);
	__h.get_deleter().__value_constructed = true;
	__h->__hash_ = hash_function()(__h->__value_);
	__h->__next_ = nullptr;
	return __h;
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class _First, class ..._Rest>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node_hash(
	size_t __hash, _First&& __f, _Rest&& ...__rest)
	{
	static_assert(!__is_hash_value_type<_First, _Rest...>::value,
	"Construct cannot be called with a hash value type");
	__node_allocator& __na = __node_alloc();
	__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
	__node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_),
	_VSTD::forward<_First>(__f),
	_VSTD::forward<_Rest>(__rest)...);
	__h.get_deleter().__value_constructed = true;
	__h->__hash_ = __hash;
	__h->__next_ = nullptr;
	return __h;
	}

	#else // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(const __container_value_type& __v)
	{
	__node_allocator& __na = __node_alloc();
	__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
	__node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), __v);
	__h.get_deleter().__value_constructed = true;
	__h->__hash_ = hash_function()(__h->__value_);
	__h->__next_ = nullptr;
	return _LIBCPP_EXPLICIT_MOVE(__h); // explicitly moved for C++03
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node_hash(size_t __hash,
	const __container_value_type& __v)
	{
	__node_allocator& __na = __node_alloc();
	__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
	__node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), __v);
	__h.get_deleter().__value_constructed = true;
	__h->__hash_ = __hash;
	__h->__next_ = nullptr;
	return _LIBCPP_EXPLICIT_MOVE(__h); // explicitly moved for C++03
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::erase(const_iterator __p)
	{
	__next_pointer __np = __p.__node_;
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"unordered container erase(iterator) called with an iterator not"
	" referring to this container");
	_LIBCPP_ASSERT(__p != end(),
	"unordered container erase(iterator) called with a non-dereferenceable iterator");
	iterator __r(__np, this);
	#else
	iterator __r(__np);
	#endif
	++__r;
	remove(__p);
	return __r;
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::erase(const_iterator __first,
	const_iterator __last)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this,
	"unodered container::erase(iterator, iterator) called with an iterator not"
	" referring to this unodered container");
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__last) == this,
	"unodered container::erase(iterator, iterator) called with an iterator not"
	" referring to this unodered container");
	#endif
	for (const_iterator __p = __first; __first != __last; __p = __first)
	{
	++__first;
	erase(__p);
	}
	__next_pointer __np = __last.__node_;
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return iterator (__np, this);
	#else
	return iterator (__np);
	#endif
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class _Key>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::size_type
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__erase_unique(const _Key& __k)
	{
	iterator __i = find(__k);
	if (__i == end())
	return 0;
	erase(__i);
	return 1;
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class _Key>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::size_type
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__erase_multi(const _Key& __k)
	{
	size_type __r = 0;
	iterator __i = find(__k);
	if (__i != end())
	{
	iterator __e = end();
	do
	{
	erase(__i++);
	++__r;
	} while (__i != __e && key_eq()(*__i, __k));
	}
	return __r;
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::remove(const_iterator __p) _NOEXCEPT
	{
	// current node
	__next_pointer __cn = __p.__node_;
	size_type __bc = bucket_count();
	size_t __chash = __constrain_hash(__cn->__hash(), __bc);
	// find previous node
	__next_pointer __pn = __bucket_list_[__chash];
	for (; __pn->__next_ != __cn; __pn = __pn->__next_)
	;
	// Fix up __bucket_list_
	// if __pn is not in same bucket (before begin is not in same bucket) &&
	// if __cn->__next_ is not in same bucket (nullptr is not in same bucket)
	if (__pn == __p1_.first().__ptr()
	\|\| __constrain_hash(__pn->__hash(), __bc) != __chash)
	{
	if (__cn->__next_ == nullptr
	\|\| __constrain_hash(__cn->__next_->__hash(), __bc) != __chash)
	__bucket_list_[__chash] = nullptr;
	}
	// if __cn->__next_ is not in same bucket (nullptr is in same bucket)
	if (__cn->__next_ != nullptr)
	{
	size_t __nhash = __constrain_hash(__cn->__next_->__hash(), __bc);
	if (__nhash != __chash)
	__bucket_list_[__nhash] = __pn;
	}
	// remove __cn
	__pn->__next_ = __cn->__next_;
	__cn->__next_ = nullptr;
	--size();
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__c_node* __c = __get_db()->__find_c_and_lock(this);
	for (__i_node** __dp = __c->end_; __dp != __c->beg_; )
	{
	--__dp;
	iterator* __i = static_cast<iterator>((__dp)->__i_);
	if (__i->__node_ == __cn)
	{
	(*__dp)->__c_ = nullptr;
	if (--__c->end_ != __dp)
	memmove(__dp, __dp+1, (__c->end_ - __dp)sizeof(__i_node));
	}
	}
	__get_db()->unlock();
	#endif
	return __node_holder(__cn->__upcast(), _Dp(__node_alloc(), true));
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class _Key>
	inline
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::size_type
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__count_unique(const _Key& __k) const
	{
	return static_cast<size_type>(find(__k) != end());
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class _Key>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::size_type
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__count_multi(const _Key& __k) const
	{
	size_type __r = 0;
	const_iterator __i = find(__k);
	if (__i != end())
	{
	const_iterator __e = end();
	do
	{
	++__i;
	++__r;
	} while (__i != __e && key_eq()(*__i, __k));
	}
	return __r;
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class _Key>
	pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator,
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator>
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__equal_range_unique(
	const _Key& __k)
	{
	iterator __i = find(__k);
	iterator __j = __i;
	if (__i != end())
	++__j;
	return pair<iterator, iterator>(__i, __j);
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class _Key>
	pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator,
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator>
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__equal_range_unique(
	const _Key& __k) const
	{
	const_iterator __i = find(__k);
	const_iterator __j = __i;
	if (__i != end())
	++__j;
	return pair<const_iterator, const_iterator>(__i, __j);
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class _Key>
	pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator,
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator>
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__equal_range_multi(
	const _Key& __k)
	{
	iterator __i = find(__k);
	iterator __j = __i;
	if (__i != end())
	{
	iterator __e = end();
	do
	{
	++__j;
	} while (__j != __e && key_eq()(*__j, __k));
	}
	return pair<iterator, iterator>(__i, __j);
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	template <class _Key>
	pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator,
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator>
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__equal_range_multi(
	const _Key& __k) const
	{
	const_iterator __i = find(__k);
	const_iterator __j = __i;
	if (__i != end())
	{
	const_iterator __e = end();
	do
	{
	++__j;
	} while (__j != __e && key_eq()(*__j, __k));
	}
	return pair<const_iterator, const_iterator>(__i, __j);
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	void
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::swap(__hash_table& __u)
	#if _LIBCPP_STD_VER <= 11
	_NOEXCEPT_DEBUG_(
	__is_nothrow_swappable<hasher>::value && __is_nothrow_swappable<key_equal>::value
	&& (!allocator_traits<__pointer_allocator>::propagate_on_container_swap::value
	\|\| __is_nothrow_swappable<__pointer_allocator>::value)
	&& (!__node_traits::propagate_on_container_swap::value
	\|\| __is_nothrow_swappable<__node_allocator>::value)
	)
	#else
	_NOEXCEPT_DEBUG_(__is_nothrow_swappable<hasher>::value && __is_nothrow_swappable<key_equal>::value)
	#endif
	{
	_LIBCPP_ASSERT(__node_traits::propagate_on_container_swap::value \|\|
	this->__node_alloc() == __u.__node_alloc(),
	"list::swap: Either propagate_on_container_swap must be true"
	" or the allocators must compare equal");
	{
	__node_pointer_pointer __npp = __bucket_list_.release();
	__bucket_list_.reset(__u.__bucket_list_.release());
	__u.__bucket_list_.reset(__npp);
	}
	_VSTD::swap(__bucket_list_.get_deleter().size(), __u.__bucket_list_.get_deleter().size());
	__swap_allocator(__bucket_list_.get_deleter().__alloc(),
	__u.__bucket_list_.get_deleter().__alloc());
	__swap_allocator(__node_alloc(), __u.__node_alloc());
	_VSTD::swap(__p1_.first().__next_, __u.__p1_.first().__next_);
	__p2_.swap(__u.__p2_);
	__p3_.swap(__u.__p3_);
	if (size() > 0)
	__bucket_list_[__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
	__p1_.first().__ptr();
	if (__u.size() > 0)
	__u.__bucket_list_[__constrain_hash(__u.__p1_.first().__next_->__hash(), __u.bucket_count())] =
	__u.__p1_.first().__ptr();
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->swap(this, &__u);
	#endif
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::size_type
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::bucket_size(size_type __n) const
	{
	_LIBCPP_ASSERT(__n < bucket_count(),
	"unordered container::bucket_size(n) called with n >= bucket_count()");
	__next_pointer __np = __bucket_list_[__n];
	size_type __bc = bucket_count();
	size_type __r = 0;
	if (__np != nullptr)
	{
	for (__np = __np->__next_; __np != nullptr &&
	__constrain_hash(__np->__hash(), __bc) == __n;
	__np = __np->__next_, ++__r)
	;
	}
	return __r;
	}

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

	#if _LIBCPP_DEBUG_LEVEL >= 2

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	bool
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__dereferenceable(const const_iterator* __i) const
	{
	return __i->__node_ != nullptr;
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	bool
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__decrementable(const const_iterator*) const
	{
	return false;
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	bool
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__addable(const const_iterator*, ptrdiff_t) const
	{
	return false;
	}

	template <class _Tp, class _Hash, class _Equal, class _Alloc>
	bool
	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__subscriptable(const const_iterator*, ptrdiff_t) const
	{
	return false;
	}

	#endif // _LIBCPP_DEBUG_LEVEL >= 2

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP__HASH_TABLE
	Index: projects/clang700-import/contrib/libc++/include/__libcpp_version
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/__libcpp_version (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/__libcpp_version (revision 337135)
	@@ -1 +1 @@
	-6000
	+7000
	Index: projects/clang700-import/contrib/libc++/include/__locale
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/__locale (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/__locale (revision 337135)
	@@ -1,1527 +1,1523 @@
	// -- 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.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP___LOCALE
	#define _LIBCPP___LOCALE

	#include <__config>
	#include <string>
	#include <memory>
	#include <utility>
	#include <mutex>
	#include <cstdint>
	#include <cctype>
	#include <locale.h>
	#if defined(_LIBCPP_MSVCRT_LIKE)
	# include <support/win32/locale_win32.h>
	#elif defined(_AIX)
	# include <support/ibm/xlocale.h>
	#elif defined(__ANDROID__)
	-// Android gained the locale aware functions in L (API level 21)
	-# include <android/api-level.h>
	-# if __ANDROID_API__ <= 20
	-# include <support/android/locale_bionic.h>
	-# endif
	+# include <support/android/locale_bionic.h>
	#elif defined(__sun__)
	# include <xlocale.h>
	# include <support/solaris/xlocale.h>
	#elif defined(_NEWLIB_VERSION)
	# include <support/newlib/xlocale.h>
	#elif (defined(__APPLE__) \|\| defined(__FreeBSD__) \
	\|\| defined(__EMSCRIPTEN__) \|\| defined(__IBMCPP__))
	# include <xlocale.h>
	#elif defined(__Fuchsia__)
	# include <support/fuchsia/xlocale.h>
	#elif defined(_LIBCPP_HAS_MUSL_LIBC)
	# include <support/musl/xlocale.h>
	#endif

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	#if !defined(_LIBCPP_LOCALE__L_EXTENSIONS)
	struct __libcpp_locale_guard {
	_LIBCPP_INLINE_VISIBILITY
	__libcpp_locale_guard(locale_t& __loc) : __old_loc_(uselocale(__loc)) {}

	_LIBCPP_INLINE_VISIBILITY
	~__libcpp_locale_guard() {
	if (__old_loc_)
	uselocale(__old_loc_);
	}

	locale_t __old_loc_;
	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


	class _LIBCPP_TYPE_VIS locale;

	template <class _Facet>
	_LIBCPP_INLINE_VISIBILITY
	bool
	has_facet(const locale&) _NOEXCEPT;

	template <class _Facet>
	_LIBCPP_INLINE_VISIBILITY
	const _Facet&
	use_facet(const locale&);

	class _LIBCPP_TYPE_VIS locale
	{
	public:
	// types:
	class _LIBCPP_TYPE_VIS facet;
	class _LIBCPP_TYPE_VIS id;

	typedef int category;
	_LIBCPP_AVAILABILITY_LOCALE_CATEGORY
	static const category // values assigned here are for exposition only
	none = 0,
	collate = LC_COLLATE_MASK,
	ctype = LC_CTYPE_MASK,
	monetary = LC_MONETARY_MASK,
	numeric = LC_NUMERIC_MASK,
	time = LC_TIME_MASK,
	messages = LC_MESSAGES_MASK,
	all = collate \| ctype \| monetary \| numeric \| time \| messages;

	// construct/copy/destroy:
	locale() _NOEXCEPT;
	locale(const locale&) _NOEXCEPT;
	explicit locale(const char*);
	explicit locale(const string&);
	locale(const locale&, const char*, category);
	locale(const locale&, const string&, category);
	template <class _Facet>
	_LIBCPP_INLINE_VISIBILITY locale(const locale&, _Facet*);
	locale(const locale&, const locale&, category);

	~locale();

	const locale& operator=(const locale&) _NOEXCEPT;

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

	// locale operations:
	string name() const;
	bool operator==(const locale&) const;
	bool operator!=(const locale& __y) const {return !(*this == __y);}
	template <class _CharT, class _Traits, class _Allocator>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	bool operator()(const basic_string<_CharT, _Traits, _Allocator>&,
	const basic_string<_CharT, _Traits, _Allocator>&) const;

	// global locale objects:
	static locale global(const locale&);
	static const locale& classic();

	private:
	class __imp;
	__imp* __locale_;

	void __install_ctor(const locale&, facet*, long);
	static locale& __global();
	bool has_facet(id&) const;
	const facet* use_facet(id&) const;

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

	class _LIBCPP_TYPE_VIS locale::facet
	: public __shared_count
	{
	protected:
	_LIBCPP_INLINE_VISIBILITY
	explicit facet(size_t __refs = 0)
	: __shared_count(static_cast<long>(__refs)-1) {}

	virtual ~facet();

	// facet(const facet&) = delete; // effectively done in __shared_count
	// void operator=(const facet&) = delete;
	private:
	virtual void __on_zero_shared() _NOEXCEPT;
	};

	class _LIBCPP_TYPE_VIS locale::id
	{
	once_flag __flag_;
	int32_t __id_;

	static int32_t __next_id;
	public:
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR id() :__id_(0) {}
	private:
	void __init();
	void operator=(const id&); // = delete;
	id(const id&); // = delete;
	public: // only needed for tests
	long __get();

	friend class locale;
	friend class locale::__imp;
	};

	template <class _Facet>
	inline _LIBCPP_INLINE_VISIBILITY
	locale::locale(const locale& __other, _Facet* __f)
	{
	__install_ctor(__other, __f, __f ? __f->id.__get() : 0);
	}

	template <class _Facet>
	locale
	locale::combine(const locale& __other) const
	{
	if (!_VSTD::has_facet<_Facet>(__other))
	__throw_runtime_error("locale::combine: locale missing facet");

	return locale(*this, &const_cast<_Facet&>(_VSTD::use_facet<_Facet>(__other)));
	}

	template <class _Facet>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	has_facet(const locale& __l) _NOEXCEPT
	{
	return __l.has_facet(_Facet::id);
	}

	template <class _Facet>
	inline _LIBCPP_INLINE_VISIBILITY
	const _Facet&
	use_facet(const locale& __l)
	{
	return static_cast<const _Facet&>(*__l.use_facet(_Facet::id));
	}

	// template <class _CharT> class collate;

	template <class _CharT>
	class _LIBCPP_TEMPLATE_VIS collate
	: public locale::facet
	{
	public:
	typedef _CharT char_type;
	typedef basic_string<char_type> string_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit collate(size_t __refs = 0)
	: locale::facet(__refs) {}

	_LIBCPP_INLINE_VISIBILITY
	int compare(const char_type* __lo1, const char_type* __hi1,
	const char_type* __lo2, const char_type* __hi2) const
	{
	return do_compare(__lo1, __hi1, __lo2, __hi2);
	}

	_LIBCPP_INLINE_VISIBILITY
	string_type transform(const char_type* __lo, const char_type* __hi) const
	{
	return do_transform(__lo, __hi);
	}

	_LIBCPP_INLINE_VISIBILITY
	long hash(const char_type* __lo, const char_type* __hi) const
	{
	return do_hash(__lo, __hi);
	}

	static locale::id id;

	protected:
	~collate();
	virtual int do_compare(const char_type* __lo1, const char_type* __hi1,
	const char_type* __lo2, const char_type* __hi2) const;
	virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const
	{return string_type(__lo, __hi);}
	virtual long do_hash(const char_type* __lo, const char_type* __hi) const;
	};

	template <class _CharT> locale::id collate<_CharT>::id;

	template <class _CharT>
	collate<_CharT>::~collate()
	{
	}

	template <class _CharT>
	int
	collate<_CharT>::do_compare(const char_type* __lo1, const char_type* __hi1,
	const char_type* __lo2, const char_type* __hi2) const
	{
	for (; __lo2 != __hi2; ++__lo1, ++__lo2)
	{
	if (__lo1 == __hi1 \|\| __lo1 < __lo2)
	return -1;
	if (__lo2 < __lo1)
	return 1;
	}
	return __lo1 != __hi1;
	}

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

	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS collate<char>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS collate<wchar_t>)

	// template <class CharT> class collate_byname;

	template <class _CharT> class _LIBCPP_TEMPLATE_VIS collate_byname;

	template <>
	class _LIBCPP_TYPE_VIS collate_byname<char>
	: public collate<char>
	{
	locale_t __l;
	public:
	typedef char char_type;
	typedef basic_string<char_type> string_type;

	explicit collate_byname(const char* __n, size_t __refs = 0);
	explicit collate_byname(const string& __n, size_t __refs = 0);

	protected:
	~collate_byname();
	virtual int do_compare(const char_type* __lo1, const char_type* __hi1,
	const char_type* __lo2, const char_type* __hi2) const;
	virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const;
	};

	template <>
	class _LIBCPP_TYPE_VIS collate_byname<wchar_t>
	: public collate<wchar_t>
	{
	locale_t __l;
	public:
	typedef wchar_t char_type;
	typedef basic_string<char_type> string_type;

	explicit collate_byname(const char* __n, size_t __refs = 0);
	explicit collate_byname(const string& __n, size_t __refs = 0);

	protected:
	~collate_byname();

	virtual int do_compare(const char_type* __lo1, const char_type* __hi1,
	const char_type* __lo2, const char_type* __hi2) const;
	virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const;
	};

	template <class _CharT, class _Traits, class _Allocator>
	bool
	locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x,
	const basic_string<_CharT, _Traits, _Allocator>& __y) const
	{
	return _VSTD::use_facet<_VSTD::collate<_CharT> >(*this).compare(
	__x.data(), __x.data() + __x.size(),
	__y.data(), __y.data() + __y.size()) < 0;
	}

	// template <class charT> class ctype

	class _LIBCPP_TYPE_VIS ctype_base
	{
	public:
	#if defined(__GLIBC__)
	typedef unsigned short mask;
	static const mask space = _ISspace;
	static const mask print = _ISprint;
	static const mask cntrl = _IScntrl;
	static const mask upper = _ISupper;
	static const mask lower = _ISlower;
	static const mask alpha = _ISalpha;
	static const mask digit = _ISdigit;
	static const mask punct = _ISpunct;
	static const mask xdigit = _ISxdigit;
	static const mask blank = _ISblank;
	#elif defined(_LIBCPP_MSVCRT_LIKE)
	typedef unsigned short mask;
	static const mask space = _SPACE;
	static const mask print = _BLANK\|_PUNCT\|_ALPHA\|_DIGIT;
	static const mask cntrl = _CONTROL;
	static const mask upper = _UPPER;
	static const mask lower = _LOWER;
	static const mask alpha = _ALPHA;
	static const mask digit = _DIGIT;
	static const mask punct = _PUNCT;
	static const mask xdigit = _HEX;
	static const mask blank = _BLANK;
	# define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT
	#elif defined(__APPLE__) \|\| defined(__FreeBSD__) \|\| defined(__EMSCRIPTEN__) \|\| defined(__NetBSD__)
	# ifdef __APPLE__
	typedef __uint32_t mask;
	# elif defined(__FreeBSD__)
	typedef unsigned long mask;
	# elif defined(__EMSCRIPTEN__) \|\| defined(__NetBSD__)
	typedef unsigned short mask;
	# endif
	static const mask space = _CTYPE_S;
	static const mask print = _CTYPE_R;
	static const mask cntrl = _CTYPE_C;
	static const mask upper = _CTYPE_U;
	static const mask lower = _CTYPE_L;
	static const mask alpha = _CTYPE_A;
	static const mask digit = _CTYPE_D;
	static const mask punct = _CTYPE_P;
	static const mask xdigit = _CTYPE_X;

	# if defined(__NetBSD__)
	static const mask blank = _CTYPE_BL;
	# else
	static const mask blank = _CTYPE_B;
	# endif
	#elif defined(__sun__) \|\| defined(_AIX)
	typedef unsigned int mask;
	static const mask space = _ISSPACE;
	static const mask print = _ISPRINT;
	static const mask cntrl = _ISCNTRL;
	static const mask upper = _ISUPPER;
	static const mask lower = _ISLOWER;
	static const mask alpha = _ISALPHA;
	static const mask digit = _ISDIGIT;
	static const mask punct = _ISPUNCT;
	static const mask xdigit = _ISXDIGIT;
	static const mask blank = _ISBLANK;
	#elif defined(_NEWLIB_VERSION)
	// Same type as Newlib's _ctype_ array in newlib/libc/include/ctype.h.
	typedef char mask;
	static const mask space = _S;
	static const mask print = _P \| _U \| _L \| _N \| _B;
	static const mask cntrl = _C;
	static const mask upper = _U;
	static const mask lower = _L;
	static const mask alpha = _U \| _L;
	static const mask digit = _N;
	static const mask punct = _P;
	static const mask xdigit = _X \| _N;
	static const mask blank = _B;
	# define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT
	# define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA
	# define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_XDIGIT
	#else
	typedef unsigned long mask;
	static const mask space = 1<<0;
	static const mask print = 1<<1;
	static const mask cntrl = 1<<2;
	static const mask upper = 1<<3;
	static const mask lower = 1<<4;
	static const mask alpha = 1<<5;
	static const mask digit = 1<<6;
	static const mask punct = 1<<7;
	static const mask xdigit = 1<<8;
	static const mask blank = 1<<9;
	#endif
	static const mask alnum = alpha \| digit;
	static const mask graph = alnum \| punct;

	- _LIBCPP_ALWAYS_INLINE ctype_base() {}
	+ _LIBCPP_INLINE_VISIBILITY ctype_base() {}
	};

	template <class _CharT> class _LIBCPP_TEMPLATE_VIS ctype;

	template <>
	class _LIBCPP_TYPE_VIS ctype<wchar_t>
	: public locale::facet,
	public ctype_base
	{
	public:
	typedef wchar_t char_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit ctype(size_t __refs = 0)
	: locale::facet(__refs) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	bool is(mask __m, char_type __c) const
	{
	return do_is(__m, __c);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const char_type* is(const char_type* __low, const char_type* __high, mask* __vec) const
	{
	return do_is(__low, __high, __vec);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const char_type* scan_is(mask __m, const char_type* __low, const char_type* __high) const
	{
	return do_scan_is(__m, __low, __high);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const char_type* scan_not(mask __m, const char_type* __low, const char_type* __high) const
	{
	return do_scan_not(__m, __low, __high);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	char_type toupper(char_type __c) const
	{
	return do_toupper(__c);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const char_type* toupper(char_type* __low, const char_type* __high) const
	{
	return do_toupper(__low, __high);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	char_type tolower(char_type __c) const
	{
	return do_tolower(__c);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const char_type* tolower(char_type* __low, const char_type* __high) const
	{
	return do_tolower(__low, __high);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	char_type widen(char __c) const
	{
	return do_widen(__c);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const char* widen(const char* __low, const char* __high, char_type* __to) const
	{
	return do_widen(__low, __high, __to);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	char narrow(char_type __c, char __dfault) const
	{
	return do_narrow(__c, __dfault);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const char_type* narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const
	{
	return do_narrow(__low, __high, __dfault, __to);
	}

	static locale::id id;

	protected:
	~ctype();
	virtual bool do_is(mask __m, char_type __c) const;
	virtual const char_type* do_is(const char_type* __low, const char_type* __high, mask* __vec) const;
	virtual const char_type* do_scan_is(mask __m, const char_type* __low, const char_type* __high) const;
	virtual const char_type* do_scan_not(mask __m, const char_type* __low, const char_type* __high) const;
	virtual char_type do_toupper(char_type) const;
	virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
	virtual char_type do_tolower(char_type) const;
	virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
	virtual char_type do_widen(char) const;
	virtual const char* do_widen(const char* __low, const char* __high, char_type* __dest) const;
	virtual char do_narrow(char_type, char __dfault) const;
	virtual const char_type* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __dest) const;
	};

	template <>
	class _LIBCPP_TYPE_VIS ctype<char>
	: public locale::facet, public ctype_base
	{
	const mask* __tab_;
	bool __del_;
	public:
	typedef char char_type;

	explicit ctype(const mask* __tab = 0, bool __del = false, size_t __refs = 0);

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	bool is(mask __m, char_type __c) const
	{
	return isascii(__c) ? (__tab_[static_cast<int>(__c)] & __m) !=0 : false;
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const char_type* is(const char_type* __low, const char_type* __high, mask* __vec) const
	{
	for (; __low != __high; ++__low, ++__vec)
	__vec = isascii(__low) ? __tab_[static_cast<int>(*__low)] : 0;
	return __low;
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const char_type* scan_is (mask __m, const char_type* __low, const char_type* __high) const
	{
	for (; __low != __high; ++__low)
	if (isascii(__low) && (__tab_[static_cast<int>(__low)] & __m))
	break;
	return __low;
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const char_type* scan_not(mask __m, const char_type* __low, const char_type* __high) const
	{
	for (; __low != __high; ++__low)
	if (!(isascii(__low) && (__tab_[static_cast<int>(__low)] & __m)))
	break;
	return __low;
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	char_type toupper(char_type __c) const
	{
	return do_toupper(__c);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const char_type* toupper(char_type* __low, const char_type* __high) const
	{
	return do_toupper(__low, __high);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	char_type tolower(char_type __c) const
	{
	return do_tolower(__c);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const char_type* tolower(char_type* __low, const char_type* __high) const
	{
	return do_tolower(__low, __high);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	char_type widen(char __c) const
	{
	return do_widen(__c);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const char* widen(const char* __low, const char* __high, char_type* __to) const
	{
	return do_widen(__low, __high, __to);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	char narrow(char_type __c, char __dfault) const
	{
	return do_narrow(__c, __dfault);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const char* narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const
	{
	return do_narrow(__low, __high, __dfault, __to);
	}

	static locale::id id;

	#ifdef _CACHED_RUNES
	static const size_t table_size = _CACHED_RUNES;
	#else
	static const size_t table_size = 256; // FIXME: Don't hardcode this.
	#endif
	- _LIBCPP_ALWAYS_INLINE const mask* table() const _NOEXCEPT {return __tab_;}
	+ _LIBCPP_INLINE_VISIBILITY const mask* table() const _NOEXCEPT {return __tab_;}
	static const mask* classic_table() _NOEXCEPT;
	#if defined(__GLIBC__) \|\| defined(__EMSCRIPTEN__)
	static const int* __classic_upper_table() _NOEXCEPT;
	static const int* __classic_lower_table() _NOEXCEPT;
	#endif
	#if defined(__NetBSD__)
	static const short* __classic_upper_table() _NOEXCEPT;
	static const short* __classic_lower_table() _NOEXCEPT;
	#endif

	protected:
	~ctype();
	virtual char_type do_toupper(char_type __c) const;
	virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
	virtual char_type do_tolower(char_type __c) const;
	virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
	virtual char_type do_widen(char __c) const;
	virtual const char* do_widen(const char* __low, const char* __high, char_type* __to) const;
	virtual char do_narrow(char_type __c, char __dfault) const;
	virtual const char* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const;
	};

	// template <class CharT> class ctype_byname;

	template <class _CharT> class _LIBCPP_TEMPLATE_VIS ctype_byname;

	template <>
	class _LIBCPP_TYPE_VIS ctype_byname<char>
	: public ctype<char>
	{
	locale_t __l;

	public:
	explicit ctype_byname(const char*, size_t = 0);
	explicit ctype_byname(const string&, size_t = 0);

	protected:
	~ctype_byname();
	virtual char_type do_toupper(char_type) const;
	virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
	virtual char_type do_tolower(char_type) const;
	virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
	};

	template <>
	class _LIBCPP_TYPE_VIS ctype_byname<wchar_t>
	: public ctype<wchar_t>
	{
	locale_t __l;

	public:
	explicit ctype_byname(const char*, size_t = 0);
	explicit ctype_byname(const string&, size_t = 0);

	protected:
	~ctype_byname();
	virtual bool do_is(mask __m, char_type __c) const;
	virtual const char_type* do_is(const char_type* __low, const char_type* __high, mask* __vec) const;
	virtual const char_type* do_scan_is(mask __m, const char_type* __low, const char_type* __high) const;
	virtual const char_type* do_scan_not(mask __m, const char_type* __low, const char_type* __high) const;
	virtual char_type do_toupper(char_type) const;
	virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
	virtual char_type do_tolower(char_type) const;
	virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
	virtual char_type do_widen(char) const;
	virtual const char* do_widen(const char* __low, const char* __high, char_type* __dest) const;
	virtual char do_narrow(char_type, char __dfault) const;
	virtual const char_type* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __dest) const;
	};

	template <class _CharT>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	isspace(_CharT __c, const locale& __loc)
	{
	return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c);
	}

	template <class _CharT>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	isprint(_CharT __c, const locale& __loc)
	{
	return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c);
	}

	template <class _CharT>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	iscntrl(_CharT __c, const locale& __loc)
	{
	return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c);
	}

	template <class _CharT>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	isupper(_CharT __c, const locale& __loc)
	{
	return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c);
	}

	template <class _CharT>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	islower(_CharT __c, const locale& __loc)
	{
	return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c);
	}

	template <class _CharT>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	isalpha(_CharT __c, const locale& __loc)
	{
	return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c);
	}

	template <class _CharT>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	isdigit(_CharT __c, const locale& __loc)
	{
	return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c);
	}

	template <class _CharT>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	ispunct(_CharT __c, const locale& __loc)
	{
	return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c);
	}

	template <class _CharT>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	isxdigit(_CharT __c, const locale& __loc)
	{
	return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c);
	}

	template <class _CharT>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	isalnum(_CharT __c, const locale& __loc)
	{
	return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c);
	}

	template <class _CharT>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	isgraph(_CharT __c, const locale& __loc)
	{
	return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c);
	}

	template <class _CharT>
	inline _LIBCPP_INLINE_VISIBILITY
	_CharT
	toupper(_CharT __c, const locale& __loc)
	{
	return use_facet<ctype<_CharT> >(__loc).toupper(__c);
	}

	template <class _CharT>
	inline _LIBCPP_INLINE_VISIBILITY
	_CharT
	tolower(_CharT __c, const locale& __loc)
	{
	return use_facet<ctype<_CharT> >(__loc).tolower(__c);
	}

	// codecvt_base

	class _LIBCPP_TYPE_VIS codecvt_base
	{
	public:
	- _LIBCPP_ALWAYS_INLINE codecvt_base() {}
	+ _LIBCPP_INLINE_VISIBILITY codecvt_base() {}
	enum result {ok, partial, error, noconv};
	};

	// template <class internT, class externT, class stateT> class codecvt;

	template <class _InternT, class _ExternT, class _StateT> class _LIBCPP_TEMPLATE_VIS codecvt;

	// template <> class codecvt<char, char, mbstate_t>

	template <>
	class _LIBCPP_TYPE_VIS codecvt<char, char, mbstate_t>
	: public locale::facet,
	public codecvt_base
	{
	public:
	typedef char intern_type;
	typedef char extern_type;
	typedef mbstate_t state_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit codecvt(size_t __refs = 0)
	: locale::facet(__refs) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	result out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
	{
	return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	result unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
	{
	return do_unshift(__st, __to, __to_end, __to_nxt);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	result in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
	{
	return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
	}

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

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	bool always_noconv() const _NOEXCEPT
	{
	return do_always_noconv();
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
	{
	return do_length(__st, __frm, __end, __mx);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	int max_length() const _NOEXCEPT
	{
	return do_max_length();
	}

	static locale::id id;

	protected:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit codecvt(const char*, size_t __refs = 0)
	: locale::facet(__refs) {}

	~codecvt();

	virtual result do_out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual result do_in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
	virtual result do_unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual int do_encoding() const _NOEXCEPT;
	virtual bool do_always_noconv() const _NOEXCEPT;
	virtual int do_length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
	virtual int do_max_length() const _NOEXCEPT;
	};

	// template <> class codecvt<wchar_t, char, mbstate_t>

	template <>
	class _LIBCPP_TYPE_VIS codecvt<wchar_t, char, mbstate_t>
	: public locale::facet,
	public codecvt_base
	{
	locale_t __l;
	public:
	typedef wchar_t intern_type;
	typedef char extern_type;
	typedef mbstate_t state_type;

	explicit codecvt(size_t __refs = 0);

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	result out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
	{
	return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	result unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
	{
	return do_unshift(__st, __to, __to_end, __to_nxt);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	result in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
	{
	return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
	}

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

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	bool always_noconv() const _NOEXCEPT
	{
	return do_always_noconv();
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
	{
	return do_length(__st, __frm, __end, __mx);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	int max_length() const _NOEXCEPT
	{
	return do_max_length();
	}

	static locale::id id;

	protected:
	explicit codecvt(const char*, size_t __refs = 0);

	~codecvt();

	virtual result do_out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual result do_in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
	virtual result do_unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual int do_encoding() const _NOEXCEPT;
	virtual bool do_always_noconv() const _NOEXCEPT;
	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
	virtual int do_max_length() const _NOEXCEPT;
	};

	// template <> class codecvt<char16_t, char, mbstate_t>

	template <>
	class _LIBCPP_TYPE_VIS codecvt<char16_t, char, mbstate_t>
	: public locale::facet,
	public codecvt_base
	{
	public:
	typedef char16_t intern_type;
	typedef char extern_type;
	typedef mbstate_t state_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit codecvt(size_t __refs = 0)
	: locale::facet(__refs) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	result out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
	{
	return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	result unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
	{
	return do_unshift(__st, __to, __to_end, __to_nxt);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	result in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
	{
	return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
	}

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

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	bool always_noconv() const _NOEXCEPT
	{
	return do_always_noconv();
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
	{
	return do_length(__st, __frm, __end, __mx);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	int max_length() const _NOEXCEPT
	{
	return do_max_length();
	}

	static locale::id id;

	protected:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit codecvt(const char*, size_t __refs = 0)
	: locale::facet(__refs) {}

	~codecvt();

	virtual result do_out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual result do_in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
	virtual result do_unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual int do_encoding() const _NOEXCEPT;
	virtual bool do_always_noconv() const _NOEXCEPT;
	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
	virtual int do_max_length() const _NOEXCEPT;
	};

	// template <> class codecvt<char32_t, char, mbstate_t>

	template <>
	class _LIBCPP_TYPE_VIS codecvt<char32_t, char, mbstate_t>
	: public locale::facet,
	public codecvt_base
	{
	public:
	typedef char32_t intern_type;
	typedef char extern_type;
	typedef mbstate_t state_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit codecvt(size_t __refs = 0)
	: locale::facet(__refs) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	result out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
	{
	return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	result unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
	{
	return do_unshift(__st, __to, __to_end, __to_nxt);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	result in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
	{
	return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
	}

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

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	bool always_noconv() const _NOEXCEPT
	{
	return do_always_noconv();
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
	{
	return do_length(__st, __frm, __end, __mx);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	int max_length() const _NOEXCEPT
	{
	return do_max_length();
	}

	static locale::id id;

	protected:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit codecvt(const char*, size_t __refs = 0)
	: locale::facet(__refs) {}

	~codecvt();

	virtual result do_out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual result do_in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
	virtual result do_unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual int do_encoding() const _NOEXCEPT;
	virtual bool do_always_noconv() const _NOEXCEPT;
	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
	virtual int do_max_length() const _NOEXCEPT;
	};

	// template <class _InternT, class _ExternT, class _StateT> class codecvt_byname

	template <class _InternT, class _ExternT, class _StateT>
	class _LIBCPP_TEMPLATE_VIS codecvt_byname
	: public codecvt<_InternT, _ExternT, _StateT>
	{
	public:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit codecvt_byname(const char* __nm, size_t __refs = 0)
	: codecvt<_InternT, _ExternT, _StateT>(__nm, __refs) {}
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit codecvt_byname(const string& __nm, size_t __refs = 0)
	: codecvt<_InternT, _ExternT, _StateT>(__nm.c_str(), __refs) {}
	protected:
	~codecvt_byname();
	};

	template <class _InternT, class _ExternT, class _StateT>
	codecvt_byname<_InternT, _ExternT, _StateT>::~codecvt_byname()
	{
	}

	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char, char, mbstate_t>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<wchar_t, char, mbstate_t>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char16_t, char, mbstate_t>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char32_t, char, mbstate_t>)

	_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);

	template <size_t _Np>
	struct __narrow_to_utf8
	{
	template <class _OutputIterator, class _CharT>
	_OutputIterator
	operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const;
	};

	template <>
	struct __narrow_to_utf8<8>
	{
	template <class _OutputIterator, class _CharT>
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
	{
	for (; __wb < __we; ++__wb, ++__s)
	__s = __wb;
	return __s;
	}
	};

	template <>
	struct __narrow_to_utf8<16>
	: public codecvt<char16_t, char, mbstate_t>
	{
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	__narrow_to_utf8() : codecvt<char16_t, char, mbstate_t>(1) {}

	~__narrow_to_utf8();

	template <class _OutputIterator, class _CharT>
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
	{
	result __r = ok;
	mbstate_t __mb;
	while (__wb < __we && __r != error)
	{
	const int __sz = 32;
	char __buf[__sz];
	char* __bn;
	const char16_t* __wn = (const char16_t*)__wb;
	__r = do_out(__mb, (const char16_t)__wb, (const char16_t)__we, __wn,
	__buf, __buf+__sz, __bn);
	if (__r == codecvt_base::error \|\| __wn == (const char16_t*)__wb)
	__throw_runtime_error("locale not supported");
	for (const char* __p = __buf; __p < __bn; ++__p, ++__s)
	__s = __p;
	__wb = (const _CharT*)__wn;
	}
	return __s;
	}
	};

	template <>
	struct __narrow_to_utf8<32>
	: public codecvt<char32_t, char, mbstate_t>
	{
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	__narrow_to_utf8() : codecvt<char32_t, char, mbstate_t>(1) {}

	~__narrow_to_utf8();

	template <class _OutputIterator, class _CharT>
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
	{
	result __r = ok;
	mbstate_t __mb;
	while (__wb < __we && __r != error)
	{
	const int __sz = 32;
	char __buf[__sz];
	char* __bn;
	const char32_t* __wn = (const char32_t*)__wb;
	__r = do_out(__mb, (const char32_t)__wb, (const char32_t)__we, __wn,
	__buf, __buf+__sz, __bn);
	if (__r == codecvt_base::error \|\| __wn == (const char32_t*)__wb)
	__throw_runtime_error("locale not supported");
	for (const char* __p = __buf; __p < __bn; ++__p, ++__s)
	__s = __p;
	__wb = (const _CharT*)__wn;
	}
	return __s;
	}
	};

	template <size_t _Np>
	struct __widen_from_utf8
	{
	template <class _OutputIterator>
	_OutputIterator
	operator()(_OutputIterator __s, const char* __nb, const char* __ne) const;
	};

	template <>
	struct __widen_from_utf8<8>
	{
	template <class _OutputIterator>
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
	{
	for (; __nb < __ne; ++__nb, ++__s)
	__s = __nb;
	return __s;
	}
	};

	template <>
	struct __widen_from_utf8<16>
	: public codecvt<char16_t, char, mbstate_t>
	{
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	__widen_from_utf8() : codecvt<char16_t, char, mbstate_t>(1) {}

	~__widen_from_utf8();

	template <class _OutputIterator>
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
	{
	result __r = ok;
	mbstate_t __mb;
	while (__nb < __ne && __r != error)
	{
	const int __sz = 32;
	char16_t __buf[__sz];
	char16_t* __bn;
	const char* __nn = __nb;
	__r = do_in(__mb, __nb, __ne - __nb > __sz ? __nb+__sz : __ne, __nn,
	__buf, __buf+__sz, __bn);
	if (__r == codecvt_base::error \|\| __nn == __nb)
	__throw_runtime_error("locale not supported");
	for (const char16_t* __p = __buf; __p < __bn; ++__p, ++__s)
	__s = (wchar_t)__p;
	__nb = __nn;
	}
	return __s;
	}
	};

	template <>
	struct __widen_from_utf8<32>
	: public codecvt<char32_t, char, mbstate_t>
	{
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	__widen_from_utf8() : codecvt<char32_t, char, mbstate_t>(1) {}

	~__widen_from_utf8();

	template <class _OutputIterator>
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
	{
	result __r = ok;
	mbstate_t __mb;
	while (__nb < __ne && __r != error)
	{
	const int __sz = 32;
	char32_t __buf[__sz];
	char32_t* __bn;
	const char* __nn = __nb;
	__r = do_in(__mb, __nb, __ne - __nb > __sz ? __nb+__sz : __ne, __nn,
	__buf, __buf+__sz, __bn);
	if (__r == codecvt_base::error \|\| __nn == __nb)
	__throw_runtime_error("locale not supported");
	for (const char32_t* __p = __buf; __p < __bn; ++__p, ++__s)
	__s = (wchar_t)__p;
	__nb = __nn;
	}
	return __s;
	}
	};

	// template <class charT> class numpunct

	template <class _CharT> class _LIBCPP_TEMPLATE_VIS numpunct;

	template <>
	class _LIBCPP_TYPE_VIS numpunct<char>
	: public locale::facet
	{
	public:
	typedef char char_type;
	typedef basic_string<char_type> string_type;

	explicit numpunct(size_t __refs = 0);

	- _LIBCPP_ALWAYS_INLINE char_type decimal_point() const {return do_decimal_point();}
	- _LIBCPP_ALWAYS_INLINE char_type thousands_sep() const {return do_thousands_sep();}
	- _LIBCPP_ALWAYS_INLINE string grouping() const {return do_grouping();}
	- _LIBCPP_ALWAYS_INLINE string_type truename() const {return do_truename();}
	- _LIBCPP_ALWAYS_INLINE string_type falsename() const {return do_falsename();}
	+ _LIBCPP_INLINE_VISIBILITY char_type decimal_point() const {return do_decimal_point();}
	+ _LIBCPP_INLINE_VISIBILITY char_type thousands_sep() const {return do_thousands_sep();}
	+ _LIBCPP_INLINE_VISIBILITY string grouping() const {return do_grouping();}
	+ _LIBCPP_INLINE_VISIBILITY string_type truename() const {return do_truename();}
	+ _LIBCPP_INLINE_VISIBILITY string_type falsename() const {return do_falsename();}

	static locale::id id;

	protected:
	~numpunct();
	virtual char_type do_decimal_point() const;
	virtual char_type do_thousands_sep() const;
	virtual string do_grouping() const;
	virtual string_type do_truename() const;
	virtual string_type do_falsename() const;

	char_type __decimal_point_;
	char_type __thousands_sep_;
	string __grouping_;
	};

	template <>
	class _LIBCPP_TYPE_VIS numpunct<wchar_t>
	: public locale::facet
	{
	public:
	typedef wchar_t char_type;
	typedef basic_string<char_type> string_type;

	explicit numpunct(size_t __refs = 0);

	- _LIBCPP_ALWAYS_INLINE char_type decimal_point() const {return do_decimal_point();}
	- _LIBCPP_ALWAYS_INLINE char_type thousands_sep() const {return do_thousands_sep();}
	- _LIBCPP_ALWAYS_INLINE string grouping() const {return do_grouping();}
	- _LIBCPP_ALWAYS_INLINE string_type truename() const {return do_truename();}
	- _LIBCPP_ALWAYS_INLINE string_type falsename() const {return do_falsename();}
	+ _LIBCPP_INLINE_VISIBILITY char_type decimal_point() const {return do_decimal_point();}
	+ _LIBCPP_INLINE_VISIBILITY char_type thousands_sep() const {return do_thousands_sep();}
	+ _LIBCPP_INLINE_VISIBILITY string grouping() const {return do_grouping();}
	+ _LIBCPP_INLINE_VISIBILITY string_type truename() const {return do_truename();}
	+ _LIBCPP_INLINE_VISIBILITY string_type falsename() const {return do_falsename();}

	static locale::id id;

	protected:
	~numpunct();
	virtual char_type do_decimal_point() const;
	virtual char_type do_thousands_sep() const;
	virtual string do_grouping() const;
	virtual string_type do_truename() const;
	virtual string_type do_falsename() const;

	char_type __decimal_point_;
	char_type __thousands_sep_;
	string __grouping_;
	};

	// template <class charT> class numpunct_byname

	template <class _CharT> class _LIBCPP_TEMPLATE_VIS numpunct_byname;

	template <>
	class _LIBCPP_TYPE_VIS numpunct_byname<char>
	: public numpunct<char>
	{
	public:
	typedef char char_type;
	typedef basic_string<char_type> string_type;

	explicit numpunct_byname(const char* __nm, size_t __refs = 0);
	explicit numpunct_byname(const string& __nm, size_t __refs = 0);

	protected:
	~numpunct_byname();

	private:
	void __init(const char*);
	};

	template <>
	class _LIBCPP_TYPE_VIS numpunct_byname<wchar_t>
	: public numpunct<wchar_t>
	{
	public:
	typedef wchar_t char_type;
	typedef basic_string<char_type> string_type;

	explicit numpunct_byname(const char* __nm, size_t __refs = 0);
	explicit numpunct_byname(const string& __nm, size_t __refs = 0);

	protected:
	~numpunct_byname();

	private:
	void __init(const char*);
	};

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP___LOCALE
	Index: projects/clang700-import/contrib/libc++/include/__nullptr
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/__nullptr (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/__nullptr (revision 337135)
	@@ -1,62 +1,62 @@
	// -- C++ --
	//===--------------------------- __nullptr --------------------------------===//
	//
	// 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_NULLPTR
	#define _LIBCPP_NULLPTR

	#include <__config>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	#ifdef _LIBCPP_HAS_NO_NULLPTR

	_LIBCPP_BEGIN_NAMESPACE_STD

	struct _LIBCPP_TEMPLATE_VIS nullptr_t
	{
	void* __lx;

	struct __nat {int __for_bool_;};

	- _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR nullptr_t() : __lx(0) {}
	- _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR nullptr_t(int __nat::*) : __lx(0) {}
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR nullptr_t() : __lx(0) {}
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR nullptr_t(int __nat::*) : __lx(0) {}

	- _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR operator int __nat::*() const {return 0;}
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR operator int __nat::*() const {return 0;}

	template <class _Tp>
	- _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	operator _Tp* () const {return 0;}

	template <class _Tp, class _Up>
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	operator _Tp _Up::* () const {return 0;}

	- friend _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR bool operator==(nullptr_t, nullptr_t) {return true;}
	- friend _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR bool operator!=(nullptr_t, nullptr_t) {return false;}
	+ friend _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR bool operator==(nullptr_t, nullptr_t) {return true;}
	+ friend _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR bool operator!=(nullptr_t, nullptr_t) {return false;}
	};

	-inline _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR nullptr_t __get_nullptr_t() {return nullptr_t(0);}
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR nullptr_t __get_nullptr_t() {return nullptr_t(0);}

	#define nullptr _VSTD::__get_nullptr_t()

	_LIBCPP_END_NAMESPACE_STD

	#else // _LIBCPP_HAS_NO_NULLPTR

	namespace std
	{
	typedef decltype(nullptr) nullptr_t;
	}

	#endif // _LIBCPP_HAS_NO_NULLPTR

	#endif // _LIBCPP_NULLPTR
	Index: projects/clang700-import/contrib/libc++/include/__sso_allocator
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/__sso_allocator (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/__sso_allocator (revision 337135)
	@@ -1,77 +1,77 @@
	// -- 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.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP___SSO_ALLOCATOR
	#define _LIBCPP___SSO_ALLOCATOR

	#include <__config>
	#include <type_traits>
	#include <new>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _Tp, size_t _Np> class _LIBCPP_HIDDEN __sso_allocator;

	template <size_t _Np>
	class _LIBCPP_HIDDEN __sso_allocator<void, _Np>
	{
	public:
	typedef const void* const_pointer;
	typedef void value_type;
	};

	template <class _Tp, size_t _Np>
	class _LIBCPP_HIDDEN __sso_allocator
	{
	typename aligned_storage<sizeof(_Tp) * _Np>::type buf_;
	bool __allocated_;
	public:
	typedef size_t size_type;
	typedef _Tp* pointer;
	typedef _Tp value_type;

	_LIBCPP_INLINE_VISIBILITY __sso_allocator() throw() : __allocated_(false) {}
	_LIBCPP_INLINE_VISIBILITY __sso_allocator(const __sso_allocator&) throw() : __allocated_(false) {}
	template <class _Up> _LIBCPP_INLINE_VISIBILITY __sso_allocator(const __sso_allocator<_Up, _Np>&) throw()
	: __allocated_(false) {}
	private:
	__sso_allocator& operator=(const __sso_allocator&);
	public:
	_LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, typename __sso_allocator<void, _Np>::const_pointer = 0)
	{
	if (!__allocated_ && __n <= _Np)
	{
	__allocated_ = true;
	return (pointer)&buf_;
	}
	- return static_cast<pointer>(_VSTD::__allocate(__n * sizeof(_Tp)));
	+ return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp)));
	}
	_LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type)
	{
	if (__p == (pointer)&buf_)
	__allocated_ = false;
	else
	- _VSTD::__libcpp_deallocate(__p);
	+ _VSTD::__libcpp_deallocate(__p, __alignof(_Tp));
	}
	_LIBCPP_INLINE_VISIBILITY size_type max_size() const throw() {return size_type(~0) / sizeof(_Tp);}

	_LIBCPP_INLINE_VISIBILITY
	bool operator==(__sso_allocator& __a) const {return &buf_ == &__a.buf_;}
	_LIBCPP_INLINE_VISIBILITY
	bool operator!=(__sso_allocator& __a) const {return &buf_ != &__a.buf_;}
	};

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP___SSO_ALLOCATOR
	Index: projects/clang700-import/contrib/libc++/include/__string
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/__string (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/__string (revision 337135)
	@@ -1,877 +1,877 @@
	// -- C++ --
	//===-------------------------- __string ----------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP___STRING
	#define _LIBCPP___STRING

	/*
	string synopsis

	namespace std
	{

	template <class charT>
	struct char_traits
	{
	typedef charT char_type;
	typedef ... int_type;
	typedef streamoff off_type;
	typedef streampos pos_type;
	typedef mbstate_t state_type;

	static constexpr void assign(char_type& c1, const char_type& c2) noexcept;
	static constexpr bool eq(char_type c1, char_type c2) noexcept;
	static constexpr bool lt(char_type c1, char_type c2) noexcept;

	static constexpr int compare(const char_type* s1, const char_type* s2, size_t n);
	static constexpr size_t length(const char_type* s);
	static constexpr const char_type*
	find(const char_type* s, size_t n, const char_type& a);
	static char_type* move(char_type* s1, const char_type* s2, size_t n);
	static char_type* copy(char_type* s1, const char_type* s2, size_t n);
	static char_type* assign(char_type* s, size_t n, char_type a);

	static constexpr int_type not_eof(int_type c) noexcept;
	static constexpr char_type to_char_type(int_type c) noexcept;
	static constexpr int_type to_int_type(char_type c) noexcept;
	static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept;
	static constexpr int_type eof() noexcept;
	};

	template <> struct char_traits<char>;
	template <> struct char_traits<wchar_t>;

	} // std

	*/

	#include <__config>
	#include <algorithm> // for search and min
	#include <cstdio> // For EOF.
	#include <memory> // for __murmur2_or_cityhash

	#include <__debug>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_STD

	// char_traits

	template <class _CharT>
	struct _LIBCPP_TEMPLATE_VIS char_traits
	{
	typedef _CharT char_type;
	typedef int int_type;
	typedef streamoff off_type;
	typedef streampos pos_type;
	typedef mbstate_t state_type;

	static inline void _LIBCPP_CONSTEXPR_AFTER_CXX14
	assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
	static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
	{return __c1 == __c2;}
	static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
	{return __c1 < __c2;}

	static _LIBCPP_CONSTEXPR_AFTER_CXX14
	int compare(const char_type* __s1, const char_type* __s2, size_t __n);
	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
	size_t length(const char_type* __s);
	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
	const char_type* find(const char_type* __s, size_t __n, const char_type& __a);
	static char_type* move(char_type* __s1, const char_type* __s2, size_t __n);
	_LIBCPP_INLINE_VISIBILITY
	static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n);
	_LIBCPP_INLINE_VISIBILITY
	static char_type* assign(char_type* __s, size_t __n, char_type __a);

	static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
	{return eq_int_type(__c, eof()) ? ~eof() : __c;}
	static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
	{return char_type(__c);}
	static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
	{return int_type(__c);}
	static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
	{return __c1 == __c2;}
	static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
	{return int_type(EOF);}
	};

	template <class _CharT>
	_LIBCPP_CONSTEXPR_AFTER_CXX14 int
	char_traits<_CharT>::compare(const char_type* __s1, const char_type* __s2, size_t __n)
	{
	for (; __n; --__n, ++__s1, ++__s2)
	{
	if (lt(__s1, __s2))
	return -1;
	if (lt(__s2, __s1))
	return 1;
	}
	return 0;
	}

	template <class _CharT>
	inline
	_LIBCPP_CONSTEXPR_AFTER_CXX14 size_t
	char_traits<_CharT>::length(const char_type* __s)
	{
	size_t __len = 0;
	for (; !eq(*__s, char_type(0)); ++__s)
	++__len;
	return __len;
	}

	template <class _CharT>
	inline
	_LIBCPP_CONSTEXPR_AFTER_CXX14 const _CharT*
	char_traits<_CharT>::find(const char_type* __s, size_t __n, const char_type& __a)
	{
	for (; __n; --__n)
	{
	if (eq(*__s, __a))
	return __s;
	++__s;
	}
	return 0;
	}

	template <class _CharT>
	_CharT*
	char_traits<_CharT>::move(char_type* __s1, const char_type* __s2, size_t __n)
	{
	char_type* __r = __s1;
	if (__s1 < __s2)
	{
	for (; __n; --__n, ++__s1, ++__s2)
	assign(__s1, __s2);
	}
	else if (__s2 < __s1)
	{
	__s1 += __n;
	__s2 += __n;
	for (; __n; --__n)
	assign(--__s1, --__s2);
	}
	return __r;
	}

	template <class _CharT>
	inline
	_CharT*
	char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n)
	{
	_LIBCPP_ASSERT(__s2 < __s1 \|\| __s2 >= __s1+__n, "char_traits::copy overlapped range");
	char_type* __r = __s1;
	for (; __n; --__n, ++__s1, ++__s2)
	assign(__s1, __s2);
	return __r;
	}

	template <class _CharT>
	inline
	_CharT*
	char_traits<_CharT>::assign(char_type* __s, size_t __n, char_type __a)
	{
	char_type* __r = __s;
	for (; __n; --__n, ++__s)
	assign(*__s, __a);
	return __r;
	}

	// char_traits<char>

	template <>
	struct _LIBCPP_TEMPLATE_VIS char_traits<char>
	{
	typedef char char_type;
	typedef int int_type;
	typedef streamoff off_type;
	typedef streampos pos_type;
	typedef mbstate_t state_type;

	static inline _LIBCPP_CONSTEXPR_AFTER_CXX14
	void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
	static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
	{return __c1 == __c2;}
	static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
	{return (unsigned char)__c1 < (unsigned char)__c2;}

	static _LIBCPP_CONSTEXPR_AFTER_CXX14
	int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
	static inline size_t _LIBCPP_CONSTEXPR_AFTER_CXX14
	length(const char_type* __s) _NOEXCEPT {return __builtin_strlen(__s);}
	static _LIBCPP_CONSTEXPR_AFTER_CXX14
	const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
	static inline char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
	{return __n == 0 ? __s1 : (char_type*) memmove(__s1, __s2, __n);}
	static inline char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
	{
	_LIBCPP_ASSERT(__s2 < __s1 \|\| __s2 >= __s1+__n, "char_traits::copy overlapped range");
	return __n == 0 ? __s1 : (char_type*)memcpy(__s1, __s2, __n);
	}
	static inline char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
	{return __n == 0 ? __s : (char_type*)memset(__s, to_int_type(__a), __n);}

	static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
	{return eq_int_type(__c, eof()) ? ~eof() : __c;}
	static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
	{return char_type(__c);}
	static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
	{return int_type((unsigned char)__c);}
	static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
	{return __c1 == __c2;}
	static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
	{return int_type(EOF);}
	};

	inline _LIBCPP_CONSTEXPR_AFTER_CXX14
	int
	char_traits<char>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
	{
	if (__n == 0)
	return 0;
	#if __has_feature(cxx_constexpr_string_builtins)
	return __builtin_memcmp(__s1, __s2, __n);
	#elif _LIBCPP_STD_VER <= 14
	return memcmp(__s1, __s2, __n);
	#else
	for (; __n; --__n, ++__s1, ++__s2)
	{
	if (lt(__s1, __s2))
	return -1;
	if (lt(__s2, __s1))
	return 1;
	}
	return 0;
	#endif
	}

	inline _LIBCPP_CONSTEXPR_AFTER_CXX14
	const char*
	char_traits<char>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
	{
	if (__n == 0)
	- return NULL;
	+ return nullptr;
	#if __has_feature(cxx_constexpr_string_builtins)
	return __builtin_char_memchr(__s, to_int_type(__a), __n);
	#elif _LIBCPP_STD_VER <= 14
	return (const char_type*) memchr(__s, to_int_type(__a), __n);
	#else
	for (; __n; --__n)
	{
	if (eq(*__s, __a))
	return __s;
	++__s;
	}
	- return NULL;
	+ return nullptr;
	#endif
	}


	// char_traits<wchar_t>

	template <>
	struct _LIBCPP_TEMPLATE_VIS char_traits<wchar_t>
	{
	typedef wchar_t char_type;
	typedef wint_t int_type;
	typedef streamoff off_type;
	typedef streampos pos_type;
	typedef mbstate_t state_type;

	static inline _LIBCPP_CONSTEXPR_AFTER_CXX14
	void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
	static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
	{return __c1 == __c2;}
	static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
	{return __c1 < __c2;}

	static _LIBCPP_CONSTEXPR_AFTER_CXX14
	int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
	static _LIBCPP_CONSTEXPR_AFTER_CXX14
	size_t length(const char_type* __s) _NOEXCEPT;
	static _LIBCPP_CONSTEXPR_AFTER_CXX14
	const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
	static inline char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
	{return __n == 0 ? __s1 : (char_type*)wmemmove(__s1, __s2, __n);}
	static inline char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
	{
	_LIBCPP_ASSERT(__s2 < __s1 \|\| __s2 >= __s1+__n, "char_traits::copy overlapped range");
	return __n == 0 ? __s1 : (char_type*)wmemcpy(__s1, __s2, __n);
	}
	static inline char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
	{return __n == 0 ? __s : (char_type*)wmemset(__s, __a, __n);}

	static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
	{return eq_int_type(__c, eof()) ? ~eof() : __c;}
	static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
	{return char_type(__c);}
	static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
	{return int_type(__c);}
	static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
	{return __c1 == __c2;}
	static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
	{return int_type(WEOF);}
	};

	inline _LIBCPP_CONSTEXPR_AFTER_CXX14
	int
	char_traits<wchar_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
	{
	if (__n == 0)
	return 0;
	#if __has_feature(cxx_constexpr_string_builtins)
	return __builtin_wmemcmp(__s1, __s2, __n);
	#elif _LIBCPP_STD_VER <= 14
	return wmemcmp(__s1, __s2, __n);
	#else
	for (; __n; --__n, ++__s1, ++__s2)
	{
	if (lt(__s1, __s2))
	return -1;
	if (lt(__s2, __s1))
	return 1;
	}
	return 0;
	#endif
	}

	inline _LIBCPP_CONSTEXPR_AFTER_CXX14
	size_t
	char_traits<wchar_t>::length(const char_type* __s) _NOEXCEPT
	{
	#if __has_feature(cxx_constexpr_string_builtins)
	return __builtin_wcslen(__s);
	#elif _LIBCPP_STD_VER <= 14
	return wcslen(__s);
	#else
	size_t __len = 0;
	for (; !eq(*__s, char_type(0)); ++__s)
	++__len;
	return __len;
	#endif
	}

	inline _LIBCPP_CONSTEXPR_AFTER_CXX14
	const wchar_t*
	char_traits<wchar_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
	{
	if (__n == 0)
	- return NULL;
	+ return nullptr;
	#if __has_feature(cxx_constexpr_string_builtins)
	- return __builtin_wmemchr(__s, __a, __n);
	+ return __builtin_wmemchr(__s, __a, __n);
	#elif _LIBCPP_STD_VER <= 14
	return wmemchr(__s, __a, __n);
	#else
	for (; __n; --__n)
	{
	if (eq(*__s, __a))
	return __s;
	++__s;
	}
	- return NULL;
	+ return nullptr;
	#endif
	}


	#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS

	template <>
	struct _LIBCPP_TEMPLATE_VIS char_traits<char16_t>
	{
	typedef char16_t char_type;
	typedef uint_least16_t int_type;
	typedef streamoff off_type;
	typedef u16streampos pos_type;
	typedef mbstate_t state_type;

	static inline _LIBCPP_CONSTEXPR_AFTER_CXX14
	void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
	static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
	{return __c1 == __c2;}
	static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
	{return __c1 < __c2;}

	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
	int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
	size_t length(const char_type* __s) _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
	const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	static char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT;

	static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
	{return eq_int_type(__c, eof()) ? ~eof() : __c;}
	static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
	{return char_type(__c);}
	static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
	{return int_type(__c);}
	static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
	{return __c1 == __c2;}
	static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
	{return int_type(0xFFFF);}
	};

	inline _LIBCPP_CONSTEXPR_AFTER_CXX14
	int
	char_traits<char16_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
	{
	for (; __n; --__n, ++__s1, ++__s2)
	{
	if (lt(__s1, __s2))
	return -1;
	if (lt(__s2, __s1))
	return 1;
	}
	return 0;
	}

	inline _LIBCPP_CONSTEXPR_AFTER_CXX14
	size_t
	char_traits<char16_t>::length(const char_type* __s) _NOEXCEPT
	{
	size_t __len = 0;
	for (; !eq(*__s, char_type(0)); ++__s)
	++__len;
	return __len;
	}

	inline _LIBCPP_CONSTEXPR_AFTER_CXX14
	const char16_t*
	char_traits<char16_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
	{
	for (; __n; --__n)
	{
	if (eq(*__s, __a))
	return __s;
	++__s;
	}
	return 0;
	}

	inline
	char16_t*
	char_traits<char16_t>::move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
	{
	char_type* __r = __s1;
	if (__s1 < __s2)
	{
	for (; __n; --__n, ++__s1, ++__s2)
	assign(__s1, __s2);
	}
	else if (__s2 < __s1)
	{
	__s1 += __n;
	__s2 += __n;
	for (; __n; --__n)
	assign(--__s1, --__s2);
	}
	return __r;
	}

	inline
	char16_t*
	char_traits<char16_t>::copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
	{
	_LIBCPP_ASSERT(__s2 < __s1 \|\| __s2 >= __s1+__n, "char_traits::copy overlapped range");
	char_type* __r = __s1;
	for (; __n; --__n, ++__s1, ++__s2)
	assign(__s1, __s2);
	return __r;
	}

	inline
	char16_t*
	char_traits<char16_t>::assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
	{
	char_type* __r = __s;
	for (; __n; --__n, ++__s)
	assign(*__s, __a);
	return __r;
	}

	template <>
	struct _LIBCPP_TEMPLATE_VIS char_traits<char32_t>
	{
	typedef char32_t char_type;
	typedef uint_least32_t int_type;
	typedef streamoff off_type;
	typedef u32streampos pos_type;
	typedef mbstate_t state_type;

	static inline _LIBCPP_CONSTEXPR_AFTER_CXX14
	void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
	static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
	{return __c1 == __c2;}
	static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
	{return __c1 < __c2;}

	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
	int compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
	size_t length(const char_type* __s) _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_AFTER_CXX14
	const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	static char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT;

	static inline _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
	{return eq_int_type(__c, eof()) ? ~eof() : __c;}
	static inline _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
	{return char_type(__c);}
	static inline _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
	{return int_type(__c);}
	static inline _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
	{return __c1 == __c2;}
	static inline _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
	{return int_type(0xFFFFFFFF);}
	};

	inline _LIBCPP_CONSTEXPR_AFTER_CXX14
	int
	char_traits<char32_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
	{
	for (; __n; --__n, ++__s1, ++__s2)
	{
	if (lt(__s1, __s2))
	return -1;
	if (lt(__s2, __s1))
	return 1;
	}
	return 0;
	}

	inline _LIBCPP_CONSTEXPR_AFTER_CXX14
	size_t
	char_traits<char32_t>::length(const char_type* __s) _NOEXCEPT
	{
	size_t __len = 0;
	for (; !eq(*__s, char_type(0)); ++__s)
	++__len;
	return __len;
	}

	inline _LIBCPP_CONSTEXPR_AFTER_CXX14
	const char32_t*
	char_traits<char32_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
	{
	for (; __n; --__n)
	{
	if (eq(*__s, __a))
	return __s;
	++__s;
	}
	return 0;
	}

	inline
	char32_t*
	char_traits<char32_t>::move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
	{
	char_type* __r = __s1;
	if (__s1 < __s2)
	{
	for (; __n; --__n, ++__s1, ++__s2)
	assign(__s1, __s2);
	}
	else if (__s2 < __s1)
	{
	__s1 += __n;
	__s2 += __n;
	for (; __n; --__n)
	assign(--__s1, --__s2);
	}
	return __r;
	}

	inline
	char32_t*
	char_traits<char32_t>::copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
	{
	_LIBCPP_ASSERT(__s2 < __s1 \|\| __s2 >= __s1+__n, "char_traits::copy overlapped range");
	char_type* __r = __s1;
	for (; __n; --__n, ++__s1, ++__s2)
	assign(__s1, __s2);
	return __r;
	}

	inline
	char32_t*
	char_traits<char32_t>::assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
	{
	char_type* __r = __s;
	for (; __n; --__n, ++__s)
	assign(*__s, __a);
	return __r;
	}

	#endif // _LIBCPP_HAS_NO_UNICODE_CHARS

	// helper fns for basic_string and string_view

	// __str_find
	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	__str_find(const _CharT *__p, _SizeT __sz,
	_CharT __c, _SizeT __pos) _NOEXCEPT
	{
	if (__pos >= __sz)
	return __npos;
	const _CharT* __r = _Traits::find(__p + __pos, __sz - __pos, __c);
	if (__r == 0)
	return __npos;
	return static_cast<_SizeT>(__r - __p);
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_CONSTEXPR_AFTER_CXX11 const _CharT *
	__search_substring(const _CharT __first1, const _CharT __last1,
	const _CharT __first2, const _CharT __last2) {
	// Take advantage of knowing source and pattern lengths.
	// Stop short when source is smaller than pattern.
	const ptrdiff_t __len2 = __last2 - __first2;
	if (__len2 == 0)
	return __first1;

	ptrdiff_t __len1 = __last1 - __first1;
	if (__len1 < __len2)
	return __last1;

	// First element of __first2 is loop invariant.
	_CharT __f2 = *__first2;
	while (true) {
	__len1 = __last1 - __first1;
	// Check whether __first1 still has at least __len2 bytes.
	if (__len1 < __len2)
	return __last1;

	// Find __f2 the first byte matching in __first1.
	__first1 = _Traits::find(__first1, __len1 - __len2 + 1, __f2);
	if (__first1 == 0)
	return __last1;

	// It is faster to compare from the first byte of __first1 even if we
	// already know that it matches the first byte of __first2: this is because
	// __first2 is most likely aligned, as it is user's "pattern" string, and
	// __first1 + 1 is most likely not aligned, as the match is in the middle of
	// the string.
	if (_Traits::compare(__first1, __first2, __len2) == 0)
	return __first1;

	++__first1;
	}
	}

	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	__str_find(const _CharT *__p, _SizeT __sz,
	const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
	{
	if (__pos > __sz)
	return __npos;

	if (__n == 0) // There is nothing to search, just return __pos.
	return __pos;

	const _CharT *__r = __search_substring<_CharT, _Traits>(
	__p + __pos, __p + __sz, __s, __s + __n);

	if (__r == __p + __sz)
	return __npos;
	return static_cast<_SizeT>(__r - __p);
	}


	// __str_rfind

	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	__str_rfind(const _CharT *__p, _SizeT __sz,
	_CharT __c, _SizeT __pos) _NOEXCEPT
	{
	if (__sz < 1)
	return __npos;
	if (__pos < __sz)
	++__pos;
	else
	__pos = __sz;
	for (const _CharT* __ps = __p + __pos; __ps != __p;)
	{
	if (_Traits::eq(*--__ps, __c))
	return static_cast<_SizeT>(__ps - __p);
	}
	return __npos;
	}

	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	__str_rfind(const _CharT *__p, _SizeT __sz,
	const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
	{
	__pos = _VSTD::min(__pos, __sz);
	if (__n < __sz - __pos)
	__pos += __n;
	else
	__pos = __sz;
	const _CharT* __r = _VSTD::__find_end(
	__p, __p + __pos, __s, __s + __n, _Traits::eq,
	random_access_iterator_tag(), random_access_iterator_tag());
	if (__n > 0 && __r == __p + __pos)
	return __npos;
	return static_cast<_SizeT>(__r - __p);
	}

	// __str_find_first_of
	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	__str_find_first_of(const _CharT *__p, _SizeT __sz,
	const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
	{
	if (__pos >= __sz \|\| __n == 0)
	return __npos;
	const _CharT* __r = _VSTD::__find_first_of_ce
	(__p + __pos, __p + __sz, __s, __s + __n, _Traits::eq );
	if (__r == __p + __sz)
	return __npos;
	return static_cast<_SizeT>(__r - __p);
	}


	// __str_find_last_of
	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	__str_find_last_of(const _CharT *__p, _SizeT __sz,
	const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
	{
	if (__n != 0)
	{
	if (__pos < __sz)
	++__pos;
	else
	__pos = __sz;
	for (const _CharT* __ps = __p + __pos; __ps != __p;)
	{
	const _CharT* __r = _Traits::find(__s, __n, *--__ps);
	if (__r)
	return static_cast<_SizeT>(__ps - __p);
	}
	}
	return __npos;
	}


	// __str_find_first_not_of
	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	__str_find_first_not_of(const _CharT *__p, _SizeT __sz,
	const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
	{
	if (__pos < __sz)
	{
	const _CharT* __pe = __p + __sz;
	for (const _CharT* __ps = __p + __pos; __ps != __pe; ++__ps)
	if (_Traits::find(__s, __n, *__ps) == 0)
	return static_cast<_SizeT>(__ps - __p);
	}
	return __npos;
	}


	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	__str_find_first_not_of(const _CharT *__p, _SizeT __sz,
	_CharT __c, _SizeT __pos) _NOEXCEPT
	{
	if (__pos < __sz)
	{
	const _CharT* __pe = __p + __sz;
	for (const _CharT* __ps = __p + __pos; __ps != __pe; ++__ps)
	if (!_Traits::eq(*__ps, __c))
	return static_cast<_SizeT>(__ps - __p);
	}
	return __npos;
	}


	// __str_find_last_not_of
	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	__str_find_last_not_of(const _CharT *__p, _SizeT __sz,
	const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
	{
	if (__pos < __sz)
	++__pos;
	else
	__pos = __sz;
	for (const _CharT* __ps = __p + __pos; __ps != __p;)
	if (_Traits::find(__s, __n, *--__ps) == 0)
	return static_cast<_SizeT>(__ps - __p);
	return __npos;
	}


	template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
	inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	__str_find_last_not_of(const _CharT *__p, _SizeT __sz,
	_CharT __c, _SizeT __pos) _NOEXCEPT
	{
	if (__pos < __sz)
	++__pos;
	else
	__pos = __sz;
	for (const _CharT* __ps = __p + __pos; __ps != __p;)
	if (!_Traits::eq(*--__ps, __c))
	return static_cast<_SizeT>(__ps - __p);
	return __npos;
	}

	template<class _Ptr>
	inline _LIBCPP_INLINE_VISIBILITY
	size_t __do_string_hash(_Ptr __p, _Ptr __e)
	{
	typedef typename iterator_traits<_Ptr>::value_type value_type;
	return __murmur2_or_cityhash<size_t>()(__p, (__e-__p)*sizeof(value_type));
	}

	template <class _CharT, class _Iter, class _Traits=char_traits<_CharT> >
	struct __quoted_output_proxy
	{
	_Iter __first;
	_Iter __last;
	_CharT __delim;
	_CharT __escape;

	__quoted_output_proxy(_Iter __f, _Iter __l, _CharT __d, _CharT __e)
	: __first(__f), __last(__l), __delim(__d), __escape(__e) {}
	// This would be a nice place for a string_ref
	};

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP___STRING
	Index: projects/clang700-import/contrib/libc++/include/__threading_support
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/__threading_support (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/__threading_support (revision 337135)
	@@ -1,639 +1,402 @@
	// -- 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.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP_THREADING_SUPPORT
	#define _LIBCPP_THREADING_SUPPORT

	#include <__config>
	#include <chrono>
	#include <errno.h>

	#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
	#pragma GCC system_header
	#endif

	#if defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
	# include <__external_threading>
	#elif !defined(_LIBCPP_HAS_NO_THREADS)

	#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
	# include <pthread.h>
	# include <sched.h>
	-#elif defined(_LIBCPP_HAS_THREAD_API_WIN32)
	-#include <windows.h>
	-#include <process.h>
	-#include <fibersapi.h>
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>

	-
	#if defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) \|\| \
	- defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL)
	+ defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL) \|\| \
	+ defined(_LIBCPP_HAS_THREAD_API_WIN32)
	#define _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_FUNC_VIS
	#else
	#define _LIBCPP_THREAD_ABI_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
	#endif

	#if defined(__FreeBSD__) && defined(__clang__) && __has_attribute(no_thread_safety_analysis)
	#define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS __attribute__((no_thread_safety_analysis))
	#else
	#define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
	// Mutex
	typedef pthread_mutex_t __libcpp_mutex_t;
	#define _LIBCPP_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER

	typedef pthread_mutex_t __libcpp_recursive_mutex_t;

	// Condition Variable
	typedef pthread_cond_t __libcpp_condvar_t;
	#define _LIBCPP_CONDVAR_INITIALIZER PTHREAD_COND_INITIALIZER

	// Execute once
	typedef pthread_once_t __libcpp_exec_once_flag;
	#define _LIBCPP_EXEC_ONCE_INITIALIZER PTHREAD_ONCE_INIT

	// Thread id
	typedef pthread_t __libcpp_thread_id;

	// Thread
	#define _LIBCPP_NULL_THREAD 0U

	typedef pthread_t __libcpp_thread_t;

	// Thrad Local Storage
	typedef pthread_key_t __libcpp_tls_key;

	#define _LIBCPP_TLS_DESTRUCTOR_CC
	#else
	// Mutex
	-typedef SRWLOCK __libcpp_mutex_t;
	-#define _LIBCPP_MUTEX_INITIALIZER SRWLOCK_INIT
	+typedef void* __libcpp_mutex_t;
	+#define _LIBCPP_MUTEX_INITIALIZER 0

	-typedef CRITICAL_SECTION __libcpp_recursive_mutex_t;
	+#if defined(_M_IX86) \|\| defined(__i386__) \|\| defined(_M_ARM) \|\| defined(__arm__)
	+typedef void* __libcpp_recursive_mutex_t[6];
	+#elif defined(_M_AMD64) \|\| defined(__x86_64__) \|\| defined(_M_ARM64) \|\| defined(__aarch64__)
	+typedef void* __libcpp_recursive_mutex_t[5];
	+#else
	+# error Unsupported architecture
	+#endif

	// Condition Variable
	-typedef CONDITION_VARIABLE __libcpp_condvar_t;
	-#define _LIBCPP_CONDVAR_INITIALIZER CONDITION_VARIABLE_INIT
	+typedef void* __libcpp_condvar_t;
	+#define _LIBCPP_CONDVAR_INITIALIZER 0

	// Execute Once
	-typedef INIT_ONCE __libcpp_exec_once_flag;
	-#define _LIBCPP_EXEC_ONCE_INITIALIZER INIT_ONCE_STATIC_INIT
	+typedef void* __libcpp_exec_once_flag;
	+#define _LIBCPP_EXEC_ONCE_INITIALIZER 0

	// Thread ID
	-typedef DWORD __libcpp_thread_id;
	+typedef long __libcpp_thread_id;

	// Thread
	#define _LIBCPP_NULL_THREAD 0U

	-typedef HANDLE __libcpp_thread_t;
	+typedef void* __libcpp_thread_t;

	// Thread Local Storage
	-typedef DWORD __libcpp_tls_key;
	+typedef long __libcpp_tls_key;

	-#define _LIBCPP_TLS_DESTRUCTOR_CC WINAPI
	+#define _LIBCPP_TLS_DESTRUCTOR_CC __stdcall
	#endif

	// Mutex
	_LIBCPP_THREAD_ABI_VISIBILITY
	int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m);

	_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
	int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m);

	_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
	bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m);

	_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
	int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m);

	_LIBCPP_THREAD_ABI_VISIBILITY
	int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m);

	_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
	int __libcpp_mutex_lock(__libcpp_mutex_t *__m);

	_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
	bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m);

	_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
	int __libcpp_mutex_unlock(__libcpp_mutex_t *__m);

	_LIBCPP_THREAD_ABI_VISIBILITY
	int __libcpp_mutex_destroy(__libcpp_mutex_t *__m);

	// Condition variable
	_LIBCPP_THREAD_ABI_VISIBILITY
	int __libcpp_condvar_signal(__libcpp_condvar_t* __cv);

	_LIBCPP_THREAD_ABI_VISIBILITY
	int __libcpp_condvar_broadcast(__libcpp_condvar_t* __cv);

	_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
	int __libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m);

	_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
	int __libcpp_condvar_timedwait(__libcpp_condvar_t __cv, __libcpp_mutex_t __m,
	timespec *__ts);

	_LIBCPP_THREAD_ABI_VISIBILITY
	int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv);

	// Execute once
	_LIBCPP_THREAD_ABI_VISIBILITY
	int __libcpp_execute_once(__libcpp_exec_once_flag *flag,
	void (*init_routine)(void));

	// Thread id
	_LIBCPP_THREAD_ABI_VISIBILITY
	bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2);

	_LIBCPP_THREAD_ABI_VISIBILITY
	bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2);

	// Thread
	_LIBCPP_THREAD_ABI_VISIBILITY
	bool __libcpp_thread_isnull(const __libcpp_thread_t *__t);

	_LIBCPP_THREAD_ABI_VISIBILITY
	int __libcpp_thread_create(__libcpp_thread_t __t, void (__func)(void ),
	void *__arg);

	_LIBCPP_THREAD_ABI_VISIBILITY
	__libcpp_thread_id __libcpp_thread_get_current_id();

	_LIBCPP_THREAD_ABI_VISIBILITY
	__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t);

	_LIBCPP_THREAD_ABI_VISIBILITY
	int __libcpp_thread_join(__libcpp_thread_t *__t);

	_LIBCPP_THREAD_ABI_VISIBILITY
	int __libcpp_thread_detach(__libcpp_thread_t *__t);

	_LIBCPP_THREAD_ABI_VISIBILITY
	void __libcpp_thread_yield();

	_LIBCPP_THREAD_ABI_VISIBILITY
	void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns);

	// Thread local storage
	_LIBCPP_THREAD_ABI_VISIBILITY
	int __libcpp_tls_create(__libcpp_tls_key* __key,
	void(_LIBCPP_TLS_DESTRUCTOR_CC* __at_exit)(void*));

	_LIBCPP_THREAD_ABI_VISIBILITY
	void *__libcpp_tls_get(__libcpp_tls_key __key);

	_LIBCPP_THREAD_ABI_VISIBILITY
	int __libcpp_tls_set(__libcpp_tls_key __key, void *__p);

	-#if !defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) \|\| \
	- defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL)
	+#if (!defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) \|\| \
	+ defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL)) && \
	+ defined(_LIBCPP_HAS_THREAD_API_PTHREAD)

	-#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
	-
	int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m)
	{
	pthread_mutexattr_t attr;
	int __ec = pthread_mutexattr_init(&attr);
	if (__ec)
	return __ec;
	__ec = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
	if (__ec) {
	pthread_mutexattr_destroy(&attr);
	return __ec;
	}
	__ec = pthread_mutex_init(__m, &attr);
	if (__ec) {
	pthread_mutexattr_destroy(&attr);
	return __ec;
	}
	__ec = pthread_mutexattr_destroy(&attr);
	if (__ec) {
	pthread_mutex_destroy(__m);
	return __ec;
	}
	return 0;
	}

	int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m)
	{
	return pthread_mutex_lock(__m);
	}

	bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m)
	{
	return pthread_mutex_trylock(__m) == 0;
	}

	int __libcpp_recursive_mutex_unlock(__libcpp_mutex_t *__m)
	{
	return pthread_mutex_unlock(__m);
	}

	int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m)
	{
	return pthread_mutex_destroy(__m);
	}

	int __libcpp_mutex_lock(__libcpp_mutex_t *__m)
	{
	return pthread_mutex_lock(__m);
	}

	bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m)
	{
	return pthread_mutex_trylock(__m) == 0;
	}

	int __libcpp_mutex_unlock(__libcpp_mutex_t *__m)
	{
	return pthread_mutex_unlock(__m);
	}

	int __libcpp_mutex_destroy(__libcpp_mutex_t *__m)
	{
	return pthread_mutex_destroy(__m);
	}

	// Condition Variable
	int __libcpp_condvar_signal(__libcpp_condvar_t *__cv)
	{
	return pthread_cond_signal(__cv);
	}

	int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv)
	{
	return pthread_cond_broadcast(__cv);
	}

	int __libcpp_condvar_wait(__libcpp_condvar_t __cv, __libcpp_mutex_t __m)
	{
	return pthread_cond_wait(__cv, __m);
	}

	int __libcpp_condvar_timedwait(__libcpp_condvar_t __cv, __libcpp_mutex_t __m,
	timespec *__ts)
	{
	return pthread_cond_timedwait(__cv, __m, __ts);
	}

	int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv)
	{
	return pthread_cond_destroy(__cv);
	}

	// Execute once
	int __libcpp_execute_once(__libcpp_exec_once_flag *flag,
	void (*init_routine)(void)) {
	return pthread_once(flag, init_routine);
	}

	// Thread id
	// Returns non-zero if the thread ids are equal, otherwise 0
	bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2)
	{
	return pthread_equal(t1, t2) != 0;
	}

	// Returns non-zero if t1 < t2, otherwise 0
	bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2)
	{
	return t1 < t2;
	}

	// Thread
	bool __libcpp_thread_isnull(const __libcpp_thread_t *__t) {
	return *__t == 0;
	}

	int __libcpp_thread_create(__libcpp_thread_t __t, void (__func)(void ),
	void *__arg)
	{
	return pthread_create(__t, 0, __func, __arg);
	}

	__libcpp_thread_id __libcpp_thread_get_current_id()
	{
	return pthread_self();
	}

	__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t)
	{
	return *__t;
	}

	int __libcpp_thread_join(__libcpp_thread_t *__t)
	{
	return pthread_join(*__t, 0);
	}

	int __libcpp_thread_detach(__libcpp_thread_t *__t)
	{
	return pthread_detach(*__t);
	}

	void __libcpp_thread_yield()
	{
	sched_yield();
	}

	void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns)
	{
	using namespace chrono;
	seconds __s = duration_cast<seconds>(__ns);
	timespec __ts;
	typedef decltype(__ts.tv_sec) ts_sec;
	_LIBCPP_CONSTEXPR ts_sec __ts_sec_max = numeric_limits<ts_sec>::max();

	if (__s.count() < __ts_sec_max)
	{
	__ts.tv_sec = static_cast<ts_sec>(__s.count());
	__ts.tv_nsec = static_cast<decltype(__ts.tv_nsec)>((__ns - __s).count());
	}
	else
	{
	__ts.tv_sec = __ts_sec_max;
	__ts.tv_nsec = 999999999; // (10^9 - 1)
	}

	while (nanosleep(&__ts, &__ts) == -1 && errno == EINTR);
	}

	// Thread local storage
	int __libcpp_tls_create(__libcpp_tls_key __key, void (__at_exit)(void *))
	{
	return pthread_key_create(__key, __at_exit);
	}

	void *__libcpp_tls_get(__libcpp_tls_key __key)
	{
	return pthread_getspecific(__key);
	}

	int __libcpp_tls_set(__libcpp_tls_key __key, void *__p)
	{
	return pthread_setspecific(__key, __p);
	}
	-
	-#elif defined(_LIBCPP_HAS_THREAD_API_WIN32)
	-
	-// Mutex
	-int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m)
	-{
	- InitializeCriticalSection(__m);
	- return 0;
	-}
	-
	-int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m)
	-{
	- EnterCriticalSection(__m);
	- return 0;
	-}
	-
	-bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m)
	-{
	- return TryEnterCriticalSection(__m) != 0;
	-}
	-
	-int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m)
	-{
	- LeaveCriticalSection(__m);
	- return 0;
	-}
	-
	-int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m)
	-{
	- DeleteCriticalSection(__m);
	- return 0;
	-}
	-
	-int __libcpp_mutex_lock(__libcpp_mutex_t *__m)
	-{
	- AcquireSRWLockExclusive(__m);
	- return 0;
	-}
	-
	-bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m)
	-{
	- return TryAcquireSRWLockExclusive(__m) != 0;
	-}
	-
	-int __libcpp_mutex_unlock(__libcpp_mutex_t *__m)
	-{
	- ReleaseSRWLockExclusive(__m);
	- return 0;
	-}
	-
	-int __libcpp_mutex_destroy(__libcpp_mutex_t *__m)
	-{
	- static_cast<void>(__m);
	- return 0;
	-}
	-
	-// Condition Variable
	-int __libcpp_condvar_signal(__libcpp_condvar_t *__cv)
	-{
	- WakeConditionVariable(__cv);
	- return 0;
	-}
	-
	-int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv)
	-{
	- WakeAllConditionVariable(__cv);
	- return 0;
	-}
	-
	-int __libcpp_condvar_wait(__libcpp_condvar_t __cv, __libcpp_mutex_t __m)
	-{
	- SleepConditionVariableSRW(__cv, __m, INFINITE, 0);
	- return 0;
	-}
	-
	-int __libcpp_condvar_timedwait(__libcpp_condvar_t __cv, __libcpp_mutex_t __m,
	- timespec *__ts)
	-{
	- using namespace _VSTD::chrono;
	-
	- auto duration = seconds(__ts->tv_sec) + nanoseconds(__ts->tv_nsec);
	- auto abstime =
	- system_clock::time_point(duration_cast<system_clock::duration>(duration));
	- auto timeout_ms = duration_cast<milliseconds>(abstime - system_clock::now());
	-
	- if (!SleepConditionVariableSRW(__cv, __m,
	- timeout_ms.count() > 0 ? timeout_ms.count()
	- : 0,
	- 0))
	- {
	- auto __ec = GetLastError();
	- return __ec == ERROR_TIMEOUT ? ETIMEDOUT : __ec;
	- }
	- return 0;
	-}
	-
	-int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv)
	-{
	- static_cast<void>(__cv);
	- return 0;
	-}
	-
	-// Execute Once
	-static inline _LIBCPP_ALWAYS_INLINE BOOL CALLBACK
	-__libcpp_init_once_execute_once_thunk(PINIT_ONCE __init_once, PVOID __parameter,
	- PVOID *__context)
	-{
	- static_cast<void>(__init_once);
	- static_cast<void>(__context);
	-
	- void (init_routine)(void) = reinterpret_cast<void ()(void)>(__parameter);
	- init_routine();
	- return TRUE;
	-}
	-
	-int __libcpp_execute_once(__libcpp_exec_once_flag *__flag,
	- void (*__init_routine)(void))
	-{
	- if (!InitOnceExecuteOnce(__flag, __libcpp_init_once_execute_once_thunk,
	- reinterpret_cast<void *>(__init_routine), NULL))
	- return GetLastError();
	- return 0;
	-}
	-
	-// Thread ID
	-bool __libcpp_thread_id_equal(__libcpp_thread_id __lhs,
	- __libcpp_thread_id __rhs)
	-{
	- return __lhs == __rhs;
	-}
	-
	-bool __libcpp_thread_id_less(__libcpp_thread_id __lhs, __libcpp_thread_id __rhs)
	-{
	- return __lhs < __rhs;
	-}
	-
	-// Thread
	-struct __libcpp_beginthreadex_thunk_data
	-{
	- void (__func)(void *);
	- void *__arg;
	-};
	-
	-static inline _LIBCPP_ALWAYS_INLINE unsigned WINAPI
	-__libcpp_beginthreadex_thunk(void *__raw_data)
	-{
	- auto *__data =
	- static_cast<__libcpp_beginthreadex_thunk_data *>(__raw_data);
	- auto *__func = __data->__func;
	- void *__arg = __data->__arg;
	- delete __data;
	- return static_cast<unsigned>(reinterpret_cast<uintptr_t>(__func(__arg)));
	-}
	-
	-bool __libcpp_thread_isnull(const __libcpp_thread_t *__t) {
	- return *__t == 0;
	-}
	-
	-int __libcpp_thread_create(__libcpp_thread_t __t, void (__func)(void ),
	- void *__arg)
	-{
	- auto *__data = new __libcpp_beginthreadex_thunk_data;
	- __data->__func = __func;
	- __data->__arg = __arg;
	-
	- *__t = reinterpret_cast<HANDLE>(_beginthreadex(nullptr, 0,
	- __libcpp_beginthreadex_thunk,
	- __data, 0, nullptr));
	-
	- if (*__t)
	- return 0;
	- return GetLastError();
	-}
	-
	-__libcpp_thread_id __libcpp_thread_get_current_id()
	-{
	- return GetCurrentThreadId();
	-}
	-
	-__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t)
	-{
	- return GetThreadId(*__t);
	-}
	-
	-int __libcpp_thread_join(__libcpp_thread_t *__t)
	-{
	- if (WaitForSingleObjectEx(*__t, INFINITE, FALSE) == WAIT_FAILED)
	- return GetLastError();
	- if (!CloseHandle(*__t))
	- return GetLastError();
	- return 0;
	-}
	-
	-int __libcpp_thread_detach(__libcpp_thread_t *__t)
	-{
	- if (!CloseHandle(*__t))
	- return GetLastError();
	- return 0;
	-}
	-
	-void __libcpp_thread_yield()
	-{
	- SwitchToThread();
	-}
	-
	-void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns)
	-{
	- using namespace chrono;
	- // round-up to the nearest milisecond
	- milliseconds __ms =
	- duration_cast<milliseconds>(__ns + chrono::nanoseconds(999999));
	- // FIXME(compnerd) this should be an alertable sleep (WFSO or SleepEx)
	- Sleep(__ms.count());
	-}
	-
	-// Thread Local Storage
	-int __libcpp_tls_create(__libcpp_tls_key* __key,
	- void(_LIBCPP_TLS_DESTRUCTOR_CC* __at_exit)(void*))
	-{
	- *__key = FlsAlloc(__at_exit);
	- if (*__key == FLS_OUT_OF_INDEXES)
	- return GetLastError();
	- return 0;
	-}
	-
	-void *__libcpp_tls_get(__libcpp_tls_key __key)
	-{
	- return FlsGetValue(__key);
	-}
	-
	-int __libcpp_tls_set(__libcpp_tls_key __key, void *__p)
	-{
	- if (!FlsSetValue(__key, __p))
	- return GetLastError();
	- return 0;
	-}
	-
	-#endif // _LIBCPP_HAS_THREAD_API_PTHREAD

	#endif // !_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL \|\| _LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // !_LIBCPP_HAS_NO_THREADS

	#endif // _LIBCPP_THREADING_SUPPORT
	Index: projects/clang700-import/contrib/libc++/include/__tree
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/__tree (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/__tree (revision 337135)
	@@ -1,2692 +1,2685 @@
	// -- 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.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP___TREE
	#define _LIBCPP___TREE

	#include <__config>
	#include <iterator>
	#include <memory>
	#include <stdexcept>
	#include <algorithm>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _Tp, class _Compare, class _Allocator> class __tree;
	template <class _Tp, class _NodePtr, class _DiffType>
	class _LIBCPP_TEMPLATE_VIS __tree_iterator;
	template <class _Tp, class _ConstNodePtr, class _DiffType>
	class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;

	template <class _Pointer> class __tree_end_node;
	template <class _VoidPtr> class __tree_node_base;
	template <class _Tp, class _VoidPtr> class __tree_node;

	-#ifndef _LIBCPP_CXX03_LANG
	template <class _Key, class _Value>
	-union __value_type;
	-#else
	-template <class _Key, class _Value>
	struct __value_type;
	-#endif

	template <class _Key, class _CP, class _Compare,
	bool = is_empty<_Compare>::value && !__libcpp_is_final<_Compare>::value>
	class __map_value_compare;

	template <class _Allocator> class __map_node_destructor;
	template <class _TreeIterator> class _LIBCPP_TEMPLATE_VIS __map_iterator;
	template <class _TreeIterator> class _LIBCPP_TEMPLATE_VIS __map_const_iterator;

	/*

	_NodePtr algorithms

	The algorithms taking _NodePtr are red black tree algorithms. Those
	algorithms taking a parameter named __root should assume that __root
	points to a proper red black tree (unless otherwise specified).

	Each algorithm herein assumes that __root->__parent_ points to a non-null
	structure which has a member __left_ which points back to __root. No other
	member is read or written to at __root->__parent_.

	__root->__parent_ will be referred to below (in comments only) as end_node.
	end_node->__left_ is an externably accessible lvalue for __root, and can be
	changed by node insertion and removal (without explicit reference to end_node).

	All nodes (with the exception of end_node), even the node referred to as
	__root, have a non-null __parent_ field.

	*/

	// Returns: true if __x is a left child of its parent, else false
	// Precondition: __x != nullptr.
	template <class _NodePtr>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	__tree_is_left_child(_NodePtr __x) _NOEXCEPT
	{
	return __x == __x->__parent_->__left_;
	}

	// 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>
	unsigned
	__tree_sub_invariant(_NodePtr __x)
	{
	if (__x == nullptr)
	return 1;
	// parent consistency checked by caller
	// check __x->__left_ consistency
	if (__x->__left_ != nullptr && __x->__left_->__parent_ != __x)
	return 0;
	// check __x->__right_ consistency
	if (__x->__right_ != nullptr && __x->__right_->__parent_ != __x)
	return 0;
	// check __x->__left_ != __x->__right_ unless both are nullptr
	if (__x->__left_ == __x->__right_ && __x->__left_ != nullptr)
	return 0;
	// If this is red, neither child can be red
	if (!__x->__is_black_)
	{
	if (__x->__left_ && !__x->__left_->__is_black_)
	return 0;
	if (__x->__right_ && !__x->__right_->__is_black_)
	return 0;
	}
	unsigned __h = __tree_sub_invariant(__x->__left_);
	if (__h == 0)
	return 0; // invalid left subtree
	if (__h != __tree_sub_invariant(__x->__right_))
	return 0; // invalid or different height right subtree
	return __h + __x->__is_black_; // return black height of this node
	}

	// 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>
	bool
	__tree_invariant(_NodePtr __root)
	{
	if (__root == nullptr)
	return true;
	// check __x->__parent_ consistency
	if (__root->__parent_ == nullptr)
	return false;
	if (!__tree_is_left_child(__root))
	return false;
	// root must be black
	if (!__root->__is_black_)
	return false;
	// do normal node checks
	return __tree_sub_invariant(__root) != 0;
	}

	// Returns: pointer to the left-most node under __x.
	// Precondition: __x != nullptr.
	template <class _NodePtr>
	inline _LIBCPP_INLINE_VISIBILITY
	_NodePtr
	__tree_min(_NodePtr __x) _NOEXCEPT
	{
	while (__x->__left_ != nullptr)
	__x = __x->__left_;
	return __x;
	}

	// Returns: pointer to the right-most node under __x.
	// Precondition: __x != nullptr.
	template <class _NodePtr>
	inline _LIBCPP_INLINE_VISIBILITY
	_NodePtr
	__tree_max(_NodePtr __x) _NOEXCEPT
	{
	while (__x->__right_ != nullptr)
	__x = __x->__right_;
	return __x;
	}

	// Returns: pointer to the next in-order node after __x.
	// Precondition: __x != nullptr.
	template <class _NodePtr>
	_NodePtr
	__tree_next(_NodePtr __x) _NOEXCEPT
	{
	if (__x->__right_ != nullptr)
	return __tree_min(__x->__right_);
	while (!__tree_is_left_child(__x))
	__x = __x->__parent_unsafe();
	return __x->__parent_unsafe();
	}

	template <class _EndNodePtr, class _NodePtr>
	inline _LIBCPP_INLINE_VISIBILITY
	_EndNodePtr
	__tree_next_iter(_NodePtr __x) _NOEXCEPT
	{
	if (__x->__right_ != nullptr)
	return static_cast<_EndNodePtr>(__tree_min(__x->__right_));
	while (!__tree_is_left_child(__x))
	__x = __x->__parent_unsafe();
	return static_cast<_EndNodePtr>(__x->__parent_);
	}

	// Returns: pointer to the previous in-order node before __x.
	// Precondition: __x != nullptr.
	// Note: __x may be the end node.
	template <class _NodePtr, class _EndNodePtr>
	inline _LIBCPP_INLINE_VISIBILITY
	_NodePtr
	__tree_prev_iter(_EndNodePtr __x) _NOEXCEPT
	{
	if (__x->__left_ != nullptr)
	return __tree_max(__x->__left_);
	_NodePtr __xx = static_cast<_NodePtr>(__x);
	while (__tree_is_left_child(__xx))
	__xx = __xx->__parent_unsafe();
	return __xx->__parent_unsafe();
	}

	// Returns: pointer to a node which has no children
	// Precondition: __x != nullptr.
	template <class _NodePtr>
	_NodePtr
	__tree_leaf(_NodePtr __x) _NOEXCEPT
	{
	while (true)
	{
	if (__x->__left_ != nullptr)
	{
	__x = __x->__left_;
	continue;
	}
	if (__x->__right_ != nullptr)
	{
	__x = __x->__right_;
	continue;
	}
	break;
	}
	return __x;
	}

	// Effects: Makes __x->__right_ the subtree root with __x as its left child
	// while preserving in-order order.
	// Precondition: __x->__right_ != nullptr
	template <class _NodePtr>
	void
	__tree_left_rotate(_NodePtr __x) _NOEXCEPT
	{
	_NodePtr __y = __x->__right_;
	__x->__right_ = __y->__left_;
	if (__x->__right_ != nullptr)
	__x->__right_->__set_parent(__x);
	__y->__parent_ = __x->__parent_;
	if (__tree_is_left_child(__x))
	__x->__parent_->__left_ = __y;
	else
	__x->__parent_unsafe()->__right_ = __y;
	__y->__left_ = __x;
	__x->__set_parent(__y);
	}

	// Effects: Makes __x->__left_ the subtree root with __x as its right child
	// while preserving in-order order.
	// Precondition: __x->__left_ != nullptr
	template <class _NodePtr>
	void
	__tree_right_rotate(_NodePtr __x) _NOEXCEPT
	{
	_NodePtr __y = __x->__left_;
	__x->__left_ = __y->__right_;
	if (__x->__left_ != nullptr)
	__x->__left_->__set_parent(__x);
	__y->__parent_ = __x->__parent_;
	if (__tree_is_left_child(__x))
	__x->__parent_->__left_ = __y;
	else
	__x->__parent_unsafe()->__right_ = __y;
	__y->__right_ = __x;
	__x->__set_parent(__y);
	}

	// Effects: Rebalances __root after attaching __x to a leaf.
	// Precondition: __root != nulptr && __x != nullptr.
	// __x has no children.
	// __x == __root or == a direct or indirect child of __root.
	// If __x were to be unlinked from __root (setting __root to
	// nullptr if __root == __x), __tree_invariant(__root) == true.
	// Postcondition: __tree_invariant(end_node->__left_) == true. end_node->__left_
	// may be different than the value passed in as __root.
	template <class _NodePtr>
	void
	__tree_balance_after_insert(_NodePtr __root, _NodePtr __x) _NOEXCEPT
	{
	__x->__is_black_ = __x == __root;
	while (__x != __root && !__x->__parent_unsafe()->__is_black_)
	{
	// __x->__parent_ != __root because __x->__parent_->__is_black == false
	if (__tree_is_left_child(__x->__parent_unsafe()))
	{
	_NodePtr __y = __x->__parent_unsafe()->__parent_unsafe()->__right_;
	if (__y != nullptr && !__y->__is_black_)
	{
	__x = __x->__parent_unsafe();
	__x->__is_black_ = true;
	__x = __x->__parent_unsafe();
	__x->__is_black_ = __x == __root;
	__y->__is_black_ = true;
	}
	else
	{
	if (!__tree_is_left_child(__x))
	{
	__x = __x->__parent_unsafe();
	__tree_left_rotate(__x);
	}
	__x = __x->__parent_unsafe();
	__x->__is_black_ = true;
	__x = __x->__parent_unsafe();
	__x->__is_black_ = false;
	__tree_right_rotate(__x);
	break;
	}
	}
	else
	{
	_NodePtr __y = __x->__parent_unsafe()->__parent_->__left_;
	if (__y != nullptr && !__y->__is_black_)
	{
	__x = __x->__parent_unsafe();
	__x->__is_black_ = true;
	__x = __x->__parent_unsafe();
	__x->__is_black_ = __x == __root;
	__y->__is_black_ = true;
	}
	else
	{
	if (__tree_is_left_child(__x))
	{
	__x = __x->__parent_unsafe();
	__tree_right_rotate(__x);
	}
	__x = __x->__parent_unsafe();
	__x->__is_black_ = true;
	__x = __x->__parent_unsafe();
	__x->__is_black_ = false;
	__tree_left_rotate(__x);
	break;
	}
	}
	}
	}

	// Precondition: __root != nullptr && __z != nullptr.
	// __tree_invariant(__root) == true.
	// __z == __root or == a direct or indirect child of __root.
	// Effects: unlinks __z from the tree rooted at __root, rebalancing as needed.
	// Postcondition: __tree_invariant(end_node->__left_) == true && end_node->__left_
	// nor any of its children refer to __z. end_node->__left_
	// may be different than the value passed in as __root.
	template <class _NodePtr>
	void
	__tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
	{
	// __z will be removed from the tree. Client still needs to destruct/deallocate it
	// __y is either __z, or if __z has two children, __tree_next(__z).
	// __y will have at most one child.
	// __y will be the initial hole in the tree (make the hole at a leaf)
	_NodePtr __y = (__z->__left_ == nullptr \|\| __z->__right_ == nullptr) ?
	__z : __tree_next(__z);
	// __x is __y's possibly null single child
	_NodePtr __x = __y->__left_ != nullptr ? __y->__left_ : __y->__right_;
	// __w is __x's possibly null uncle (will become __x's sibling)
	_NodePtr __w = nullptr;
	// link __x to __y's parent, and find __w
	if (__x != nullptr)
	__x->__parent_ = __y->__parent_;
	if (__tree_is_left_child(__y))
	{
	__y->__parent_->__left_ = __x;
	if (__y != __root)
	__w = __y->__parent_unsafe()->__right_;
	else
	__root = __x; // __w == nullptr
	}
	else
	{
	__y->__parent_unsafe()->__right_ = __x;
	// __y can't be root if it is a right child
	__w = __y->__parent_->__left_;
	}
	bool __removed_black = __y->__is_black_;
	// If we didn't remove __z, do so now by splicing in __y for __z,
	// but copy __z's color. This does not impact __x or __w.
	if (__y != __z)
	{
	// __z->__left_ != nulptr but __z->__right_ might == __x == nullptr
	__y->__parent_ = __z->__parent_;
	if (__tree_is_left_child(__z))
	__y->__parent_->__left_ = __y;
	else
	__y->__parent_unsafe()->__right_ = __y;
	__y->__left_ = __z->__left_;
	__y->__left_->__set_parent(__y);
	__y->__right_ = __z->__right_;
	if (__y->__right_ != nullptr)
	__y->__right_->__set_parent(__y);
	__y->__is_black_ = __z->__is_black_;
	if (__root == __z)
	__root = __y;
	}
	// There is no need to rebalance if we removed a red, or if we removed
	// the last node.
	if (__removed_black && __root != nullptr)
	{
	// Rebalance:
	// __x has an implicit black color (transferred from the removed __y)
	// associated with it, no matter what its color is.
	// If __x is __root (in which case it can't be null), it is supposed
	// to be black anyway, and if it is doubly black, then the double
	// can just be ignored.
	// If __x is red (in which case it can't be null), then it can absorb
	// the implicit black just by setting its color to black.
	// Since __y was black and only had one child (which __x points to), __x
	// is either red with no children, else null, otherwise __y would have
	// different black heights under left and right pointers.
	// if (__x == __root \|\| __x != nullptr && !__x->__is_black_)
	if (__x != nullptr)
	__x->__is_black_ = true;
	else
	{
	// Else __x isn't root, and is "doubly black", even though it may
	// be null. __w can not be null here, else the parent would
	// see a black height >= 2 on the __x side and a black height
	// of 1 on the __w side (__w must be a non-null black or a red
	// with a non-null black child).
	while (true)
	{
	if (!__tree_is_left_child(__w)) // if x is left child
	{
	if (!__w->__is_black_)
	{
	__w->__is_black_ = true;
	__w->__parent_unsafe()->__is_black_ = false;
	__tree_left_rotate(__w->__parent_unsafe());
	// __x is still valid
	// reset __root only if necessary
	if (__root == __w->__left_)
	__root = __w;
	// reset sibling, and it still can't be null
	__w = __w->__left_->__right_;
	}
	// __w->__is_black_ is now true, __w may have null children
	if ((__w->__left_ == nullptr \|\| __w->__left_->__is_black_) &&
	(__w->__right_ == nullptr \|\| __w->__right_->__is_black_))
	{
	__w->__is_black_ = false;
	__x = __w->__parent_unsafe();
	// __x can no longer be null
	if (__x == __root \|\| !__x->__is_black_)
	{
	__x->__is_black_ = true;
	break;
	}
	// reset sibling, and it still can't be null
	__w = __tree_is_left_child(__x) ?
	__x->__parent_unsafe()->__right_ :
	__x->__parent_->__left_;
	// continue;
	}
	else // __w has a red child
	{
	if (__w->__right_ == nullptr \|\| __w->__right_->__is_black_)
	{
	// __w left child is non-null and red
	__w->__left_->__is_black_ = true;
	__w->__is_black_ = false;
	__tree_right_rotate(__w);
	// __w is known not to be root, so root hasn't changed
	// reset sibling, and it still can't be null
	__w = __w->__parent_unsafe();
	}
	// __w has a right red child, left child may be null
	__w->__is_black_ = __w->__parent_unsafe()->__is_black_;
	__w->__parent_unsafe()->__is_black_ = true;
	__w->__right_->__is_black_ = true;
	__tree_left_rotate(__w->__parent_unsafe());
	break;
	}
	}
	else
	{
	if (!__w->__is_black_)
	{
	__w->__is_black_ = true;
	__w->__parent_unsafe()->__is_black_ = false;
	__tree_right_rotate(__w->__parent_unsafe());
	// __x is still valid
	// reset __root only if necessary
	if (__root == __w->__right_)
	__root = __w;
	// reset sibling, and it still can't be null
	__w = __w->__right_->__left_;
	}
	// __w->__is_black_ is now true, __w may have null children
	if ((__w->__left_ == nullptr \|\| __w->__left_->__is_black_) &&
	(__w->__right_ == nullptr \|\| __w->__right_->__is_black_))
	{
	__w->__is_black_ = false;
	__x = __w->__parent_unsafe();
	// __x can no longer be null
	if (!__x->__is_black_ \|\| __x == __root)
	{
	__x->__is_black_ = true;
	break;
	}
	// reset sibling, and it still can't be null
	__w = __tree_is_left_child(__x) ?
	__x->__parent_unsafe()->__right_ :
	__x->__parent_->__left_;
	// continue;
	}
	else // __w has a red child
	{
	if (__w->__left_ == nullptr \|\| __w->__left_->__is_black_)
	{
	// __w right child is non-null and red
	__w->__right_->__is_black_ = true;
	__w->__is_black_ = false;
	__tree_left_rotate(__w);
	// __w is known not to be root, so root hasn't changed
	// reset sibling, and it still can't be null
	__w = __w->__parent_unsafe();
	}
	// __w has a left red child, right child may be null
	__w->__is_black_ = __w->__parent_unsafe()->__is_black_;
	__w->__parent_unsafe()->__is_black_ = true;
	__w->__left_->__is_black_ = true;
	__tree_right_rotate(__w->__parent_unsafe());
	break;
	}
	}
	}
	}
	}
	}

	// node traits


	#ifndef _LIBCPP_CXX03_LANG
	template <class _Tp>
	struct __is_tree_value_type_imp : false_type {};

	template <class _Key, class _Value>
	struct __is_tree_value_type_imp<__value_type<_Key, _Value>> : true_type {};

	template <class ..._Args>
	struct __is_tree_value_type : false_type {};

	template <class _One>
	struct __is_tree_value_type<_One> : __is_tree_value_type_imp<typename __uncvref<_One>::type> {};
	#endif

	template <class _Tp>
	struct __tree_key_value_types {
	typedef _Tp key_type;
	typedef _Tp __node_value_type;
	typedef _Tp __container_value_type;
	static const bool __is_map = false;

	_LIBCPP_INLINE_VISIBILITY
	static key_type const& __get_key(_Tp const& __v) {
	return __v;
	}
	_LIBCPP_INLINE_VISIBILITY
	static __container_value_type const& __get_value(__node_value_type const& __v) {
	return __v;
	}
	_LIBCPP_INLINE_VISIBILITY
	static __container_value_type* __get_ptr(__node_value_type& __n) {
	return _VSTD::addressof(__n);
	}
	-
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	- static __container_value_type&& __move(__node_value_type& __v) {
	+ static __container_value_type&& __move(__node_value_type& __v) {
	return _VSTD::move(__v);
	}
	#endif
	};

	template <class _Key, class _Tp>
	struct __tree_key_value_types<__value_type<_Key, _Tp> > {
	typedef _Key key_type;
	typedef _Tp mapped_type;
	typedef __value_type<_Key, _Tp> __node_value_type;
	typedef pair<const _Key, _Tp> __container_value_type;
	- typedef pair<_Key, _Tp> __nc_value_type;
	typedef __container_value_type __map_value_type;
	static const bool __is_map = true;

	_LIBCPP_INLINE_VISIBILITY
	static key_type const&
	__get_key(__node_value_type const& __t) {
	- return __t.__cc.first;
	+ return __t.__get_value().first;
	}

	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY
	static typename enable_if<__is_same_uncvref<_Up, __container_value_type>::value,
	key_type const&>::type
	__get_key(_Up& __t) {
	return __t.first;
	}

	_LIBCPP_INLINE_VISIBILITY
	static __container_value_type const&
	__get_value(__node_value_type const& __t) {
	- return __t.__cc;
	+ return __t.__get_value();
	}

	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY
	static typename enable_if<__is_same_uncvref<_Up, __container_value_type>::value,
	__container_value_type const&>::type
	__get_value(_Up& __t) {
	return __t;
	}

	_LIBCPP_INLINE_VISIBILITY
	static __container_value_type* __get_ptr(__node_value_type& __n) {
	- return _VSTD::addressof(__n.__cc);
	+ return _VSTD::addressof(__n.__get_value());
	}

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	- static __nc_value_type&& __move(__node_value_type& __v) {
	- return _VSTD::move(__v.__nc);
	+ static pair<key_type&&, mapped_type&&> __move(__node_value_type& __v) {
	+ return __v.__move();
	}
	#endif
	};

	template <class _VoidPtr>
	struct __tree_node_base_types {
	typedef _VoidPtr __void_pointer;

	typedef __tree_node_base<__void_pointer> __node_base_type;
	typedef typename __rebind_pointer<_VoidPtr, __node_base_type>::type
	__node_base_pointer;

	typedef __tree_end_node<__node_base_pointer> __end_node_type;
	typedef typename __rebind_pointer<_VoidPtr, __end_node_type>::type
	__end_node_pointer;
	#if defined(_LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB)
	typedef __end_node_pointer __parent_pointer;
	#else
	typedef typename conditional<
	is_pointer<__end_node_pointer>::value,
	__end_node_pointer,
	__node_base_pointer>::type __parent_pointer;
	#endif

	private:
	static_assert((is_same<typename pointer_traits<_VoidPtr>::element_type, void>::value),
	"_VoidPtr does not point to unqualified void type");
	};

	template <class _Tp, class _AllocPtr, class _KVTypes = __tree_key_value_types<_Tp>,
	bool = _KVTypes::__is_map>
	struct __tree_map_pointer_types {};

	template <class _Tp, class _AllocPtr, class _KVTypes>
	struct __tree_map_pointer_types<_Tp, _AllocPtr, _KVTypes, true> {
	typedef typename _KVTypes::__map_value_type _Mv;
	typedef typename __rebind_pointer<_AllocPtr, _Mv>::type
	__map_value_type_pointer;
	typedef typename __rebind_pointer<_AllocPtr, const _Mv>::type
	__const_map_value_type_pointer;
	};

	template <class _NodePtr, class _NodeT = typename pointer_traits<_NodePtr>::element_type>
	struct __tree_node_types;

	template <class _NodePtr, class _Tp, class _VoidPtr>
	struct __tree_node_types<_NodePtr, __tree_node<_Tp, _VoidPtr> >
	: public __tree_node_base_types<_VoidPtr>,
	__tree_key_value_types<_Tp>,
	__tree_map_pointer_types<_Tp, _VoidPtr>
	{
	typedef __tree_node_base_types<_VoidPtr> __base;
	typedef __tree_key_value_types<_Tp> __key_base;
	typedef __tree_map_pointer_types<_Tp, _VoidPtr> __map_pointer_base;
	public:

	typedef typename pointer_traits<_NodePtr>::element_type __node_type;
	typedef _NodePtr __node_pointer;

	typedef _Tp __node_value_type;
	typedef typename __rebind_pointer<_VoidPtr, __node_value_type>::type
	__node_value_type_pointer;
	typedef typename __rebind_pointer<_VoidPtr, const __node_value_type>::type
	__const_node_value_type_pointer;
	#if defined(_LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB)
	typedef typename __base::__end_node_pointer __iter_pointer;
	#else
	typedef typename conditional<
	is_pointer<__node_pointer>::value,
	typename __base::__end_node_pointer,
	__node_pointer>::type __iter_pointer;
	#endif
	private:
	static_assert(!is_const<__node_type>::value,
	"_NodePtr should never be a pointer to const");
	static_assert((is_same<typename __rebind_pointer<_VoidPtr, __node_type>::type,
	_NodePtr>::value), "_VoidPtr does not rebind to _NodePtr.");
	};

	template <class _ValueTp, class _VoidPtr>
	struct __make_tree_node_types {
	typedef typename __rebind_pointer<_VoidPtr, __tree_node<_ValueTp, _VoidPtr> >::type
	_NodePtr;
	typedef __tree_node_types<_NodePtr> type;
	};

	// node

	template <class _Pointer>
	class __tree_end_node
	{
	public:
	typedef _Pointer pointer;
	pointer __left_;

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

	template <class _VoidPtr>
	class __tree_node_base
	: public __tree_node_base_types<_VoidPtr>::__end_node_type
	{
	typedef __tree_node_base_types<_VoidPtr> _NodeBaseTypes;

	public:
	typedef typename _NodeBaseTypes::__node_base_pointer pointer;
	typedef typename _NodeBaseTypes::__parent_pointer __parent_pointer;

	pointer __right_;
	__parent_pointer __parent_;
	bool __is_black_;

	_LIBCPP_INLINE_VISIBILITY
	pointer __parent_unsafe() const { return static_cast<pointer>(__parent_);}

	_LIBCPP_INLINE_VISIBILITY
	void __set_parent(pointer __p) {
	__parent_ = static_cast<__parent_pointer>(__p);
	}

	private:
	~__tree_node_base() _LIBCPP_EQUAL_DELETE;
	__tree_node_base(__tree_node_base const&) _LIBCPP_EQUAL_DELETE;
	__tree_node_base& operator=(__tree_node_base const&) _LIBCPP_EQUAL_DELETE;
	};

	template <class _Tp, class _VoidPtr>
	class __tree_node
	: public __tree_node_base<_VoidPtr>
	{
	public:
	typedef _Tp __node_value_type;

	__node_value_type __value_;

	private:
	~__tree_node() _LIBCPP_EQUAL_DELETE;
	__tree_node(__tree_node const&) _LIBCPP_EQUAL_DELETE;
	__tree_node& operator=(__tree_node const&) _LIBCPP_EQUAL_DELETE;
	};


	template <class _Allocator>
	class __tree_node_destructor
	{
	typedef _Allocator allocator_type;
	typedef allocator_traits<allocator_type> __alloc_traits;

	public:
	typedef typename __alloc_traits::pointer pointer;
	private:
	typedef __tree_node_types<pointer> _NodeTypes;
	allocator_type& __na_;

	__tree_node_destructor& operator=(const __tree_node_destructor&);

	public:
	bool __value_constructed;

	_LIBCPP_INLINE_VISIBILITY
	explicit __tree_node_destructor(allocator_type& __na, bool __val = false) _NOEXCEPT
	: __na_(__na),
	__value_constructed(__val)
	{}

	_LIBCPP_INLINE_VISIBILITY
	void operator()(pointer __p) _NOEXCEPT
	{
	if (__value_constructed)
	__alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__value_));
	if (__p)
	__alloc_traits::deallocate(__na_, __p, 1);
	}

	template <class> friend class __map_node_destructor;
	};


	template <class _Tp, class _NodePtr, class _DiffType>
	class _LIBCPP_TEMPLATE_VIS __tree_iterator
	{
	typedef __tree_node_types<_NodePtr> _NodeTypes;
	typedef _NodePtr __node_pointer;
	typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;
	typedef typename _NodeTypes::__end_node_pointer __end_node_pointer;
	typedef typename _NodeTypes::__iter_pointer __iter_pointer;
	typedef pointer_traits<__node_pointer> __pointer_traits;

	__iter_pointer __ptr_;

	public:
	typedef bidirectional_iterator_tag iterator_category;
	typedef _Tp value_type;
	typedef _DiffType difference_type;
	typedef value_type& reference;
	typedef typename _NodeTypes::__node_value_type_pointer pointer;

	_LIBCPP_INLINE_VISIBILITY __tree_iterator() _NOEXCEPT
	#if _LIBCPP_STD_VER > 11
	: __ptr_(nullptr)
	#endif
	{}

	_LIBCPP_INLINE_VISIBILITY reference operator*() const
	{return __get_np()->__value_;}
	_LIBCPP_INLINE_VISIBILITY pointer operator->() const
	{return pointer_traits<pointer>::pointer_to(__get_np()->__value_);}

	_LIBCPP_INLINE_VISIBILITY
	__tree_iterator& operator++() {
	__ptr_ = static_cast<__iter_pointer>(
	__tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_)));
	return *this;
	}
	_LIBCPP_INLINE_VISIBILITY
	__tree_iterator operator++(int)
	{__tree_iterator __t(this); ++(this); return __t;}

	_LIBCPP_INLINE_VISIBILITY
	__tree_iterator& operator--() {
	__ptr_ = static_cast<__iter_pointer>(__tree_prev_iter<__node_base_pointer>(
	static_cast<__end_node_pointer>(__ptr_)));
	return *this;
	}
	_LIBCPP_INLINE_VISIBILITY
	__tree_iterator operator--(int)
	{__tree_iterator __t(this); --(this); return __t;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const __tree_iterator& __x, const __tree_iterator& __y)
	{return __x.__ptr_ == __y.__ptr_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const __tree_iterator& __x, const __tree_iterator& __y)
	{return !(__x == __y);}

	private:
	_LIBCPP_INLINE_VISIBILITY
	explicit __tree_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit __tree_iterator(__end_node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	__node_pointer __get_np() const { return static_cast<__node_pointer>(__ptr_); }
	template <class, class, class> friend class __tree;
	template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;
	template <class> friend class _LIBCPP_TEMPLATE_VIS __map_iterator;
	template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
	template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
	template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS set;
	template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS multiset;
	};

	template <class _Tp, class _NodePtr, class _DiffType>
	class _LIBCPP_TEMPLATE_VIS __tree_const_iterator
	{
	typedef __tree_node_types<_NodePtr> _NodeTypes;
	typedef typename _NodeTypes::__node_pointer __node_pointer;
	typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;
	typedef typename _NodeTypes::__end_node_pointer __end_node_pointer;
	typedef typename _NodeTypes::__iter_pointer __iter_pointer;
	typedef pointer_traits<__node_pointer> __pointer_traits;

	__iter_pointer __ptr_;

	public:
	typedef bidirectional_iterator_tag iterator_category;
	typedef _Tp value_type;
	typedef _DiffType difference_type;
	typedef const value_type& reference;
	typedef typename _NodeTypes::__const_node_value_type_pointer pointer;

	_LIBCPP_INLINE_VISIBILITY __tree_const_iterator() _NOEXCEPT
	#if _LIBCPP_STD_VER > 11
	: __ptr_(nullptr)
	#endif
	{}

	private:
	typedef __tree_iterator<value_type, __node_pointer, difference_type>
	__non_const_iterator;
	public:
	_LIBCPP_INLINE_VISIBILITY
	__tree_const_iterator(__non_const_iterator __p) _NOEXCEPT
	: __ptr_(__p.__ptr_) {}

	_LIBCPP_INLINE_VISIBILITY reference operator*() const
	{return __get_np()->__value_;}
	_LIBCPP_INLINE_VISIBILITY pointer operator->() const
	{return pointer_traits<pointer>::pointer_to(__get_np()->__value_);}

	_LIBCPP_INLINE_VISIBILITY
	__tree_const_iterator& operator++() {
	__ptr_ = static_cast<__iter_pointer>(
	__tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_)));
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	__tree_const_iterator operator++(int)
	{__tree_const_iterator __t(this); ++(this); return __t;}

	_LIBCPP_INLINE_VISIBILITY
	__tree_const_iterator& operator--() {
	__ptr_ = static_cast<__iter_pointer>(__tree_prev_iter<__node_base_pointer>(
	static_cast<__end_node_pointer>(__ptr_)));
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	__tree_const_iterator operator--(int)
	{__tree_const_iterator __t(this); --(this); return __t;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const __tree_const_iterator& __x, const __tree_const_iterator& __y)
	{return __x.__ptr_ == __y.__ptr_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const __tree_const_iterator& __x, const __tree_const_iterator& __y)
	{return !(__x == __y);}

	private:
	_LIBCPP_INLINE_VISIBILITY
	explicit __tree_const_iterator(__node_pointer __p) _NOEXCEPT
	: __ptr_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit __tree_const_iterator(__end_node_pointer __p) _NOEXCEPT
	: __ptr_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	__node_pointer __get_np() const { return static_cast<__node_pointer>(__ptr_); }

	template <class, class, class> friend class __tree;
	template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
	template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
	template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS set;
	template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS multiset;
	template <class> friend class _LIBCPP_TEMPLATE_VIS __map_const_iterator;

	};

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Tp, class _Compare, class _Allocator>
	struct __diagnose_tree_helper {
	static constexpr bool __trigger_diagnostics()
	_LIBCPP_DIAGNOSE_WARNING(!__invokable<_Compare const&, _Tp const&, _Tp const&>::value,
	"the specified comparator type does not provide a const call operator")
	{ return true; }
	};

	template <class _Key, class _Value, class _KeyComp, class _Alloc>
	struct __diagnose_tree_helper<
	__value_type<_Key, _Value>,
	__map_value_compare<_Key, __value_type<_Key, _Value>, _KeyComp>,
	_Alloc
	> : __diagnose_tree_helper<_Key, _KeyComp, _Alloc>
	{
	};
	#endif // !_LIBCPP_CXX03_LANG

	template <class _Tp, class _Compare, class _Allocator>
	class __tree
	{
	public:
	typedef _Tp value_type;
	typedef _Compare value_compare;
	typedef _Allocator allocator_type;

	private:
	typedef allocator_traits<allocator_type> __alloc_traits;
	typedef typename __make_tree_node_types<value_type,
	typename __alloc_traits::void_pointer>::type
	_NodeTypes;
	typedef typename _NodeTypes::key_type key_type;
	public:
	typedef typename _NodeTypes::__node_value_type __node_value_type;
	typedef typename _NodeTypes::__container_value_type __container_value_type;

	typedef typename __alloc_traits::pointer pointer;
	typedef typename __alloc_traits::const_pointer const_pointer;
	typedef typename __alloc_traits::size_type size_type;
	typedef typename __alloc_traits::difference_type difference_type;

	public:
	typedef typename _NodeTypes::__void_pointer __void_pointer;

	typedef typename _NodeTypes::__node_type __node;
	typedef typename _NodeTypes::__node_pointer __node_pointer;

	typedef typename _NodeTypes::__node_base_type __node_base;
	typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;

	typedef typename _NodeTypes::__end_node_type __end_node_t;
	typedef typename _NodeTypes::__end_node_pointer __end_node_ptr;

	typedef typename _NodeTypes::__parent_pointer __parent_pointer;
	typedef typename _NodeTypes::__iter_pointer __iter_pointer;

	typedef typename __rebind_alloc_helper<__alloc_traits, __node>::type __node_allocator;
	typedef allocator_traits<__node_allocator> __node_traits;

	private:
	// check for sane allocator pointer rebinding semantics. Rebinding the
	// allocator for a new pointer type should be exactly the same as rebinding
	// the pointer using 'pointer_traits'.
	static_assert((is_same<__node_pointer, typename __node_traits::pointer>::value),
	"Allocator does not rebind pointers in a sane manner.");
	typedef typename __rebind_alloc_helper<__node_traits, __node_base>::type
	__node_base_allocator;
	typedef allocator_traits<__node_base_allocator> __node_base_traits;
	static_assert((is_same<__node_base_pointer, typename __node_base_traits::pointer>::value),
	"Allocator does not rebind pointers in a sane manner.");

	private:
	__iter_pointer __begin_node_;
	__compressed_pair<__end_node_t, __node_allocator> __pair1_;
	__compressed_pair<size_type, value_compare> __pair3_;

	public:
	_LIBCPP_INLINE_VISIBILITY
	__iter_pointer __end_node() _NOEXCEPT
	{
	return static_cast<__iter_pointer>(
	pointer_traits<__end_node_ptr>::pointer_to(__pair1_.first())
	);
	}
	_LIBCPP_INLINE_VISIBILITY
	__iter_pointer __end_node() const _NOEXCEPT
	{
	return static_cast<__iter_pointer>(
	pointer_traits<__end_node_ptr>::pointer_to(
	const_cast<__end_node_t&>(__pair1_.first())
	)
	);
	}
	_LIBCPP_INLINE_VISIBILITY
	__node_allocator& __node_alloc() _NOEXCEPT {return __pair1_.second();}
	private:
	_LIBCPP_INLINE_VISIBILITY
	const __node_allocator& __node_alloc() const _NOEXCEPT
	{return __pair1_.second();}
	_LIBCPP_INLINE_VISIBILITY
	__iter_pointer& __begin_node() _NOEXCEPT {return __begin_node_;}
	_LIBCPP_INLINE_VISIBILITY
	const __iter_pointer& __begin_node() const _NOEXCEPT {return __begin_node_;}
	public:
	_LIBCPP_INLINE_VISIBILITY
	allocator_type __alloc() const _NOEXCEPT
	{return allocator_type(__node_alloc());}
	private:
	_LIBCPP_INLINE_VISIBILITY
	size_type& size() _NOEXCEPT {return __pair3_.first();}
	public:
	_LIBCPP_INLINE_VISIBILITY
	const size_type& size() const _NOEXCEPT {return __pair3_.first();}
	_LIBCPP_INLINE_VISIBILITY
	value_compare& value_comp() _NOEXCEPT {return __pair3_.second();}
	_LIBCPP_INLINE_VISIBILITY
	const value_compare& value_comp() const _NOEXCEPT
	{return __pair3_.second();}
	public:

	_LIBCPP_INLINE_VISIBILITY
	__node_pointer __root() const _NOEXCEPT
	{return static_cast<__node_pointer>(__end_node()->__left_);}

	__node_base_pointer* __root_ptr() const _NOEXCEPT {
	return _VSTD::addressof(__end_node()->__left_);
	}

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

	explicit __tree(const value_compare& __comp)
	_NOEXCEPT_(
	is_nothrow_default_constructible<__node_allocator>::value &&
	is_nothrow_copy_constructible<value_compare>::value);
	explicit __tree(const allocator_type& __a);
	__tree(const value_compare& __comp, const allocator_type& __a);
	__tree(const __tree& __t);
	__tree& operator=(const __tree& __t);
	template <class _InputIterator>
	void __assign_unique(_InputIterator __first, _InputIterator __last);
	template <class _InputIterator>
	void __assign_multi(_InputIterator __first, _InputIterator __last);
	#ifndef _LIBCPP_CXX03_LANG
	__tree(__tree&& __t)
	_NOEXCEPT_(
	is_nothrow_move_constructible<__node_allocator>::value &&
	is_nothrow_move_constructible<value_compare>::value);
	__tree(__tree&& __t, const allocator_type& __a);
	__tree& operator=(__tree&& __t)
	_NOEXCEPT_(
	__node_traits::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<value_compare>::value &&
	is_nothrow_move_assignable<__node_allocator>::value);
	#endif // _LIBCPP_CXX03_LANG

	~__tree();

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

	_LIBCPP_INLINE_VISIBILITY
	size_type max_size() const _NOEXCEPT
	{return std::min<size_type>(
	__node_traits::max_size(__node_alloc()),
	numeric_limits<difference_type >::max());}

	void clear() _NOEXCEPT;

	void swap(__tree& __t)
	#if _LIBCPP_STD_VER <= 11
	_NOEXCEPT_(
	__is_nothrow_swappable<value_compare>::value
	&& (!__node_traits::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<__node_allocator>::value)
	);
	#else
	_NOEXCEPT_(__is_nothrow_swappable<value_compare>::value);
	#endif

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Key, class ..._Args>
	pair<iterator, bool>
	__emplace_unique_key_args(_Key const&, _Args&&... __args);
	template <class _Key, class ..._Args>
	iterator
	__emplace_hint_unique_key_args(const_iterator, _Key const&, _Args&&...);

	template <class... _Args>
	pair<iterator, bool> __emplace_unique_impl(_Args&&... __args);

	template <class... _Args>
	iterator __emplace_hint_unique_impl(const_iterator __p, _Args&&... __args);

	template <class... _Args>
	iterator __emplace_multi(_Args&&... __args);

	template <class... _Args>
	iterator __emplace_hint_multi(const_iterator __p, _Args&&... __args);

	template <class _Pp>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> __emplace_unique(_Pp&& __x) {
	return __emplace_unique_extract_key(_VSTD::forward<_Pp>(__x),
	__can_extract_key<_Pp, key_type>());
	}

	template <class _First, class _Second>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<
	__can_extract_map_key<_First, key_type, __container_value_type>::value,
	pair<iterator, bool>
	>::type __emplace_unique(_First&& __f, _Second&& __s) {
	return __emplace_unique_key_args(__f, _VSTD::forward<_First>(__f),
	_VSTD::forward<_Second>(__s));
	}

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> __emplace_unique(_Args&&... __args) {
	return __emplace_unique_impl(_VSTD::forward<_Args>(__args)...);
	}

	template <class _Pp>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool>
	__emplace_unique_extract_key(_Pp&& __x, __extract_key_fail_tag) {
	return __emplace_unique_impl(_VSTD::forward<_Pp>(__x));
	}

	template <class _Pp>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool>
	__emplace_unique_extract_key(_Pp&& __x, __extract_key_self_tag) {
	return __emplace_unique_key_args(__x, _VSTD::forward<_Pp>(__x));
	}

	template <class _Pp>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool>
	__emplace_unique_extract_key(_Pp&& __x, __extract_key_first_tag) {
	return __emplace_unique_key_args(__x.first, _VSTD::forward<_Pp>(__x));
	}

	template <class _Pp>
	_LIBCPP_INLINE_VISIBILITY
	iterator __emplace_hint_unique(const_iterator __p, _Pp&& __x) {
	return __emplace_hint_unique_extract_key(__p, _VSTD::forward<_Pp>(__x),
	__can_extract_key<_Pp, key_type>());
	}

	template <class _First, class _Second>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<
	__can_extract_map_key<_First, key_type, __container_value_type>::value,
	iterator
	>::type __emplace_hint_unique(const_iterator __p, _First&& __f, _Second&& __s) {
	return __emplace_hint_unique_key_args(__p, __f,
	_VSTD::forward<_First>(__f),
	_VSTD::forward<_Second>(__s));
	}

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	iterator __emplace_hint_unique(const_iterator __p, _Args&&... __args) {
	return __emplace_hint_unique_impl(__p, _VSTD::forward<_Args>(__args)...);
	}

	template <class _Pp>
	_LIBCPP_INLINE_VISIBILITY
	iterator
	__emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_fail_tag) {
	return __emplace_hint_unique_impl(__p, _VSTD::forward<_Pp>(__x));
	}

	template <class _Pp>
	_LIBCPP_INLINE_VISIBILITY
	iterator
	__emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_self_tag) {
	return __emplace_hint_unique_key_args(__p, __x, _VSTD::forward<_Pp>(__x));
	}

	template <class _Pp>
	_LIBCPP_INLINE_VISIBILITY
	iterator
	__emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_first_tag) {
	return __emplace_hint_unique_key_args(__p, __x.first, _VSTD::forward<_Pp>(__x));
	}

	#else
	template <class _Key, class _Args>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> __emplace_unique_key_args(_Key const&, _Args& __args);
	template <class _Key, class _Args>
	_LIBCPP_INLINE_VISIBILITY
	iterator __emplace_hint_unique_key_args(const_iterator, _Key const&, _Args&);
	#endif

	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> __insert_unique(const __container_value_type& __v) {
	return __emplace_unique_key_args(_NodeTypes::__get_key(__v), __v);
	}

	_LIBCPP_INLINE_VISIBILITY
	iterator __insert_unique(const_iterator __p, const __container_value_type& __v) {
	return __emplace_hint_unique_key_args(__p, _NodeTypes::__get_key(__v), __v);
	}

	#ifdef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	iterator __insert_multi(const __container_value_type& __v);
	_LIBCPP_INLINE_VISIBILITY
	iterator __insert_multi(const_iterator __p, const __container_value_type& __v);
	#else
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> __insert_unique(__container_value_type&& __v) {
	return __emplace_unique_key_args(_NodeTypes::__get_key(__v), _VSTD::move(__v));
	}

	_LIBCPP_INLINE_VISIBILITY
	iterator __insert_unique(const_iterator __p, __container_value_type&& __v) {
	return __emplace_hint_unique_key_args(__p, _NodeTypes::__get_key(__v), _VSTD::move(__v));
	}

	template <class _Vp, class = typename enable_if<
	!is_same<typename __unconstref<_Vp>::type,
	__container_value_type
	>::value
	>::type>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> __insert_unique(_Vp&& __v) {
	return __emplace_unique(_VSTD::forward<_Vp>(__v));
	}

	template <class _Vp, class = typename enable_if<
	!is_same<typename __unconstref<_Vp>::type,
	__container_value_type
	>::value
	>::type>
	_LIBCPP_INLINE_VISIBILITY
	iterator __insert_unique(const_iterator __p, _Vp&& __v) {
	return __emplace_hint_unique(__p, _VSTD::forward<_Vp>(__v));
	}

	_LIBCPP_INLINE_VISIBILITY
	iterator __insert_multi(__container_value_type&& __v) {
	return __emplace_multi(_VSTD::move(__v));
	}

	_LIBCPP_INLINE_VISIBILITY
	iterator __insert_multi(const_iterator __p, __container_value_type&& __v) {
	return __emplace_hint_multi(__p, _VSTD::move(__v));
	}

	template <class _Vp>
	_LIBCPP_INLINE_VISIBILITY
	iterator __insert_multi(_Vp&& __v) {
	return __emplace_multi(_VSTD::forward<_Vp>(__v));
	}

	template <class _Vp>
	_LIBCPP_INLINE_VISIBILITY
	iterator __insert_multi(const_iterator __p, _Vp&& __v) {
	return __emplace_hint_multi(__p, _VSTD::forward<_Vp>(__v));
	}

	#endif // !_LIBCPP_CXX03_LANG

	pair<iterator, bool> __node_insert_unique(__node_pointer __nd);
	iterator __node_insert_unique(const_iterator __p,
	__node_pointer __nd);

	iterator __node_insert_multi(__node_pointer __nd);
	iterator __node_insert_multi(const_iterator __p, __node_pointer __nd);

	iterator erase(const_iterator __p);
	iterator erase(const_iterator __f, const_iterator __l);
	template <class _Key>
	size_type __erase_unique(const _Key& __k);
	template <class _Key>
	size_type __erase_multi(const _Key& __k);

	void __insert_node_at(__parent_pointer __parent,
	__node_base_pointer& __child,
	__node_base_pointer __new_node);

	template <class _Key>
	iterator find(const _Key& __v);
	template <class _Key>
	const_iterator find(const _Key& __v) const;

	template <class _Key>
	size_type __count_unique(const _Key& __k) const;
	template <class _Key>
	size_type __count_multi(const _Key& __k) const;

	template <class _Key>
	_LIBCPP_INLINE_VISIBILITY
	iterator lower_bound(const _Key& __v)
	{return __lower_bound(__v, __root(), __end_node());}
	template <class _Key>
	iterator __lower_bound(const _Key& __v,
	__node_pointer __root,
	__iter_pointer __result);
	template <class _Key>
	_LIBCPP_INLINE_VISIBILITY
	const_iterator lower_bound(const _Key& __v) const
	{return __lower_bound(__v, __root(), __end_node());}
	template <class _Key>
	const_iterator __lower_bound(const _Key& __v,
	__node_pointer __root,
	__iter_pointer __result) const;
	template <class _Key>
	_LIBCPP_INLINE_VISIBILITY
	iterator upper_bound(const _Key& __v)
	{return __upper_bound(__v, __root(), __end_node());}
	template <class _Key>
	iterator __upper_bound(const _Key& __v,
	__node_pointer __root,
	__iter_pointer __result);
	template <class _Key>
	_LIBCPP_INLINE_VISIBILITY
	const_iterator upper_bound(const _Key& __v) const
	{return __upper_bound(__v, __root(), __end_node());}
	template <class _Key>
	const_iterator __upper_bound(const _Key& __v,
	__node_pointer __root,
	__iter_pointer __result) const;
	template <class _Key>
	pair<iterator, iterator>
	__equal_range_unique(const _Key& __k);
	template <class _Key>
	pair<const_iterator, const_iterator>
	__equal_range_unique(const _Key& __k) const;

	template <class _Key>
	pair<iterator, iterator>
	__equal_range_multi(const _Key& __k);
	template <class _Key>
	pair<const_iterator, const_iterator>
	__equal_range_multi(const _Key& __k) const;

	typedef __tree_node_destructor<__node_allocator> _Dp;
	typedef unique_ptr<__node, _Dp> __node_holder;

	__node_holder remove(const_iterator __p) _NOEXCEPT;
	private:
	__node_base_pointer&
	__find_leaf_low(__parent_pointer& __parent, const key_type& __v);
	__node_base_pointer&
	__find_leaf_high(__parent_pointer& __parent, const key_type& __v);
	__node_base_pointer&
	__find_leaf(const_iterator __hint,
	__parent_pointer& __parent, const key_type& __v);
	// FIXME: Make this function const qualified. Unfortunetly doing so
	// breaks existing code which uses non-const callable comparators.
	template <class _Key>
	__node_base_pointer&
	__find_equal(__parent_pointer& __parent, const _Key& __v);
	template <class _Key>
	_LIBCPP_INLINE_VISIBILITY __node_base_pointer&
	__find_equal(__parent_pointer& __parent, const _Key& __v) const {
	return const_cast<__tree*>(this)->__find_equal(__parent, __v);
	}
	template <class _Key>
	__node_base_pointer&
	__find_equal(const_iterator __hint, __parent_pointer& __parent,
	__node_base_pointer& __dummy,
	const _Key& __v);

	#ifndef _LIBCPP_CXX03_LANG
	template <class ..._Args>
	__node_holder __construct_node(_Args&& ...__args);
	#else
	__node_holder __construct_node(const __container_value_type& __v);
	#endif

	void destroy(__node_pointer __nd) _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const __tree& __t)
	{__copy_assign_alloc(__t, integral_constant<bool,
	__node_traits::propagate_on_container_copy_assignment::value>());}

	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const __tree& __t, true_type)
	{
	if (__node_alloc() != __t.__node_alloc())
	clear();
	__node_alloc() = __t.__node_alloc();
	}
	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const __tree&, false_type) {}

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

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

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

	__node_pointer __detach();
	static __node_pointer __detach(__node_pointer);

	template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
	template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
	};

	template <class _Tp, class _Compare, class _Allocator>
	__tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp)
	_NOEXCEPT_(
	is_nothrow_default_constructible<__node_allocator>::value &&
	is_nothrow_copy_constructible<value_compare>::value)
	: __pair3_(0, __comp)
	{
	__begin_node() = __end_node();
	}

	template <class _Tp, class _Compare, class _Allocator>
	__tree<_Tp, _Compare, _Allocator>::__tree(const allocator_type& __a)
	: __begin_node_(__iter_pointer()),
	__pair1_(__second_tag(), __node_allocator(__a)),
	__pair3_(0)
	{
	__begin_node() = __end_node();
	}

	template <class _Tp, class _Compare, class _Allocator>
	__tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp,
	const allocator_type& __a)
	: __begin_node_(__iter_pointer()),
	__pair1_(__second_tag(), __node_allocator(__a)),
	__pair3_(0, __comp)
	{
	__begin_node() = __end_node();
	}

	// Precondition: size() != 0
	template <class _Tp, class _Compare, class _Allocator>
	typename __tree<_Tp, _Compare, _Allocator>::__node_pointer
	__tree<_Tp, _Compare, _Allocator>::__detach()
	{
	__node_pointer __cache = static_cast<__node_pointer>(__begin_node());
	__begin_node() = __end_node();
	__end_node()->__left_->__parent_ = nullptr;
	__end_node()->__left_ = nullptr;
	size() = 0;
	// __cache->__left_ == nullptr
	if (__cache->__right_ != nullptr)
	__cache = static_cast<__node_pointer>(__cache->__right_);
	// __cache->__left_ == nullptr
	// __cache->__right_ == nullptr
	return __cache;
	}

	// Precondition: __cache != nullptr
	// __cache->left_ == nullptr
	// __cache->right_ == nullptr
	// This is no longer a red-black tree
	template <class _Tp, class _Compare, class _Allocator>
	typename __tree<_Tp, _Compare, _Allocator>::__node_pointer
	__tree<_Tp, _Compare, _Allocator>::__detach(__node_pointer __cache)
	{
	if (__cache->__parent_ == nullptr)
	return nullptr;
	if (__tree_is_left_child(static_cast<__node_base_pointer>(__cache)))
	{
	__cache->__parent_->__left_ = nullptr;
	__cache = static_cast<__node_pointer>(__cache->__parent_);
	if (__cache->__right_ == nullptr)
	return __cache;
	return static_cast<__node_pointer>(__tree_leaf(__cache->__right_));
	}
	// __cache is right child
	__cache->__parent_unsafe()->__right_ = nullptr;
	__cache = static_cast<__node_pointer>(__cache->__parent_);
	if (__cache->__left_ == nullptr)
	return __cache;
	return static_cast<__node_pointer>(__tree_leaf(__cache->__left_));
	}

	template <class _Tp, class _Compare, class _Allocator>
	__tree<_Tp, _Compare, _Allocator>&
	__tree<_Tp, _Compare, _Allocator>::operator=(const __tree& __t)
	{
	if (this != &__t)
	{
	value_comp() = __t.value_comp();
	__copy_assign_alloc(__t);
	__assign_multi(__t.begin(), __t.end());
	}
	return *this;
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class _InputIterator>
	void
	__tree<_Tp, _Compare, _Allocator>::__assign_unique(_InputIterator __first, _InputIterator __last)
	{
	typedef iterator_traits<_InputIterator> _ITraits;
	typedef typename _ITraits::value_type _ItValueType;
	static_assert((is_same<_ItValueType, __container_value_type>::value),
	"__assign_unique may only be called with the containers value type");

	if (size() != 0)
	{
	__node_pointer __cache = __detach();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (; __cache != nullptr && __first != __last; ++__first)
	{
	__cache->__value_ = *__first;
	__node_pointer __next = __detach(__cache);
	__node_insert_unique(__cache);
	__cache = __next;
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	while (__cache->__parent_ != nullptr)
	__cache = static_cast<__node_pointer>(__cache->__parent_);
	destroy(__cache);
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	if (__cache != nullptr)
	{
	while (__cache->__parent_ != nullptr)
	__cache = static_cast<__node_pointer>(__cache->__parent_);
	destroy(__cache);
	}
	}
	for (; __first != __last; ++__first)
	__insert_unique(*__first);
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class _InputIterator>
	void
	__tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _InputIterator __last)
	{
	typedef iterator_traits<_InputIterator> _ITraits;
	typedef typename _ITraits::value_type _ItValueType;
	static_assert((is_same<_ItValueType, __container_value_type>::value \|\|
	is_same<_ItValueType, __node_value_type>::value),
	"__assign_multi may only be called with the containers value type"
	" or the nodes value type");
	if (size() != 0)
	{
	__node_pointer __cache = __detach();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (; __cache != nullptr && __first != __last; ++__first)
	{
	__cache->__value_ = *__first;
	__node_pointer __next = __detach(__cache);
	__node_insert_multi(__cache);
	__cache = __next;
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	while (__cache->__parent_ != nullptr)
	__cache = static_cast<__node_pointer>(__cache->__parent_);
	destroy(__cache);
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	if (__cache != nullptr)
	{
	while (__cache->__parent_ != nullptr)
	__cache = static_cast<__node_pointer>(__cache->__parent_);
	destroy(__cache);
	}
	}
	for (; __first != __last; ++__first)
	__insert_multi(_NodeTypes::__get_value(*__first));
	}

	template <class _Tp, class _Compare, class _Allocator>
	__tree<_Tp, _Compare, _Allocator>::__tree(const __tree& __t)
	: __begin_node_(__iter_pointer()),
	__pair1_(__second_tag(), __node_traits::select_on_container_copy_construction(__t.__node_alloc())),
	__pair3_(0, __t.value_comp())
	{
	__begin_node() = __end_node();
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Compare, class _Allocator>
	__tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t)
	_NOEXCEPT_(
	is_nothrow_move_constructible<__node_allocator>::value &&
	is_nothrow_move_constructible<value_compare>::value)
	: __begin_node_(_VSTD::move(__t.__begin_node_)),
	__pair1_(_VSTD::move(__t.__pair1_)),
	__pair3_(_VSTD::move(__t.__pair3_))
	{
	if (size() == 0)
	__begin_node() = __end_node();
	else
	{
	__end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
	__t.__begin_node() = __t.__end_node();
	__t.__end_node()->__left_ = nullptr;
	__t.size() = 0;
	}
	}

	template <class _Tp, class _Compare, class _Allocator>
	__tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t, const allocator_type& __a)
	: __pair1_(__second_tag(), __node_allocator(__a)),
	__pair3_(0, _VSTD::move(__t.value_comp()))
	{
	if (__a == __t.__alloc())
	{
	if (__t.size() == 0)
	__begin_node() = __end_node();
	else
	{
	__begin_node() = __t.__begin_node();
	__end_node()->__left_ = __t.__end_node()->__left_;
	__end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
	size() = __t.size();
	__t.__begin_node() = __t.__end_node();
	__t.__end_node()->__left_ = nullptr;
	__t.size() = 0;
	}
	}
	else
	{
	__begin_node() = __end_node();
	}
	}

	template <class _Tp, class _Compare, class _Allocator>
	void
	__tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, true_type)
	_NOEXCEPT_(is_nothrow_move_assignable<value_compare>::value &&
	is_nothrow_move_assignable<__node_allocator>::value)
	{
	destroy(static_cast<__node_pointer>(__end_node()->__left_));
	__begin_node_ = __t.__begin_node_;
	__pair1_.first() = __t.__pair1_.first();
	__move_assign_alloc(__t);
	__pair3_ = _VSTD::move(__t.__pair3_);
	if (size() == 0)
	__begin_node() = __end_node();
	else
	{
	__end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
	__t.__begin_node() = __t.__end_node();
	__t.__end_node()->__left_ = nullptr;
	__t.size() = 0;
	}
	}

	template <class _Tp, class _Compare, class _Allocator>
	void
	__tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
	{
	if (__node_alloc() == __t.__node_alloc())
	__move_assign(__t, true_type());
	else
	{
	value_comp() = _VSTD::move(__t.value_comp());
	const_iterator __e = end();
	if (size() != 0)
	{
	__node_pointer __cache = __detach();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	while (__cache != nullptr && __t.size() != 0)
	{
	__cache->__value_ = _VSTD::move(__t.remove(__t.begin())->__value_);
	__node_pointer __next = __detach(__cache);
	__node_insert_multi(__cache);
	__cache = __next;
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	while (__cache->__parent_ != nullptr)
	__cache = static_cast<__node_pointer>(__cache->__parent_);
	destroy(__cache);
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	if (__cache != nullptr)
	{
	while (__cache->__parent_ != nullptr)
	__cache = static_cast<__node_pointer>(__cache->__parent_);
	destroy(__cache);
	}
	}
	while (__t.size() != 0)
	__insert_multi(__e, _NodeTypes::__move(__t.remove(__t.begin())->__value_));
	}
	}

	template <class _Tp, class _Compare, class _Allocator>
	__tree<_Tp, _Compare, _Allocator>&
	__tree<_Tp, _Compare, _Allocator>::operator=(__tree&& __t)
	_NOEXCEPT_(
	__node_traits::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<value_compare>::value &&
	is_nothrow_move_assignable<__node_allocator>::value)

	{
	__move_assign(__t, integral_constant<bool,
	__node_traits::propagate_on_container_move_assignment::value>());
	return *this;
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Compare, class _Allocator>
	__tree<_Tp, _Compare, _Allocator>::~__tree()
	{
	static_assert((is_copy_constructible<value_compare>::value),
	"Comparator must be copy-constructible.");
	#ifndef _LIBCPP_CXX03_LANG
	static_assert((__diagnose_tree_helper<_Tp, _Compare, _Allocator>::
	__trigger_diagnostics()), "");
	#endif
	destroy(__root());
	}

	template <class _Tp, class _Compare, class _Allocator>
	void
	__tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd) _NOEXCEPT
	{
	if (__nd != nullptr)
	{
	destroy(static_cast<__node_pointer>(__nd->__left_));
	destroy(static_cast<__node_pointer>(__nd->__right_));
	__node_allocator& __na = __node_alloc();
	__node_traits::destroy(__na, _NodeTypes::__get_ptr(__nd->__value_));
	__node_traits::deallocate(__na, __nd, 1);
	}
	}

	template <class _Tp, class _Compare, class _Allocator>
	void
	__tree<_Tp, _Compare, _Allocator>::swap(__tree& __t)
	#if _LIBCPP_STD_VER <= 11
	_NOEXCEPT_(
	__is_nothrow_swappable<value_compare>::value
	&& (!__node_traits::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<__node_allocator>::value)
	)
	#else
	_NOEXCEPT_(__is_nothrow_swappable<value_compare>::value)
	#endif
	{
	using _VSTD::swap;
	swap(__begin_node_, __t.__begin_node_);
	swap(__pair1_.first(), __t.__pair1_.first());
	__swap_allocator(__node_alloc(), __t.__node_alloc());
	__pair3_.swap(__t.__pair3_);
	if (size() == 0)
	__begin_node() = __end_node();
	else
	__end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
	if (__t.size() == 0)
	__t.__begin_node() = __t.__end_node();
	else
	__t.__end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__t.__end_node());
	}

	template <class _Tp, class _Compare, class _Allocator>
	void
	__tree<_Tp, _Compare, _Allocator>::clear() _NOEXCEPT
	{
	destroy(__root());
	size() = 0;
	__begin_node() = __end_node();
	__end_node()->__left_ = nullptr;
	}

	// Find lower_bound place to insert
	// Set __parent to parent of null leaf
	// Return reference to null leaf
	template <class _Tp, class _Compare, class _Allocator>
	typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
	__tree<_Tp, _Compare, _Allocator>::__find_leaf_low(__parent_pointer& __parent,
	const key_type& __v)
	{
	__node_pointer __nd = __root();
	if (__nd != nullptr)
	{
	while (true)
	{
	if (value_comp()(__nd->__value_, __v))
	{
	if (__nd->__right_ != nullptr)
	__nd = static_cast<__node_pointer>(__nd->__right_);
	else
	{
	__parent = static_cast<__parent_pointer>(__nd);
	return __nd->__right_;
	}
	}
	else
	{
	if (__nd->__left_ != nullptr)
	__nd = static_cast<__node_pointer>(__nd->__left_);
	else
	{
	__parent = static_cast<__parent_pointer>(__nd);
	return __parent->__left_;
	}
	}
	}
	}
	__parent = static_cast<__parent_pointer>(__end_node());
	return __parent->__left_;
	}

	// Find upper_bound place to insert
	// Set __parent to parent of null leaf
	// Return reference to null leaf
	template <class _Tp, class _Compare, class _Allocator>
	typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
	__tree<_Tp, _Compare, _Allocator>::__find_leaf_high(__parent_pointer& __parent,
	const key_type& __v)
	{
	__node_pointer __nd = __root();
	if (__nd != nullptr)
	{
	while (true)
	{
	if (value_comp()(__v, __nd->__value_))
	{
	if (__nd->__left_ != nullptr)
	__nd = static_cast<__node_pointer>(__nd->__left_);
	else
	{
	__parent = static_cast<__parent_pointer>(__nd);
	return __parent->__left_;
	}
	}
	else
	{
	if (__nd->__right_ != nullptr)
	__nd = static_cast<__node_pointer>(__nd->__right_);
	else
	{
	__parent = static_cast<__parent_pointer>(__nd);
	return __nd->__right_;
	}
	}
	}
	}
	__parent = static_cast<__parent_pointer>(__end_node());
	return __parent->__left_;
	}

	// Find leaf place to insert closest to __hint
	// First check prior to __hint.
	// Next check after __hint.
	// Next do O(log N) search.
	// Set __parent to parent of null leaf
	// Return reference to null leaf
	template <class _Tp, class _Compare, class _Allocator>
	typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
	__tree<_Tp, _Compare, _Allocator>::__find_leaf(const_iterator __hint,
	__parent_pointer& __parent,
	const key_type& __v)
	{
	if (__hint == end() \|\| !value_comp()(*__hint, __v)) // check before
	{
	// __v <= *__hint
	const_iterator __prior = __hint;
	if (__prior == begin() \|\| !value_comp()(__v, *--__prior))
	{
	// prev(__hint) <= __v <= __hint
	if (__hint.__ptr_->__left_ == nullptr)
	{
	__parent = static_cast<__parent_pointer>(__hint.__ptr_);
	return __parent->__left_;
	}
	else
	{
	__parent = static_cast<__parent_pointer>(__prior.__ptr_);
	return static_cast<__node_base_pointer>(__prior.__ptr_)->__right_;
	}
	}
	// __v < *prev(__hint)
	return __find_leaf_high(__parent, __v);
	}
	// else __v > *__hint
	return __find_leaf_low(__parent, __v);
	}

	// Find place to insert if __v doesn't exist
	// Set __parent to parent of null leaf
	// Return reference to null leaf
	// If __v exists, set parent to node of __v and return reference to node of __v
	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key>
	typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
	__tree<_Tp, _Compare, _Allocator>::__find_equal(__parent_pointer& __parent,
	const _Key& __v)
	{
	__node_pointer __nd = __root();
	__node_base_pointer* __nd_ptr = __root_ptr();
	if (__nd != nullptr)
	{
	while (true)
	{
	if (value_comp()(__v, __nd->__value_))
	{
	if (__nd->__left_ != nullptr) {
	__nd_ptr = _VSTD::addressof(__nd->__left_);
	__nd = static_cast<__node_pointer>(__nd->__left_);
	} else {
	__parent = static_cast<__parent_pointer>(__nd);
	return __parent->__left_;
	}
	}
	else if (value_comp()(__nd->__value_, __v))
	{
	if (__nd->__right_ != nullptr) {
	__nd_ptr = _VSTD::addressof(__nd->__right_);
	__nd = static_cast<__node_pointer>(__nd->__right_);
	} else {
	__parent = static_cast<__parent_pointer>(__nd);
	return __nd->__right_;
	}
	}
	else
	{
	__parent = static_cast<__parent_pointer>(__nd);
	return *__nd_ptr;
	}
	}
	}
	__parent = static_cast<__parent_pointer>(__end_node());
	return __parent->__left_;
	}

	// Find place to insert if __v doesn't exist
	// First check prior to __hint.
	// Next check after __hint.
	// Next do O(log N) search.
	// Set __parent to parent of null leaf
	// Return reference to null leaf
	// If __v exists, set parent to node of __v and return reference to node of __v
	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key>
	typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
	__tree<_Tp, _Compare, _Allocator>::__find_equal(const_iterator __hint,
	__parent_pointer& __parent,
	__node_base_pointer& __dummy,
	const _Key& __v)
	{
	if (__hint == end() \|\| value_comp()(__v, *__hint)) // check before
	{
	// __v < *__hint
	const_iterator __prior = __hint;
	if (__prior == begin() \|\| value_comp()(*--__prior, __v))
	{
	// prev(__hint) < __v < __hint
	if (__hint.__ptr_->__left_ == nullptr)
	{
	__parent = static_cast<__parent_pointer>(__hint.__ptr_);
	return __parent->__left_;
	}
	else
	{
	__parent = static_cast<__parent_pointer>(__prior.__ptr_);
	return static_cast<__node_base_pointer>(__prior.__ptr_)->__right_;
	}
	}
	// __v <= *prev(__hint)
	return __find_equal(__parent, __v);
	}
	else if (value_comp()(*__hint, __v)) // check after
	{
	// *__hint < __v
	const_iterator __next = _VSTD::next(__hint);
	if (__next == end() \|\| value_comp()(__v, *__next))
	{
	// __hint < __v < _VSTD::next(__hint)
	if (__hint.__get_np()->__right_ == nullptr)
	{
	__parent = static_cast<__parent_pointer>(__hint.__ptr_);
	return static_cast<__node_base_pointer>(__hint.__ptr_)->__right_;
	}
	else
	{
	__parent = static_cast<__parent_pointer>(__next.__ptr_);
	return __parent->__left_;
	}
	}
	// *next(__hint) <= __v
	return __find_equal(__parent, __v);
	}
	// else __v == *__hint
	__parent = static_cast<__parent_pointer>(__hint.__ptr_);
	__dummy = static_cast<__node_base_pointer>(__hint.__ptr_);
	return __dummy;
	}

	template <class _Tp, class _Compare, class _Allocator>
	void
	__tree<_Tp, _Compare, _Allocator>::__insert_node_at(__parent_pointer __parent,
	__node_base_pointer& __child,
	__node_base_pointer __new_node)
	{
	__new_node->__left_ = nullptr;
	__new_node->__right_ = nullptr;
	__new_node->__parent_ = __parent;
	// __new_node->__is_black_ is initialized in __tree_balance_after_insert
	__child = __new_node;
	if (__begin_node()->__left_ != nullptr)
	__begin_node() = static_cast<__iter_pointer>(__begin_node()->__left_);
	__tree_balance_after_insert(__end_node()->__left_, __child);
	++size();
	}

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key, class... _Args>
	pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
	__tree<_Tp, _Compare, _Allocator>::__emplace_unique_key_args(_Key const& __k, _Args&&... __args)
	#else
	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key, class _Args>
	pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
	__tree<_Tp, _Compare, _Allocator>::__emplace_unique_key_args(_Key const& __k, _Args& __args)
	#endif
	{
	__parent_pointer __parent;
	__node_base_pointer& __child = __find_equal(__parent, __k);
	__node_pointer __r = static_cast<__node_pointer>(__child);
	bool __inserted = false;
	if (__child == nullptr)
	{
	#ifndef _LIBCPP_CXX03_LANG
	__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
	#else
	__node_holder __h = __construct_node(__args);
	#endif
	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
	__r = __h.release();
	__inserted = true;
	}
	return pair<iterator, bool>(iterator(__r), __inserted);
	}


	#ifndef _LIBCPP_CXX03_LANG
	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key, class... _Args>
	typename __tree<_Tp, _Compare, _Allocator>::iterator
	__tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_key_args(
	const_iterator __p, _Key const& __k, _Args&&... __args)
	#else
	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key, class _Args>
	typename __tree<_Tp, _Compare, _Allocator>::iterator
	__tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_key_args(
	const_iterator __p, _Key const& __k, _Args& __args)
	#endif
	{
	__parent_pointer __parent;
	__node_base_pointer __dummy;
	__node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __k);
	__node_pointer __r = static_cast<__node_pointer>(__child);
	if (__child == nullptr)
	{
	#ifndef _LIBCPP_CXX03_LANG
	__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
	#else
	__node_holder __h = __construct_node(__args);
	#endif
	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
	__r = __h.release();
	}
	return iterator(__r);
	}


	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Compare, class _Allocator>
	template <class ..._Args>
	typename __tree<_Tp, _Compare, _Allocator>::__node_holder
	__tree<_Tp, _Compare, _Allocator>::__construct_node(_Args&& ...__args)
	{
	static_assert(!__is_tree_value_type<_Args...>::value,
	"Cannot construct from __value_type");
	__node_allocator& __na = __node_alloc();
	__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
	__node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), _VSTD::forward<_Args>(__args)...);
	__h.get_deleter().__value_constructed = true;
	return __h;
	}


	template <class _Tp, class _Compare, class _Allocator>
	template <class... _Args>
	pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
	__tree<_Tp, _Compare, _Allocator>::__emplace_unique_impl(_Args&&... __args)
	{
	__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
	__parent_pointer __parent;
	__node_base_pointer& __child = __find_equal(__parent, __h->__value_);
	__node_pointer __r = static_cast<__node_pointer>(__child);
	bool __inserted = false;
	if (__child == nullptr)
	{
	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
	__r = __h.release();
	__inserted = true;
	}
	return pair<iterator, bool>(iterator(__r), __inserted);
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class... _Args>
	typename __tree<_Tp, _Compare, _Allocator>::iterator
	__tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_impl(const_iterator __p, _Args&&... __args)
	{
	__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
	__parent_pointer __parent;
	__node_base_pointer __dummy;
	__node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __h->__value_);
	__node_pointer __r = static_cast<__node_pointer>(__child);
	if (__child == nullptr)
	{
	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
	__r = __h.release();
	}
	return iterator(__r);
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class... _Args>
	typename __tree<_Tp, _Compare, _Allocator>::iterator
	__tree<_Tp, _Compare, _Allocator>::__emplace_multi(_Args&&... __args)
	{
	__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
	__parent_pointer __parent;
	__node_base_pointer& __child = __find_leaf_high(__parent, _NodeTypes::__get_key(__h->__value_));
	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
	return iterator(static_cast<__node_pointer>(__h.release()));
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class... _Args>
	typename __tree<_Tp, _Compare, _Allocator>::iterator
	__tree<_Tp, _Compare, _Allocator>::__emplace_hint_multi(const_iterator __p,
	_Args&&... __args)
	{
	__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
	__parent_pointer __parent;
	__node_base_pointer& __child = __find_leaf(__p, __parent, _NodeTypes::__get_key(__h->__value_));
	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
	return iterator(static_cast<__node_pointer>(__h.release()));
	}


	#else // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Compare, class _Allocator>
	typename __tree<_Tp, _Compare, _Allocator>::__node_holder
	__tree<_Tp, _Compare, _Allocator>::__construct_node(const __container_value_type& __v)
	{
	__node_allocator& __na = __node_alloc();
	__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
	__node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), __v);
	__h.get_deleter().__value_constructed = true;
	return _LIBCPP_EXPLICIT_MOVE(__h); // explicitly moved for C++03
	}

	#endif // _LIBCPP_CXX03_LANG

	#ifdef _LIBCPP_CXX03_LANG
	template <class _Tp, class _Compare, class _Allocator>
	typename __tree<_Tp, _Compare, _Allocator>::iterator
	__tree<_Tp, _Compare, _Allocator>::__insert_multi(const __container_value_type& __v)
	{
	__parent_pointer __parent;
	__node_base_pointer& __child = __find_leaf_high(__parent, _NodeTypes::__get_key(__v));
	__node_holder __h = __construct_node(__v);
	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
	return iterator(__h.release());
	}

	template <class _Tp, class _Compare, class _Allocator>
	typename __tree<_Tp, _Compare, _Allocator>::iterator
	__tree<_Tp, _Compare, _Allocator>::__insert_multi(const_iterator __p, const __container_value_type& __v)
	{
	__parent_pointer __parent;
	__node_base_pointer& __child = __find_leaf(__p, __parent, _NodeTypes::__get_key(__v));
	__node_holder __h = __construct_node(__v);
	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
	return iterator(__h.release());
	}
	#endif

	template <class _Tp, class _Compare, class _Allocator>
	pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
	__tree<_Tp, _Compare, _Allocator>::__node_insert_unique(__node_pointer __nd)
	{
	__parent_pointer __parent;
	__node_base_pointer& __child = __find_equal(__parent, __nd->__value_);
	__node_pointer __r = static_cast<__node_pointer>(__child);
	bool __inserted = false;
	if (__child == nullptr)
	{
	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
	__r = __nd;
	__inserted = true;
	}
	return pair<iterator, bool>(iterator(__r), __inserted);
	}

	template <class _Tp, class _Compare, class _Allocator>
	typename __tree<_Tp, _Compare, _Allocator>::iterator
	__tree<_Tp, _Compare, _Allocator>::__node_insert_unique(const_iterator __p,
	__node_pointer __nd)
	{
	__parent_pointer __parent;
	__node_base_pointer __dummy;
	__node_base_pointer& __child = __find_equal(__p, __parent, __nd->__value_);
	__node_pointer __r = static_cast<__node_pointer>(__child);
	if (__child == nullptr)
	{
	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
	__r = __nd;
	}
	return iterator(__r);
	}

	template <class _Tp, class _Compare, class _Allocator>
	typename __tree<_Tp, _Compare, _Allocator>::iterator
	__tree<_Tp, _Compare, _Allocator>::__node_insert_multi(__node_pointer __nd)
	{
	__parent_pointer __parent;
	__node_base_pointer& __child = __find_leaf_high(__parent, _NodeTypes::__get_key(__nd->__value_));
	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
	return iterator(__nd);
	}

	template <class _Tp, class _Compare, class _Allocator>
	typename __tree<_Tp, _Compare, _Allocator>::iterator
	__tree<_Tp, _Compare, _Allocator>::__node_insert_multi(const_iterator __p,
	__node_pointer __nd)
	{
	__parent_pointer __parent;
	__node_base_pointer& __child = __find_leaf(__p, __parent, _NodeTypes::__get_key(__nd->__value_));
	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
	return iterator(__nd);
	}

	template <class _Tp, class _Compare, class _Allocator>
	typename __tree<_Tp, _Compare, _Allocator>::iterator
	__tree<_Tp, _Compare, _Allocator>::erase(const_iterator __p)
	{
	__node_pointer __np = __p.__get_np();
	iterator __r(__p.__ptr_);
	++__r;
	if (__begin_node() == __p.__ptr_)
	__begin_node() = __r.__ptr_;
	--size();
	__node_allocator& __na = __node_alloc();
	__tree_remove(__end_node()->__left_,
	static_cast<__node_base_pointer>(__np));
	__node_traits::destroy(__na, _NodeTypes::__get_ptr(
	const_cast<__node_value_type&>(*__p)));
	__node_traits::deallocate(__na, __np, 1);
	return __r;
	}

	template <class _Tp, class _Compare, class _Allocator>
	typename __tree<_Tp, _Compare, _Allocator>::iterator
	__tree<_Tp, _Compare, _Allocator>::erase(const_iterator __f, const_iterator __l)
	{
	while (__f != __l)
	__f = erase(__f);
	return iterator(__l.__ptr_);
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key>
	typename __tree<_Tp, _Compare, _Allocator>::size_type
	__tree<_Tp, _Compare, _Allocator>::__erase_unique(const _Key& __k)
	{
	iterator __i = find(__k);
	if (__i == end())
	return 0;
	erase(__i);
	return 1;
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key>
	typename __tree<_Tp, _Compare, _Allocator>::size_type
	__tree<_Tp, _Compare, _Allocator>::__erase_multi(const _Key& __k)
	{
	pair<iterator, iterator> __p = __equal_range_multi(__k);
	size_type __r = 0;
	for (; __p.first != __p.second; ++__r)
	__p.first = erase(__p.first);
	return __r;
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key>
	typename __tree<_Tp, _Compare, _Allocator>::iterator
	__tree<_Tp, _Compare, _Allocator>::find(const _Key& __v)
	{
	iterator __p = __lower_bound(__v, __root(), __end_node());
	if (__p != end() && !value_comp()(__v, *__p))
	return __p;
	return end();
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key>
	typename __tree<_Tp, _Compare, _Allocator>::const_iterator
	__tree<_Tp, _Compare, _Allocator>::find(const _Key& __v) const
	{
	const_iterator __p = __lower_bound(__v, __root(), __end_node());
	if (__p != end() && !value_comp()(__v, *__p))
	return __p;
	return end();
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key>
	typename __tree<_Tp, _Compare, _Allocator>::size_type
	__tree<_Tp, _Compare, _Allocator>::__count_unique(const _Key& __k) const
	{
	__node_pointer __rt = __root();
	while (__rt != nullptr)
	{
	if (value_comp()(__k, __rt->__value_))
	{
	__rt = static_cast<__node_pointer>(__rt->__left_);
	}
	else if (value_comp()(__rt->__value_, __k))
	__rt = static_cast<__node_pointer>(__rt->__right_);
	else
	return 1;
	}
	return 0;
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key>
	typename __tree<_Tp, _Compare, _Allocator>::size_type
	__tree<_Tp, _Compare, _Allocator>::__count_multi(const _Key& __k) const
	{
	__iter_pointer __result = __end_node();
	__node_pointer __rt = __root();
	while (__rt != nullptr)
	{
	if (value_comp()(__k, __rt->__value_))
	{
	__result = static_cast<__iter_pointer>(__rt);
	__rt = static_cast<__node_pointer>(__rt->__left_);
	}
	else if (value_comp()(__rt->__value_, __k))
	__rt = static_cast<__node_pointer>(__rt->__right_);
	else
	return _VSTD::distance(
	__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__iter_pointer>(__rt)),
	__upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result)
	);
	}
	return 0;
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key>
	typename __tree<_Tp, _Compare, _Allocator>::iterator
	__tree<_Tp, _Compare, _Allocator>::__lower_bound(const _Key& __v,
	__node_pointer __root,
	__iter_pointer __result)
	{
	while (__root != nullptr)
	{
	if (!value_comp()(__root->__value_, __v))
	{
	__result = static_cast<__iter_pointer>(__root);
	__root = static_cast<__node_pointer>(__root->__left_);
	}
	else
	__root = static_cast<__node_pointer>(__root->__right_);
	}
	return iterator(__result);
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key>
	typename __tree<_Tp, _Compare, _Allocator>::const_iterator
	__tree<_Tp, _Compare, _Allocator>::__lower_bound(const _Key& __v,
	__node_pointer __root,
	__iter_pointer __result) const
	{
	while (__root != nullptr)
	{
	if (!value_comp()(__root->__value_, __v))
	{
	__result = static_cast<__iter_pointer>(__root);
	__root = static_cast<__node_pointer>(__root->__left_);
	}
	else
	__root = static_cast<__node_pointer>(__root->__right_);
	}
	return const_iterator(__result);
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key>
	typename __tree<_Tp, _Compare, _Allocator>::iterator
	__tree<_Tp, _Compare, _Allocator>::__upper_bound(const _Key& __v,
	__node_pointer __root,
	__iter_pointer __result)
	{
	while (__root != nullptr)
	{
	if (value_comp()(__v, __root->__value_))
	{
	__result = static_cast<__iter_pointer>(__root);
	__root = static_cast<__node_pointer>(__root->__left_);
	}
	else
	__root = static_cast<__node_pointer>(__root->__right_);
	}
	return iterator(__result);
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key>
	typename __tree<_Tp, _Compare, _Allocator>::const_iterator
	__tree<_Tp, _Compare, _Allocator>::__upper_bound(const _Key& __v,
	__node_pointer __root,
	__iter_pointer __result) const
	{
	while (__root != nullptr)
	{
	if (value_comp()(__v, __root->__value_))
	{
	__result = static_cast<__iter_pointer>(__root);
	__root = static_cast<__node_pointer>(__root->__left_);
	}
	else
	__root = static_cast<__node_pointer>(__root->__right_);
	}
	return const_iterator(__result);
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key>
	pair<typename __tree<_Tp, _Compare, _Allocator>::iterator,
	typename __tree<_Tp, _Compare, _Allocator>::iterator>
	__tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k)
	{
	typedef pair<iterator, iterator> _Pp;
	__iter_pointer __result = __end_node();
	__node_pointer __rt = __root();
	while (__rt != nullptr)
	{
	if (value_comp()(__k, __rt->__value_))
	{
	__result = static_cast<__iter_pointer>(__rt);
	__rt = static_cast<__node_pointer>(__rt->__left_);
	}
	else if (value_comp()(__rt->__value_, __k))
	__rt = static_cast<__node_pointer>(__rt->__right_);
	else
	return _Pp(iterator(__rt),
	iterator(
	__rt->__right_ != nullptr ?
	static_cast<__iter_pointer>(__tree_min(__rt->__right_))
	: __result));
	}
	return _Pp(iterator(__result), iterator(__result));
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key>
	pair<typename __tree<_Tp, _Compare, _Allocator>::const_iterator,
	typename __tree<_Tp, _Compare, _Allocator>::const_iterator>
	__tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k) const
	{
	typedef pair<const_iterator, const_iterator> _Pp;
	__iter_pointer __result = __end_node();
	__node_pointer __rt = __root();
	while (__rt != nullptr)
	{
	if (value_comp()(__k, __rt->__value_))
	{
	__result = static_cast<__iter_pointer>(__rt);
	__rt = static_cast<__node_pointer>(__rt->__left_);
	}
	else if (value_comp()(__rt->__value_, __k))
	__rt = static_cast<__node_pointer>(__rt->__right_);
	else
	return _Pp(const_iterator(__rt),
	const_iterator(
	__rt->__right_ != nullptr ?
	static_cast<__iter_pointer>(__tree_min(__rt->__right_))
	: __result));
	}
	return _Pp(const_iterator(__result), const_iterator(__result));
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key>
	pair<typename __tree<_Tp, _Compare, _Allocator>::iterator,
	typename __tree<_Tp, _Compare, _Allocator>::iterator>
	__tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k)
	{
	typedef pair<iterator, iterator> _Pp;
	__iter_pointer __result = __end_node();
	__node_pointer __rt = __root();
	while (__rt != nullptr)
	{
	if (value_comp()(__k, __rt->__value_))
	{
	__result = static_cast<__iter_pointer>(__rt);
	__rt = static_cast<__node_pointer>(__rt->__left_);
	}
	else if (value_comp()(__rt->__value_, __k))
	__rt = static_cast<__node_pointer>(__rt->__right_);
	else
	return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__iter_pointer>(__rt)),
	__upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result));
	}
	return _Pp(iterator(__result), iterator(__result));
	}

	template <class _Tp, class _Compare, class _Allocator>
	template <class _Key>
	pair<typename __tree<_Tp, _Compare, _Allocator>::const_iterator,
	typename __tree<_Tp, _Compare, _Allocator>::const_iterator>
	__tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) const
	{
	typedef pair<const_iterator, const_iterator> _Pp;
	__iter_pointer __result = __end_node();
	__node_pointer __rt = __root();
	while (__rt != nullptr)
	{
	if (value_comp()(__k, __rt->__value_))
	{
	__result = static_cast<__iter_pointer>(__rt);
	__rt = static_cast<__node_pointer>(__rt->__left_);
	}
	else if (value_comp()(__rt->__value_, __k))
	__rt = static_cast<__node_pointer>(__rt->__right_);
	else
	return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__iter_pointer>(__rt)),
	__upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result));
	}
	return _Pp(const_iterator(__result), const_iterator(__result));
	}

	template <class _Tp, class _Compare, class _Allocator>
	typename __tree<_Tp, _Compare, _Allocator>::__node_holder
	__tree<_Tp, _Compare, _Allocator>::remove(const_iterator __p) _NOEXCEPT
	{
	__node_pointer __np = __p.__get_np();
	if (__begin_node() == __p.__ptr_)
	{
	if (__np->__right_ != nullptr)
	__begin_node() = static_cast<__iter_pointer>(__np->__right_);
	else
	__begin_node() = static_cast<__iter_pointer>(__np->__parent_);
	}
	--size();
	__tree_remove(__end_node()->__left_,
	static_cast<__node_base_pointer>(__np));
	return __node_holder(__np, _Dp(__node_alloc(), true));
	}

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

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP___TREE
	Index: projects/clang700-import/contrib/libc++/include/algorithm
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/algorithm (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/algorithm (revision 337135)
	@@ -1,5905 +1,5821 @@
	// -- C++ --
	//===-------------------------- algorithm ---------------------------------===//
	//
	// 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_ALGORITHM
	#define _LIBCPP_ALGORITHM

	/*
	algorithm synopsis

	#include <initializer_list>

	namespace std
	{

	template <class InputIterator, class Predicate>
	- bool
	+ constexpr bool // constexpr in C++20
	all_of(InputIterator first, InputIterator last, Predicate pred);

	template <class InputIterator, class Predicate>
	- bool
	+ constexpr bool // constexpr in C++20
	any_of(InputIterator first, InputIterator last, Predicate pred);

	template <class InputIterator, class Predicate>
	- bool
	+ constexpr bool // constexpr in C++20
	none_of(InputIterator first, InputIterator last, Predicate pred);

	template <class InputIterator, class Function>
	- Function
	+ constexpr Function // constexpr in C++20
	for_each(InputIterator first, InputIterator last, Function f);

	template<class InputIterator, class Size, class Function>
	- InputIterator for_each_n(InputIterator first, Size n, Function f); // C++17
	+ constexpr InputIterator // constexpr in C++20
	+ for_each_n(InputIterator first, Size n, Function f); // C++17

	template <class InputIterator, class T>
	- InputIterator
	+ constexpr InputIterator // constexpr in C++20
	find(InputIterator first, InputIterator last, const T& value);

	template <class InputIterator, class Predicate>
	- InputIterator
	+ constexpr InputIterator // constexpr in C++20
	find_if(InputIterator first, InputIterator last, Predicate pred);

	template<class InputIterator, class Predicate>
	- InputIterator
	+ InputIterator // constexpr in C++20
	find_if_not(InputIterator first, InputIterator last, Predicate pred);

	template <class ForwardIterator1, class ForwardIterator2>
	- ForwardIterator1
	+ ForwardIterator1 // constexpr in C++20
	find_end(ForwardIterator1 first1, ForwardIterator1 last1,
	ForwardIterator2 first2, ForwardIterator2 last2);

	template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
	- ForwardIterator1
	+ ForwardIterator1 // constexpr in C++20
	find_end(ForwardIterator1 first1, ForwardIterator1 last1,
	ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);

	template <class ForwardIterator1, class ForwardIterator2>
	- ForwardIterator1
	+ constexpr ForwardIterator1 // constexpr in C++20
	find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
	ForwardIterator2 first2, ForwardIterator2 last2);

	template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
	- ForwardIterator1
	+ constexpr ForwardIterator1 // constexpr in C++20
	find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
	ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);

	template <class ForwardIterator>
	- ForwardIterator
	+ constexpr ForwardIterator // constexpr in C++20
	adjacent_find(ForwardIterator first, ForwardIterator last);

	template <class ForwardIterator, class BinaryPredicate>
	- ForwardIterator
	+ constexpr ForwardIterator // constexpr in C++20
	adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);

	template <class InputIterator, class T>
	- typename iterator_traits<InputIterator>::difference_type
	+ constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20
	count(InputIterator first, InputIterator last, const T& value);

	template <class InputIterator, class Predicate>
	- typename iterator_traits<InputIterator>::difference_type
	+ constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20
	count_if(InputIterator first, InputIterator last, Predicate pred);

	template <class InputIterator1, class InputIterator2>
	- pair<InputIterator1, InputIterator2>
	+ constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
	mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);

	template <class InputIterator1, class InputIterator2>
	- pair<InputIterator1, InputIterator2>
	+ constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
	mismatch(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, InputIterator2 last2); // C++14

	template <class InputIterator1, class InputIterator2, class BinaryPredicate>
	- pair<InputIterator1, InputIterator2>
	+ constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
	mismatch(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, BinaryPredicate pred);

	template <class InputIterator1, class InputIterator2, class BinaryPredicate>
	- pair<InputIterator1, InputIterator2>
	+ constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
	mismatch(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, InputIterator2 last2,
	BinaryPredicate pred); // C++14

	template <class InputIterator1, class InputIterator2>
	- bool
	+ constexpr bool // constexpr in C++20
	equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);

	template <class InputIterator1, class InputIterator2>
	- bool
	+ constexpr bool // constexpr in C++20
	equal(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, InputIterator2 last2); // C++14

	template <class InputIterator1, class InputIterator2, class BinaryPredicate>
	- bool
	+ constexpr bool // constexpr in C++20
	equal(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, BinaryPredicate pred);

	template <class InputIterator1, class InputIterator2, class BinaryPredicate>
	- bool
	+ constexpr bool // constexpr in C++20
	equal(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, InputIterator2 last2,
	BinaryPredicate pred); // C++14

	template<class ForwardIterator1, class ForwardIterator2>
	- bool
	+ constexpr bool // constexpr in C++20
	is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
	ForwardIterator2 first2);

	template<class ForwardIterator1, class ForwardIterator2>
	- bool
	+ constexpr bool // constexpr in C++20
	is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
	ForwardIterator2 first2, ForwardIterator2 last2); // C++14

	template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
	- bool
	+ constexpr bool // constexpr in C++20
	is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
	ForwardIterator2 first2, BinaryPredicate pred);

	template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
	- bool
	+ constexpr bool // constexpr in C++20
	is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
	ForwardIterator2 first2, ForwardIterator2 last2,
	BinaryPredicate pred); // C++14

	template <class ForwardIterator1, class ForwardIterator2>
	- ForwardIterator1
	+ constexpr ForwardIterator1 // constexpr in C++20
	search(ForwardIterator1 first1, ForwardIterator1 last1,
	ForwardIterator2 first2, ForwardIterator2 last2);

	template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
	- ForwardIterator1
	+ constexpr ForwardIterator1 // constexpr in C++20
	search(ForwardIterator1 first1, ForwardIterator1 last1,
	ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);

	template <class ForwardIterator, class Size, class T>
	- ForwardIterator
	+ constexpr ForwardIterator // constexpr in C++20
	search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value);

	template <class ForwardIterator, class Size, class T, class BinaryPredicate>
	- ForwardIterator
	+ constexpr ForwardIterator // constexpr in C++20
	search_n(ForwardIterator first, ForwardIterator last,
	Size count, const T& value, BinaryPredicate pred);

	template <class InputIterator, class OutputIterator>
	OutputIterator
	copy(InputIterator first, InputIterator last, OutputIterator result);

	template<class InputIterator, class OutputIterator, class Predicate>
	OutputIterator
	copy_if(InputIterator first, InputIterator last,
	OutputIterator result, Predicate pred);

	template<class InputIterator, class Size, class OutputIterator>
	OutputIterator
	copy_n(InputIterator first, Size n, OutputIterator result);

	template <class BidirectionalIterator1, class BidirectionalIterator2>
	BidirectionalIterator2
	copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
	BidirectionalIterator2 result);

	template <class ForwardIterator1, class ForwardIterator2>
	ForwardIterator2
	swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);

	template <class ForwardIterator1, class ForwardIterator2>
	void
	iter_swap(ForwardIterator1 a, ForwardIterator2 b);

	template <class InputIterator, class OutputIterator, class UnaryOperation>
	- OutputIterator
	+ constexpr OutputIterator // constexpr in C++20
	transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op);

	template <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation>
	- OutputIterator
	+ constexpr OutputIterator // constexpr in C++20
	transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
	OutputIterator result, BinaryOperation binary_op);

	template <class ForwardIterator, class T>
	- void
	+ constexpr void // constexpr in C++20
	replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value);

	template <class ForwardIterator, class Predicate, class T>
	- void
	+ constexpr void // constexpr in C++20
	replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value);

	template <class InputIterator, class OutputIterator, class T>
	- OutputIterator
	+ constexpr OutputIterator // constexpr in C++20
	replace_copy(InputIterator first, InputIterator last, OutputIterator result,
	const T& old_value, const T& new_value);

	template <class InputIterator, class OutputIterator, class Predicate, class T>
	- OutputIterator
	+ constexpr OutputIterator // constexpr in C++20
	replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value);

	template <class ForwardIterator, class T>
	- void
	+ constexpr void // constexpr in C++20
	fill(ForwardIterator first, ForwardIterator last, const T& value);

	template <class OutputIterator, class Size, class T>
	- OutputIterator
	+ constexpr OutputIterator // constexpr in C++20
	fill_n(OutputIterator first, Size n, const T& value);

	template <class ForwardIterator, class Generator>
	- void
	+ constexpr void // constexpr in C++20
	generate(ForwardIterator first, ForwardIterator last, Generator gen);

	template <class OutputIterator, class Size, class Generator>
	- OutputIterator
	+ constexpr OutputIterator // constexpr in C++20
	generate_n(OutputIterator first, Size n, Generator gen);

	template <class ForwardIterator, class T>
	- ForwardIterator
	+ constexpr ForwardIterator // constexpr in C++20
	remove(ForwardIterator first, ForwardIterator last, const T& value);

	template <class ForwardIterator, class Predicate>
	- ForwardIterator
	+ constexpr ForwardIterator // constexpr in C++20
	remove_if(ForwardIterator first, ForwardIterator last, Predicate pred);

	template <class InputIterator, class OutputIterator, class T>
	- OutputIterator
	+ constexpr OutputIterator // constexpr in C++20
	remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value);

	template <class InputIterator, class OutputIterator, class Predicate>
	- OutputIterator
	+ constexpr OutputIterator // constexpr in C++20
	remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred);

	template <class ForwardIterator>
	ForwardIterator
	unique(ForwardIterator first, ForwardIterator last);

	template <class ForwardIterator, class BinaryPredicate>
	ForwardIterator
	unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);

	template <class InputIterator, class OutputIterator>
	OutputIterator
	unique_copy(InputIterator first, InputIterator last, OutputIterator result);

	template <class InputIterator, class OutputIterator, class BinaryPredicate>
	OutputIterator
	unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred);

	template <class BidirectionalIterator>
	void
	reverse(BidirectionalIterator first, BidirectionalIterator last);

	template <class BidirectionalIterator, class OutputIterator>
	- OutputIterator
	+ constexpr OutputIterator // constexpr in C++20
	reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result);

	template <class ForwardIterator>
	ForwardIterator
	rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);

	template <class ForwardIterator, class OutputIterator>
	OutputIterator
	rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result);

	template <class RandomAccessIterator>
	void
	random_shuffle(RandomAccessIterator first, RandomAccessIterator last); // deprecated in C++14, removed in C++17

	template <class RandomAccessIterator, class RandomNumberGenerator>
	void
	random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
	RandomNumberGenerator& rand); // deprecated in C++14, removed in C++17

	template<class PopulationIterator, class SampleIterator,
	class Distance, class UniformRandomBitGenerator>
	SampleIterator sample(PopulationIterator first, PopulationIterator last,
	SampleIterator out, Distance n,
	UniformRandomBitGenerator&& g); // C++17

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

	template <class InputIterator, class Predicate>
	- bool
	+ constexpr bool // constexpr in C++20
	is_partitioned(InputIterator first, InputIterator last, Predicate pred);

	template <class ForwardIterator, class Predicate>
	ForwardIterator
	partition(ForwardIterator first, ForwardIterator last, Predicate pred);

	template <class InputIterator, class OutputIterator1,
	class OutputIterator2, class Predicate>
	- pair<OutputIterator1, OutputIterator2>
	+ constexpr pair<OutputIterator1, OutputIterator2> // constexpr in C++20
	partition_copy(InputIterator first, InputIterator last,
	OutputIterator1 out_true, OutputIterator2 out_false,
	Predicate pred);

	template <class ForwardIterator, class Predicate>
	ForwardIterator
	stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred);

	template<class ForwardIterator, class Predicate>
	- ForwardIterator
	+ constexpr ForwardIterator // constexpr in C++20
	partition_point(ForwardIterator first, ForwardIterator last, Predicate pred);

	template <class ForwardIterator>
	- bool
	+ constexpr bool // constexpr in C++20
	is_sorted(ForwardIterator first, ForwardIterator last);

	template <class ForwardIterator, class Compare>
	bool
	is_sorted(ForwardIterator first, ForwardIterator last, Compare comp);

	template<class ForwardIterator>
	- ForwardIterator
	+ constexpr ForwardIterator // constexpr in C++20
	is_sorted_until(ForwardIterator first, ForwardIterator last);

	template <class ForwardIterator, class Compare>
	- ForwardIterator
	+ constexpr ForwardIterator // constexpr in C++20
	is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp);

	template <class RandomAccessIterator>
	void
	sort(RandomAccessIterator first, RandomAccessIterator last);

	template <class RandomAccessIterator, class Compare>
	void
	sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

	template <class RandomAccessIterator>
	void
	stable_sort(RandomAccessIterator first, RandomAccessIterator last);

	template <class RandomAccessIterator, class Compare>
	void
	stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

	template <class RandomAccessIterator>
	void
	partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last);

	template <class RandomAccessIterator, class Compare>
	void
	partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp);

	template <class InputIterator, class RandomAccessIterator>
	RandomAccessIterator
	partial_sort_copy(InputIterator first, InputIterator last,
	RandomAccessIterator result_first, RandomAccessIterator result_last);

	template <class InputIterator, class RandomAccessIterator, class Compare>
	RandomAccessIterator
	partial_sort_copy(InputIterator first, InputIterator last,
	RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp);

	template <class RandomAccessIterator>
	void
	nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last);

	template <class RandomAccessIterator, class Compare>
	void
	nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp);

	template <class ForwardIterator, class T>
	- ForwardIterator
	+ constexpr ForwardIterator // constexpr in C++20
	lower_bound(ForwardIterator first, ForwardIterator last, const T& value);

	template <class ForwardIterator, class T, class Compare>
	- ForwardIterator
	+ constexpr ForwardIterator // constexpr in C++20
	lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);

	template <class ForwardIterator, class T>
	- ForwardIterator
	+ constexpr ForwardIterator // constexpr in C++20
	upper_bound(ForwardIterator first, ForwardIterator last, const T& value);

	template <class ForwardIterator, class T, class Compare>
	- ForwardIterator
	+ constexpr ForwardIterator // constexpr in C++20
	upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);

	template <class ForwardIterator, class T>
	- pair<ForwardIterator, ForwardIterator>
	+ constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20
	equal_range(ForwardIterator first, ForwardIterator last, const T& value);

	template <class ForwardIterator, class T, class Compare>
	- pair<ForwardIterator, ForwardIterator>
	+ constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20
	equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);

	template <class ForwardIterator, class T>
	- bool
	+ constexpr bool // constexpr in C++20
	binary_search(ForwardIterator first, ForwardIterator last, const T& value);

	template <class ForwardIterator, class T, class Compare>
	- bool
	+ constexpr bool // constexpr in C++20
	binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);

	template <class InputIterator1, class InputIterator2, class OutputIterator>
	OutputIterator
	merge(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, InputIterator2 last2, OutputIterator result);

	template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
	OutputIterator
	merge(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);

	template <class BidirectionalIterator>
	void
	inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last);

	template <class BidirectionalIterator, class Compare>
	void
	inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp);

	template <class InputIterator1, class InputIterator2>
	- bool
	+ constexpr bool // constexpr in C++20
	includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);

	template <class InputIterator1, class InputIterator2, class Compare>
	- bool
	+ constexpr bool // constexpr in C++20
	includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp);

	template <class InputIterator1, class InputIterator2, class OutputIterator>
	OutputIterator
	set_union(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, InputIterator2 last2, OutputIterator result);

	template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
	OutputIterator
	set_union(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);

	template <class InputIterator1, class InputIterator2, class OutputIterator>
	- OutputIterator
	+ constexpr OutputIterator // constexpr in C++20
	set_intersection(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, InputIterator2 last2, OutputIterator result);

	template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
	- OutputIterator
	+ constexpr OutputIterator // constexpr in C++20
	set_intersection(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);

	template <class InputIterator1, class InputIterator2, class OutputIterator>
	OutputIterator
	set_difference(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, InputIterator2 last2, OutputIterator result);

	template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
	OutputIterator
	set_difference(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);

	template <class InputIterator1, class InputIterator2, class OutputIterator>
	OutputIterator
	set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, InputIterator2 last2, OutputIterator result);

	template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
	OutputIterator
	set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);

	template <class RandomAccessIterator>
	void
	push_heap(RandomAccessIterator first, RandomAccessIterator last);

	template <class RandomAccessIterator, class Compare>
	void
	push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

	template <class RandomAccessIterator>
	void
	pop_heap(RandomAccessIterator first, RandomAccessIterator last);

	template <class RandomAccessIterator, class Compare>
	void
	pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

	template <class RandomAccessIterator>
	void
	make_heap(RandomAccessIterator first, RandomAccessIterator last);

	template <class RandomAccessIterator, class Compare>
	void
	make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

	template <class RandomAccessIterator>
	void
	sort_heap(RandomAccessIterator first, RandomAccessIterator last);

	template <class RandomAccessIterator, class Compare>
	void
	sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

	template <class RandomAccessIterator>
	- bool
	+ constexpr bool // constexpr in C++20
	is_heap(RandomAccessIterator first, RandomAccessiterator last);

	template <class RandomAccessIterator, class Compare>
	- bool
	+ constexpr bool // constexpr in C++20
	is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp);

	template <class RandomAccessIterator>
	- RandomAccessIterator
	+ constexpr RandomAccessIterator // constexpr in C++20
	is_heap_until(RandomAccessIterator first, RandomAccessiterator last);

	template <class RandomAccessIterator, class Compare>
	- RandomAccessIterator
	+ constexpr RandomAccessIterator // constexpr in C++20
	is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp);

	template <class ForwardIterator>
	ForwardIterator
	min_element(ForwardIterator first, ForwardIterator last); // constexpr in C++14

	template <class ForwardIterator, class Compare>
	ForwardIterator
	min_element(ForwardIterator first, ForwardIterator last, Compare comp); // constexpr in C++14

	template <class T>
	const T&
	min(const T& a, const T& b); // constexpr in C++14

	template <class T, class Compare>
	const T&
	min(const T& a, const T& b, Compare comp); // constexpr in C++14

	template<class T>
	T
	min(initializer_list<T> t); // constexpr in C++14

	template<class T, class Compare>
	T
	min(initializer_list<T> t, Compare comp); // constexpr in C++14

	template<class T>
	constexpr const T& clamp( const T& v, const T& lo, const T& hi ); // C++17

	template<class T, class Compare>
	constexpr const T& clamp( const T& v, const T& lo, const T& hi, Compare comp ); // C++17

	template <class ForwardIterator>
	ForwardIterator
	max_element(ForwardIterator first, ForwardIterator last); // constexpr in C++14

	template <class ForwardIterator, class Compare>
	ForwardIterator
	max_element(ForwardIterator first, ForwardIterator last, Compare comp); // constexpr in C++14

	template <class T>
	const T&
	max(const T& a, const T& b); // constexpr in C++14

	template <class T, class Compare>
	const T&
	max(const T& a, const T& b, Compare comp); // constexpr in C++14

	template<class T>
	T
	max(initializer_list<T> t); // constexpr in C++14

	template<class T, class Compare>
	T
	max(initializer_list<T> t, Compare comp); // constexpr in C++14

	template<class ForwardIterator>
	pair<ForwardIterator, ForwardIterator>
	minmax_element(ForwardIterator first, ForwardIterator last); // constexpr in C++14

	template<class ForwardIterator, class Compare>
	pair<ForwardIterator, ForwardIterator>
	minmax_element(ForwardIterator first, ForwardIterator last, Compare comp); // constexpr in C++14

	template<class T>
	pair<const T&, const T&>
	minmax(const T& a, const T& b); // constexpr in C++14

	template<class T, class Compare>
	pair<const T&, const T&>
	minmax(const T& a, const T& b, Compare comp); // constexpr in C++14

	template<class T>
	pair<T, T>
	minmax(initializer_list<T> t); // constexpr in C++14

	template<class T, class Compare>
	pair<T, T>
	minmax(initializer_list<T> t, Compare comp); // constexpr in C++14

	template <class InputIterator1, class InputIterator2>
	- bool
	+ constexpr bool // constexpr in C++20
	lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);

	template <class InputIterator1, class InputIterator2, class Compare>
	- bool
	+ constexpr bool // constexpr in C++20
	lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, InputIterator2 last2, Compare comp);

	template <class BidirectionalIterator>
	bool
	next_permutation(BidirectionalIterator first, BidirectionalIterator last);

	template <class BidirectionalIterator, class Compare>
	bool
	next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);

	template <class BidirectionalIterator>
	bool
	prev_permutation(BidirectionalIterator first, BidirectionalIterator last);

	template <class BidirectionalIterator, class Compare>
	bool
	prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);

	} // std

	*/

	#include <__config>
	#include <initializer_list>
	#include <type_traits>
	#include <cstring>
	#include <utility> // needed to provide swap_ranges.
	#include <memory>
	+#include <functional>
	#include <iterator>
	#include <cstddef>

	#if defined(__IBMCPP__)
	#include "support/ibm/support.h"
	#endif
	#if defined(_LIBCPP_COMPILER_MSVC)
	#include <intrin.h>
	#endif

	#include <__debug>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_STD

	// I'd like to replace these with _VSTD::equal_to<void>, but can't because:
	// * That only works with C++14 and later, and
	// * We haven't included <functional> here.
	template <class _T1, class _T2 = _T1>
	struct __equal_to
	{
	- _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
	- _LIBCPP_INLINE_VISIBILITY bool operator()(const _T1& __x, const _T2& __y) const {return __x == __y;}
	- _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T1& __y) const {return __x == __y;}
	- _LIBCPP_INLINE_VISIBILITY bool operator()(const _T2& __x, const _T2& __y) const {return __x == __y;}
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _T1& __x, const _T2& __y) const {return __x == __y;}
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _T2& __x, const _T1& __y) const {return __x == __y;}
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 bool operator()(const _T2& __x, const _T2& __y) const {return __x == __y;}
	};

	template <class _T1>
	struct __equal_to<_T1, _T1>
	{
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
	};

	template <class _T1>
	struct __equal_to<const _T1, _T1>
	{
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
	};

	template <class _T1>
	struct __equal_to<_T1, const _T1>
	{
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool operator()(const _T1& __x, const _T1& __y) const {return __x == __y;}
	};

	template <class _T1, class _T2 = _T1>
	struct __less
	{
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool operator()(const _T1& __x, const _T2& __y) const {return __x < __y;}

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool operator()(const _T2& __x, const _T1& __y) const {return __x < __y;}

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool operator()(const _T2& __x, const _T2& __y) const {return __x < __y;}
	};

	template <class _T1>
	struct __less<_T1, _T1>
	{
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
	};

	template <class _T1>
	struct __less<const _T1, _T1>
	{
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
	};

	template <class _T1>
	struct __less<_T1, const _T1>
	{
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
	};

	template <class _Predicate>
	class __invert // invert the sense of a comparison
	{
	private:
	_Predicate __p_;
	public:
	_LIBCPP_INLINE_VISIBILITY __invert() {}

	_LIBCPP_INLINE_VISIBILITY
	explicit __invert(_Predicate __p) : __p_(__p) {}

	template <class _T1>
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const _T1& __x) {return !__p_(__x);}

	template <class _T1, class _T2>
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const _T1& __x, const _T2& __y) {return __p_(__y, __x);}
	};

	#ifdef _LIBCPP_DEBUG

	template <class _Compare>
	struct __debug_less
	{
	_Compare __comp_;
	__debug_less(_Compare& __c) : __comp_(__c) {}

	template <class _Tp, class _Up>
	bool operator()(const _Tp& __x, const _Up& __y)
	{
	bool __r = __comp_(__x, __y);
	if (__r)
	__do_compare_assert(0, __y, __x);
	return __r;
	}

	template <class _LHS, class _RHS>
	inline _LIBCPP_INLINE_VISIBILITY
	decltype((void)_VSTD::declval<_Compare&>()(
	_VSTD::declval<_LHS const&>(), _VSTD::declval<_RHS const&>()))
	__do_compare_assert(int, _LHS const& __l, _RHS const& __r) {
	_LIBCPP_ASSERT(!__comp_(__l, __r),
	"Comparator does not induce a strict weak ordering");
	}

	template <class _LHS, class _RHS>
	inline _LIBCPP_INLINE_VISIBILITY
	void __do_compare_assert(long, _LHS const&, _RHS const&) {}
	};

	#endif // _LIBCPP_DEBUG

	// Precondition: __x != 0
	inline _LIBCPP_INLINE_VISIBILITY
	unsigned __ctz(unsigned __x) {
	#ifndef _LIBCPP_COMPILER_MSVC
	return static_cast<unsigned>(__builtin_ctz(__x));
	#else
	static_assert(sizeof(unsigned) == sizeof(unsigned long), "");
	static_assert(sizeof(unsigned long) == 4, "");
	unsigned long where;
	// Search from LSB to MSB for first set bit.
	// Returns zero if no set bit is found.
	if (_BitScanForward(&where, __x))
	return where;
	return 32;
	#endif
	}

	inline _LIBCPP_INLINE_VISIBILITY
	unsigned long __ctz(unsigned long __x) {
	#ifndef _LIBCPP_COMPILER_MSVC
	return static_cast<unsigned long>(__builtin_ctzl(__x));
	#else
	static_assert(sizeof(unsigned long) == sizeof(unsigned), "");
	return __ctz(static_cast<unsigned>(__x));
	#endif
	}

	inline _LIBCPP_INLINE_VISIBILITY
	unsigned long long __ctz(unsigned long long __x) {
	#ifndef _LIBCPP_COMPILER_MSVC
	return static_cast<unsigned long long>(__builtin_ctzll(__x));
	#else
	unsigned long where;
	// Search from LSB to MSB for first set bit.
	// Returns zero if no set bit is found.
	#if defined(_LIBCPP_HAS_BITSCAN64)
	(defined(_M_AMD64) \|\| defined(__x86_64__))
	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>(__x)))
	return where;
	// Scan the High Word.
	if (_BitScanForward(&where, static_cast<unsigned long>(__x >> 32)))
	return where + 32; // Create a bit offset from the LSB.
	#endif
	return 64;
	#endif // _LIBCPP_COMPILER_MSVC
	}

	// Precondition: __x != 0
	inline _LIBCPP_INLINE_VISIBILITY
	unsigned __clz(unsigned __x) {
	#ifndef _LIBCPP_COMPILER_MSVC
	return static_cast<unsigned>(__builtin_clz(__x));
	#else
	static_assert(sizeof(unsigned) == sizeof(unsigned long), "");
	static_assert(sizeof(unsigned long) == 4, "");
	unsigned long where;
	// Search from LSB to MSB for first set bit.
	// Returns zero if no set bit is found.
	if (_BitScanReverse(&where, __x))
	return 31 - where;
	return 32; // Undefined Behavior.
	#endif
	}

	inline _LIBCPP_INLINE_VISIBILITY
	unsigned long __clz(unsigned long __x) {
	#ifndef _LIBCPP_COMPILER_MSVC
	return static_cast<unsigned long>(__builtin_clzl (__x));
	#else
	static_assert(sizeof(unsigned) == sizeof(unsigned long), "");
	return __clz(static_cast<unsigned>(__x));
	#endif
	}

	inline _LIBCPP_INLINE_VISIBILITY
	unsigned long long __clz(unsigned long long __x) {
	#ifndef _LIBCPP_COMPILER_MSVC
	return static_cast<unsigned long long>(__builtin_clzll(__x));
	#else
	unsigned long where;
	// 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, __x))
	return static_cast<int>(63 - where);
	#else
	// Scan the high 32 bits.
	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>(__x)))
	return 63 - where;
	#endif
	return 64; // Undefined Behavior.
	#endif // _LIBCPP_COMPILER_MSVC
	}

	inline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned __x) {
	#ifndef _LIBCPP_COMPILER_MSVC
	return __builtin_popcount (__x);
	#else
	static_assert(sizeof(unsigned) == 4, "");
	return __popcnt(__x);
	#endif
	}

	inline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned long __x) {
	#ifndef _LIBCPP_COMPILER_MSVC
	return __builtin_popcountl (__x);
	#else
	static_assert(sizeof(unsigned long) == 4, "");
	return __popcnt(__x);
	#endif
	}

	inline _LIBCPP_INLINE_VISIBILITY int __pop_count(unsigned long long __x) {
	#ifndef _LIBCPP_COMPILER_MSVC
	return __builtin_popcountll(__x);
	#else
	static_assert(sizeof(unsigned long long) == 8, "");
	return __popcnt64(__x);
	#endif
	}

	// all_of

	template <class _InputIterator, class _Predicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
	{
	for (; __first != __last; ++__first)
	if (!__pred(*__first))
	return false;
	return true;
	}

	// any_of

	template <class _InputIterator, class _Predicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
	{
	for (; __first != __last; ++__first)
	if (__pred(*__first))
	return true;
	return false;
	}

	// none_of

	template <class _InputIterator, class _Predicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
	{
	for (; __first != __last; ++__first)
	if (__pred(*__first))
	return false;
	return true;
	}

	// for_each

	template <class _InputIterator, class _Function>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_Function
	for_each(_InputIterator __first, _InputIterator __last, _Function __f)
	{
	for (; __first != __last; ++__first)
	__f(*__first);
	return __f;
	}

	#if _LIBCPP_STD_VER > 14
	// for_each_n

	template <class _InputIterator, class _Size, class _Function>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_InputIterator
	for_each_n(_InputIterator __first, _Size __orig_n, _Function __f)
	{
	typedef decltype(__convert_to_integral(__orig_n)) _IntegralSize;
	_IntegralSize __n = __orig_n;
	while (__n > 0)
	{
	__f(*__first);
	++__first;
	--__n;
	}
	return __first;
	}
	#endif

	// find

	template <class _InputIterator, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_InputIterator
	find(_InputIterator __first, _InputIterator __last, const _Tp& __value_)
	{
	for (; __first != __last; ++__first)
	if (*__first == __value_)
	break;
	return __first;
	}

	// find_if

	template <class _InputIterator, class _Predicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_InputIterator
	find_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
	{
	for (; __first != __last; ++__first)
	if (__pred(*__first))
	break;
	return __first;
	}

	// find_if_not

	template<class _InputIterator, class _Predicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_InputIterator
	find_if_not(_InputIterator __first, _InputIterator __last, _Predicate __pred)
	{
	for (; __first != __last; ++__first)
	if (!__pred(*__first))
	break;
	return __first;
	}

	// find_end

	template <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
	-_ForwardIterator1
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator1
	__find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
	_ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred,
	forward_iterator_tag, forward_iterator_tag)
	{
	// modeled after search algorithm
	_ForwardIterator1 __r = __last1; // __last1 is the "default" answer
	if (__first2 == __last2)
	return __r;
	while (true)
	{
	while (true)
	{
	if (__first1 == __last1) // if source exhausted return last correct answer
	return __r; // (or __last1 if never found)
	if (__pred(__first1, __first2))
	break;
	++__first1;
	}
	// __first1 matches __first2, now match elements after here
	_ForwardIterator1 __m1 = __first1;
	_ForwardIterator2 __m2 = __first2;
	while (true)
	{
	if (++__m2 == __last2)
	{ // Pattern exhaused, record answer and search for another one
	__r = __first1;
	++__first1;
	break;
	}
	if (++__m1 == __last1) // Source exhausted, return last answer
	return __r;
	if (!__pred(__m1, __m2)) // mismatch, restart with a new __first
	{
	++__first1;
	break;
	} // else there is a match, check next elements
	}
	}
	}

	template <class _BinaryPredicate, class _BidirectionalIterator1, class _BidirectionalIterator2>
	-_BidirectionalIterator1
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 _BidirectionalIterator1
	__find_end(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1,
	_BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, _BinaryPredicate __pred,
	bidirectional_iterator_tag, bidirectional_iterator_tag)
	{
	// modeled after search algorithm (in reverse)
	if (__first2 == __last2)
	return __last1; // Everything matches an empty sequence
	_BidirectionalIterator1 __l1 = __last1;
	_BidirectionalIterator2 __l2 = __last2;
	--__l2;
	while (true)
	{
	// Find last element in sequence 1 that matchs *(__last2-1), with a mininum of loop checks
	while (true)
	{
	if (__first1 == __l1) // return __last1 if no element matches *__first2
	return __last1;
	if (__pred(--__l1, __l2))
	break;
	}
	// __l1 matches __l2, now match elements before here
	_BidirectionalIterator1 __m1 = __l1;
	_BidirectionalIterator2 __m2 = __l2;
	while (true)
	{
	if (__m2 == __first2) // If pattern exhausted, __m1 is the answer (works for 1 element pattern)
	return __m1;
	if (__m1 == __first1) // Otherwise if source exhaused, pattern not found
	return __last1;
	if (!__pred(--__m1, --__m2)) // if there is a mismatch, restart with a new __l1
	{
	break;
	} // else there is a match, check next elements
	}
	}
	}

	template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _RandomAccessIterator1
	__find_end(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
	_RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
	random_access_iterator_tag, random_access_iterator_tag)
	{
	// Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern
	typename iterator_traits<_RandomAccessIterator2>::difference_type __len2 = __last2 - __first2;
	if (__len2 == 0)
	return __last1;
	typename iterator_traits<_RandomAccessIterator1>::difference_type __len1 = __last1 - __first1;
	if (__len1 < __len2)
	return __last1;
	const _RandomAccessIterator1 __s = __first1 + (__len2 - 1); // End of pattern match can't go before here
	_RandomAccessIterator1 __l1 = __last1;
	_RandomAccessIterator2 __l2 = __last2;
	--__l2;
	while (true)
	{
	while (true)
	{
	if (__s == __l1)
	return __last1;
	if (__pred(--__l1, __l2))
	break;
	}
	_RandomAccessIterator1 __m1 = __l1;
	_RandomAccessIterator2 __m2 = __l2;
	while (true)
	{
	if (__m2 == __first2)
	return __m1;
	// no need to check range on __m1 because __s guarantees we have enough source
	if (!__pred(--__m1, --__m2))
	{
	break;
	}
	}
	}
	}

	template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_ForwardIterator1
	find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
	_ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
	{
	return _VSTD::__find_end<typename add_lvalue_reference<_BinaryPredicate>::type>
	(__first1, __last1, __first2, __last2, __pred,
	typename iterator_traits<_ForwardIterator1>::iterator_category(),
	typename iterator_traits<_ForwardIterator2>::iterator_category());
	}

	template <class _ForwardIterator1, class _ForwardIterator2>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_ForwardIterator1
	find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
	_ForwardIterator2 __first2, _ForwardIterator2 __last2)
	{
	typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
	typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
	return _VSTD::find_end(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
	}

	// find_first_of

	template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _ForwardIterator1
	__find_first_of_ce(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
	_ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
	{
	for (; __first1 != __last1; ++__first1)
	for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j)
	if (__pred(__first1, __j))
	return __first1;
	return __last1;
	}


	template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_ForwardIterator1
	find_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
	_ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
	{
	return _VSTD::__find_first_of_ce(__first1, __last1, __first2, __last2, __pred);
	}

	template <class _ForwardIterator1, class _ForwardIterator2>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_ForwardIterator1
	find_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
	_ForwardIterator2 __first2, _ForwardIterator2 __last2)
	{
	typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
	typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
	return _VSTD::__find_first_of_ce(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
	}

	// adjacent_find

	template <class _ForwardIterator, class _BinaryPredicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_ForwardIterator
	adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
	{
	if (__first != __last)
	{
	_ForwardIterator __i = __first;
	while (++__i != __last)
	{
	if (__pred(__first, __i))
	return __first;
	__first = __i;
	}
	}
	return __last;
	}

	template <class _ForwardIterator>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_ForwardIterator
	adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
	{
	typedef typename iterator_traits<_ForwardIterator>::value_type __v;
	return _VSTD::adjacent_find(__first, __last, __equal_to<__v>());
	}

	// count

	template <class _InputIterator, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	typename iterator_traits<_InputIterator>::difference_type
	count(_InputIterator __first, _InputIterator __last, const _Tp& __value_)
	{
	typename iterator_traits<_InputIterator>::difference_type __r(0);
	for (; __first != __last; ++__first)
	if (*__first == __value_)
	++__r;
	return __r;
	}

	// count_if

	template <class _InputIterator, class _Predicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	typename iterator_traits<_InputIterator>::difference_type
	count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
	{
	typename iterator_traits<_InputIterator>::difference_type __r(0);
	for (; __first != __last; ++__first)
	if (__pred(*__first))
	++__r;
	return __r;
	}

	// mismatch

	template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	pair<_InputIterator1, _InputIterator2>
	mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _BinaryPredicate __pred)
	{
	for (; __first1 != __last1; ++__first1, (void) ++__first2)
	if (!__pred(__first1, __first2))
	break;
	return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
	}

	template <class _InputIterator1, class _InputIterator2>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	pair<_InputIterator1, _InputIterator2>
	mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2)
	{
	typedef typename iterator_traits<_InputIterator1>::value_type __v1;
	typedef typename iterator_traits<_InputIterator2>::value_type __v2;
	return _VSTD::mismatch(__first1, __last1, __first2, __equal_to<__v1, __v2>());
	}

	#if _LIBCPP_STD_VER > 11
	template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	pair<_InputIterator1, _InputIterator2>
	mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2,
	_BinaryPredicate __pred)
	{
	for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void) ++__first2)
	if (!__pred(__first1, __first2))
	break;
	return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
	}

	template <class _InputIterator1, class _InputIterator2>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	pair<_InputIterator1, _InputIterator2>
	mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2)
	{
	typedef typename iterator_traits<_InputIterator1>::value_type __v1;
	typedef typename iterator_traits<_InputIterator2>::value_type __v2;
	return _VSTD::mismatch(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
	}
	#endif

	// equal

	template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred)
	{
	for (; __first1 != __last1; ++__first1, (void) ++__first2)
	if (!__pred(__first1, __first2))
	return false;
	return true;
	}

	template <class _InputIterator1, class _InputIterator2>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2)
	{
	typedef typename iterator_traits<_InputIterator1>::value_type __v1;
	typedef typename iterator_traits<_InputIterator2>::value_type __v2;
	return _VSTD::equal(__first1, __last1, __first2, __equal_to<__v1, __v2>());
	}

	#if _LIBCPP_STD_VER > 11
	template <class _BinaryPredicate, class _InputIterator1, class _InputIterator2>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	__equal(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __pred,
	input_iterator_tag, input_iterator_tag )
	{
	for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void) ++__first2)
	if (!__pred(__first1, __first2))
	return false;
	return __first1 == __last1 && __first2 == __last2;
	}

	template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	__equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
	_RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
	random_access_iterator_tag, random_access_iterator_tag )
	{
	if ( _VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2))
	return false;
	return _VSTD::equal<_RandomAccessIterator1, _RandomAccessIterator2,
	typename add_lvalue_reference<_BinaryPredicate>::type>
	(__first1, __last1, __first2, __pred );
	}

	template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	equal(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __pred )
	{
	return _VSTD::__equal<typename add_lvalue_reference<_BinaryPredicate>::type>
	(__first1, __last1, __first2, __last2, __pred,
	typename iterator_traits<_InputIterator1>::iterator_category(),
	typename iterator_traits<_InputIterator2>::iterator_category());
	}

	template <class _InputIterator1, class _InputIterator2>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	equal(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2)
	{
	typedef typename iterator_traits<_InputIterator1>::value_type __v1;
	typedef typename iterator_traits<_InputIterator2>::value_type __v2;
	return _VSTD::__equal(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>(),
	typename iterator_traits<_InputIterator1>::iterator_category(),
	typename iterator_traits<_InputIterator2>::iterator_category());
	}
	#endif

	// is_permutation

	template<class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
	-bool
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
	is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
	_ForwardIterator2 __first2, _BinaryPredicate __pred)
	{
	- // shorten sequences as much as possible by lopping of any equal parts
	+// shorten sequences as much as possible by lopping of any equal prefix
	for (; __first1 != __last1; ++__first1, (void) ++__first2)
	if (!__pred(__first1, __first2))
	- goto __not_done;
	- return true;
	-__not_done:
	- // __first1 != __last1 && __first1 != __first2
	+ break;
	+ if (__first1 == __last1)
	+ return true;
	+
	+// __first1 != __last1 && __first1 != __first2
	typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1;
	_D1 __l1 = _VSTD::distance(__first1, __last1);
	if (__l1 == _D1(1))
	return false;
	_ForwardIterator2 __last2 = _VSTD::next(__first2, __l1);
	// For each element in [f1, l1) see if there are the same number of
	// equal elements in [f2, l2)
	for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i)
	{
	- // Have we already counted the number of *__i in [f1, l1)?
	- for (_ForwardIterator1 __j = __first1; __j != __i; ++__j)
	- if (__pred(__j, __i))
	- goto __next_iter;
	- {
	+ // Have we already counted the number of *__i in [f1, l1)?
	+ _ForwardIterator1 __match = __first1;
	+ for (; __match != __i; ++__match)
	+ if (__pred(__match, __i))
	+ break;
	+ if (__match == __i) {
	// Count number of *__i in [f2, l2)
	_D1 __c2 = 0;
	for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j)
	if (__pred(__i, __j))
	++__c2;
	if (__c2 == 0)
	return false;
	// Count number of *__i in [__i, l1) (we can start with 1)
	_D1 __c1 = 1;
	for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j)
	if (__pred(__i, __j))
	++__c1;
	if (__c1 != __c2)
	return false;
	}
	-__next_iter:;
	}
	return true;
	}

	template<class _ForwardIterator1, class _ForwardIterator2>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
	_ForwardIterator2 __first2)
	{
	typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
	typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
	return _VSTD::is_permutation(__first1, __last1, __first2, __equal_to<__v1, __v2>());
	}

	#if _LIBCPP_STD_VER > 11
	template<class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
	-bool
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
	__is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
	_ForwardIterator2 __first2, _ForwardIterator2 __last2,
	_BinaryPredicate __pred,
	forward_iterator_tag, forward_iterator_tag )
	{
	- // shorten sequences as much as possible by lopping of any equal parts
	+// shorten sequences as much as possible by lopping of any equal prefix
	for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void) ++__first2)
	if (!__pred(__first1, __first2))
	- goto __not_done;
	- return __first1 == __last1 && __first2 == __last2;
	-__not_done:
	- // __first1 != __last1 && __first2 != __last2 && __first1 != __first2
	+ break;
	+ if (__first1 == __last1)
	+ return __first2 == __last2;
	+ else if (__first2 == __last2)
	+ return false;
	+
	typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1;
	_D1 __l1 = _VSTD::distance(__first1, __last1);

	typedef typename iterator_traits<_ForwardIterator2>::difference_type _D2;
	_D2 __l2 = _VSTD::distance(__first2, __last2);
	if (__l1 != __l2)
	return false;

	// For each element in [f1, l1) see if there are the same number of
	// equal elements in [f2, l2)
	for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i)
	{
	- // Have we already counted the number of *__i in [f1, l1)?
	- for (_ForwardIterator1 __j = __first1; __j != __i; ++__j)
	- if (__pred(__j, __i))
	- goto __next_iter;
	- {
	+ // Have we already counted the number of *__i in [f1, l1)?
	+ _ForwardIterator1 __match = __first1;
	+ for (; __match != __i; ++__match)
	+ if (__pred(__match, __i))
	+ break;
	+ if (__match == __i) {
	// Count number of *__i in [f2, l2)
	_D1 __c2 = 0;
	for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j)
	if (__pred(__i, __j))
	++__c2;
	if (__c2 == 0)
	return false;
	// Count number of *__i in [__i, l1) (we can start with 1)
	_D1 __c1 = 1;
	for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j)
	if (__pred(__i, __j))
	++__c1;
	if (__c1 != __c2)
	return false;
	}
	-__next_iter:;
	}
	return true;
	}

	template<class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
	-bool
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
	__is_permutation(_RandomAccessIterator1 __first1, _RandomAccessIterator2 __last1,
	_RandomAccessIterator1 __first2, _RandomAccessIterator2 __last2,
	_BinaryPredicate __pred,
	random_access_iterator_tag, random_access_iterator_tag )
	{
	if ( _VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2))
	return false;
	return _VSTD::is_permutation<_RandomAccessIterator1, _RandomAccessIterator2,
	typename add_lvalue_reference<_BinaryPredicate>::type>
	(__first1, __last1, __first2, __pred );
	}

	template<class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
	_ForwardIterator2 __first2, _ForwardIterator2 __last2,
	_BinaryPredicate __pred )
	{
	return _VSTD::__is_permutation<typename add_lvalue_reference<_BinaryPredicate>::type>
	(__first1, __last1, __first2, __last2, __pred,
	typename iterator_traits<_ForwardIterator1>::iterator_category(),
	typename iterator_traits<_ForwardIterator2>::iterator_category());
	}

	template<class _ForwardIterator1, class _ForwardIterator2>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
	_ForwardIterator2 __first2, _ForwardIterator2 __last2)
	{
	typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
	typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
	return _VSTD::__is_permutation(__first1, __last1, __first2, __last2,
	__equal_to<__v1, __v2>(),
	typename iterator_traits<_ForwardIterator1>::iterator_category(),
	typename iterator_traits<_ForwardIterator2>::iterator_category());
	}
	#endif

	// search
	+// __search is in <functional>

	-template <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
	-pair<_ForwardIterator1, _ForwardIterator1>
	-__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
	- _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred,
	- forward_iterator_tag, forward_iterator_tag)
	-{
	- if (__first2 == __last2)
	- return make_pair(__first1, __first1); // Everything matches an empty sequence
	- while (true)
	- {
	- // Find first element in sequence 1 that matchs *__first2, with a mininum of loop checks
	- while (true)
	- {
	- if (__first1 == __last1) // return __last1 if no element matches *__first2
	- return make_pair(__last1, __last1);
	- if (__pred(__first1, __first2))
	- break;
	- ++__first1;
	- }
	- // __first1 matches __first2, now match elements after here
	- _ForwardIterator1 __m1 = __first1;
	- _ForwardIterator2 __m2 = __first2;
	- while (true)
	- {
	- if (++__m2 == __last2) // If pattern exhausted, __first1 is the answer (works for 1 element pattern)
	- return make_pair(__first1, __m1);
	- if (++__m1 == __last1) // Otherwise if source exhaused, pattern not found
	- return make_pair(__last1, __last1);
	- if (!__pred(__m1, __m2)) // if there is a mismatch, restart with a new __first1
	- {
	- ++__first1;
	- break;
	- } // else there is a match, check next elements
	- }
	- }
	-}
	-
	-template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
	-_LIBCPP_CONSTEXPR_AFTER_CXX11
	-pair<_RandomAccessIterator1, _RandomAccessIterator1>
	-__search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
	- _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
	- random_access_iterator_tag, random_access_iterator_tag)
	-{
	- typedef typename iterator_traits<_RandomAccessIterator1>::difference_type _D1;
	- typedef typename iterator_traits<_RandomAccessIterator2>::difference_type _D2;
	- // Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern
	- const _D2 __len2 = __last2 - __first2;
	- if (__len2 == 0)
	- return make_pair(__first1, __first1);
	- const _D1 __len1 = __last1 - __first1;
	- if (__len1 < __len2)
	- return make_pair(__last1, __last1);
	- const _RandomAccessIterator1 __s = __last1 - (__len2 - 1); // Start of pattern match can't go beyond here
	-
	- while (true)
	- {
	- while (true)
	- {
	- if (__first1 == __s)
	- return make_pair(__last1, __last1);
	- if (__pred(__first1, __first2))
	- break;
	- ++__first1;
	- }
	-
	- _RandomAccessIterator1 __m1 = __first1;
	- _RandomAccessIterator2 __m2 = __first2;
	- while (true)
	- {
	- if (++__m2 == __last2)
	- return make_pair(__first1, __first1 + __len2);
	- ++__m1; // no need to check range on __m1 because __s guarantees we have enough source
	- if (!__pred(__m1, __m2))
	- {
	- ++__first1;
	- break;
	- }
	- }
	- }
	-}
	-
	template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_ForwardIterator1
	search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
	_ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
	{
	return _VSTD::__search<typename add_lvalue_reference<_BinaryPredicate>::type>
	(__first1, __last1, __first2, __last2, __pred,
	typename iterator_traits<_ForwardIterator1>::iterator_category(),
	typename iterator_traits<_ForwardIterator2>::iterator_category())
	.first;
	}

	template <class _ForwardIterator1, class _ForwardIterator2>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_ForwardIterator1
	search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
	_ForwardIterator2 __first2, _ForwardIterator2 __last2)
	{
	typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
	typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
	return _VSTD::search(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
	}

	+
	+#if _LIBCPP_STD_VER > 14
	+template <class _ForwardIterator, class _Searcher>
	+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	+_ForwardIterator search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher &__s)
	+{ return __s(__f, __l).first; }
	+#endif
	+
	// search_n

	template <class _BinaryPredicate, class _ForwardIterator, class _Size, class _Tp>
	-_ForwardIterator
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
	__search_n(_ForwardIterator __first, _ForwardIterator __last,
	_Size __count, const _Tp& __value_, _BinaryPredicate __pred, forward_iterator_tag)
	{
	if (__count <= 0)
	return __first;
	while (true)
	{
	// Find first element in sequence that matchs __value_, with a mininum of loop checks
	while (true)
	{
	if (__first == __last) // return __last if no element matches __value_
	return __last;
	if (__pred(*__first, __value_))
	break;
	++__first;
	}
	// *__first matches __value_, now match elements after here
	_ForwardIterator __m = __first;
	_Size __c(0);
	while (true)
	{
	if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern)
	return __first;
	if (++__m == __last) // Otherwise if source exhaused, pattern not found
	return __last;
	if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first
	{
	__first = __m;
	++__first;
	break;
	} // else there is a match, check next elements
	}
	}
	}

	template <class _BinaryPredicate, class _RandomAccessIterator, class _Size, class _Tp>
	-_RandomAccessIterator
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator
	__search_n(_RandomAccessIterator __first, _RandomAccessIterator __last,
	_Size __count, const _Tp& __value_, _BinaryPredicate __pred, random_access_iterator_tag)
	{
	if (__count <= 0)
	return __first;
	_Size __len = static_cast<_Size>(__last - __first);
	if (__len < __count)
	return __last;
	const _RandomAccessIterator __s = __last - (__count - 1); // Start of pattern match can't go beyond here
	while (true)
	{
	// Find first element in sequence that matchs __value_, with a mininum of loop checks
	while (true)
	{
	if (__first >= __s) // return __last if no element matches __value_
	return __last;
	if (__pred(*__first, __value_))
	break;
	++__first;
	}
	// *__first matches __value_, now match elements after here
	_RandomAccessIterator __m = __first;
	_Size __c(0);
	while (true)
	{
	if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern)
	return __first;
	++__m; // no need to check range on __m because __s guarantees we have enough source
	if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first
	{
	__first = __m;
	++__first;
	break;
	} // else there is a match, check next elements
	}
	}
	}

	template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_ForwardIterator
	search_n(_ForwardIterator __first, _ForwardIterator __last,
	_Size __count, const _Tp& __value_, _BinaryPredicate __pred)
	{
	return _VSTD::__search_n<typename add_lvalue_reference<_BinaryPredicate>::type>
	(__first, __last, __convert_to_integral(__count), __value_, __pred,
	typename iterator_traits<_ForwardIterator>::iterator_category());
	}

	template <class _ForwardIterator, class _Size, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_ForwardIterator
	search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_)
	{
	typedef typename iterator_traits<_ForwardIterator>::value_type __v;
	return _VSTD::search_n(__first, __last, __convert_to_integral(__count),
	__value_, __equal_to<__v, _Tp>());
	}

	// copy
	template <class _Iter>
	inline _LIBCPP_INLINE_VISIBILITY
	_Iter
	__unwrap_iter(_Iter __i)
	{
	return __i;
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_trivially_copy_assignable<_Tp>::value,
	_Tp*
	>::type
	__unwrap_iter(move_iterator<_Tp*> __i)
	{
	return __i.base();
	}

	#if _LIBCPP_DEBUG_LEVEL < 2

	template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
	typename enable_if
	<
	is_trivially_copy_assignable<_Tp>::value,
	_Tp*
	>::type
	__unwrap_iter(__wrap_iter<_Tp*> __i)
	{
	return __i.base();
	}

	#else

	template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
	typename enable_if
	<
	is_trivially_copy_assignable<_Tp>::value,
	__wrap_iter<_Tp*>
	>::type
	__unwrap_iter(__wrap_iter<_Tp*> __i)
	{
	return __i;
	}

	#endif // _LIBCPP_DEBUG_LEVEL < 2

	template <class _InputIterator, class _OutputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	__copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
	{
	for (; __first != __last; ++__first, (void) ++__result)
	__result = __first;
	return __result;
	}

	template <class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_same<typename remove_const<_Tp>::type, _Up>::value &&
	is_trivially_copy_assignable<_Up>::value,
	_Up*
	>::type
	__copy(_Tp* __first, _Tp* __last, _Up* __result)
	{
	const size_t __n = static_cast<size_t>(__last - __first);
	if (__n > 0)
	_VSTD::memmove(__result, __first, __n * sizeof(_Up));
	return __result + __n;
	}

	template <class _InputIterator, class _OutputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
	{
	return _VSTD::__copy(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
	}

	// copy_backward

	template <class _BidirectionalIterator, class _OutputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	__copy_backward(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
	{
	while (__first != __last)
	--__result = --__last;
	return __result;
	}

	template <class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_same<typename remove_const<_Tp>::type, _Up>::value &&
	is_trivially_copy_assignable<_Up>::value,
	_Up*
	>::type
	__copy_backward(_Tp* __first, _Tp* __last, _Up* __result)
	{
	const size_t __n = static_cast<size_t>(__last - __first);
	if (__n > 0)
	{
	__result -= __n;
	_VSTD::memmove(__result, __first, __n * sizeof(_Up));
	}
	return __result;
	}

	template <class _BidirectionalIterator1, class _BidirectionalIterator2>
	inline _LIBCPP_INLINE_VISIBILITY
	_BidirectionalIterator2
	copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
	_BidirectionalIterator2 __result)
	{
	return _VSTD::__copy_backward(__unwrap_iter(__first),
	__unwrap_iter(__last),
	__unwrap_iter(__result));
	}

	// copy_if

	template<class _InputIterator, class _OutputIterator, class _Predicate>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	copy_if(_InputIterator __first, _InputIterator __last,
	_OutputIterator __result, _Predicate __pred)
	{
	for (; __first != __last; ++__first)
	{
	if (__pred(*__first))
	{
	__result = __first;
	++__result;
	}
	}
	return __result;
	}

	// copy_n

	template<class _InputIterator, class _Size, class _OutputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_input_iterator<_InputIterator>::value &&
	!__is_random_access_iterator<_InputIterator>::value,
	_OutputIterator
	>::type
	copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
	{
	typedef decltype(__convert_to_integral(__orig_n)) _IntegralSize;
	_IntegralSize __n = __orig_n;
	if (__n > 0)
	{
	__result = __first;
	++__result;
	for (--__n; __n > 0; --__n)
	{
	++__first;
	__result = __first;
	++__result;
	}
	}
	return __result;
	}

	template<class _InputIterator, class _Size, class _OutputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_random_access_iterator<_InputIterator>::value,
	_OutputIterator
	>::type
	copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
	{
	typedef decltype(__convert_to_integral(__orig_n)) _IntegralSize;
	_IntegralSize __n = __orig_n;
	return _VSTD::copy(__first, __first + __n, __result);
	}

	// move

	template <class _InputIterator, class _OutputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	__move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
	{
	for (; __first != __last; ++__first, (void) ++__result)
	__result = _VSTD::move(__first);
	return __result;
	}

	template <class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_same<typename remove_const<_Tp>::type, _Up>::value &&
	is_trivially_copy_assignable<_Up>::value,
	_Up*
	>::type
	__move(_Tp* __first, _Tp* __last, _Up* __result)
	{
	const size_t __n = static_cast<size_t>(__last - __first);
	if (__n > 0)
	_VSTD::memmove(__result, __first, __n * sizeof(_Up));
	return __result + __n;
	}

	template <class _InputIterator, class _OutputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
	{
	return _VSTD::__move(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
	}

	// move_backward

	template <class _InputIterator, class _OutputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	__move_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
	{
	while (__first != __last)
	--__result = _VSTD::move(--__last);
	return __result;
	}

	template <class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_same<typename remove_const<_Tp>::type, _Up>::value &&
	is_trivially_copy_assignable<_Up>::value,
	_Up*
	>::type
	__move_backward(_Tp* __first, _Tp* __last, _Up* __result)
	{
	const size_t __n = static_cast<size_t>(__last - __first);
	if (__n > 0)
	{
	__result -= __n;
	_VSTD::memmove(__result, __first, __n * sizeof(_Up));
	}
	return __result;
	}

	template <class _BidirectionalIterator1, class _BidirectionalIterator2>
	inline _LIBCPP_INLINE_VISIBILITY
	_BidirectionalIterator2
	move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
	_BidirectionalIterator2 __result)
	{
	return _VSTD::__move_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
	}

	// iter_swap

	// moved to <type_traits> for better swap / noexcept support

	// transform

	template <class _InputIterator, class _OutputIterator, class _UnaryOperation>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_OutputIterator
	transform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __op)
	{
	for (; __first != __last; ++__first, (void) ++__result)
	__result = __op(__first);
	return __result;
	}

	template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _BinaryOperation>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_OutputIterator
	transform(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2,
	_OutputIterator __result, _BinaryOperation __binary_op)
	{
	for (; __first1 != __last1; ++__first1, (void) ++__first2, ++__result)
	__result = __binary_op(__first1, *__first2);
	return __result;
	}

	// replace

	template <class _ForwardIterator, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	void
	replace(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value)
	{
	for (; __first != __last; ++__first)
	if (*__first == __old_value)
	*__first = __new_value;
	}

	// replace_if

	template <class _ForwardIterator, class _Predicate, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	void
	replace_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp& __new_value)
	{
	for (; __first != __last; ++__first)
	if (__pred(*__first))
	*__first = __new_value;
	}

	// replace_copy

	template <class _InputIterator, class _OutputIterator, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_OutputIterator
	replace_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
	const _Tp& __old_value, const _Tp& __new_value)
	{
	for (; __first != __last; ++__first, (void) ++__result)
	if (*__first == __old_value)
	*__result = __new_value;
	else
	__result = __first;
	return __result;
	}

	// replace_copy_if

	template <class _InputIterator, class _OutputIterator, class _Predicate, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_OutputIterator
	replace_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
	_Predicate __pred, const _Tp& __new_value)
	{
	for (; __first != __last; ++__first, (void) ++__result)
	if (__pred(*__first))
	*__result = __new_value;
	else
	__result = __first;
	return __result;
	}

	// fill_n

	template <class _OutputIterator, class _Size, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_OutputIterator
	__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_)
	{
	for (; __n > 0; ++__first, (void) --__n)
	*__first = __value_;
	return __first;
	}

	-template <class _Tp, class _Size, class _Up>
	-inline _LIBCPP_INLINE_VISIBILITY
	-typename enable_if
	-<
	- is_integral<_Tp>::value && sizeof(_Tp) == 1 &&
	- !is_same<_Tp, bool>::value &&
	- is_integral<_Up>::value && sizeof(_Up) == 1,
	- _Tp*
	->::type
	-__fill_n(_Tp* __first, _Size __n,_Up __value_)
	-{
	- if (__n > 0)
	- _VSTD::memset(__first, (unsigned char)__value_, (size_t)(__n));
	- return __first + __n;
	-}
	-
	template <class _OutputIterator, class _Size, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_OutputIterator
	fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_)
	{
	return _VSTD::__fill_n(__first, __convert_to_integral(__n), __value_);
	}

	// fill

	template <class _ForwardIterator, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	void
	__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, forward_iterator_tag)
	{
	for (; __first != __last; ++__first)
	*__first = __value_;
	}

	template <class _RandomAccessIterator, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	void
	__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value_, random_access_iterator_tag)
	{
	_VSTD::fill_n(__first, __last - __first, __value_);
	}

	template <class _ForwardIterator, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	void
	fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
	{
	_VSTD::__fill(__first, __last, __value_, typename iterator_traits<_ForwardIterator>::iterator_category());
	}

	// generate

	template <class _ForwardIterator, class _Generator>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	void
	generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen)
	{
	for (; __first != __last; ++__first)
	*__first = __gen();
	}

	// generate_n

	template <class _OutputIterator, class _Size, class _Generator>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_OutputIterator
	generate_n(_OutputIterator __first, _Size __orig_n, _Generator __gen)
	{
	typedef decltype(__convert_to_integral(__orig_n)) _IntegralSize;
	_IntegralSize __n = __orig_n;
	for (; __n > 0; ++__first, (void) --__n)
	*__first = __gen();
	return __first;
	}

	// remove

	template <class _ForwardIterator, class _Tp>
	-_ForwardIterator
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
	remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
	{
	__first = _VSTD::find(__first, __last, __value_);
	if (__first != __last)
	{
	_ForwardIterator __i = __first;
	while (++__i != __last)
	{
	if (!(*__i == __value_))
	{
	__first = _VSTD::move(__i);
	++__first;
	}
	}
	}
	return __first;
	}

	// remove_if

	template <class _ForwardIterator, class _Predicate>
	-_ForwardIterator
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
	remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
	{
	__first = _VSTD::find_if<_ForwardIterator, typename add_lvalue_reference<_Predicate>::type>
	(__first, __last, __pred);
	if (__first != __last)
	{
	_ForwardIterator __i = __first;
	while (++__i != __last)
	{
	if (!__pred(*__i))
	{
	__first = _VSTD::move(__i);
	++__first;
	}
	}
	}
	return __first;
	}

	// remove_copy

	template <class _InputIterator, class _OutputIterator, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_OutputIterator
	remove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value_)
	{
	for (; __first != __last; ++__first)
	{
	if (!(*__first == __value_))
	{
	__result = __first;
	++__result;
	}
	}
	return __result;
	}

	// remove_copy_if

	template <class _InputIterator, class _OutputIterator, class _Predicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_OutputIterator
	remove_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred)
	{
	for (; __first != __last; ++__first)
	{
	if (!__pred(*__first))
	{
	__result = __first;
	++__result;
	}
	}
	return __result;
	}

	// unique

	template <class _ForwardIterator, class _BinaryPredicate>
	-_ForwardIterator
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
	unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
	{
	__first = _VSTD::adjacent_find<_ForwardIterator, typename add_lvalue_reference<_BinaryPredicate>::type>
	(__first, __last, __pred);
	if (__first != __last)
	{
	// ... a a ? ...
	// f i
	_ForwardIterator __i = __first;
	for (++__i; ++__i != __last;)
	if (!__pred(__first, __i))
	++__first = _VSTD::move(__i);
	++__first;
	}
	return __first;
	}

	template <class _ForwardIterator>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_ForwardIterator
	unique(_ForwardIterator __first, _ForwardIterator __last)
	{
	typedef typename iterator_traits<_ForwardIterator>::value_type __v;
	return _VSTD::unique(__first, __last, __equal_to<__v>());
	}

	// unique_copy

	template <class _BinaryPredicate, class _InputIterator, class _OutputIterator>
	-_OutputIterator
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator
	__unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred,
	input_iterator_tag, output_iterator_tag)
	{
	if (__first != __last)
	{
	typename iterator_traits<_InputIterator>::value_type __t(*__first);
	*__result = __t;
	++__result;
	while (++__first != __last)
	{
	if (!__pred(__t, *__first))
	{
	__t = *__first;
	*__result = __t;
	++__result;
	}
	}
	}
	return __result;
	}

	template <class _BinaryPredicate, class _ForwardIterator, class _OutputIterator>
	-_OutputIterator
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator
	__unique_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _BinaryPredicate __pred,
	forward_iterator_tag, output_iterator_tag)
	{
	if (__first != __last)
	{
	_ForwardIterator __i = __first;
	__result = __i;
	++__result;
	while (++__first != __last)
	{
	if (!__pred(__i, __first))
	{
	__result = __first;
	++__result;
	__i = __first;
	}
	}
	}
	return __result;
	}

	template <class _BinaryPredicate, class _InputIterator, class _ForwardIterator>
	-_ForwardIterator
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
	__unique_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _BinaryPredicate __pred,
	input_iterator_tag, forward_iterator_tag)
	{
	if (__first != __last)
	{
	__result = __first;
	while (++__first != __last)
	if (!__pred(__result, __first))
	++__result = __first;
	++__result;
	}
	return __result;
	}

	template <class _InputIterator, class _OutputIterator, class _BinaryPredicate>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_OutputIterator
	unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred)
	{
	return _VSTD::__unique_copy<typename add_lvalue_reference<_BinaryPredicate>::type>
	(__first, __last, __result, __pred,
	typename iterator_traits<_InputIterator>::iterator_category(),
	typename iterator_traits<_OutputIterator>::iterator_category());
	}

	template <class _InputIterator, class _OutputIterator>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_OutputIterator
	unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
	{
	typedef typename iterator_traits<_InputIterator>::value_type __v;
	return _VSTD::unique_copy(__first, __last, __result, __equal_to<__v>());
	}

	// reverse

	template <class _BidirectionalIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	__reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag)
	{
	while (__first != __last)
	{
	if (__first == --__last)
	break;
	_VSTD::iter_swap(__first, __last);
	++__first;
	}
	}

	template <class _RandomAccessIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	__reverse(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag)
	{
	if (__first != __last)
	for (; __first < --__last; ++__first)
	_VSTD::iter_swap(__first, __last);
	}

	template <class _BidirectionalIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
	{
	_VSTD::__reverse(__first, __last, typename iterator_traits<_BidirectionalIterator>::iterator_category());
	}

	// reverse_copy

	template <class _BidirectionalIterator, class _OutputIterator>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_OutputIterator
	reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
	{
	for (; __first != __last; ++__result)
	__result = --__last;
	return __result;
	}

	// rotate

	template <class _ForwardIterator>
	_ForwardIterator
	__rotate_left(_ForwardIterator __first, _ForwardIterator __last)
	{
	typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
	value_type __tmp = _VSTD::move(*__first);
	_ForwardIterator __lm1 = _VSTD::move(_VSTD::next(__first), __last, __first);
	*__lm1 = _VSTD::move(__tmp);
	return __lm1;
	}

	template <class _BidirectionalIterator>
	_BidirectionalIterator
	__rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last)
	{
	typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
	_BidirectionalIterator __lm1 = _VSTD::prev(__last);
	value_type __tmp = _VSTD::move(*__lm1);
	_BidirectionalIterator __fp1 = _VSTD::move_backward(__first, __lm1, __last);
	*__first = _VSTD::move(__tmp);
	return __fp1;
	}

	template <class _ForwardIterator>
	_ForwardIterator
	__rotate_forward(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
	{
	_ForwardIterator __i = __middle;
	while (true)
	{
	swap(__first, __i);
	++__first;
	if (++__i == __last)
	break;
	if (__first == __middle)
	__middle = __i;
	}
	_ForwardIterator __r = __first;
	if (__first != __middle)
	{
	__i = __middle;
	while (true)
	{
	swap(__first, __i);
	++__first;
	if (++__i == __last)
	{
	if (__first == __middle)
	break;
	__i = __middle;
	}
	else if (__first == __middle)
	__middle = __i;
	}
	}
	return __r;
	}

	template<typename _Integral>
	inline _LIBCPP_INLINE_VISIBILITY
	_Integral
	__algo_gcd(_Integral __x, _Integral __y)
	{
	do
	{
	_Integral __t = __x % __y;
	__x = __y;
	__y = __t;
	} while (__y);
	return __x;
	}

	template<typename _RandomAccessIterator>
	_RandomAccessIterator
	__rotate_gcd(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)
	{
	typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
	typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;

	const difference_type __m1 = __middle - __first;
	const difference_type __m2 = __last - __middle;
	if (__m1 == __m2)
	{
	_VSTD::swap_ranges(__first, __middle, __middle);
	return __middle;
	}
	const difference_type __g = _VSTD::__algo_gcd(__m1, __m2);
	for (_RandomAccessIterator __p = __first + __g; __p != __first;)
	{
	value_type __t(_VSTD::move(*--__p));
	_RandomAccessIterator __p1 = __p;
	_RandomAccessIterator __p2 = __p1 + __m1;
	do
	{
	__p1 = _VSTD::move(__p2);
	__p1 = __p2;
	const difference_type __d = __last - __p2;
	if (__m1 < __d)
	__p2 += __m1;
	else
	__p2 = __first + (__m1 - __d);
	} while (__p2 != __p);
	*__p1 = _VSTD::move(__t);
	}
	return __first + __m2;
	}

	template <class _ForwardIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_ForwardIterator
	__rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
	_VSTD::forward_iterator_tag)
	{
	typedef typename _VSTD::iterator_traits<_ForwardIterator>::value_type value_type;
	if (_VSTD::is_trivially_move_assignable<value_type>::value)
	{
	if (_VSTD::next(__first) == __middle)
	return _VSTD::__rotate_left(__first, __last);
	}
	return _VSTD::__rotate_forward(__first, __middle, __last);
	}

	template <class _BidirectionalIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_BidirectionalIterator
	__rotate(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
	_VSTD::bidirectional_iterator_tag)
	{
	typedef typename _VSTD::iterator_traits<_BidirectionalIterator>::value_type value_type;
	if (_VSTD::is_trivially_move_assignable<value_type>::value)
	{
	if (_VSTD::next(__first) == __middle)
	return _VSTD::__rotate_left(__first, __last);
	if (_VSTD::next(__middle) == __last)
	return _VSTD::__rotate_right(__first, __last);
	}
	return _VSTD::__rotate_forward(__first, __middle, __last);
	}

	template <class _RandomAccessIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_RandomAccessIterator
	__rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
	_VSTD::random_access_iterator_tag)
	{
	typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::value_type value_type;
	if (_VSTD::is_trivially_move_assignable<value_type>::value)
	{
	if (_VSTD::next(__first) == __middle)
	return _VSTD::__rotate_left(__first, __last);
	if (_VSTD::next(__middle) == __last)
	return _VSTD::__rotate_right(__first, __last);
	return _VSTD::__rotate_gcd(__first, __middle, __last);
	}
	return _VSTD::__rotate_forward(__first, __middle, __last);
	}

	template <class _ForwardIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_ForwardIterator
	rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
	{
	if (__first == __middle)
	return __last;
	if (__middle == __last)
	return __first;
	return _VSTD::__rotate(__first, __middle, __last,
	typename _VSTD::iterator_traits<_ForwardIterator>::iterator_category());
	}

	// rotate_copy

	template <class _ForwardIterator, class _OutputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result)
	{
	return _VSTD::copy(__first, __middle, _VSTD::copy(__middle, __last, __result));
	}

	// min_element

	template <class _ForwardIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_ForwardIterator
	min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
	{
	if (__first != __last)
	{
	_ForwardIterator __i = __first;
	while (++__i != __last)
	if (__comp(__i, __first))
	__first = __i;
	}
	return __first;
	}

	template <class _ForwardIterator>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_ForwardIterator
	min_element(_ForwardIterator __first, _ForwardIterator __last)
	{
	return _VSTD::min_element(__first, __last,
	__less<typename iterator_traits<_ForwardIterator>::value_type>());
	}

	// min

	template <class _Tp, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	const _Tp&
	min(const _Tp& __a, const _Tp& __b, _Compare __comp)
	{
	return __comp(__b, __a) ? __b : __a;
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	const _Tp&
	min(const _Tp& __a, const _Tp& __b)
	{
	return _VSTD::min(__a, __b, __less<_Tp>());
	}

	#ifndef _LIBCPP_CXX03_LANG

	template<class _Tp, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_Tp
	min(initializer_list<_Tp> __t, _Compare __comp)
	{
	return *_VSTD::min_element(__t.begin(), __t.end(), __comp);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_Tp
	min(initializer_list<_Tp> __t)
	{
	return *_VSTD::min_element(__t.begin(), __t.end(), __less<_Tp>());
	}

	#endif // _LIBCPP_CXX03_LANG

	// max_element

	template <class _ForwardIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_ForwardIterator
	max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
	{
	if (__first != __last)
	{
	_ForwardIterator __i = __first;
	while (++__i != __last)
	if (__comp(__first, __i))
	__first = __i;
	}
	return __first;
	}


	template <class _ForwardIterator>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_ForwardIterator
	max_element(_ForwardIterator __first, _ForwardIterator __last)
	{
	return _VSTD::max_element(__first, __last,
	__less<typename iterator_traits<_ForwardIterator>::value_type>());
	}

	// max

	template <class _Tp, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	const _Tp&
	max(const _Tp& __a, const _Tp& __b, _Compare __comp)
	{
	return __comp(__a, __b) ? __b : __a;
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	const _Tp&
	max(const _Tp& __a, const _Tp& __b)
	{
	return _VSTD::max(__a, __b, __less<_Tp>());
	}

	#ifndef _LIBCPP_CXX03_LANG

	template<class _Tp, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_Tp
	max(initializer_list<_Tp> __t, _Compare __comp)
	{
	return *_VSTD::max_element(__t.begin(), __t.end(), __comp);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_Tp
	max(initializer_list<_Tp> __t)
	{
	return *_VSTD::max_element(__t.begin(), __t.end(), __less<_Tp>());
	}

	#endif // _LIBCPP_CXX03_LANG

	#if _LIBCPP_STD_VER > 14
	// clamp
	template<class _Tp, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	const _Tp&
	clamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
	{
	_LIBCPP_ASSERT(!__comp(__hi, __lo), "Bad bounds passed to std::clamp");
	return __comp(__v, __lo) ? __lo : __comp(__hi, __v) ? __hi : __v;

	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	const _Tp&
	clamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi)
	{
	return _VSTD::clamp(__v, __lo, __hi, __less<_Tp>());
	}
	#endif

	// minmax_element

	template <class _ForwardIterator, class _Compare>
	_LIBCPP_CONSTEXPR_AFTER_CXX11
	std::pair<_ForwardIterator, _ForwardIterator>
	minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
	{
	std::pair<_ForwardIterator, _ForwardIterator> __result(__first, __first);
	if (__first != __last)
	{
	if (++__first != __last)
	{
	if (__comp(__first, __result.first))
	__result.first = __first;
	else
	__result.second = __first;
	while (++__first != __last)
	{
	_ForwardIterator __i = __first;
	if (++__first == __last)
	{
	if (__comp(__i, __result.first))
	__result.first = __i;
	else if (!__comp(__i, __result.second))
	__result.second = __i;
	break;
	}
	else
	{
	if (__comp(__first, __i))
	{
	if (__comp(__first, __result.first))
	__result.first = __first;
	if (!__comp(__i, __result.second))
	__result.second = __i;
	}
	else
	{
	if (__comp(__i, __result.first))
	__result.first = __i;
	if (!__comp(__first, __result.second))
	__result.second = __first;
	}
	}
	}
	}
	}
	return __result;
	}

	template <class _ForwardIterator>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	std::pair<_ForwardIterator, _ForwardIterator>
	minmax_element(_ForwardIterator __first, _ForwardIterator __last)
	{
	return _VSTD::minmax_element(__first, __last,
	__less<typename iterator_traits<_ForwardIterator>::value_type>());
	}

	// minmax

	template<class _Tp, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	pair<const _Tp&, const _Tp&>
	minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
	{
	return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a) :
	pair<const _Tp&, const _Tp&>(__a, __b);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	pair<const _Tp&, const _Tp&>
	minmax(const _Tp& __a, const _Tp& __b)
	{
	return _VSTD::minmax(__a, __b, __less<_Tp>());
	}

	#ifndef _LIBCPP_CXX03_LANG

	template<class _Tp, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	pair<_Tp, _Tp>
	minmax(initializer_list<_Tp> __t, _Compare __comp)
	{
	typedef typename initializer_list<_Tp>::const_iterator _Iter;
	_Iter __first = __t.begin();
	_Iter __last = __t.end();
	std::pair<_Tp, _Tp> __result(__first, __first);

	++__first;
	if (__t.size() % 2 == 0)
	{
	if (__comp(*__first, __result.first))
	__result.first = *__first;
	else
	__result.second = *__first;
	++__first;
	}

	while (__first != __last)
	{
	_Tp __prev = *__first++;
	if (__comp(*__first, __prev)) {
	if ( __comp(__first, __result.first)) __result.first = __first;
	if (!__comp(__prev, __result.second)) __result.second = __prev;
	}
	else {
	if ( __comp(__prev, __result.first)) __result.first = __prev;
	if (!__comp(__first, __result.second)) __result.second = __first;
	}

	__first++;
	}
	return __result;
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	pair<_Tp, _Tp>
	minmax(initializer_list<_Tp> __t)
	{
	return _VSTD::minmax(__t, __less<_Tp>());
	}

	#endif // _LIBCPP_CXX03_LANG

	// random_shuffle

	// __independent_bits_engine

	template <unsigned long long _Xp, size_t _Rp>
	struct __log2_imp
	{
	static const size_t value = _Xp & ((unsigned long long)(1) << _Rp) ? _Rp
	: __log2_imp<_Xp, _Rp - 1>::value;
	};

	template <unsigned long long _Xp>
	struct __log2_imp<_Xp, 0>
	{
	static const size_t value = 0;
	};

	template <size_t _Rp>
	struct __log2_imp<0, _Rp>
	{
	static const size_t value = _Rp + 1;
	};

	template <class _UIntType, _UIntType _Xp>
	struct __log2
	{
	static const size_t value = __log2_imp<_Xp,
	sizeof(_UIntType) * __CHAR_BIT__ - 1>::value;
	};

	template<class _Engine, class _UIntType>
	class __independent_bits_engine
	{
	public:
	// types
	typedef _UIntType result_type;

	private:
	typedef typename _Engine::result_type _Engine_result_type;
	typedef typename conditional
	<
	sizeof(_Engine_result_type) <= sizeof(result_type),
	result_type,
	_Engine_result_type
	>::type _Working_result_type;

	_Engine& __e_;
	size_t __w_;
	size_t __w0_;
	size_t __n_;
	size_t __n0_;
	_Working_result_type __y0_;
	_Working_result_type __y1_;
	_Engine_result_type __mask0_;
	_Engine_result_type __mask1_;

	#ifdef _LIBCPP_CXX03_LANG
	static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min
	+ _Working_result_type(1);
	#else
	static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min()
	+ _Working_result_type(1);
	#endif
	static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value;
	static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits;
	static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits;

	public:
	// constructors and seeding functions
	__independent_bits_engine(_Engine& __e, size_t __w);

	// generating functions
	result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}

	private:
	result_type __eval(false_type);
	result_type __eval(true_type);
	};

	template<class _Engine, class _UIntType>
	__independent_bits_engine<_Engine, _UIntType>
	::__independent_bits_engine(_Engine& __e, size_t __w)
	: __e_(__e),
	__w_(__w)
	{
	__n_ = __w_ / __m + (__w_ % __m != 0);
	__w0_ = __w_ / __n_;
	if (_Rp == 0)
	__y0_ = _Rp;
	else if (__w0_ < _WDt)
	__y0_ = (_Rp >> __w0_) << __w0_;
	else
	__y0_ = 0;
	if (_Rp - __y0_ > __y0_ / __n_)
	{
	++__n_;
	__w0_ = __w_ / __n_;
	if (__w0_ < _WDt)
	__y0_ = (_Rp >> __w0_) << __w0_;
	else
	__y0_ = 0;
	}
	__n0_ = __n_ - __w_ % __n_;
	if (__w0_ < _WDt - 1)
	__y1_ = (_Rp >> (__w0_ + 1)) << (__w0_ + 1);
	else
	__y1_ = 0;
	__mask0_ = __w0_ > 0 ? _Engine_result_type(~0) >> (_EDt - __w0_) :
	_Engine_result_type(0);
	__mask1_ = __w0_ < _EDt - 1 ?
	_Engine_result_type(~0) >> (_EDt - (__w0_ + 1)) :
	_Engine_result_type(~0);
	}

	template<class _Engine, class _UIntType>
	inline
	_UIntType
	__independent_bits_engine<_Engine, _UIntType>::__eval(false_type)
	{
	return static_cast<result_type>(__e_() & __mask0_);
	}

	template<class _Engine, class _UIntType>
	_UIntType
	__independent_bits_engine<_Engine, _UIntType>::__eval(true_type)
	{
	const size_t _WRt = numeric_limits<result_type>::digits;
	result_type _Sp = 0;
	for (size_t __k = 0; __k < __n0_; ++__k)
	{
	_Engine_result_type __u;
	do
	{
	__u = __e_() - _Engine::min();
	} while (__u >= __y0_);
	if (__w0_ < _WRt)
	_Sp <<= __w0_;
	else
	_Sp = 0;
	_Sp += __u & __mask0_;
	}
	for (size_t __k = __n0_; __k < __n_; ++__k)
	{
	_Engine_result_type __u;
	do
	{
	__u = __e_() - _Engine::min();
	} while (__u >= __y1_);
	if (__w0_ < _WRt - 1)
	_Sp <<= __w0_ + 1;
	else
	_Sp = 0;
	_Sp += __u & __mask1_;
	}
	return _Sp;
	}

	// uniform_int_distribution

	template<class _IntType = int>
	class uniform_int_distribution
	{
	public:
	// types
	typedef _IntType result_type;

	class param_type
	{
	result_type __a_;
	result_type __b_;
	public:
	typedef uniform_int_distribution distribution_type;

	explicit param_type(result_type __a = 0,
	result_type __b = numeric_limits<result_type>::max())
	: __a_(__a), __b_(__b) {}

	result_type a() const {return __a_;}
	result_type b() const {return __b_;}

	friend bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
	friend bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}
	};

	private:
	param_type __p_;

	public:
	// constructors and reset functions
	explicit uniform_int_distribution(result_type __a = 0,
	result_type __b = numeric_limits<result_type>::max())
	: __p_(param_type(__a, __b)) {}
	explicit uniform_int_distribution(const param_type& __p) : __p_(__p) {}
	void reset() {}

	// generating functions
	template<class _URNG> result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);

	// property functions
	result_type a() const {return __p_.a();}
	result_type b() const {return __p_.b();}

	param_type param() const {return __p_;}
	void param(const param_type& __p) {__p_ = __p;}

	result_type min() const {return a();}
	result_type max() const {return b();}

	friend bool operator==(const uniform_int_distribution& __x,
	const uniform_int_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend bool operator!=(const uniform_int_distribution& __x,
	const uniform_int_distribution& __y)
	{return !(__x == __y);}
	};

	template<class _IntType>
	template<class _URNG>
	typename uniform_int_distribution<_IntType>::result_type
	uniform_int_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
	{
	typedef typename conditional<sizeof(result_type) <= sizeof(uint32_t),
	uint32_t, uint64_t>::type _UIntType;
	const _UIntType _Rp = __p.b() - __p.a() + _UIntType(1);
	if (_Rp == 1)
	return __p.a();
	const size_t _Dt = numeric_limits<_UIntType>::digits;
	typedef __independent_bits_engine<_URNG, _UIntType> _Eng;
	if (_Rp == 0)
	return static_cast<result_type>(_Eng(__g, _Dt)());
	size_t __w = _Dt - __clz(_Rp) - 1;
	if ((_Rp & (std::numeric_limits<_UIntType>::max() >> (_Dt - __w))) != 0)
	++__w;
	_Eng __e(__g, __w);
	_UIntType __u;
	do
	{
	__u = __e();
	} while (__u >= _Rp);
	return static_cast<result_type>(__u + __p.a());
	}

	#if _LIBCPP_STD_VER <= 14 \|\| defined(_LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE) \
	\|\| defined(_LIBCPP_BUILDING_LIBRARY)
	class _LIBCPP_TYPE_VIS __rs_default;

	_LIBCPP_FUNC_VIS __rs_default __rs_get();

	class _LIBCPP_TYPE_VIS __rs_default
	{
	static unsigned __c_;

	__rs_default();
	public:
	typedef uint_fast32_t result_type;

	static const result_type _Min = 0;
	static const result_type _Max = 0xFFFFFFFF;

	__rs_default(const __rs_default&);
	~__rs_default();

	result_type operator()();

	static _LIBCPP_CONSTEXPR result_type min() {return _Min;}
	static _LIBCPP_CONSTEXPR result_type max() {return _Max;}

	friend _LIBCPP_FUNC_VIS __rs_default __rs_get();
	};

	_LIBCPP_FUNC_VIS __rs_default __rs_get();

	template <class _RandomAccessIterator>
	void
	random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
	{
	typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
	typedef uniform_int_distribution<ptrdiff_t> _Dp;
	typedef typename _Dp::param_type _Pp;
	difference_type __d = __last - __first;
	if (__d > 1)
	{
	_Dp __uid;
	__rs_default __g = __rs_get();
	for (--__last, --__d; __first < __last; ++__first, --__d)
	{
	difference_type __i = __uid(__g, _Pp(0, __d));
	if (__i != difference_type(0))
	swap(__first, (__first + __i));
	}
	}
	}

	template <class _RandomAccessIterator, class _RandomNumberGenerator>
	void
	random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
	#ifndef _LIBCPP_CXX03_LANG
	_RandomNumberGenerator&& __rand)
	#else
	_RandomNumberGenerator& __rand)
	#endif
	{
	typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
	difference_type __d = __last - __first;
	if (__d > 1)
	{
	for (--__last; __first < __last; ++__first, --__d)
	{
	difference_type __i = __rand(__d);
	swap(__first, (__first + __i));
	}
	}
	}
	#endif

	template <class _PopulationIterator, class _SampleIterator, class _Distance,
	class _UniformRandomNumberGenerator>
	_LIBCPP_INLINE_VISIBILITY
	_SampleIterator __sample(_PopulationIterator __first,
	_PopulationIterator __last, _SampleIterator __output_iter,
	_Distance __n,
	_UniformRandomNumberGenerator & __g,
	input_iterator_tag) {

	_Distance __k = 0;
	for (; __first != __last && __k < __n; ++__first, (void)++__k)
	__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_iter[__r] = *__first;
	}
	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_iter,
	_Distance __n,
	_UniformRandomNumberGenerator& __g,
	forward_iterator_tag) {
	_Distance __unsampled_sz = _VSTD::distance(__first, __last);
	for (__n = _VSTD::min(__n, __unsampled_sz); __n != 0; ++__first) {
	_Distance __r =
	_VSTD::uniform_int_distribution<_Distance>(0, --__unsampled_sz)(__g);
	if (__r < __n) {
	__output_iter++ = __first;
	--__n;
	}
	}
	return __output_iter;
	}

	template <class _PopulationIterator, class _SampleIterator, class _Distance,
	class _UniformRandomNumberGenerator>
	_LIBCPP_INLINE_VISIBILITY
	_SampleIterator __sample(_PopulationIterator __first,
	_PopulationIterator __last, _SampleIterator __output_iter,
	_Distance __n, _UniformRandomNumberGenerator& __g) {
	typedef typename iterator_traits<_PopulationIterator>::iterator_category
	_PopCategory;
	typedef typename iterator_traits<_PopulationIterator>::difference_type
	_Difference;
	static_assert(__is_forward_iterator<_PopulationIterator>::value \|\|
	__is_random_access_iterator<_SampleIterator>::value,
	"SampleIterator must meet the requirements of RandomAccessIterator");
	typedef typename common_type<_Distance, _Difference>::type _CommonType;
	_LIBCPP_ASSERT(__n >= 0, "N must be a positive number.");
	return _VSTD::__sample(
	__first, __last, __output_iter, _CommonType(__n),
	__g, _PopCategory());
	}

	#if _LIBCPP_STD_VER > 14
	template <class _PopulationIterator, class _SampleIterator, class _Distance,
	class _UniformRandomNumberGenerator>
	inline _LIBCPP_INLINE_VISIBILITY
	_SampleIterator sample(_PopulationIterator __first,
	_PopulationIterator __last, _SampleIterator __output_iter,
	_Distance __n, _UniformRandomNumberGenerator&& __g) {
	return _VSTD::__sample(__first, __last, __output_iter, __n, __g);
	}
	#endif // _LIBCPP_STD_VER > 14

	template<class _RandomAccessIterator, class _UniformRandomNumberGenerator>
	void shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
	#ifndef _LIBCPP_CXX03_LANG
	_UniformRandomNumberGenerator&& __g)
	#else
	_UniformRandomNumberGenerator& __g)
	#endif
	{
	typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
	typedef uniform_int_distribution<ptrdiff_t> _Dp;
	typedef typename _Dp::param_type _Pp;
	difference_type __d = __last - __first;
	if (__d > 1)
	{
	_Dp __uid;
	for (--__last, --__d; __first < __last; ++__first, --__d)
	{
	difference_type __i = __uid(__g, _Pp(0, __d));
	if (__i != difference_type(0))
	swap(__first, (__first + __i));
	}
	}
	}

	template <class _InputIterator, class _Predicate>
	-bool
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
	is_partitioned(_InputIterator __first, _InputIterator __last, _Predicate __pred)
	{
	for (; __first != __last; ++__first)
	if (!__pred(*__first))
	break;
	if ( __first == __last )
	return true;
	++__first;
	for (; __first != __last; ++__first)
	if (__pred(*__first))
	return false;
	return true;
	}

	// partition

	template <class _Predicate, class _ForwardIterator>
	_ForwardIterator
	__partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, forward_iterator_tag)
	{
	while (true)
	{
	if (__first == __last)
	return __first;
	if (!__pred(*__first))
	break;
	++__first;
	}
	for (_ForwardIterator __p = __first; ++__p != __last;)
	{
	if (__pred(*__p))
	{
	swap(__first, __p);
	++__first;
	}
	}
	return __first;
	}

	template <class _Predicate, class _BidirectionalIterator>
	_BidirectionalIterator
	__partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
	bidirectional_iterator_tag)
	{
	while (true)
	{
	while (true)
	{
	if (__first == __last)
	return __first;
	if (!__pred(*__first))
	break;
	++__first;
	}
	do
	{
	if (__first == --__last)
	return __first;
	} while (!__pred(*__last));
	swap(__first, __last);
	++__first;
	}
	}

	template <class _ForwardIterator, class _Predicate>
	inline _LIBCPP_INLINE_VISIBILITY
	_ForwardIterator
	partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
	{
	return _VSTD::__partition<typename add_lvalue_reference<_Predicate>::type>
	(__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category());
	}

	// partition_copy

	template <class _InputIterator, class _OutputIterator1,
	class _OutputIterator2, class _Predicate>
	-pair<_OutputIterator1, _OutputIterator2>
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_OutputIterator1, _OutputIterator2>
	partition_copy(_InputIterator __first, _InputIterator __last,
	_OutputIterator1 __out_true, _OutputIterator2 __out_false,
	_Predicate __pred)
	{
	for (; __first != __last; ++__first)
	{
	if (__pred(*__first))
	{
	__out_true = __first;
	++__out_true;
	}
	else
	{
	__out_false = __first;
	++__out_false;
	}
	}
	return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
	}

	// partition_point

	template<class _ForwardIterator, class _Predicate>
	-_ForwardIterator
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
	partition_point(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
	{
	typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
	difference_type __len = _VSTD::distance(__first, __last);
	while (__len != 0)
	{
	difference_type __l2 = __len / 2;
	_ForwardIterator __m = __first;
	_VSTD::advance(__m, __l2);
	if (__pred(*__m))
	{
	__first = ++__m;
	__len -= __l2 + 1;
	}
	else
	__len = __l2;
	}
	return __first;
	}

	// stable_partition

	template <class _Predicate, class _ForwardIterator, class _Distance, class _Pair>
	_ForwardIterator
	__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
	_Distance __len, _Pair __p, forward_iterator_tag __fit)
	{
	// *__first is known to be false
	// __len >= 1
	if (__len == 1)
	return __first;
	if (__len == 2)
	{
	_ForwardIterator __m = __first;
	if (__pred(*++__m))
	{
	swap(__first, __m);
	return __m;
	}
	return __first;
	}
	if (__len <= __p.second)
	{ // The buffer is big enough to use
	typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
	__destruct_n __d(0);
	unique_ptr<value_type, __destruct_n&> __h(__p.first, __d);
	// Move the falses into the temporary buffer, and the trues to the front of the line
	// Update __first to always point to the end of the trues
	value_type* __t = __p.first;
	::new(__t) value_type(_VSTD::move(*__first));
	__d.__incr((value_type*)0);
	++__t;
	_ForwardIterator __i = __first;
	while (++__i != __last)
	{
	if (__pred(*__i))
	{
	__first = _VSTD::move(__i);
	++__first;
	}
	else
	{
	::new(__t) value_type(_VSTD::move(*__i));
	__d.__incr((value_type*)0);
	++__t;
	}
	}
	// All trues now at start of range, all falses in buffer
	// Move falses back into range, but don't mess up __first which points to first false
	__i = __first;
	for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i)
	__i = _VSTD::move(__t2);
	// __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
	return __first;
	}
	// Else not enough buffer, do in place
	// __len >= 3
	_ForwardIterator __m = __first;
	_Distance __len2 = __len / 2; // __len2 >= 2
	_VSTD::advance(__m, __len2);
	// recurse on [__first, __m), *__first know to be false
	// F?????????????????
	// f m l
	typedef typename add_lvalue_reference<_Predicate>::type _PredRef;
	_ForwardIterator __first_false = __stable_partition<_PredRef>(__first, __m, __pred, __len2, __p, __fit);
	// TTTFFFFF??????????
	// f ff m l
	// recurse on [__m, __last], except increase __m until (__m) is false, __last know to be true
	_ForwardIterator __m1 = __m;
	_ForwardIterator __second_false = __last;
	_Distance __len_half = __len - __len2;
	while (__pred(*__m1))
	{
	if (++__m1 == __last)
	goto __second_half_done;
	--__len_half;
	}
	// TTTFFFFFTTTF??????
	// f ff m m1 l
	__second_false = __stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __fit);
	__second_half_done:
	// TTTFFFFFTTTTTFFFFF
	// f ff m sf l
	return _VSTD::rotate(__first_false, __m, __second_false);
	// TTTTTTTTFFFFFFFFFF
	// \|
	}

	struct __return_temporary_buffer
	{
	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) const {_VSTD::return_temporary_buffer(__p);}
	};

	template <class _Predicate, class _ForwardIterator>
	_ForwardIterator
	__stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
	forward_iterator_tag)
	{
	const unsigned __alloc_limit = 3; // might want to make this a function of trivial assignment
	// Either prove all true and return __first or point to first false
	while (true)
	{
	if (__first == __last)
	return __first;
	if (!__pred(*__first))
	break;
	++__first;
	}
	// We now have a reduced range [__first, __last)
	// *__first is known to be false
	typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
	typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
	difference_type __len = _VSTD::distance(__first, __last);
	pair<value_type*, ptrdiff_t> __p(0, 0);
	unique_ptr<value_type, __return_temporary_buffer> __h;
	if (__len >= __alloc_limit)
	{
	__p = _VSTD::get_temporary_buffer<value_type>(__len);
	__h.reset(__p.first);
	}
	return __stable_partition<typename add_lvalue_reference<_Predicate>::type>
	(__first, __last, __pred, __len, __p, forward_iterator_tag());
	}

	template <class _Predicate, class _BidirectionalIterator, class _Distance, class _Pair>
	_BidirectionalIterator
	__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
	_Distance __len, _Pair __p, bidirectional_iterator_tag __bit)
	{
	// *__first is known to be false
	// *__last is known to be true
	// __len >= 2
	if (__len == 2)
	{
	swap(__first, __last);
	return __last;
	}
	if (__len == 3)
	{
	_BidirectionalIterator __m = __first;
	if (__pred(*++__m))
	{
	swap(__first, __m);
	swap(__m, __last);
	return __last;
	}
	swap(__m, __last);
	swap(__first, __m);
	return __m;
	}
	if (__len <= __p.second)
	{ // The buffer is big enough to use
	typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
	__destruct_n __d(0);
	unique_ptr<value_type, __destruct_n&> __h(__p.first, __d);
	// Move the falses into the temporary buffer, and the trues to the front of the line
	// Update __first to always point to the end of the trues
	value_type* __t = __p.first;
	::new(__t) value_type(_VSTD::move(*__first));
	__d.__incr((value_type*)0);
	++__t;
	_BidirectionalIterator __i = __first;
	while (++__i != __last)
	{
	if (__pred(*__i))
	{
	__first = _VSTD::move(__i);
	++__first;
	}
	else
	{
	::new(__t) value_type(_VSTD::move(*__i));
	__d.__incr((value_type*)0);
	++__t;
	}
	}
	// move *__last, known to be true
	__first = _VSTD::move(__i);
	__i = ++__first;
	// All trues now at start of range, all falses in buffer
	// Move falses back into range, but don't mess up __first which points to first false
	for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i)
	__i = _VSTD::move(__t2);
	// __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
	return __first;
	}
	// Else not enough buffer, do in place
	// __len >= 4
	_BidirectionalIterator __m = __first;
	_Distance __len2 = __len / 2; // __len2 >= 2
	_VSTD::advance(__m, __len2);
	// recurse on [__first, __m-1], except reduce __m-1 until (__m-1) is true, __first know to be false
	// F????????????????T
	// f m l
	_BidirectionalIterator __m1 = __m;
	_BidirectionalIterator __first_false = __first;
	_Distance __len_half = __len2;
	while (!__pred(*--__m1))
	{
	if (__m1 == __first)
	goto __first_half_done;
	--__len_half;
	}
	// F???TFFF?????????T
	// f m1 m l
	typedef typename add_lvalue_reference<_Predicate>::type _PredRef;
	__first_false = __stable_partition<_PredRef>(__first, __m1, __pred, __len_half, __p, __bit);
	__first_half_done:
	// TTTFFFFF?????????T
	// f ff m l
	// recurse on [__m, __last], except increase __m until (__m) is false, __last know to be true
	__m1 = __m;
	_BidirectionalIterator __second_false = __last;
	++__second_false;
	__len_half = __len - __len2;
	while (__pred(*__m1))
	{
	if (++__m1 == __last)
	goto __second_half_done;
	--__len_half;
	}
	// TTTFFFFFTTTF?????T
	// f ff m m1 l
	__second_false = __stable_partition<_PredRef>(__m1, __last, __pred, __len_half, __p, __bit);
	__second_half_done:
	// TTTFFFFFTTTTTFFFFF
	// f ff m sf l
	return _VSTD::rotate(__first_false, __m, __second_false);
	// TTTTTTTTFFFFFFFFFF
	// \|
	}

	template <class _Predicate, class _BidirectionalIterator>
	_BidirectionalIterator
	__stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
	bidirectional_iterator_tag)
	{
	typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
	typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
	const difference_type __alloc_limit = 4; // might want to make this a function of trivial assignment
	// Either prove all true and return __first or point to first false
	while (true)
	{
	if (__first == __last)
	return __first;
	if (!__pred(*__first))
	break;
	++__first;
	}
	// __first points to first false, everything prior to __first is already set.
	// Either prove [__first, __last) is all false and return __first, or point __last to last true
	do
	{
	if (__first == --__last)
	return __first;
	} while (!__pred(*__last));
	// We now have a reduced range [__first, __last]
	// *__first is known to be false
	// *__last is known to be true
	// __len >= 2
	difference_type __len = _VSTD::distance(__first, __last) + 1;
	pair<value_type*, ptrdiff_t> __p(0, 0);
	unique_ptr<value_type, __return_temporary_buffer> __h;
	if (__len >= __alloc_limit)
	{
	__p = _VSTD::get_temporary_buffer<value_type>(__len);
	__h.reset(__p.first);
	}
	return __stable_partition<typename add_lvalue_reference<_Predicate>::type>
	(__first, __last, __pred, __len, __p, bidirectional_iterator_tag());
	}

	template <class _ForwardIterator, class _Predicate>
	inline _LIBCPP_INLINE_VISIBILITY
	_ForwardIterator
	stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
	{
	return __stable_partition<typename add_lvalue_reference<_Predicate>::type>
	(__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category());
	}

	// is_sorted_until

	template <class _ForwardIterator, class _Compare>
	-_ForwardIterator
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
	is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
	{
	if (__first != __last)
	{
	_ForwardIterator __i = __first;
	while (++__i != __last)
	{
	if (__comp(__i, __first))
	return __i;
	__first = __i;
	}
	}
	return __last;
	}

	template<class _ForwardIterator>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_ForwardIterator
	is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
	{
	return _VSTD::is_sorted_until(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
	}

	// is_sorted

	template <class _ForwardIterator, class _Compare>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	is_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
	{
	return _VSTD::is_sorted_until(__first, __last, __comp) == __last;
	}

	template<class _ForwardIterator>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	is_sorted(_ForwardIterator __first, _ForwardIterator __last)
	{
	return _VSTD::is_sorted(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
	}

	// sort

	// stable, 2-3 compares, 0-2 swaps

	template <class _Compare, class _ForwardIterator>
	unsigned
	__sort3(_ForwardIterator __x, _ForwardIterator __y, _ForwardIterator __z, _Compare __c)
	{
	unsigned __r = 0;
	if (!__c(__y, __x)) // if x <= y
	{
	if (!__c(__z, __y)) // if y <= z
	return __r; // x <= y && y <= z
	// x <= y && y > z
	swap(__y, __z); // x <= z && y < z
	__r = 1;
	if (__c(__y, __x)) // if x > y
	{
	swap(__x, __y); // x < y && y <= z
	__r = 2;
	}
	return __r; // x <= y && y < z
	}
	if (__c(__z, __y)) // x > y, if y > z
	{
	swap(__x, __z); // x < y && y < z
	__r = 1;
	return __r;
	}
	swap(__x, __y); // x > y && y <= z
	__r = 1; // x < y && x <= z
	if (__c(__z, __y)) // if y > z
	{
	swap(__y, __z); // x <= y && y < z
	__r = 2;
	}
	return __r;
	} // x <= y && y <= z

	// stable, 3-6 compares, 0-5 swaps

	template <class _Compare, class _ForwardIterator>
	unsigned
	__sort4(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3,
	_ForwardIterator __x4, _Compare __c)
	{
	unsigned __r = __sort3<_Compare>(__x1, __x2, __x3, __c);
	if (__c(__x4, __x3))
	{
	swap(__x3, __x4);
	++__r;
	if (__c(__x3, __x2))
	{
	swap(__x2, __x3);
	++__r;
	if (__c(__x2, __x1))
	{
	swap(__x1, __x2);
	++__r;
	}
	}
	}
	return __r;
	}

	// stable, 4-10 compares, 0-9 swaps

	template <class _Compare, class _ForwardIterator>
	unsigned
	__sort5(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3,
	_ForwardIterator __x4, _ForwardIterator __x5, _Compare __c)
	{
	unsigned __r = __sort4<_Compare>(__x1, __x2, __x3, __x4, __c);
	if (__c(__x5, __x4))
	{
	swap(__x4, __x5);
	++__r;
	if (__c(__x4, __x3))
	{
	swap(__x3, __x4);
	++__r;
	if (__c(__x3, __x2))
	{
	swap(__x2, __x3);
	++__r;
	if (__c(__x2, __x1))
	{
	swap(__x1, __x2);
	++__r;
	}
	}
	}
	}
	return __r;
	}

	// Assumes size > 0
	template <class _Compare, class _BirdirectionalIterator>
	void
	__selection_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last, _Compare __comp)
	{
	_BirdirectionalIterator __lm1 = __last;
	for (--__lm1; __first != __lm1; ++__first)
	{
	_BirdirectionalIterator __i = _VSTD::min_element<_BirdirectionalIterator,
	typename add_lvalue_reference<_Compare>::type>
	(__first, __last, __comp);
	if (__i != __first)
	swap(__first, __i);
	}
	}

	template <class _Compare, class _BirdirectionalIterator>
	void
	__insertion_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last, _Compare __comp)
	{
	typedef typename iterator_traits<_BirdirectionalIterator>::value_type value_type;
	if (__first != __last)
	{
	_BirdirectionalIterator __i = __first;
	for (++__i; __i != __last; ++__i)
	{
	_BirdirectionalIterator __j = __i;
	value_type __t(_VSTD::move(*__j));
	for (_BirdirectionalIterator __k = __i; __k != __first && __comp(__t, *--__k); --__j)
	__j = _VSTD::move(__k);
	*__j = _VSTD::move(__t);
	}
	}
	}

	template <class _Compare, class _RandomAccessIterator>
	void
	__insertion_sort_3(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
	{
	typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
	_RandomAccessIterator __j = __first+2;
	__sort3<_Compare>(__first, __first+1, __j, __comp);
	for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i)
	{
	if (__comp(__i, __j))
	{
	value_type __t(_VSTD::move(*__i));
	_RandomAccessIterator __k = __j;
	__j = __i;
	do
	{
	__j = _VSTD::move(__k);
	__j = __k;
	} while (__j != __first && __comp(__t, *--__k));
	*__j = _VSTD::move(__t);
	}
	__j = __i;
	}
	}

	template <class _Compare, class _RandomAccessIterator>
	bool
	__insertion_sort_incomplete(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
	{
	switch (__last - __first)
	{
	case 0:
	case 1:
	return true;
	case 2:
	if (__comp(--__last, __first))
	swap(__first, __last);
	return true;
	case 3:
	_VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp);
	return true;
	case 4:
	_VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp);
	return true;
	case 5:
	_VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp);
	return true;
	}
	typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
	_RandomAccessIterator __j = __first+2;
	__sort3<_Compare>(__first, __first+1, __j, __comp);
	const unsigned __limit = 8;
	unsigned __count = 0;
	for (_RandomAccessIterator __i = __j+1; __i != __last; ++__i)
	{
	if (__comp(__i, __j))
	{
	value_type __t(_VSTD::move(*__i));
	_RandomAccessIterator __k = __j;
	__j = __i;
	do
	{
	__j = _VSTD::move(__k);
	__j = __k;
	} while (__j != __first && __comp(__t, *--__k));
	*__j = _VSTD::move(__t);
	if (++__count == __limit)
	return ++__i == __last;
	}
	__j = __i;
	}
	return true;
	}

	template <class _Compare, class _BirdirectionalIterator>
	void
	__insertion_sort_move(_BirdirectionalIterator __first1, _BirdirectionalIterator __last1,
	typename iterator_traits<_BirdirectionalIterator>::value_type* __first2, _Compare __comp)
	{
	typedef typename iterator_traits<_BirdirectionalIterator>::value_type value_type;
	if (__first1 != __last1)
	{
	__destruct_n __d(0);
	unique_ptr<value_type, __destruct_n&> __h(__first2, __d);
	value_type* __last2 = __first2;
	::new(__last2) value_type(_VSTD::move(*__first1));
	__d.__incr((value_type*)0);
	for (++__last2; ++__first1 != __last1; ++__last2)
	{
	value_type* __j2 = __last2;
	value_type* __i2 = __j2;
	if (__comp(__first1, --__i2))
	{
	::new(__j2) value_type(_VSTD::move(*__i2));
	__d.__incr((value_type*)0);
	for (--__j2; __i2 != __first2 && __comp(__first1, --__i2); --__j2)
	__j2 = _VSTD::move(__i2);
	__j2 = _VSTD::move(__first1);
	}
	else
	{
	::new(__j2) value_type(_VSTD::move(*__first1));
	__d.__incr((value_type*)0);
	}
	}
	__h.release();
	}
	}

	template <class _Compare, class _RandomAccessIterator>
	void
	__sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
	{
	// _Compare is known to be a reference type
	typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
	typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
	const difference_type __limit = is_trivially_copy_constructible<value_type>::value &&
	is_trivially_copy_assignable<value_type>::value ? 30 : 6;
	while (true)
	{
	__restart:
	difference_type __len = __last - __first;
	switch (__len)
	{
	case 0:
	case 1:
	return;
	case 2:
	if (__comp(--__last, __first))
	swap(__first, __last);
	return;
	case 3:
	_VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp);
	return;
	case 4:
	_VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp);
	return;
	case 5:
	_VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp);
	return;
	}
	if (__len <= __limit)
	{
	_VSTD::__insertion_sort_3<_Compare>(__first, __last, __comp);
	return;
	}
	// __len > 5
	_RandomAccessIterator __m = __first;
	_RandomAccessIterator __lm1 = __last;
	--__lm1;
	unsigned __n_swaps;
	{
	difference_type __delta;
	if (__len >= 1000)
	{
	__delta = __len/2;
	__m += __delta;
	__delta /= 2;
	__n_swaps = _VSTD::__sort5<_Compare>(__first, __first + __delta, __m, __m+__delta, __lm1, __comp);
	}
	else
	{
	__delta = __len/2;
	__m += __delta;
	__n_swaps = _VSTD::__sort3<_Compare>(__first, __m, __lm1, __comp);
	}
	}
	// *__m is median
	// partition [__first, __m) < __m and __m <= [__m, __last)
	// (this inhibits tossing elements equivalent to __m around unnecessarily)
	_RandomAccessIterator __i = __first;
	_RandomAccessIterator __j = __lm1;
	// j points beyond range to be tested, __m is known to be <= __lm1
	// The search going up is known to be guarded but the search coming down isn't.
	// Prime the downward search with a guard.
	if (!__comp(__i, __m)) // if __first == __m
	{
	// __first == __m, *__first doesn't go in first part
	// manually guard downward moving __j against __i
	while (true)
	{
	if (__i == --__j)
	{
	// __first == __m, *__m <= all other elements
	// Parition instead into [__first, __i) == __first and __first < [__i, __last)
	++__i; // __first + 1
	__j = __last;
	if (!__comp(__first, --__j)) // we need a guard if __first == (__last-1)
	{
	while (true)
	{
	if (__i == __j)
	return; // [__first, __last) all equivalent elements
	if (__comp(__first, __i))
	{
	swap(__i, __j);
	++__n_swaps;
	++__i;
	break;
	}
	++__i;
	}
	}
	// [__first, __i) == __first and __first < [__j, __last) and __j == __last - 1
	if (__i == __j)
	return;
	while (true)
	{
	while (!__comp(__first, __i))
	++__i;
	while (__comp(__first, --__j))
	;
	if (__i >= __j)
	break;
	swap(__i, __j);
	++__n_swaps;
	++__i;
	}
	// [__first, __i) == __first and __first < [__i, __last)
	// The first part is sorted, sort the secod part
	// _VSTD::__sort<_Compare>(__i, __last, __comp);
	__first = __i;
	goto __restart;
	}
	if (__comp(__j, __m))
	{
	swap(__i, __j);
	++__n_swaps;
	break; // found guard for downward moving __j, now use unguarded partition
	}
	}
	}
	// It is known that __i < __m
	++__i;
	// j points beyond range to be tested, __m is known to be <= __lm1
	// if not yet partitioned...
	if (__i < __j)
	{
	// known that (__i - 1) < __m
	// known that __i <= __m
	while (true)
	{
	// __m still guards upward moving __i
	while (__comp(__i, __m))
	++__i;
	// It is now known that a guard exists for downward moving __j
	while (!__comp(--__j, __m))
	;
	if (__i > __j)
	break;
	swap(__i, __j);
	++__n_swaps;
	// It is known that __m != __j
	// If __m just moved, follow it
	if (__m == __i)
	__m = __j;
	++__i;
	}
	}
	// [__first, __i) < __m and __m <= [__i, __last)
	if (__i != __m && __comp(__m, __i))
	{
	swap(__i, __m);
	++__n_swaps;
	}
	// [__first, __i) < __i and __i <= [__i+1, __last)
	// If we were given a perfect partition, see if insertion sort is quick...
	if (__n_swaps == 0)
	{
	bool __fs = _VSTD::__insertion_sort_incomplete<_Compare>(__first, __i, __comp);
	if (_VSTD::__insertion_sort_incomplete<_Compare>(__i+1, __last, __comp))
	{
	if (__fs)
	return;
	__last = __i;
	continue;
	}
	else
	{
	if (__fs)
	{
	__first = ++__i;
	continue;
	}
	}
	}
	// sort smaller range with recursive call and larger with tail recursion elimination
	if (__i - __first < __last - __i)
	{
	_VSTD::__sort<_Compare>(__first, __i, __comp);
	// _VSTD::__sort<_Compare>(__i+1, __last, __comp);
	__first = ++__i;
	}
	else
	{
	_VSTD::__sort<_Compare>(__i+1, __last, __comp);
	// _VSTD::__sort<_Compare>(__first, __i, __comp);
	__last = __i;
	}
	}
	}

	// This forwarder keeps the top call and the recursive calls using the same instantiation, forcing a reference _Compare
	template <class _RandomAccessIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	__sort<_Comp_ref>(__first, __last, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	__sort<_Comp_ref>(__first, __last, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _RandomAccessIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
	{
	_VSTD::sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	sort(_Tp __first, _Tp __last)
	{
	_VSTD::sort((size_t)__first, (size_t)__last, __less<size_t>());
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	sort(__wrap_iter<_Tp> __first, __wrap_iter<_Tp> __last)
	{
	_VSTD::sort(__first.base(), __last.base());
	}

	template <class _Tp, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	sort(__wrap_iter<_Tp> __first, __wrap_iter<_Tp> __last, _Compare __comp)
	{
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	_VSTD::sort<_Tp*, _Comp_ref>(__first.base(), __last.base(), __comp);
	}

	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<char>&, char>(char, char*, __less<char>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<wchar_t>&, wchar_t>(wchar_t, wchar_t*, __less<wchar_t>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<signed char>&, signed char>(signed char, signed char*, __less<signed char>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned char>&, unsigned char>(unsigned char, unsigned char*, __less<unsigned char>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<short>&, short>(short, short*, __less<short>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned short>&, unsigned short>(unsigned short, unsigned short*, __less<unsigned short>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<int>&, int>(int, int*, __less<int>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned>&, unsigned>(unsigned, unsigned*, __less<unsigned>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long>&, long>(long, long*, __less<long>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned long>&, unsigned long>(unsigned long, unsigned long*, __less<unsigned long>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long long>&, long long>(long long, long long*, __less<long long>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<unsigned long long>&, unsigned long long>(unsigned long long, unsigned long long*, __less<unsigned long long>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<float>&, float>(float, float*, __less<float>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<double>&, double>(double, double*, __less<double>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void __sort<__less<long double>&, long double>(long double, long double*, __less<long double>&))

	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<char>&, char>(char, char*, __less<char>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<wchar_t>&, wchar_t>(wchar_t, wchar_t*, __less<wchar_t>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<signed char>&, signed char>(signed char, signed char*, __less<signed char>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned char>&, unsigned char>(unsigned char, unsigned char*, __less<unsigned char>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<short>&, short>(short, short*, __less<short>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned short>&, unsigned short>(unsigned short, unsigned short*, __less<unsigned short>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<int>&, int>(int, int*, __less<int>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned>&, unsigned>(unsigned, unsigned*, __less<unsigned>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long>&, long>(long, long*, __less<long>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned long>&, unsigned long>(unsigned long, unsigned long*, __less<unsigned long>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long long>&, long long>(long long, long long*, __less<long long>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<unsigned long long>&, unsigned long long>(unsigned long long, unsigned long long*, __less<unsigned long long>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<float>&, float>(float, float*, __less<float>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<double>&, double>(double, double*, __less<double>&))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS bool __insertion_sort_incomplete<__less<long double>&, long double>(long double, long double*, __less<long double>&))

	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS unsigned __sort5<__less<long double>&, long double>(long double, long double, long double, long double, long double, __less<long double>&))

	// lower_bound

	template <class _Compare, class _ForwardIterator, class _Tp>
	-_ForwardIterator
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
	__lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
	{
	typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
	difference_type __len = _VSTD::distance(__first, __last);
	while (__len != 0)
	{
	difference_type __l2 = __len / 2;
	_ForwardIterator __m = __first;
	_VSTD::advance(__m, __l2);
	if (__comp(*__m, __value_))
	{
	__first = ++__m;
	__len -= __l2 + 1;
	}
	else
	__len = __l2;
	}
	return __first;
	}

	template <class _ForwardIterator, class _Tp, class _Compare>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_ForwardIterator
	lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	return __lower_bound<_Comp_ref>(__first, __last, __value_, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	return __lower_bound<_Comp_ref>(__first, __last, __value_, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _ForwardIterator, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_ForwardIterator
	lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
	{
	return _VSTD::lower_bound(__first, __last, __value_,
	__less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
	}

	// upper_bound

	template <class _Compare, class _ForwardIterator, class _Tp>
	-_ForwardIterator
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
	__upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
	{
	typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
	difference_type __len = _VSTD::distance(__first, __last);
	while (__len != 0)
	{
	difference_type __l2 = __len / 2;
	_ForwardIterator __m = __first;
	_VSTD::advance(__m, __l2);
	if (__comp(__value_, *__m))
	__len = __l2;
	else
	{
	__first = ++__m;
	__len -= __l2 + 1;
	}
	}
	return __first;
	}

	template <class _ForwardIterator, class _Tp, class _Compare>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_ForwardIterator
	upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	return __upper_bound<_Comp_ref>(__first, __last, __value_, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	return __upper_bound<_Comp_ref>(__first, __last, __value_, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _ForwardIterator, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_ForwardIterator
	upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
	{
	return _VSTD::upper_bound(__first, __last, __value_,
	__less<_Tp, typename iterator_traits<_ForwardIterator>::value_type>());
	}

	// equal_range

	template <class _Compare, class _ForwardIterator, class _Tp>
	-pair<_ForwardIterator, _ForwardIterator>
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_ForwardIterator, _ForwardIterator>
	__equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
	{
	typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
	difference_type __len = _VSTD::distance(__first, __last);
	while (__len != 0)
	{
	difference_type __l2 = __len / 2;
	_ForwardIterator __m = __first;
	_VSTD::advance(__m, __l2);
	if (__comp(*__m, __value_))
	{
	__first = ++__m;
	__len -= __l2 + 1;
	}
	else if (__comp(__value_, *__m))
	{
	__last = __m;
	__len = __l2;
	}
	else
	{
	_ForwardIterator __mp1 = __m;
	return pair<_ForwardIterator, _ForwardIterator>
	(
	__lower_bound<_Compare>(__first, __m, __value_, __comp),
	__upper_bound<_Compare>(++__mp1, __last, __value_, __comp)
	);
	}
	}
	return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
	}

	template <class _ForwardIterator, class _Tp, class _Compare>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	pair<_ForwardIterator, _ForwardIterator>
	equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	return __equal_range<_Comp_ref>(__first, __last, __value_, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	return __equal_range<_Comp_ref>(__first, __last, __value_, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _ForwardIterator, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	pair<_ForwardIterator, _ForwardIterator>
	equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
	{
	return _VSTD::equal_range(__first, __last, __value_,
	__less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
	}

	// binary_search

	template <class _Compare, class _ForwardIterator, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	__binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
	{
	__first = __lower_bound<_Compare>(__first, __last, __value_, __comp);
	return __first != __last && !__comp(__value_, *__first);
	}

	template <class _ForwardIterator, class _Tp, class _Compare>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	return __binary_search<_Comp_ref>(__first, __last, __value_, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	return __binary_search<_Comp_ref>(__first, __last, __value_, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _ForwardIterator, class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
	{
	return _VSTD::binary_search(__first, __last, __value_,
	__less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
	}

	// merge

	template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
	_OutputIterator
	__merge(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
	{
	for (; __first1 != __last1; ++__result)
	{
	if (__first2 == __last2)
	return _VSTD::copy(__first1, __last1, __result);
	if (__comp(__first2, __first1))
	{
	__result = __first2;
	++__first2;
	}
	else
	{
	__result = __first1;
	++__first1;
	}
	}
	return _VSTD::copy(__first2, __last2, __result);
	}

	template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	merge(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	merge(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
	{
	typedef typename iterator_traits<_InputIterator1>::value_type __v1;
	typedef typename iterator_traits<_InputIterator2>::value_type __v2;
	return merge(__first1, __last1, __first2, __last2, __result, __less<__v1, __v2>());
	}

	// inplace_merge

	template <class _Compare, class _InputIterator1, class _InputIterator2,
	class _OutputIterator>
	void __half_inplace_merge(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2,
	_OutputIterator __result, _Compare __comp)
	{
	for (; __first1 != __last1; ++__result)
	{
	if (__first2 == __last2)
	{
	_VSTD::move(__first1, __last1, __result);
	return;
	}

	if (__comp(__first2, __first1))
	{
	__result = _VSTD::move(__first2);
	++__first2;
	}
	else
	{
	__result = _VSTD::move(__first1);
	++__first1;
	}
	}
	// __first2 through __last2 are already in the right spot.
	}

	template <class _Compare, class _BidirectionalIterator>
	void
	__buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
	_Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1,
	typename iterator_traits<_BidirectionalIterator>::difference_type __len2,
	typename iterator_traits<_BidirectionalIterator>::value_type* __buff)
	{
	typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
	__destruct_n __d(0);
	unique_ptr<value_type, __destruct_n&> __h2(__buff, __d);
	if (__len1 <= __len2)
	{
	value_type* __p = __buff;
	for (_BidirectionalIterator __i = __first; __i != __middle; __d.__incr((value_type*)0), (void) ++__i, ++__p)
	::new(__p) value_type(_VSTD::move(*__i));
	__half_inplace_merge(__buff, __p, __middle, __last, __first, __comp);
	}
	else
	{
	value_type* __p = __buff;
	for (_BidirectionalIterator __i = __middle; __i != __last; __d.__incr((value_type*)0), (void) ++__i, ++__p)
	::new(__p) value_type(_VSTD::move(*__i));
	typedef reverse_iterator<_BidirectionalIterator> _RBi;
	typedef reverse_iterator<value_type*> _Rv;
	__half_inplace_merge(_Rv(__p), _Rv(__buff),
	_RBi(__middle), _RBi(__first),
	_RBi(__last), __invert<_Compare>(__comp));
	}
	}

	template <class _Compare, class _BidirectionalIterator>
	void
	__inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
	_Compare __comp, typename iterator_traits<_BidirectionalIterator>::difference_type __len1,
	typename iterator_traits<_BidirectionalIterator>::difference_type __len2,
	typename iterator_traits<_BidirectionalIterator>::value_type* __buff, ptrdiff_t __buff_size)
	{
	typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
	while (true)
	{
	// if __middle == __last, we're done
	if (__len2 == 0)
	return;
	if (__len1 <= __buff_size \|\| __len2 <= __buff_size)
	return __buffered_inplace_merge<_Compare>
	(__first, __middle, __last, __comp, __len1, __len2, __buff);
	// shrink [__first, __middle) as much as possible (with no moves), returning if it shrinks to 0
	for (; true; ++__first, (void) --__len1)
	{
	if (__len1 == 0)
	return;
	if (__comp(__middle, __first))
	break;
	}
	// __first < __middle < __last
	// __first > __middle
	// partition [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) such that
	// all elements in:
	// [__first, __m1) <= [__middle, __m2)
	// [__middle, __m2) < [__m1, __middle)
	// [__m1, __middle) <= [__m2, __last)
	// and __m1 or __m2 is in the middle of its range
	_BidirectionalIterator __m1; // "median" of [__first, __middle)
	_BidirectionalIterator __m2; // "median" of [__middle, __last)
	difference_type __len11; // distance(__first, __m1)
	difference_type __len21; // distance(__middle, __m2)
	// binary search smaller range
	if (__len1 < __len2)
	{ // __len >= 1, __len2 >= 2
	__len21 = __len2 / 2;
	__m2 = __middle;
	_VSTD::advance(__m2, __len21);
	__m1 = __upper_bound<_Compare>(__first, __middle, *__m2, __comp);
	__len11 = _VSTD::distance(__first, __m1);
	}
	else
	{
	if (__len1 == 1)
	{ // __len1 >= __len2 && __len2 > 0, therefore __len2 == 1
	// It is known __first > __middle
	swap(__first, __middle);
	return;
	}
	// __len1 >= 2, __len2 >= 1
	__len11 = __len1 / 2;
	__m1 = __first;
	_VSTD::advance(__m1, __len11);
	__m2 = __lower_bound<_Compare>(__middle, __last, *__m1, __comp);
	__len21 = _VSTD::distance(__middle, __m2);
	}
	difference_type __len12 = __len1 - __len11; // distance(__m1, __middle)
	difference_type __len22 = __len2 - __len21; // distance(__m2, __last)
	// [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last)
	// swap middle two partitions
	__middle = _VSTD::rotate(__m1, __middle, __m2);
	// __len12 and __len21 now have swapped meanings
	// merge smaller range with recurisve call and larger with tail recursion elimination
	if (__len11 + __len21 < __len12 + __len22)
	{
	__inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size);
	// __inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size);
	__first = __middle;
	__middle = __m2;
	__len1 = __len12;
	__len2 = __len22;
	}
	else
	{
	__inplace_merge<_Compare>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size);
	// __inplace_merge<_Compare>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size);
	__last = __middle;
	__middle = __m1;
	__len1 = __len11;
	__len2 = __len21;
	}
	}
	}

	template <class _BidirectionalIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
	_Compare __comp)
	{
	typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
	typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
	difference_type __len1 = _VSTD::distance(__first, __middle);
	difference_type __len2 = _VSTD::distance(__middle, __last);
	difference_type __buf_size = _VSTD::min(__len1, __len2);
	pair<value_type*, ptrdiff_t> __buf = _VSTD::get_temporary_buffer<value_type>(__buf_size);
	unique_ptr<value_type, __return_temporary_buffer> __h(__buf.first);

	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __c, __len1, __len2,
	__buf.first, __buf.second);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __comp, __len1, __len2,
	__buf.first, __buf.second);
	#endif // _LIBCPP_DEBUG
	}

	template <class _BidirectionalIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last)
	{
	_VSTD::inplace_merge(__first, __middle, __last,
	__less<typename iterator_traits<_BidirectionalIterator>::value_type>());
	}

	// stable_sort

	template <class _Compare, class _InputIterator1, class _InputIterator2>
	void
	__merge_move_construct(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2,
	typename iterator_traits<_InputIterator1>::value_type* __result, _Compare __comp)
	{
	typedef typename iterator_traits<_InputIterator1>::value_type value_type;
	__destruct_n __d(0);
	unique_ptr<value_type, __destruct_n&> __h(__result, __d);
	for (; true; ++__result)
	{
	if (__first1 == __last1)
	{
	for (; __first2 != __last2; ++__first2, ++__result, __d.__incr((value_type*)0))
	::new (__result) value_type(_VSTD::move(*__first2));
	__h.release();
	return;
	}
	if (__first2 == __last2)
	{
	for (; __first1 != __last1; ++__first1, ++__result, __d.__incr((value_type*)0))
	::new (__result) value_type(_VSTD::move(*__first1));
	__h.release();
	return;
	}
	if (__comp(__first2, __first1))
	{
	::new (__result) value_type(_VSTD::move(*__first2));
	__d.__incr((value_type*)0);
	++__first2;
	}
	else
	{
	::new (__result) value_type(_VSTD::move(*__first1));
	__d.__incr((value_type*)0);
	++__first1;
	}
	}
	}

	template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
	void
	__merge_move_assign(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2,
	_OutputIterator __result, _Compare __comp)
	{
	for (; __first1 != __last1; ++__result)
	{
	if (__first2 == __last2)
	{
	for (; __first1 != __last1; ++__first1, ++__result)
	__result = _VSTD::move(__first1);
	return;
	}
	if (__comp(__first2, __first1))
	{
	__result = _VSTD::move(__first2);
	++__first2;
	}
	else
	{
	__result = _VSTD::move(__first1);
	++__first1;
	}
	}
	for (; __first2 != __last2; ++__first2, ++__result)
	__result = _VSTD::move(__first2);
	}

	template <class _Compare, class _RandomAccessIterator>
	void
	__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
	typename iterator_traits<_RandomAccessIterator>::difference_type __len,
	typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size);

	template <class _Compare, class _RandomAccessIterator>
	void
	__stable_sort_move(_RandomAccessIterator __first1, _RandomAccessIterator __last1, _Compare __comp,
	typename iterator_traits<_RandomAccessIterator>::difference_type __len,
	typename iterator_traits<_RandomAccessIterator>::value_type* __first2)
	{
	typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
	switch (__len)
	{
	case 0:
	return;
	case 1:
	::new(__first2) value_type(_VSTD::move(*__first1));
	return;
	case 2:
	- __destruct_n __d(0);
	+ __destruct_n __d(0);
	unique_ptr<value_type, __destruct_n&> __h2(__first2, __d);
	- if (__comp(--__last1, __first1))
	+ if (__comp(--__last1, __first1))
	{
	::new(__first2) value_type(_VSTD::move(*__last1));
	__d.__incr((value_type*)0);
	++__first2;
	::new(__first2) value_type(_VSTD::move(*__first1));
	}
	else
	{
	::new(__first2) value_type(_VSTD::move(*__first1));
	__d.__incr((value_type*)0);
	++__first2;
	::new(__first2) value_type(_VSTD::move(*__last1));
	}
	__h2.release();
	return;
	}
	if (__len <= 8)
	{
	__insertion_sort_move<_Compare>(__first1, __last1, __first2, __comp);
	return;
	}
	typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2;
	_RandomAccessIterator __m = __first1 + __l2;
	__stable_sort<_Compare>(__first1, __m, __comp, __l2, __first2, __l2);
	__stable_sort<_Compare>(__m, __last1, __comp, __len - __l2, __first2 + __l2, __len - __l2);
	__merge_move_construct<_Compare>(__first1, __m, __m, __last1, __first2, __comp);
	}

	template <class _Tp>
	struct __stable_sort_switch
	{
	static const unsigned value = 128*is_trivially_copy_assignable<_Tp>::value;
	};

	template <class _Compare, class _RandomAccessIterator>
	void
	__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
	typename iterator_traits<_RandomAccessIterator>::difference_type __len,
	typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size)
	{
	typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
	typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
	switch (__len)
	{
	case 0:
	case 1:
	return;
	case 2:
	if (__comp(--__last, __first))
	swap(__first, __last);
	return;
	}
	if (__len <= static_cast<difference_type>(__stable_sort_switch<value_type>::value))
	{
	__insertion_sort<_Compare>(__first, __last, __comp);
	return;
	}
	typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2;
	_RandomAccessIterator __m = __first + __l2;
	if (__len <= __buff_size)
	{
	__destruct_n __d(0);
	unique_ptr<value_type, __destruct_n&> __h2(__buff, __d);
	__stable_sort_move<_Compare>(__first, __m, __comp, __l2, __buff);
	__d.__set(__l2, (value_type*)0);
	__stable_sort_move<_Compare>(__m, __last, __comp, __len - __l2, __buff + __l2);
	__d.__set(__len, (value_type*)0);
	__merge_move_assign<_Compare>(__buff, __buff + __l2, __buff + __l2, __buff + __len, __first, __comp);
	// __merge<_Compare>(move_iterator<value_type*>(__buff),
	// move_iterator<value_type*>(__buff + __l2),
	// move_iterator<_RandomAccessIterator>(__buff + __l2),
	// move_iterator<_RandomAccessIterator>(__buff + __len),
	// __first, __comp);
	return;
	}
	__stable_sort<_Compare>(__first, __m, __comp, __l2, __buff, __buff_size);
	__stable_sort<_Compare>(__m, __last, __comp, __len - __l2, __buff, __buff_size);
	__inplace_merge<_Compare>(__first, __m, __last, __comp, __l2, __len - __l2, __buff, __buff_size);
	}

	template <class _RandomAccessIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
	{
	typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
	typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
	difference_type __len = __last - __first;
	pair<value_type*, ptrdiff_t> __buf(0, 0);
	unique_ptr<value_type, __return_temporary_buffer> __h;
	if (__len > static_cast<difference_type>(__stable_sort_switch<value_type>::value))
	{
	__buf = _VSTD::get_temporary_buffer<value_type>(__len);
	__h.reset(__buf.first);
	}
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	__stable_sort<_Comp_ref>(__first, __last, __c, __len, __buf.first, __buf.second);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	__stable_sort<_Comp_ref>(__first, __last, __comp, __len, __buf.first, __buf.second);
	#endif // _LIBCPP_DEBUG
	}

	template <class _RandomAccessIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
	{
	_VSTD::stable_sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
	}

	// is_heap_until

	template <class _RandomAccessIterator, class _Compare>
	-_RandomAccessIterator
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator
	is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
	{
	typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::difference_type difference_type;
	difference_type __len = __last - __first;
	difference_type __p = 0;
	difference_type __c = 1;
	_RandomAccessIterator __pp = __first;
	while (__c < __len)
	{
	_RandomAccessIterator __cp = __first + __c;
	if (__comp(__pp, __cp))
	return __cp;
	++__c;
	++__cp;
	if (__c == __len)
	return __last;
	if (__comp(__pp, __cp))
	return __cp;
	++__p;
	++__pp;
	__c = 2 * __p + 1;
	}
	return __last;
	}

	template<class _RandomAccessIterator>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_RandomAccessIterator
	is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
	{
	return _VSTD::is_heap_until(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
	}

	// is_heap

	template <class _RandomAccessIterator, class _Compare>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
	{
	return _VSTD::is_heap_until(__first, __last, __comp) == __last;
	}

	template<class _RandomAccessIterator>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
	{
	return _VSTD::is_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
	}

	// push_heap

	template <class _Compare, class _RandomAccessIterator>
	void
	__sift_up(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
	typename iterator_traits<_RandomAccessIterator>::difference_type __len)
	{
	typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
	if (__len > 1)
	{
	__len = (__len - 2) / 2;
	_RandomAccessIterator __ptr = __first + __len;
	if (__comp(__ptr, --__last))
	{
	value_type __t(_VSTD::move(*__last));
	do
	{
	__last = _VSTD::move(__ptr);
	__last = __ptr;
	if (__len == 0)
	break;
	__len = (__len - 1) / 2;
	__ptr = __first + __len;
	} while (__comp(*__ptr, __t));
	*__last = _VSTD::move(__t);
	}
	}
	}

	template <class _RandomAccessIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	__sift_up<_Comp_ref>(__first, __last, __c, __last - __first);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	__sift_up<_Comp_ref>(__first, __last, __comp, __last - __first);
	#endif // _LIBCPP_DEBUG
	}

	template <class _RandomAccessIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
	{
	_VSTD::push_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
	}

	// pop_heap

	template <class _Compare, class _RandomAccessIterator>
	void
	__sift_down(_RandomAccessIterator __first, _RandomAccessIterator /__last/,
	_Compare __comp,
	typename iterator_traits<_RandomAccessIterator>::difference_type __len,
	_RandomAccessIterator __start)
	{
	typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
	typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
	// left-child of __start is at 2 * __start + 1
	// right-child of __start is at 2 * __start + 2
	difference_type __child = __start - __first;

	if (__len < 2 \|\| (__len - 2) / 2 < __child)
	return;

	__child = 2 * __child + 1;
	_RandomAccessIterator __child_i = __first + __child;

	if ((__child + 1) < __len && __comp(__child_i, (__child_i + 1))) {
	// right-child exists and is greater than left-child
	++__child_i;
	++__child;
	}

	// check if we are in heap-order
	if (__comp(__child_i, __start))
	// we are, __start is larger than it's largest child
	return;

	value_type __top(_VSTD::move(*__start));
	do
	{
	// we are not in heap-order, swap the parent with it's largest child
	__start = _VSTD::move(__child_i);
	__start = __child_i;

	if ((__len - 2) / 2 < __child)
	break;

	// recompute the child based off of the updated parent
	__child = 2 * __child + 1;
	__child_i = __first + __child;

	if ((__child + 1) < __len && __comp(__child_i, (__child_i + 1))) {
	// right-child exists and is greater than left-child
	++__child_i;
	++__child;
	}

	// check if we are in heap-order
	} while (!__comp(*__child_i, __top));
	*__start = _VSTD::move(__top);
	}

	template <class _Compare, class _RandomAccessIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
	typename iterator_traits<_RandomAccessIterator>::difference_type __len)
	{
	if (__len > 1)
	{
	swap(__first, --__last);
	__sift_down<_Compare>(__first, __last, __comp, __len - 1, __first);
	}
	}

	template <class _RandomAccessIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	__pop_heap<_Comp_ref>(__first, __last, __c, __last - __first);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	__pop_heap<_Comp_ref>(__first, __last, __comp, __last - __first);
	#endif // _LIBCPP_DEBUG
	}

	template <class _RandomAccessIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
	{
	_VSTD::pop_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
	}

	// make_heap

	template <class _Compare, class _RandomAccessIterator>
	void
	__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
	{
	typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
	difference_type __n = __last - __first;
	if (__n > 1)
	{
	// start from the first parent, there is no need to consider children
	for (difference_type __start = (__n - 2) / 2; __start >= 0; --__start)
	{
	__sift_down<_Compare>(__first, __last, __comp, __n, __first + __start);
	}
	}
	}

	template <class _RandomAccessIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	__make_heap<_Comp_ref>(__first, __last, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	__make_heap<_Comp_ref>(__first, __last, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _RandomAccessIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
	{
	_VSTD::make_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
	}

	// sort_heap

	template <class _Compare, class _RandomAccessIterator>
	void
	__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
	{
	typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
	for (difference_type __n = __last - __first; __n > 1; --__last, --__n)
	__pop_heap<_Compare>(__first, __last, __comp, __n);
	}

	template <class _RandomAccessIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	__sort_heap<_Comp_ref>(__first, __last, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	__sort_heap<_Comp_ref>(__first, __last, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _RandomAccessIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
	{
	_VSTD::sort_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
	}

	// partial_sort

	template <class _Compare, class _RandomAccessIterator>
	void
	__partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
	_Compare __comp)
	{
	__make_heap<_Compare>(__first, __middle, __comp);
	typename iterator_traits<_RandomAccessIterator>::difference_type __len = __middle - __first;
	for (_RandomAccessIterator __i = __middle; __i != __last; ++__i)
	{
	if (__comp(__i, __first))
	{
	swap(__i, __first);
	__sift_down<_Compare>(__first, __middle, __comp, __len, __first);
	}
	}
	__sort_heap<_Compare>(__first, __middle, __comp);
	}

	template <class _RandomAccessIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
	_Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	__partial_sort<_Comp_ref>(__first, __middle, __last, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	__partial_sort<_Comp_ref>(__first, __middle, __last, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _RandomAccessIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)
	{
	_VSTD::partial_sort(__first, __middle, __last,
	__less<typename iterator_traits<_RandomAccessIterator>::value_type>());
	}

	// partial_sort_copy

	template <class _Compare, class _InputIterator, class _RandomAccessIterator>
	_RandomAccessIterator
	__partial_sort_copy(_InputIterator __first, _InputIterator __last,
	_RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)
	{
	_RandomAccessIterator __r = __result_first;
	if (__r != __result_last)
	{
	for (; __first != __last && __r != __result_last; (void) ++__first, ++__r)
	__r = __first;
	__make_heap<_Compare>(__result_first, __r, __comp);
	typename iterator_traits<_RandomAccessIterator>::difference_type __len = __r - __result_first;
	for (; __first != __last; ++__first)
	if (__comp(__first, __result_first))
	{
	__result_first = __first;
	__sift_down<_Compare>(__result_first, __r, __comp, __len, __result_first);
	}
	__sort_heap<_Compare>(__result_first, __r, __comp);
	}
	return __r;
	}

	template <class _InputIterator, class _RandomAccessIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	_RandomAccessIterator
	partial_sort_copy(_InputIterator __first, _InputIterator __last,
	_RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	return __partial_sort_copy<_Comp_ref>(__first, __last, __result_first, __result_last, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _InputIterator, class _RandomAccessIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_RandomAccessIterator
	partial_sort_copy(_InputIterator __first, _InputIterator __last,
	_RandomAccessIterator __result_first, _RandomAccessIterator __result_last)
	{
	return _VSTD::partial_sort_copy(__first, __last, __result_first, __result_last,
	__less<typename iterator_traits<_RandomAccessIterator>::value_type>());
	}

	// nth_element

	template <class _Compare, class _RandomAccessIterator>
	void
	__nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)
	{
	// _Compare is known to be a reference type
	typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
	const difference_type __limit = 7;
	while (true)
	{
	__restart:
	if (__nth == __last)
	return;
	difference_type __len = __last - __first;
	switch (__len)
	{
	case 0:
	case 1:
	return;
	case 2:
	if (__comp(--__last, __first))
	swap(__first, __last);
	return;
	case 3:
	{
	_RandomAccessIterator __m = __first;
	_VSTD::__sort3<_Compare>(__first, ++__m, --__last, __comp);
	return;
	}
	}
	if (__len <= __limit)
	{
	__selection_sort<_Compare>(__first, __last, __comp);
	return;
	}
	// __len > __limit >= 3
	_RandomAccessIterator __m = __first + __len/2;
	_RandomAccessIterator __lm1 = __last;
	unsigned __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, --__lm1, __comp);
	// *__m is median
	// partition [__first, __m) < __m and __m <= [__m, __last)
	// (this inhibits tossing elements equivalent to __m around unnecessarily)
	_RandomAccessIterator __i = __first;
	_RandomAccessIterator __j = __lm1;
	// j points beyond range to be tested, __lm1 is known to be <= __m
	// The search going up is known to be guarded but the search coming down isn't.
	// Prime the downward search with a guard.
	if (!__comp(__i, __m)) // if __first == __m
	{
	// __first == __m, *__first doesn't go in first part
	// manually guard downward moving __j against __i
	while (true)
	{
	if (__i == --__j)
	{
	// __first == __m, *__m <= all other elements
	// Parition instead into [__first, __i) == __first and __first < [__i, __last)
	++__i; // __first + 1
	__j = __last;
	if (!__comp(__first, --__j)) // we need a guard if __first == (__last-1)
	{
	while (true)
	{
	if (__i == __j)
	return; // [__first, __last) all equivalent elements
	if (__comp(__first, __i))
	{
	swap(__i, __j);
	++__n_swaps;
	++__i;
	break;
	}
	++__i;
	}
	}
	// [__first, __i) == __first and __first < [__j, __last) and __j == __last - 1
	if (__i == __j)
	return;
	while (true)
	{
	while (!__comp(__first, __i))
	++__i;
	while (__comp(__first, --__j))
	;
	if (__i >= __j)
	break;
	swap(__i, __j);
	++__n_swaps;
	++__i;
	}
	// [__first, __i) == __first and __first < [__i, __last)
	// The first part is sorted,
	if (__nth < __i)
	return;
	// __nth_element the secod part
	// __nth_element<_Compare>(__i, __nth, __last, __comp);
	__first = __i;
	goto __restart;
	}
	if (__comp(__j, __m))
	{
	swap(__i, __j);
	++__n_swaps;
	break; // found guard for downward moving __j, now use unguarded partition
	}
	}
	}
	++__i;
	// j points beyond range to be tested, __lm1 is known to be <= __m
	// if not yet partitioned...
	if (__i < __j)
	{
	// known that (__i - 1) < __m
	while (true)
	{
	// __m still guards upward moving __i
	while (__comp(__i, __m))
	++__i;
	// It is now known that a guard exists for downward moving __j
	while (!__comp(--__j, __m))
	;
	if (__i >= __j)
	break;
	swap(__i, __j);
	++__n_swaps;
	// It is known that __m != __j
	// If __m just moved, follow it
	if (__m == __i)
	__m = __j;
	++__i;
	}
	}
	// [__first, __i) < __m and __m <= [__i, __last)
	if (__i != __m && __comp(__m, __i))
	{
	swap(__i, __m);
	++__n_swaps;
	}
	// [__first, __i) < __i and __i <= [__i+1, __last)
	if (__nth == __i)
	return;
	if (__n_swaps == 0)
	{
	// We were given a perfectly partitioned sequence. Coincidence?
	if (__nth < __i)
	{
	// Check for [__first, __i) already sorted
	__j = __m = __first;
	while (++__j != __i)
	{
	if (__comp(__j, __m))
	// not yet sorted, so sort
	goto not_sorted;
	__m = __j;
	}
	// [__first, __i) sorted
	return;
	}
	else
	{
	// Check for [__i, __last) already sorted
	__j = __m = __i;
	while (++__j != __last)
	{
	if (__comp(__j, __m))
	// not yet sorted, so sort
	goto not_sorted;
	__m = __j;
	}
	// [__i, __last) sorted
	return;
	}
	}
	not_sorted:
	// __nth_element on range containing __nth
	if (__nth < __i)
	{
	// __nth_element<_Compare>(__first, __nth, __i, __comp);
	__last = __i;
	}
	else
	{
	// __nth_element<_Compare>(__i+1, __nth, __last, __comp);
	__first = ++__i;
	}
	}
	}

	template <class _RandomAccessIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	__nth_element<_Comp_ref>(__first, __nth, __last, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	__nth_element<_Comp_ref>(__first, __nth, __last, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _RandomAccessIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last)
	{
	_VSTD::nth_element(__first, __nth, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
	}

	// includes

	template <class _Compare, class _InputIterator1, class _InputIterator2>
	-bool
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
	__includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
	_Compare __comp)
	{
	for (; __first2 != __last2; ++__first1)
	{
	if (__first1 == __last1 \|\| __comp(__first2, __first1))
	return false;
	if (!__comp(__first1, __first2))
	++__first2;
	}
	return true;
	}

	template <class _InputIterator1, class _InputIterator2, class _Compare>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
	_Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	return __includes<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _InputIterator1, class _InputIterator2>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2)
	{
	return _VSTD::includes(__first1, __last1, __first2, __last2,
	__less<typename iterator_traits<_InputIterator1>::value_type,
	typename iterator_traits<_InputIterator2>::value_type>());
	}

	// set_union

	template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
	_OutputIterator
	__set_union(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
	{
	for (; __first1 != __last1; ++__result)
	{
	if (__first2 == __last2)
	return _VSTD::copy(__first1, __last1, __result);
	if (__comp(__first2, __first1))
	{
	__result = __first2;
	++__first2;
	}
	else
	{
	if (!__comp(__first1, __first2))
	++__first2;
	__result = __first1;
	++__first1;
	}
	}
	return _VSTD::copy(__first2, __last2, __result);
	}

	template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	set_union(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	return __set_union<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	set_union(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
	{
	return _VSTD::set_union(__first1, __last1, __first2, __last2, __result,
	__less<typename iterator_traits<_InputIterator1>::value_type,
	typename iterator_traits<_InputIterator2>::value_type>());
	}

	// set_intersection

	template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
	-_OutputIterator
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator
	__set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
	{
	while (__first1 != __last1 && __first2 != __last2)
	{
	if (__comp(__first1, __first2))
	++__first1;
	else
	{
	if (!__comp(__first2, __first1))
	{
	__result = __first1;
	++__result;
	++__first1;
	}
	++__first2;
	}
	}
	return __result;
	}

	template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_OutputIterator
	set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	return __set_intersection<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_OutputIterator
	set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
	{
	return _VSTD::set_intersection(__first1, __last1, __first2, __last2, __result,
	__less<typename iterator_traits<_InputIterator1>::value_type,
	typename iterator_traits<_InputIterator2>::value_type>());
	}

	// set_difference

	template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
	_OutputIterator
	__set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
	{
	while (__first1 != __last1)
	{
	if (__first2 == __last2)
	return _VSTD::copy(__first1, __last1, __result);
	if (__comp(__first1, __first2))
	{
	__result = __first1;
	++__result;
	++__first1;
	}
	else
	{
	if (!__comp(__first2, __first1))
	++__first1;
	++__first2;
	}
	}
	return __result;
	}

	template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	return __set_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
	{
	return _VSTD::set_difference(__first1, __last1, __first2, __last2, __result,
	__less<typename iterator_traits<_InputIterator1>::value_type,
	typename iterator_traits<_InputIterator2>::value_type>());
	}

	// set_symmetric_difference

	template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
	_OutputIterator
	__set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
	{
	while (__first1 != __last1)
	{
	if (__first2 == __last2)
	return _VSTD::copy(__first1, __last1, __result);
	if (__comp(__first1, __first2))
	{
	__result = __first1;
	++__result;
	++__first1;
	}
	else
	{
	if (__comp(__first2, __first1))
	{
	__result = __first2;
	++__result;
	}
	else
	++__first1;
	++__first2;
	}
	}
	return _VSTD::copy(__first2, __last2, __result);
	}

	template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	return __set_symmetric_difference<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
	{
	return _VSTD::set_symmetric_difference(__first1, __last1, __first2, __last2, __result,
	__less<typename iterator_traits<_InputIterator1>::value_type,
	typename iterator_traits<_InputIterator2>::value_type>());
	}

	// lexicographical_compare

	template <class _Compare, class _InputIterator1, class _InputIterator2>
	-bool
	+_LIBCPP_CONSTEXPR_AFTER_CXX17 bool
	__lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
	{
	for (; __first2 != __last2; ++__first1, (void) ++__first2)
	{
	if (__first1 == __last1 \|\| __comp(__first1, __first2))
	return true;
	if (__comp(__first2, __first1))
	return false;
	}
	return false;
	}

	template <class _InputIterator1, class _InputIterator2, class _Compare>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	return __lexicographical_compare<_Comp_ref>(__first1, __last1, __first2, __last2, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _InputIterator1, class _InputIterator2>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	bool
	lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _InputIterator2 __last2)
	{
	return _VSTD::lexicographical_compare(__first1, __last1, __first2, __last2,
	__less<typename iterator_traits<_InputIterator1>::value_type,
	typename iterator_traits<_InputIterator2>::value_type>());
	}

	// next_permutation

	template <class _Compare, class _BidirectionalIterator>
	bool
	__next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
	{
	_BidirectionalIterator __i = __last;
	if (__first == __last \|\| __first == --__i)
	return false;
	while (true)
	{
	_BidirectionalIterator __ip1 = __i;
	if (__comp(--__i, __ip1))
	{
	_BidirectionalIterator __j = __last;
	while (!__comp(__i, --__j))
	;
	swap(__i, __j);
	_VSTD::reverse(__ip1, __last);
	return true;
	}
	if (__i == __first)
	{
	_VSTD::reverse(__first, __last);
	return false;
	}
	}
	}

	template <class _BidirectionalIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	return __next_permutation<_Comp_ref>(__first, __last, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	return __next_permutation<_Comp_ref>(__first, __last, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _BidirectionalIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
	{
	return _VSTD::next_permutation(__first, __last,
	__less<typename iterator_traits<_BidirectionalIterator>::value_type>());
	}

	// prev_permutation

	template <class _Compare, class _BidirectionalIterator>
	bool
	__prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
	{
	_BidirectionalIterator __i = __last;
	if (__first == __last \|\| __first == --__i)
	return false;
	while (true)
	{
	_BidirectionalIterator __ip1 = __i;
	if (__comp(__ip1, --__i))
	{
	_BidirectionalIterator __j = __last;
	while (!__comp(--__j, __i))
	;
	swap(__i, __j);
	_VSTD::reverse(__ip1, __last);
	return true;
	}
	if (__i == __first)
	{
	_VSTD::reverse(__first, __last);
	return false;
	}
	}
	}

	template <class _BidirectionalIterator, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
	{
	#ifdef _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
	__debug_less<_Compare> __c(__comp);
	return __prev_permutation<_Comp_ref>(__first, __last, __c);
	#else // _LIBCPP_DEBUG
	typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
	return __prev_permutation<_Comp_ref>(__first, __last, __comp);
	#endif // _LIBCPP_DEBUG
	}

	template <class _BidirectionalIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
	{
	return _VSTD::prev_permutation(__first, __last,
	__less<typename iterator_traits<_BidirectionalIterator>::value_type>());
	}

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_ALGORITHM
	Index: projects/clang700-import/contrib/libc++/include/any
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/any (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/any (revision 337135)
	@@ -1,667 +1,667 @@
	// -- C++ --
	//===------------------------------ any -----------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP_ANY
	#define _LIBCPP_ANY

	/*
	any synopsis

	namespace std {

	class bad_any_cast : public bad_cast
	{
	public:
	virtual const char* what() const noexcept;
	};

	class any
	{
	public:

	// 6.3.1 any construct/destruct
	any() noexcept;

	any(const any& other);
	any(any&& other) noexcept;

	template <class ValueType>
	any(ValueType&& value);

	~any();

	// 6.3.2 any assignments
	any& operator=(const any& rhs);
	any& operator=(any&& rhs) noexcept;

	template <class ValueType>
	any& operator=(ValueType&& rhs);

	// 6.3.3 any modifiers
	template <class ValueType, class... Args>
	decay_t<ValueType>& emplace(Args&&... args);
	template <class ValueType, class U, class... Args>
	decay_t<ValueType>& emplace(initializer_list<U>, Args&&...);
	void reset() noexcept;
	void swap(any& rhs) noexcept;

	// 6.3.4 any observers
	bool has_value() const noexcept;
	const type_info& type() const noexcept;
	};

	// 6.4 Non-member functions
	void swap(any& x, any& y) noexcept;

	template <class T, class ...Args>
	any make_any(Args&& ...args);
	template <class T, class U, class ...Args>
	any make_any(initializer_list<U>, Args&& ...args);

	template<class ValueType>
	ValueType any_cast(const any& operand);
	template<class ValueType>
	ValueType any_cast(any& operand);
	template<class ValueType>
	ValueType any_cast(any&& operand);

	template<class ValueType>
	const ValueType* any_cast(const any* operand) noexcept;
	template<class ValueType>
	ValueType* any_cast(any* operand) noexcept;

	} // namespace std

	*/

	#include <experimental/__config>
	#include <memory>
	#include <new>
	#include <typeinfo>
	#include <type_traits>
	#include <cstdlib>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	namespace std {
	class _LIBCPP_EXCEPTION_ABI bad_any_cast : public bad_cast
	{
	public:
	virtual const char* what() const _NOEXCEPT;
	};
	} // namespace std

	_LIBCPP_BEGIN_NAMESPACE_STD

	#if _LIBCPP_STD_VER > 14

	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
	void __throw_bad_any_cast()
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw bad_any_cast();
	#else
	_VSTD::abort();
	#endif
	}

	// Forward declarations
	class _LIBCPP_TEMPLATE_VIS any;

	template <class _ValueType>
	_LIBCPP_INLINE_VISIBILITY
	add_pointer_t<add_const_t<_ValueType>>
	any_cast(any const *) _NOEXCEPT;

	template <class _ValueType>
	_LIBCPP_INLINE_VISIBILITY
	add_pointer_t<_ValueType> any_cast(any *) _NOEXCEPT;

	namespace __any_imp
	{
	using _Buffer = aligned_storage_t<3sizeof(void), alignment_of<void*>::value>;

	template <class _Tp>
	using _IsSmallObject = integral_constant<bool
	, sizeof(_Tp) <= sizeof(_Buffer)
	&& alignment_of<_Buffer>::value
	% alignment_of<_Tp>::value == 0
	&& is_nothrow_move_constructible<_Tp>::value
	>;

	enum class _Action {
	_Destroy,
	_Copy,
	_Move,
	_Get,
	_TypeInfo
	};

	template <class _Tp> struct _SmallHandler;
	template <class _Tp> struct _LargeHandler;

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS __unique_typeinfo { static constexpr int __id = 0; };
	template <class _Tp> constexpr int __unique_typeinfo<_Tp>::__id;

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr const void* __get_fallback_typeid() {
	return &__unique_typeinfo<decay_t<_Tp>>::__id;
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool __compare_typeid(type_info const* __id, const void* __fallback_id)
	{
	#if !defined(_LIBCPP_NO_RTTI)
	if (__id && *__id == typeid(_Tp))
	return true;
	#endif
	if (!__id && __fallback_id == __any_imp::__get_fallback_typeid<_Tp>())
	return true;
	return false;
	}

	template <class _Tp>
	using _Handler = conditional_t<
	_IsSmallObject<_Tp>::value, _SmallHandler<_Tp>, _LargeHandler<_Tp>>;

	} // namespace __any_imp

	class _LIBCPP_TEMPLATE_VIS any
	{
	public:
	// construct/destruct
	_LIBCPP_INLINE_VISIBILITY
	constexpr any() _NOEXCEPT : __h(nullptr) {}

	_LIBCPP_INLINE_VISIBILITY
	any(any const & __other) : __h(nullptr)
	{
	if (__other.__h) __other.__call(_Action::_Copy, this);
	}

	_LIBCPP_INLINE_VISIBILITY
	any(any && __other) _NOEXCEPT : __h(nullptr)
	{
	if (__other.__h) __other.__call(_Action::_Move, this);
	}

	template <
	class _ValueType
	, class _Tp = decay_t<_ValueType>
	, class = enable_if_t<
	!is_same<_Tp, any>::value &&
	!__is_inplace_type<_ValueType>::value &&
	is_copy_constructible<_Tp>::value>
	>
	_LIBCPP_INLINE_VISIBILITY
	any(_ValueType && __value);

	template <class _ValueType, class ..._Args,
	class _Tp = decay_t<_ValueType>,
	class = enable_if_t<
	is_constructible<_Tp, _Args...>::value &&
	is_copy_constructible<_Tp>::value
	>
	>
	_LIBCPP_INLINE_VISIBILITY
	explicit any(in_place_type_t<_ValueType>, _Args&&... __args);

	template <class _ValueType, class _Up, class ..._Args,
	class _Tp = decay_t<_ValueType>,
	class = enable_if_t<
	is_constructible<_Tp, initializer_list<_Up>&, _Args...>::value &&
	is_copy_constructible<_Tp>::value>
	>
	_LIBCPP_INLINE_VISIBILITY
	explicit any(in_place_type_t<_ValueType>, initializer_list<_Up>, _Args&&... __args);

	_LIBCPP_INLINE_VISIBILITY
	~any() { this->reset(); }

	// assignments
	_LIBCPP_INLINE_VISIBILITY
	any & operator=(any const & __rhs) {
	any(__rhs).swap(*this);
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	any & operator=(any && __rhs) _NOEXCEPT {
	any(_VSTD::move(__rhs)).swap(*this);
	return *this;
	}

	template <
	class _ValueType
	, class _Tp = decay_t<_ValueType>
	, class = enable_if_t<
	!is_same<_Tp, any>::value
	&& is_copy_constructible<_Tp>::value>
	>
	_LIBCPP_INLINE_VISIBILITY
	any & operator=(_ValueType && __rhs);

	template <class _ValueType, class ..._Args,
	class _Tp = decay_t<_ValueType>,
	class = enable_if_t<
	is_constructible<_Tp, _Args...>::value &&
	is_copy_constructible<_Tp>::value>
	>
	_LIBCPP_INLINE_VISIBILITY
	_Tp& emplace(_Args&&... args);

	template <class _ValueType, class _Up, class ..._Args,
	class _Tp = decay_t<_ValueType>,
	class = enable_if_t<
	is_constructible<_Tp, initializer_list<_Up>&, _Args...>::value &&
	is_copy_constructible<_Tp>::value>
	>
	_LIBCPP_INLINE_VISIBILITY
	_Tp& emplace(initializer_list<_Up>, _Args&&...);

	// 6.3.3 any modifiers
	_LIBCPP_INLINE_VISIBILITY
	void reset() _NOEXCEPT { if (__h) this->__call(_Action::_Destroy); }

	_LIBCPP_INLINE_VISIBILITY
	void swap(any & __rhs) _NOEXCEPT;

	// 6.3.4 any observers
	_LIBCPP_INLINE_VISIBILITY
	bool has_value() const _NOEXCEPT { return __h != nullptr; }

	#if !defined(_LIBCPP_NO_RTTI)
	_LIBCPP_INLINE_VISIBILITY
	const type_info & type() const _NOEXCEPT {
	if (__h) {
	return static_cast<type_info const >(this->__call(_Action::_TypeInfo));
	} else {
	return typeid(void);
	}
	}
	#endif

	private:
	typedef __any_imp::_Action _Action;
	using _HandleFuncPtr = void* ()(_Action, any const , any , const type_info ,
	const void* __fallback_info);

	union _Storage {
	constexpr _Storage() : __ptr(nullptr) {}
	void * __ptr;
	__any_imp::_Buffer __buf;
	};

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void * __call(_Action __a, any * __other = nullptr,
	type_info const * __info = nullptr,
	const void* __fallback_info = nullptr) const
	{
	return __h(__a, this, __other, __info, __fallback_info);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void * __call(_Action __a, any * __other = nullptr,
	type_info const * __info = nullptr,
	const void* __fallback_info = nullptr)
	{
	return __h(__a, this, __other, __info, __fallback_info);
	}

	template <class>
	friend struct __any_imp::_SmallHandler;
	template <class>
	friend struct __any_imp::_LargeHandler;

	template <class _ValueType>
	friend add_pointer_t<add_const_t<_ValueType>>
	any_cast(any const *) _NOEXCEPT;

	template <class _ValueType>
	friend add_pointer_t<_ValueType>
	any_cast(any *) _NOEXCEPT;

	_HandleFuncPtr __h = nullptr;
	_Storage __s;
	};

	namespace __any_imp
	{
	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS _SmallHandler
	{
	_LIBCPP_INLINE_VISIBILITY
	static void* __handle(_Action __act, any const * __this, any * __other,
	type_info const * __info, const void* __fallback_info)
	{
	switch (__act)
	{
	case _Action::_Destroy:
	__destroy(const_cast<any &>(*__this));
	return nullptr;
	case _Action::_Copy:
	__copy(__this, __other);
	return nullptr;
	case _Action::_Move:
	__move(const_cast<any &>(__this), __other);
	return nullptr;
	case _Action::_Get:
	return __get(const_cast<any &>(*__this), __info, __fallback_info);
	case _Action::_TypeInfo:
	return __type_info();
	}
	}

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY
	static _Tp& __create(any & __dest, _Args&&... __args) {
	_Tp* __ret = ::new (static_cast<void*>(&__dest.__s.__buf)) _Tp(_VSTD::forward<_Args>(__args)...);
	__dest.__h = &_SmallHandler::__handle;
	return *__ret;
	}

	private:
	_LIBCPP_INLINE_VISIBILITY
	static void __destroy(any & __this) {
	_Tp & __value = static_cast<_Tp >(static_cast<void*>(&__this.__s.__buf));
	__value.~_Tp();
	__this.__h = nullptr;
	}

	_LIBCPP_INLINE_VISIBILITY
	static void __copy(any const & __this, any & __dest) {
	_SmallHandler::__create(__dest, static_cast<_Tp const >(
	static_cast<void const *>(&__this.__s.__buf)));
	}

	_LIBCPP_INLINE_VISIBILITY
	static void __move(any & __this, any & __dest) {
	_SmallHandler::__create(__dest, _VSTD::move(
	static_cast<_Tp>(static_cast<void*>(&__this.__s.__buf))));
	__destroy(__this);
	}

	_LIBCPP_INLINE_VISIBILITY
	static void* __get(any & __this,
	type_info const * __info,
	const void* __fallback_id)
	{
	if (__any_imp::__compare_typeid<_Tp>(__info, __fallback_id))
	return static_cast<void*>(&__this.__s.__buf);
	return nullptr;
	}

	_LIBCPP_INLINE_VISIBILITY
	static void* __type_info()
	{
	#if !defined(_LIBCPP_NO_RTTI)
	return const_cast<void>(static_cast<void const >(&typeid(_Tp)));
	#else
	return nullptr;
	#endif
	}
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS _LargeHandler
	{
	_LIBCPP_INLINE_VISIBILITY
	static void* __handle(_Action __act, any const * __this,
	any * __other, type_info const * __info,
	void const* __fallback_info)
	{
	switch (__act)
	{
	case _Action::_Destroy:
	__destroy(const_cast<any &>(*__this));
	return nullptr;
	case _Action::_Copy:
	__copy(__this, __other);
	return nullptr;
	case _Action::_Move:
	__move(const_cast<any &>(__this), __other);
	return nullptr;
	case _Action::_Get:
	return __get(const_cast<any &>(*__this), __info, __fallback_info);
	case _Action::_TypeInfo:
	return __type_info();
	}
	}

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY
	static _Tp& __create(any & __dest, _Args&&... __args) {
	typedef allocator<_Tp> _Alloc;
	typedef __allocator_destructor<_Alloc> _Dp;
	_Alloc __a;
	unique_ptr<_Tp, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	_Tp* __ret = ::new ((void*)__hold.get()) _Tp(_VSTD::forward<_Args>(__args)...);
	__dest.__s.__ptr = __hold.release();
	__dest.__h = &_LargeHandler::__handle;
	return *__ret;
	}

	private:

	_LIBCPP_INLINE_VISIBILITY
	static void __destroy(any & __this){
	delete static_cast<_Tp*>(__this.__s.__ptr);
	__this.__h = nullptr;
	}

	_LIBCPP_INLINE_VISIBILITY
	static void __copy(any const & __this, any & __dest) {
	_LargeHandler::__create(__dest, static_cast<_Tp const >(__this.__s.__ptr));
	}

	_LIBCPP_INLINE_VISIBILITY
	static void __move(any & __this, any & __dest) {
	__dest.__s.__ptr = __this.__s.__ptr;
	__dest.__h = &_LargeHandler::__handle;
	__this.__h = nullptr;
	}

	_LIBCPP_INLINE_VISIBILITY
	static void* __get(any & __this, type_info const * __info,
	void const* __fallback_info)
	{
	if (__any_imp::__compare_typeid<_Tp>(__info, __fallback_info))
	return static_cast<void*>(__this.__s.__ptr);
	return nullptr;

	}

	_LIBCPP_INLINE_VISIBILITY
	static void* __type_info()
	{
	#if !defined(_LIBCPP_NO_RTTI)
	return const_cast<void>(static_cast<void const >(&typeid(_Tp)));
	#else
	return nullptr;
	#endif
	}
	};

	} // namespace __any_imp


	template <class _ValueType, class _Tp, class>
	any::any(_ValueType && __v) : __h(nullptr)
	{
	__any_imp::_Handler<_Tp>::__create(*this, _VSTD::forward<_ValueType>(__v));
	}

	template <class _ValueType, class ..._Args, class _Tp, class>
	any::any(in_place_type_t<_ValueType>, _Args&&... __args) {
	__any_imp::_Handler<_Tp>::__create(*this, _VSTD::forward<_Args>(__args)...);
	};

	template <class _ValueType, class _Up, class ..._Args, class _Tp, class>
	any::any(in_place_type_t<_ValueType>, initializer_list<_Up> __il, _Args&&... __args) {
	__any_imp::_Handler<_Tp>::__create(*this, __il, _VSTD::forward<_Args>(__args)...);
	}

	template <class _ValueType, class, class>
	inline _LIBCPP_INLINE_VISIBILITY
	any & any::operator=(_ValueType && __v)
	{
	any(_VSTD::forward<_ValueType>(__v)).swap(*this);
	return *this;
	}

	template <class _ValueType, class ..._Args, class _Tp, class>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp& any::emplace(_Args&&... __args) {
	reset();
	return __any_imp::_Handler<_Tp>::__create(*this, _VSTD::forward<_Args>(__args)...);
	}

	template <class _ValueType, class _Up, class ..._Args, class _Tp, class>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp& any::emplace(initializer_list<_Up> __il, _Args&&... __args) {
	reset();
	return __any_imp::_Handler<_Tp>::__create(*this, __il, _VSTD::forward<_Args>(__args)...);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	void any::swap(any & __rhs) _NOEXCEPT
	{
	if (this == &__rhs)
	return;
	if (__h && __rhs.__h) {
	any __tmp;
	__rhs.__call(_Action::_Move, &__tmp);
	this->__call(_Action::_Move, &__rhs);
	__tmp.__call(_Action::_Move, this);
	}
	else if (__h) {
	this->__call(_Action::_Move, &__rhs);
	}
	else if (__rhs.__h) {
	__rhs.__call(_Action::_Move, this);
	}
	}

	// 6.4 Non-member functions

	inline _LIBCPP_INLINE_VISIBILITY
	void swap(any & __lhs, any & __rhs) _NOEXCEPT
	{
	__lhs.swap(__rhs);
	}

	template <class _Tp, class ..._Args>
	inline _LIBCPP_INLINE_VISIBILITY
	any make_any(_Args&&... __args) {
	return any(in_place_type<_Tp>, _VSTD::forward<_Args>(__args)...);
	}

	template <class _Tp, class _Up, class ..._Args>
	inline _LIBCPP_INLINE_VISIBILITY
	any make_any(initializer_list<_Up> __il, _Args&&... __args) {
	return any(in_place_type<_Tp>, __il, _VSTD::forward<_Args>(__args)...);
	}

	template <class _ValueType>
	inline _LIBCPP_INLINE_VISIBILITY
	_ValueType any_cast(any const & __v)
	{
	using _RawValueType = __uncvref_t<_ValueType>;
	static_assert(is_constructible<_ValueType, _RawValueType const &>::value,
	"ValueType is required to be a const lvalue reference "
	"or a CopyConstructible type");
	auto __tmp = _VSTD::any_cast<add_const_t<_RawValueType>>(&__v);
	if (__tmp == nullptr)
	__throw_bad_any_cast();
	return static_cast<_ValueType>(*__tmp);
	}

	template <class _ValueType>
	inline _LIBCPP_INLINE_VISIBILITY
	_ValueType any_cast(any & __v)
	{
	using _RawValueType = __uncvref_t<_ValueType>;
	static_assert(is_constructible<_ValueType, _RawValueType &>::value,
	"ValueType is required to be an lvalue reference "
	"or a CopyConstructible type");
	auto __tmp = _VSTD::any_cast<_RawValueType>(&__v);
	if (__tmp == nullptr)
	__throw_bad_any_cast();
	return static_cast<_ValueType>(*__tmp);
	}

	template <class _ValueType>
	inline _LIBCPP_INLINE_VISIBILITY
	_ValueType any_cast(any && __v)
	{
	using _RawValueType = __uncvref_t<_ValueType>;
	static_assert(is_constructible<_ValueType, _RawValueType>::value,
	"ValueType is required to be an rvalue reference "
	"or a CopyConstructible type");
	auto __tmp = _VSTD::any_cast<_RawValueType>(&__v);
	if (__tmp == nullptr)
	__throw_bad_any_cast();
	return static_cast<_ValueType>(_VSTD::move(*__tmp));
	}

	template <class _ValueType>
	inline _LIBCPP_INLINE_VISIBILITY
	add_pointer_t<add_const_t<_ValueType>>
	any_cast(any const * __any) _NOEXCEPT
	{
	static_assert(!is_reference<_ValueType>::value,
	"_ValueType may not be a reference.");
	return _VSTD::any_cast<_ValueType>(const_cast<any *>(__any));
	}

	template <class _RetType>
	inline _LIBCPP_INLINE_VISIBILITY
	_RetType __pointer_or_func_cast(void* __p, /IsFunction/false_type) noexcept {
	return static_cast<_RetType>(__p);
	}

	template <class _RetType>
	inline _LIBCPP_INLINE_VISIBILITY
	_RetType __pointer_or_func_cast(void, /IsFunction*/true_type) noexcept {
	return nullptr;
	}

	template <class _ValueType>
	add_pointer_t<_ValueType>
	any_cast(any * __any) _NOEXCEPT
	{
	using __any_imp::_Action;
	static_assert(!is_reference<_ValueType>::value,
	"_ValueType may not be a reference.");
	typedef typename add_pointer<_ValueType>::type _ReturnType;
	if (__any && __any->__h) {
	void *__p = __any->__call(_Action::_Get, nullptr,
	#if !defined(_LIBCPP_NO_RTTI)
	&typeid(_ValueType),
	#else
	nullptr,
	#endif
	__any_imp::__get_fallback_typeid<_ValueType>());
	return _VSTD::__pointer_or_func_cast<_ReturnType>(
	__p, is_function<_ValueType>{});
	}
	return nullptr;
	}

	#endif // _LIBCPP_STD_VER > 14

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_ANY
	Index: projects/clang700-import/contrib/libc++/include/array
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/array (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/array (revision 337135)
	@@ -1,346 +1,485 @@
	// -- C++ --
	//===---------------------------- array -----------------------------------===//
	//
	// 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_ARRAY
	#define _LIBCPP_ARRAY

	/*
	array synopsis

	namespace std
	{
	template <class T, size_t N >
	struct array
	{
	// types:
	typedef T & reference;
	typedef const T & const_reference;
	typedef implementation defined iterator;
	typedef implementation defined const_iterator;
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;
	typedef T value_type;
	typedef T* pointer;
	typedef const T* const_pointer;
	typedef std::reverse_iterator<iterator> reverse_iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

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

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

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

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

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

	// element access:
	reference operator[](size_type n);
	const_reference operator[](size_type n) const; // constexpr in C++14
	const_reference at(size_type n) const; // constexpr in C++14
	reference at(size_type n);

	reference front();
	const_reference front() const; // constexpr in C++14
	reference back();
	const_reference back() const; // constexpr in C++14

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

	+ template <class T, class... U>
	+ array(T, U...) -> array<T, 1 + sizeof...(U)>;
	+
	template <class T, size_t N>
	bool operator==(const array<T,N>& x, const array<T,N>& y);
	template <class T, size_t N>
	bool operator!=(const array<T,N>& x, const array<T,N>& y);
	template <class T, size_t N>
	bool operator<(const array<T,N>& x, const array<T,N>& y);
	template <class T, size_t N>
	bool operator>(const array<T,N>& x, const array<T,N>& y);
	template <class T, size_t N>
	bool operator<=(const array<T,N>& x, const array<T,N>& y);
	template <class T, size_t N>
	bool operator>=(const array<T,N>& x, const array<T,N>& y);

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

	template <class T> class tuple_size;
	template <size_t I, class T> class tuple_element;
	template <class T, size_t N> struct tuple_size<array<T, N>>;
	template <size_t I, class T, size_t N> struct tuple_element<I, array<T, N>>;
	template <size_t I, class T, size_t N> T& get(array<T, N>&) noexcept; // constexpr in C++14
	template <size_t I, class T, size_t N> const T& get(const array<T, N>&) noexcept; // constexpr in C++14
	template <size_t I, class T, size_t N> T&& get(array<T, N>&&) noexcept; // constexpr in C++14
	template <size_t I, class T, size_t N> const T&& get(const array<T, N>&&) noexcept; // constexpr in C++14

	} // std

	*/

	#include <__config>
	#include <__tuple>
	#include <type_traits>
	#include <utility>
	#include <iterator>
	#include <algorithm>
	#include <stdexcept>
	+#include <cstdlib> // for _LIBCPP_UNREACHABLE
	+#include <__debug>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif



	_LIBCPP_BEGIN_NAMESPACE_STD

	+
	template <class _Tp, size_t _Size>
	struct _LIBCPP_TEMPLATE_VIS array
	{
	// types:
	typedef array __self;
	typedef _Tp value_type;
	typedef value_type& reference;
	typedef const value_type& const_reference;
	typedef value_type* iterator;
	typedef const value_type* const_iterator;
	typedef value_type* pointer;
	typedef const value_type* const_pointer;
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;
	typedef std::reverse_iterator<iterator> reverse_iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

	- value_type __elems_[_Size > 0 ? _Size : 1];
	+ _Tp __elems_[_Size];

	// No explicit construct/copy/destroy for aggregate type
	- _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u)
	- {_VSTD::fill_n(__elems_, _Size, __u);}
	- _LIBCPP_INLINE_VISIBILITY
	- void swap(array& __a) _NOEXCEPT_(_Size == 0 \|\| __is_nothrow_swappable<_Tp>::value)
	- { __swap_dispatch((std::integral_constant<bool, _Size == 0>()), __a); }
	+ _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u) {
	+ _VSTD::fill_n(__elems_, _Size, __u);
	+ }

	_LIBCPP_INLINE_VISIBILITY
	- void __swap_dispatch(std::true_type, array&) {}
	+ void swap(array& __a) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) {
	+ std::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);
	+ }

	- _LIBCPP_INLINE_VISIBILITY
	- void __swap_dispatch(std::false_type, array& __a)
	- { _VSTD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);}
	-
	// iterators:
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	- iterator begin() _NOEXCEPT {return iterator(__elems_);}
	+ iterator begin() _NOEXCEPT {return iterator(data());}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	- const_iterator begin() const _NOEXCEPT {return const_iterator(__elems_);}
	+ const_iterator begin() const _NOEXCEPT {return const_iterator(data());}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	- iterator end() _NOEXCEPT {return iterator(__elems_ + _Size);}
	+ iterator end() _NOEXCEPT {return iterator(data() + _Size);}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	- const_iterator end() const _NOEXCEPT {return const_iterator(__elems_ + _Size);}
	+ const_iterator end() const _NOEXCEPT {return const_iterator(data() + _Size);}

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

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

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

	// element access:
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reference operator[](size_type __n) {return __elems_[__n];}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	const_reference operator[](size_type __n) const {return __elems_[__n];}

	_LIBCPP_CONSTEXPR_AFTER_CXX14 reference at(size_type __n);
	_LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference at(size_type __n) const;

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reference front() {return __elems_[0];}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference front() const {return __elems_[0];}
	- _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reference back() {return __elems_[_Size > 0 ? _Size-1 : 0];}
	- _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference back() const {return __elems_[_Size > 0 ? _Size-1 : 0];}
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 reference back() {return __elems_[_Size - 1];}
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const_reference back() const {return __elems_[_Size - 1];}

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

	+
	template <class _Tp, size_t _Size>
	_LIBCPP_CONSTEXPR_AFTER_CXX14
	typename array<_Tp, _Size>::reference
	array<_Tp, _Size>::at(size_type __n)
	{
	if (__n >= _Size)
	__throw_out_of_range("array::at");

	return __elems_[__n];
	}

	template <class _Tp, size_t _Size>
	_LIBCPP_CONSTEXPR_AFTER_CXX11
	typename array<_Tp, _Size>::const_reference
	array<_Tp, _Size>::at(size_type __n) const
	{
	if (__n >= _Size)
	__throw_out_of_range("array::at");
	return __elems_[__n];
	}

	+template <class _Tp>
	+struct _LIBCPP_TEMPLATE_VIS array<_Tp, 0>
	+{
	+ // types:
	+ typedef array __self;
	+ typedef _Tp value_type;
	+ typedef value_type& reference;
	+ typedef const value_type& const_reference;
	+ typedef value_type* iterator;
	+ typedef const value_type* const_iterator;
	+ typedef value_type* pointer;
	+ typedef const value_type* const_pointer;
	+ typedef size_t size_type;
	+ typedef ptrdiff_t difference_type;
	+ typedef std::reverse_iterator<iterator> reverse_iterator;
	+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
	+
	+ typedef typename conditional<is_const<_Tp>::value, const char,
	+ char>::type _CharType;
	+
	+ struct _ArrayInStructT { _Tp __data_[1]; };
	+ _ALIGNAS_TYPE(_ArrayInStructT) _CharType __elems_[sizeof(_ArrayInStructT)];
	+
	+ // No explicit construct/copy/destroy for aggregate type
	+ _LIBCPP_INLINE_VISIBILITY void fill(const value_type&) {
	+ static_assert(!is_const<_Tp>::value,
	+ "cannot fill zero-sized array of type 'const T'");
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void swap(array&) _NOEXCEPT {
	+ static_assert(!is_const<_Tp>::value,
	+ "cannot swap zero-sized array of type 'const T'");
	+ }
	+
	+ // iterators:
	+ _LIBCPP_INLINE_VISIBILITY
	+ iterator begin() _NOEXCEPT {return iterator(data());}
	+ _LIBCPP_INLINE_VISIBILITY
	+ const_iterator begin() const _NOEXCEPT {return const_iterator(data());}
	+ _LIBCPP_INLINE_VISIBILITY
	+ iterator end() _NOEXCEPT {return iterator(data());}
	+ _LIBCPP_INLINE_VISIBILITY
	+ const_iterator end() const _NOEXCEPT {return const_iterator(data());}
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
	+ _LIBCPP_INLINE_VISIBILITY
	+ const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());}
	+ _LIBCPP_INLINE_VISIBILITY
	+ reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());}
	+ _LIBCPP_INLINE_VISIBILITY
	+ const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());}
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ const_iterator cbegin() const _NOEXCEPT {return begin();}
	+ _LIBCPP_INLINE_VISIBILITY
	+ const_iterator cend() const _NOEXCEPT {return end();}
	+ _LIBCPP_INLINE_VISIBILITY
	+ const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
	+ _LIBCPP_INLINE_VISIBILITY
	+ const_reverse_iterator crend() const _NOEXCEPT {return rend();}
	+
	+ // capacity:
	+ _LIBCPP_INLINE_VISIBILITY
	+ _LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT {return 0; }
	+ _LIBCPP_INLINE_VISIBILITY
	+ _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return 0;}
	+ _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
	+ _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return true;}
	+
	+ // element access:
	+ _LIBCPP_INLINE_VISIBILITY
	+ reference operator[](size_type) {
	+ _LIBCPP_ASSERT(false, "cannot call array<T, 0>::operator[] on a zero-sized array");
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	+ const_reference operator[](size_type) const {
	+ _LIBCPP_ASSERT(false, "cannot call array<T, 0>::operator[] on a zero-sized array");
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ reference at(size_type) {
	+ __throw_out_of_range("array<T, 0>::at");
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ const_reference at(size_type) const {
	+ __throw_out_of_range("array<T, 0>::at");
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ reference front() {
	+ _LIBCPP_ASSERT(false, "cannot call array<T, 0>::front() on a zero-sized array");
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ const_reference front() const {
	+ _LIBCPP_ASSERT(false, "cannot call array<T, 0>::front() on a zero-sized array");
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ reference back() {
	+ _LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array");
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ const_reference back() const {
	+ _LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array");
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ value_type* data() _NOEXCEPT {return reinterpret_cast<value_type*>(__elems_);}
	+ _LIBCPP_INLINE_VISIBILITY
	+ const value_type* data() const _NOEXCEPT {return reinterpret_cast<const value_type*>(__elems_);}
	+};
	+
	+
	+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
	+template<class _Tp, class... _Args,
	+ class = typename enable_if<(is_same_v<_Tp, _Args> && ...), void>::type
	+ >
	+array(_Tp, _Args...)
	+ -> array<_Tp, 1 + sizeof...(_Args)>;
	+#endif
	+
	template <class _Tp, size_t _Size>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
	{
	- return _VSTD::equal(__x.__elems_, __x.__elems_ + _Size, __y.__elems_);
	+ return _VSTD::equal(__x.begin(), __x.end(), __y.begin());
	}

	template <class _Tp, size_t _Size>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
	{
	return !(__x == __y);
	}

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

	template <class _Tp, size_t _Size>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
	{
	return __y < __x;
	}

	template <class _Tp, size_t _Size>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
	{
	return !(__y < __x);
	}

	template <class _Tp, size_t _Size>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
	{
	return !(__x < __y);
	}

	template <class _Tp, size_t _Size>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	_Size == 0 \|\|
	__is_swappable<_Tp>::value,
	void
	>::type
	swap(array<_Tp, _Size>& __x, array<_Tp, _Size>& __y)
	_NOEXCEPT_(noexcept(__x.swap(__y)))
	{
	__x.swap(__y);
	}

	template <class _Tp, size_t _Size>
	class _LIBCPP_TEMPLATE_VIS tuple_size<array<_Tp, _Size> >
	: public integral_constant<size_t, _Size> {};

	template <size_t _Ip, class _Tp, size_t _Size>
	class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, array<_Tp, _Size> >
	{
	static_assert(_Ip < _Size, "Index out of bounds in std::tuple_element<> (std::array)");
	public:
	typedef _Tp type;
	};

	template <size_t _Ip, class _Tp, size_t _Size>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_Tp&
	get(array<_Tp, _Size>& __a) _NOEXCEPT
	{
	static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array)");
	return __a.__elems_[_Ip];
	}

	template <size_t _Ip, class _Tp, size_t _Size>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	const _Tp&
	get(const array<_Tp, _Size>& __a) _NOEXCEPT
	{
	static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array)");
	return __a.__elems_[_Ip];
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <size_t _Ip, class _Tp, size_t _Size>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_Tp&&
	get(array<_Tp, _Size>&& __a) _NOEXCEPT
	{
	static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array &&)");
	return _VSTD::move(__a.__elems_[_Ip]);
	}

	template <size_t _Ip, class _Tp, size_t _Size>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	const _Tp&&
	get(const array<_Tp, _Size>&& __a) _NOEXCEPT
	{
	static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array &&)");
	return _VSTD::move(__a.__elems_[_Ip]);
	}

	#endif // !_LIBCPP_CXX03_LANG

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_ARRAY
	Index: projects/clang700-import/contrib/libc++/include/atomic
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/atomic (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/atomic (revision 337135)
	@@ -1,1888 +1,1891 @@
	// -- C++ --
	//===--------------------------- atomic -----------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP_ATOMIC
	#define _LIBCPP_ATOMIC

	/*
	atomic synopsis

	namespace std
	{

	// feature test macro

	#define __cpp_lib_atomic_is_always_lock_free // as specified by SG10

	// order and consistency

	typedef enum memory_order
	{
	memory_order_relaxed,
	memory_order_consume, // load-consume
	memory_order_acquire, // load-acquire
	memory_order_release, // store-release
	memory_order_acq_rel, // store-release load-acquire
	memory_order_seq_cst // store-release load-acquire
	} memory_order;

	template <class T> T kill_dependency(T y) noexcept;

	// lock-free property

	#define ATOMIC_BOOL_LOCK_FREE unspecified
	#define ATOMIC_CHAR_LOCK_FREE unspecified
	#define ATOMIC_CHAR16_T_LOCK_FREE unspecified
	#define ATOMIC_CHAR32_T_LOCK_FREE unspecified
	#define ATOMIC_WCHAR_T_LOCK_FREE unspecified
	#define ATOMIC_SHORT_LOCK_FREE unspecified
	#define ATOMIC_INT_LOCK_FREE unspecified
	#define ATOMIC_LONG_LOCK_FREE unspecified
	#define ATOMIC_LLONG_LOCK_FREE unspecified
	#define ATOMIC_POINTER_LOCK_FREE unspecified

	// flag type and operations

	typedef struct atomic_flag
	{
	bool test_and_set(memory_order m = memory_order_seq_cst) volatile noexcept;
	bool test_and_set(memory_order m = memory_order_seq_cst) noexcept;
	void clear(memory_order m = memory_order_seq_cst) volatile noexcept;
	void clear(memory_order m = memory_order_seq_cst) noexcept;
	atomic_flag() noexcept = default;
	atomic_flag(const atomic_flag&) = delete;
	atomic_flag& operator=(const atomic_flag&) = delete;
	atomic_flag& operator=(const atomic_flag&) volatile = delete;
	} atomic_flag;

	bool
	atomic_flag_test_and_set(volatile atomic_flag* obj) noexcept;

	bool
	atomic_flag_test_and_set(atomic_flag* obj) noexcept;

	bool
	atomic_flag_test_and_set_explicit(volatile atomic_flag* obj,
	memory_order m) noexcept;

	bool
	atomic_flag_test_and_set_explicit(atomic_flag* obj, memory_order m) noexcept;

	void
	atomic_flag_clear(volatile atomic_flag* obj) noexcept;

	void
	atomic_flag_clear(atomic_flag* obj) noexcept;

	void
	atomic_flag_clear_explicit(volatile atomic_flag* obj, memory_order m) noexcept;

	void
	atomic_flag_clear_explicit(atomic_flag* obj, memory_order m) noexcept;

	#define ATOMIC_FLAG_INIT see below
	#define ATOMIC_VAR_INIT(value) see below

	template <class T>
	struct atomic
	{
	static constexpr bool is_always_lock_free;
	bool is_lock_free() const volatile noexcept;
	bool is_lock_free() const noexcept;
	void store(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
	void store(T desr, memory_order m = memory_order_seq_cst) noexcept;
	T load(memory_order m = memory_order_seq_cst) const volatile noexcept;
	T load(memory_order m = memory_order_seq_cst) const noexcept;
	operator T() const volatile noexcept;
	operator T() const noexcept;
	T exchange(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
	T exchange(T desr, memory_order m = memory_order_seq_cst) noexcept;
	bool compare_exchange_weak(T& expc, T desr,
	memory_order s, memory_order f) volatile noexcept;
	bool compare_exchange_weak(T& expc, T desr, memory_order s, memory_order f) noexcept;
	bool compare_exchange_strong(T& expc, T desr,
	memory_order s, memory_order f) volatile noexcept;
	bool compare_exchange_strong(T& expc, T desr,
	memory_order s, memory_order f) noexcept;
	bool compare_exchange_weak(T& expc, T desr,
	memory_order m = memory_order_seq_cst) volatile noexcept;
	bool compare_exchange_weak(T& expc, T desr,
	memory_order m = memory_order_seq_cst) noexcept;
	bool compare_exchange_strong(T& expc, T desr,
	memory_order m = memory_order_seq_cst) volatile noexcept;
	bool compare_exchange_strong(T& expc, T desr,
	memory_order m = memory_order_seq_cst) noexcept;

	atomic() noexcept = default;
	constexpr atomic(T desr) noexcept;
	atomic(const atomic&) = delete;
	atomic& operator=(const atomic&) = delete;
	atomic& operator=(const atomic&) volatile = delete;
	T operator=(T) volatile noexcept;
	T operator=(T) noexcept;
	};

	template <>
	struct atomic<integral>
	{
	static constexpr bool is_always_lock_free;
	bool is_lock_free() const volatile noexcept;
	bool is_lock_free() const noexcept;
	void store(integral desr, memory_order m = memory_order_seq_cst) volatile noexcept;
	void store(integral desr, memory_order m = memory_order_seq_cst) noexcept;
	integral load(memory_order m = memory_order_seq_cst) const volatile noexcept;
	integral load(memory_order m = memory_order_seq_cst) const noexcept;
	operator integral() const volatile noexcept;
	operator integral() const noexcept;
	integral exchange(integral desr,
	memory_order m = memory_order_seq_cst) volatile noexcept;
	integral exchange(integral desr, memory_order m = memory_order_seq_cst) noexcept;
	bool compare_exchange_weak(integral& expc, integral desr,
	memory_order s, memory_order f) volatile noexcept;
	bool compare_exchange_weak(integral& expc, integral desr,
	memory_order s, memory_order f) noexcept;
	bool compare_exchange_strong(integral& expc, integral desr,
	memory_order s, memory_order f) volatile noexcept;
	bool compare_exchange_strong(integral& expc, integral desr,
	memory_order s, memory_order f) noexcept;
	bool compare_exchange_weak(integral& expc, integral desr,
	memory_order m = memory_order_seq_cst) volatile noexcept;
	bool compare_exchange_weak(integral& expc, integral desr,
	memory_order m = memory_order_seq_cst) noexcept;
	bool compare_exchange_strong(integral& expc, integral desr,
	memory_order m = memory_order_seq_cst) volatile noexcept;
	bool compare_exchange_strong(integral& expc, integral desr,
	memory_order m = memory_order_seq_cst) noexcept;

	integral
	fetch_add(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
	integral fetch_add(integral op, memory_order m = memory_order_seq_cst) noexcept;
	integral
	fetch_sub(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
	integral fetch_sub(integral op, memory_order m = memory_order_seq_cst) noexcept;
	integral
	fetch_and(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
	integral fetch_and(integral op, memory_order m = memory_order_seq_cst) noexcept;
	integral
	fetch_or(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
	integral fetch_or(integral op, memory_order m = memory_order_seq_cst) noexcept;
	integral
	fetch_xor(integral op, memory_order m = memory_order_seq_cst) volatile noexcept;
	integral fetch_xor(integral op, memory_order m = memory_order_seq_cst) noexcept;

	atomic() noexcept = default;
	constexpr atomic(integral desr) noexcept;
	atomic(const atomic&) = delete;
	atomic& operator=(const atomic&) = delete;
	atomic& operator=(const atomic&) volatile = delete;
	integral operator=(integral desr) volatile noexcept;
	integral operator=(integral desr) noexcept;

	integral operator++(int) volatile noexcept;
	integral operator++(int) noexcept;
	integral operator--(int) volatile noexcept;
	integral operator--(int) noexcept;
	integral operator++() volatile noexcept;
	integral operator++() noexcept;
	integral operator--() volatile noexcept;
	integral operator--() noexcept;
	integral operator+=(integral op) volatile noexcept;
	integral operator+=(integral op) noexcept;
	integral operator-=(integral op) volatile noexcept;
	integral operator-=(integral op) noexcept;
	integral operator&=(integral op) volatile noexcept;
	integral operator&=(integral op) noexcept;
	integral operator\|=(integral op) volatile noexcept;
	integral operator\|=(integral op) noexcept;
	integral operator^=(integral op) volatile noexcept;
	integral operator^=(integral op) noexcept;
	};

	template <class T>
	struct atomic<T*>
	{
	static constexpr bool is_always_lock_free;
	bool is_lock_free() const volatile noexcept;
	bool is_lock_free() const noexcept;
	void store(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept;
	void store(T* desr, memory_order m = memory_order_seq_cst) noexcept;
	T* load(memory_order m = memory_order_seq_cst) const volatile noexcept;
	T* load(memory_order m = memory_order_seq_cst) const noexcept;
	operator T*() const volatile noexcept;
	operator T*() const noexcept;
	T* exchange(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept;
	T* exchange(T* desr, memory_order m = memory_order_seq_cst) noexcept;
	bool compare_exchange_weak(T& expc, T desr,
	memory_order s, memory_order f) volatile noexcept;
	bool compare_exchange_weak(T& expc, T desr,
	memory_order s, memory_order f) noexcept;
	bool compare_exchange_strong(T& expc, T desr,
	memory_order s, memory_order f) volatile noexcept;
	bool compare_exchange_strong(T& expc, T desr,
	memory_order s, memory_order f) noexcept;
	bool compare_exchange_weak(T& expc, T desr,
	memory_order m = memory_order_seq_cst) volatile noexcept;
	bool compare_exchange_weak(T& expc, T desr,
	memory_order m = memory_order_seq_cst) noexcept;
	bool compare_exchange_strong(T& expc, T desr,
	memory_order m = memory_order_seq_cst) volatile noexcept;
	bool compare_exchange_strong(T& expc, T desr,
	memory_order m = memory_order_seq_cst) noexcept;
	T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile noexcept;
	T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept;
	T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile noexcept;
	T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept;

	atomic() noexcept = default;
	constexpr atomic(T* desr) noexcept;
	atomic(const atomic&) = delete;
	atomic& operator=(const atomic&) = delete;
	atomic& operator=(const atomic&) volatile = delete;

	T* operator=(T*) volatile noexcept;
	T* operator=(T*) noexcept;
	T* operator++(int) volatile noexcept;
	T* operator++(int) noexcept;
	T* operator--(int) volatile noexcept;
	T* operator--(int) noexcept;
	T* operator++() volatile noexcept;
	T* operator++() noexcept;
	T* operator--() volatile noexcept;
	T* operator--() noexcept;
	T* operator+=(ptrdiff_t op) volatile noexcept;
	T* operator+=(ptrdiff_t op) noexcept;
	T* operator-=(ptrdiff_t op) volatile noexcept;
	T* operator-=(ptrdiff_t op) noexcept;
	};


	template <class T>
	bool
	atomic_is_lock_free(const volatile atomic<T>* obj) noexcept;

	template <class T>
	bool
	atomic_is_lock_free(const atomic<T>* obj) noexcept;

	template <class T>
	void
	atomic_init(volatile atomic<T>* obj, T desr) noexcept;

	template <class T>
	void
	atomic_init(atomic<T>* obj, T desr) noexcept;

	template <class T>
	void
	atomic_store(volatile atomic<T>* obj, T desr) noexcept;

	template <class T>
	void
	atomic_store(atomic<T>* obj, T desr) noexcept;

	template <class T>
	void
	atomic_store_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexcept;

	template <class T>
	void
	atomic_store_explicit(atomic<T>* obj, T desr, memory_order m) noexcept;

	template <class T>
	T
	atomic_load(const volatile atomic<T>* obj) noexcept;

	template <class T>
	T
	atomic_load(const atomic<T>* obj) noexcept;

	template <class T>
	T
	atomic_load_explicit(const volatile atomic<T>* obj, memory_order m) noexcept;

	template <class T>
	T
	atomic_load_explicit(const atomic<T>* obj, memory_order m) noexcept;

	template <class T>
	T
	atomic_exchange(volatile atomic<T>* obj, T desr) noexcept;

	template <class T>
	T
	atomic_exchange(atomic<T>* obj, T desr) noexcept;

	template <class T>
	T
	atomic_exchange_explicit(volatile atomic<T>* obj, T desr, memory_order m) noexcept;

	template <class T>
	T
	atomic_exchange_explicit(atomic<T>* obj, T desr, memory_order m) noexcept;

	template <class T>
	bool
	atomic_compare_exchange_weak(volatile atomic<T>* obj, T* expc, T desr) noexcept;

	template <class T>
	bool
	atomic_compare_exchange_weak(atomic<T>* obj, T* expc, T desr) noexcept;

	template <class T>
	bool
	atomic_compare_exchange_strong(volatile atomic<T>* obj, T* expc, T desr) noexcept;

	template <class T>
	bool
	atomic_compare_exchange_strong(atomic<T>* obj, T* expc, T desr) noexcept;

	template <class T>
	bool
	atomic_compare_exchange_weak_explicit(volatile atomic<T>* obj, T* expc,
	T desr,
	memory_order s, memory_order f) noexcept;

	template <class T>
	bool
	atomic_compare_exchange_weak_explicit(atomic<T>* obj, T* expc, T desr,
	memory_order s, memory_order f) noexcept;

	template <class T>
	bool
	atomic_compare_exchange_strong_explicit(volatile atomic<T>* obj,
	T* expc, T desr,
	memory_order s, memory_order f) noexcept;

	template <class T>
	bool
	atomic_compare_exchange_strong_explicit(atomic<T>* obj, T* expc,
	T desr,
	memory_order s, memory_order f) noexcept;

	template <class Integral>
	Integral
	atomic_fetch_add(volatile atomic<Integral>* obj, Integral op) noexcept;

	template <class Integral>
	Integral
	atomic_fetch_add(atomic<Integral>* obj, Integral op) noexcept;

	template <class Integral>
	Integral
	atomic_fetch_add_explicit(volatile atomic<Integral>* obj, Integral op,
	memory_order m) noexcept;
	template <class Integral>
	Integral
	atomic_fetch_add_explicit(atomic<Integral>* obj, Integral op,
	memory_order m) noexcept;
	template <class Integral>
	Integral
	atomic_fetch_sub(volatile atomic<Integral>* obj, Integral op) noexcept;

	template <class Integral>
	Integral
	atomic_fetch_sub(atomic<Integral>* obj, Integral op) noexcept;

	template <class Integral>
	Integral
	atomic_fetch_sub_explicit(volatile atomic<Integral>* obj, Integral op,
	memory_order m) noexcept;
	template <class Integral>
	Integral
	atomic_fetch_sub_explicit(atomic<Integral>* obj, Integral op,
	memory_order m) noexcept;
	template <class Integral>
	Integral
	atomic_fetch_and(volatile atomic<Integral>* obj, Integral op) noexcept;

	template <class Integral>
	Integral
	atomic_fetch_and(atomic<Integral>* obj, Integral op) noexcept;

	template <class Integral>
	Integral
	atomic_fetch_and_explicit(volatile atomic<Integral>* obj, Integral op,
	memory_order m) noexcept;
	template <class Integral>
	Integral
	atomic_fetch_and_explicit(atomic<Integral>* obj, Integral op,
	memory_order m) noexcept;
	template <class Integral>
	Integral
	atomic_fetch_or(volatile atomic<Integral>* obj, Integral op) noexcept;

	template <class Integral>
	Integral
	atomic_fetch_or(atomic<Integral>* obj, Integral op) noexcept;

	template <class Integral>
	Integral
	atomic_fetch_or_explicit(volatile atomic<Integral>* obj, Integral op,
	memory_order m) noexcept;
	template <class Integral>
	Integral
	atomic_fetch_or_explicit(atomic<Integral>* obj, Integral op,
	memory_order m) noexcept;
	template <class Integral>
	Integral
	atomic_fetch_xor(volatile atomic<Integral>* obj, Integral op) noexcept;

	template <class Integral>
	Integral
	atomic_fetch_xor(atomic<Integral>* obj, Integral op) noexcept;

	template <class Integral>
	Integral
	atomic_fetch_xor_explicit(volatile atomic<Integral>* obj, Integral op,
	memory_order m) noexcept;
	template <class Integral>
	Integral
	atomic_fetch_xor_explicit(atomic<Integral>* obj, Integral op,
	memory_order m) noexcept;

	template <class T>
	T*
	atomic_fetch_add(volatile atomic<T> obj, ptrdiff_t op) noexcept;

	template <class T>
	T*
	atomic_fetch_add(atomic<T> obj, ptrdiff_t op) noexcept;

	template <class T>
	T*
	atomic_fetch_add_explicit(volatile atomic<T> obj, ptrdiff_t op,
	memory_order m) noexcept;
	template <class T>
	T*
	atomic_fetch_add_explicit(atomic<T> obj, ptrdiff_t op, memory_order m) noexcept;

	template <class T>
	T*
	atomic_fetch_sub(volatile atomic<T> obj, ptrdiff_t op) noexcept;

	template <class T>
	T*
	atomic_fetch_sub(atomic<T> obj, ptrdiff_t op) noexcept;

	template <class T>
	T*
	atomic_fetch_sub_explicit(volatile atomic<T> obj, ptrdiff_t op,
	memory_order m) noexcept;
	template <class T>
	T*
	atomic_fetch_sub_explicit(atomic<T> obj, ptrdiff_t op, memory_order m) noexcept;

	// Atomics for standard typedef types

	typedef atomic<bool> atomic_bool;
	typedef atomic<char> atomic_char;
	typedef atomic<signed char> atomic_schar;
	typedef atomic<unsigned char> atomic_uchar;
	typedef atomic<short> atomic_short;
	typedef atomic<unsigned short> atomic_ushort;
	typedef atomic<int> atomic_int;
	typedef atomic<unsigned int> atomic_uint;
	typedef atomic<long> atomic_long;
	typedef atomic<unsigned long> atomic_ulong;
	typedef atomic<long long> atomic_llong;
	typedef atomic<unsigned long long> atomic_ullong;
	typedef atomic<char16_t> atomic_char16_t;
	typedef atomic<char32_t> atomic_char32_t;
	typedef atomic<wchar_t> atomic_wchar_t;

	typedef atomic<int_least8_t> atomic_int_least8_t;
	typedef atomic<uint_least8_t> atomic_uint_least8_t;
	typedef atomic<int_least16_t> atomic_int_least16_t;
	typedef atomic<uint_least16_t> atomic_uint_least16_t;
	typedef atomic<int_least32_t> atomic_int_least32_t;
	typedef atomic<uint_least32_t> atomic_uint_least32_t;
	typedef atomic<int_least64_t> atomic_int_least64_t;
	typedef atomic<uint_least64_t> atomic_uint_least64_t;

	typedef atomic<int_fast8_t> atomic_int_fast8_t;
	typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
	typedef atomic<int_fast16_t> atomic_int_fast16_t;
	typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
	typedef atomic<int_fast32_t> atomic_int_fast32_t;
	typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
	typedef atomic<int_fast64_t> atomic_int_fast64_t;
	typedef atomic<uint_fast64_t> atomic_uint_fast64_t;

	typedef atomic<int8_t> atomic_int8_t;
	typedef atomic<uint8_t> atomic_uint8_t;
	typedef atomic<int16_t> atomic_int16_t;
	typedef atomic<uint16_t> atomic_uint16_t;
	typedef atomic<int32_t> atomic_int32_t;
	typedef atomic<uint32_t> atomic_uint32_t;
	typedef atomic<int64_t> atomic_int64_t;
	typedef atomic<uint64_t> atomic_uint64_t;

	typedef atomic<intptr_t> atomic_intptr_t;
	typedef atomic<uintptr_t> atomic_uintptr_t;
	typedef atomic<size_t> atomic_size_t;
	typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
	typedef atomic<intmax_t> atomic_intmax_t;
	typedef atomic<uintmax_t> atomic_uintmax_t;

	// fences

	void atomic_thread_fence(memory_order m) noexcept;
	void atomic_signal_fence(memory_order m) noexcept;

	} // std

	*/

	#include <__config>
	#include <cstddef>
	#include <cstdint>
	#include <type_traits>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	#ifdef _LIBCPP_HAS_NO_THREADS
	#error <atomic> is not supported on this single threaded system
	#endif
	#if !defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_GCC_ATOMIC_IMP)
	#error <atomic> is not implemented
	#endif
	+#ifdef kill_dependency
	+#error C++ standard library is incompatible with <stdatomic.h>
	+#endif

	#if _LIBCPP_STD_VER > 14
	# define __cpp_lib_atomic_is_always_lock_free 201603L
	#endif

	#define _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) \
	_LIBCPP_DIAGNOSE_WARNING(__m == memory_order_consume \|\| \
	__m == memory_order_acquire \|\| \
	__m == memory_order_acq_rel, \
	"memory order argument to atomic operation is invalid")

	#define _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) \
	_LIBCPP_DIAGNOSE_WARNING(__m == memory_order_release \|\| \
	__m == memory_order_acq_rel, \
	"memory order argument to atomic operation is invalid")

	#define _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__m, __f) \
	_LIBCPP_DIAGNOSE_WARNING(__f == memory_order_release \|\| \
	__f == memory_order_acq_rel, \
	"memory order argument to atomic operation is invalid")

	_LIBCPP_BEGIN_NAMESPACE_STD

	typedef enum memory_order
	{
	memory_order_relaxed, memory_order_consume, memory_order_acquire,
	memory_order_release, memory_order_acq_rel, memory_order_seq_cst
	} memory_order;

	#if defined(_LIBCPP_HAS_GCC_ATOMIC_IMP)
	namespace __gcc_atomic {
	template <typename _Tp>
	struct __gcc_atomic_t {

	#if _GNUC_VER >= 501
	static_assert(is_trivially_copyable<_Tp>::value,
	"std::atomic<Tp> requires that 'Tp' be a trivially copyable type");
	#endif

	_LIBCPP_INLINE_VISIBILITY
	#ifndef _LIBCPP_CXX03_LANG
	__gcc_atomic_t() _NOEXCEPT = default;
	#else
	__gcc_atomic_t() _NOEXCEPT : __a_value() {}
	#endif // _LIBCPP_CXX03_LANG
	_LIBCPP_CONSTEXPR explicit __gcc_atomic_t(_Tp value) _NOEXCEPT
	: __a_value(value) {}
	_Tp __a_value;
	};
	#define _Atomic(x) __gcc_atomic::__gcc_atomic_t<x>

	template <typename _Tp> _Tp __create();

	template <typename _Tp, typename _Td>
	typename enable_if<sizeof(_Tp()->__a_value = __create<_Td>()), char>::type
	__test_atomic_assignable(int);
	template <typename _Tp, typename _Up>
	__two __test_atomic_assignable(...);

	template <typename _Tp, typename _Td>
	struct __can_assign {
	static const bool value =
	sizeof(__test_atomic_assignable<_Tp, _Td>(1)) == sizeof(char);
	};

	static inline _LIBCPP_CONSTEXPR int __to_gcc_order(memory_order __order) {
	// Avoid switch statement to make this a constexpr.
	return __order == memory_order_relaxed ? __ATOMIC_RELAXED:
	(__order == memory_order_acquire ? __ATOMIC_ACQUIRE:
	(__order == memory_order_release ? __ATOMIC_RELEASE:
	(__order == memory_order_seq_cst ? __ATOMIC_SEQ_CST:
	(__order == memory_order_acq_rel ? __ATOMIC_ACQ_REL:
	__ATOMIC_CONSUME))));
	}

	static inline _LIBCPP_CONSTEXPR int __to_gcc_failure_order(memory_order __order) {
	// Avoid switch statement to make this a constexpr.
	return __order == memory_order_relaxed ? __ATOMIC_RELAXED:
	(__order == memory_order_acquire ? __ATOMIC_ACQUIRE:
	(__order == memory_order_release ? __ATOMIC_RELAXED:
	(__order == memory_order_seq_cst ? __ATOMIC_SEQ_CST:
	(__order == memory_order_acq_rel ? __ATOMIC_ACQUIRE:
	__ATOMIC_CONSUME))));
	}

	} // namespace __gcc_atomic

	template <typename _Tp>
	static inline
	typename enable_if<
	__gcc_atomic::__can_assign<volatile _Atomic(_Tp)*, _Tp>::value>::type
	__c11_atomic_init(volatile _Atomic(_Tp)* __a, _Tp __val) {
	__a->__a_value = __val;
	}

	template <typename _Tp>
	static inline
	typename enable_if<
	!__gcc_atomic::__can_assign<volatile _Atomic(_Tp)*, _Tp>::value &&
	__gcc_atomic::__can_assign< _Atomic(_Tp)*, _Tp>::value>::type
	__c11_atomic_init(volatile _Atomic(_Tp)* __a, _Tp __val) {
	// [atomics.types.generic]p1 guarantees _Tp is trivially copyable. Because
	// the default operator= in an object is not volatile, a byte-by-byte copy
	// is required.
	volatile char* to = reinterpret_cast<volatile char*>(&__a->__a_value);
	volatile char* end = to + sizeof(_Tp);
	char* from = reinterpret_cast<char*>(&__val);
	while (to != end) {
	to++ = from++;
	}
	}

	template <typename _Tp>
	static inline void __c11_atomic_init(_Atomic(_Tp)* __a, _Tp __val) {
	__a->__a_value = __val;
	}

	static inline void __c11_atomic_thread_fence(memory_order __order) {
	__atomic_thread_fence(__gcc_atomic::__to_gcc_order(__order));
	}

	static inline void __c11_atomic_signal_fence(memory_order __order) {
	__atomic_signal_fence(__gcc_atomic::__to_gcc_order(__order));
	}

	template <typename _Tp>
	static inline void __c11_atomic_store(volatile _Atomic(_Tp)* __a, _Tp __val,
	memory_order __order) {
	return __atomic_store(&__a->__a_value, &__val,
	__gcc_atomic::__to_gcc_order(__order));
	}

	template <typename _Tp>
	static inline void __c11_atomic_store(_Atomic(_Tp)* __a, _Tp __val,
	memory_order __order) {
	__atomic_store(&__a->__a_value, &__val,
	__gcc_atomic::__to_gcc_order(__order));
	}

	template <typename _Tp>
	-static inline _Tp __c11_atomic_load(volatile _Atomic(_Tp)* __a,
	+static inline _Tp __c11_atomic_load(const volatile _Atomic(_Tp)* __a,
	memory_order __order) {
	_Tp __ret;
	__atomic_load(&__a->__a_value, &__ret,
	__gcc_atomic::__to_gcc_order(__order));
	return __ret;
	}

	template <typename _Tp>
	-static inline _Tp __c11_atomic_load(_Atomic(_Tp)* __a, memory_order __order) {
	+static inline _Tp __c11_atomic_load(const _Atomic(_Tp)* __a, memory_order __order) {
	_Tp __ret;
	__atomic_load(&__a->__a_value, &__ret,
	__gcc_atomic::__to_gcc_order(__order));
	return __ret;
	}

	template <typename _Tp>
	static inline _Tp __c11_atomic_exchange(volatile _Atomic(_Tp)* __a,
	_Tp __value, memory_order __order) {
	_Tp __ret;
	__atomic_exchange(&__a->__a_value, &__value, &__ret,
	__gcc_atomic::__to_gcc_order(__order));
	return __ret;
	}

	template <typename _Tp>
	static inline _Tp __c11_atomic_exchange(_Atomic(_Tp)* __a, _Tp __value,
	memory_order __order) {
	_Tp __ret;
	__atomic_exchange(&__a->__a_value, &__value, &__ret,
	__gcc_atomic::__to_gcc_order(__order));
	return __ret;
	}

	template <typename _Tp>
	static inline bool __c11_atomic_compare_exchange_strong(
	volatile _Atomic(_Tp)* __a, _Tp* __expected, _Tp __value,
	memory_order __success, memory_order __failure) {
	return __atomic_compare_exchange(&__a->__a_value, __expected, &__value,
	false,
	__gcc_atomic::__to_gcc_order(__success),
	__gcc_atomic::__to_gcc_failure_order(__failure));
	}

	template <typename _Tp>
	static inline bool __c11_atomic_compare_exchange_strong(
	_Atomic(_Tp)* __a, _Tp* __expected, _Tp __value, memory_order __success,
	memory_order __failure) {
	return __atomic_compare_exchange(&__a->__a_value, __expected, &__value,
	false,
	__gcc_atomic::__to_gcc_order(__success),
	__gcc_atomic::__to_gcc_failure_order(__failure));
	}

	template <typename _Tp>
	static inline bool __c11_atomic_compare_exchange_weak(
	volatile _Atomic(_Tp)* __a, _Tp* __expected, _Tp __value,
	memory_order __success, memory_order __failure) {
	return __atomic_compare_exchange(&__a->__a_value, __expected, &__value,
	true,
	__gcc_atomic::__to_gcc_order(__success),
	__gcc_atomic::__to_gcc_failure_order(__failure));
	}

	template <typename _Tp>
	static inline bool __c11_atomic_compare_exchange_weak(
	_Atomic(_Tp)* __a, _Tp* __expected, _Tp __value, memory_order __success,
	memory_order __failure) {
	return __atomic_compare_exchange(&__a->__a_value, __expected, &__value,
	true,
	__gcc_atomic::__to_gcc_order(__success),
	__gcc_atomic::__to_gcc_failure_order(__failure));
	}

	template <typename _Tp>
	struct __skip_amt { enum {value = 1}; };

	template <typename _Tp>
	struct __skip_amt<_Tp*> { enum {value = sizeof(_Tp)}; };

	// FIXME: Haven't figured out what the spec says about using arrays with
	// atomic_fetch_add. Force a failure rather than creating bad behavior.
	template <typename _Tp>
	struct __skip_amt<_Tp[]> { };
	template <typename _Tp, int n>
	struct __skip_amt<_Tp[n]> { };

	template <typename _Tp, typename _Td>
	static inline _Tp __c11_atomic_fetch_add(volatile _Atomic(_Tp)* __a,
	_Td __delta, memory_order __order) {
	return __atomic_fetch_add(&__a->__a_value, __delta * __skip_amt<_Tp>::value,
	__gcc_atomic::__to_gcc_order(__order));
	}

	template <typename _Tp, typename _Td>
	static inline _Tp __c11_atomic_fetch_add(_Atomic(_Tp)* __a, _Td __delta,
	memory_order __order) {
	return __atomic_fetch_add(&__a->__a_value, __delta * __skip_amt<_Tp>::value,
	__gcc_atomic::__to_gcc_order(__order));
	}

	template <typename _Tp, typename _Td>
	static inline _Tp __c11_atomic_fetch_sub(volatile _Atomic(_Tp)* __a,
	_Td __delta, memory_order __order) {
	return __atomic_fetch_sub(&__a->__a_value, __delta * __skip_amt<_Tp>::value,
	__gcc_atomic::__to_gcc_order(__order));
	}

	template <typename _Tp, typename _Td>
	static inline _Tp __c11_atomic_fetch_sub(_Atomic(_Tp)* __a, _Td __delta,
	memory_order __order) {
	return __atomic_fetch_sub(&__a->__a_value, __delta * __skip_amt<_Tp>::value,
	__gcc_atomic::__to_gcc_order(__order));
	}

	template <typename _Tp>
	static inline _Tp __c11_atomic_fetch_and(volatile _Atomic(_Tp)* __a,
	_Tp __pattern, memory_order __order) {
	return __atomic_fetch_and(&__a->__a_value, __pattern,
	__gcc_atomic::__to_gcc_order(__order));
	}

	template <typename _Tp>
	static inline _Tp __c11_atomic_fetch_and(_Atomic(_Tp)* __a,
	_Tp __pattern, memory_order __order) {
	return __atomic_fetch_and(&__a->__a_value, __pattern,
	__gcc_atomic::__to_gcc_order(__order));
	}

	template <typename _Tp>
	static inline _Tp __c11_atomic_fetch_or(volatile _Atomic(_Tp)* __a,
	_Tp __pattern, memory_order __order) {
	return __atomic_fetch_or(&__a->__a_value, __pattern,
	__gcc_atomic::__to_gcc_order(__order));
	}

	template <typename _Tp>
	static inline _Tp __c11_atomic_fetch_or(_Atomic(_Tp)* __a, _Tp __pattern,
	memory_order __order) {
	return __atomic_fetch_or(&__a->__a_value, __pattern,
	__gcc_atomic::__to_gcc_order(__order));
	}

	template <typename _Tp>
	static inline _Tp __c11_atomic_fetch_xor(volatile _Atomic(_Tp)* __a,
	_Tp __pattern, memory_order __order) {
	return __atomic_fetch_xor(&__a->__a_value, __pattern,
	__gcc_atomic::__to_gcc_order(__order));
	}

	template <typename _Tp>
	static inline _Tp __c11_atomic_fetch_xor(_Atomic(_Tp)* __a, _Tp __pattern,
	memory_order __order) {
	return __atomic_fetch_xor(&__a->__a_value, __pattern,
	__gcc_atomic::__to_gcc_order(__order));
	}
	#endif // _LIBCPP_HAS_GCC_ATOMIC_IMP

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	kill_dependency(_Tp __y) _NOEXCEPT
	{
	return __y;
	}

	#if defined(__CLANG_ATOMIC_BOOL_LOCK_FREE)
	# define ATOMIC_BOOL_LOCK_FREE __CLANG_ATOMIC_BOOL_LOCK_FREE
	# define ATOMIC_CHAR_LOCK_FREE __CLANG_ATOMIC_CHAR_LOCK_FREE
	# define ATOMIC_CHAR16_T_LOCK_FREE __CLANG_ATOMIC_CHAR16_T_LOCK_FREE
	# define ATOMIC_CHAR32_T_LOCK_FREE __CLANG_ATOMIC_CHAR32_T_LOCK_FREE
	# define ATOMIC_WCHAR_T_LOCK_FREE __CLANG_ATOMIC_WCHAR_T_LOCK_FREE
	# define ATOMIC_SHORT_LOCK_FREE __CLANG_ATOMIC_SHORT_LOCK_FREE
	# define ATOMIC_INT_LOCK_FREE __CLANG_ATOMIC_INT_LOCK_FREE
	# define ATOMIC_LONG_LOCK_FREE __CLANG_ATOMIC_LONG_LOCK_FREE
	# define ATOMIC_LLONG_LOCK_FREE __CLANG_ATOMIC_LLONG_LOCK_FREE
	# define ATOMIC_POINTER_LOCK_FREE __CLANG_ATOMIC_POINTER_LOCK_FREE
	#else
	# define ATOMIC_BOOL_LOCK_FREE __GCC_ATOMIC_BOOL_LOCK_FREE
	# define ATOMIC_CHAR_LOCK_FREE __GCC_ATOMIC_CHAR_LOCK_FREE
	# define ATOMIC_CHAR16_T_LOCK_FREE __GCC_ATOMIC_CHAR16_T_LOCK_FREE
	# define ATOMIC_CHAR32_T_LOCK_FREE __GCC_ATOMIC_CHAR32_T_LOCK_FREE
	# define ATOMIC_WCHAR_T_LOCK_FREE __GCC_ATOMIC_WCHAR_T_LOCK_FREE
	# define ATOMIC_SHORT_LOCK_FREE __GCC_ATOMIC_SHORT_LOCK_FREE
	# define ATOMIC_INT_LOCK_FREE __GCC_ATOMIC_INT_LOCK_FREE
	# define ATOMIC_LONG_LOCK_FREE __GCC_ATOMIC_LONG_LOCK_FREE
	# define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE
	# define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE
	#endif

	// general atomic<T>

	template <class _Tp, bool = is_integral<_Tp>::value && !is_same<_Tp, bool>::value>
	struct __atomic_base // false
	{
	mutable _Atomic(_Tp) __a_;

	#if defined(__cpp_lib_atomic_is_always_lock_free)
	static _LIBCPP_CONSTEXPR bool is_always_lock_free = __atomic_always_lock_free(sizeof(__a_), 0);
	#endif

	_LIBCPP_INLINE_VISIBILITY
	bool is_lock_free() const volatile _NOEXCEPT
	{
	#if defined(_LIBCPP_HAS_C_ATOMIC_IMP)
	return __c11_atomic_is_lock_free(sizeof(_Tp));
	#else
	return __atomic_is_lock_free(sizeof(_Tp), 0);
	#endif
	}
	_LIBCPP_INLINE_VISIBILITY
	bool is_lock_free() const _NOEXCEPT
	{return static_cast<__atomic_base const volatile*>(this)->is_lock_free();}
	_LIBCPP_INLINE_VISIBILITY
	void store(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
	_LIBCPP_CHECK_STORE_MEMORY_ORDER(__m)
	{__c11_atomic_store(&__a_, __d, __m);}
	_LIBCPP_INLINE_VISIBILITY
	void store(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT
	_LIBCPP_CHECK_STORE_MEMORY_ORDER(__m)
	{__c11_atomic_store(&__a_, __d, __m);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp load(memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT
	_LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
	{return __c11_atomic_load(&__a_, __m);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp load(memory_order __m = memory_order_seq_cst) const _NOEXCEPT
	_LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
	{return __c11_atomic_load(&__a_, __m);}
	_LIBCPP_INLINE_VISIBILITY
	operator _Tp() const volatile _NOEXCEPT {return load();}
	_LIBCPP_INLINE_VISIBILITY
	operator _Tp() const _NOEXCEPT {return load();}
	_LIBCPP_INLINE_VISIBILITY
	_Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
	{return __c11_atomic_exchange(&__a_, __d, __m);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT
	{return __c11_atomic_exchange(&__a_, __d, __m);}
	_LIBCPP_INLINE_VISIBILITY
	bool compare_exchange_weak(_Tp& __e, _Tp __d,
	memory_order __s, memory_order __f) volatile _NOEXCEPT
	_LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
	{return __c11_atomic_compare_exchange_weak(&__a_, &__e, __d, __s, __f);}
	_LIBCPP_INLINE_VISIBILITY
	bool compare_exchange_weak(_Tp& __e, _Tp __d,
	memory_order __s, memory_order __f) _NOEXCEPT
	_LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
	{return __c11_atomic_compare_exchange_weak(&__a_, &__e, __d, __s, __f);}
	_LIBCPP_INLINE_VISIBILITY
	bool compare_exchange_strong(_Tp& __e, _Tp __d,
	memory_order __s, memory_order __f) volatile _NOEXCEPT
	_LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
	{return __c11_atomic_compare_exchange_strong(&__a_, &__e, __d, __s, __f);}
	_LIBCPP_INLINE_VISIBILITY
	bool compare_exchange_strong(_Tp& __e, _Tp __d,
	memory_order __s, memory_order __f) _NOEXCEPT
	_LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
	{return __c11_atomic_compare_exchange_strong(&__a_, &__e, __d, __s, __f);}
	_LIBCPP_INLINE_VISIBILITY
	bool compare_exchange_weak(_Tp& __e, _Tp __d,
	memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
	{return __c11_atomic_compare_exchange_weak(&__a_, &__e, __d, __m, __m);}
	_LIBCPP_INLINE_VISIBILITY
	bool compare_exchange_weak(_Tp& __e, _Tp __d,
	memory_order __m = memory_order_seq_cst) _NOEXCEPT
	{return __c11_atomic_compare_exchange_weak(&__a_, &__e, __d, __m, __m);}
	_LIBCPP_INLINE_VISIBILITY
	bool compare_exchange_strong(_Tp& __e, _Tp __d,
	memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
	{return __c11_atomic_compare_exchange_strong(&__a_, &__e, __d, __m, __m);}
	_LIBCPP_INLINE_VISIBILITY
	bool compare_exchange_strong(_Tp& __e, _Tp __d,
	memory_order __m = memory_order_seq_cst) _NOEXCEPT
	{return __c11_atomic_compare_exchange_strong(&__a_, &__e, __d, __m, __m);}

	_LIBCPP_INLINE_VISIBILITY
	#ifndef _LIBCPP_CXX03_LANG
	__atomic_base() _NOEXCEPT = default;
	#else
	__atomic_base() _NOEXCEPT : __a_() {}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __a_(__d) {}
	#ifndef _LIBCPP_CXX03_LANG
	__atomic_base(const __atomic_base&) = delete;
	__atomic_base& operator=(const __atomic_base&) = delete;
	__atomic_base& operator=(const __atomic_base&) volatile = delete;
	#else
	private:
	__atomic_base(const __atomic_base&);
	__atomic_base& operator=(const __atomic_base&);
	__atomic_base& operator=(const __atomic_base&) volatile;
	#endif
	};

	#if defined(__cpp_lib_atomic_is_always_lock_free)
	template <class _Tp, bool __b>
	_LIBCPP_CONSTEXPR bool __atomic_base<_Tp, __b>::is_always_lock_free;
	#endif

	// atomic<Integral>

	template <class _Tp>
	struct __atomic_base<_Tp, true>
	: public __atomic_base<_Tp, false>
	{
	typedef __atomic_base<_Tp, false> __base;
	_LIBCPP_INLINE_VISIBILITY
	__atomic_base() _NOEXCEPT _LIBCPP_DEFAULT
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __base(__d) {}

	_LIBCPP_INLINE_VISIBILITY
	_Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
	{return __c11_atomic_fetch_add(&this->__a_, __op, __m);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
	{return __c11_atomic_fetch_add(&this->__a_, __op, __m);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
	{return __c11_atomic_fetch_sub(&this->__a_, __op, __m);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
	{return __c11_atomic_fetch_sub(&this->__a_, __op, __m);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
	{return __c11_atomic_fetch_and(&this->__a_, __op, __m);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
	{return __c11_atomic_fetch_and(&this->__a_, __op, __m);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
	{return __c11_atomic_fetch_or(&this->__a_, __op, __m);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
	{return __c11_atomic_fetch_or(&this->__a_, __op, __m);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
	{return __c11_atomic_fetch_xor(&this->__a_, __op, __m);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
	{return __c11_atomic_fetch_xor(&this->__a_, __op, __m);}

	_LIBCPP_INLINE_VISIBILITY
	_Tp operator++(int) volatile _NOEXCEPT {return fetch_add(_Tp(1));}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator++(int) _NOEXCEPT {return fetch_add(_Tp(1));}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator--(int) volatile _NOEXCEPT {return fetch_sub(_Tp(1));}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator--(int) _NOEXCEPT {return fetch_sub(_Tp(1));}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator++() volatile _NOEXCEPT {return fetch_add(_Tp(1)) + _Tp(1);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator++() _NOEXCEPT {return fetch_add(_Tp(1)) + _Tp(1);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator--() volatile _NOEXCEPT {return fetch_sub(_Tp(1)) - _Tp(1);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator--() _NOEXCEPT {return fetch_sub(_Tp(1)) - _Tp(1);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator+=(_Tp __op) volatile _NOEXCEPT {return fetch_add(__op) + __op;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator+=(_Tp __op) _NOEXCEPT {return fetch_add(__op) + __op;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator-=(_Tp __op) volatile _NOEXCEPT {return fetch_sub(__op) - __op;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator-=(_Tp __op) _NOEXCEPT {return fetch_sub(__op) - __op;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator&=(_Tp __op) volatile _NOEXCEPT {return fetch_and(__op) & __op;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator&=(_Tp __op) _NOEXCEPT {return fetch_and(__op) & __op;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator\|=(_Tp __op) volatile _NOEXCEPT {return fetch_or(__op) \| __op;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator\|=(_Tp __op) _NOEXCEPT {return fetch_or(__op) \| __op;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator^=(_Tp __op) volatile _NOEXCEPT {return fetch_xor(__op) ^ __op;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator^=(_Tp __op) _NOEXCEPT {return fetch_xor(__op) ^ __op;}
	};

	// atomic<T>

	template <class _Tp>
	struct atomic
	: public __atomic_base<_Tp>
	{
	typedef __atomic_base<_Tp> __base;
	_LIBCPP_INLINE_VISIBILITY
	atomic() _NOEXCEPT _LIBCPP_DEFAULT
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR atomic(_Tp __d) _NOEXCEPT : __base(__d) {}

	_LIBCPP_INLINE_VISIBILITY
	_Tp operator=(_Tp __d) volatile _NOEXCEPT
	{__base::store(__d); return __d;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator=(_Tp __d) _NOEXCEPT
	{__base::store(__d); return __d;}
	};

	// atomic<T*>

	template <class _Tp>
	struct atomic<_Tp*>
	: public __atomic_base<_Tp*>
	{
	typedef __atomic_base<_Tp*> __base;
	_LIBCPP_INLINE_VISIBILITY
	atomic() _NOEXCEPT _LIBCPP_DEFAULT
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR atomic(_Tp* __d) _NOEXCEPT : __base(__d) {}

	_LIBCPP_INLINE_VISIBILITY
	_Tp* operator=(_Tp* __d) volatile _NOEXCEPT
	{__base::store(__d); return __d;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp* operator=(_Tp* __d) _NOEXCEPT
	{__base::store(__d); return __d;}

	_LIBCPP_INLINE_VISIBILITY
	_Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst)
	volatile _NOEXCEPT
	{return __c11_atomic_fetch_add(&this->__a_, __op, __m);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
	{return __c11_atomic_fetch_add(&this->__a_, __op, __m);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst)
	volatile _NOEXCEPT
	{return __c11_atomic_fetch_sub(&this->__a_, __op, __m);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT
	{return __c11_atomic_fetch_sub(&this->__a_, __op, __m);}

	_LIBCPP_INLINE_VISIBILITY
	_Tp* operator++(int) volatile _NOEXCEPT {return fetch_add(1);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp* operator++(int) _NOEXCEPT {return fetch_add(1);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp* operator--(int) volatile _NOEXCEPT {return fetch_sub(1);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp* operator--(int) _NOEXCEPT {return fetch_sub(1);}
	_LIBCPP_INLINE_VISIBILITY
	_Tp* operator++() volatile _NOEXCEPT {return fetch_add(1) + 1;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp* operator++() _NOEXCEPT {return fetch_add(1) + 1;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp* operator--() volatile _NOEXCEPT {return fetch_sub(1) - 1;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp* operator--() _NOEXCEPT {return fetch_sub(1) - 1;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp* operator+=(ptrdiff_t __op) volatile _NOEXCEPT {return fetch_add(__op) + __op;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp* operator+=(ptrdiff_t __op) _NOEXCEPT {return fetch_add(__op) + __op;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp* operator-=(ptrdiff_t __op) volatile _NOEXCEPT {return fetch_sub(__op) - __op;}
	_LIBCPP_INLINE_VISIBILITY
	_Tp* operator-=(ptrdiff_t __op) _NOEXCEPT {return fetch_sub(__op) - __op;}
	};

	// atomic_is_lock_free

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	atomic_is_lock_free(const volatile atomic<_Tp>* __o) _NOEXCEPT
	{
	return __o->is_lock_free();
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	atomic_is_lock_free(const atomic<_Tp>* __o) _NOEXCEPT
	{
	return __o->is_lock_free();
	}

	// atomic_init

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	atomic_init(volatile atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
	{
	__c11_atomic_init(&__o->__a_, __d);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	atomic_init(atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
	{
	__c11_atomic_init(&__o->__a_, __d);
	}

	// atomic_store

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	atomic_store(volatile atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
	{
	__o->store(__d);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	atomic_store(atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
	{
	__o->store(__d);
	}

	// atomic_store_explicit

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	atomic_store_explicit(volatile atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT
	_LIBCPP_CHECK_STORE_MEMORY_ORDER(__m)
	{
	__o->store(__d, __m);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	atomic_store_explicit(atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT
	_LIBCPP_CHECK_STORE_MEMORY_ORDER(__m)
	{
	__o->store(__d, __m);
	}

	// atomic_load

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	atomic_load(const volatile atomic<_Tp>* __o) _NOEXCEPT
	{
	return __o->load();
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	atomic_load(const atomic<_Tp>* __o) _NOEXCEPT
	{
	return __o->load();
	}

	// atomic_load_explicit

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	atomic_load_explicit(const volatile atomic<_Tp>* __o, memory_order __m) _NOEXCEPT
	_LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
	{
	return __o->load(__m);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	atomic_load_explicit(const atomic<_Tp>* __o, memory_order __m) _NOEXCEPT
	_LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
	{
	return __o->load(__m);
	}

	// atomic_exchange

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	atomic_exchange(volatile atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
	{
	return __o->exchange(__d);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	atomic_exchange(atomic<_Tp>* __o, _Tp __d) _NOEXCEPT
	{
	return __o->exchange(__d);
	}

	// atomic_exchange_explicit

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	atomic_exchange_explicit(volatile atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT
	{
	return __o->exchange(__d, __m);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	atomic_exchange_explicit(atomic<_Tp>* __o, _Tp __d, memory_order __m) _NOEXCEPT
	{
	return __o->exchange(__d, __m);
	}

	// atomic_compare_exchange_weak

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	atomic_compare_exchange_weak(volatile atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT
	{
	return __o->compare_exchange_weak(*__e, __d);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	atomic_compare_exchange_weak(atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT
	{
	return __o->compare_exchange_weak(*__e, __d);
	}

	// atomic_compare_exchange_strong

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	atomic_compare_exchange_strong(volatile atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT
	{
	return __o->compare_exchange_strong(*__e, __d);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	atomic_compare_exchange_strong(atomic<_Tp>* __o, _Tp* __e, _Tp __d) _NOEXCEPT
	{
	return __o->compare_exchange_strong(*__e, __d);
	}

	// atomic_compare_exchange_weak_explicit

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	atomic_compare_exchange_weak_explicit(volatile atomic<_Tp>* __o, _Tp* __e,
	_Tp __d,
	memory_order __s, memory_order __f) _NOEXCEPT
	_LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
	{
	return __o->compare_exchange_weak(*__e, __d, __s, __f);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	atomic_compare_exchange_weak_explicit(atomic<_Tp>* __o, _Tp* __e, _Tp __d,
	memory_order __s, memory_order __f) _NOEXCEPT
	_LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
	{
	return __o->compare_exchange_weak(*__e, __d, __s, __f);
	}

	// atomic_compare_exchange_strong_explicit

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	atomic_compare_exchange_strong_explicit(volatile atomic<_Tp>* __o,
	_Tp* __e, _Tp __d,
	memory_order __s, memory_order __f) _NOEXCEPT
	_LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
	{
	return __o->compare_exchange_strong(*__e, __d, __s, __f);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	atomic_compare_exchange_strong_explicit(atomic<_Tp>* __o, _Tp* __e,
	_Tp __d,
	memory_order __s, memory_order __f) _NOEXCEPT
	_LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
	{
	return __o->compare_exchange_strong(*__e, __d, __s, __f);
	}

	// atomic_fetch_add

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_add(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
	{
	return __o->fetch_add(__op);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_add(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
	{
	return __o->fetch_add(__op);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp*
	atomic_fetch_add(volatile atomic<_Tp> __o, ptrdiff_t __op) _NOEXCEPT
	{
	return __o->fetch_add(__op);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp*
	atomic_fetch_add(atomic<_Tp> __o, ptrdiff_t __op) _NOEXCEPT
	{
	return __o->fetch_add(__op);
	}

	// atomic_fetch_add_explicit

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_add_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
	{
	return __o->fetch_add(__op, __m);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_add_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
	{
	return __o->fetch_add(__op, __m);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp*
	atomic_fetch_add_explicit(volatile atomic<_Tp> __o, ptrdiff_t __op,
	memory_order __m) _NOEXCEPT
	{
	return __o->fetch_add(__op, __m);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp*
	atomic_fetch_add_explicit(atomic<_Tp> __o, ptrdiff_t __op, memory_order __m) _NOEXCEPT
	{
	return __o->fetch_add(__op, __m);
	}

	// atomic_fetch_sub

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_sub(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
	{
	return __o->fetch_sub(__op);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_sub(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
	{
	return __o->fetch_sub(__op);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp*
	atomic_fetch_sub(volatile atomic<_Tp> __o, ptrdiff_t __op) _NOEXCEPT
	{
	return __o->fetch_sub(__op);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp*
	atomic_fetch_sub(atomic<_Tp> __o, ptrdiff_t __op) _NOEXCEPT
	{
	return __o->fetch_sub(__op);
	}

	// atomic_fetch_sub_explicit

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_sub_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
	{
	return __o->fetch_sub(__op, __m);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_sub_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
	{
	return __o->fetch_sub(__op, __m);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp*
	atomic_fetch_sub_explicit(volatile atomic<_Tp> __o, ptrdiff_t __op,
	memory_order __m) _NOEXCEPT
	{
	return __o->fetch_sub(__op, __m);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp*
	atomic_fetch_sub_explicit(atomic<_Tp> __o, ptrdiff_t __op, memory_order __m) _NOEXCEPT
	{
	return __o->fetch_sub(__op, __m);
	}

	// atomic_fetch_and

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_and(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
	{
	return __o->fetch_and(__op);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_and(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
	{
	return __o->fetch_and(__op);
	}

	// atomic_fetch_and_explicit

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_and_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
	{
	return __o->fetch_and(__op, __m);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_and_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
	{
	return __o->fetch_and(__op, __m);
	}

	// atomic_fetch_or

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_or(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
	{
	return __o->fetch_or(__op);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_or(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
	{
	return __o->fetch_or(__op);
	}

	// atomic_fetch_or_explicit

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_or_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
	{
	return __o->fetch_or(__op, __m);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_or_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
	{
	return __o->fetch_or(__op, __m);
	}

	// atomic_fetch_xor

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_xor(volatile atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
	{
	return __o->fetch_xor(__op);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_xor(atomic<_Tp>* __o, _Tp __op) _NOEXCEPT
	{
	return __o->fetch_xor(__op);
	}

	// atomic_fetch_xor_explicit

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_xor_explicit(volatile atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
	{
	return __o->fetch_xor(__op, __m);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
	_Tp
	>::type
	atomic_fetch_xor_explicit(atomic<_Tp>* __o, _Tp __op, memory_order __m) _NOEXCEPT
	{
	return __o->fetch_xor(__op, __m);
	}

	// flag type and operations

	typedef struct atomic_flag
	{
	_Atomic(bool) __a_;

	_LIBCPP_INLINE_VISIBILITY
	bool test_and_set(memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
	{return __c11_atomic_exchange(&__a_, true, __m);}
	_LIBCPP_INLINE_VISIBILITY
	bool test_and_set(memory_order __m = memory_order_seq_cst) _NOEXCEPT
	{return __c11_atomic_exchange(&__a_, true, __m);}
	_LIBCPP_INLINE_VISIBILITY
	void clear(memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
	{__c11_atomic_store(&__a_, false, __m);}
	_LIBCPP_INLINE_VISIBILITY
	void clear(memory_order __m = memory_order_seq_cst) _NOEXCEPT
	{__c11_atomic_store(&__a_, false, __m);}

	_LIBCPP_INLINE_VISIBILITY
	#ifndef _LIBCPP_CXX03_LANG
	atomic_flag() _NOEXCEPT = default;
	#else
	atomic_flag() _NOEXCEPT : __a_() {}
	#endif // _LIBCPP_CXX03_LANG

	- _LIBCPP_INLINE_VISIBILITY
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	atomic_flag(bool __b) _NOEXCEPT : __a_(__b) {} // EXTENSION

	#ifndef _LIBCPP_CXX03_LANG
	atomic_flag(const atomic_flag&) = delete;
	atomic_flag& operator=(const atomic_flag&) = delete;
	atomic_flag& operator=(const atomic_flag&) volatile = delete;
	#else
	private:
	atomic_flag(const atomic_flag&);
	atomic_flag& operator=(const atomic_flag&);
	atomic_flag& operator=(const atomic_flag&) volatile;
	#endif
	} atomic_flag;

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	atomic_flag_test_and_set(volatile atomic_flag* __o) _NOEXCEPT
	{
	return __o->test_and_set();
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	atomic_flag_test_and_set(atomic_flag* __o) _NOEXCEPT
	{
	return __o->test_and_set();
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	atomic_flag_test_and_set_explicit(volatile atomic_flag* __o, memory_order __m) _NOEXCEPT
	{
	return __o->test_and_set(__m);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	atomic_flag_test_and_set_explicit(atomic_flag* __o, memory_order __m) _NOEXCEPT
	{
	return __o->test_and_set(__m);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	void
	atomic_flag_clear(volatile atomic_flag* __o) _NOEXCEPT
	{
	__o->clear();
	}

	inline _LIBCPP_INLINE_VISIBILITY
	void
	atomic_flag_clear(atomic_flag* __o) _NOEXCEPT
	{
	__o->clear();
	}

	inline _LIBCPP_INLINE_VISIBILITY
	void
	atomic_flag_clear_explicit(volatile atomic_flag* __o, memory_order __m) _NOEXCEPT
	{
	__o->clear(__m);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	void
	atomic_flag_clear_explicit(atomic_flag* __o, memory_order __m) _NOEXCEPT
	{
	__o->clear(__m);
	}

	// fences

	inline _LIBCPP_INLINE_VISIBILITY
	void
	atomic_thread_fence(memory_order __m) _NOEXCEPT
	{
	__c11_atomic_thread_fence(__m);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	void
	atomic_signal_fence(memory_order __m) _NOEXCEPT
	{
	__c11_atomic_signal_fence(__m);
	}

	// Atomics for standard typedef types

	typedef atomic<bool> atomic_bool;
	typedef atomic<char> atomic_char;
	typedef atomic<signed char> atomic_schar;
	typedef atomic<unsigned char> atomic_uchar;
	typedef atomic<short> atomic_short;
	typedef atomic<unsigned short> atomic_ushort;
	typedef atomic<int> atomic_int;
	typedef atomic<unsigned int> atomic_uint;
	typedef atomic<long> atomic_long;
	typedef atomic<unsigned long> atomic_ulong;
	typedef atomic<long long> atomic_llong;
	typedef atomic<unsigned long long> atomic_ullong;
	typedef atomic<char16_t> atomic_char16_t;
	typedef atomic<char32_t> atomic_char32_t;
	typedef atomic<wchar_t> atomic_wchar_t;

	typedef atomic<int_least8_t> atomic_int_least8_t;
	typedef atomic<uint_least8_t> atomic_uint_least8_t;
	typedef atomic<int_least16_t> atomic_int_least16_t;
	typedef atomic<uint_least16_t> atomic_uint_least16_t;
	typedef atomic<int_least32_t> atomic_int_least32_t;
	typedef atomic<uint_least32_t> atomic_uint_least32_t;
	typedef atomic<int_least64_t> atomic_int_least64_t;
	typedef atomic<uint_least64_t> atomic_uint_least64_t;

	typedef atomic<int_fast8_t> atomic_int_fast8_t;
	typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
	typedef atomic<int_fast16_t> atomic_int_fast16_t;
	typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
	typedef atomic<int_fast32_t> atomic_int_fast32_t;
	typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
	typedef atomic<int_fast64_t> atomic_int_fast64_t;
	typedef atomic<uint_fast64_t> atomic_uint_fast64_t;

	typedef atomic< int8_t> atomic_int8_t;
	typedef atomic<uint8_t> atomic_uint8_t;
	typedef atomic< int16_t> atomic_int16_t;
	typedef atomic<uint16_t> atomic_uint16_t;
	typedef atomic< int32_t> atomic_int32_t;
	typedef atomic<uint32_t> atomic_uint32_t;
	typedef atomic< int64_t> atomic_int64_t;
	typedef atomic<uint64_t> atomic_uint64_t;

	typedef atomic<intptr_t> atomic_intptr_t;
	typedef atomic<uintptr_t> atomic_uintptr_t;
	typedef atomic<size_t> atomic_size_t;
	typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
	typedef atomic<intmax_t> atomic_intmax_t;
	typedef atomic<uintmax_t> atomic_uintmax_t;

	#define ATOMIC_FLAG_INIT {false}
	#define ATOMIC_VAR_INIT(__v) {__v}

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_ATOMIC
	Index: projects/clang700-import/contrib/libc++/include/chrono
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/chrono (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/chrono (revision 337135)
	@@ -1,1168 +1,1660 @@
	// -- C++ --
	//===---------------------------- chrono ----------------------------------===//
	//
	// 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_CHRONO
	#define _LIBCPP_CHRONO

	/*
	chrono synopsis

	namespace std
	{
	namespace chrono
	{

	template <class ToDuration, class Rep, class Period>
	constexpr
	ToDuration
	duration_cast(const duration<Rep, Period>& fd);

	template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> {};

	template <class Rep> inline constexpr bool treat_as_floating_point_v
	= treat_as_floating_point<Rep>::value; // C++17

	template <class Rep>
	struct duration_values
	{
	public:
	static constexpr Rep zero();
	static constexpr Rep max();
	static constexpr Rep min();
	};

	// duration

	template <class Rep, class Period = ratio<1>>
	class duration
	{
	static_assert(!__is_duration<Rep>::value, "A duration representation can not be a duration");
	static_assert(__is_ratio<Period>::value, "Second template parameter of duration must be a std::ratio");
	static_assert(Period::num > 0, "duration period must be positive");
	public:
	typedef Rep rep;
	typedef typename _Period::type period;

	constexpr duration() = default;
	template <class Rep2>
	constexpr explicit duration(const Rep2& r,
	typename enable_if
	<
	is_convertible<Rep2, rep>::value &&
	(treat_as_floating_point<rep>::value \|\|
	!treat_as_floating_point<rep>::value && !treat_as_floating_point<Rep2>::value)
	>::type* = 0);

	// conversions
	template <class Rep2, class Period2>
	constexpr duration(const duration<Rep2, Period2>& d,
	typename enable_if
	<
	treat_as_floating_point<rep>::value \|\|
	ratio_divide<Period2, period>::type::den == 1
	>::type* = 0);

	// observer

	constexpr rep count() const;

	// arithmetic

	constexpr common_type<duration>::type operator+() const;
	constexpr common_type<duration>::type operator-() const;
	constexpr duration& operator++();
	constexpr duration operator++(int);
	constexpr duration& operator--();
	constexpr duration operator--(int);

	constexpr duration& operator+=(const duration& d);
	constexpr duration& operator-=(const duration& d);

	duration& operator*=(const rep& rhs);
	duration& operator/=(const rep& rhs);

	// special values

	static constexpr duration zero();
	static constexpr duration min();
	static constexpr duration max();
	};

	typedef duration<long long, nano> nanoseconds;
	typedef duration<long long, micro> microseconds;
	typedef duration<long long, milli> milliseconds;
	typedef duration<long long > seconds;
	typedef duration< long, ratio< 60> > minutes;
	typedef duration< long, ratio<3600> > hours;

	template <class Clock, class Duration = typename Clock::duration>
	class time_point
	{
	public:
	typedef Clock clock;
	typedef Duration duration;
	typedef typename duration::rep rep;
	typedef typename duration::period period;
	private:
	duration d_; // exposition only

	public:
	time_point(); // has value "epoch" // constexpr in C++14
	explicit time_point(const duration& d); // same as time_point() + d // constexpr in C++14

	// conversions
	template <class Duration2>
	time_point(const time_point<clock, Duration2>& t); // constexpr in C++14

	// observer

	duration time_since_epoch() const; // constexpr in C++14

	// arithmetic

	time_point& operator+=(const duration& d);
	time_point& operator-=(const duration& d);

	// special values

	static constexpr time_point min();
	static constexpr time_point max();
	};

	} // chrono

	// common_type traits
	template <class Rep1, class Period1, class Rep2, class Period2>
	struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>;

	template <class Clock, class Duration1, class Duration2>
	struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>;

	namespace chrono {

	+
	+template<class T> struct is_clock; // C++20
	+template<class T> inline constexpr bool is_clock_v = is_clock<T>::value; // C++20
	+
	+
	// duration arithmetic
	template <class Rep1, class Period1, class Rep2, class Period2>
	constexpr
	typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
	operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
	template <class Rep1, class Period1, class Rep2, class Period2>
	constexpr
	typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
	operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
	template <class Rep1, class Period, class Rep2>
	constexpr
	duration<typename common_type<Rep1, Rep2>::type, Period>
	operator*(const duration<Rep1, Period>& d, const Rep2& s);
	template <class Rep1, class Period, class Rep2>
	constexpr
	duration<typename common_type<Rep1, Rep2>::type, Period>
	operator*(const Rep1& s, const duration<Rep2, Period>& d);
	template <class Rep1, class Period, class Rep2>
	constexpr
	duration<typename common_type<Rep1, Rep2>::type, Period>
	operator/(const duration<Rep1, Period>& d, const Rep2& s);
	template <class Rep1, class Period1, class Rep2, class Period2>
	constexpr
	typename common_type<Rep1, Rep2>::type
	operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

	// duration comparisons
	template <class Rep1, class Period1, class Rep2, class Period2>
	constexpr
	bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
	template <class Rep1, class Period1, class Rep2, class Period2>
	constexpr
	bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
	template <class Rep1, class Period1, class Rep2, class Period2>
	constexpr
	bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
	template <class Rep1, class Period1, class Rep2, class Period2>
	constexpr
	bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
	template <class Rep1, class Period1, class Rep2, class Period2>
	constexpr
	bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
	template <class Rep1, class Period1, class Rep2, class Period2>
	constexpr
	bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

	// duration_cast
	template <class ToDuration, class Rep, class Period>
	ToDuration duration_cast(const duration<Rep, Period>& d);

	template <class ToDuration, class Rep, class Period>
	constexpr ToDuration floor(const duration<Rep, Period>& d); // C++17
	template <class ToDuration, class Rep, class Period>
	constexpr ToDuration ceil(const duration<Rep, Period>& d); // C++17
	template <class ToDuration, class Rep, class Period>
	constexpr ToDuration round(const duration<Rep, Period>& d); // C++17

	+// duration I/O is elsewhere
	+
	// time_point arithmetic (all constexpr in C++14)
	template <class Clock, class Duration1, class Rep2, class Period2>
	time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
	operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
	template <class Rep1, class Period1, class Clock, class Duration2>
	time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
	operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
	template <class Clock, class Duration1, class Rep2, class Period2>
	time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
	operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
	template <class Clock, class Duration1, class Duration2>
	typename common_type<Duration1, Duration2>::type
	operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);

	// time_point comparisons (all constexpr in C++14)
	template <class Clock, class Duration1, class Duration2>
	bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
	template <class Clock, class Duration1, class Duration2>
	bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
	template <class Clock, class Duration1, class Duration2>
	bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
	template <class Clock, class Duration1, class Duration2>
	bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
	template <class Clock, class Duration1, class Duration2>
	bool operator> (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
	template <class Clock, class Duration1, class Duration2>
	bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);

	// time_point_cast (constexpr in C++14)

	template <class ToDuration, class Clock, class Duration>
	time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);

	template <class ToDuration, class Clock, class Duration>
	constexpr time_point<Clock, ToDuration>
	floor(const time_point<Clock, Duration>& tp); // C++17

	template <class ToDuration, class Clock, class Duration>
	constexpr time_point<Clock, ToDuration>
	ceil(const time_point<Clock, Duration>& tp); // C++17

	template <class ToDuration, class Clock, class Duration>
	constexpr time_point<Clock, ToDuration>
	round(const time_point<Clock, Duration>& tp); // C++17

	template <class Rep, class Period>
	constexpr duration<Rep, Period> abs(duration<Rep, Period> d); // C++17
	+
	// Clocks

	class system_clock
	{
	public:
	typedef microseconds duration;
	typedef duration::rep rep;
	typedef duration::period period;
	typedef chrono::time_point<system_clock> time_point;
	static const bool is_steady = false; // constexpr in C++14

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

	+template <class Duration>
	+ using sys_time = time_point<system_clock, Duration>; // C++20
	+using sys_seconds = sys_time<seconds>; // C++20
	+using sys_days = sys_time<days>; // C++20
	+
	+class utc_clock; // C++20
	+
	+template <class Duration>
	+ using utc_time = time_point<utc_clock, Duration>; // C++20
	+using utc_seconds = utc_time<seconds>; // C++20
	+
	+class tai_clock; // C++20
	+
	+template <class Duration>
	+ using tai_time = time_point<tai_clock, Duration>; // C++20
	+using tai_seconds = tai_time<seconds>; // C++20
	+
	+class file_clock; // C++20
	+
	+template<class Duration>
	+ using file_time = time_point<file_clock, Duration>; // C++20
	+
	class steady_clock
	{
	public:
	typedef nanoseconds duration;
	typedef duration::rep rep;
	typedef duration::period period;
	typedef chrono::time_point<steady_clock, duration> time_point;
	static const bool is_steady = true; // constexpr in C++14

	static time_point now() noexcept;
	};

	typedef steady_clock high_resolution_clock;

	+// 25.7.8, local time // C++20
	+struct local_t {};
	+template<class Duration>
	+ using local_time = time_point<local_t, Duration>;
	+using local_seconds = local_time<seconds>;
	+using local_days = local_time<days>;
	+
	+// 25.7.9, time_point conversions template<class DestClock, class SourceClock> // C++20
	+struct clock_time_conversion;
	+
	+template<class DestClock, class SourceClock, class Duration>
	+ auto clock_cast(const time_point<SourceClock, Duration>& t);
	+
	+// 25.8.2, class last_spec // C++20
	+struct last_spec;
	+
	+// 25.8.3, class day // C++20
	+
	+class day;
	+constexpr bool operator==(const day& x, const day& y) noexcept;
	+constexpr bool operator!=(const day& x, const day& y) noexcept;
	+constexpr bool operator< (const day& x, const day& y) noexcept;
	+constexpr bool operator> (const day& x, const day& y) noexcept;
	+constexpr bool operator<=(const day& x, const day& y) noexcept;
	+constexpr bool operator>=(const day& x, const day& y) noexcept;
	+constexpr day operator+(const day& x, const days& y) noexcept;
	+constexpr day operator+(const days& x, const day& y) noexcept;
	+constexpr day operator-(const day& x, const days& y) noexcept;
	+constexpr days operator-(const day& x, const day& y) noexcept;
	+
	+// 25.8.4, class month // C++20
	+class month;
	+constexpr bool operator==(const month& x, const month& y) noexcept;
	+constexpr bool operator!=(const month& x, const month& y) noexcept;
	+constexpr bool operator< (const month& x, const month& y) noexcept;
	+constexpr bool operator> (const month& x, const month& y) noexcept;
	+constexpr bool operator<=(const month& x, const month& y) noexcept;
	+constexpr bool operator>=(const month& x, const month& y) noexcept;
	+constexpr month operator+(const month& x, const months& y) noexcept;
	+constexpr month operator+(const months& x, const month& y) noexcept;
	+constexpr month operator-(const month& x, const months& y) noexcept;
	+constexpr months operator-(const month& x, const month& y) noexcept;
	+
	+// 25.8.5, class year // C++20
	+class year;
	+constexpr bool operator==(const year& x, const year& y) noexcept;
	+constexpr bool operator!=(const year& x, const year& y) noexcept;
	+constexpr bool operator< (const year& x, const year& y) noexcept;
	+constexpr bool operator> (const year& x, const year& y) noexcept;
	+constexpr bool operator<=(const year& x, const year& y) noexcept;
	+constexpr bool operator>=(const year& x, const year& y) noexcept;
	+constexpr year operator+(const year& x, const years& y) noexcept;
	+constexpr year operator+(const years& x, const year& y) noexcept;
	+constexpr year operator-(const year& x, const years& y) noexcept;
	+constexpr years operator-(const year& x, const year& y) noexcept;
	+
	+// 25.8.6, class weekday // C++20
	+class weekday;
	+
	+constexpr bool operator==(const weekday& x, const weekday& y) noexcept;
	+constexpr bool operator!=(const weekday& x, const weekday& y) noexcept;
	+constexpr weekday operator+(const weekday& x, const days& y) noexcept;
	+constexpr weekday operator+(const days& x, const weekday& y) noexcept;
	+constexpr weekday operator-(const weekday& x, const days& y) noexcept;
	+constexpr days operator-(const weekday& x, const weekday& y) noexcept;
	+
	+// 25.8.7, class weekday_indexed // C++20
	+
	+class weekday_indexed;
	+constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;
	+constexpr bool operator!=(const weekday_indexed& x, const weekday_indexed& y) noexcept;
	+
	+// 25.8.8, class weekday_last // C++20
	+class weekday_last;
	+
	+constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;
	+constexpr bool operator!=(const weekday_last& x, const weekday_last& y) noexcept;
	+
	+// 25.8.9, class month_day // C++20
	+class month_day;
	+
	+constexpr bool operator==(const month_day& x, const month_day& y) noexcept;
	+constexpr bool operator!=(const month_day& x, const month_day& y) noexcept;
	+constexpr bool operator< (const month_day& x, const month_day& y) noexcept;
	+constexpr bool operator> (const month_day& x, const month_day& y) noexcept;
	+constexpr bool operator<=(const month_day& x, const month_day& y) noexcept;
	+constexpr bool operator>=(const month_day& x, const month_day& y) noexcept;
	+
	+
	+// 25.8.10, class month_day_last // C++20
	+class month_day_last;
	+
	+constexpr bool operator==(const month_day_last& x, const month_day_last& y) noexcept;
	+constexpr bool operator!=(const month_day_last& x, const month_day_last& y) noexcept;
	+constexpr bool operator< (const month_day_last& x, const month_day_last& y) noexcept;
	+constexpr bool operator> (const month_day_last& x, const month_day_last& y) noexcept;
	+constexpr bool operator<=(const month_day_last& x, const month_day_last& y) noexcept;
	+constexpr bool operator>=(const month_day_last& x, const month_day_last& y) noexcept;
	+
	+// 25.8.11, class month_weekday // C++20
	+class month_weekday;
	+
	+constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept;
	+constexpr bool operator!=(const month_weekday& x, const month_weekday& y) noexcept;
	+
	+// 25.8.12, class month_weekday_last // C++20
	+class month_weekday_last;
	+
	+constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept;
	+constexpr bool operator!=(const month_weekday_last& x, const month_weekday_last& y) noexcept;
	+
	+
	+// 25.8.13, class year_month // C++20
	+class year_month;
	+
	+constexpr bool operator==(const year_month& x, const year_month& y) noexcept;
	+constexpr bool operator!=(const year_month& x, const year_month& y) noexcept;
	+constexpr bool operator< (const year_month& x, const year_month& y) noexcept;
	+constexpr bool operator> (const year_month& x, const year_month& y) noexcept;
	+constexpr bool operator<=(const year_month& x, const year_month& y) noexcept;
	+constexpr bool operator>=(const year_month& x, const year_month& y) noexcept;
	+
	+constexpr year_month operator+(const year_month& ym, const months& dm) noexcept;
	+constexpr year_month operator+(const months& dm, const year_month& ym) noexcept;
	+constexpr year_month operator-(const year_month& ym, const months& dm) noexcept;
	+constexpr months operator-(const year_month& x, const year_month& y) noexcept;
	+constexpr year_month operator+(const year_month& ym, const years& dy) noexcept;
	+constexpr year_month operator+(const years& dy, const year_month& ym) noexcept;
	+constexpr year_month operator-(const year_month& ym, const years& dy) noexcept;
	+
	+// 25.8.14, class year_month_day class // C++20
	+year_month_day;
	+
	+constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;
	+constexpr bool operator!=(const year_month_day& x, const year_month_day& y) noexcept;
	+constexpr bool operator< (const year_month_day& x, const year_month_day& y) noexcept;
	+constexpr bool operator> (const year_month_day& x, const year_month_day& y) noexcept;
	+constexpr bool operator<=(const year_month_day& x, const year_month_day& y) noexcept;
	+constexpr bool operator>=(const year_month_day& x, const year_month_day& y) noexcept;
	+
	+constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept;
	+constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept;
	+constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) noexcept;
	+constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept;
	+constexpr year_month_day operator-(const year_month_day& ymd, const months& dm) noexcept;
	+constexpr year_month_day operator-(const year_month_day& ymd, const years& dy) noexcept;
	+
	+
	+// 25.8.15, class year_month_day_last // C++20
	+class year_month_day_last;
	+
	+constexpr bool operator==(const year_month_day_last& x,
	+ const year_month_day_last& y) noexcept;
	+constexpr bool operator!=(const year_month_day_last& x,
	+ const year_month_day_last& y) noexcept;
	+constexpr bool operator< (const year_month_day_last& x,
	+ const year_month_day_last& y) noexcept;
	+constexpr bool operator> (const year_month_day_last& x,
	+ const year_month_day_last& y) noexcept;
	+constexpr bool operator<=(const year_month_day_last& x,
	+ const year_month_day_last& y) noexcept;
	+constexpr bool operator>=(const year_month_day_last& x,
	+ const year_month_day_last& y) noexcept;
	+
	+constexpr year_month_day_last
	+ operator+(const year_month_day_last& ymdl, const months& dm) noexcept;
	+constexpr year_month_day_last
	+ operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
	+constexpr year_month_day_last
	+ operator+(const year_month_day_last& ymdl, const years& dy) noexcept;
	+constexpr year_month_day_last
	+ operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
	+constexpr year_month_day_last
	+ operator-(const year_month_day_last& ymdl, const months& dm) noexcept;
	+constexpr year_month_day_last
	+ operator-(const year_month_day_last& ymdl, const years& dy) noexcept;
	+
	+// 25.8.16, class year_month_weekday // C++20
	+class year_month_weekday;
	+
	+constexpr bool operator==(const year_month_weekday& x,
	+ const year_month_weekday& y) noexcept;
	+constexpr bool operator!=(const year_month_weekday& x,
	+ const year_month_weekday& y) noexcept;
	+
	+constexpr year_month_weekday
	+ operator+(const year_month_weekday& ymwd, const months& dm) noexcept;
	+constexpr year_month_weekday
	+ operator+(const months& dm, const year_month_weekday& ymwd) noexcept;
	+constexpr year_month_weekday
	+ operator+(const year_month_weekday& ymwd, const years& dy) noexcept;
	+constexpr year_month_weekday
	+ operator+(const years& dy, const year_month_weekday& ymwd) noexcept;
	+constexpr year_month_weekday
	+ operator-(const year_month_weekday& ymwd, const months& dm) noexcept;
	+constexpr year_month_weekday
	+ operator-(const year_month_weekday& ymwd, const years& dy) noexcept;
	+
	+// 25.8.17, class year_month_weekday_last // C++20
	+class year_month_weekday_last;
	+
	+constexpr bool operator==(const year_month_weekday_last& x,
	+ const year_month_weekday_last& y) noexcept;
	+constexpr bool operator!=(const year_month_weekday_last& x,
	+ const year_month_weekday_last& y) noexcept;
	+constexpr year_month_weekday_last
	+ operator+(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
	+constexpr year_month_weekday_last
	+ operator+(const months& dm, const year_month_weekday_last& ymwdl) noexcept;
	+constexpr year_month_weekday_last
	+ operator+(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
	+constexpr year_month_weekday_last
	+ operator+(const years& dy, const year_month_weekday_last& ymwdl) noexcept;
	+constexpr year_month_weekday_last
	+ operator-(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
	+constexpr year_month_weekday_last
	+ operator-(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
	+
	+// 25.8.18, civil calendar conventional syntax operators // C++20
	+constexpr year_month
	+ operator/(const year& y, const month& m) noexcept;
	+constexpr year_month
	+ operator/(const year& y, int m) noexcept;
	+constexpr month_day
	+ operator/(const month& m, const day& d) noexcept;
	+constexpr month_day
	+ operator/(const month& m, int d) noexcept;
	+constexpr month_day
	+ operator/(int m, const day& d) noexcept;
	+constexpr month_day
	+ operator/(const day& d, const month& m) noexcept;
	+constexpr month_day
	+ operator/(const day& d, int m) noexcept;
	+constexpr month_day_last
	+ operator/(const month& m, last_spec) noexcept;
	+constexpr month_day_last
	+ operator/(int m, last_spec) noexcept;
	+constexpr month_day_last
	+ operator/(last_spec, const month& m) noexcept;
	+constexpr month_day_last
	+ operator/(last_spec, int m) noexcept;
	+constexpr month_weekday
	+ operator/(const month& m, const weekday_indexed& wdi) noexcept;
	+constexpr month_weekday
	+ operator/(int m, const weekday_indexed& wdi) noexcept;
	+constexpr month_weekday
	+ operator/(const weekday_indexed& wdi, const month& m) noexcept;
	+constexpr month_weekday
	+ operator/(const weekday_indexed& wdi, int m) noexcept;
	+constexpr month_weekday_last
	+ operator/(const month& m, const weekday_last& wdl) noexcept;
	+constexpr month_weekday_last
	+ operator/(int m, const weekday_last& wdl) noexcept;
	+constexpr month_weekday_last
	+ operator/(const weekday_last& wdl, const month& m) noexcept;
	+constexpr month_weekday_last
	+ operator/(const weekday_last& wdl, int m) noexcept;
	+constexpr year_month_day
	+ operator/(const year_month& ym, const day& d) noexcept;
	+constexpr year_month_day
	+ operator/(const year_month& ym, int d) noexcept;
	+constexpr year_month_day
	+ operator/(const year& y, const month_day& md) noexcept;
	+constexpr year_month_day
	+ operator/(int y, const month_day& md) noexcept;
	+constexpr year_month_day
	+ operator/(const month_day& md, const year& y) noexcept;
	+constexpr year_month_day
	+ operator/(const month_day& md, int y) noexcept;
	+constexpr year_month_day_last
	+ operator/(const year_month& ym, last_spec) noexcept;
	+constexpr year_month_day_last
	+ operator/(const year& y, const month_day_last& mdl) noexcept;
	+constexpr year_month_day_last
	+ operator/(int y, const month_day_last& mdl) noexcept;
	+constexpr year_month_day_last
	+ operator/(const month_day_last& mdl, const year& y) noexcept;
	+constexpr year_month_day_last
	+ operator/(const month_day_last& mdl, int y) noexcept;
	+constexpr year_month_weekday
	+ operator/(const year_month& ym, const weekday_indexed& wdi) noexcept;
	+constexpr year_month_weekday
	+ operator/(const year& y, const month_weekday& mwd) noexcept;
	+constexpr year_month_weekday
	+ operator/(int y, const month_weekday& mwd) noexcept;
	+constexpr year_month_weekday
	+ operator/(const month_weekday& mwd, const year& y) noexcept;
	+constexpr year_month_weekday
	+ operator/(const month_weekday& mwd, int y) noexcept;
	+constexpr year_month_weekday_last
	+ operator/(const year_month& ym, const weekday_last& wdl) noexcept;
	+constexpr year_month_weekday_last
	+ operator/(const year& y, const month_weekday_last& mwdl) noexcept;
	+constexpr year_month_weekday_last
	+ operator/(int y, const month_weekday_last& mwdl) noexcept;
	+constexpr year_month_weekday_last
	+ operator/(const month_weekday_last& mwdl, const year& y) noexcept;
	+constexpr year_month_weekday_last
	+ operator/(const month_weekday_last& mwdl, int y) noexcept;
	+
	+// 25.9, class template time_of_day // C++20
	+template<class Duration> class time_of_day;
	+
	+template<> class time_of_day<hours>;
	+template<> class time_of_day<minutes>;
	+template<> class time_of_day<seconds>;
	+template<class Rep, class Period> class time_of_day<duration<Rep, Period>>;
	+
	+// 25.10.2, time zone database // C++20
	+struct tzdb;
	+class tzdb_list;
	+
	+// 25.10.2.3, time zone database access // C++20
	+const tzdb& get_tzdb();
	+tzdb_list& get_tzdb_list();
	+const time_zone* locate_zone(string_view tz_name);
	+const time_zone* current_zone();
	+
	+// 25.10.2.4, remote time zone database support // C++20
	+const tzdb& reload_tzdb();
	+string remote_version();
	+
	+// 25.10.3, exception classes // C++20
	+class nonexistent_local_time;
	+class ambiguous_local_time;
	+
	+// 25.10.4, information classes // C++20
	+struct sys_info;
	+struct local_info;
	+
	+// 25.10.5, class time_zone // C++20
	+enum class choose {earliest, latest};
	+class time_zone;
	+bool operator==(const time_zone& x, const time_zone& y) noexcept;
	+bool operator!=(const time_zone& x, const time_zone& y) noexcept;
	+bool operator<(const time_zone& x, const time_zone& y) noexcept;
	+bool operator>(const time_zone& x, const time_zone& y) noexcept;
	+bool operator<=(const time_zone& x, const time_zone& y) noexcept;
	+bool operator>=(const time_zone& x, const time_zone& y) noexcept;
	+
	+// 25.10.6, class template zoned_traits // C++20
	+template<class T> struct zoned_traits;
	+
	+// 25.10.7, class template zoned_time // C++20
	+template<class Duration, class TimeZonePtr = const time_zone*> class zoned_time;
	+using zoned_seconds = zoned_time<seconds>;
	+
	+template<class Duration1, class Duration2, class TimeZonePtr>
	+ bool operator==(const zoned_time<Duration1, TimeZonePtr>& x,
	+ const zoned_time<Duration2, TimeZonePtr>& y);
	+template<class Duration1, class Duration2, class TimeZonePtr>
	+ bool operator!=(const zoned_time<Duration1, TimeZonePtr>& x,
	+ const zoned_time<Duration2, TimeZonePtr>& y);
	+
	+// 25.10.8, leap second support // C++20
	+class leap;
	+
	+bool operator==(const leap& x, const leap& y);
	+bool operator!=(const leap& x, const leap& y);
	+bool operator< (const leap& x, const leap& y);
	+bool operator> (const leap& x, const leap& y);
	+bool operator<=(const leap& x, const leap& y);
	+bool operator>=(const leap& x, const leap& y);
	+template<class Duration>
	+ bool operator==(const leap& x, const sys_time<Duration>& y);
	+template<class Duration>
	+ bool operator==(const sys_time<Duration>& x, const leap& y);
	+template<class Duration>
	+ bool operator!=(const leap& x, const sys_time<Duration>& y);
	+template<class Duration>
	+ bool operator!=(const sys_time<Duration>& x, const leap& y);
	+template<class Duration>
	+ bool operator< (const leap& x, const sys_time<Duration>& y);
	+template<class Duration>
	+ bool operator< (const sys_time<Duration>& x, const leap& y);
	+template<class Duration>
	+ bool operator> (const leap& x, const sys_time<Duration>& y);
	+template<class Duration>
	+ bool operator> (const sys_time<Duration>& x, const leap& y);
	+template<class Duration>
	+ bool operator<=(const leap& x, const sys_time<Duration>& y);
	+template<class Duration>
	+ bool operator<=(const sys_time<Duration>& x, const leap& y);
	+template<class Duration>
	+ bool operator>=(const leap& x, const sys_time<Duration>& y);
	+template<class Duration>
	+ bool operator>=(const sys_time<Duration>& x, const leap& y);
	+
	+// 25.10.9, class link // C++20
	+class link;
	+bool operator==(const link& x, const link& y);
	+bool operator!=(const link& x, const link& y);
	+bool operator< (const link& x, const link& y);
	+bool operator> (const link& x, const link& y);
	+bool operator<=(const link& x, const link& y);
	+bool operator>=(const link& x, const link& y);
	+
	+// 25.11, formatting // C++20
	+template<class charT, class Streamable>
	+ basic_string<charT>
	+ format(const charT* fmt, const Streamable& s);
	+
	+template<class charT, class Streamable>
	+ basic_string<charT>
	+ format(const locale& loc, const charT* fmt, const Streamable& s);
	+
	+template<class charT, class traits, class Alloc, class Streamable>
	+ basic_string<charT, traits, Alloc>
	+ format(const basic_string<charT, traits, Alloc>& fmt, const Streamable& s);
	+
	+template<class charT, class traits, class Alloc, class Streamable>
	+ basic_string<charT, traits, Alloc>
	+ format(const locale& loc, const basic_string<charT, traits, Alloc>& fmt,
	+ const Streamable& s);
	+
	+// 25.12, parsing // C++20
	+template<class charT, class traits, class Alloc, class Parsable>
	+unspecified
	+ parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp);
	+
	+template<class charT, class traits, class Alloc, class Parsable>
	+unspecified
	+ parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp,
	+ basic_string<charT, traits, Alloc>& abbrev);
	+
	+template<class charT, class traits, class Alloc, class Parsable>
	+unspecified
	+ parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp,
	+ minutes& offset);
	+
	+template<class charT, class traits, class Alloc, class Parsable>
	+unspecified
	+ parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp,
	+ basic_string<charT, traits, Alloc>& abbrev, minutes& offset);
	+
	+inline constexpr last_spec last{}; // C++20
	+inline constexpr chrono::weekday Sunday{0}; // C++20
	+inline constexpr chrono::weekday Monday{1}; // C++20
	+inline constexpr chrono::weekday Tuesday{2}; // C++20
	+inline constexpr chrono::weekday Wednesday{3}; // C++20
	+inline constexpr chrono::weekday Thursday{4}; // C++20
	+inline constexpr chrono::weekday Friday{5}; // C++20
	+inline constexpr chrono::weekday Saturday{6}; // C++20
	+
	+inline constexpr chrono::month January{1}; // C++20
	+inline constexpr chrono::month February{2}; // C++20
	+inline constexpr chrono::month March{3}; // C++20
	+inline constexpr chrono::month April{4}; // C++20
	+inline constexpr chrono::month May{5}; // C++20
	+inline constexpr chrono::month June{6}; // C++20
	+inline constexpr chrono::month July{7}; // C++20
	+inline constexpr chrono::month August{8}; // C++20
	+inline constexpr chrono::month September{9}; // C++20
	+inline constexpr chrono::month October{10}; // C++20
	+inline constexpr chrono::month November{11}; // C++20
	+inline constexpr chrono::month December{12}; // C++20
	} // chrono

	+inline namespace literals {
	+ inline namespace chrono_literals {
	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::day operator ""d(unsigned long long d) noexcept; // C++20
	+constexpr chrono::year operator ""y(unsigned long long y) noexcept; // C++20
	+} // chrono_literals
	+} // literals

	} // std
	*/

	#include <__config>
	#include <ctime>
	#include <type_traits>
	#include <ratio>
	#include <limits>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_STD

	namespace chrono
	{

	template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TEMPLATE_VIS duration;

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

	template <class _Rep, class _Period>
	struct __is_duration<duration<_Rep, _Period> > : true_type {};

	template <class _Rep, class _Period>
	struct __is_duration<const duration<_Rep, _Period> > : true_type {};

	template <class _Rep, class _Period>
	struct __is_duration<volatile duration<_Rep, _Period> > : true_type {};

	template <class _Rep, class _Period>
	struct __is_duration<const volatile duration<_Rep, _Period> > : true_type {};

	} // chrono

	template <class _Rep1, class _Period1, class _Rep2, class _Period2>
	struct _LIBCPP_TEMPLATE_VIS common_type<chrono::duration<_Rep1, _Period1>,
	chrono::duration<_Rep2, _Period2> >
	{
	typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
	typename __ratio_gcd<_Period1, _Period2>::type> type;
	};

	namespace chrono {

	// duration_cast

	template <class _FromDuration, class _ToDuration,
	class _Period = typename ratio_divide<typename _FromDuration::period, typename _ToDuration::period>::type,
	bool = _Period::num == 1,
	bool = _Period::den == 1>
	struct __duration_cast;

	template <class _FromDuration, class _ToDuration, class _Period>
	struct __duration_cast<_FromDuration, _ToDuration, _Period, true, true>
	{
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	_ToDuration operator()(const _FromDuration& __fd) const
	{
	return _ToDuration(static_cast<typename _ToDuration::rep>(__fd.count()));
	}
	};

	template <class _FromDuration, class _ToDuration, class _Period>
	struct __duration_cast<_FromDuration, _ToDuration, _Period, true, false>
	{
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	_ToDuration operator()(const _FromDuration& __fd) const
	{
	typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
	return _ToDuration(static_cast<typename _ToDuration::rep>(
	static_cast<_Ct>(__fd.count()) / static_cast<_Ct>(_Period::den)));
	}
	};

	template <class _FromDuration, class _ToDuration, class _Period>
	struct __duration_cast<_FromDuration, _ToDuration, _Period, false, true>
	{
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	_ToDuration operator()(const _FromDuration& __fd) const
	{
	typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
	return _ToDuration(static_cast<typename _ToDuration::rep>(
	static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)));
	}
	};

	template <class _FromDuration, class _ToDuration, class _Period>
	struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false>
	{
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	_ToDuration operator()(const _FromDuration& __fd) const
	{
	typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
	return _ToDuration(static_cast<typename _ToDuration::rep>(
	static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)
	/ static_cast<_Ct>(_Period::den)));
	}
	};

	template <class _ToDuration, class _Rep, class _Period>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	typename enable_if
	<
	__is_duration<_ToDuration>::value,
	_ToDuration
	>::type
	duration_cast(const duration<_Rep, _Period>& __fd)
	{
	return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
	}

	template <class _Rep>
	struct _LIBCPP_TEMPLATE_VIS treat_as_floating_point : is_floating_point<_Rep> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Rep>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool treat_as_floating_point_v
	= treat_as_floating_point<_Rep>::value;
	#endif

	template <class _Rep>
	struct _LIBCPP_TEMPLATE_VIS duration_values
	{
	public:
	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() {return _Rep(0);}
	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max() {return numeric_limits<_Rep>::max();}
	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min() {return numeric_limits<_Rep>::lowest();}
	};

	#if _LIBCPP_STD_VER > 14
	template <class _ToDuration, class _Rep, class _Period>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	typename enable_if
	<
	__is_duration<_ToDuration>::value,
	_ToDuration
	>::type
	floor(const duration<_Rep, _Period>& __d)
	{
	_ToDuration __t = duration_cast<_ToDuration>(__d);
	if (__t > __d)
	__t = __t - _ToDuration{1};
	return __t;
	}

	template <class _ToDuration, class _Rep, class _Period>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	typename enable_if
	<
	__is_duration<_ToDuration>::value,
	_ToDuration
	>::type
	ceil(const duration<_Rep, _Period>& __d)
	{
	_ToDuration __t = duration_cast<_ToDuration>(__d);
	if (__t < __d)
	__t = __t + _ToDuration{1};
	return __t;
	}

	template <class _ToDuration, class _Rep, class _Period>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	typename enable_if
	<
	__is_duration<_ToDuration>::value,
	_ToDuration
	>::type
	round(const duration<_Rep, _Period>& __d)
	{
	_ToDuration __lower = floor<_ToDuration>(__d);
	_ToDuration __upper = __lower + _ToDuration{1};
	auto __lowerDiff = __d - __lower;
	auto __upperDiff = __upper - __d;
	if (__lowerDiff < __upperDiff)
	return __lower;
	if (__lowerDiff > __upperDiff)
	return __upper;
	return __lower.count() & 1 ? __upper : __lower;
	}
	#endif

	// duration

	template <class _Rep, class _Period>
	class _LIBCPP_TEMPLATE_VIS duration
	{
	static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration");
	static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio");
	static_assert(_Period::num > 0, "duration period must be positive");

	template <class _R1, class _R2>
	struct __no_overflow
	{
	private:
	static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
	static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
	static const intmax_t __n1 = _R1::num / __gcd_n1_n2;
	static const intmax_t __d1 = _R1::den / __gcd_d1_d2;
	static const intmax_t __n2 = _R2::num / __gcd_n1_n2;
	static const intmax_t __d2 = _R2::den / __gcd_d1_d2;
	static const intmax_t max = -((intmax_t(1) << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1);

	template <intmax_t _Xp, intmax_t _Yp, bool __overflow>
	struct __mul // __overflow == false
	{
	static const intmax_t value = _Xp * _Yp;
	};

	template <intmax_t _Xp, intmax_t _Yp>
	struct __mul<_Xp, _Yp, true>
	{
	static const intmax_t value = 1;
	};

	public:
	static const bool value = (__n1 <= max / __d2) && (__n2 <= max / __d1);
	typedef ratio<__mul<__n1, __d2, !value>::value,
	__mul<__n2, __d1, !value>::value> type;
	};

	public:
	typedef _Rep rep;
	typedef typename _Period::type period;
	private:
	rep __rep_;
	public:

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	#ifndef _LIBCPP_CXX03_LANG
	duration() = default;
	#else
	duration() {}
	#endif

	template <class _Rep2>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	explicit duration(const _Rep2& __r,
	typename enable_if
	<
	is_convertible<_Rep2, rep>::value &&
	(treat_as_floating_point<rep>::value \|\|
	!treat_as_floating_point<_Rep2>::value)
	>::type* = 0)
	: __rep_(__r) {}

	// conversions
	template <class _Rep2, class _Period2>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	duration(const duration<_Rep2, _Period2>& __d,
	typename enable_if
	<
	__no_overflow<_Period2, period>::value && (
	treat_as_floating_point<rep>::value \|\|
	(__no_overflow<_Period2, period>::type::den == 1 &&
	!treat_as_floating_point<_Rep2>::value))
	>::type* = 0)
	: __rep_(_VSTD::chrono::duration_cast<duration>(__d).count()) {}

	// observer

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;}

	// arithmetic

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator++() {++__rep_; return *this;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration operator++(int) {return duration(__rep_++);}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator--() {--__rep_; return *this;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration operator--(int) {return duration(__rep_--);}

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;}

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator=(const rep& rhs) {__rep_ = rhs; return *this;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator/=(const rep& rhs) {__rep_ /= rhs; return *this;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const rep& rhs) {__rep_ %= rhs; return *this;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const duration& rhs) {__rep_ %= rhs.count(); return *this;}

	// special values

	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() {return duration(duration_values<rep>::zero());}
	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min() {return duration(duration_values<rep>::min());}
	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max() {return duration(duration_values<rep>::max());}
	};

	typedef duration<long long, nano> nanoseconds;
	typedef duration<long long, micro> microseconds;
	typedef duration<long long, milli> milliseconds;
	typedef duration<long long > seconds;
	typedef duration< long, ratio< 60> > minutes;
	typedef duration< long, ratio<3600> > hours;

	// Duration ==

	template <class _LhsDuration, class _RhsDuration>
	struct __duration_eq
	{
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
	{
	typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
	return _Ct(__lhs).count() == _Ct(__rhs).count();
	}
	};

	template <class _LhsDuration>
	struct __duration_eq<_LhsDuration, _LhsDuration>
	{
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
	{return __lhs.count() == __rhs.count();}
	};

	template <class _Rep1, class _Period1, class _Rep2, class _Period2>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	bool
	operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
	{
	return __duration_eq<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
	}

	// Duration !=

	template <class _Rep1, class _Period1, class _Rep2, class _Period2>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	bool
	operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
	{
	return !(__lhs == __rhs);
	}

	// Duration <

	template <class _LhsDuration, class _RhsDuration>
	struct __duration_lt
	{
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
	{
	typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
	return _Ct(__lhs).count() < _Ct(__rhs).count();
	}
	};

	template <class _LhsDuration>
	struct __duration_lt<_LhsDuration, _LhsDuration>
	{
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
	{return __lhs.count() < __rhs.count();}
	};

	template <class _Rep1, class _Period1, class _Rep2, class _Period2>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	bool
	operator< (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
	{
	return __duration_lt<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
	}

	// Duration >

	template <class _Rep1, class _Period1, class _Rep2, class _Period2>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	bool
	operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
	{
	return __rhs < __lhs;
	}

	// Duration <=

	template <class _Rep1, class _Period1, class _Rep2, class _Period2>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	bool
	operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
	{
	return !(__rhs < __lhs);
	}

	// Duration >=

	template <class _Rep1, class _Period1, class _Rep2, class _Period2>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	bool
	operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
	{
	return !(__lhs < __rhs);
	}

	// Duration +

	template <class _Rep1, class _Period1, class _Rep2, class _Period2>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
	operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
	{
	typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
	return _Cd(_Cd(__lhs).count() + _Cd(__rhs).count());
	}

	// Duration -

	template <class _Rep1, class _Period1, class _Rep2, class _Period2>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
	operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
	{
	typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
	return _Cd(_Cd(__lhs).count() - _Cd(__rhs).count());
	}

	// Duration *

	template <class _Rep1, class _Period, class _Rep2>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	typename enable_if
	<
	is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
	duration<typename common_type<_Rep1, _Rep2>::type, _Period>
	>::type
	operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
	{
	typedef typename common_type<_Rep1, _Rep2>::type _Cr;
	typedef duration<_Cr, _Period> _Cd;
	return _Cd(_Cd(__d).count() * static_cast<_Cr>(__s));
	}

	template <class _Rep1, class _Period, class _Rep2>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	typename enable_if
	<
	is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value,
	duration<typename common_type<_Rep1, _Rep2>::type, _Period>
	>::type
	operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
	{
	return __d * __s;
	}

	// Duration /

	template <class _Duration, class _Rep, bool = __is_duration<_Rep>::value>
	struct __duration_divide_result
	{
	};

	template <class _Duration, class _Rep2,
	bool = is_convertible<_Rep2,
	typename common_type<typename _Duration::rep, _Rep2>::type>::value>
	struct __duration_divide_imp
	{
	};

	template <class _Rep1, class _Period, class _Rep2>
	struct __duration_divide_imp<duration<_Rep1, _Period>, _Rep2, true>
	{
	typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> type;
	};

	template <class _Rep1, class _Period, class _Rep2>
	struct __duration_divide_result<duration<_Rep1, _Period>, _Rep2, false>
	: __duration_divide_imp<duration<_Rep1, _Period>, _Rep2>
	{
	};

	template <class _Rep1, class _Period, class _Rep2>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
	operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
	{
	typedef typename common_type<_Rep1, _Rep2>::type _Cr;
	typedef duration<_Cr, _Period> _Cd;
	return _Cd(_Cd(__d).count() / static_cast<_Cr>(__s));
	}

	template <class _Rep1, class _Period1, class _Rep2, class _Period2>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	typename common_type<_Rep1, _Rep2>::type
	operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
	{
	typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct;
	return _Ct(__lhs).count() / _Ct(__rhs).count();
	}

	// Duration %

	template <class _Rep1, class _Period, class _Rep2>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
	operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
	{
	typedef typename common_type<_Rep1, _Rep2>::type _Cr;
	typedef duration<_Cr, _Period> _Cd;
	return _Cd(_Cd(__d).count() % static_cast<_Cr>(__s));
	}

	template <class _Rep1, class _Period1, class _Rep2, class _Period2>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
	operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
	{
	typedef typename common_type<_Rep1, _Rep2>::type _Cr;
	typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
	return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count()));
	}

	//////////////////////////////////////////////////////////
	///////////////////// time_point /////////////////////////
	//////////////////////////////////////////////////////////

	template <class _Clock, class _Duration = typename _Clock::duration>
	class _LIBCPP_TEMPLATE_VIS time_point
	{
	static_assert(__is_duration<_Duration>::value,
	"Second template parameter of time_point must be a std::chrono::duration");
	public:
	typedef _Clock clock;
	typedef _Duration duration;
	typedef typename duration::rep rep;
	typedef typename duration::period period;
	private:
	duration __d_;

	public:
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 time_point() : __d_(duration::zero()) {}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit time_point(const duration& __d) : __d_(__d) {}

	// conversions
	template <class _Duration2>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	time_point(const time_point<clock, _Duration2>& t,
	typename enable_if
	<
	is_convertible<_Duration2, duration>::value
	>::type* = 0)
	: __d_(t.time_since_epoch()) {}

	// observer

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 duration time_since_epoch() const {return __d_;}

	// arithmetic

	_LIBCPP_INLINE_VISIBILITY time_point& operator+=(const duration& __d) {__d_ += __d; return *this;}
	_LIBCPP_INLINE_VISIBILITY time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;}

	// special values

	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() {return time_point(duration::min());}
	_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point max() {return time_point(duration::max());}
	};

	} // chrono

	template <class _Clock, class _Duration1, class _Duration2>
	struct _LIBCPP_TEMPLATE_VIS common_type<chrono::time_point<_Clock, _Duration1>,
	chrono::time_point<_Clock, _Duration2> >
	{
	typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type;
	};

	namespace chrono {

	template <class _ToDuration, class _Clock, class _Duration>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	time_point<_Clock, _ToDuration>
	time_point_cast(const time_point<_Clock, _Duration>& __t)
	{
	return time_point<_Clock, _ToDuration>(_VSTD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
	}

	#if _LIBCPP_STD_VER > 14
	template <class _ToDuration, class _Clock, class _Duration>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	typename enable_if
	<
	__is_duration<_ToDuration>::value,
	time_point<_Clock, _ToDuration>
	>::type
	floor(const time_point<_Clock, _Duration>& __t)
	{
	return time_point<_Clock, _ToDuration>{floor<_ToDuration>(__t.time_since_epoch())};
	}

	template <class _ToDuration, class _Clock, class _Duration>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	typename enable_if
	<
	__is_duration<_ToDuration>::value,
	time_point<_Clock, _ToDuration>
	>::type
	ceil(const time_point<_Clock, _Duration>& __t)
	{
	return time_point<_Clock, _ToDuration>{ceil<_ToDuration>(__t.time_since_epoch())};
	}

	template <class _ToDuration, class _Clock, class _Duration>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	typename enable_if
	<
	__is_duration<_ToDuration>::value,
	time_point<_Clock, _ToDuration>
	>::type
	round(const time_point<_Clock, _Duration>& __t)
	{
	return time_point<_Clock, _ToDuration>{round<_ToDuration>(__t.time_since_epoch())};
	}

	template <class _Rep, class _Period>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	typename enable_if
	<
	numeric_limits<_Rep>::is_signed,
	duration<_Rep, _Period>
	>::type
	abs(duration<_Rep, _Period> __d)
	{
	return __d >= __d.zero() ? __d : -__d;
	}
	#endif

	// time_point ==

	template <class _Clock, class _Duration1, class _Duration2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
	{
	return __lhs.time_since_epoch() == __rhs.time_since_epoch();
	}

	// time_point !=

	template <class _Clock, class _Duration1, class _Duration2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
	{
	return !(__lhs == __rhs);
	}

	// time_point <

	template <class _Clock, class _Duration1, class _Duration2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator<(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
	{
	return __lhs.time_since_epoch() < __rhs.time_since_epoch();
	}

	// time_point >

	template <class _Clock, class _Duration1, class _Duration2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
	{
	return __rhs < __lhs;
	}

	// time_point <=

	template <class _Clock, class _Duration1, class _Duration2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator<=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
	{
	return !(__rhs < __lhs);
	}

	// time_point >=

	template <class _Clock, class _Duration1, class _Duration2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
	{
	return !(__lhs < __rhs);
	}

	// time_point operator+(time_point x, duration y);

	template <class _Clock, class _Duration1, class _Rep2, class _Period2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
	operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
	{
	typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr;
	return _Tr (__lhs.time_since_epoch() + __rhs);
	}

	// time_point operator+(duration x, time_point y);

	template <class _Rep1, class _Period1, class _Clock, class _Duration2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	time_point<_Clock, typename common_type<duration<_Rep1, _Period1>, _Duration2>::type>
	operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
	{
	return __rhs + __lhs;
	}

	// time_point operator-(time_point x, duration y);

	template <class _Clock, class _Duration1, class _Rep2, class _Period2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
	operator-(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
	{
	typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Ret;
	return _Ret(__lhs.time_since_epoch() -__rhs);
	}

	// duration operator-(time_point x, time_point y);

	template <class _Clock, class _Duration1, class _Duration2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	typename common_type<_Duration1, _Duration2>::type
	operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
	{
	return __lhs.time_since_epoch() - __rhs.time_since_epoch();
	}

	//////////////////////////////////////////////////////////
	/////////////////////// clocks ///////////////////////////
	//////////////////////////////////////////////////////////

	class _LIBCPP_TYPE_VIS system_clock
	{
	public:
	typedef microseconds duration;
	typedef duration::rep rep;
	typedef duration::period period;
	typedef chrono::time_point<system_clock> time_point;
	static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false;

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

	#ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
	class _LIBCPP_TYPE_VIS steady_clock
	{
	public:
	typedef nanoseconds duration;
	typedef duration::rep rep;
	typedef duration::period period;
	typedef chrono::time_point<steady_clock, duration> time_point;
	static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = true;

	static time_point now() _NOEXCEPT;
	};

	typedef steady_clock high_resolution_clock;
	#else
	typedef system_clock high_resolution_clock;
	#endif

	} // chrono

	#if _LIBCPP_STD_VER > 11
	// Suffixes for duration literals [time.duration.literals]
	inline namespace literals
	{
	inline namespace chrono_literals
	{

	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)
	{
	return chrono::duration<long double, ratio<3600,1>>(__h);
	}


	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)
	{
	return chrono::duration<long double, ratio<60,1>> (__m);
	}


	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)
	{
	return chrono::duration<long double> (__s);
	}


	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)
	{
	return chrono::duration<long double, milli>(__ms);
	}


	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)
	{
	return chrono::duration<long double, micro> (__us);
	}


	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)
	{
	return chrono::duration<long double, nano> (__ns);
	}

	}}

	namespace chrono { // hoist the literals into namespace std::chrono
	using namespace literals::chrono_literals;
	}

	#endif

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_CHRONO
	Index: projects/clang700-import/contrib/libc++/include/cmath
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/cmath (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/cmath (revision 337135)
	@@ -1,611 +1,611 @@
	// -- C++ --
	//===---------------------------- cmath -----------------------------------===//
	//
	// 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_CMATH
	#define _LIBCPP_CMATH

	/*
	cmath synopsis

	Macros:

	HUGE_VAL
	HUGE_VALF // C99
	HUGE_VALL // C99
	INFINITY // C99
	NAN // C99
	FP_INFINITE // C99
	FP_NAN // C99
	FP_NORMAL // C99
	FP_SUBNORMAL // C99
	FP_ZERO // C99
	FP_FAST_FMA // C99
	FP_FAST_FMAF // C99
	FP_FAST_FMAL // C99
	FP_ILOGB0 // C99
	FP_ILOGBNAN // C99
	MATH_ERRNO // C99
	MATH_ERREXCEPT // C99
	math_errhandling // C99

	namespace std
	{

	Types:

	float_t // C99
	double_t // C99

	// C90

	floating_point abs(floating_point x);

	floating_point acos (arithmetic x);
	float acosf(float x);
	long double acosl(long double x);

	floating_point asin (arithmetic x);
	float asinf(float x);
	long double asinl(long double x);

	floating_point atan (arithmetic x);
	float atanf(float x);
	long double atanl(long double x);

	floating_point atan2 (arithmetic y, arithmetic x);
	float atan2f(float y, float x);
	long double atan2l(long double y, long double x);

	floating_point ceil (arithmetic x);
	float ceilf(float x);
	long double ceill(long double x);

	floating_point cos (arithmetic x);
	float cosf(float x);
	long double cosl(long double x);

	floating_point cosh (arithmetic x);
	float coshf(float x);
	long double coshl(long double x);

	floating_point exp (arithmetic x);
	float expf(float x);
	long double expl(long double x);

	floating_point fabs (arithmetic x);
	float fabsf(float x);
	long double fabsl(long double x);

	floating_point floor (arithmetic x);
	float floorf(float x);
	long double floorl(long double x);

	floating_point fmod (arithmetic x, arithmetic y);
	float fmodf(float x, float y);
	long double fmodl(long double x, long double y);

	floating_point frexp (arithmetic value, int* exp);
	float frexpf(float value, int* exp);
	long double frexpl(long double value, int* exp);

	floating_point ldexp (arithmetic value, int exp);
	float ldexpf(float value, int exp);
	long double ldexpl(long double value, int exp);

	floating_point log (arithmetic x);
	float logf(float x);
	long double logl(long double x);

	floating_point log10 (arithmetic x);
	float log10f(float x);
	long double log10l(long double x);

	floating_point modf (floating_point value, floating_point* iptr);
	float modff(float value, float* iptr);
	long double modfl(long double value, long double* iptr);

	floating_point pow (arithmetic x, arithmetic y);
	float powf(float x, float y);
	long double powl(long double x, long double y);

	floating_point sin (arithmetic x);
	float sinf(float x);
	long double sinl(long double x);

	floating_point sinh (arithmetic x);
	float sinhf(float x);
	long double sinhl(long double x);

	floating_point sqrt (arithmetic x);
	float sqrtf(float x);
	long double sqrtl(long double x);

	floating_point tan (arithmetic x);
	float tanf(float x);
	long double tanl(long double x);

	floating_point tanh (arithmetic x);
	float tanhf(float x);
	long double tanhl(long double x);

	// C99

	bool signbit(arithmetic x);

	int fpclassify(arithmetic x);

	bool isfinite(arithmetic x);
	bool isinf(arithmetic x);
	bool isnan(arithmetic x);
	bool isnormal(arithmetic x);

	bool isgreater(arithmetic x, arithmetic y);
	bool isgreaterequal(arithmetic x, arithmetic y);
	bool isless(arithmetic x, arithmetic y);
	bool islessequal(arithmetic x, arithmetic y);
	bool islessgreater(arithmetic x, arithmetic y);
	bool isunordered(arithmetic x, arithmetic y);

	floating_point acosh (arithmetic x);
	float acoshf(float x);
	long double acoshl(long double x);

	floating_point asinh (arithmetic x);
	float asinhf(float x);
	long double asinhl(long double x);

	floating_point atanh (arithmetic x);
	float atanhf(float x);
	long double atanhl(long double x);

	floating_point cbrt (arithmetic x);
	float cbrtf(float x);
	long double cbrtl(long double x);

	floating_point copysign (arithmetic x, arithmetic y);
	float copysignf(float x, float y);
	long double copysignl(long double x, long double y);

	floating_point erf (arithmetic x);
	float erff(float x);
	long double erfl(long double x);

	floating_point erfc (arithmetic x);
	float erfcf(float x);
	long double erfcl(long double x);

	floating_point exp2 (arithmetic x);
	float exp2f(float x);
	long double exp2l(long double x);

	floating_point expm1 (arithmetic x);
	float expm1f(float x);
	long double expm1l(long double x);

	floating_point fdim (arithmetic x, arithmetic y);
	float fdimf(float x, float y);
	long double fdiml(long double x, long double y);

	floating_point fma (arithmetic x, arithmetic y, arithmetic z);
	float fmaf(float x, float y, float z);
	long double fmal(long double x, long double y, long double z);

	floating_point fmax (arithmetic x, arithmetic y);
	float fmaxf(float x, float y);
	long double fmaxl(long double x, long double y);

	floating_point fmin (arithmetic x, arithmetic y);
	float fminf(float x, float y);
	long double fminl(long double x, long double y);

	floating_point hypot (arithmetic x, arithmetic y);
	float hypotf(float x, float y);
	long double hypotl(long double x, long double y);

	double hypot(double x, double y, double z); // C++17
	float hypot(float x, float y, float z); // C++17
	long double hypot(long double x, long double y, long double z); // C++17

	int ilogb (arithmetic x);
	int ilogbf(float x);
	int ilogbl(long double x);

	floating_point lgamma (arithmetic x);
	float lgammaf(float x);
	long double lgammal(long double x);

	long long llrint (arithmetic x);
	long long llrintf(float x);
	long long llrintl(long double x);

	long long llround (arithmetic x);
	long long llroundf(float x);
	long long llroundl(long double x);

	floating_point log1p (arithmetic x);
	float log1pf(float x);
	long double log1pl(long double x);

	floating_point log2 (arithmetic x);
	float log2f(float x);
	long double log2l(long double x);

	floating_point logb (arithmetic x);
	float logbf(float x);
	long double logbl(long double x);

	long lrint (arithmetic x);
	long lrintf(float x);
	long lrintl(long double x);

	long lround (arithmetic x);
	long lroundf(float x);
	long lroundl(long double x);

	double nan (const char* str);
	float nanf(const char* str);
	long double nanl(const char* str);

	floating_point nearbyint (arithmetic x);
	float nearbyintf(float x);
	long double nearbyintl(long double x);

	floating_point nextafter (arithmetic x, arithmetic y);
	float nextafterf(float x, float y);
	long double nextafterl(long double x, long double y);

	floating_point nexttoward (arithmetic x, long double y);
	float nexttowardf(float x, long double y);
	long double nexttowardl(long double x, long double y);

	floating_point remainder (arithmetic x, arithmetic y);
	float remainderf(float x, float y);
	long double remainderl(long double x, long double y);

	floating_point remquo (arithmetic x, arithmetic y, int* pquo);
	float remquof(float x, float y, int* pquo);
	long double remquol(long double x, long double y, int* pquo);

	floating_point rint (arithmetic x);
	float rintf(float x);
	long double rintl(long double x);

	floating_point round (arithmetic x);
	float roundf(float x);
	long double roundl(long double x);

	floating_point scalbln (arithmetic x, long ex);
	float scalblnf(float x, long ex);
	long double scalblnl(long double x, long ex);

	floating_point scalbn (arithmetic x, int ex);
	float scalbnf(float x, int ex);
	long double scalbnl(long double x, int ex);

	floating_point tgamma (arithmetic x);
	float tgammaf(float x);
	long double tgammal(long double x);

	floating_point trunc (arithmetic x);
	float truncf(float x);
	long double truncl(long double x);

	} // std

	*/

	#include <__config>
	#include <math.h>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	using ::signbit;
	using ::fpclassify;
	using ::isfinite;
	using ::isinf;
	using ::isnan;
	using ::isnormal;
	using ::isgreater;
	using ::isgreaterequal;
	using ::isless;
	using ::islessequal;
	using ::islessgreater;
	using ::isunordered;
	using ::isunordered;

	using ::float_t;
	using ::double_t;

	#ifndef _AIX
	using ::abs;
	#endif

	using ::acos;
	using ::acosf;
	using ::asin;
	using ::asinf;
	using ::atan;
	using ::atanf;
	using ::atan2;
	using ::atan2f;
	using ::ceil;
	using ::ceilf;
	using ::cos;
	using ::cosf;
	using ::cosh;
	using ::coshf;

	using ::exp;
	using ::expf;

	using ::fabs;
	using ::fabsf;
	using ::floor;
	using ::floorf;

	using ::fmod;
	using ::fmodf;

	using ::frexp;
	using ::frexpf;
	using ::ldexp;
	using ::ldexpf;

	using ::log;
	using ::logf;

	using ::log10;
	using ::log10f;
	using ::modf;
	using ::modff;

	using ::pow;
	using ::powf;

	using ::sin;
	using ::sinf;
	using ::sinh;
	using ::sinhf;

	using ::sqrt;
	using ::sqrtf;
	using ::tan;
	using ::tanf;

	using ::tanh;
	using ::tanhf;

	using ::acosh;
	using ::acoshf;
	using ::asinh;
	using ::asinhf;
	using ::atanh;
	using ::atanhf;
	using ::cbrt;
	using ::cbrtf;

	using ::copysign;
	using ::copysignf;

	using ::erf;
	using ::erff;
	using ::erfc;
	using ::erfcf;
	using ::exp2;
	using ::exp2f;
	using ::expm1;
	using ::expm1f;
	using ::fdim;
	using ::fdimf;
	using ::fmaf;
	using ::fma;
	using ::fmax;
	using ::fmaxf;
	using ::fmin;
	using ::fminf;
	using ::hypot;
	using ::hypotf;
	using ::ilogb;
	using ::ilogbf;
	using ::lgamma;
	using ::lgammaf;
	using ::llrint;
	using ::llrintf;
	using ::llround;
	using ::llroundf;
	using ::log1p;
	using ::log1pf;
	using ::log2;
	using ::log2f;
	using ::logb;
	using ::logbf;
	using ::lrint;
	using ::lrintf;
	using ::lround;
	using ::lroundf;

	using ::nan;
	using ::nanf;

	using ::nearbyint;
	using ::nearbyintf;
	using ::nextafter;
	using ::nextafterf;
	using ::nexttoward;
	using ::nexttowardf;
	using ::remainder;
	using ::remainderf;
	using ::remquo;
	using ::remquof;
	using ::rint;
	using ::rintf;
	using ::round;
	using ::roundf;
	using ::scalbln;
	using ::scalblnf;
	using ::scalbn;
	using ::scalbnf;
	using ::tgamma;
	using ::tgammaf;
	using ::trunc;
	using ::truncf;

	using ::acosl;
	using ::asinl;
	using ::atanl;
	using ::atan2l;
	using ::ceill;
	using ::cosl;
	using ::coshl;
	using ::expl;
	using ::fabsl;
	using ::floorl;
	using ::fmodl;
	using ::frexpl;
	using ::ldexpl;
	using ::logl;
	using ::log10l;
	using ::modfl;
	using ::powl;
	using ::sinl;
	using ::sinhl;
	using ::sqrtl;
	using ::tanl;

	using ::tanhl;
	using ::acoshl;
	using ::asinhl;
	using ::atanhl;
	using ::cbrtl;

	using ::copysignl;

	using ::erfl;
	using ::erfcl;
	using ::exp2l;
	using ::expm1l;
	using ::fdiml;
	using ::fmal;
	using ::fmaxl;
	using ::fminl;
	using ::hypotl;
	using ::ilogbl;
	using ::lgammal;
	using ::llrintl;
	using ::llroundl;
	using ::log1pl;
	using ::log2l;
	using ::logbl;
	using ::lrintl;
	using ::lroundl;
	using ::nanl;
	using ::nearbyintl;
	using ::nextafterl;
	using ::nexttowardl;
	using ::remainderl;
	using ::remquol;
	using ::rintl;
	using ::roundl;
	using ::scalblnl;
	using ::scalbnl;
	using ::tgammal;
	using ::truncl;

	#if _LIBCPP_STD_VER > 14
	inline _LIBCPP_INLINE_VISIBILITY float hypot( float x, float y, float z ) { return sqrt(xx + yy + z*z); }
	inline _LIBCPP_INLINE_VISIBILITY double hypot( double x, double y, double z ) { return sqrt(xx + yy + z*z); }
	inline _LIBCPP_INLINE_VISIBILITY long double hypot( long double x, long double y, long double z ) { return sqrt(xx + yy + z*z); }

	template <class _A1, class _A2, class _A3>
	inline _LIBCPP_INLINE_VISIBILITY
	typename __lazy_enable_if
	<
	is_arithmetic<_A1>::value &&
	is_arithmetic<_A2>::value &&
	is_arithmetic<_A3>::value,
	__promote<_A1, _A2, _A3>
	>::type
	hypot(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT
	{
	typedef typename __promote<_A1, _A2, _A3>::type __result_type;
	static_assert((!(is_same<_A1, __result_type>::value &&
	is_same<_A2, __result_type>::value &&
	is_same<_A3, __result_type>::value)), "");
	return hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z);
	}
	#endif

	template <class _A1>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
	__libcpp_isnan_or_builtin(_A1 __lcpp_x) _NOEXCEPT
	{
	#if __has_builtin(__builtin_isnan)
	return __builtin_isnan(__lcpp_x);
	#else
	return isnan(__lcpp_x);
	#endif
	}

	template <class _A1>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
	__libcpp_isnan_or_builtin(_A1 __lcpp_x) _NOEXCEPT
	{
	return isnan(__lcpp_x);
	}

	template <class _A1>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
	__libcpp_isinf_or_builtin(_A1 __lcpp_x) _NOEXCEPT
	{
	#if __has_builtin(__builtin_isinf)
	return __builtin_isinf(__lcpp_x);
	#else
	return isinf(__lcpp_x);
	#endif
	}

	template <class _A1>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
	__libcpp_isinf_or_builtin(_A1 __lcpp_x) _NOEXCEPT
	{
	return isinf(__lcpp_x);
	}

	template <class _A1>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
	__libcpp_isfinite_or_builtin(_A1 __lcpp_x) _NOEXCEPT
	{
	#if __has_builtin(__builtin_isfinite)
	return __builtin_isfinite(__lcpp_x);
	#else
	return isfinite(__lcpp_x);
	#endif
	}

	template <class _A1>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
	__libcpp_isfinite_or_builtin(_A1 __lcpp_x) _NOEXCEPT
	{
	return isfinite(__lcpp_x);
	}

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_CMATH
	Index: projects/clang700-import/contrib/libc++/include/codecvt
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/codecvt (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/codecvt (revision 337135)
	@@ -1,550 +1,550 @@
	// -- C++ --
	//===-------------------------- codecvt -----------------------------------===//
	//
	// 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_CODECVT
	#define _LIBCPP_CODECVT

	/*
	codecvt synopsis

	namespace std
	{

	enum codecvt_mode
	{
	consume_header = 4,
	generate_header = 2,
	little_endian = 1
	};

	template <class Elem, unsigned long Maxcode = 0x10ffff,
	codecvt_mode Mode = (codecvt_mode)0>
	class codecvt_utf8
	: public codecvt<Elem, char, mbstate_t>
	{
	explicit codecvt_utf8(size_t refs = 0);
	~codecvt_utf8();
	};

	template <class Elem, unsigned long Maxcode = 0x10ffff,
	codecvt_mode Mode = (codecvt_mode)0>
	class codecvt_utf16
	: public codecvt<Elem, char, mbstate_t>
	{
	explicit codecvt_utf16(size_t refs = 0);
	~codecvt_utf16();
	};

	template <class Elem, unsigned long Maxcode = 0x10ffff,
	codecvt_mode Mode = (codecvt_mode)0>
	class codecvt_utf8_utf16
	: public codecvt<Elem, char, mbstate_t>
	{
	explicit codecvt_utf8_utf16(size_t refs = 0);
	~codecvt_utf8_utf16();
	};

	} // std

	*/

	#include <__config>
	#include <__locale>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	enum codecvt_mode
	{
	consume_header = 4,
	generate_header = 2,
	little_endian = 1
	};

	// codecvt_utf8

	template <class _Elem> class __codecvt_utf8;

	template <>
	class _LIBCPP_TYPE_VIS __codecvt_utf8<wchar_t>
	: public codecvt<wchar_t, char, mbstate_t>
	{
	unsigned long _Maxcode_;
	codecvt_mode _Mode_;
	public:
	typedef wchar_t intern_type;
	typedef char extern_type;
	typedef mbstate_t state_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
	codecvt_mode _Mode)
	: codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
	_Mode_(_Mode) {}
	protected:
	virtual result
	do_out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual result
	do_in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
	virtual result
	do_unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual int do_encoding() const throw();
	virtual bool do_always_noconv() const throw();
	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
	size_t __mx) const;
	virtual int do_max_length() const throw();
	};

	template <>
	class _LIBCPP_TYPE_VIS __codecvt_utf8<char16_t>
	: public codecvt<char16_t, char, mbstate_t>
	{
	unsigned long _Maxcode_;
	codecvt_mode _Mode_;
	public:
	typedef char16_t intern_type;
	typedef char extern_type;
	typedef mbstate_t state_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
	codecvt_mode _Mode)
	: codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
	_Mode_(_Mode) {}
	protected:
	virtual result
	do_out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual result
	do_in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
	virtual result
	do_unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual int do_encoding() const throw();
	virtual bool do_always_noconv() const throw();
	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
	size_t __mx) const;
	virtual int do_max_length() const throw();
	};

	template <>
	class _LIBCPP_TYPE_VIS __codecvt_utf8<char32_t>
	: public codecvt<char32_t, char, mbstate_t>
	{
	unsigned long _Maxcode_;
	codecvt_mode _Mode_;
	public:
	typedef char32_t intern_type;
	typedef char extern_type;
	typedef mbstate_t state_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
	codecvt_mode _Mode)
	: codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
	_Mode_(_Mode) {}
	protected:
	virtual result
	do_out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual result
	do_in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
	virtual result
	do_unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual int do_encoding() const throw();
	virtual bool do_always_noconv() const throw();
	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
	size_t __mx) const;
	virtual int do_max_length() const throw();
	};

	template <class _Elem, unsigned long _Maxcode = 0x10ffff,
	codecvt_mode _Mode = (codecvt_mode)0>
	class _LIBCPP_TEMPLATE_VIS codecvt_utf8
	: public __codecvt_utf8<_Elem>
	{
	public:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit codecvt_utf8(size_t __refs = 0)
	: __codecvt_utf8<_Elem>(__refs, _Maxcode, _Mode) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	~codecvt_utf8() {}
	};

	// codecvt_utf16

	template <class _Elem, bool _LittleEndian> class __codecvt_utf16;

	template <>
	class _LIBCPP_TYPE_VIS __codecvt_utf16<wchar_t, false>
	: public codecvt<wchar_t, char, mbstate_t>
	{
	unsigned long _Maxcode_;
	codecvt_mode _Mode_;
	public:
	typedef wchar_t intern_type;
	typedef char extern_type;
	typedef mbstate_t state_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
	codecvt_mode _Mode)
	: codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
	_Mode_(_Mode) {}
	protected:
	virtual result
	do_out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual result
	do_in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
	virtual result
	do_unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual int do_encoding() const throw();
	virtual bool do_always_noconv() const throw();
	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
	size_t __mx) const;
	virtual int do_max_length() const throw();
	};

	template <>
	class _LIBCPP_TYPE_VIS __codecvt_utf16<wchar_t, true>
	: public codecvt<wchar_t, char, mbstate_t>
	{
	unsigned long _Maxcode_;
	codecvt_mode _Mode_;
	public:
	typedef wchar_t intern_type;
	typedef char extern_type;
	typedef mbstate_t state_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
	codecvt_mode _Mode)
	: codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
	_Mode_(_Mode) {}
	protected:
	virtual result
	do_out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual result
	do_in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
	virtual result
	do_unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual int do_encoding() const throw();
	virtual bool do_always_noconv() const throw();
	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
	size_t __mx) const;
	virtual int do_max_length() const throw();
	};

	template <>
	class _LIBCPP_TYPE_VIS __codecvt_utf16<char16_t, false>
	: public codecvt<char16_t, char, mbstate_t>
	{
	unsigned long _Maxcode_;
	codecvt_mode _Mode_;
	public:
	typedef char16_t intern_type;
	typedef char extern_type;
	typedef mbstate_t state_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
	codecvt_mode _Mode)
	: codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
	_Mode_(_Mode) {}
	protected:
	virtual result
	do_out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual result
	do_in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
	virtual result
	do_unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual int do_encoding() const throw();
	virtual bool do_always_noconv() const throw();
	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
	size_t __mx) const;
	virtual int do_max_length() const throw();
	};

	template <>
	class _LIBCPP_TYPE_VIS __codecvt_utf16<char16_t, true>
	: public codecvt<char16_t, char, mbstate_t>
	{
	unsigned long _Maxcode_;
	codecvt_mode _Mode_;
	public:
	typedef char16_t intern_type;
	typedef char extern_type;
	typedef mbstate_t state_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
	codecvt_mode _Mode)
	: codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
	_Mode_(_Mode) {}
	protected:
	virtual result
	do_out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual result
	do_in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
	virtual result
	do_unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual int do_encoding() const throw();
	virtual bool do_always_noconv() const throw();
	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
	size_t __mx) const;
	virtual int do_max_length() const throw();
	};

	template <>
	class _LIBCPP_TYPE_VIS __codecvt_utf16<char32_t, false>
	: public codecvt<char32_t, char, mbstate_t>
	{
	unsigned long _Maxcode_;
	codecvt_mode _Mode_;
	public:
	typedef char32_t intern_type;
	typedef char extern_type;
	typedef mbstate_t state_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
	codecvt_mode _Mode)
	: codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
	_Mode_(_Mode) {}
	protected:
	virtual result
	do_out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual result
	do_in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
	virtual result
	do_unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual int do_encoding() const throw();
	virtual bool do_always_noconv() const throw();
	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
	size_t __mx) const;
	virtual int do_max_length() const throw();
	};

	template <>
	class _LIBCPP_TYPE_VIS __codecvt_utf16<char32_t, true>
	: public codecvt<char32_t, char, mbstate_t>
	{
	unsigned long _Maxcode_;
	codecvt_mode _Mode_;
	public:
	typedef char32_t intern_type;
	typedef char extern_type;
	typedef mbstate_t state_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
	codecvt_mode _Mode)
	: codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
	_Mode_(_Mode) {}
	protected:
	virtual result
	do_out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual result
	do_in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
	virtual result
	do_unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual int do_encoding() const throw();
	virtual bool do_always_noconv() const throw();
	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
	size_t __mx) const;
	virtual int do_max_length() const throw();
	};

	template <class _Elem, unsigned long _Maxcode = 0x10ffff,
	codecvt_mode _Mode = (codecvt_mode)0>
	class _LIBCPP_TEMPLATE_VIS codecvt_utf16
	: public __codecvt_utf16<_Elem, _Mode & little_endian>
	{
	public:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit codecvt_utf16(size_t __refs = 0)
	: __codecvt_utf16<_Elem, _Mode & little_endian>(__refs, _Maxcode, _Mode) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	~codecvt_utf16() {}
	};

	// codecvt_utf8_utf16

	template <class _Elem> class __codecvt_utf8_utf16;

	template <>
	class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<wchar_t>
	: public codecvt<wchar_t, char, mbstate_t>
	{
	unsigned long _Maxcode_;
	codecvt_mode _Mode_;
	public:
	typedef wchar_t intern_type;
	typedef char extern_type;
	typedef mbstate_t state_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
	codecvt_mode _Mode)
	: codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
	_Mode_(_Mode) {}
	protected:
	virtual result
	do_out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual result
	do_in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
	virtual result
	do_unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual int do_encoding() const throw();
	virtual bool do_always_noconv() const throw();
	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
	size_t __mx) const;
	virtual int do_max_length() const throw();
	};

	template <>
	class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<char32_t>
	: public codecvt<char32_t, char, mbstate_t>
	{
	unsigned long _Maxcode_;
	codecvt_mode _Mode_;
	public:
	typedef char32_t intern_type;
	typedef char extern_type;
	typedef mbstate_t state_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
	codecvt_mode _Mode)
	: codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
	_Mode_(_Mode) {}
	protected:
	virtual result
	do_out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual result
	do_in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
	virtual result
	do_unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual int do_encoding() const throw();
	virtual bool do_always_noconv() const throw();
	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
	size_t __mx) const;
	virtual int do_max_length() const throw();
	};

	template <>
	class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<char16_t>
	: public codecvt<char16_t, char, mbstate_t>
	{
	unsigned long _Maxcode_;
	codecvt_mode _Mode_;
	public:
	typedef char16_t intern_type;
	typedef char extern_type;
	typedef mbstate_t state_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
	codecvt_mode _Mode)
	: codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
	_Mode_(_Mode) {}
	protected:
	virtual result
	do_out(state_type& __st,
	const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual result
	do_in(state_type& __st,
	const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
	intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
	virtual result
	do_unshift(state_type& __st,
	extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
	virtual int do_encoding() const throw();
	virtual bool do_always_noconv() const throw();
	virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
	size_t __mx) const;
	virtual int do_max_length() const throw();
	};

	template <class _Elem, unsigned long _Maxcode = 0x10ffff,
	codecvt_mode _Mode = (codecvt_mode)0>
	class _LIBCPP_TEMPLATE_VIS codecvt_utf8_utf16
	: public __codecvt_utf8_utf16<_Elem>
	{
	public:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit codecvt_utf8_utf16(size_t __refs = 0)
	: __codecvt_utf8_utf16<_Elem>(__refs, _Maxcode, _Mode) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	~codecvt_utf8_utf16() {}
	};

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_CODECVT
	Index: projects/clang700-import/contrib/libc++/include/compare
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/compare (nonexistent)
	+++ projects/clang700-import/contrib/libc++/include/compare (revision 337135)
	@@ -0,0 +1,679 @@
	+// -- C++ --
	+//===-------------------------- compare -----------------------------------===//
	+//
	+// 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_COMPARE
	+#define _LIBCPP_COMPARE
	+
	+/*
	+ compare synopsis
	+
	+namespace std {
	+ // [cmp.categories], comparison category types
	+ class weak_equality;
	+ class strong_equality;
	+ class partial_ordering;
	+ class weak_ordering;
	+ class strong_ordering;
	+
	+ // named comparison functions
	+ constexpr bool is_eq (weak_equality cmp) noexcept { return cmp == 0; }
	+ constexpr bool is_neq (weak_equality cmp) noexcept { return cmp != 0; }
	+ constexpr bool is_lt (partial_ordering cmp) noexcept { return cmp < 0; }
	+ constexpr bool is_lteq(partial_ordering cmp) noexcept { return cmp <= 0; }
	+ constexpr bool is_gt (partial_ordering cmp) noexcept { return cmp > 0; }
	+ constexpr bool is_gteq(partial_ordering cmp) noexcept { return cmp >= 0; }
	+
	+ // [cmp.common], common comparison category type
	+ template<class... Ts>
	+ struct common_comparison_category {
	+ using type = see below;
	+ };
	+ template<class... Ts>
	+ using common_comparison_category_t = typename common_comparison_category<Ts...>::type;
	+
	+ // [cmp.alg], comparison algorithms
	+ template<class T> constexpr strong_ordering strong_order(const T& a, const T& b);
	+ template<class T> constexpr weak_ordering weak_order(const T& a, const T& b);
	+ template<class T> constexpr partial_ordering partial_order(const T& a, const T& b);
	+ template<class T> constexpr strong_equality strong_equal(const T& a, const T& b);
	+ template<class T> constexpr weak_equality weak_equal(const T& a, const T& b);
	+}
	+*/
	+
	+#include <__config>
	+#include <type_traits>
	+#include <array>
	+
	+#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
	+#pragma GCC system_header
	+#endif
	+
	+_LIBCPP_BEGIN_NAMESPACE_STD
	+
	+#if _LIBCPP_STD_VER > 17
	+
	+// exposition only
	+enum class _LIBCPP_ENUM_VIS _EqResult : unsigned char {
	+ __zero = 0,
	+ __equal = __zero,
	+ __equiv = __equal,
	+ __nonequal = 1,
	+ __nonequiv = __nonequal
	+};
	+
	+enum class _LIBCPP_ENUM_VIS _OrdResult : signed char {
	+ __less = -1,
	+ __greater = 1
	+};
	+
	+enum class _LIBCPP_ENUM_VIS _NCmpResult : signed char {
	+ __unordered = -127
	+};
	+
	+struct _CmpUnspecifiedType;
	+using _CmpUnspecifiedParam = void (_CmpUnspecifiedType::*)();
	+
	+class weak_equality {
	+ _LIBCPP_INLINE_VISIBILITY
	+ constexpr explicit weak_equality(_EqResult __val) noexcept : __value_(__val) {}
	+
	+public:
	+ static const weak_equality equivalent;
	+ static const weak_equality nonequivalent;
	+
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(weak_equality __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(_CmpUnspecifiedParam, weak_equality __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(weak_equality __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(_CmpUnspecifiedParam, weak_equality __v) noexcept;
	+
	+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr weak_equality operator<=>(weak_equality __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr weak_equality operator<=>(_CmpUnspecifiedParam, weak_equality __v) noexcept;
	+#endif
	+
	+private:
	+ _EqResult __value_;
	+};
	+
	+_LIBCPP_INLINE_VAR constexpr weak_equality weak_equality::equivalent(_EqResult::__equiv);
	+_LIBCPP_INLINE_VAR constexpr weak_equality weak_equality::nonequivalent(_EqResult::__nonequiv);
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr bool operator==(weak_equality __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__value_ == _EqResult::__zero;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr bool operator==(_CmpUnspecifiedParam, weak_equality __v) noexcept {
	+ return __v.__value_ == _EqResult::__zero;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr bool operator!=(weak_equality __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__value_ != _EqResult::__zero;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr bool operator!=(_CmpUnspecifiedParam, weak_equality __v) noexcept {
	+ return __v.__value_ != _EqResult::__zero;
	+}
	+
	+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr weak_equality operator<=>(weak_equality __v, _CmpUnspecifiedParam) noexcept {
	+ return __v;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr weak_equality operator<=>(_CmpUnspecifiedParam, weak_equality __v) noexcept {
	+ return __v;
	+}
	+#endif
	+
	+class strong_equality {
	+ _LIBCPP_INLINE_VISIBILITY
	+ explicit constexpr strong_equality(_EqResult __val) noexcept : __value_(__val) {}
	+
	+public:
	+ static const strong_equality equal;
	+ static const strong_equality nonequal;
	+ static const strong_equality equivalent;
	+ static const strong_equality nonequivalent;
	+
	+ // conversion
	+ _LIBCPP_INLINE_VISIBILITY constexpr operator weak_equality() const noexcept {
	+ return __value_ == _EqResult::__zero ? weak_equality::equivalent
	+ : weak_equality::nonequivalent;
	+ }
	+
	+ // comparisons
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(strong_equality __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(strong_equality __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(_CmpUnspecifiedParam, strong_equality __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(_CmpUnspecifiedParam, strong_equality __v) noexcept;
	+
	+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr strong_equality operator<=>(strong_equality __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr strong_equality operator<=>(_CmpUnspecifiedParam, strong_equality __v) noexcept;
	+#endif
	+private:
	+ _EqResult __value_;
	+};
	+
	+_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::equal(_EqResult::__equal);
	+_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::nonequal(_EqResult::__nonequal);
	+_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::equivalent(_EqResult::__equiv);
	+_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::nonequivalent(_EqResult::__nonequiv);
	+
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator==(strong_equality __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__value_ == _EqResult::__zero;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator==(_CmpUnspecifiedParam, strong_equality __v) noexcept {
	+ return __v.__value_ == _EqResult::__zero;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator!=(strong_equality __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__value_ != _EqResult::__zero;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator!=(_CmpUnspecifiedParam, strong_equality __v) noexcept {
	+ return __v.__value_ != _EqResult::__zero;
	+}
	+
	+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr strong_equality operator<=>(strong_equality __v, _CmpUnspecifiedParam) noexcept {
	+ return __v;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr strong_equality operator<=>(_CmpUnspecifiedParam, strong_equality __v) noexcept {
	+ return __v;
	+}
	+#endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
	+
	+class partial_ordering {
	+ using _ValueT = signed char;
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ explicit constexpr partial_ordering(_EqResult __v) noexcept
	+ : __value_(_ValueT(__v)) {}
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ explicit constexpr partial_ordering(_OrdResult __v) noexcept
	+ : __value_(_ValueT(__v)) {}
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ explicit constexpr partial_ordering(_NCmpResult __v) noexcept
	+ : __value_(_ValueT(__v)) {}
	+
	+ constexpr bool __is_ordered() const noexcept {
	+ return __value_ != _ValueT(_NCmpResult::__unordered);
	+ }
	+public:
	+ // valid values
	+ static const partial_ordering less;
	+ static const partial_ordering equivalent;
	+ static const partial_ordering greater;
	+ static const partial_ordering unordered;
	+
	+ // conversion
	+ constexpr operator weak_equality() const noexcept {
	+ return __value_ == 0 ? weak_equality::equivalent : weak_equality::nonequivalent;
	+ }
	+
	+ // comparisons
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator< (partial_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator<=(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator> (partial_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator< (_CmpUnspecifiedParam, partial_ordering __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator<=(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator> (_CmpUnspecifiedParam, partial_ordering __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
	+
	+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr partial_ordering operator<=>(partial_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr partial_ordering operator<=>(_CmpUnspecifiedParam, partial_ordering __v) noexcept;
	+#endif
	+
	+private:
	+ _ValueT __value_;
	+};
	+
	+_LIBCPP_INLINE_VAR constexpr partial_ordering partial_ordering::less(_OrdResult::__less);
	+_LIBCPP_INLINE_VAR constexpr partial_ordering partial_ordering::equivalent(_EqResult::__equiv);
	+_LIBCPP_INLINE_VAR constexpr partial_ordering partial_ordering::greater(_OrdResult::__greater);
	+_LIBCPP_INLINE_VAR constexpr partial_ordering partial_ordering::unordered(_NCmpResult ::__unordered);
	+
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator==(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__is_ordered() && __v.__value_ == 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator< (partial_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__is_ordered() && __v.__value_ < 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator<=(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__is_ordered() && __v.__value_ <= 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator> (partial_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__is_ordered() && __v.__value_ > 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator>=(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__is_ordered() && __v.__value_ >= 0;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator==(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
	+ return __v.__is_ordered() && 0 == __v.__value_;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator< (_CmpUnspecifiedParam, partial_ordering __v) noexcept {
	+ return __v.__is_ordered() && 0 < __v.__value_;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator<=(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
	+ return __v.__is_ordered() && 0 <= __v.__value_;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator> (_CmpUnspecifiedParam, partial_ordering __v) noexcept {
	+ return __v.__is_ordered() && 0 > __v.__value_;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator>=(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
	+ return __v.__is_ordered() && 0 >= __v.__value_;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator!=(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return !__v.__is_ordered() \|\| __v.__value_ != 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator!=(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
	+ return !__v.__is_ordered() \|\| __v.__value_ != 0;
	+}
	+
	+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr partial_ordering operator<=>(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr partial_ordering operator<=>(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
	+ return __v < 0 ? partial_ordering::greater : (__v > 0 ? partial_ordering::less : __v);
	+}
	+#endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
	+
	+class weak_ordering {
	+ using _ValueT = signed char;
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ explicit constexpr weak_ordering(_EqResult __v) noexcept : __value_(_ValueT(__v)) {}
	+ _LIBCPP_INLINE_VISIBILITY
	+ explicit constexpr weak_ordering(_OrdResult __v) noexcept : __value_(_ValueT(__v)) {}
	+
	+public:
	+ static const weak_ordering less;
	+ static const weak_ordering equivalent;
	+ static const weak_ordering greater;
	+
	+ // conversions
	+ _LIBCPP_INLINE_VISIBILITY
	+ constexpr operator weak_equality() const noexcept {
	+ return __value_ == 0 ? weak_equality::equivalent
	+ : weak_equality::nonequivalent;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ constexpr operator partial_ordering() const noexcept {
	+ return __value_ == 0 ? partial_ordering::equivalent
	+ : (__value_ < 0 ? partial_ordering::less : partial_ordering::greater);
	+ }
	+
	+ // comparisons
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator< (weak_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator<=(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator> (weak_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator< (_CmpUnspecifiedParam, weak_ordering __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator<=(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator> (_CmpUnspecifiedParam, weak_ordering __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
	+
	+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr weak_ordering operator<=>(weak_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr weak_ordering operator<=>(_CmpUnspecifiedParam, weak_ordering __v) noexcept;
	+#endif
	+
	+private:
	+ _ValueT __value_;
	+};
	+
	+_LIBCPP_INLINE_VAR constexpr weak_ordering weak_ordering::less(_OrdResult::__less);
	+_LIBCPP_INLINE_VAR constexpr weak_ordering weak_ordering::equivalent(_EqResult::__equiv);
	+_LIBCPP_INLINE_VAR constexpr weak_ordering weak_ordering::greater(_OrdResult::__greater);
	+
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator==(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__value_ == 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator!=(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__value_ != 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator< (weak_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__value_ < 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator<=(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__value_ <= 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator> (weak_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__value_ > 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator>=(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__value_ >= 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator==(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
	+ return 0 == __v.__value_;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator!=(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
	+ return 0 != __v.__value_;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator< (_CmpUnspecifiedParam, weak_ordering __v) noexcept {
	+ return 0 < __v.__value_;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator<=(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
	+ return 0 <= __v.__value_;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator> (_CmpUnspecifiedParam, weak_ordering __v) noexcept {
	+ return 0 > __v.__value_;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator>=(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
	+ return 0 >= __v.__value_;
	+}
	+
	+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr weak_ordering operator<=>(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr weak_ordering operator<=>(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
	+ return __v < 0 ? weak_ordering::greater : (__v > 0 ? weak_ordering::less : __v);
	+}
	+#endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
	+
	+class strong_ordering {
	+ using _ValueT = signed char;
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ explicit constexpr strong_ordering(_EqResult __v) noexcept : __value_(_ValueT(__v)) {}
	+ _LIBCPP_INLINE_VISIBILITY
	+ explicit constexpr strong_ordering(_OrdResult __v) noexcept : __value_(_ValueT(__v)) {}
	+
	+public:
	+ static const strong_ordering less;
	+ static const strong_ordering equal;
	+ static const strong_ordering equivalent;
	+ static const strong_ordering greater;
	+
	+ // conversions
	+ _LIBCPP_INLINE_VISIBILITY
	+ constexpr operator weak_equality() const noexcept {
	+ return __value_ == 0 ? weak_equality::equivalent
	+ : weak_equality::nonequivalent;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ constexpr operator strong_equality() const noexcept {
	+ return __value_ == 0 ? strong_equality::equal
	+ : strong_equality::nonequal;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ constexpr operator partial_ordering() const noexcept {
	+ return __value_ == 0 ? partial_ordering::equivalent
	+ : (__value_ < 0 ? partial_ordering::less : partial_ordering::greater);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ constexpr operator weak_ordering() const noexcept {
	+ return __value_ == 0 ? weak_ordering::equivalent
	+ : (__value_ < 0 ? weak_ordering::less : weak_ordering::greater);
	+ }
	+
	+ // comparisons
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator< (strong_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator<=(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator> (strong_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator==(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator!=(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator< (_CmpUnspecifiedParam, strong_ordering __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator<=(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator> (_CmpUnspecifiedParam, strong_ordering __v) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr bool operator>=(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
	+
	+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr strong_ordering operator<=>(strong_ordering __v, _CmpUnspecifiedParam) noexcept;
	+ _LIBCPP_INLINE_VISIBILITY friend constexpr strong_ordering operator<=>(_CmpUnspecifiedParam, strong_ordering __v) noexcept;
	+#endif
	+
	+private:
	+ _ValueT __value_;
	+};
	+
	+_LIBCPP_INLINE_VAR constexpr strong_ordering strong_ordering::less(_OrdResult::__less);
	+_LIBCPP_INLINE_VAR constexpr strong_ordering strong_ordering::equal(_EqResult::__equal);
	+_LIBCPP_INLINE_VAR constexpr strong_ordering strong_ordering::equivalent(_EqResult::__equiv);
	+_LIBCPP_INLINE_VAR constexpr strong_ordering strong_ordering::greater(_OrdResult::__greater);
	+
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator==(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__value_ == 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator!=(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__value_ != 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator< (strong_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__value_ < 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator<=(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__value_ <= 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator> (strong_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__value_ > 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator>=(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v.__value_ >= 0;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator==(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
	+ return 0 == __v.__value_;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator!=(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
	+ return 0 != __v.__value_;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator< (_CmpUnspecifiedParam, strong_ordering __v) noexcept {
	+ return 0 < __v.__value_;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator<=(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
	+ return 0 <= __v.__value_;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator> (_CmpUnspecifiedParam, strong_ordering __v) noexcept {
	+ return 0 > __v.__value_;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool operator>=(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
	+ return 0 >= __v.__value_;
	+}
	+
	+#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr strong_ordering operator<=>(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
	+ return __v;
	+}
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr strong_ordering operator<=>(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
	+ return __v < 0 ? strong_ordering::greater : (__v > 0 ? strong_ordering::less : __v);
	+}
	+#endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
	+
	+// named comparison functions
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool is_eq(weak_equality __cmp) noexcept { return __cmp == 0; }
	+
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool is_neq(weak_equality __cmp) noexcept { return __cmp != 0; }
	+
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool is_lt(partial_ordering __cmp) noexcept { return __cmp < 0; }
	+
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool is_lteq(partial_ordering __cmp) noexcept { return __cmp <= 0; }
	+
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool is_gt(partial_ordering __cmp) noexcept { return __cmp > 0; }
	+
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr bool is_gteq(partial_ordering __cmp) noexcept { return __cmp >= 0; }
	+
	+namespace __comp_detail {
	+
	+enum _ClassifyCompCategory : unsigned{
	+ _None,
	+ _WeakEq,
	+ _StrongEq,
	+ _PartialOrd,
	+ _WeakOrd,
	+ _StrongOrd,
	+ _CCC_Size
	+};
	+
	+template <class _Tp>
	+_LIBCPP_INLINE_VISIBILITY
	+constexpr _ClassifyCompCategory __type_to_enum() noexcept {
	+ if (is_same_v<_Tp, weak_equality>)
	+ return _WeakEq;
	+ if (is_same_v<_Tp, strong_equality>)
	+ return _StrongEq;
	+ if (is_same_v<_Tp, partial_ordering>)
	+ return _PartialOrd;
	+ if (is_same_v<_Tp, weak_ordering>)
	+ return _WeakOrd;
	+ if (is_same_v<_Tp, strong_ordering>)
	+ return _StrongOrd;
	+ return _None;
	+}
	+
	+template <size_t _Size>
	+constexpr _ClassifyCompCategory
	+__compute_comp_type(std::array<_ClassifyCompCategory, _Size> __types) {
	+ std::array<int, _CCC_Size> __seen = {};
	+ for (auto __type : __types)
	+ ++__seen[__type];
	+ if (__seen[_None])
	+ return _None;
	+ if (__seen[_WeakEq])
	+ return _WeakEq;
	+ if (__seen[_StrongEq] && (__seen[_PartialOrd] \|\| __seen[_WeakOrd]))
	+ return _WeakEq;
	+ if (__seen[_StrongEq])
	+ return _StrongEq;
	+ if (__seen[_PartialOrd])
	+ return _PartialOrd;
	+ if (__seen[_WeakOrd])
	+ return _WeakOrd;
	+ return _StrongOrd;
	+}
	+
	+template <class ..._Ts>
	+constexpr auto __get_comp_type() {
	+ using _CCC = _ClassifyCompCategory;
	+ constexpr array<_CCC, sizeof...(_Ts)> __type_kinds{{__comp_detail::__type_to_enum<_Ts>()...}};
	+ constexpr _CCC _Cat = sizeof...(_Ts) == 0 ? _StrongOrd
	+ : __compute_comp_type(__type_kinds);
	+ if constexpr (_Cat == _None)
	+ return void();
	+ else if constexpr (_Cat == _WeakEq)
	+ return weak_equality::equivalent;
	+ else if constexpr (_Cat == _StrongEq)
	+ return strong_equality::equivalent;
	+ else if constexpr (_Cat == _PartialOrd)
	+ return partial_ordering::equivalent;
	+ else if constexpr (_Cat == _WeakOrd)
	+ return weak_ordering::equivalent;
	+ else if constexpr (_Cat == _StrongOrd)
	+ return strong_ordering::equivalent;
	+ else
	+ static_assert(_Cat != _Cat, "unhandled case");
	+}
	+} // namespace __comp_detail
	+
	+// [cmp.common], common comparison category type
	+template<class... _Ts>
	+struct _LIBCPP_TEMPLATE_VIS common_comparison_category {
	+ using type = decltype(__comp_detail::__get_comp_type<_Ts...>());
	+};
	+
	+template<class... _Ts>
	+using common_comparison_category_t = typename common_comparison_category<_Ts...>::type;
	+
	+// [cmp.alg], comparison algorithms
	+// TODO: unimplemented
	+template<class _Tp> constexpr strong_ordering strong_order(const _Tp& __lhs, const _Tp& __rhs);
	+template<class _Tp> constexpr weak_ordering weak_order(const _Tp& __lhs, const _Tp& __rhs);
	+template<class _Tp> constexpr partial_ordering partial_order(const _Tp& __lhs, const _Tp& __rhs);
	+template<class _Tp> constexpr strong_equality strong_equal(const _Tp& __lhs, const _Tp& __rhs);
	+template<class _Tp> constexpr weak_equality weak_equal(const _Tp& __lhs, const _Tp& __rhs);
	+
	+#endif // _LIBCPP_STD_VER > 17
	+
	+_LIBCPP_END_NAMESPACE_STD
	+
	+#endif // _LIBCPP_COMPARE
	Index: projects/clang700-import/contrib/libc++/include/complex
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/complex (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/complex (revision 337135)
	@@ -1,1484 +1,1495 @@
	// -- C++ --
	//===--------------------------- complex ----------------------------------===//
	//
	// 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_COMPLEX
	#define _LIBCPP_COMPLEX

	/*
	complex synopsis

	namespace std
	{

	template<class T>
	class complex
	{
	public:
	typedef T value_type;

	complex(const T& re = T(), const T& im = T()); // constexpr in C++14
	complex(const complex&); // constexpr in C++14
	template<class X> complex(const complex<X>&); // constexpr in C++14

	T real() const; // constexpr in C++14
	T imag() const; // constexpr in C++14

	void real(T);
	void imag(T);

	complex<T>& operator= (const T&);
	complex<T>& operator+=(const T&);
	complex<T>& operator-=(const T&);
	complex<T>& operator*=(const T&);
	complex<T>& operator/=(const T&);

	complex& operator=(const complex&);
	template<class X> complex<T>& operator= (const complex<X>&);
	template<class X> complex<T>& operator+=(const complex<X>&);
	template<class X> complex<T>& operator-=(const complex<X>&);
	template<class X> complex<T>& operator*=(const complex<X>&);
	template<class X> complex<T>& operator/=(const complex<X>&);
	};

	template<>
	class complex<float>
	{
	public:
	typedef float value_type;

	constexpr complex(float re = 0.0f, float im = 0.0f);
	explicit constexpr complex(const complex<double>&);
	explicit constexpr complex(const complex<long double>&);

	constexpr float real() const;
	void real(float);
	constexpr float imag() const;
	void imag(float);

	complex<float>& operator= (float);
	complex<float>& operator+=(float);
	complex<float>& operator-=(float);
	complex<float>& operator*=(float);
	complex<float>& operator/=(float);

	complex<float>& operator=(const complex<float>&);
	template<class X> complex<float>& operator= (const complex<X>&);
	template<class X> complex<float>& operator+=(const complex<X>&);
	template<class X> complex<float>& operator-=(const complex<X>&);
	template<class X> complex<float>& operator*=(const complex<X>&);
	template<class X> complex<float>& operator/=(const complex<X>&);
	};

	template<>
	class complex<double>
	{
	public:
	typedef double value_type;

	constexpr complex(double re = 0.0, double im = 0.0);
	constexpr complex(const complex<float>&);
	explicit constexpr complex(const complex<long double>&);

	constexpr double real() const;
	void real(double);
	constexpr double imag() const;
	void imag(double);

	complex<double>& operator= (double);
	complex<double>& operator+=(double);
	complex<double>& operator-=(double);
	complex<double>& operator*=(double);
	complex<double>& operator/=(double);
	complex<double>& operator=(const complex<double>&);

	template<class X> complex<double>& operator= (const complex<X>&);
	template<class X> complex<double>& operator+=(const complex<X>&);
	template<class X> complex<double>& operator-=(const complex<X>&);
	template<class X> complex<double>& operator*=(const complex<X>&);
	template<class X> complex<double>& operator/=(const complex<X>&);
	};

	template<>
	class complex<long double>
	{
	public:
	typedef long double value_type;

	constexpr complex(long double re = 0.0L, long double im = 0.0L);
	constexpr complex(const complex<float>&);
	constexpr complex(const complex<double>&);

	constexpr long double real() const;
	void real(long double);
	constexpr long double imag() const;
	void imag(long double);

	complex<long double>& operator=(const complex<long double>&);
	complex<long double>& operator= (long double);
	complex<long double>& operator+=(long double);
	complex<long double>& operator-=(long double);
	complex<long double>& operator*=(long double);
	complex<long double>& operator/=(long double);

	template<class X> complex<long double>& operator= (const complex<X>&);
	template<class X> complex<long double>& operator+=(const complex<X>&);
	template<class X> complex<long double>& operator-=(const complex<X>&);
	template<class X> complex<long double>& operator*=(const complex<X>&);
	template<class X> complex<long double>& operator/=(const complex<X>&);
	};

	// 26.3.6 operators:
	template<class T> complex<T> operator+(const complex<T>&, const complex<T>&);
	template<class T> complex<T> operator+(const complex<T>&, const T&);
	template<class T> complex<T> operator+(const T&, const complex<T>&);
	template<class T> complex<T> operator-(const complex<T>&, const complex<T>&);
	template<class T> complex<T> operator-(const complex<T>&, const T&);
	template<class T> complex<T> operator-(const T&, const complex<T>&);
	template<class T> complex<T> operator*(const complex<T>&, const complex<T>&);
	template<class T> complex<T> operator*(const complex<T>&, const T&);
	template<class T> complex<T> operator*(const T&, const complex<T>&);
	template<class T> complex<T> operator/(const complex<T>&, const complex<T>&);
	template<class T> complex<T> operator/(const complex<T>&, const T&);
	template<class T> complex<T> operator/(const T&, const complex<T>&);
	template<class T> complex<T> operator+(const complex<T>&);
	template<class T> complex<T> operator-(const complex<T>&);
	template<class T> bool operator==(const complex<T>&, const complex<T>&); // constexpr in C++14
	template<class T> bool operator==(const complex<T>&, const T&); // constexpr in C++14
	template<class T> bool operator==(const T&, const complex<T>&); // constexpr in C++14
	template<class T> bool operator!=(const complex<T>&, const complex<T>&); // constexpr in C++14
	template<class T> bool operator!=(const complex<T>&, const T&); // constexpr in C++14
	template<class T> bool operator!=(const T&, const complex<T>&); // constexpr in C++14

	template<class T, class charT, class traits>
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>&, complex<T>&);
	template<class T, class charT, class traits>
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>&, const complex<T>&);

	// 26.3.7 values:

	template<class T> T real(const complex<T>&); // constexpr in C++14
	long double real(long double); // constexpr in C++14
	double real(double); // constexpr in C++14
	template<Integral T> double real(T); // constexpr in C++14
	float real(float); // constexpr in C++14

	template<class T> T imag(const complex<T>&); // constexpr in C++14
	long double imag(long double); // constexpr in C++14
	double imag(double); // constexpr in C++14
	template<Integral T> double imag(T); // constexpr in C++14
	float imag(float); // constexpr in C++14

	template<class T> T abs(const complex<T>&);

	template<class T> T arg(const complex<T>&);
	long double arg(long double);
	double arg(double);
	template<Integral T> double arg(T);
	float arg(float);

	template<class T> T norm(const complex<T>&);
	long double norm(long double);
	double norm(double);
	template<Integral T> double norm(T);
	float norm(float);

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

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

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

	// 26.3.8 transcendentals:
	template<class T> complex<T> acos(const complex<T>&);
	template<class T> complex<T> asin(const complex<T>&);
	template<class T> complex<T> atan(const complex<T>&);
	template<class T> complex<T> acosh(const complex<T>&);
	template<class T> complex<T> asinh(const complex<T>&);
	template<class T> complex<T> atanh(const complex<T>&);
	template<class T> complex<T> cos (const complex<T>&);
	template<class T> complex<T> cosh (const complex<T>&);
	template<class T> complex<T> exp (const complex<T>&);
	template<class T> complex<T> log (const complex<T>&);
	template<class T> complex<T> log10(const complex<T>&);

	template<class T> complex<T> pow(const complex<T>&, const T&);
	template<class T> complex<T> pow(const complex<T>&, const complex<T>&);
	template<class T> complex<T> pow(const T&, const complex<T>&);

	template<class T> complex<T> sin (const complex<T>&);
	template<class T> complex<T> sinh (const complex<T>&);
	template<class T> complex<T> sqrt (const complex<T>&);
	template<class T> complex<T> tan (const complex<T>&);
	template<class T> complex<T> tanh (const complex<T>&);

	template<class T, class charT, class traits>
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is, complex<T>& x);

	template<class T, class charT, class traits>
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& o, const complex<T>& x);

	} // std

	*/

	#include <__config>
	#include <type_traits>
	#include <stdexcept>
	#include <cmath>
	#include <sstream>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	template<class _Tp> class _LIBCPP_TEMPLATE_VIS complex;

	template<class _Tp> complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
	template<class _Tp> complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);

	template<class _Tp>
	class _LIBCPP_TEMPLATE_VIS complex
	{
	public:
	typedef _Tp value_type;
	private:
	value_type __re_;
	value_type __im_;
	public:
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	complex(const value_type& __re = value_type(), const value_type& __im = value_type())
	: __re_(__re), __im_(__im) {}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	complex(const complex<_Xp>& __c)
	: __re_(__c.real()), __im_(__c.imag()) {}

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 value_type real() const {return __re_;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 value_type imag() const {return __im_;}

	_LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
	_LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}

	_LIBCPP_INLINE_VISIBILITY complex& operator= (const value_type& __re)
	{__re_ = __re; __im_ = value_type(); return *this;}
	_LIBCPP_INLINE_VISIBILITY complex& operator+=(const value_type& __re) {__re_ += __re; return *this;}
	_LIBCPP_INLINE_VISIBILITY complex& operator-=(const value_type& __re) {__re_ -= __re; return *this;}
	_LIBCPP_INLINE_VISIBILITY complex& operator=(const value_type& __re) {__re_ = __re; __im_ = __re; return this;}
	_LIBCPP_INLINE_VISIBILITY complex& operator/=(const value_type& __re) {__re_ /= __re; __im_ /= __re; return *this;}

	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
	{
	__re_ = __c.real();
	__im_ = __c.imag();
	return *this;
	}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
	{
	__re_ += __c.real();
	__im_ += __c.imag();
	return *this;
	}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
	{
	__re_ -= __c.real();
	__im_ -= __c.imag();
	return *this;
	}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
	{
	this = this * complex(__c.real(), __c.imag());
	return *this;
	}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
	{
	this = this / complex(__c.real(), __c.imag());
	return *this;
	}
	};

	template<> class _LIBCPP_TEMPLATE_VIS complex<double>;
	template<> class _LIBCPP_TEMPLATE_VIS complex<long double>;

	template<>
	class _LIBCPP_TEMPLATE_VIS complex<float>
	{
	float __re_;
	float __im_;
	public:
	typedef float value_type;

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(float __re = 0.0f, float __im = 0.0f)
	: __re_(__re), __im_(__im) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
	_LIBCPP_INLINE_VISIBILITY
	explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float real() const {return __re_;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float imag() const {return __im_;}

	_LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
	_LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}

	_LIBCPP_INLINE_VISIBILITY complex& operator= (float __re)
	{__re_ = __re; __im_ = value_type(); return *this;}
	_LIBCPP_INLINE_VISIBILITY complex& operator+=(float __re) {__re_ += __re; return *this;}
	_LIBCPP_INLINE_VISIBILITY complex& operator-=(float __re) {__re_ -= __re; return *this;}
	_LIBCPP_INLINE_VISIBILITY complex& operator=(float __re) {__re_ = __re; __im_ = __re; return this;}
	_LIBCPP_INLINE_VISIBILITY complex& operator/=(float __re) {__re_ /= __re; __im_ /= __re; return *this;}

	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
	{
	__re_ = __c.real();
	__im_ = __c.imag();
	return *this;
	}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
	{
	__re_ += __c.real();
	__im_ += __c.imag();
	return *this;
	}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
	{
	__re_ -= __c.real();
	__im_ -= __c.imag();
	return *this;
	}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
	{
	this = this * complex(__c.real(), __c.imag());
	return *this;
	}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
	{
	this = this / complex(__c.real(), __c.imag());
	return *this;
	}
	};

	template<>
	class _LIBCPP_TEMPLATE_VIS complex<double>
	{
	double __re_;
	double __im_;
	public:
	typedef double value_type;

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(double __re = 0.0, double __im = 0.0)
	: __re_(__re), __im_(__im) {}
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR complex(const complex<float>& __c);
	_LIBCPP_INLINE_VISIBILITY
	explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double real() const {return __re_;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double imag() const {return __im_;}

	_LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
	_LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}

	_LIBCPP_INLINE_VISIBILITY complex& operator= (double __re)
	{__re_ = __re; __im_ = value_type(); return *this;}
	_LIBCPP_INLINE_VISIBILITY complex& operator+=(double __re) {__re_ += __re; return *this;}
	_LIBCPP_INLINE_VISIBILITY complex& operator-=(double __re) {__re_ -= __re; return *this;}
	_LIBCPP_INLINE_VISIBILITY complex& operator=(double __re) {__re_ = __re; __im_ = __re; return this;}
	_LIBCPP_INLINE_VISIBILITY complex& operator/=(double __re) {__re_ /= __re; __im_ /= __re; return *this;}

	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
	{
	__re_ = __c.real();
	__im_ = __c.imag();
	return *this;
	}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
	{
	__re_ += __c.real();
	__im_ += __c.imag();
	return *this;
	}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
	{
	__re_ -= __c.real();
	__im_ -= __c.imag();
	return *this;
	}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
	{
	this = this * complex(__c.real(), __c.imag());
	return *this;
	}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
	{
	this = this / complex(__c.real(), __c.imag());
	return *this;
	}
	};

	template<>
	class _LIBCPP_TEMPLATE_VIS complex<long double>
	{
	long double __re_;
	long double __im_;
	public:
	typedef long double value_type;

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(long double __re = 0.0L, long double __im = 0.0L)
	: __re_(__re), __im_(__im) {}
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR complex(const complex<float>& __c);
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR complex(const complex<double>& __c);

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double real() const {return __re_;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double imag() const {return __im_;}

	_LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
	_LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}

	_LIBCPP_INLINE_VISIBILITY complex& operator= (long double __re)
	{__re_ = __re; __im_ = value_type(); return *this;}
	_LIBCPP_INLINE_VISIBILITY complex& operator+=(long double __re) {__re_ += __re; return *this;}
	_LIBCPP_INLINE_VISIBILITY complex& operator-=(long double __re) {__re_ -= __re; return *this;}
	_LIBCPP_INLINE_VISIBILITY complex& operator=(long double __re) {__re_ = __re; __im_ = __re; return this;}
	_LIBCPP_INLINE_VISIBILITY complex& operator/=(long double __re) {__re_ /= __re; __im_ /= __re; return *this;}

	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator= (const complex<_Xp>& __c)
	{
	__re_ = __c.real();
	__im_ = __c.imag();
	return *this;
	}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator+=(const complex<_Xp>& __c)
	{
	__re_ += __c.real();
	__im_ += __c.imag();
	return *this;
	}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator-=(const complex<_Xp>& __c)
	{
	__re_ -= __c.real();
	__im_ -= __c.imag();
	return *this;
	}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator*=(const complex<_Xp>& __c)
	{
	this = this * complex(__c.real(), __c.imag());
	return *this;
	}
	template<class _Xp> _LIBCPP_INLINE_VISIBILITY complex& operator/=(const complex<_Xp>& __c)
	{
	this = this / complex(__c.real(), __c.imag());
	return *this;
	}
	};

	inline
	_LIBCPP_CONSTEXPR
	complex<float>::complex(const complex<double>& __c)
	: __re_(__c.real()), __im_(__c.imag()) {}

	inline
	_LIBCPP_CONSTEXPR
	complex<float>::complex(const complex<long double>& __c)
	: __re_(__c.real()), __im_(__c.imag()) {}

	inline
	_LIBCPP_CONSTEXPR
	complex<double>::complex(const complex<float>& __c)
	: __re_(__c.real()), __im_(__c.imag()) {}

	inline
	_LIBCPP_CONSTEXPR
	complex<double>::complex(const complex<long double>& __c)
	: __re_(__c.real()), __im_(__c.imag()) {}

	inline
	_LIBCPP_CONSTEXPR
	complex<long double>::complex(const complex<float>& __c)
	: __re_(__c.real()), __im_(__c.imag()) {}

	inline
	_LIBCPP_CONSTEXPR
	complex<long double>::complex(const complex<double>& __c)
	: __re_(__c.real()), __im_(__c.imag()) {}

	// 26.3.6 operators:

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
	{
	complex<_Tp> __t(__x);
	__t += __y;
	return __t;
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	operator+(const complex<_Tp>& __x, const _Tp& __y)
	{
	complex<_Tp> __t(__x);
	__t += __y;
	return __t;
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	operator+(const _Tp& __x, const complex<_Tp>& __y)
	{
	complex<_Tp> __t(__y);
	__t += __x;
	return __t;
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
	{
	complex<_Tp> __t(__x);
	__t -= __y;
	return __t;
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	operator-(const complex<_Tp>& __x, const _Tp& __y)
	{
	complex<_Tp> __t(__x);
	__t -= __y;
	return __t;
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	operator-(const _Tp& __x, const complex<_Tp>& __y)
	{
	complex<_Tp> __t(-__y);
	__t += __x;
	return __t;
	}

	template<class _Tp>
	complex<_Tp>
	operator*(const complex<_Tp>& __z, const complex<_Tp>& __w)
	{
	_Tp __a = __z.real();
	_Tp __b = __z.imag();
	_Tp __c = __w.real();
	_Tp __d = __w.imag();
	_Tp __ac = __a * __c;
	_Tp __bd = __b * __d;
	_Tp __ad = __a * __d;
	_Tp __bc = __b * __c;
	_Tp __x = __ac - __bd;
	_Tp __y = __ad + __bc;
	if (__libcpp_isnan_or_builtin(__x) && __libcpp_isnan_or_builtin(__y))
	{
	bool __recalc = false;
	if (__libcpp_isinf_or_builtin(__a) \|\| __libcpp_isinf_or_builtin(__b))
	{
	__a = copysign(__libcpp_isinf_or_builtin(__a) ? _Tp(1) : _Tp(0), __a);
	__b = copysign(__libcpp_isinf_or_builtin(__b) ? _Tp(1) : _Tp(0), __b);
	if (__libcpp_isnan_or_builtin(__c))
	__c = copysign(_Tp(0), __c);
	if (__libcpp_isnan_or_builtin(__d))
	__d = copysign(_Tp(0), __d);
	__recalc = true;
	}
	if (__libcpp_isinf_or_builtin(__c) \|\| __libcpp_isinf_or_builtin(__d))
	{
	__c = copysign(__libcpp_isinf_or_builtin(__c) ? _Tp(1) : _Tp(0), __c);
	__d = copysign(__libcpp_isinf_or_builtin(__d) ? _Tp(1) : _Tp(0), __d);
	if (__libcpp_isnan_or_builtin(__a))
	__a = copysign(_Tp(0), __a);
	if (__libcpp_isnan_or_builtin(__b))
	__b = copysign(_Tp(0), __b);
	__recalc = true;
	}
	if (!__recalc && (__libcpp_isinf_or_builtin(__ac) \|\| __libcpp_isinf_or_builtin(__bd) \|\|
	__libcpp_isinf_or_builtin(__ad) \|\| __libcpp_isinf_or_builtin(__bc)))
	{
	if (__libcpp_isnan_or_builtin(__a))
	__a = copysign(_Tp(0), __a);
	if (__libcpp_isnan_or_builtin(__b))
	__b = copysign(_Tp(0), __b);
	if (__libcpp_isnan_or_builtin(__c))
	__c = copysign(_Tp(0), __c);
	if (__libcpp_isnan_or_builtin(__d))
	__d = copysign(_Tp(0), __d);
	__recalc = true;
	}
	if (__recalc)
	{
	__x = _Tp(INFINITY) * (__a * __c - __b * __d);
	__y = _Tp(INFINITY) * (__a * __d + __b * __c);
	}
	}
	return complex<_Tp>(__x, __y);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	operator*(const complex<_Tp>& __x, const _Tp& __y)
	{
	complex<_Tp> __t(__x);
	__t *= __y;
	return __t;
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	operator*(const _Tp& __x, const complex<_Tp>& __y)
	{
	complex<_Tp> __t(__y);
	__t *= __x;
	return __t;
	}

	template<class _Tp>
	complex<_Tp>
	operator/(const complex<_Tp>& __z, const complex<_Tp>& __w)
	{
	int __ilogbw = 0;
	_Tp __a = __z.real();
	_Tp __b = __z.imag();
	_Tp __c = __w.real();
	_Tp __d = __w.imag();
	_Tp __logbw = logb(fmax(fabs(__c), fabs(__d)));
	if (__libcpp_isfinite_or_builtin(__logbw))
	{
	__ilogbw = static_cast<int>(__logbw);
	__c = scalbn(__c, -__ilogbw);
	__d = scalbn(__d, -__ilogbw);
	}
	_Tp __denom = __c * __c + __d * __d;
	_Tp __x = scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
	_Tp __y = scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
	if (__libcpp_isnan_or_builtin(__x) && __libcpp_isnan_or_builtin(__y))
	{
	if ((__denom == _Tp(0)) && (!__libcpp_isnan_or_builtin(__a) \|\| !__libcpp_isnan_or_builtin(__b)))
	{
	__x = copysign(_Tp(INFINITY), __c) * __a;
	__y = copysign(_Tp(INFINITY), __c) * __b;
	}
	else if ((__libcpp_isinf_or_builtin(__a) \|\| __libcpp_isinf_or_builtin(__b)) && __libcpp_isfinite_or_builtin(__c) && __libcpp_isfinite_or_builtin(__d))
	{
	__a = copysign(__libcpp_isinf_or_builtin(__a) ? _Tp(1) : _Tp(0), __a);
	__b = copysign(__libcpp_isinf_or_builtin(__b) ? _Tp(1) : _Tp(0), __b);
	__x = _Tp(INFINITY) * (__a * __c + __b * __d);
	__y = _Tp(INFINITY) * (__b * __c - __a * __d);
	}
	else if (__libcpp_isinf_or_builtin(__logbw) && __logbw > _Tp(0) && __libcpp_isfinite_or_builtin(__a) && __libcpp_isfinite_or_builtin(__b))
	{
	__c = copysign(__libcpp_isinf_or_builtin(__c) ? _Tp(1) : _Tp(0), __c);
	__d = copysign(__libcpp_isinf_or_builtin(__d) ? _Tp(1) : _Tp(0), __d);
	__x = _Tp(0) * (__a * __c + __b * __d);
	__y = _Tp(0) * (__b * __c - __a * __d);
	}
	}
	return complex<_Tp>(__x, __y);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	operator/(const complex<_Tp>& __x, const _Tp& __y)
	{
	return complex<_Tp>(__x.real() / __y, __x.imag() / __y);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	operator/(const _Tp& __x, const complex<_Tp>& __y)
	{
	complex<_Tp> __t(__x);
	__t /= __y;
	return __t;
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	operator+(const complex<_Tp>& __x)
	{
	return __x;
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	operator-(const complex<_Tp>& __x)
	{
	return complex<_Tp>(-__x.real(), -__x.imag());
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
	{
	return __x.real() == __y.real() && __x.imag() == __y.imag();
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator==(const complex<_Tp>& __x, const _Tp& __y)
	{
	return __x.real() == __y && __x.imag() == 0;
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator==(const _Tp& __x, const complex<_Tp>& __y)
	{
	return __x == __y.real() && 0 == __y.imag();
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
	{
	return !(__x == __y);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator!=(const complex<_Tp>& __x, const _Tp& __y)
	{
	return !(__x == __y);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator!=(const _Tp& __x, const complex<_Tp>& __y)
	{
	return !(__x == __y);
	}

	// 26.3.7 values:

	template <class _Tp, bool = is_integral<_Tp>::value,
	bool = is_floating_point<_Tp>::value
	>
	struct __libcpp_complex_overload_traits {};

	// Integral Types
	template <class _Tp>
	struct __libcpp_complex_overload_traits<_Tp, true, false>
	{
	typedef double _ValueType;
	typedef complex<double> _ComplexType;
	};

	// Floating point types
	template <class _Tp>
	struct __libcpp_complex_overload_traits<_Tp, false, true>
	{
	typedef _Tp _ValueType;
	typedef complex<_Tp> _ComplexType;
	};

	// real

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_Tp
	real(const complex<_Tp>& __c)
	{
	return __c.real();
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	typename __libcpp_complex_overload_traits<_Tp>::_ValueType
	real(_Tp __re)
	{
	return __re;
	}

	// imag

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_Tp
	imag(const complex<_Tp>& __c)
	{
	return __c.imag();
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	typename __libcpp_complex_overload_traits<_Tp>::_ValueType
	imag(_Tp)
	{
	return 0;
	}

	// abs

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	abs(const complex<_Tp>& __c)
	{
	return hypot(__c.real(), __c.imag());
	}

	// arg

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	arg(const complex<_Tp>& __c)
	{
	return atan2(__c.imag(), __c.real());
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if<
	is_same<_Tp, long double>::value,
	long double
	>::type
	arg(_Tp __re)
	{
	return atan2l(0.L, __re);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value \|\| is_same<_Tp, double>::value,
	double
	>::type
	arg(_Tp __re)
	{
	return atan2(0., __re);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if<
	is_same<_Tp, float>::value,
	float
	>::type
	arg(_Tp __re)
	{
	return atan2f(0.F, __re);
	}

	// norm

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	norm(const complex<_Tp>& __c)
	{
	if (__libcpp_isinf_or_builtin(__c.real()))
	return abs(__c.real());
	if (__libcpp_isinf_or_builtin(__c.imag()))
	return abs(__c.imag());
	return __c.real() * __c.real() + __c.imag() * __c.imag();
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename __libcpp_complex_overload_traits<_Tp>::_ValueType
	norm(_Tp __re)
	{
	typedef typename __libcpp_complex_overload_traits<_Tp>::_ValueType _ValueType;
	return static_cast<_ValueType>(__re) * __re;
	}

	// conj

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	conj(const complex<_Tp>& __c)
	{
	return complex<_Tp>(__c.real(), -__c.imag());
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
	conj(_Tp __re)
	{
	typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
	return _ComplexType(__re);
	}



	// proj

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	proj(const complex<_Tp>& __c)
	{
	std::complex<_Tp> __r = __c;
	if (__libcpp_isinf_or_builtin(__c.real()) \|\| __libcpp_isinf_or_builtin(__c.imag()))
	__r = complex<_Tp>(INFINITY, copysign(_Tp(0), __c.imag()));
	return __r;
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_floating_point<_Tp>::value,
	typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
	>::type
	proj(_Tp __re)
	{
	if (__libcpp_isinf_or_builtin(__re))
	__re = abs(__re);
	return complex<_Tp>(__re);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_integral<_Tp>::value,
	typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
	>::type
	proj(_Tp __re)
	{
	typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
	return _ComplexType(__re);
	}

	// polar

	template<class _Tp>
	complex<_Tp>
	-polar(const _Tp& __rho, const _Tp& __theta = _Tp(0))
	+polar(const _Tp& __rho, const _Tp& __theta = _Tp())
	{
	if (__libcpp_isnan_or_builtin(__rho) \|\| signbit(__rho))
	return complex<_Tp>(_Tp(NAN), _Tp(NAN));
	if (__libcpp_isnan_or_builtin(__theta))
	{
	if (__libcpp_isinf_or_builtin(__rho))
	return complex<_Tp>(__rho, __theta);
	return complex<_Tp>(__theta, __theta);
	}
	if (__libcpp_isinf_or_builtin(__theta))
	{
	if (__libcpp_isinf_or_builtin(__rho))
	return complex<_Tp>(__rho, _Tp(NAN));
	return complex<_Tp>(_Tp(NAN), _Tp(NAN));
	}
	_Tp __x = __rho * cos(__theta);
	if (__libcpp_isnan_or_builtin(__x))
	__x = 0;
	_Tp __y = __rho * sin(__theta);
	if (__libcpp_isnan_or_builtin(__y))
	__y = 0;
	return complex<_Tp>(__x, __y);
	}

	// log

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	log(const complex<_Tp>& __x)
	{
	return complex<_Tp>(log(abs(__x)), arg(__x));
	}

	// log10

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	log10(const complex<_Tp>& __x)
	{
	return log(__x) / log(_Tp(10));
	}

	// sqrt

	template<class _Tp>
	complex<_Tp>
	sqrt(const complex<_Tp>& __x)
	{
	if (__libcpp_isinf_or_builtin(__x.imag()))
	return complex<_Tp>(_Tp(INFINITY), __x.imag());
	if (__libcpp_isinf_or_builtin(__x.real()))
	{
	if (__x.real() > _Tp(0))
	return complex<_Tp>(__x.real(), __libcpp_isnan_or_builtin(__x.imag()) ? __x.imag() : copysign(_Tp(0), __x.imag()));
	return complex<_Tp>(__libcpp_isnan_or_builtin(__x.imag()) ? __x.imag() : _Tp(0), copysign(__x.real(), __x.imag()));
	}
	return polar(sqrt(abs(__x)), arg(__x) / _Tp(2));
	}

	// exp

	template<class _Tp>
	complex<_Tp>
	exp(const complex<_Tp>& __x)
	{
	_Tp __i = __x.imag();
	if (__libcpp_isinf_or_builtin(__x.real()))
	{
	if (__x.real() < _Tp(0))
	{
	if (!__libcpp_isfinite_or_builtin(__i))
	__i = _Tp(1);
	}
	else if (__i == 0 \|\| !__libcpp_isfinite_or_builtin(__i))
	{
	if (__libcpp_isinf_or_builtin(__i))
	__i = _Tp(NAN);
	return complex<_Tp>(__x.real(), __i);
	}
	}
	else if (__libcpp_isnan_or_builtin(__x.real()) && __x.imag() == 0)
	return __x;
	_Tp __e = exp(__x.real());
	return complex<_Tp>(__e * cos(__i), __e * sin(__i));
	}

	// pow

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
	{
	return exp(__y * log(__x));
	}

	template<class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<typename __promote<_Tp, _Up>::type>
	pow(const complex<_Tp>& __x, const complex<_Up>& __y)
	{
	typedef complex<typename __promote<_Tp, _Up>::type> result_type;
	return _VSTD::pow(result_type(__x), result_type(__y));
	}

	template<class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_arithmetic<_Up>::value,
	complex<typename __promote<_Tp, _Up>::type>
	>::type
	pow(const complex<_Tp>& __x, const _Up& __y)
	{
	typedef complex<typename __promote<_Tp, _Up>::type> result_type;
	return _VSTD::pow(result_type(__x), result_type(__y));
	}

	template<class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_arithmetic<_Tp>::value,
	complex<typename __promote<_Tp, _Up>::type>
	>::type
	pow(const _Tp& __x, const complex<_Up>& __y)
	{
	typedef complex<typename __promote<_Tp, _Up>::type> result_type;
	return _VSTD::pow(result_type(__x), result_type(__y));
	}

	+// __sqr, computes pow(x, 2)
	+
	+template<class _Tp>
	+inline _LIBCPP_INLINE_VISIBILITY
	+complex<_Tp>
	+__sqr(const complex<_Tp>& __x)
	+{
	+ return complex<_Tp>((__x.real() - __x.imag()) * (__x.real() + __x.imag()),
	+ _Tp(2) * __x.real() * __x.imag());
	+}
	+
	// asinh

	template<class _Tp>
	complex<_Tp>
	asinh(const complex<_Tp>& __x)
	{
	const _Tp __pi(atan2(+0., -0.));
	if (__libcpp_isinf_or_builtin(__x.real()))
	{
	if (__libcpp_isnan_or_builtin(__x.imag()))
	return __x;
	if (__libcpp_isinf_or_builtin(__x.imag()))
	return complex<_Tp>(__x.real(), copysign(__pi * _Tp(0.25), __x.imag()));
	return complex<_Tp>(__x.real(), copysign(_Tp(0), __x.imag()));
	}
	if (__libcpp_isnan_or_builtin(__x.real()))
	{
	if (__libcpp_isinf_or_builtin(__x.imag()))
	return complex<_Tp>(__x.imag(), __x.real());
	if (__x.imag() == 0)
	return __x;
	return complex<_Tp>(__x.real(), __x.real());
	}
	if (__libcpp_isinf_or_builtin(__x.imag()))
	return complex<_Tp>(copysign(__x.imag(), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
	- complex<_Tp> __z = log(__x + sqrt(pow(__x, _Tp(2)) + _Tp(1)));
	+ complex<_Tp> __z = log(__x + sqrt(__sqr(__x) + _Tp(1)));
	return complex<_Tp>(copysign(__z.real(), __x.real()), copysign(__z.imag(), __x.imag()));
	}

	// acosh

	template<class _Tp>
	complex<_Tp>
	acosh(const complex<_Tp>& __x)
	{
	const _Tp __pi(atan2(+0., -0.));
	if (__libcpp_isinf_or_builtin(__x.real()))
	{
	if (__libcpp_isnan_or_builtin(__x.imag()))
	return complex<_Tp>(abs(__x.real()), __x.imag());
	if (__libcpp_isinf_or_builtin(__x.imag()))
	{
	if (__x.real() > 0)
	return complex<_Tp>(__x.real(), copysign(__pi * _Tp(0.25), __x.imag()));
	else
	return complex<_Tp>(-__x.real(), copysign(__pi * _Tp(0.75), __x.imag()));
	}
	if (__x.real() < 0)
	return complex<_Tp>(-__x.real(), copysign(__pi, __x.imag()));
	return complex<_Tp>(__x.real(), copysign(_Tp(0), __x.imag()));
	}
	if (__libcpp_isnan_or_builtin(__x.real()))
	{
	if (__libcpp_isinf_or_builtin(__x.imag()))
	return complex<_Tp>(abs(__x.imag()), __x.real());
	return complex<_Tp>(__x.real(), __x.real());
	}
	if (__libcpp_isinf_or_builtin(__x.imag()))
	return complex<_Tp>(abs(__x.imag()), copysign(__pi/_Tp(2), __x.imag()));
	- complex<_Tp> __z = log(__x + sqrt(pow(__x, _Tp(2)) - _Tp(1)));
	+ complex<_Tp> __z = log(__x + sqrt(__sqr(__x) - _Tp(1)));
	return complex<_Tp>(copysign(__z.real(), _Tp(0)), copysign(__z.imag(), __x.imag()));
	}

	// atanh

	template<class _Tp>
	complex<_Tp>
	atanh(const complex<_Tp>& __x)
	{
	const _Tp __pi(atan2(+0., -0.));
	if (__libcpp_isinf_or_builtin(__x.imag()))
	{
	return complex<_Tp>(copysign(_Tp(0), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
	}
	if (__libcpp_isnan_or_builtin(__x.imag()))
	{
	if (__libcpp_isinf_or_builtin(__x.real()) \|\| __x.real() == 0)
	return complex<_Tp>(copysign(_Tp(0), __x.real()), __x.imag());
	return complex<_Tp>(__x.imag(), __x.imag());
	}
	if (__libcpp_isnan_or_builtin(__x.real()))
	{
	return complex<_Tp>(__x.real(), __x.real());
	}
	if (__libcpp_isinf_or_builtin(__x.real()))
	{
	return complex<_Tp>(copysign(_Tp(0), __x.real()), copysign(__pi/_Tp(2), __x.imag()));
	}
	if (abs(__x.real()) == _Tp(1) && __x.imag() == _Tp(0))
	{
	return complex<_Tp>(copysign(_Tp(INFINITY), __x.real()), copysign(_Tp(0), __x.imag()));
	}
	complex<_Tp> __z = log((_Tp(1) + __x) / (_Tp(1) - __x)) / _Tp(2);
	return complex<_Tp>(copysign(__z.real(), __x.real()), copysign(__z.imag(), __x.imag()));
	}

	// sinh

	template<class _Tp>
	complex<_Tp>
	sinh(const complex<_Tp>& __x)
	{
	if (__libcpp_isinf_or_builtin(__x.real()) && !__libcpp_isfinite_or_builtin(__x.imag()))
	return complex<_Tp>(__x.real(), _Tp(NAN));
	if (__x.real() == 0 && !__libcpp_isfinite_or_builtin(__x.imag()))
	return complex<_Tp>(__x.real(), _Tp(NAN));
	if (__x.imag() == 0 && !__libcpp_isfinite_or_builtin(__x.real()))
	return __x;
	return complex<_Tp>(sinh(__x.real()) * cos(__x.imag()), cosh(__x.real()) * sin(__x.imag()));
	}

	// cosh

	template<class _Tp>
	complex<_Tp>
	cosh(const complex<_Tp>& __x)
	{
	if (__libcpp_isinf_or_builtin(__x.real()) && !__libcpp_isfinite_or_builtin(__x.imag()))
	return complex<_Tp>(abs(__x.real()), _Tp(NAN));
	if (__x.real() == 0 && !__libcpp_isfinite_or_builtin(__x.imag()))
	return complex<_Tp>(_Tp(NAN), __x.real());
	if (__x.real() == 0 && __x.imag() == 0)
	return complex<_Tp>(_Tp(1), __x.imag());
	if (__x.imag() == 0 && !__libcpp_isfinite_or_builtin(__x.real()))
	return complex<_Tp>(abs(__x.real()), __x.imag());
	return complex<_Tp>(cosh(__x.real()) * cos(__x.imag()), sinh(__x.real()) * sin(__x.imag()));
	}

	// tanh

	template<class _Tp>
	complex<_Tp>
	tanh(const complex<_Tp>& __x)
	{
	if (__libcpp_isinf_or_builtin(__x.real()))
	{
	if (!__libcpp_isfinite_or_builtin(__x.imag()))
	return complex<_Tp>(_Tp(1), _Tp(0));
	return complex<_Tp>(_Tp(1), copysign(_Tp(0), sin(_Tp(2) * __x.imag())));
	}
	if (__libcpp_isnan_or_builtin(__x.real()) && __x.imag() == 0)
	return __x;
	_Tp __2r(_Tp(2) * __x.real());
	_Tp __2i(_Tp(2) * __x.imag());
	_Tp __d(cosh(__2r) + cos(__2i));
	_Tp __2rsh(sinh(__2r));
	if (__libcpp_isinf_or_builtin(__2rsh) && __libcpp_isinf_or_builtin(__d))
	return complex<_Tp>(__2rsh > _Tp(0) ? _Tp(1) : _Tp(-1),
	__2i > _Tp(0) ? _Tp(0) : _Tp(-0.));
	return complex<_Tp>(__2rsh/__d, sin(__2i)/__d);
	}

	// asin

	template<class _Tp>
	complex<_Tp>
	asin(const complex<_Tp>& __x)
	{
	complex<_Tp> __z = asinh(complex<_Tp>(-__x.imag(), __x.real()));
	return complex<_Tp>(__z.imag(), -__z.real());
	}

	// acos

	template<class _Tp>
	complex<_Tp>
	acos(const complex<_Tp>& __x)
	{
	const _Tp __pi(atan2(+0., -0.));
	if (__libcpp_isinf_or_builtin(__x.real()))
	{
	if (__libcpp_isnan_or_builtin(__x.imag()))
	return complex<_Tp>(__x.imag(), __x.real());
	if (__libcpp_isinf_or_builtin(__x.imag()))
	{
	if (__x.real() < _Tp(0))
	return complex<_Tp>(_Tp(0.75) * __pi, -__x.imag());
	return complex<_Tp>(_Tp(0.25) * __pi, -__x.imag());
	}
	if (__x.real() < _Tp(0))
	return complex<_Tp>(__pi, signbit(__x.imag()) ? -__x.real() : __x.real());
	return complex<_Tp>(_Tp(0), signbit(__x.imag()) ? __x.real() : -__x.real());
	}
	if (__libcpp_isnan_or_builtin(__x.real()))
	{
	if (__libcpp_isinf_or_builtin(__x.imag()))
	return complex<_Tp>(__x.real(), -__x.imag());
	return complex<_Tp>(__x.real(), __x.real());
	}
	if (__libcpp_isinf_or_builtin(__x.imag()))
	return complex<_Tp>(__pi/_Tp(2), -__x.imag());
	if (__x.real() == 0 && (__x.imag() == 0 \|\| isnan(__x.imag())))
	return complex<_Tp>(__pi/_Tp(2), -__x.imag());
	- complex<_Tp> __z = log(__x + sqrt(pow(__x, _Tp(2)) - _Tp(1)));
	+ complex<_Tp> __z = log(__x + sqrt(__sqr(__x) - _Tp(1)));
	if (signbit(__x.imag()))
	return complex<_Tp>(abs(__z.imag()), abs(__z.real()));
	return complex<_Tp>(abs(__z.imag()), -abs(__z.real()));
	}

	// atan

	template<class _Tp>
	complex<_Tp>
	atan(const complex<_Tp>& __x)
	{
	complex<_Tp> __z = atanh(complex<_Tp>(-__x.imag(), __x.real()));
	return complex<_Tp>(__z.imag(), -__z.real());
	}

	// sin

	template<class _Tp>
	complex<_Tp>
	sin(const complex<_Tp>& __x)
	{
	complex<_Tp> __z = sinh(complex<_Tp>(-__x.imag(), __x.real()));
	return complex<_Tp>(__z.imag(), -__z.real());
	}

	// cos

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	complex<_Tp>
	cos(const complex<_Tp>& __x)
	{
	return cosh(complex<_Tp>(-__x.imag(), __x.real()));
	}

	// tan

	template<class _Tp>
	complex<_Tp>
	tan(const complex<_Tp>& __x)
	{
	complex<_Tp> __z = tanh(complex<_Tp>(-__x.imag(), __x.real()));
	return complex<_Tp>(__z.imag(), -__z.real());
	}

	template<class _Tp, class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
	{
	if (__is.good())
	{
	ws(__is);
	if (__is.peek() == _CharT('('))
	{
	__is.get();
	_Tp __r;
	__is >> __r;
	if (!__is.fail())
	{
	ws(__is);
	_CharT __c = __is.peek();
	if (__c == _CharT(','))
	{
	__is.get();
	_Tp __i;
	__is >> __i;
	if (!__is.fail())
	{
	ws(__is);
	__c = __is.peek();
	if (__c == _CharT(')'))
	{
	__is.get();
	__x = complex<_Tp>(__r, __i);
	}
	else
	__is.setstate(ios_base::failbit);
	}
	else
	__is.setstate(ios_base::failbit);
	}
	else if (__c == _CharT(')'))
	{
	__is.get();
	__x = complex<_Tp>(__r, _Tp(0));
	}
	else
	__is.setstate(ios_base::failbit);
	}
	else
	__is.setstate(ios_base::failbit);
	}
	else
	{
	_Tp __r;
	__is >> __r;
	if (!__is.fail())
	__x = complex<_Tp>(__r, _Tp(0));
	else
	__is.setstate(ios_base::failbit);
	}
	}
	else
	__is.setstate(ios_base::failbit);
	return __is;
	}

	template<class _Tp, class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
	{
	basic_ostringstream<_CharT, _Traits> __s;
	__s.flags(__os.flags());
	__s.imbue(__os.getloc());
	__s.precision(__os.precision());
	__s << '(' << __x.real() << ',' << __x.imag() << ')';
	return __os << __s.str();
	}

	#if _LIBCPP_STD_VER > 11
	// Literal suffix for complex number literals [complex.literals]
	inline namespace literals
	{
	inline namespace complex_literals
	{
	constexpr complex<long double> operator""il(long double __im)
	{
	return { 0.0l, __im };
	}

	constexpr complex<long double> operator""il(unsigned long long __im)
	{
	return { 0.0l, static_cast<long double>(__im) };
	}


	constexpr complex<double> operator""i(long double __im)
	{
	return { 0.0, static_cast<double>(__im) };
	}

	constexpr complex<double> operator""i(unsigned long long __im)
	{
	return { 0.0, static_cast<double>(__im) };
	}


	constexpr complex<float> operator""if(long double __im)
	{
	return { 0.0f, static_cast<float>(__im) };
	}

	constexpr complex<float> operator""if(unsigned long long __im)
	{
	return { 0.0f, static_cast<float>(__im) };
	}
	}
	}
	#endif

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_COMPLEX
	Index: projects/clang700-import/contrib/libc++/include/complex.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/complex.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/complex.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/include/complex.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/ctype.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/ctype.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/ctype.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/include/ctype.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/deque
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/deque (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/deque (revision 337135)
	@@ -1,2910 +1,2933 @@
	// -- C++ --
	//===---------------------------- deque -----------------------------------===//
	//
	// 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_DEQUE
	#define _LIBCPP_DEQUE

	/*
	deque synopsis

	namespace std
	{

	template <class T, class Allocator = allocator<T> >
	class deque
	{
	public:
	// types:
	typedef T value_type;
	typedef Allocator allocator_type;

	typedef typename allocator_type::reference reference;
	typedef typename allocator_type::const_reference const_reference;
	typedef implementation-defined iterator;
	typedef implementation-defined const_iterator;
	typedef typename allocator_type::size_type size_type;
	typedef typename allocator_type::difference_type difference_type;

	typedef typename allocator_type::pointer pointer;
	typedef typename allocator_type::const_pointer const_pointer;
	typedef std::reverse_iterator<iterator> reverse_iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

	// construct/copy/destroy:
	deque() noexcept(is_nothrow_default_constructible<allocator_type>::value);
	explicit deque(const allocator_type& a);
	explicit deque(size_type n);
	explicit deque(size_type n, const allocator_type& a); // C++14
	deque(size_type n, const value_type& v);
	deque(size_type n, const value_type& v, const allocator_type& a);
	template <class InputIterator>
	deque(InputIterator f, InputIterator l);
	template <class InputIterator>
	deque(InputIterator f, InputIterator l, const allocator_type& a);
	deque(const deque& c);
	deque(deque&& c)
	noexcept(is_nothrow_move_constructible<allocator_type>::value);
	deque(initializer_list<value_type> il, const Allocator& a = allocator_type());
	deque(const deque& c, const allocator_type& a);
	deque(deque&& c, const allocator_type& a);
	~deque();

	deque& operator=(const deque& c);
	deque& operator=(deque&& c)
	noexcept(
	allocator_type::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<allocator_type>::value);
	deque& operator=(initializer_list<value_type> il);

	template <class InputIterator>
	void assign(InputIterator f, InputIterator l);
	void assign(size_type n, const value_type& v);
	void assign(initializer_list<value_type> il);

	allocator_type get_allocator() const noexcept;

	// iterators:

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

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

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

	// capacity:
	size_type size() const noexcept;
	size_type max_size() const noexcept;
	void resize(size_type n);
	void resize(size_type n, const value_type& v);
	void shrink_to_fit();
	bool empty() const noexcept;

	// element access:
	reference operator[](size_type i);
	const_reference operator[](size_type i) const;
	reference at(size_type i);
	const_reference at(size_type i) const;
	reference front();
	const_reference front() const;
	reference back();
	const_reference back() const;

	// modifiers:
	void push_front(const value_type& v);
	void push_front(value_type&& v);
	void push_back(const value_type& v);
	void push_back(value_type&& v);
	template <class... Args> reference emplace_front(Args&&... args); // reference in C++17
	template <class... Args> reference emplace_back(Args&&... args); // reference in C++17
	template <class... Args> iterator emplace(const_iterator p, Args&&... args);
	iterator insert(const_iterator p, const value_type& v);
	iterator insert(const_iterator p, value_type&& v);
	iterator insert(const_iterator p, size_type n, const value_type& v);
	template <class InputIterator>
	iterator insert(const_iterator p, InputIterator f, InputIterator l);
	iterator insert(const_iterator p, initializer_list<value_type> il);
	void pop_front();
	void pop_back();
	iterator erase(const_iterator p);
	iterator erase(const_iterator f, const_iterator l);
	void swap(deque& c)
	noexcept(allocator_traits<allocator_type>::is_always_equal::value); // C++17
	void clear() noexcept;
	};

	+template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
	+ deque(InputIterator, InputIterator, Allocator = Allocator())
	+ -> deque<typename iterator_traits<InputIterator>::value_type, Allocator>;
	+
	template <class T, class Allocator>
	bool operator==(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
	template <class T, class Allocator>
	bool operator< (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
	template <class T, class Allocator>
	bool operator!=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
	template <class T, class Allocator>
	bool operator> (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
	template <class T, class Allocator>
	bool operator>=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
	template <class T, class Allocator>
	bool operator<=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);

	// specialized algorithms:
	template <class T, class Allocator>
	void swap(deque<T,Allocator>& x, deque<T,Allocator>& y)
	noexcept(noexcept(x.swap(y)));

	} // std

	*/

	#include <__config>
	#include <__split_buffer>
	#include <type_traits>
	#include <initializer_list>
	#include <iterator>
	#include <algorithm>
	#include <stdexcept>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _Tp, class _Allocator> class __deque_base;
	template <class _Tp, class _Allocator = allocator<_Tp> > class _LIBCPP_TEMPLATE_VIS deque;

	template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
	class _DiffType, _DiffType _BlockSize>
	class _LIBCPP_TEMPLATE_VIS __deque_iterator;

	template <class _RAIter,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	copy(_RAIter __f,
	_RAIter __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _OutputIterator>
	_OutputIterator
	copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	_OutputIterator __r);

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r);

	template <class _RAIter,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	copy_backward(_RAIter __f,
	_RAIter __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _OutputIterator>
	_OutputIterator
	copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	_OutputIterator __r);

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r);

	template <class _RAIter,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	move(_RAIter __f,
	_RAIter __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _OutputIterator>
	_OutputIterator
	move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	_OutputIterator __r);

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r);

	template <class _RAIter,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	move_backward(_RAIter __f,
	_RAIter __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _OutputIterator>
	_OutputIterator
	move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	_OutputIterator __r);

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r);

	template <class _ValueType, class _DiffType>
	struct __deque_block_size {
	static const _DiffType value = sizeof(_ValueType) < 256 ? 4096 / sizeof(_ValueType) : 16;
	};

	template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
	class _DiffType, _DiffType _BS =
	#ifdef _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE
	// Keep template parameter to avoid changing all template declarations thoughout
	// this file.
	0
	#else
	__deque_block_size<_ValueType, _DiffType>::value
	#endif
	>
	class _LIBCPP_TEMPLATE_VIS __deque_iterator
	{
	typedef _MapPointer __map_iterator;
	public:
	typedef _Pointer pointer;
	typedef _DiffType difference_type;
	private:
	__map_iterator __m_iter_;
	pointer __ptr_;

	static const difference_type __block_size;
	public:
	typedef _ValueType value_type;
	typedef random_access_iterator_tag iterator_category;
	typedef _Reference reference;

	_LIBCPP_INLINE_VISIBILITY __deque_iterator() _NOEXCEPT
	#if _LIBCPP_STD_VER > 11
	: __m_iter_(nullptr), __ptr_(nullptr)
	#endif
	{}

	template <class _Pp, class _Rp, class _MP>
	_LIBCPP_INLINE_VISIBILITY
	__deque_iterator(const __deque_iterator<value_type, _Pp, _Rp, _MP, difference_type, _BS>& __it,
	typename enable_if<is_convertible<_Pp, pointer>::value>::type* = 0) _NOEXCEPT
	: __m_iter_(__it.__m_iter_), __ptr_(__it.__ptr_) {}

	_LIBCPP_INLINE_VISIBILITY reference operator() const {return __ptr_;}
	_LIBCPP_INLINE_VISIBILITY pointer operator->() const {return __ptr_;}

	_LIBCPP_INLINE_VISIBILITY __deque_iterator& operator++()
	{
	if (++__ptr_ - *__m_iter_ == __block_size)
	{
	++__m_iter_;
	__ptr_ = *__m_iter_;
	}
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY __deque_iterator operator++(int)
	{
	__deque_iterator __tmp = *this;
	++(*this);
	return __tmp;
	}

	_LIBCPP_INLINE_VISIBILITY __deque_iterator& operator--()
	{
	if (__ptr_ == *__m_iter_)
	{
	--__m_iter_;
	__ptr_ = *__m_iter_ + __block_size;
	}
	--__ptr_;
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY __deque_iterator operator--(int)
	{
	__deque_iterator __tmp = *this;
	--(*this);
	return __tmp;
	}

	_LIBCPP_INLINE_VISIBILITY __deque_iterator& operator+=(difference_type __n)
	{
	if (__n != 0)
	{
	__n += __ptr_ - *__m_iter_;
	if (__n > 0)
	{
	__m_iter_ += __n / __block_size;
	__ptr_ = *__m_iter_ + __n % __block_size;
	}
	else // (__n < 0)
	{
	difference_type __z = __block_size - 1 - __n;
	__m_iter_ -= __z / __block_size;
	__ptr_ = *__m_iter_ + (__block_size - 1 - __z % __block_size);
	}
	}
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY __deque_iterator& operator-=(difference_type __n)
	{
	return *this += -__n;
	}

	_LIBCPP_INLINE_VISIBILITY __deque_iterator operator+(difference_type __n) const
	{
	__deque_iterator __t(*this);
	__t += __n;
	return __t;
	}

	_LIBCPP_INLINE_VISIBILITY __deque_iterator operator-(difference_type __n) const
	{
	__deque_iterator __t(*this);
	__t -= __n;
	return __t;
	}

	_LIBCPP_INLINE_VISIBILITY
	friend __deque_iterator operator+(difference_type __n, const __deque_iterator& __it)
	{return __it + __n;}

	_LIBCPP_INLINE_VISIBILITY
	friend difference_type operator-(const __deque_iterator& __x, const __deque_iterator& __y)
	{
	if (__x != __y)
	return (__x.__m_iter_ - __y.__m_iter_) * __block_size
	+ (__x.__ptr_ - *__x.__m_iter_)
	- (__y.__ptr_ - *__y.__m_iter_);
	return 0;
	}

	_LIBCPP_INLINE_VISIBILITY reference operator[](difference_type __n) const
	{return (this + __n);}

	_LIBCPP_INLINE_VISIBILITY friend
	bool operator==(const __deque_iterator& __x, const __deque_iterator& __y)
	{return __x.__ptr_ == __y.__ptr_;}

	_LIBCPP_INLINE_VISIBILITY friend
	bool operator!=(const __deque_iterator& __x, const __deque_iterator& __y)
	{return !(__x == __y);}

	_LIBCPP_INLINE_VISIBILITY friend
	bool operator<(const __deque_iterator& __x, const __deque_iterator& __y)
	{return __x.__m_iter_ < __y.__m_iter_ \|\|
	(__x.__m_iter_ == __y.__m_iter_ && __x.__ptr_ < __y.__ptr_);}

	_LIBCPP_INLINE_VISIBILITY friend
	bool operator>(const __deque_iterator& __x, const __deque_iterator& __y)
	{return __y < __x;}

	_LIBCPP_INLINE_VISIBILITY friend
	bool operator<=(const __deque_iterator& __x, const __deque_iterator& __y)
	{return !(__y < __x);}

	_LIBCPP_INLINE_VISIBILITY friend
	bool operator>=(const __deque_iterator& __x, const __deque_iterator& __y)
	{return !(__x < __y);}

	private:
	_LIBCPP_INLINE_VISIBILITY __deque_iterator(__map_iterator __m, pointer __p) _NOEXCEPT
	: __m_iter_(__m), __ptr_(__p) {}

	template <class _Tp, class _Ap> friend class __deque_base;
	template <class _Tp, class _Ap> friend class _LIBCPP_TEMPLATE_VIS deque;
	template <class _Vp, class _Pp, class _Rp, class _MP, class _Dp, _Dp>
	friend class _LIBCPP_TEMPLATE_VIS __deque_iterator;

	template <class _RAIter,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	friend
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	copy(_RAIter __f,
	_RAIter __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*);

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _OutputIterator>
	friend
	_OutputIterator
	copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	_OutputIterator __r);

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	friend
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r);

	template <class _RAIter,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	friend
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	copy_backward(_RAIter __f,
	_RAIter __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*);

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _OutputIterator>
	friend
	_OutputIterator
	copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	_OutputIterator __r);

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	friend
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r);

	template <class _RAIter,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	friend
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	move(_RAIter __f,
	_RAIter __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*);

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _OutputIterator>
	friend
	_OutputIterator
	move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	_OutputIterator __r);

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	friend
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r);

	template <class _RAIter,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	friend
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	move_backward(_RAIter __f,
	_RAIter __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*);

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _OutputIterator>
	friend
	_OutputIterator
	move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	_OutputIterator __r);

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	friend
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r);
	};

	template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
	class _DiffType, _DiffType _BlockSize>
	const _DiffType __deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer,
	_DiffType, _BlockSize>::__block_size =
	__deque_block_size<_ValueType, _DiffType>::value;

	// copy

	template <class _RAIter,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	copy(_RAIter __f,
	_RAIter __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*)
	{
	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::difference_type difference_type;
	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
	const difference_type __block_size = __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::__block_size;
	while (__f != __l)
	{
	pointer __rb = __r.__ptr_;
	pointer __re = *__r.__m_iter_ + __block_size;
	difference_type __bs = __re - __rb;
	difference_type __n = __l - __f;
	_RAIter __m = __l;
	if (__n > __bs)
	{
	__n = __bs;
	__m = __f + __n;
	}
	_VSTD::copy(__f, __m, __rb);
	__f = __m;
	__r += __n;
	}
	return __r;
	}

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _OutputIterator>
	_OutputIterator
	copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	_OutputIterator __r)
	{
	typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::difference_type difference_type;
	typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::pointer pointer;
	const difference_type __block_size = __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::__block_size;
	difference_type __n = __l - __f;
	while (__n > 0)
	{
	pointer __fb = __f.__ptr_;
	pointer __fe = *__f.__m_iter_ + __block_size;
	difference_type __bs = __fe - __fb;
	if (__bs > __n)
	{
	__bs = __n;
	__fe = __fb + __bs;
	}
	__r = _VSTD::copy(__fb, __fe, __r);
	__n -= __bs;
	__f += __bs;
	}
	return __r;
	}

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r)
	{
	typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::difference_type difference_type;
	typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::pointer pointer;
	const difference_type __block_size = __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::__block_size;
	difference_type __n = __l - __f;
	while (__n > 0)
	{
	pointer __fb = __f.__ptr_;
	pointer __fe = *__f.__m_iter_ + __block_size;
	difference_type __bs = __fe - __fb;
	if (__bs > __n)
	{
	__bs = __n;
	__fe = __fb + __bs;
	}
	__r = _VSTD::copy(__fb, __fe, __r);
	__n -= __bs;
	__f += __bs;
	}
	return __r;
	}

	// copy_backward

	template <class _RAIter,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	copy_backward(_RAIter __f,
	_RAIter __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*)
	{
	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::difference_type difference_type;
	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
	while (__f != __l)
	{
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _VSTD::prev(__r);
	pointer __rb = *__rp.__m_iter_;
	pointer __re = __rp.__ptr_ + 1;
	difference_type __bs = __re - __rb;
	difference_type __n = __l - __f;
	_RAIter __m = __f;
	if (__n > __bs)
	{
	__n = __bs;
	__m = __l - __n;
	}
	_VSTD::copy_backward(__m, __l, __re);
	__l = __m;
	__r -= __n;
	}
	return __r;
	}

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _OutputIterator>
	_OutputIterator
	copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	_OutputIterator __r)
	{
	typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::difference_type difference_type;
	typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::pointer pointer;
	difference_type __n = __l - __f;
	while (__n > 0)
	{
	--__l;
	pointer __lb = *__l.__m_iter_;
	pointer __le = __l.__ptr_ + 1;
	difference_type __bs = __le - __lb;
	if (__bs > __n)
	{
	__bs = __n;
	__lb = __le - __bs;
	}
	__r = _VSTD::copy_backward(__lb, __le, __r);
	__n -= __bs;
	__l -= __bs - 1;
	}
	return __r;
	}

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r)
	{
	typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::difference_type difference_type;
	typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::pointer pointer;
	difference_type __n = __l - __f;
	while (__n > 0)
	{
	--__l;
	pointer __lb = *__l.__m_iter_;
	pointer __le = __l.__ptr_ + 1;
	difference_type __bs = __le - __lb;
	if (__bs > __n)
	{
	__bs = __n;
	__lb = __le - __bs;
	}
	__r = _VSTD::copy_backward(__lb, __le, __r);
	__n -= __bs;
	__l -= __bs - 1;
	}
	return __r;
	}

	// move

	template <class _RAIter,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	move(_RAIter __f,
	_RAIter __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*)
	{
	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::difference_type difference_type;
	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
	const difference_type __block_size = __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::__block_size;
	while (__f != __l)
	{
	pointer __rb = __r.__ptr_;
	pointer __re = *__r.__m_iter_ + __block_size;
	difference_type __bs = __re - __rb;
	difference_type __n = __l - __f;
	_RAIter __m = __l;
	if (__n > __bs)
	{
	__n = __bs;
	__m = __f + __n;
	}
	_VSTD::move(__f, __m, __rb);
	__f = __m;
	__r += __n;
	}
	return __r;
	}

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _OutputIterator>
	_OutputIterator
	move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	_OutputIterator __r)
	{
	typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::difference_type difference_type;
	typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::pointer pointer;
	const difference_type __block_size = __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::__block_size;
	difference_type __n = __l - __f;
	while (__n > 0)
	{
	pointer __fb = __f.__ptr_;
	pointer __fe = *__f.__m_iter_ + __block_size;
	difference_type __bs = __fe - __fb;
	if (__bs > __n)
	{
	__bs = __n;
	__fe = __fb + __bs;
	}
	__r = _VSTD::move(__fb, __fe, __r);
	__n -= __bs;
	__f += __bs;
	}
	return __r;
	}

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r)
	{
	typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::difference_type difference_type;
	typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::pointer pointer;
	const difference_type __block_size = __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::__block_size;
	difference_type __n = __l - __f;
	while (__n > 0)
	{
	pointer __fb = __f.__ptr_;
	pointer __fe = *__f.__m_iter_ + __block_size;
	difference_type __bs = __fe - __fb;
	if (__bs > __n)
	{
	__bs = __n;
	__fe = __fb + __bs;
	}
	__r = _VSTD::move(__fb, __fe, __r);
	__n -= __bs;
	__f += __bs;
	}
	return __r;
	}

	// move_backward

	template <class _RAIter,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	move_backward(_RAIter __f,
	_RAIter __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r,
	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*)
	{
	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::difference_type difference_type;
	typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
	while (__f != __l)
	{
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _VSTD::prev(__r);
	pointer __rb = *__rp.__m_iter_;
	pointer __re = __rp.__ptr_ + 1;
	difference_type __bs = __re - __rb;
	difference_type __n = __l - __f;
	_RAIter __m = __f;
	if (__n > __bs)
	{
	__n = __bs;
	__m = __l - __n;
	}
	_VSTD::move_backward(__m, __l, __re);
	__l = __m;
	__r -= __n;
	}
	return __r;
	}

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _OutputIterator>
	_OutputIterator
	move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	_OutputIterator __r)
	{
	typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::difference_type difference_type;
	typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::pointer pointer;
	difference_type __n = __l - __f;
	while (__n > 0)
	{
	--__l;
	pointer __lb = *__l.__m_iter_;
	pointer __le = __l.__ptr_ + 1;
	difference_type __bs = __le - __lb;
	if (__bs > __n)
	{
	__bs = __n;
	__lb = __le - __bs;
	}
	__r = _VSTD::move_backward(__lb, __le, __r);
	__n -= __bs;
	__l -= __bs - 1;
	}
	return __r;
	}

	template <class _V1, class _P1, class _R1, class _M1, class _D1, _D1 _B1,
	class _V2, class _P2, class _R2, class _M2, class _D2, _D2 _B2>
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>
	move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
	__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __l,
	__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __r)
	{
	typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::difference_type difference_type;
	typedef typename __deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1>::pointer pointer;
	difference_type __n = __l - __f;
	while (__n > 0)
	{
	--__l;
	pointer __lb = *__l.__m_iter_;
	pointer __le = __l.__ptr_ + 1;
	difference_type __bs = __le - __lb;
	if (__bs > __n)
	{
	__bs = __n;
	__lb = __le - __bs;
	}
	__r = _VSTD::move_backward(__lb, __le, __r);
	__n -= __bs;
	__l -= __bs - 1;
	}
	return __r;
	}

	template <bool>
	class __deque_base_common
	{
	protected:
	_LIBCPP_NORETURN void __throw_length_error() const;
	_LIBCPP_NORETURN void __throw_out_of_range() const;
	};

	template <bool __b>
	void
	__deque_base_common<__b>::__throw_length_error() const
	{
	_VSTD::__throw_length_error("deque");
	}

	template <bool __b>
	void
	__deque_base_common<__b>::__throw_out_of_range() const
	{
	_VSTD::__throw_out_of_range("deque");
	}

	template <class _Tp, class _Allocator>
	class __deque_base
	: protected __deque_base_common<true>
	{
	__deque_base(const __deque_base& __c);
	__deque_base& operator=(const __deque_base& __c);
	-protected:
	- typedef _Tp value_type;
	+public:
	typedef _Allocator allocator_type;
	typedef allocator_traits<allocator_type> __alloc_traits;
	+ typedef typename __alloc_traits::size_type size_type;
	+protected:
	+ typedef _Tp value_type;
	typedef value_type& reference;
	typedef const value_type& const_reference;
	- typedef typename __alloc_traits::size_type size_type;
	typedef typename __alloc_traits::difference_type difference_type;
	typedef typename __alloc_traits::pointer pointer;
	typedef typename __alloc_traits::const_pointer const_pointer;

	static const difference_type __block_size;

	typedef typename __rebind_alloc_helper<__alloc_traits, pointer>::type __pointer_allocator;
	typedef allocator_traits<__pointer_allocator> __map_traits;
	typedef typename __map_traits::pointer __map_pointer;
	typedef typename __rebind_alloc_helper<__alloc_traits, const_pointer>::type __const_pointer_allocator;
	typedef typename allocator_traits<__const_pointer_allocator>::const_pointer __map_const_pointer;
	typedef __split_buffer<pointer, __pointer_allocator> __map;

	typedef __deque_iterator<value_type, pointer, reference, __map_pointer,
	difference_type> iterator;
	typedef __deque_iterator<value_type, const_pointer, const_reference, __map_const_pointer,
	difference_type> const_iterator;

	+protected:
	__map __map_;
	size_type __start_;
	__compressed_pair<size_type, allocator_type> __size_;

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

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

	_LIBCPP_INLINE_VISIBILITY
	__deque_base()
	_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
	_LIBCPP_INLINE_VISIBILITY
	explicit __deque_base(const allocator_type& __a);
	public:
	~__deque_base();

	#ifndef _LIBCPP_CXX03_LANG
	__deque_base(__deque_base&& __c)
	_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
	__deque_base(__deque_base&& __c, const allocator_type& __a);
	#endif // _LIBCPP_CXX03_LANG

	void swap(__deque_base& __c)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT;
	#else
	_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<allocator_type>::value);
	#endif
	protected:
	void clear() _NOEXCEPT;

	bool __invariants() const;

	_LIBCPP_INLINE_VISIBILITY
	void __move_assign(__deque_base& __c)
	_NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<allocator_type>::value)
	{
	__map_ = _VSTD::move(__c.__map_);
	__start_ = __c.__start_;
	size() = __c.size();
	__move_assign_alloc(__c);
	__c.__start_ = __c.size() = 0;
	}

	_LIBCPP_INLINE_VISIBILITY
	void __move_assign_alloc(__deque_base& __c)
	_NOEXCEPT_(!__alloc_traits::propagate_on_container_move_assignment::value \|\|
	is_nothrow_move_assignable<allocator_type>::value)
	{__move_assign_alloc(__c, integral_constant<bool,
	__alloc_traits::propagate_on_container_move_assignment::value>());}

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

	_LIBCPP_INLINE_VISIBILITY
	void __move_assign_alloc(__deque_base&, false_type) _NOEXCEPT
	{}
	};

	template <class _Tp, class _Allocator>
	const typename __deque_base<_Tp, _Allocator>::difference_type
	__deque_base<_Tp, _Allocator>::__block_size =
	__deque_block_size<value_type, difference_type>::value;

	template <class _Tp, class _Allocator>
	bool
	__deque_base<_Tp, _Allocator>::__invariants() const
	{
	if (!__map_.__invariants())
	return false;
	if (__map_.size() >= size_type(-1) / __block_size)
	return false;
	for (typename __map::const_iterator __i = __map_.begin(), __e = __map_.end();
	__i != __e; ++__i)
	if (*__i == nullptr)
	return false;
	if (__map_.size() != 0)
	{
	if (size() >= __map_.size() * __block_size)
	return false;
	if (__start_ >= __map_.size() * __block_size - size())
	return false;
	}
	else
	{
	if (size() != 0)
	return false;
	if (__start_ != 0)
	return false;
	}
	return true;
	}

	template <class _Tp, class _Allocator>
	typename __deque_base<_Tp, _Allocator>::iterator
	__deque_base<_Tp, _Allocator>::begin() _NOEXCEPT
	{
	__map_pointer __mp = __map_.begin() + __start_ / __block_size;
	return iterator(__mp, __map_.empty() ? 0 : *__mp + __start_ % __block_size);
	}

	template <class _Tp, class _Allocator>
	typename __deque_base<_Tp, _Allocator>::const_iterator
	__deque_base<_Tp, _Allocator>::begin() const _NOEXCEPT
	{
	__map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __start_ / __block_size);
	return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __start_ % __block_size);
	}

	template <class _Tp, class _Allocator>
	typename __deque_base<_Tp, _Allocator>::iterator
	__deque_base<_Tp, _Allocator>::end() _NOEXCEPT
	{
	size_type __p = size() + __start_;
	__map_pointer __mp = __map_.begin() + __p / __block_size;
	return iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __block_size);
	}

	template <class _Tp, class _Allocator>
	typename __deque_base<_Tp, _Allocator>::const_iterator
	__deque_base<_Tp, _Allocator>::end() const _NOEXCEPT
	{
	size_type __p = size() + __start_;
	__map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __p / __block_size);
	return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __block_size);
	}

	template <class _Tp, class _Allocator>
	inline
	__deque_base<_Tp, _Allocator>::__deque_base()
	_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
	: __start_(0), __size_(0) {}

	template <class _Tp, class _Allocator>
	inline
	__deque_base<_Tp, _Allocator>::__deque_base(const allocator_type& __a)
	: __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {}

	template <class _Tp, class _Allocator>
	__deque_base<_Tp, _Allocator>::~__deque_base()
	{
	clear();
	typename __map::iterator __i = __map_.begin();
	typename __map::iterator __e = __map_.end();
	for (; __i != __e; ++__i)
	__alloc_traits::deallocate(__alloc(), *__i, __block_size);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Allocator>
	__deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c)
	_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
	: __map_(_VSTD::move(__c.__map_)),
	__start_(_VSTD::move(__c.__start_)),
	__size_(_VSTD::move(__c.__size_))
	{
	__c.__start_ = 0;
	__c.size() = 0;
	}

	template <class _Tp, class _Allocator>
	__deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c, const allocator_type& __a)
	: __map_(_VSTD::move(__c.__map_), __pointer_allocator(__a)),
	__start_(_VSTD::move(__c.__start_)),
	__size_(_VSTD::move(__c.size()), __a)
	{
	if (__a == __c.__alloc())
	{
	__c.__start_ = 0;
	__c.size() = 0;
	}
	else
	{
	__map_.clear();
	__start_ = 0;
	size() = 0;
	}
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Allocator>
	void
	__deque_base<_Tp, _Allocator>::swap(__deque_base& __c)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT
	#else
	_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<allocator_type>::value)
	#endif
	{
	__map_.swap(__c.__map_);
	_VSTD::swap(__start_, __c.__start_);
	_VSTD::swap(size(), __c.size());
	__swap_allocator(__alloc(), __c.__alloc());
	}

	template <class _Tp, class _Allocator>
	void
	__deque_base<_Tp, _Allocator>::clear() _NOEXCEPT
	{
	allocator_type& __a = __alloc();
	for (iterator __i = begin(), __e = end(); __i != __e; ++__i)
	__alloc_traits::destroy(__a, _VSTD::addressof(*__i));
	size() = 0;
	while (__map_.size() > 2)
	{
	__alloc_traits::deallocate(__a, __map_.front(), __block_size);
	__map_.pop_front();
	}
	switch (__map_.size())
	{
	case 1:
	__start_ = __block_size / 2;
	break;
	case 2:
	__start_ = __block_size;
	break;
	}
	}

	template <class _Tp, class _Allocator /= allocator<_Tp>/>
	class _LIBCPP_TEMPLATE_VIS deque
	: private __deque_base<_Tp, _Allocator>
	{
	public:
	// types:

	typedef _Tp value_type;
	typedef _Allocator allocator_type;

	static_assert((is_same<typename allocator_type::value_type, value_type>::value),
	"Allocator::value_type must be same type as value_type");

	typedef __deque_base<value_type, allocator_type> __base;

	typedef typename __base::__alloc_traits __alloc_traits;
	typedef typename __base::reference reference;
	typedef typename __base::const_reference const_reference;
	typedef typename __base::iterator iterator;
	typedef typename __base::const_iterator const_iterator;
	typedef typename __base::size_type size_type;
	typedef typename __base::difference_type difference_type;

	typedef typename __base::pointer pointer;
	typedef typename __base::const_pointer const_pointer;
	typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
	typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;

	// construct/copy/destroy:
	_LIBCPP_INLINE_VISIBILITY
	deque()
	_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
	{}
	_LIBCPP_INLINE_VISIBILITY explicit deque(const allocator_type& __a) : __base(__a) {}
	explicit deque(size_type __n);
	#if _LIBCPP_STD_VER > 11
	explicit deque(size_type __n, const _Allocator& __a);
	#endif
	deque(size_type __n, const value_type& __v);
	deque(size_type __n, const value_type& __v, const allocator_type& __a);
	template <class _InputIter>
	deque(_InputIter __f, _InputIter __l,
	typename enable_if<__is_input_iterator<_InputIter>::value>::type* = 0);
	template <class _InputIter>
	deque(_InputIter __f, _InputIter __l, const allocator_type& __a,
	typename enable_if<__is_input_iterator<_InputIter>::value>::type* = 0);
	deque(const deque& __c);
	deque(const deque& __c, const allocator_type& __a);

	deque& operator=(const deque& __c);

	#ifndef _LIBCPP_CXX03_LANG
	deque(initializer_list<value_type> __il);
	deque(initializer_list<value_type> __il, const allocator_type& __a);

	_LIBCPP_INLINE_VISIBILITY
	deque& operator=(initializer_list<value_type> __il) {assign(__il); return *this;}

	_LIBCPP_INLINE_VISIBILITY
	deque(deque&& __c) _NOEXCEPT_(is_nothrow_move_constructible<__base>::value);
	_LIBCPP_INLINE_VISIBILITY
	deque(deque&& __c, const allocator_type& __a);
	_LIBCPP_INLINE_VISIBILITY
	deque& operator=(deque&& __c)
	_NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<allocator_type>::value);

	_LIBCPP_INLINE_VISIBILITY
	void assign(initializer_list<value_type> __il) {assign(__il.begin(), __il.end());}
	#endif // _LIBCPP_CXX03_LANG

	template <class _InputIter>
	void assign(_InputIter __f, _InputIter __l,
	typename enable_if<__is_input_iterator<_InputIter>::value &&
	!__is_random_access_iterator<_InputIter>::value>::type* = 0);
	template <class _RAIter>
	void assign(_RAIter __f, _RAIter __l,
	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);
	void assign(size_type __n, const value_type& __v);

	_LIBCPP_INLINE_VISIBILITY
	allocator_type get_allocator() const _NOEXCEPT;

	// iterators:

	_LIBCPP_INLINE_VISIBILITY
	iterator begin() _NOEXCEPT {return __base::begin();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator begin() const _NOEXCEPT {return __base::begin();}
	_LIBCPP_INLINE_VISIBILITY
	iterator end() _NOEXCEPT {return __base::end();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator end() const _NOEXCEPT {return __base::end();}

	_LIBCPP_INLINE_VISIBILITY
	reverse_iterator rbegin() _NOEXCEPT
	{return reverse_iterator(__base::end());}
	_LIBCPP_INLINE_VISIBILITY
	const_reverse_iterator rbegin() const _NOEXCEPT
	{return const_reverse_iterator(__base::end());}
	_LIBCPP_INLINE_VISIBILITY
	reverse_iterator rend() _NOEXCEPT
	{return reverse_iterator(__base::begin());}
	_LIBCPP_INLINE_VISIBILITY
	const_reverse_iterator rend() const _NOEXCEPT
	{return const_reverse_iterator(__base::begin());}

	_LIBCPP_INLINE_VISIBILITY
	const_iterator cbegin() const _NOEXCEPT
	{return __base::begin();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator cend() const _NOEXCEPT
	{return __base::end();}
	_LIBCPP_INLINE_VISIBILITY
	const_reverse_iterator crbegin() const _NOEXCEPT
	{return const_reverse_iterator(__base::end());}
	_LIBCPP_INLINE_VISIBILITY
	const_reverse_iterator crend() const _NOEXCEPT
	{return const_reverse_iterator(__base::begin());}

	// capacity:
	_LIBCPP_INLINE_VISIBILITY
	size_type size() const _NOEXCEPT {return __base::size();}
	_LIBCPP_INLINE_VISIBILITY
	size_type max_size() const _NOEXCEPT
	{return std::min<size_type>(
	__alloc_traits::max_size(__base::__alloc()),
	numeric_limits<difference_type>::max());}
	void resize(size_type __n);
	void resize(size_type __n, const value_type& __v);
	void shrink_to_fit() _NOEXCEPT;
	_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
	bool empty() const _NOEXCEPT {return __base::size() == 0;}

	// element access:
	_LIBCPP_INLINE_VISIBILITY
	reference operator[](size_type __i);
	_LIBCPP_INLINE_VISIBILITY
	const_reference operator[](size_type __i) const;
	_LIBCPP_INLINE_VISIBILITY
	reference at(size_type __i);
	_LIBCPP_INLINE_VISIBILITY
	const_reference at(size_type __i) const;
	_LIBCPP_INLINE_VISIBILITY
	reference front();
	_LIBCPP_INLINE_VISIBILITY
	const_reference front() const;
	_LIBCPP_INLINE_VISIBILITY
	reference back();
	_LIBCPP_INLINE_VISIBILITY
	const_reference back() const;

	// 23.2.2.3 modifiers:
	void push_front(const value_type& __v);
	void push_back(const value_type& __v);
	#ifndef _LIBCPP_CXX03_LANG
	#if _LIBCPP_STD_VER > 14
	template <class... _Args> reference emplace_front(_Args&&... __args);
	template <class... _Args> reference emplace_back (_Args&&... __args);
	#else
	template <class... _Args> void emplace_front(_Args&&... __args);
	template <class... _Args> void emplace_back (_Args&&... __args);
	#endif
	template <class... _Args> iterator emplace(const_iterator __p, _Args&&... __args);

	void push_front(value_type&& __v);
	void push_back(value_type&& __v);
	iterator insert(const_iterator __p, value_type&& __v);

	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __p, initializer_list<value_type> __il)
	{return insert(__p, __il.begin(), __il.end());}
	#endif // _LIBCPP_CXX03_LANG
	iterator insert(const_iterator __p, const value_type& __v);
	iterator insert(const_iterator __p, size_type __n, const value_type& __v);
	template <class _InputIter>
	iterator insert(const_iterator __p, _InputIter __f, _InputIter __l,
	typename enable_if<__is_input_iterator<_InputIter>::value
	&&!__is_forward_iterator<_InputIter>::value>::type* = 0);
	template <class _ForwardIterator>
	iterator insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l,
	typename enable_if<__is_forward_iterator<_ForwardIterator>::value
	&&!__is_bidirectional_iterator<_ForwardIterator>::value>::type* = 0);
	template <class _BiIter>
	iterator insert(const_iterator __p, _BiIter __f, _BiIter __l,
	typename enable_if<__is_bidirectional_iterator<_BiIter>::value>::type* = 0);

	void pop_front();
	void pop_back();
	iterator erase(const_iterator __p);
	iterator erase(const_iterator __f, const_iterator __l);

	_LIBCPP_INLINE_VISIBILITY
	void swap(deque& __c)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT;
	#else
	_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<allocator_type>::value);
	#endif
	_LIBCPP_INLINE_VISIBILITY
	void clear() _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY
	bool __invariants() const {return __base::__invariants();}
	private:
	typedef typename __base::__map_const_pointer __map_const_pointer;

	_LIBCPP_INLINE_VISIBILITY
	static size_type __recommend_blocks(size_type __n)
	{
	return __n / __base::__block_size + (__n % __base::__block_size != 0);
	}
	_LIBCPP_INLINE_VISIBILITY
	size_type __capacity() const
	{
	return __base::__map_.size() == 0 ? 0 : __base::__map_.size() * __base::__block_size - 1;
	}
	_LIBCPP_INLINE_VISIBILITY
	size_type __front_spare() const
	{
	return __base::__start_;
	}
	_LIBCPP_INLINE_VISIBILITY
	size_type __back_spare() const
	{
	return __capacity() - (__base::__start_ + __base::size());
	}

	template <class _InpIter>
	void __append(_InpIter __f, _InpIter __l,
	typename enable_if<__is_input_iterator<_InpIter>::value &&
	!__is_forward_iterator<_InpIter>::value>::type* = 0);
	template <class _ForIter>
	void __append(_ForIter __f, _ForIter __l,
	typename enable_if<__is_forward_iterator<_ForIter>::value>::type* = 0);
	void __append(size_type __n);
	void __append(size_type __n, const value_type& __v);
	void __erase_to_end(const_iterator __f);
	void __add_front_capacity();
	void __add_front_capacity(size_type __n);
	void __add_back_capacity();
	void __add_back_capacity(size_type __n);
	iterator __move_and_check(iterator __f, iterator __l, iterator __r,
	const_pointer& __vt);
	iterator __move_backward_and_check(iterator __f, iterator __l, iterator __r,
	const_pointer& __vt);
	void __move_construct_and_check(iterator __f, iterator __l,
	iterator __r, const_pointer& __vt);
	void __move_construct_backward_and_check(iterator __f, iterator __l,
	iterator __r, const_pointer& __vt);

	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const deque& __c)
	{__copy_assign_alloc(__c, integral_constant<bool,
	__alloc_traits::propagate_on_container_copy_assignment::value>());}

	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const deque& __c, true_type)
	{
	if (__base::__alloc() != __c.__alloc())
	{
	clear();
	shrink_to_fit();
	}
	__base::__alloc() = __c.__alloc();
	__base::__map_.__alloc() = __c.__map_.__alloc();
	}

	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const deque&, false_type)
	{}

	void __move_assign(deque& __c, true_type)
	_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
	void __move_assign(deque& __c, false_type);
	};
	+
	+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
	+template<class _InputIterator,
	+ class _Alloc = typename std::allocator<typename iterator_traits<_InputIterator>::value_type>,
	+ class = typename enable_if<__is_allocator<_Alloc>::value, void>::type
	+ >
	+deque(_InputIterator, _InputIterator)
	+ -> deque<typename iterator_traits<_InputIterator>::value_type, _Alloc>;
	+
	+template<class _InputIterator,
	+ class _Alloc,
	+ class = typename enable_if<__is_allocator<_Alloc>::value, void>::type
	+ >
	+deque(_InputIterator, _InputIterator, _Alloc)
	+ -> deque<typename iterator_traits<_InputIterator>::value_type, _Alloc>;
	+#endif
	+

	template <class _Tp, class _Allocator>
	deque<_Tp, _Allocator>::deque(size_type __n)
	{
	if (__n > 0)
	__append(__n);
	}

	#if _LIBCPP_STD_VER > 11
	template <class _Tp, class _Allocator>
	deque<_Tp, _Allocator>::deque(size_type __n, const _Allocator& __a)
	: __base(__a)
	{
	if (__n > 0)
	__append(__n);
	}
	#endif

	template <class _Tp, class _Allocator>
	deque<_Tp, _Allocator>::deque(size_type __n, const value_type& __v)
	{
	if (__n > 0)
	__append(__n, __v);
	}

	template <class _Tp, class _Allocator>
	deque<_Tp, _Allocator>::deque(size_type __n, const value_type& __v, const allocator_type& __a)
	: __base(__a)
	{
	if (__n > 0)
	__append(__n, __v);
	}

	template <class _Tp, class _Allocator>
	template <class _InputIter>
	deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l,
	typename enable_if<__is_input_iterator<_InputIter>::value>::type*)
	{
	__append(__f, __l);
	}

	template <class _Tp, class _Allocator>
	template <class _InputIter>
	deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l, const allocator_type& __a,
	typename enable_if<__is_input_iterator<_InputIter>::value>::type*)
	: __base(__a)
	{
	__append(__f, __l);
	}

	template <class _Tp, class _Allocator>
	deque<_Tp, _Allocator>::deque(const deque& __c)
	: __base(__alloc_traits::select_on_container_copy_construction(__c.__alloc()))
	{
	__append(__c.begin(), __c.end());
	}

	template <class _Tp, class _Allocator>
	deque<_Tp, _Allocator>::deque(const deque& __c, const allocator_type& __a)
	: __base(__a)
	{
	__append(__c.begin(), __c.end());
	}

	template <class _Tp, class _Allocator>
	deque<_Tp, _Allocator>&
	deque<_Tp, _Allocator>::operator=(const deque& __c)
	{
	if (this != &__c)
	{
	__copy_assign_alloc(__c);
	assign(__c.begin(), __c.end());
	}
	return *this;
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Allocator>
	deque<_Tp, _Allocator>::deque(initializer_list<value_type> __il)
	{
	__append(__il.begin(), __il.end());
	}

	template <class _Tp, class _Allocator>
	deque<_Tp, _Allocator>::deque(initializer_list<value_type> __il, const allocator_type& __a)
	: __base(__a)
	{
	__append(__il.begin(), __il.end());
	}

	template <class _Tp, class _Allocator>
	inline
	deque<_Tp, _Allocator>::deque(deque&& __c)
	_NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
	: __base(_VSTD::move(__c))
	{
	}

	template <class _Tp, class _Allocator>
	inline
	deque<_Tp, _Allocator>::deque(deque&& __c, const allocator_type& __a)
	: __base(_VSTD::move(__c), __a)
	{
	if (__a != __c.__alloc())
	{
	typedef move_iterator<iterator> _Ip;
	assign(_Ip(__c.begin()), _Ip(__c.end()));
	}
	}

	template <class _Tp, class _Allocator>
	inline
	deque<_Tp, _Allocator>&
	deque<_Tp, _Allocator>::operator=(deque&& __c)
	_NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<allocator_type>::value)
	{
	__move_assign(__c, integral_constant<bool,
	__alloc_traits::propagate_on_container_move_assignment::value>());
	return *this;
	}

	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::__move_assign(deque& __c, false_type)
	{
	if (__base::__alloc() != __c.__alloc())
	{
	typedef move_iterator<iterator> _Ip;
	assign(_Ip(__c.begin()), _Ip(__c.end()));
	}
	else
	__move_assign(__c, true_type());
	}

	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::__move_assign(deque& __c, true_type)
	_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
	{
	clear();
	shrink_to_fit();
	__base::__move_assign(__c);
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Allocator>
	template <class _InputIter>
	void
	deque<_Tp, _Allocator>::assign(_InputIter __f, _InputIter __l,
	typename enable_if<__is_input_iterator<_InputIter>::value &&
	!__is_random_access_iterator<_InputIter>::value>::type*)
	{
	iterator __i = __base::begin();
	iterator __e = __base::end();
	for (; __f != __l && __i != __e; ++__f, (void) ++__i)
	__i = __f;
	if (__f != __l)
	__append(__f, __l);
	else
	__erase_to_end(__i);
	}

	template <class _Tp, class _Allocator>
	template <class _RAIter>
	void
	deque<_Tp, _Allocator>::assign(_RAIter __f, _RAIter __l,
	typename enable_if<__is_random_access_iterator<_RAIter>::value>::type*)
	{
	if (static_cast<size_type>(__l - __f) > __base::size())
	{
	_RAIter __m = __f + __base::size();
	_VSTD::copy(__f, __m, __base::begin());
	__append(__m, __l);
	}
	else
	__erase_to_end(_VSTD::copy(__f, __l, __base::begin()));
	}

	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::assign(size_type __n, const value_type& __v)
	{
	if (__n > __base::size())
	{
	_VSTD::fill_n(__base::begin(), __base::size(), __v);
	__n -= __base::size();
	__append(__n, __v);
	}
	else
	__erase_to_end(_VSTD::fill_n(__base::begin(), __n, __v));
	}

	template <class _Tp, class _Allocator>
	inline
	_Allocator
	deque<_Tp, _Allocator>::get_allocator() const _NOEXCEPT
	{
	return __base::__alloc();
	}

	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::resize(size_type __n)
	{
	if (__n > __base::size())
	__append(__n - __base::size());
	else if (__n < __base::size())
	__erase_to_end(__base::begin() + __n);
	}

	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::resize(size_type __n, const value_type& __v)
	{
	if (__n > __base::size())
	__append(__n - __base::size(), __v);
	else if (__n < __base::size())
	__erase_to_end(__base::begin() + __n);
	}

	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
	{
	allocator_type& __a = __base::__alloc();
	if (empty())
	{
	while (__base::__map_.size() > 0)
	{
	__alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
	__base::__map_.pop_back();
	}
	__base::__start_ = 0;
	}
	else
	{
	if (__front_spare() >= __base::__block_size)
	{
	__alloc_traits::deallocate(__a, __base::__map_.front(), __base::__block_size);
	__base::__map_.pop_front();
	__base::__start_ -= __base::__block_size;
	}
	if (__back_spare() >= __base::__block_size)
	{
	__alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
	__base::__map_.pop_back();
	}
	}
	__base::__map_.shrink_to_fit();
	}

	template <class _Tp, class _Allocator>
	inline
	typename deque<_Tp, _Allocator>::reference
	deque<_Tp, _Allocator>::operator[](size_type __i)
	{
	size_type __p = __base::__start_ + __i;
	return ((__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
	}

	template <class _Tp, class _Allocator>
	inline
	typename deque<_Tp, _Allocator>::const_reference
	deque<_Tp, _Allocator>::operator[](size_type __i) const
	{
	size_type __p = __base::__start_ + __i;
	return ((__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
	}

	template <class _Tp, class _Allocator>
	inline
	typename deque<_Tp, _Allocator>::reference
	deque<_Tp, _Allocator>::at(size_type __i)
	{
	if (__i >= __base::size())
	__base::__throw_out_of_range();
	size_type __p = __base::__start_ + __i;
	return ((__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
	}

	template <class _Tp, class _Allocator>
	inline
	typename deque<_Tp, _Allocator>::const_reference
	deque<_Tp, _Allocator>::at(size_type __i) const
	{
	if (__i >= __base::size())
	__base::__throw_out_of_range();
	size_type __p = __base::__start_ + __i;
	return ((__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
	}

	template <class _Tp, class _Allocator>
	inline
	typename deque<_Tp, _Allocator>::reference
	deque<_Tp, _Allocator>::front()
	{
	return ((__base::__map_.begin() + __base::__start_ / __base::__block_size)
	+ __base::__start_ % __base::__block_size);
	}

	template <class _Tp, class _Allocator>
	inline
	typename deque<_Tp, _Allocator>::const_reference
	deque<_Tp, _Allocator>::front() const
	{
	return ((__base::__map_.begin() + __base::__start_ / __base::__block_size)
	+ __base::__start_ % __base::__block_size);
	}

	template <class _Tp, class _Allocator>
	inline
	typename deque<_Tp, _Allocator>::reference
	deque<_Tp, _Allocator>::back()
	{
	size_type __p = __base::size() + __base::__start_ - 1;
	return ((__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
	}

	template <class _Tp, class _Allocator>
	inline
	typename deque<_Tp, _Allocator>::const_reference
	deque<_Tp, _Allocator>::back() const
	{
	size_type __p = __base::size() + __base::__start_ - 1;
	return ((__base::__map_.begin() + __p / __base::__block_size) + __p % __base::__block_size);
	}

	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::push_back(const value_type& __v)
	{
	allocator_type& __a = __base::__alloc();
	if (__back_spare() == 0)
	__add_back_capacity();
	// __back_spare() >= 1
	__alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), __v);
	++__base::size();
	}

	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::push_front(const value_type& __v)
	{
	allocator_type& __a = __base::__alloc();
	if (__front_spare() == 0)
	__add_front_capacity();
	// __front_spare() >= 1
	__alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), __v);
	--__base::__start_;
	++__base::size();
	}

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::push_back(value_type&& __v)
	{
	allocator_type& __a = __base::__alloc();
	if (__back_spare() == 0)
	__add_back_capacity();
	// __back_spare() >= 1
	__alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::move(__v));
	++__base::size();
	}

	template <class _Tp, class _Allocator>
	template <class... _Args>
	#if _LIBCPP_STD_VER > 14
	typename deque<_Tp, _Allocator>::reference
	#else
	void
	#endif
	deque<_Tp, _Allocator>::emplace_back(_Args&&... __args)
	{
	allocator_type& __a = __base::__alloc();
	if (__back_spare() == 0)
	__add_back_capacity();
	// __back_spare() >= 1
	__alloc_traits::construct(__a, _VSTD::addressof(*__base::end()),
	_VSTD::forward<_Args>(__args)...);
	++__base::size();
	#if _LIBCPP_STD_VER > 14
	return *--__base::end();
	#endif
	}

	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::push_front(value_type&& __v)
	{
	allocator_type& __a = __base::__alloc();
	if (__front_spare() == 0)
	__add_front_capacity();
	// __front_spare() >= 1
	__alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::move(__v));
	--__base::__start_;
	++__base::size();
	}


	template <class _Tp, class _Allocator>
	template <class... _Args>
	#if _LIBCPP_STD_VER > 14
	typename deque<_Tp, _Allocator>::reference
	#else
	void
	#endif
	deque<_Tp, _Allocator>::emplace_front(_Args&&... __args)
	{
	allocator_type& __a = __base::__alloc();
	if (__front_spare() == 0)
	__add_front_capacity();
	// __front_spare() >= 1
	__alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::forward<_Args>(__args)...);
	--__base::__start_;
	++__base::size();
	#if _LIBCPP_STD_VER > 14
	return *__base::begin();
	#endif
	}

	template <class _Tp, class _Allocator>
	typename deque<_Tp, _Allocator>::iterator
	deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v)
	{
	size_type __pos = __p - __base::begin();
	size_type __to_end = __base::size() - __pos;
	allocator_type& __a = __base::__alloc();
	if (__pos < __to_end)
	{ // insert by shifting things backward
	if (__front_spare() == 0)
	__add_front_capacity();
	// __front_spare() >= 1
	if (__pos == 0)
	{
	__alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::move(__v));
	--__base::__start_;
	++__base::size();
	}
	else
	{
	iterator __b = __base::begin();
	iterator __bm1 = _VSTD::prev(__b);
	__alloc_traits::construct(__a, _VSTD::addressof(__bm1), _VSTD::move(__b));
	--__base::__start_;
	++__base::size();
	if (__pos > 1)
	__b = _VSTD::move(_VSTD::next(__b), __b + __pos, __b);
	*__b = _VSTD::move(__v);
	}
	}
	else
	{ // insert by shifting things forward
	if (__back_spare() == 0)
	__add_back_capacity();
	// __back_capacity >= 1
	size_type __de = __base::size() - __pos;
	if (__de == 0)
	{
	__alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::move(__v));
	++__base::size();
	}
	else
	{
	iterator __e = __base::end();
	iterator __em1 = _VSTD::prev(__e);
	__alloc_traits::construct(__a, _VSTD::addressof(__e), _VSTD::move(__em1));
	++__base::size();
	if (__de > 1)
	__e = _VSTD::move_backward(__e - __de, __em1, __e);
	*--__e = _VSTD::move(__v);
	}
	}
	return __base::begin() + __pos;
	}

	template <class _Tp, class _Allocator>
	template <class... _Args>
	typename deque<_Tp, _Allocator>::iterator
	deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
	{
	size_type __pos = __p - __base::begin();
	size_type __to_end = __base::size() - __pos;
	allocator_type& __a = __base::__alloc();
	if (__pos < __to_end)
	{ // insert by shifting things backward
	if (__front_spare() == 0)
	__add_front_capacity();
	// __front_spare() >= 1
	if (__pos == 0)
	{
	__alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::forward<_Args>(__args)...);
	--__base::__start_;
	++__base::size();
	}
	else
	{
	__temp_value<value_type, _Allocator> __tmp(this->__alloc(), _VSTD::forward<_Args>(__args)...);
	iterator __b = __base::begin();
	iterator __bm1 = _VSTD::prev(__b);
	__alloc_traits::construct(__a, _VSTD::addressof(__bm1), _VSTD::move(__b));
	--__base::__start_;
	++__base::size();
	if (__pos > 1)
	__b = _VSTD::move(_VSTD::next(__b), __b + __pos, __b);
	*__b = _VSTD::move(__tmp.get());
	}
	}
	else
	{ // insert by shifting things forward
	if (__back_spare() == 0)
	__add_back_capacity();
	// __back_capacity >= 1
	size_type __de = __base::size() - __pos;
	if (__de == 0)
	{
	__alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::forward<_Args>(__args)...);
	++__base::size();
	}
	else
	{
	__temp_value<value_type, _Allocator> __tmp(this->__alloc(), _VSTD::forward<_Args>(__args)...);
	iterator __e = __base::end();
	iterator __em1 = _VSTD::prev(__e);
	__alloc_traits::construct(__a, _VSTD::addressof(__e), _VSTD::move(__em1));
	++__base::size();
	if (__de > 1)
	__e = _VSTD::move_backward(__e - __de, __em1, __e);
	*--__e = _VSTD::move(__tmp.get());
	}
	}
	return __base::begin() + __pos;
	}

	#endif // _LIBCPP_CXX03_LANG


	template <class _Tp, class _Allocator>
	typename deque<_Tp, _Allocator>::iterator
	deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
	{
	size_type __pos = __p - __base::begin();
	size_type __to_end = __base::size() - __pos;
	allocator_type& __a = __base::__alloc();
	if (__pos < __to_end)
	{ // insert by shifting things backward
	if (__front_spare() == 0)
	__add_front_capacity();
	// __front_spare() >= 1
	if (__pos == 0)
	{
	__alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), __v);
	--__base::__start_;
	++__base::size();
	}
	else
	{
	const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
	iterator __b = __base::begin();
	iterator __bm1 = _VSTD::prev(__b);
	if (__vt == pointer_traits<const_pointer>::pointer_to(*__b))
	__vt = pointer_traits<const_pointer>::pointer_to(*__bm1);
	__alloc_traits::construct(__a, _VSTD::addressof(__bm1), _VSTD::move(__b));
	--__base::__start_;
	++__base::size();
	if (__pos > 1)
	__b = __move_and_check(_VSTD::next(__b), __b + __pos, __b, __vt);
	__b = __vt;
	}
	}
	else
	{ // insert by shifting things forward
	if (__back_spare() == 0)
	__add_back_capacity();
	// __back_capacity >= 1
	size_type __de = __base::size() - __pos;
	if (__de == 0)
	{
	__alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), __v);
	++__base::size();
	}
	else
	{
	const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
	iterator __e = __base::end();
	iterator __em1 = _VSTD::prev(__e);
	if (__vt == pointer_traits<const_pointer>::pointer_to(*__em1))
	__vt = pointer_traits<const_pointer>::pointer_to(*__e);
	__alloc_traits::construct(__a, _VSTD::addressof(__e), _VSTD::move(__em1));
	++__base::size();
	if (__de > 1)
	__e = __move_backward_and_check(__e - __de, __em1, __e, __vt);
	--__e = __vt;
	}
	}
	return __base::begin() + __pos;
	}

	template <class _Tp, class _Allocator>
	typename deque<_Tp, _Allocator>::iterator
	deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_type& __v)
	{
	size_type __pos = __p - __base::begin();
	size_type __to_end = __base::size() - __pos;
	allocator_type& __a = __base::__alloc();
	if (__pos < __to_end)
	{ // insert by shifting things backward
	if (__n > __front_spare())
	__add_front_capacity(__n - __front_spare());
	// __n <= __front_spare()
	iterator __old_begin = __base::begin();
	iterator __i = __old_begin;
	if (__n > __pos)
	{
	for (size_type __m = __n - __pos; __m; --__m, --__base::__start_, ++__base::size())
	__alloc_traits::construct(__a, _VSTD::addressof(*--__i), __v);
	__n = __pos;
	}
	if (__n > 0)
	{
	const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
	iterator __obn = __old_begin + __n;
	__move_construct_backward_and_check(__old_begin, __obn, __i, __vt);
	if (__n < __pos)
	__old_begin = __move_and_check(__obn, __old_begin + __pos, __old_begin, __vt);
	_VSTD::fill_n(__old_begin, __n, *__vt);
	}
	}
	else
	{ // insert by shifting things forward
	size_type __back_capacity = __back_spare();
	if (__n > __back_capacity)
	__add_back_capacity(__n - __back_capacity);
	// __n <= __back_capacity
	iterator __old_end = __base::end();
	iterator __i = __old_end;
	size_type __de = __base::size() - __pos;
	if (__n > __de)
	{
	for (size_type __m = __n - __de; __m; --__m, ++__i, ++__base::size())
	__alloc_traits::construct(__a, _VSTD::addressof(*__i), __v);
	__n = __de;
	}
	if (__n > 0)
	{
	const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
	iterator __oen = __old_end - __n;
	__move_construct_and_check(__oen, __old_end, __i, __vt);
	if (__n < __de)
	__old_end = __move_backward_and_check(__old_end - __de, __oen, __old_end, __vt);
	_VSTD::fill_n(__old_end - __n, __n, *__vt);
	}
	}
	return __base::begin() + __pos;
	}

	template <class _Tp, class _Allocator>
	template <class _InputIter>
	typename deque<_Tp, _Allocator>::iterator
	deque<_Tp, _Allocator>::insert(const_iterator __p, _InputIter __f, _InputIter __l,
	typename enable_if<__is_input_iterator<_InputIter>::value
	&&!__is_forward_iterator<_InputIter>::value>::type*)
	{
	__split_buffer<value_type, allocator_type&> __buf(__base::__alloc());
	__buf.__construct_at_end(__f, __l);
	typedef typename __split_buffer<value_type, allocator_type&>::iterator __bi;
	return insert(__p, move_iterator<__bi>(__buf.begin()), move_iterator<__bi>(__buf.end()));
	}

	template <class _Tp, class _Allocator>
	template <class _ForwardIterator>
	typename deque<_Tp, _Allocator>::iterator
	deque<_Tp, _Allocator>::insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l,
	typename enable_if<__is_forward_iterator<_ForwardIterator>::value
	&&!__is_bidirectional_iterator<_ForwardIterator>::value>::type*)
	{
	size_type __n = _VSTD::distance(__f, __l);
	__split_buffer<value_type, allocator_type&> __buf(__n, 0, __base::__alloc());
	__buf.__construct_at_end(__f, __l);
	typedef typename __split_buffer<value_type, allocator_type&>::iterator __fwd;
	return insert(__p, move_iterator<__fwd>(__buf.begin()), move_iterator<__fwd>(__buf.end()));
	}

	template <class _Tp, class _Allocator>
	template <class _BiIter>
	typename deque<_Tp, _Allocator>::iterator
	deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
	typename enable_if<__is_bidirectional_iterator<_BiIter>::value>::type*)
	{
	size_type __n = _VSTD::distance(__f, __l);
	size_type __pos = __p - __base::begin();
	size_type __to_end = __base::size() - __pos;
	allocator_type& __a = __base::__alloc();
	if (__pos < __to_end)
	{ // insert by shifting things backward
	if (__n > __front_spare())
	__add_front_capacity(__n - __front_spare());
	// __n <= __front_spare()
	iterator __old_begin = __base::begin();
	iterator __i = __old_begin;
	_BiIter __m = __f;
	if (__n > __pos)
	{
	__m = __pos < __n / 2 ? _VSTD::prev(__l, __pos) : _VSTD::next(__f, __n - __pos);
	for (_BiIter __j = __m; __j != __f; --__base::__start_, ++__base::size())
	__alloc_traits::construct(__a, _VSTD::addressof(--__i), --__j);
	__n = __pos;
	}
	if (__n > 0)
	{
	iterator __obn = __old_begin + __n;
	for (iterator __j = __obn; __j != __old_begin;)
	{
	__alloc_traits::construct(__a, _VSTD::addressof(--__i), _VSTD::move(--__j));
	--__base::__start_;
	++__base::size();
	}
	if (__n < __pos)
	__old_begin = _VSTD::move(__obn, __old_begin + __pos, __old_begin);
	_VSTD::copy(__m, __l, __old_begin);
	}
	}
	else
	{ // insert by shifting things forward
	size_type __back_capacity = __back_spare();
	if (__n > __back_capacity)
	__add_back_capacity(__n - __back_capacity);
	// __n <= __back_capacity
	iterator __old_end = __base::end();
	iterator __i = __old_end;
	_BiIter __m = __l;
	size_type __de = __base::size() - __pos;
	if (__n > __de)
	{
	__m = __de < __n / 2 ? _VSTD::next(__f, __de) : _VSTD::prev(__l, __n - __de);
	for (_BiIter __j = __m; __j != __l; ++__i, (void) ++__j, ++__base::size())
	__alloc_traits::construct(__a, _VSTD::addressof(__i), __j);
	__n = __de;
	}
	if (__n > 0)
	{
	iterator __oen = __old_end - __n;
	for (iterator __j = __oen; __j != __old_end; ++__i, ++__j, ++__base::size())
	__alloc_traits::construct(__a, _VSTD::addressof(__i), _VSTD::move(__j));
	if (__n < __de)
	__old_end = _VSTD::move_backward(__old_end - __de, __oen, __old_end);
	_VSTD::copy_backward(__f, __m, __old_end);
	}
	}
	return __base::begin() + __pos;
	}

	template <class _Tp, class _Allocator>
	template <class _InpIter>
	void
	deque<_Tp, _Allocator>::__append(_InpIter __f, _InpIter __l,
	typename enable_if<__is_input_iterator<_InpIter>::value &&
	!__is_forward_iterator<_InpIter>::value>::type*)
	{
	for (; __f != __l; ++__f)
	#ifdef _LIBCPP_CXX03_LANG
	push_back(*__f);
	#else
	emplace_back(*__f);
	#endif
	}

	template <class _Tp, class _Allocator>
	template <class _ForIter>
	void
	deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,
	typename enable_if<__is_forward_iterator<_ForIter>::value>::type*)
	{
	size_type __n = _VSTD::distance(__f, __l);
	allocator_type& __a = __base::__alloc();
	size_type __back_capacity = __back_spare();
	if (__n > __back_capacity)
	__add_back_capacity(__n - __back_capacity);
	// __n <= __back_capacity
	for (iterator __i = __base::end(); __f != __l; ++__i, (void) ++__f, ++__base::size())
	__alloc_traits::construct(__a, _VSTD::addressof(__i), __f);
	}

	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::__append(size_type __n)
	{
	allocator_type& __a = __base::__alloc();
	size_type __back_capacity = __back_spare();
	if (__n > __back_capacity)
	__add_back_capacity(__n - __back_capacity);
	// __n <= __back_capacity
	for (iterator __i = __base::end(); __n; --__n, ++__i, ++__base::size())
	__alloc_traits::construct(__a, _VSTD::addressof(*__i));
	}

	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::__append(size_type __n, const value_type& __v)
	{
	allocator_type& __a = __base::__alloc();
	size_type __back_capacity = __back_spare();
	if (__n > __back_capacity)
	__add_back_capacity(__n - __back_capacity);
	// __n <= __back_capacity
	for (iterator __i = __base::end(); __n; --__n, ++__i, ++__base::size())
	__alloc_traits::construct(__a, _VSTD::addressof(*__i), __v);
	}

	// Create front capacity for one block of elements.
	// Strong guarantee. Either do it or don't touch anything.
	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::__add_front_capacity()
	{
	allocator_type& __a = __base::__alloc();
	if (__back_spare() >= __base::__block_size)
	{
	__base::__start_ += __base::__block_size;
	pointer __pt = __base::__map_.back();
	__base::__map_.pop_back();
	__base::__map_.push_front(__pt);
	}
	// Else if __base::__map_.size() < __base::__map_.capacity() then we need to allocate 1 buffer
	else if (__base::__map_.size() < __base::__map_.capacity())
	{ // we can put the new buffer into the map, but don't shift things around
	// until all buffers are allocated. If we throw, we don't need to fix
	// anything up (any added buffers are undetectible)
	if (__base::__map_.__front_spare() > 0)
	__base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
	else
	{
	__base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
	// Done allocating, reorder capacity
	pointer __pt = __base::__map_.back();
	__base::__map_.pop_back();
	__base::__map_.push_front(__pt);
	}
	__base::__start_ = __base::__map_.size() == 1 ?
	__base::__block_size / 2 :
	__base::__start_ + __base::__block_size;
	}
	// Else need to allocate 1 buffer, and we need to reallocate __map_.
	else
	{
	__split_buffer<pointer, typename __base::__pointer_allocator&>
	__buf(max<size_type>(2 * __base::__map_.capacity(), 1),
	0, __base::__map_.__alloc());

	typedef __allocator_destructor<_Allocator> _Dp;
	unique_ptr<pointer, _Dp> __hold(
	__alloc_traits::allocate(__a, __base::__block_size),
	_Dp(__a, __base::__block_size));
	__buf.push_back(__hold.get());
	__hold.release();

	for (typename __base::__map_pointer __i = __base::__map_.begin();
	__i != __base::__map_.end(); ++__i)
	__buf.push_back(*__i);
	_VSTD::swap(__base::__map_.__first_, __buf.__first_);
	_VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
	_VSTD::swap(__base::__map_.__end_, __buf.__end_);
	_VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
	__base::__start_ = __base::__map_.size() == 1 ?
	__base::__block_size / 2 :
	__base::__start_ + __base::__block_size;
	}
	}

	// Create front capacity for __n elements.
	// Strong guarantee. Either do it or don't touch anything.
	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::__add_front_capacity(size_type __n)
	{
	allocator_type& __a = __base::__alloc();
	size_type __nb = __recommend_blocks(__n + __base::__map_.empty());
	// Number of unused blocks at back:
	size_type __back_capacity = __back_spare() / __base::__block_size;
	__back_capacity = _VSTD::min(__back_capacity, __nb); // don't take more than you need
	__nb -= __back_capacity; // number of blocks need to allocate
	// If __nb == 0, then we have sufficient capacity.
	if (__nb == 0)
	{
	__base::__start_ += __base::__block_size * __back_capacity;
	for (; __back_capacity > 0; --__back_capacity)
	{
	pointer __pt = __base::__map_.back();
	__base::__map_.pop_back();
	__base::__map_.push_front(__pt);
	}
	}
	// Else if __nb <= __map_.capacity() - __map_.size() then we need to allocate __nb buffers
	else if (__nb <= __base::__map_.capacity() - __base::__map_.size())
	{ // we can put the new buffers into the map, but don't shift things around
	// until all buffers are allocated. If we throw, we don't need to fix
	// anything up (any added buffers are undetectible)
	for (; __nb > 0; --__nb, __base::__start_ += __base::__block_size - (__base::__map_.size() == 1))
	{
	if (__base::__map_.__front_spare() == 0)
	break;
	__base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
	}
	for (; __nb > 0; --__nb, ++__back_capacity)
	__base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
	// Done allocating, reorder capacity
	__base::__start_ += __back_capacity * __base::__block_size;
	for (; __back_capacity > 0; --__back_capacity)
	{
	pointer __pt = __base::__map_.back();
	__base::__map_.pop_back();
	__base::__map_.push_front(__pt);
	}
	}
	// Else need to allocate __nb buffers, and we need to reallocate __map_.
	else
	{
	size_type __ds = (__nb + __back_capacity) * __base::__block_size - __base::__map_.empty();
	__split_buffer<pointer, typename __base::__pointer_allocator&>
	__buf(max<size_type>(2* __base::__map_.capacity(),
	__nb + __base::__map_.size()),
	0, __base::__map_.__alloc());
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (; __nb > 0; --__nb)
	__buf.push_back(__alloc_traits::allocate(__a, __base::__block_size));
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	for (typename __base::__map_pointer __i = __buf.begin();
	__i != __buf.end(); ++__i)
	__alloc_traits::deallocate(__a, *__i, __base::__block_size);
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (; __back_capacity > 0; --__back_capacity)
	{
	__buf.push_back(__base::__map_.back());
	__base::__map_.pop_back();
	}
	for (typename __base::__map_pointer __i = __base::__map_.begin();
	__i != __base::__map_.end(); ++__i)
	__buf.push_back(*__i);
	_VSTD::swap(__base::__map_.__first_, __buf.__first_);
	_VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
	_VSTD::swap(__base::__map_.__end_, __buf.__end_);
	_VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
	__base::__start_ += __ds;
	}
	}

	// Create back capacity for one block of elements.
	// Strong guarantee. Either do it or don't touch anything.
	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::__add_back_capacity()
	{
	allocator_type& __a = __base::__alloc();
	if (__front_spare() >= __base::__block_size)
	{
	__base::__start_ -= __base::__block_size;
	pointer __pt = __base::__map_.front();
	__base::__map_.pop_front();
	__base::__map_.push_back(__pt);
	}
	// Else if __nb <= __map_.capacity() - __map_.size() then we need to allocate __nb buffers
	else if (__base::__map_.size() < __base::__map_.capacity())
	{ // we can put the new buffer into the map, but don't shift things around
	// until it is allocated. If we throw, we don't need to fix
	// anything up (any added buffers are undetectible)
	if (__base::__map_.__back_spare() != 0)
	__base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
	else
	{
	__base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
	// Done allocating, reorder capacity
	pointer __pt = __base::__map_.front();
	__base::__map_.pop_front();
	__base::__map_.push_back(__pt);
	}
	}
	// Else need to allocate 1 buffer, and we need to reallocate __map_.
	else
	{
	__split_buffer<pointer, typename __base::__pointer_allocator&>
	__buf(max<size_type>(2* __base::__map_.capacity(), 1),
	__base::__map_.size(),
	__base::__map_.__alloc());

	typedef __allocator_destructor<_Allocator> _Dp;
	unique_ptr<pointer, _Dp> __hold(
	__alloc_traits::allocate(__a, __base::__block_size),
	_Dp(__a, __base::__block_size));
	__buf.push_back(__hold.get());
	__hold.release();

	for (typename __base::__map_pointer __i = __base::__map_.end();
	__i != __base::__map_.begin();)
	__buf.push_front(*--__i);
	_VSTD::swap(__base::__map_.__first_, __buf.__first_);
	_VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
	_VSTD::swap(__base::__map_.__end_, __buf.__end_);
	_VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
	}
	}

	// Create back capacity for __n elements.
	// Strong guarantee. Either do it or don't touch anything.
	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::__add_back_capacity(size_type __n)
	{
	allocator_type& __a = __base::__alloc();
	size_type __nb = __recommend_blocks(__n + __base::__map_.empty());
	// Number of unused blocks at front:
	size_type __front_capacity = __front_spare() / __base::__block_size;
	__front_capacity = _VSTD::min(__front_capacity, __nb); // don't take more than you need
	__nb -= __front_capacity; // number of blocks need to allocate
	// If __nb == 0, then we have sufficient capacity.
	if (__nb == 0)
	{
	__base::__start_ -= __base::__block_size * __front_capacity;
	for (; __front_capacity > 0; --__front_capacity)
	{
	pointer __pt = __base::__map_.front();
	__base::__map_.pop_front();
	__base::__map_.push_back(__pt);
	}
	}
	// Else if __nb <= __map_.capacity() - __map_.size() then we need to allocate __nb buffers
	else if (__nb <= __base::__map_.capacity() - __base::__map_.size())
	{ // we can put the new buffers into the map, but don't shift things around
	// until all buffers are allocated. If we throw, we don't need to fix
	// anything up (any added buffers are undetectible)
	for (; __nb > 0; --__nb)
	{
	if (__base::__map_.__back_spare() == 0)
	break;
	__base::__map_.push_back(__alloc_traits::allocate(__a, __base::__block_size));
	}
	for (; __nb > 0; --__nb, ++__front_capacity, __base::__start_ +=
	__base::__block_size - (__base::__map_.size() == 1))
	__base::__map_.push_front(__alloc_traits::allocate(__a, __base::__block_size));
	// Done allocating, reorder capacity
	__base::__start_ -= __base::__block_size * __front_capacity;
	for (; __front_capacity > 0; --__front_capacity)
	{
	pointer __pt = __base::__map_.front();
	__base::__map_.pop_front();
	__base::__map_.push_back(__pt);
	}
	}
	// Else need to allocate __nb buffers, and we need to reallocate __map_.
	else
	{
	size_type __ds = __front_capacity * __base::__block_size;
	__split_buffer<pointer, typename __base::__pointer_allocator&>
	__buf(max<size_type>(2* __base::__map_.capacity(),
	__nb + __base::__map_.size()),
	__base::__map_.size() - __front_capacity,
	__base::__map_.__alloc());
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (; __nb > 0; --__nb)
	__buf.push_back(__alloc_traits::allocate(__a, __base::__block_size));
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	for (typename __base::__map_pointer __i = __buf.begin();
	__i != __buf.end(); ++__i)
	__alloc_traits::deallocate(__a, *__i, __base::__block_size);
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (; __front_capacity > 0; --__front_capacity)
	{
	__buf.push_back(__base::__map_.front());
	__base::__map_.pop_front();
	}
	for (typename __base::__map_pointer __i = __base::__map_.end();
	__i != __base::__map_.begin();)
	__buf.push_front(*--__i);
	_VSTD::swap(__base::__map_.__first_, __buf.__first_);
	_VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
	_VSTD::swap(__base::__map_.__end_, __buf.__end_);
	_VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
	__base::__start_ -= __ds;
	}
	}

	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::pop_front()
	{
	allocator_type& __a = __base::__alloc();
	__alloc_traits::destroy(__a, __to_raw_pointer(*(__base::__map_.begin() +
	__base::__start_ / __base::__block_size) +
	__base::__start_ % __base::__block_size));
	--__base::size();
	if (++__base::__start_ >= 2 * __base::__block_size)
	{
	__alloc_traits::deallocate(__a, __base::__map_.front(), __base::__block_size);
	__base::__map_.pop_front();
	__base::__start_ -= __base::__block_size;
	}
	}

	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::pop_back()
	{
	allocator_type& __a = __base::__alloc();
	size_type __p = __base::size() + __base::__start_ - 1;
	__alloc_traits::destroy(__a, __to_raw_pointer(*(__base::__map_.begin() +
	__p / __base::__block_size) +
	__p % __base::__block_size));
	--__base::size();
	if (__back_spare() >= 2 * __base::__block_size)
	{
	__alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
	__base::__map_.pop_back();
	}
	}

	// move assign [__f, __l) to [__r, __r + (__l-__f)).
	// If __vt points into [__f, __l), then subtract (__f - __r) from __vt.
	template <class _Tp, class _Allocator>
	typename deque<_Tp, _Allocator>::iterator
	deque<_Tp, _Allocator>::__move_and_check(iterator __f, iterator __l, iterator __r,
	const_pointer& __vt)
	{
	// as if
	// for (; __f != __l; ++__f, ++__r)
	// __r = _VSTD::move(__f);
	difference_type __n = __l - __f;
	while (__n > 0)
	{
	pointer __fb = __f.__ptr_;
	pointer __fe = *__f.__m_iter_ + __base::__block_size;
	difference_type __bs = __fe - __fb;
	if (__bs > __n)
	{
	__bs = __n;
	__fe = __fb + __bs;
	}
	if (__fb <= __vt && __vt < __fe)
	__vt = (const_iterator(static_cast<__map_const_pointer>(__f.__m_iter_), __vt) -= __f - __r).__ptr_;
	__r = _VSTD::move(__fb, __fe, __r);
	__n -= __bs;
	__f += __bs;
	}
	return __r;
	}

	// move assign [__f, __l) to [__r - (__l-__f), __r) backwards.
	// If __vt points into [__f, __l), then add (__r - __l) to __vt.
	template <class _Tp, class _Allocator>
	typename deque<_Tp, _Allocator>::iterator
	deque<_Tp, _Allocator>::__move_backward_and_check(iterator __f, iterator __l, iterator __r,
	const_pointer& __vt)
	{
	// as if
	// while (__f != __l)
	// --__r = _VSTD::move(--__l);
	difference_type __n = __l - __f;
	while (__n > 0)
	{
	--__l;
	pointer __lb = *__l.__m_iter_;
	pointer __le = __l.__ptr_ + 1;
	difference_type __bs = __le - __lb;
	if (__bs > __n)
	{
	__bs = __n;
	__lb = __le - __bs;
	}
	if (__lb <= __vt && __vt < __le)
	__vt = (const_iterator(static_cast<__map_const_pointer>(__l.__m_iter_), __vt) += __r - __l - 1).__ptr_;
	__r = _VSTD::move_backward(__lb, __le, __r);
	__n -= __bs;
	__l -= __bs - 1;
	}
	return __r;
	}

	// move construct [__f, __l) to [__r, __r + (__l-__f)).
	// If __vt points into [__f, __l), then add (__r - __f) to __vt.
	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::__move_construct_and_check(iterator __f, iterator __l,
	iterator __r, const_pointer& __vt)
	{
	allocator_type& __a = __base::__alloc();
	// as if
	// for (; __f != __l; ++__r, ++__f, ++__base::size())
	// __alloc_traits::construct(__a, _VSTD::addressof(__r), _VSTD::move(__f));
	difference_type __n = __l - __f;
	while (__n > 0)
	{
	pointer __fb = __f.__ptr_;
	pointer __fe = *__f.__m_iter_ + __base::__block_size;
	difference_type __bs = __fe - __fb;
	if (__bs > __n)
	{
	__bs = __n;
	__fe = __fb + __bs;
	}
	if (__fb <= __vt && __vt < __fe)
	__vt = (const_iterator(static_cast<__map_const_pointer>(__f.__m_iter_), __vt) += __r - __f).__ptr_;
	for (; __fb != __fe; ++__fb, ++__r, ++__base::size())
	__alloc_traits::construct(__a, _VSTD::addressof(__r), _VSTD::move(__fb));
	__n -= __bs;
	__f += __bs;
	}
	}

	// move construct [__f, __l) to [__r - (__l-__f), __r) backwards.
	// If __vt points into [__f, __l), then subtract (__l - __r) from __vt.
	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::__move_construct_backward_and_check(iterator __f, iterator __l,
	iterator __r, const_pointer& __vt)
	{
	allocator_type& __a = __base::__alloc();
	// as if
	// for (iterator __j = __l; __j != __f;)
	// {
	// __alloc_traitsconstruct(__a, _VSTD::addressof(--__r), _VSTD::move(--__j));
	// --__base::__start_;
	// ++__base::size();
	// }
	difference_type __n = __l - __f;
	while (__n > 0)
	{
	--__l;
	pointer __lb = *__l.__m_iter_;
	pointer __le = __l.__ptr_ + 1;
	difference_type __bs = __le - __lb;
	if (__bs > __n)
	{
	__bs = __n;
	__lb = __le - __bs;
	}
	if (__lb <= __vt && __vt < __le)
	__vt = (const_iterator(static_cast<__map_const_pointer>(__l.__m_iter_), __vt) -= __l - __r + 1).__ptr_;
	while (__le != __lb)
	{
	__alloc_traits::construct(__a, _VSTD::addressof(--__r), _VSTD::move(--__le));
	--__base::__start_;
	++__base::size();
	}
	__n -= __bs;
	__l -= __bs - 1;
	}
	}

	template <class _Tp, class _Allocator>
	typename deque<_Tp, _Allocator>::iterator
	deque<_Tp, _Allocator>::erase(const_iterator __f)
	{
	iterator __b = __base::begin();
	difference_type __pos = __f - __b;
	iterator __p = __b + __pos;
	allocator_type& __a = __base::__alloc();
	if (static_cast<size_t>(__pos) <= (__base::size() - 1) / 2)
	{ // erase from front
	_VSTD::move_backward(__b, __p, _VSTD::next(__p));
	__alloc_traits::destroy(__a, _VSTD::addressof(*__b));
	--__base::size();
	++__base::__start_;
	if (__front_spare() >= 2 * __base::__block_size)
	{
	__alloc_traits::deallocate(__a, __base::__map_.front(), __base::__block_size);
	__base::__map_.pop_front();
	__base::__start_ -= __base::__block_size;
	}
	}
	else
	{ // erase from back
	iterator __i = _VSTD::move(_VSTD::next(__p), __base::end(), __p);
	__alloc_traits::destroy(__a, _VSTD::addressof(*__i));
	--__base::size();
	if (__back_spare() >= 2 * __base::__block_size)
	{
	__alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
	__base::__map_.pop_back();
	}
	}
	return __base::begin() + __pos;
	}

	template <class _Tp, class _Allocator>
	typename deque<_Tp, _Allocator>::iterator
	deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l)
	{
	difference_type __n = __l - __f;
	iterator __b = __base::begin();
	difference_type __pos = __f - __b;
	iterator __p = __b + __pos;
	if (__n > 0)
	{
	allocator_type& __a = __base::__alloc();
	if (static_cast<size_t>(__pos) <= (__base::size() - __n) / 2)
	{ // erase from front
	iterator __i = _VSTD::move_backward(__b, __p, __p + __n);
	for (; __b != __i; ++__b)
	__alloc_traits::destroy(__a, _VSTD::addressof(*__b));
	__base::size() -= __n;
	__base::__start_ += __n;
	while (__front_spare() >= 2 * __base::__block_size)
	{
	__alloc_traits::deallocate(__a, __base::__map_.front(), __base::__block_size);
	__base::__map_.pop_front();
	__base::__start_ -= __base::__block_size;
	}
	}
	else
	{ // erase from back
	iterator __i = _VSTD::move(__p + __n, __base::end(), __p);
	for (iterator __e = __base::end(); __i != __e; ++__i)
	__alloc_traits::destroy(__a, _VSTD::addressof(*__i));
	__base::size() -= __n;
	while (__back_spare() >= 2 * __base::__block_size)
	{
	__alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
	__base::__map_.pop_back();
	}
	}
	}
	return __base::begin() + __pos;
	}

	template <class _Tp, class _Allocator>
	void
	deque<_Tp, _Allocator>::__erase_to_end(const_iterator __f)
	{
	iterator __e = __base::end();
	difference_type __n = __e - __f;
	if (__n > 0)
	{
	allocator_type& __a = __base::__alloc();
	iterator __b = __base::begin();
	difference_type __pos = __f - __b;
	for (iterator __p = __b + __pos; __p != __e; ++__p)
	__alloc_traits::destroy(__a, _VSTD::addressof(*__p));
	__base::size() -= __n;
	while (__back_spare() >= 2 * __base::__block_size)
	{
	__alloc_traits::deallocate(__a, __base::__map_.back(), __base::__block_size);
	__base::__map_.pop_back();
	}
	}
	}

	template <class _Tp, class _Allocator>
	inline
	void
	deque<_Tp, _Allocator>::swap(deque& __c)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT
	#else
	_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<allocator_type>::value)
	#endif
	{
	__base::swap(__c);
	}

	template <class _Tp, class _Allocator>
	inline
	void
	deque<_Tp, _Allocator>::clear() _NOEXCEPT
	{
	__base::clear();
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
	{
	const typename deque<_Tp, _Allocator>::size_type __sz = __x.size();
	return __sz == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
	{
	return !(__x == __y);
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator< (const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
	{
	return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator> (const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
	{
	return __y < __x;
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
	{
	return !(__x < __y);
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
	{
	return !(__y < __x);
	}

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

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_DEQUE
	Index: projects/clang700-import/contrib/libc++/include/errno.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/errno.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/errno.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/include/errno.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/exception
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/exception (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/exception (revision 337135)
	@@ -1,337 +1,337 @@
	// -- C++ --
	//===-------------------------- exception ---------------------------------===//
	//
	// 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_EXCEPTION
	#define _LIBCPP_EXCEPTION

	/*
	exception synopsis

	namespace std
	{

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

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

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

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

	bool uncaught_exception() noexcept;
	int uncaught_exceptions() noexcept; // C++17

	typedef unspecified exception_ptr;

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

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

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

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

	} // std

	*/

	#include <__config>
	#include <cstddef>
	#include <cstdlib>
	#include <type_traits>

	#if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_NO_VCRUNTIME)
	#include <vcruntime_exception.h>
	#endif

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	namespace std // purposefully not using versioning namespace
	{

	#if !defined(_LIBCPP_ABI_MICROSOFT) \|\| defined(_LIBCPP_NO_VCRUNTIME)
	class _LIBCPP_EXCEPTION_ABI exception
	{
	public:
	_LIBCPP_INLINE_VISIBILITY exception() _NOEXCEPT {}
	virtual ~exception() _NOEXCEPT;
	virtual const char* what() const _NOEXCEPT;
	};

	class _LIBCPP_EXCEPTION_ABI bad_exception
	: public exception
	{
	public:
	_LIBCPP_INLINE_VISIBILITY bad_exception() _NOEXCEPT {}
	virtual ~bad_exception() _NOEXCEPT;
	virtual const char* what() const _NOEXCEPT;
	};
	#endif // !_LIBCPP_ABI_MICROSOFT \|\| _LIBCPP_NO_VCRUNTIME

	#if _LIBCPP_STD_VER <= 14 \
	\|\| defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS) \
	\|\| defined(_LIBCPP_BUILDING_LIBRARY)
	typedef void (*unexpected_handler)();
	_LIBCPP_FUNC_VIS unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT;
	_LIBCPP_FUNC_VIS unexpected_handler get_unexpected() _NOEXCEPT;
	_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void unexpected();
	#endif

	typedef void (*terminate_handler)();
	_LIBCPP_FUNC_VIS terminate_handler set_terminate(terminate_handler) _NOEXCEPT;
	_LIBCPP_FUNC_VIS terminate_handler get_terminate() _NOEXCEPT;
	_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void terminate() _NOEXCEPT;

	_LIBCPP_FUNC_VIS bool uncaught_exception() _NOEXCEPT;
	_LIBCPP_FUNC_VIS _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS int uncaught_exceptions() _NOEXCEPT;

	class _LIBCPP_TYPE_VIS exception_ptr;

	_LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
	_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);

	#ifndef _LIBCPP_ABI_MICROSOFT

	class _LIBCPP_TYPE_VIS exception_ptr
	{
	void* __ptr_;
	public:
	_LIBCPP_INLINE_VISIBILITY exception_ptr() _NOEXCEPT : __ptr_() {}
	_LIBCPP_INLINE_VISIBILITY exception_ptr(nullptr_t) _NOEXCEPT : __ptr_() {}

	exception_ptr(const exception_ptr&) _NOEXCEPT;
	exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
	~exception_ptr() _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT
	{return __ptr_ != nullptr;}

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

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

	friend _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
	friend _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
	};

	template<class _Ep>
	exception_ptr
	make_exception_ptr(_Ep __e) _NOEXCEPT
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	throw __e;
	}
	catch (...)
	{
	return current_exception();
	}
	#else
	((void)__e);
	_VSTD::abort();
	#endif
	}

	#else // _LIBCPP_ABI_MICROSOFT

	class _LIBCPP_TYPE_VIS exception_ptr
	{
	#if defined(__clang__)
	#pragma clang diagnostic push
	#pragma clang diagnostic ignored "-Wunused-private-field"
	#endif
	void* __ptr1_;
	void* __ptr2_;
	#if defined(__clang__)
	#pragma clang diagnostic pop
	#endif
	public:
	exception_ptr() _NOEXCEPT;
	exception_ptr(nullptr_t) _NOEXCEPT;
	exception_ptr(const exception_ptr& __other) _NOEXCEPT;
	exception_ptr& operator=(const exception_ptr& __other) _NOEXCEPT;
	exception_ptr& operator=(nullptr_t) _NOEXCEPT;
	~exception_ptr() _NOEXCEPT;
	_LIBCPP_EXPLICIT operator bool() const _NOEXCEPT;
	};

	_LIBCPP_FUNC_VIS
	bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT;

	inline _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
	{return !(__x == __y);}

	_LIBCPP_FUNC_VIS void swap(exception_ptr&, exception_ptr&) _NOEXCEPT;

	_LIBCPP_FUNC_VIS exception_ptr __copy_exception_ptr(void __except, const void __ptr);
	_LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
	_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr p);

	// This is a built-in template function which automagically extracts the required
	// information.
	template <class _E> void *__GetExceptionInfo(_E);

	template<class _Ep>
	exception_ptr
	make_exception_ptr(_Ep __e) _NOEXCEPT
	{
	return __copy_exception_ptr(_VSTD::addressof(__e), __GetExceptionInfo(__e));
	}

	#endif // _LIBCPP_ABI_MICROSOFT
	// nested_exception

	class _LIBCPP_EXCEPTION_ABI nested_exception
	{
	exception_ptr __ptr_;
	public:
	nested_exception() _NOEXCEPT;
	// nested_exception(const nested_exception&) noexcept = default;
	// nested_exception& operator=(const nested_exception&) noexcept = default;
	virtual ~nested_exception() _NOEXCEPT;

	// access functions
	_LIBCPP_NORETURN void rethrow_nested() const;
	_LIBCPP_INLINE_VISIBILITY exception_ptr nested_ptr() const _NOEXCEPT {return __ptr_;}
	};

	template <class _Tp>
	struct __nested
	: public _Tp,
	public nested_exception
	{
	_LIBCPP_INLINE_VISIBILITY explicit __nested(const _Tp& __t) : _Tp(__t) {}
	};

	#ifndef _LIBCPP_NO_EXCEPTIONS
	template <class _Tp, class _Up, bool>
	struct __throw_with_nested;

	template <class _Tp, class _Up>
	struct __throw_with_nested<_Tp, _Up, true> {
	- _LIBCPP_NORETURN static inline _LIBCPP_ALWAYS_INLINE void
	+ _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void
	#ifndef _LIBCPP_CXX03_LANG
	__do_throw(_Tp&& __t)
	#else
	__do_throw (_Tp& __t)
	#endif // _LIBCPP_CXX03_LANG
	{
	throw __nested<_Up>(_VSTD::forward<_Tp>(__t));
	}
	};

	template <class _Tp, class _Up>
	struct __throw_with_nested<_Tp, _Up, false> {
	- _LIBCPP_NORETURN static inline _LIBCPP_ALWAYS_INLINE void
	+ _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void
	#ifndef _LIBCPP_CXX03_LANG
	__do_throw(_Tp&& __t)
	#else
	__do_throw (_Tp& __t)
	#endif // _LIBCPP_CXX03_LANG
	{
	throw _VSTD::forward<_Tp>(__t);
	}
	};
	#endif

	template <class _Tp>
	_LIBCPP_NORETURN
	void
	#ifndef _LIBCPP_CXX03_LANG
	throw_with_nested(_Tp&& __t)
	#else
	throw_with_nested (_Tp& __t)
	#endif // _LIBCPP_CXX03_LANG
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	typedef typename decay<_Tp>::type _Up;
	static_assert( is_copy_constructible<_Up>::value, "type thrown must be CopyConstructible");
	__throw_with_nested<_Tp, _Up,
	is_class<_Up>::value &&
	!is_base_of<nested_exception, _Up>::value &&
	!__libcpp_is_final<_Up>::value>::
	__do_throw(_VSTD::forward<_Tp>(__t));
	#else
	((void)__t);
	// FIXME: Make this abort
	#endif
	}

	template <class _From, class _To>
	struct __can_dynamic_cast : public _LIBCPP_BOOL_CONSTANT(
	is_polymorphic<_From>::value &&
	(!is_base_of<_To, _From>::value \|\|
	is_convertible<const _From, const _To>::value)) {};

	template <class _Ep>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	rethrow_if_nested(const _Ep& __e,
	typename enable_if< __can_dynamic_cast<_Ep, nested_exception>::value>::type* = 0)
	{
	const nested_exception* __nep = dynamic_cast<const nested_exception*>(_VSTD::addressof(__e));
	if (__nep)
	__nep->rethrow_nested();
	}

	template <class _Ep>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	rethrow_if_nested(const _Ep&,
	typename enable_if<!__can_dynamic_cast<_Ep, nested_exception>::value>::type* = 0)
	{
	}

	} // std

	#endif // _LIBCPP_EXCEPTION
	Index: projects/clang700-import/contrib/libc++/include/experimental/__config
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/__config (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/__config (revision 337135)
	@@ -1,57 +1,67 @@
	// -- C++ --
	//===--------------------------- __config ---------------------------------===//
	//
	// 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_EXPERIMENTAL_CONFIG
	#define _LIBCPP_EXPERIMENTAL_CONFIG

	#include <__config>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL namespace std { namespace experimental {
	#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL } }
	#define _VSTD_EXPERIMENTAL std::experimental

	#define _LIBCPP_BEGIN_NAMESPACE_LFTS _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v1 {
	#define _LIBCPP_END_NAMESPACE_LFTS } } }
	#define _VSTD_LFTS _VSTD_EXPERIMENTAL::fundamentals_v1

	#define _LIBCPP_BEGIN_NAMESPACE_LFTS_V2 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v2 {
	#define _LIBCPP_END_NAMESPACE_LFTS_V2 } } }
	#define _VSTD_LFTS_V2 _VSTD_EXPERIMENTAL::fundamentals_v2

	#define _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR _LIBCPP_BEGIN_NAMESPACE_LFTS namespace pmr {
	#define _LIBCPP_END_NAMESPACE_LFTS_PMR _LIBCPP_END_NAMESPACE_LFTS }
	#define _VSTD_LFTS_PMR _VSTD_LFTS::pmr

	#define _LIBCPP_BEGIN_NAMESPACE_CHRONO_LFTS _LIBCPP_BEGIN_NAMESPACE_STD \
	namespace chrono { namespace experimental { inline namespace fundamentals_v1 {
	#define _LIBCPP_END_NAMESPACE_CHRONO_LFTS _LIBCPP_END_NAMESPACE_STD } } }

	#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM \
	_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL namespace filesystem { \
	inline namespace v1 {

	#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM \
	} } _LIBCPP_END_NAMESPACE_EXPERIMENTAL

	#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES \
	_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace coroutines_v1 {

	#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_COROUTINES \
	} _LIBCPP_END_NAMESPACE_EXPERIMENTAL

	#define _VSTD_CORO _VSTD_EXPERIMENTAL::coroutines_v1

	-#define _VSTD_FS ::std::experimental::filesystem::v1
	+#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD \
	+ _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace parallelism_v2 {
	+
	+#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD \
	+ } _LIBCPP_END_NAMESPACE_EXPERIMENTAL
	+
	+#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI \
	+ _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD namespace simd_abi {
	+
	+#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI \
	+ } _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD

	#endif
	Index: projects/clang700-import/contrib/libc++/include/experimental/algorithm
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/algorithm (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/algorithm (revision 337135)
	@@ -1,73 +1,60 @@
	// -- C++ --
	//===-------------------------- algorithm ---------------------------------===//
	//
	// 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_EXPERIMENTAL_ALGORITHM
	#define _LIBCPP_EXPERIMENTAL_ALGORITHM

	/*
	experimental/algorithm synopsis

	#include <algorithm>

	namespace std {
	namespace experimental {
	inline namespace fundamentals_v1 {

	template <class ForwardIterator, class Searcher>
	ForwardIterator search(ForwardIterator first, ForwardIterator last,
	const Searcher &searcher);
	-template <class PopulationIterator, class SampleIterator, class Distance,
	- class UniformRandomNumberGenerator>
	-SampleIterator sample(PopulationIterator first, PopulationIterator last,
	- SampleIterator out, Distance n,
	- UniformRandomNumberGenerator &&g);

	+// sample removed because it's now part of C++17
	+
	} // namespace fundamentals_v1
	} // namespace experimental
	} // namespace std

	*/

	#include <experimental/__config>
	#include <algorithm>
	#include <type_traits>

	#include <__debug>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_LFTS

	template <class _ForwardIterator, class _Searcher>
	_LIBCPP_INLINE_VISIBILITY
	_ForwardIterator search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher &__s)
	{ return __s(__f, __l).first; }
	-
	-
	-template <class _PopulationIterator, class _SampleIterator, class _Distance,
	- class _UniformRandomNumberGenerator>
	-inline _LIBCPP_INLINE_VISIBILITY
	-_SampleIterator sample(_PopulationIterator __first, _PopulationIterator __last,
	- _SampleIterator __output_iter, _Distance __n,
	- _UniformRandomNumberGenerator &&__g) {
	- return _VSTD::__sample(__first, __last, __output_iter, __n, __g);
	-}

	_LIBCPP_END_NAMESPACE_LFTS

	_LIBCPP_POP_MACROS

	#endif /* _LIBCPP_EXPERIMENTAL_ALGORITHM */
	Index: projects/clang700-import/contrib/libc++/include/experimental/any
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/any (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/any (revision 337135)
	@@ -1,592 +1,11 @@
	// -- C++ --
	//===------------------------------ any -----------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	-#ifndef _LIBCPP_EXPERIMENTAL_ANY
	-#define _LIBCPP_EXPERIMENTAL_ANY
	-
	-/*
	- experimental/any synopsis
	-
	-namespace std {
	-namespace experimental {
	-inline namespace fundamentals_v1 {
	-
	- class bad_any_cast : public bad_cast
	- {
	- public:
	- virtual const char* what() const noexcept;
	- };
	-
	- class any
	- {
	- public:
	-
	- // 6.3.1 any construct/destruct
	- any() noexcept;
	-
	- any(const any& other);
	- any(any&& other) noexcept;
	-
	- template <class ValueType>
	- any(ValueType&& value);
	-
	- ~any();
	-
	- // 6.3.2 any assignments
	- any& operator=(const any& rhs);
	- any& operator=(any&& rhs) noexcept;
	-
	- template <class ValueType>
	- any& operator=(ValueType&& rhs);
	-
	- // 6.3.3 any modifiers
	- void clear() noexcept;
	- void swap(any& rhs) noexcept;
	-
	- // 6.3.4 any observers
	- bool empty() const noexcept;
	- const type_info& type() const noexcept;
	- };
	-
	- // 6.4 Non-member functions
	- void swap(any& x, any& y) noexcept;
	-
	- template<class ValueType>
	- ValueType any_cast(const any& operand);
	- template<class ValueType>
	- ValueType any_cast(any& operand);
	- template<class ValueType>
	- ValueType any_cast(any&& operand);
	-
	- template<class ValueType>
	- const ValueType* any_cast(const any* operand) noexcept;
	- template<class ValueType>
	- ValueType* any_cast(any* operand) noexcept;
	-
	-} // namespace fundamentals_v1
	-} // namespace experimental
	-} // namespace std
	-
	-*/
	-
	-#include <experimental/__config>
	-#include <memory>
	-#include <new>
	-#include <typeinfo>
	-#include <type_traits>
	-#include <cstdlib>
	-
	-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	-#pragma GCC system_header
	-#endif
	-
	-_LIBCPP_BEGIN_NAMESPACE_LFTS
	-
	-class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast
	-{
	-public:
	- virtual const char* what() const _NOEXCEPT;
	-};
	-
	-#if _LIBCPP_STD_VER > 11 // C++ > 11
	-
	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	-_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
	-void __throw_bad_any_cast()
	-{
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- throw bad_any_cast();
	-#else
	- _VSTD::abort();
	-#endif
	-}
	-
	-// Forward declarations
	-class any;
	-
	-template <class _ValueType>
	-typename add_pointer<typename add_const<_ValueType>::type>::type
	-_LIBCPP_INLINE_VISIBILITY
	-any_cast(any const *) _NOEXCEPT;
	-
	-template <class _ValueType>
	-typename add_pointer<_ValueType>::type
	-_LIBCPP_INLINE_VISIBILITY
	-any_cast(any *) _NOEXCEPT;
	-
	-namespace __any_imp
	-{
	- typedef typename aligned_storage<3sizeof(void), alignment_of<void*>::value>::type
	- _Buffer;
	-
	- template <class _Tp>
	- struct _IsSmallObject
	- : public integral_constant<bool
	- , sizeof(_Tp) <= sizeof(_Buffer)
	- && alignment_of<_Buffer>::value
	- % alignment_of<_Tp>::value == 0
	- && is_nothrow_move_constructible<_Tp>::value
	- >
	- {};
	-
	- enum class _Action
	- {
	- _Destroy,
	- _Copy,
	- _Move,
	- _Get,
	- _TypeInfo
	- };
	-
	- template <class _Tp>
	- struct _SmallHandler;
	-
	- template <class _Tp>
	- struct _LargeHandler;
	-
	- template <class _Tp>
	- using _Handler = typename conditional<_IsSmallObject<_Tp>::value
	- , _SmallHandler<_Tp>
	- , _LargeHandler<_Tp>
	- >::type;
	- template <class _ValueType>
	- using _EnableIfNotAny = typename
	- enable_if<
	- !is_same<typename decay<_ValueType>::type, any>::value
	- >::type;
	-
	-} // namespace __any_imp
	-
	-class any
	-{
	-public:
	- // 6.3.1 any construct/destruct
	- _LIBCPP_INLINE_VISIBILITY
	- any() _NOEXCEPT : __h(nullptr) {}
	-
	- _LIBCPP_INLINE_VISIBILITY
	- any(any const & __other) : __h(nullptr)
	- {
	- if (__other.__h) __other.__call(_Action::_Copy, this);
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- any(any && __other) _NOEXCEPT : __h(nullptr)
	- {
	- if (__other.__h) __other.__call(_Action::_Move, this);
	- }
	-
	- template <
	- class _ValueType
	- , class = __any_imp::_EnableIfNotAny<_ValueType>
	- >
	- _LIBCPP_INLINE_VISIBILITY
	- any(_ValueType && __value);
	-
	- _LIBCPP_INLINE_VISIBILITY
	- ~any()
	- {
	- this->clear();
	- }
	-
	- // 6.3.2 any assignments
	- _LIBCPP_INLINE_VISIBILITY
	- any & operator=(any const & __rhs)
	- {
	- any(__rhs).swap(*this);
	- return *this;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- any & operator=(any && __rhs) _NOEXCEPT
	- {
	- any(_VSTD::move(__rhs)).swap(*this);
	- return *this;
	- }
	-
	- template <
	- class _ValueType
	- , class = __any_imp::_EnableIfNotAny<_ValueType>
	- >
	- _LIBCPP_INLINE_VISIBILITY
	- any & operator=(_ValueType && __rhs);
	-
	- // 6.3.3 any modifiers
	- _LIBCPP_INLINE_VISIBILITY
	- void clear() _NOEXCEPT
	- {
	- if (__h) this->__call(_Action::_Destroy);
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- void swap(any & __rhs) _NOEXCEPT;
	-
	- // 6.3.4 any observers
	- _LIBCPP_INLINE_VISIBILITY
	- bool empty() const _NOEXCEPT
	- {
	- return __h == nullptr;
	- }
	-
	-#if !defined(_LIBCPP_NO_RTTI)
	- _LIBCPP_INLINE_VISIBILITY
	- const type_info & type() const _NOEXCEPT
	- {
	- if (__h) {
	- return static_cast<type_info const >(this->__call(_Action::_TypeInfo));
	- } else {
	- return typeid(void);
	- }
	- }
	-#endif
	-
	-private:
	- typedef __any_imp::_Action _Action;
	-
	- typedef void* (_HandleFuncPtr)(_Action, any const , any , const type_info );
	-
	- union _Storage
	- {
	- void * __ptr;
	- __any_imp::_Buffer __buf;
	- };
	-
	- _LIBCPP_ALWAYS_INLINE
	- void * __call(_Action __a, any * __other = nullptr,
	- type_info const * __info = nullptr) const
	- {
	- return __h(__a, this, __other, __info);
	- }
	-
	- _LIBCPP_ALWAYS_INLINE
	- void * __call(_Action __a, any * __other = nullptr,
	- type_info const * __info = nullptr)
	- {
	- return __h(__a, this, __other, __info);
	- }
	-
	- template <class>
	- friend struct __any_imp::_SmallHandler;
	- template <class>
	- friend struct __any_imp::_LargeHandler;
	-
	- template <class _ValueType>
	- friend typename add_pointer<typename add_const<_ValueType>::type>::type
	- any_cast(any const *) _NOEXCEPT;
	-
	- template <class _ValueType>
	- friend typename add_pointer<_ValueType>::type
	- any_cast(any *) _NOEXCEPT;
	-
	- _HandleFuncPtr __h;
	- _Storage __s;
	-};
	-
	-namespace __any_imp
	-{
	-
	- template <class _Tp>
	- struct _LIBCPP_TEMPLATE_VIS _SmallHandler
	- {
	- _LIBCPP_INLINE_VISIBILITY
	- static void* __handle(_Action __act, any const * __this, any * __other,
	- type_info const * __info)
	- {
	- switch (__act)
	- {
	- case _Action::_Destroy:
	- __destroy(const_cast<any &>(*__this));
	- return nullptr;
	- case _Action::_Copy:
	- __copy(__this, __other);
	- return nullptr;
	- case _Action::_Move:
	- __move(const_cast<any &>(__this), __other);
	- return nullptr;
	- case _Action::_Get:
	- return __get(const_cast<any &>(*__this), __info);
	- case _Action::_TypeInfo:
	- return __type_info();
	- }
	- }
	-
	- template <class _Up>
	- _LIBCPP_INLINE_VISIBILITY
	- static void __create(any & __dest, _Up && __v)
	- {
	- ::new (static_cast<void*>(&__dest.__s.__buf)) _Tp(_VSTD::forward<_Up>(__v));
	- __dest.__h = &_SmallHandler::__handle;
	- }
	-
	- private:
	- _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY
	- static void __destroy(any & __this)
	- {
	- _Tp & __value = static_cast<_Tp >(static_cast<void*>(&__this.__s.__buf));
	- __value.~_Tp();
	- __this.__h = nullptr;
	- }
	-
	- _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY
	- static void __copy(any const & __this, any & __dest)
	- {
	- _SmallHandler::__create(__dest, static_cast<_Tp const >(
	- static_cast<void const *>(&__this.__s.__buf)));
	- }
	-
	- _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY
	- static void __move(any & __this, any & __dest)
	- {
	- _SmallHandler::__create(__dest, _VSTD::move(
	- static_cast<_Tp>(static_cast<void*>(&__this.__s.__buf))));
	- __destroy(__this);
	- }
	-
	- _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY
	- static void* __get(any & __this, type_info const * __info)
	- {
	-#if !defined(_LIBCPP_NO_RTTI)
	- if (typeid(_Tp) == *__info) {
	- return static_cast<void*>(&__this.__s.__buf);
	- }
	- return nullptr;
	-#else
	- return static_cast<void*>(&__this.__s.__buf);
	-#endif
	- }
	-
	- _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY
	- static void* __type_info()
	- {
	-#if !defined(_LIBCPP_NO_RTTI)
	- return const_cast<void>(static_cast<void const >(&typeid(_Tp)));
	-#else
	- return nullptr;
	-#endif
	- }
	- };
	-
	- template <class _Tp>
	- struct _LIBCPP_TEMPLATE_VIS _LargeHandler
	- {
	- _LIBCPP_INLINE_VISIBILITY
	- static void* __handle(_Action __act, any const * __this, any * __other,
	- type_info const * __info)
	- {
	- switch (__act)
	- {
	- case _Action::_Destroy:
	- __destroy(const_cast<any &>(*__this));
	- return nullptr;
	- case _Action::_Copy:
	- __copy(__this, __other);
	- return nullptr;
	- case _Action::_Move:
	- __move(const_cast<any &>(__this), __other);
	- return nullptr;
	- case _Action::_Get:
	- return __get(const_cast<any &>(*__this), __info);
	- case _Action::_TypeInfo:
	- return __type_info();
	- }
	- }
	-
	- template <class _Up>
	- _LIBCPP_INLINE_VISIBILITY
	- static void __create(any & __dest, _Up && __v)
	- {
	- typedef allocator<_Tp> _Alloc;
	- typedef __allocator_destructor<_Alloc> _Dp;
	- _Alloc __a;
	- unique_ptr<_Tp, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	- ::new ((void*)__hold.get()) _Tp(_VSTD::forward<_Up>(__v));
	- __dest.__s.__ptr = __hold.release();
	- __dest.__h = &_LargeHandler::__handle;
	- }
	-
	- private:
	-
	- _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY
	- static void __destroy(any & __this)
	- {
	- delete static_cast<_Tp*>(__this.__s.__ptr);
	- __this.__h = nullptr;
	- }
	-
	- _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY
	- static void __copy(any const & __this, any & __dest)
	- {
	- _LargeHandler::__create(__dest, static_cast<_Tp const >(__this.__s.__ptr));
	- }
	-
	- _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY
	- static void __move(any & __this, any & __dest)
	- {
	- __dest.__s.__ptr = __this.__s.__ptr;
	- __dest.__h = &_LargeHandler::__handle;
	- __this.__h = nullptr;
	- }
	-
	- _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY
	- static void* __get(any & __this, type_info const * __info)
	- {
	-#if !defined(_LIBCPP_NO_RTTI)
	- if (typeid(_Tp) == *__info) {
	- return static_cast<void*>(__this.__s.__ptr);
	- }
	- return nullptr;
	-#else
	- return static_cast<void*>(__this.__s.__ptr);
	-#endif
	- }
	-
	- _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY
	- static void* __type_info()
	- {
	-#if !defined(_LIBCPP_NO_RTTI)
	- return const_cast<void>(static_cast<void const >(&typeid(_Tp)));
	-#else
	- return nullptr;
	-#endif
	- }
	- };
	-
	-} // namespace __any_imp
	-
	-
	-template <class _ValueType, class>
	-any::any(_ValueType && __v) : __h(nullptr)
	-{
	- typedef typename decay<_ValueType>::type _Tp;
	- static_assert(is_copy_constructible<_Tp>::value,
	- "_ValueType must be CopyConstructible.");
	- typedef __any_imp::_Handler<_Tp> _HandlerType;
	- _HandlerType::__create(*this, _VSTD::forward<_ValueType>(__v));
	-}
	-
	-template <class _ValueType, class>
	-any & any::operator=(_ValueType && __v)
	-{
	- typedef typename decay<_ValueType>::type _Tp;
	- static_assert(is_copy_constructible<_Tp>::value,
	- "_ValueType must be CopyConstructible.");
	- any(_VSTD::forward<_ValueType>(__v)).swap(*this);
	- return *this;
	-}
	-
	-inline
	-void any::swap(any & __rhs) _NOEXCEPT
	-{
	- if (__h && __rhs.__h) {
	- any __tmp;
	- __rhs.__call(_Action::_Move, &__tmp);
	- this->__call(_Action::_Move, &__rhs);
	- __tmp.__call(_Action::_Move, this);
	- }
	- else if (__h) {
	- this->__call(_Action::_Move, &__rhs);
	- }
	- else if (__rhs.__h) {
	- __rhs.__call(_Action::_Move, this);
	- }
	-}
	-
	-// 6.4 Non-member functions
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void swap(any & __lhs, any & __rhs) _NOEXCEPT
	-{
	- __lhs.swap(__rhs);
	-}
	-
	-template <class _ValueType>
	-_LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
	-_ValueType any_cast(any const & __v)
	-{
	- static_assert(
	- is_reference<_ValueType>::value
	- \|\| is_copy_constructible<_ValueType>::value,
	- "_ValueType is required to be a reference or a CopyConstructible type.");
	- typedef typename add_const<typename remove_reference<_ValueType>::type>::type
	- _Tp;
	- _Tp * __tmp = any_cast<_Tp>(&__v);
	- if (__tmp == nullptr)
	- __throw_bad_any_cast();
	- return *__tmp;
	-}
	-
	-template <class _ValueType>
	-_LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
	-_ValueType any_cast(any & __v)
	-{
	- static_assert(
	- is_reference<_ValueType>::value
	- \|\| is_copy_constructible<_ValueType>::value,
	- "_ValueType is required to be a reference or a CopyConstructible type.");
	- typedef typename remove_reference<_ValueType>::type _Tp;
	- _Tp * __tmp = any_cast<_Tp>(&__v);
	- if (__tmp == nullptr)
	- __throw_bad_any_cast();
	- return *__tmp;
	-}
	-
	-template <class _ValueType>
	-_LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
	-_ValueType any_cast(any && __v)
	-{
	- static_assert(
	- is_reference<_ValueType>::value
	- \|\| is_copy_constructible<_ValueType>::value,
	- "_ValueType is required to be a reference or a CopyConstructible type.");
	- typedef typename remove_reference<_ValueType>::type _Tp;
	- _Tp * __tmp = any_cast<_Tp>(&__v);
	- if (__tmp == nullptr)
	- __throw_bad_any_cast();
	- return *__tmp;
	-}
	-
	-template <class _ValueType>
	-inline
	-typename add_pointer<typename add_const<_ValueType>::type>::type
	-any_cast(any const * __any) _NOEXCEPT
	-{
	- static_assert(!is_reference<_ValueType>::value,
	- "_ValueType may not be a reference.");
	- return any_cast<_ValueType>(const_cast<any *>(__any));
	-}
	-
	-template <class _ValueType>
	-typename add_pointer<_ValueType>::type
	-any_cast(any * __any) _NOEXCEPT
	-{
	- using __any_imp::_Action;
	- static_assert(!is_reference<_ValueType>::value,
	- "_ValueType may not be a reference.");
	- typedef typename add_pointer<_ValueType>::type _ReturnType;
	- if (__any && __any->__h) {
	-
	- return static_cast<_ReturnType>(
	- __any->__call(_Action::_Get, nullptr,
	-#if !defined(_LIBCPP_NO_RTTI)
	- &typeid(_ValueType)
	-#else
	- nullptr
	-#endif
	- ));
	-
	- }
	- return nullptr;
	-}
	-
	-#endif // _LIBCPP_STD_VER > 11
	-
	-_LIBCPP_END_NAMESPACE_LFTS
	-
	-#endif // _LIBCPP_EXPERIMENTAL_ANY
	+#error "<experimental/any> has been removed. Use <any> instead."
	Index: projects/clang700-import/contrib/libc++/include/experimental/chrono
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/chrono (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/chrono (revision 337135)
	@@ -1,59 +1,11 @@
	// -- C++ --
	//===------------------------------ chrono ---------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	-#ifndef _LIBCPP_EXPERIMENTAL_CHRONO
	-#define _LIBCPP_EXPERIMENTAL_CHRONO
	-
	-/**
	- experimental/chrono synopsis
	-
	-// C++1y
	-
	-#include <chrono>
	-
	-namespace std {
	-namespace chrono {
	-namespace experimental {
	-inline namespace fundamentals_v1 {
	-
	- // See C++14 20.12.4, customization traits
	- template <class Rep> constexpr bool treat_as_floating_point_v
	- = treat_as_floating_point<Rep>::value;
	-
	-} // namespace fundamentals_v1
	-} // namespace experimental
	-} // namespace chrono
	-} // namespace std
	-
	- */
	-
	-#include <experimental/__config>
	-#include <chrono>
	-
	-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	-#pragma GCC system_header
	-#endif
	-
	-#if _LIBCPP_STD_VER > 11
	-
	-_LIBCPP_BEGIN_NAMESPACE_CHRONO_LFTS
	-
	-#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
	-
	-template <class _Rep> _LIBCPP_CONSTEXPR bool treat_as_floating_point_v
	- = treat_as_floating_point<_Rep>::value;
	-
	-#endif /* _LIBCPP_HAS_NO_VARIABLE_TEMPLATES */
	-
	-_LIBCPP_END_NAMESPACE_CHRONO_LFTS
	-
	-#endif /* _LIBCPP_STD_VER > 11 */
	-
	-#endif /* _LIBCPP_EXPERIMENTAL_CHRONO */
	+#error "<experimental/chrono> has been removed. Use <chrono> instead."
	Index: projects/clang700-import/contrib/libc++/include/experimental/coroutine
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/coroutine (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/coroutine (revision 337135)
	@@ -1,296 +1,336 @@
	// -- C++ --
	//===----------------------------- coroutine -----------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP_EXPERIMENTAL_COROUTINE
	#define _LIBCPP_EXPERIMENTAL_COROUTINE

	/**
	experimental/coroutine synopsis

	// C++next

	namespace std {
	namespace experimental {
	inline namespace coroutines_v1 {

	// 18.11.1 coroutine traits
	template <typename R, typename... ArgTypes>
	class coroutine_traits;
	// 18.11.2 coroutine handle
	template <typename Promise = void>
	class coroutine_handle;
	// 18.11.2.7 comparison operators:
	bool operator==(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
	bool operator!=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
	bool operator<(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
	bool operator<=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
	bool operator>=(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
	bool operator>(coroutine_handle<> x, coroutine_handle<> y) _NOEXCEPT;
	// 18.11.3 trivial awaitables
	struct suspend_never;
	struct suspend_always;
	// 18.11.2.8 hash support:
	template <class T> struct hash;
	template <class P> struct hash<coroutine_handle<P>>;

	} // namespace coroutines_v1
	} // namespace experimental
	} // namespace std

	*/

	#include <experimental/__config>
	#include <new>
	#include <type_traits>
	#include <functional>
	#include <memory> // for hash<T*>
	#include <cstddef>
	#include <cassert>
	#include <__debug>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	#ifdef _LIBCPP_HAS_NO_COROUTINES
	# if defined(_LIBCPP_WARNING)
	_LIBCPP_WARNING("<experimental/coroutine> cannot be used with this compiler")
	# else
	# warning <experimental/coroutine> cannot be used with this compiler
	# endif
	#endif

	#ifndef _LIBCPP_HAS_NO_COROUTINES

	_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_COROUTINES

	template <class _Tp, class = void>
	struct __coroutine_traits_sfinae {};

	template <class _Tp>
	struct __coroutine_traits_sfinae<
	_Tp, typename __void_t<typename _Tp::promise_type>::type>
	{
	using promise_type = typename _Tp::promise_type;
	};

	template <typename _Ret, typename... _Args>
	struct _LIBCPP_TEMPLATE_VIS coroutine_traits
	: public __coroutine_traits_sfinae<_Ret>
	{
	};

	template <typename _Promise = void>
	class _LIBCPP_TEMPLATE_VIS coroutine_handle;

	template <>
	class _LIBCPP_TEMPLATE_VIS coroutine_handle<void> {
	public:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR coroutine_handle() _NOEXCEPT : __handle_(nullptr) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR coroutine_handle(nullptr_t) _NOEXCEPT : __handle_(nullptr) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	coroutine_handle& operator=(nullptr_t) _NOEXCEPT {
	__handle_ = nullptr;
	return *this;
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR void* address() const _NOEXCEPT { return __handle_; }

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR explicit operator bool() const _NOEXCEPT { return __handle_; }

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void operator()() { resume(); }

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void resume() {
	_LIBCPP_ASSERT(__is_suspended(),
	"resume() can only be called on suspended coroutines");
	_LIBCPP_ASSERT(!done(),
	"resume() has undefined behavior when the coroutine is done");
	__builtin_coro_resume(__handle_);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void destroy() {
	_LIBCPP_ASSERT(__is_suspended(),
	"destroy() can only be called on suspended coroutines");
	__builtin_coro_destroy(__handle_);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	bool done() const {
	_LIBCPP_ASSERT(__is_suspended(),
	"done() can only be called on suspended coroutines");
	return __builtin_coro_done(__handle_);
	}

	public:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	static coroutine_handle from_address(void* __addr) _NOEXCEPT {
	coroutine_handle __tmp;
	__tmp.__handle_ = __addr;
	return __tmp;
	}

	// FIXME: Should from_address(nullptr) be allowed?
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	static coroutine_handle from_address(nullptr_t) _NOEXCEPT {
	return coroutine_handle(nullptr);
	}

	template <class _Tp, bool _CallIsValid = false>
	static coroutine_handle from_address(_Tp*) {
	static_assert(_CallIsValid,
	"coroutine_handle<void>::from_address cannot be called with "
	"non-void pointers");
	}

	private:
	bool __is_suspended() const _NOEXCEPT {
	// FIXME actually implement a check for if the coro is suspended.
	return __handle_;
	}

	template <class _PromiseT> friend class coroutine_handle;
	void* __handle_;
	};

	// 18.11.2.7 comparison operators:
	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	bool operator==(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
	return __x.address() == __y.address();
	}
	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	bool operator!=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
	return !(__x == __y);
	}
	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	bool operator<(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
	return less<void*>()(__x.address(), __y.address());
	}
	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	bool operator>(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
	return __y < __x;
	}
	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	bool operator<=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
	return !(__x > __y);
	}
	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	bool operator>=(coroutine_handle<> __x, coroutine_handle<> __y) _NOEXCEPT {
	return !(__x < __y);
	}

	template <typename _Promise>
	class _LIBCPP_TEMPLATE_VIS coroutine_handle : public coroutine_handle<> {
	using _Base = coroutine_handle<>;
	public:
	#ifndef _LIBCPP_CXX03_LANG
	// 18.11.2.1 construct/reset
	using coroutine_handle<>::coroutine_handle;
	#else
	- _LIBCPP_ALWAYS_INLINE coroutine_handle() _NOEXCEPT : _Base() {}
	- _LIBCPP_ALWAYS_INLINE coroutine_handle(nullptr_t) _NOEXCEPT : _Base(nullptr) {}
	+ _LIBCPP_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT : _Base() {}
	+ _LIBCPP_INLINE_VISIBILITY coroutine_handle(nullptr_t) _NOEXCEPT : _Base(nullptr) {}
	#endif
	_LIBCPP_INLINE_VISIBILITY
	coroutine_handle& operator=(nullptr_t) _NOEXCEPT {
	_Base::operator=(nullptr);
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	_Promise& promise() const {
	- return reinterpret_cast<_Promise>(
	+ return static_cast<_Promise>(
	__builtin_coro_promise(this->__handle_, __alignof(_Promise), false));
	}

	public:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	static coroutine_handle from_address(void* __addr) _NOEXCEPT {
	coroutine_handle __tmp;
	__tmp.__handle_ = __addr;
	return __tmp;
	}

	// NOTE: this overload isn't required by the standard but is needed so
	// the deleted _Promise* overload doesn't make from_address(nullptr)
	// ambiguous.
	// FIXME: should from_address work with nullptr?
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	static coroutine_handle from_address(nullptr_t) _NOEXCEPT {
	return coroutine_handle(nullptr);
	}

	template <class _Tp, bool _CallIsValid = false>
	static coroutine_handle from_address(_Tp*) {
	static_assert(_CallIsValid,
	"coroutine_handle<promise_type>::from_address cannot be called with "
	"non-void pointers");
	}

	template <bool _CallIsValid = false>
	static coroutine_handle from_address(_Promise*) {
	static_assert(_CallIsValid,
	"coroutine_handle<promise_type>::from_address cannot be used with "
	"pointers to the coroutine's promise type; use 'from_promise' instead");
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	static coroutine_handle from_promise(_Promise& __promise) _NOEXCEPT {
	typedef typename remove_cv<_Promise>::type _RawPromise;
	coroutine_handle __tmp;
	__tmp.__handle_ = __builtin_coro_promise(
	_VSTD::addressof(const_cast<_RawPromise&>(__promise)),
	__alignof(_Promise), true);
	return __tmp;
	}
	};

	+#if __has_builtin(__builtin_coro_noop)
	+struct noop_coroutine_promise {};
	+
	+template <>
	+class _LIBCPP_TEMPLATE_VIS coroutine_handle<noop_coroutine_promise>
	+ : public coroutine_handle<> {
	+ using _Base = coroutine_handle<>;
	+ using _Promise = noop_coroutine_promise;
	+public:
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ _Promise& promise() const {
	+ return static_cast<_Promise>(
	+ __builtin_coro_promise(this->__handle_, __alignof(_Promise), false));
	+ }
	+
	+ _LIBCPP_CONSTEXPR explicit operator bool() const _NOEXCEPT { return true; }
	+ _LIBCPP_CONSTEXPR bool done() const _NOEXCEPT { return false; }
	+
	+ _LIBCPP_CONSTEXPR_AFTER_CXX17 void operator()() const _NOEXCEPT {}
	+ _LIBCPP_CONSTEXPR_AFTER_CXX17 void resume() const _NOEXCEPT {}
	+ _LIBCPP_CONSTEXPR_AFTER_CXX17 void destroy() const _NOEXCEPT {}
	+
	+private:
	+ _LIBCPP_INLINE_VISIBILITY
	+ friend coroutine_handle<noop_coroutine_promise> noop_coroutine() _NOEXCEPT;
	+
	+ _LIBCPP_INLINE_VISIBILITY coroutine_handle() _NOEXCEPT {
	+ this->__handle_ = __builtin_coro_noop();
	+ }
	+};
	+
	+using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
	+
	+inline _LIBCPP_INLINE_VISIBILITY
	+noop_coroutine_handle noop_coroutine() _NOEXCEPT {
	+ return noop_coroutine_handle();
	+}
	+#endif // __has_builtin(__builtin_coro_noop)
	+
	struct _LIBCPP_TYPE_VIS suspend_never {
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	bool await_ready() const _NOEXCEPT { return true; }
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void await_suspend(coroutine_handle<>) const _NOEXCEPT {}
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void await_resume() const _NOEXCEPT {}
	};

	struct _LIBCPP_TYPE_VIS suspend_always {
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	bool await_ready() const _NOEXCEPT { return false; }
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void await_suspend(coroutine_handle<>) const _NOEXCEPT {}
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void await_resume() const _NOEXCEPT {}
	};

	_LIBCPP_END_NAMESPACE_EXPERIMENTAL_COROUTINES

	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _Tp>
	struct hash<_VSTD_CORO::coroutine_handle<_Tp> > {
	using __arg_type = _VSTD_CORO::coroutine_handle<_Tp>;
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(__arg_type const& __v) const _NOEXCEPT
	{return hash<void*>()(__v.address());}
	};

	_LIBCPP_END_NAMESPACE_STD

	#endif // !defined(_LIBCPP_HAS_NO_COROUTINES)

	#endif /* _LIBCPP_EXPERIMENTAL_COROUTINE */
	Index: projects/clang700-import/contrib/libc++/include/experimental/dynarray
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/dynarray (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/dynarray (revision 337135)
	@@ -1,304 +1,305 @@
	// -- C++ --
	//===-------------------------- dynarray ----------------------------------===//
	//
	// 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_DYNARRAY
	#define _LIBCPP_DYNARRAY

	/*
	dynarray synopsis

	namespace std { namespace experimental {

	template< typename T >
	class dynarray
	{
	// types:
	typedef T value_type;
	typedef T& reference;
	typedef const T& const_reference;
	typedef T* pointer;
	typedef const T* const_pointer;
	typedef implementation-defined iterator;
	typedef implementation-defined const_iterator;
	typedef reverse_iterator<iterator> reverse_iterator;
	typedef reverse_iterator<const_iterator> const_reverse_iterator;
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;

	public:
	// construct/copy/destroy:
	explicit dynarray(size_type c);
	dynarray(size_type c, const T& v);
	dynarray(const dynarray& d);
	dynarray(initializer_list<T>);

	template <class Alloc>
	dynarray(allocator_arg_t, const Alloc& a, size_type c, const Alloc& alloc);
	template <class Alloc>
	dynarray(allocator_arg_t, const Alloc& a, size_type c, const T& v, const Alloc& alloc);
	template <class Alloc>
	dynarray(allocator_arg_t, const Alloc& a, const dynarray& d, const Alloc& alloc);
	template <class Alloc>
	dynarray(allocator_arg_t, const Alloc& a, initializer_list<T>, const Alloc& alloc);
	dynarray& operator=(const dynarray&) = delete;
	~dynarray();

	// iterators:
	iterator begin() noexcept;
	const_iterator begin() const noexcept;
	const_iterator cbegin() const noexcept;
	iterator end() noexcept;
	const_iterator end() const noexcept;
	const_iterator cend() const noexcept;

	reverse_iterator rbegin() noexcept;
	const_reverse_iterator rbegin() const noexcept;
	const_reverse_iterator crbegin() const noexcept;
	reverse_iterator rend() noexcept;
	const_reverse_iterator rend() const noexcept;
	const_reverse_iterator crend() const noexcept;

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

	// element access:
	reference operator[](size_type n);
	const_reference operator[](size_type n) const;

	reference front();
	const_reference front() const;
	reference back();
	const_reference back() const;

	const_reference at(size_type n) const;
	reference at(size_type n);

	// data access:
	T* data() noexcept;
	const T* data() const noexcept;

	// mutating member functions:
	void fill(const T& v);
	};

	}} // std::experimental

	*/
	#include <__config>
	#if _LIBCPP_STD_VER > 11

	#include <__functional_base>
	#include <iterator>
	#include <stdexcept>
	#include <initializer_list>
	#include <new>
	#include <algorithm>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>

	namespace std { namespace experimental { inline namespace __array_extensions_v1 {

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_DYNARRAY dynarray
	{
	public:
	// types:
	typedef dynarray __self;
	typedef _Tp value_type;
	typedef value_type& reference;
	typedef const value_type& const_reference;
	typedef value_type* iterator;
	typedef const value_type* const_iterator;
	typedef value_type* pointer;
	typedef const value_type* const_pointer;
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;
	typedef std::reverse_iterator<iterator> reverse_iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

	private:
	size_t __size_;
	value_type * __base_;
	- _LIBCPP_ALWAYS_INLINE dynarray () noexcept : __size_(0), __base_(nullptr) {}
	+ _LIBCPP_INLINE_VISIBILITY dynarray () noexcept : __size_(0), __base_(nullptr) {}

	- static inline _LIBCPP_INLINE_VISIBILITY value_type* __allocate ( size_t count )
	- {
	- if ( numeric_limits<size_t>::max() / sizeof (value_type) <= count )
	+ static inline _LIBCPP_INLINE_VISIBILITY
	+ value_type* __allocate(size_t __count) {
	+ if (numeric_limits<size_t>::max() / sizeof (value_type) <= __count)
	__throw_bad_array_length();

	- return static_cast<value_type > (_VSTD::__allocate (sizeof(value_type) count));
	+ return static_cast<value_type *>(
	+ _VSTD::__libcpp_allocate(sizeof(value_type) * __count, __alignof(value_type)));
	}

	- static inline _LIBCPP_INLINE_VISIBILITY void __deallocate_value( value_type* __ptr ) noexcept
	- {
	- _VSTD::__libcpp_deallocate (static_cast<void *> (__ptr));
	+ static inline _LIBCPP_INLINE_VISIBILITY
	+ void __deallocate_value(value_type* __ptr ) noexcept {
	+ _VSTD::__libcpp_deallocate(static_cast<void *>(__ptr), __alignof(value_type));
	}

	public:

	_LIBCPP_INLINE_VISIBILITY
	explicit dynarray(size_type __c);
	_LIBCPP_INLINE_VISIBILITY
	dynarray(size_type __c, const value_type& __v);
	_LIBCPP_INLINE_VISIBILITY
	dynarray(const dynarray& __d);
	_LIBCPP_INLINE_VISIBILITY
	dynarray(initializer_list<value_type>);

	// We're not implementing these right now.
	// Updated with the resolution of LWG issue #2255
	// template <typename _Alloc>
	// dynarray(allocator_arg_t, const _Alloc& __alloc, size_type __c);
	// template <typename _Alloc>
	// dynarray(allocator_arg_t, const _Alloc& __alloc, size_type __c, const value_type& __v);
	// template <typename _Alloc>
	// dynarray(allocator_arg_t, const _Alloc& __alloc, const dynarray& __d);
	// template <typename _Alloc>
	// dynarray(allocator_arg_t, const _Alloc& __alloc, initializer_list<value_type>);

	dynarray& operator=(const dynarray&) = delete;
	_LIBCPP_INLINE_VISIBILITY
	~dynarray();

	// iterators:
	inline _LIBCPP_INLINE_VISIBILITY iterator begin() noexcept { return iterator(data()); }
	inline _LIBCPP_INLINE_VISIBILITY const_iterator begin() const noexcept { return const_iterator(data()); }
	inline _LIBCPP_INLINE_VISIBILITY const_iterator cbegin() const noexcept { return const_iterator(data()); }
	inline _LIBCPP_INLINE_VISIBILITY iterator end() noexcept { return iterator(data() + __size_); }
	inline _LIBCPP_INLINE_VISIBILITY const_iterator end() const noexcept { return const_iterator(data() + __size_); }
	inline _LIBCPP_INLINE_VISIBILITY const_iterator cend() const noexcept { return const_iterator(data() + __size_); }

	inline _LIBCPP_INLINE_VISIBILITY reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
	inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
	inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
	inline _LIBCPP_INLINE_VISIBILITY reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
	inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
	inline _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); }

	// capacity:
	inline _LIBCPP_INLINE_VISIBILITY size_type size() const noexcept { return __size_; }
	inline _LIBCPP_INLINE_VISIBILITY size_type max_size() const noexcept { return __size_; }
	inline _LIBCPP_INLINE_VISIBILITY bool empty() const noexcept { return __size_ == 0; }

	// element access:
	inline _LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n) { return data()[__n]; }
	inline _LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const { return data()[__n]; }

	inline _LIBCPP_INLINE_VISIBILITY reference front() { return data()[0]; }
	inline _LIBCPP_INLINE_VISIBILITY const_reference front() const { return data()[0]; }
	inline _LIBCPP_INLINE_VISIBILITY reference back() { return data()[__size_-1]; }
	inline _LIBCPP_INLINE_VISIBILITY const_reference back() const { return data()[__size_-1]; }

	inline _LIBCPP_INLINE_VISIBILITY const_reference at(size_type __n) const;
	inline _LIBCPP_INLINE_VISIBILITY reference at(size_type __n);

	// data access:
	inline _LIBCPP_INLINE_VISIBILITY _Tp* data() noexcept { return __base_; }
	inline _LIBCPP_INLINE_VISIBILITY const _Tp* data() const noexcept { return __base_; }

	// mutating member functions:
	inline _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __v) { fill_n(begin(), __size_, __v); }
	};

	template <class _Tp>
	inline
	dynarray<_Tp>::dynarray(size_type __c) : dynarray ()
	{
	__base_ = __allocate (__c);
	value_type *__data = data ();
	for ( __size_ = 0; __size_ < __c; ++__size_, ++__data )
	::new (__data) value_type;
	}

	template <class _Tp>
	inline
	dynarray<_Tp>::dynarray(size_type __c, const value_type& __v) : dynarray ()
	{
	__base_ = __allocate (__c);
	value_type *__data = data ();
	for ( __size_ = 0; __size_ < __c; ++__size_, ++__data )
	::new (__data) value_type (__v);
	}

	template <class _Tp>
	inline
	dynarray<_Tp>::dynarray(initializer_list<value_type> __il) : dynarray ()
	{
	size_t sz = __il.size();
	__base_ = __allocate (sz);
	value_type *__data = data ();
	auto src = __il.begin();
	for ( __size_ = 0; __size_ < sz; ++__size_, ++__data, ++src )
	::new (__data) value_type (*src);
	}

	template <class _Tp>
	inline
	dynarray<_Tp>::dynarray(const dynarray& __d) : dynarray ()
	{
	size_t sz = __d.size();
	__base_ = __allocate (sz);
	value_type *__data = data ();
	auto src = __d.begin();
	for ( __size_ = 0; __size_ < sz; ++__size_, ++__data, ++src )
	::new (__data) value_type (*src);
	}

	template <class _Tp>
	inline
	dynarray<_Tp>::~dynarray()
	{
	value_type *__data = data () + __size_;
	for ( size_t i = 0; i < __size_; ++i )
	(--__data)->value_type::~value_type();
	__deallocate_value( __base_ );
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename dynarray<_Tp>::reference
	dynarray<_Tp>::at(size_type __n)
	{
	if (__n >= __size_)
	__throw_out_of_range("dynarray::at");

	return data()[__n];
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename dynarray<_Tp>::const_reference
	dynarray<_Tp>::at(size_type __n) const
	{
	if (__n >= __size_)
	__throw_out_of_range("dynarray::at");

	return data()[__n];
	}

	}}}


	_LIBCPP_BEGIN_NAMESPACE_STD
	template <class _Tp, class _Alloc>
	struct _LIBCPP_TEMPLATE_VIS uses_allocator<std::experimental::dynarray<_Tp>, _Alloc> : true_type {};
	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // if _LIBCPP_STD_VER > 11
	#endif // _LIBCPP_DYNARRAY
	Index: projects/clang700-import/contrib/libc++/include/experimental/filesystem
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/filesystem (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/filesystem (revision 337135)
	@@ -1,2140 +1,257 @@
	// -- C++ --
	//===--------------------------- filesystem -------------------------------===//
	//
	// 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_EXPERIMENTAL_FILESYSTEM
	#define _LIBCPP_EXPERIMENTAL_FILESYSTEM
	/*
	filesystem synopsis

	namespace std { namespace experimental { namespace filesystem { inline namespace v1 {

	class path;

	- void swap(path& lhs, path& rhs) _NOEXCEPT;
	- size_t hash_value(const path& p) _NOEXCEPT;
	+ void swap(path& lhs, path& rhs) noexcept;
	+ size_t hash_value(const path& p) noexcept;

	- bool operator==(const path& lhs, const path& rhs) _NOEXCEPT;
	- bool operator!=(const path& lhs, const path& rhs) _NOEXCEPT;
	- bool operator< (const path& lhs, const path& rhs) _NOEXCEPT;
	- bool operator<=(const path& lhs, const path& rhs) _NOEXCEPT;
	- bool operator> (const path& lhs, const path& rhs) _NOEXCEPT;
	- bool operator>=(const path& lhs, const path& rhs) _NOEXCEPT;
	+ bool operator==(const path& lhs, const path& rhs) noexcept;
	+ bool operator!=(const path& lhs, const path& rhs) noexcept;
	+ bool operator< (const path& lhs, const path& rhs) noexcept;
	+ bool operator<=(const path& lhs, const path& rhs) noexcept;
	+ bool operator> (const path& lhs, const path& rhs) noexcept;
	+ bool operator>=(const path& lhs, const path& rhs) noexcept;

	path operator/ (const path& lhs, const path& rhs);

	+ // fs.path.io operators are friends of path.
	template <class charT, class traits>
	- basic_ostream<charT, traits>&
	+ friend basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os, const path& p);

	template <class charT, class traits>
	- basic_istream<charT, traits>&
	+ friend basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is, path& p);

	template <class Source>
	path u8path(const Source& source);
	template <class InputIterator>
	path u8path(InputIterator first, InputIterator last);

	class filesystem_error;
	class directory_entry;

	class directory_iterator;

	// enable directory_iterator range-based for statements
	directory_iterator begin(directory_iterator iter) noexcept;
	directory_iterator end(const directory_iterator&) noexcept;

	class recursive_directory_iterator;

	// enable recursive_directory_iterator range-based for statements
	recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
	recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;

	class file_status;

	struct space_info
	{
	uintmax_t capacity;
	uintmax_t free;
	uintmax_t available;
	};

	enum class file_type;
	enum class perms;
	+ enum class perm_options;
	enum class copy_options;
	enum class directory_options;

	typedef chrono::time_point<trivial-clock> file_time_type;

	// operational functions

	- path absolute(const path& p, const path& base=current_path());
	+ path absolute(const path& p);
	+ path absolute(const path& p, error_code &ec);

	- path canonical(const path& p, const path& base = current_path());
	+ path canonical(const path& p);
	path canonical(const path& p, error_code& ec);
	- 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);
	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);

	bool copy_file(const path& from, const path& to);
	- bool copy_file(const path& from, const path& to, error_code& ec) _NOEXCEPT;
	+ bool copy_file(const path& from, const path& to, error_code& ec);
	bool copy_file(const path& from, const path& to, copy_options option);
	bool copy_file(const path& from, const path& to, copy_options option,
	- error_code& ec) _NOEXCEPT;
	+ error_code& ec);

	void copy_symlink(const path& existing_symlink, const path& new_symlink);
	void copy_symlink(const path& existing_symlink, const path& new_symlink,
	- error_code& ec) _NOEXCEPT;
	+ error_code& ec) noexcept;

	bool create_directories(const path& p);
	- bool create_directories(const path& p, error_code& ec) _NOEXCEPT;
	+ bool create_directories(const path& p, error_code& ec);

	bool create_directory(const path& p);
	- bool create_directory(const path& p, error_code& ec) _NOEXCEPT;
	+ bool create_directory(const path& p, error_code& ec) noexcept;

	bool create_directory(const path& p, const path& attributes);
	bool create_directory(const path& p, const path& attributes,
	- error_code& ec) _NOEXCEPT;
	+ error_code& ec) noexcept;

	void create_directory_symlink(const path& to, const path& new_symlink);
	void create_directory_symlink(const path& to, const path& new_symlink,
	- error_code& ec) _NOEXCEPT;
	+ error_code& ec) noexcept;

	void create_hard_link(const path& to, const path& new_hard_link);
	void create_hard_link(const path& to, const path& new_hard_link,
	- error_code& ec) _NOEXCEPT;
	+ error_code& ec) noexcept;

	void create_symlink(const path& to, const path& new_symlink);
	void create_symlink(const path& to, const path& new_symlink,
	- error_code& ec) _NOEXCEPT;
	+ error_code& ec) noexcept;

	path current_path();
	path current_path(error_code& ec);
	void current_path(const path& p);
	- void current_path(const path& p, error_code& ec) _NOEXCEPT;
	+ void current_path(const path& p, error_code& ec) noexcept;

	- bool exists(file_status s) _NOEXCEPT;
	+ bool exists(file_status s) noexcept;
	bool exists(const path& p);
	- bool exists(const path& p, error_code& ec) _NOEXCEPT;
	+ bool exists(const path& p, error_code& ec) noexcept;

	bool equivalent(const path& p1, const path& p2);
	- bool equivalent(const path& p1, const path& p2, error_code& ec) _NOEXCEPT;
	+ bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept;

	uintmax_t file_size(const path& p);
	- uintmax_t file_size(const path& p, error_code& ec) _NOEXCEPT;
	+ uintmax_t file_size(const path& p, error_code& ec) noexcept;

	uintmax_t hard_link_count(const path& p);
	- uintmax_t hard_link_count(const path& p, error_code& ec) _NOEXCEPT;
	+ uintmax_t hard_link_count(const path& p, error_code& ec) noexcept;

	- bool is_block_file(file_status s) _NOEXCEPT;
	+ bool is_block_file(file_status s) noexcept;
	bool is_block_file(const path& p);
	- bool is_block_file(const path& p, error_code& ec) _NOEXCEPT;
	+ bool is_block_file(const path& p, error_code& ec) noexcept;

	- bool is_character_file(file_status s) _NOEXCEPT;
	+ bool is_character_file(file_status s) noexcept;
	bool is_character_file(const path& p);
	- bool is_character_file(const path& p, error_code& ec) _NOEXCEPT;
	+ bool is_character_file(const path& p, error_code& ec) noexcept;

	- bool is_directory(file_status s) _NOEXCEPT;
	+ bool is_directory(file_status s) noexcept;
	bool is_directory(const path& p);
	- bool is_directory(const path& p, error_code& ec) _NOEXCEPT;
	+ bool is_directory(const path& p, error_code& ec) noexcept;

	bool is_empty(const path& p);
	- bool is_empty(const path& p, error_code& ec) _NOEXCEPT;
	+ bool is_empty(const path& p, error_code& ec) noexcept;

	- bool is_fifo(file_status s) _NOEXCEPT;
	+ bool is_fifo(file_status s) noexcept;
	bool is_fifo(const path& p);
	- bool is_fifo(const path& p, error_code& ec) _NOEXCEPT;
	+ bool is_fifo(const path& p, error_code& ec) noexcept;

	- bool is_other(file_status s) _NOEXCEPT;
	+ bool is_other(file_status s) noexcept;
	bool is_other(const path& p);
	- bool is_other(const path& p, error_code& ec) _NOEXCEPT;
	+ bool is_other(const path& p, error_code& ec) noexcept;

	- bool is_regular_file(file_status s) _NOEXCEPT;
	+ bool is_regular_file(file_status s) noexcept;
	bool is_regular_file(const path& p);
	- bool is_regular_file(const path& p, error_code& ec) _NOEXCEPT;
	+ bool is_regular_file(const path& p, error_code& ec) noexcept;

	- bool is_socket(file_status s) _NOEXCEPT;
	+ bool is_socket(file_status s) noexcept;
	bool is_socket(const path& p);
	- bool is_socket(const path& p, error_code& ec) _NOEXCEPT;
	+ bool is_socket(const path& p, error_code& ec) noexcept;

	- bool is_symlink(file_status s) _NOEXCEPT;
	+ bool is_symlink(file_status s) noexcept;
	bool is_symlink(const path& p);
	- bool is_symlink(const path& p, error_code& ec) _NOEXCEPT;
	+ bool is_symlink(const path& p, error_code& ec) noexcept;

	file_time_type last_write_time(const path& p);
	- file_time_type last_write_time(const path& p, error_code& ec) _NOEXCEPT;
	+ file_time_type last_write_time(const path& p, error_code& ec) noexcept;
	void last_write_time(const path& p, file_time_type new_time);
	void last_write_time(const path& p, file_time_type new_time,
	- error_code& ec) _NOEXCEPT;
	+ error_code& ec) noexcept;

	- void permissions(const path& p, perms prms);
	- void permissions(const path& p, perms prms, error_code& ec) _NOEXCEPT;
	+ void permissions(const path& p, perms prms,
	+ perm_options opts=perm_options::replace);
	+ void permissions(const path& p, perms prms, error_code& ec) noexcept;
	+ void permissions(const path& p, perms prms, perm_options opts,
	+ error_code& ec);

	+ path proximate(const path& p, error_code& ec);
	+ path proximate(const path& p, const path& base = current_path());
	+ path proximate(const path& p, const path& base, error_code &ec);
	+
	path read_symlink(const path& p);
	path read_symlink(const path& p, error_code& ec);

	+ path relative(const path& p, error_code& ec);
	+ path relative(const path& p, const path& base=current_path());
	+ path relative(const path& p, const path& base, error_code& ec);
	+
	bool remove(const path& p);
	- bool remove(const path& p, error_code& ec) _NOEXCEPT;
	+ bool remove(const path& p, error_code& ec) noexcept;

	uintmax_t remove_all(const path& p);
	- uintmax_t remove_all(const path& p, error_code& ec) _NOEXCEPT;
	+ uintmax_t remove_all(const path& p, error_code& ec);

	void rename(const path& from, const path& to);
	- void rename(const path& from, const path& to, error_code& ec) _NOEXCEPT;
	+ void rename(const path& from, const path& to, error_code& ec) noexcept;

	void resize_file(const path& p, uintmax_t size);
	- void resize_file(const path& p, uintmax_t size, error_code& ec) _NOEXCEPT;
	+ void resize_file(const path& p, uintmax_t size, error_code& ec) noexcept;

	space_info space(const path& p);
	- space_info space(const path& p, error_code& ec) _NOEXCEPT;
	+ space_info space(const path& p, error_code& ec) noexcept;

	file_status status(const path& p);
	- file_status status(const path& p, error_code& ec) _NOEXCEPT;
	+ file_status status(const path& p, error_code& ec) noexcept;

	- bool status_known(file_status s) _NOEXCEPT;
	+ bool status_known(file_status s) noexcept;

	file_status symlink_status(const path& p);
	- file_status symlink_status(const path& p, error_code& ec) _NOEXCEPT;
	+ file_status symlink_status(const path& p, error_code& ec) noexcept;

	- path system_complete(const path& p);
	- path system_complete(const path& p, error_code& ec);
	-
	path temp_directory_path();
	path temp_directory_path(error_code& ec);

	+ path weakly_canonical(path const& p);
	+ path weakly_canonical(path const& p, error_code& ec);
	+
	+
	} } } } // namespaces std::experimental::filesystem::v1

	*/

	#include <experimental/__config>
	-#include <cstddef>
	-#include <chrono>
	-#include <iterator>
	-#include <iosfwd>
	-#include <locale>
	-#include <memory>
	-#include <stack>
	-#include <string>
	-#include <system_error>
	-#include <utility>
	-#include <iomanip> // for quoted
	-#include <string_view>
	+#include <filesystem>

	-#include <__debug>
	-
	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	+_LIBCPP_PUSH_MACROS
	+#include <__undef_macros>
	+
	+#ifndef _LIBCPP_CXX03_LANG
	+
	#define __cpp_lib_experimental_filesystem 201406

	_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM

	-typedef chrono::time_point<std::chrono::system_clock> file_time_type;
	+using namespace _VSTD_FS;

	-struct _LIBCPP_TYPE_VIS space_info
	-{
	- uintmax_t capacity;
	- uintmax_t free;
	- uintmax_t available;
	-};
	+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM

	-enum class _LIBCPP_ENUM_VIS file_type : signed char
	-{
	- none = 0,
	- not_found = -1,
	- regular = 1,
	- directory = 2,
	- symlink = 3,
	- block = 4,
	- character = 5,
	- fifo = 6,
	- socket = 7,
	- unknown = 8
	-};
	+#endif // !_LIBCPP_CXX03_LANG

	-enum class _LIBCPP_ENUM_VIS perms : unsigned
	-{
	- none = 0,
	-
	- owner_read = 0400,
	- owner_write = 0200,
	- owner_exec = 0100,
	- owner_all = 0700,
	-
	- group_read = 040,
	- group_write = 020,
	- group_exec = 010,
	- group_all = 070,
	-
	- others_read = 04,
	- others_write = 02,
	- others_exec = 01,
	- others_all = 07,
	-
	- all = 0777,
	-
	- set_uid = 04000,
	- set_gid = 02000,
	- sticky_bit = 01000,
	- mask = 07777,
	- unknown = 0xFFFF,
	-
	- add_perms = 0x10000,
	- remove_perms = 0x20000,
	- symlink_nofollow = 0x40000
	-};
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline _LIBCPP_CONSTEXPR perms operator&(perms _LHS, perms _RHS)
	-{ return static_cast<perms>(static_cast<unsigned>(_LHS) & static_cast<unsigned>(_RHS)); }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline _LIBCPP_CONSTEXPR perms operator\|(perms _LHS, perms _RHS)
	-{ return static_cast<perms>(static_cast<unsigned>(_LHS) \| static_cast<unsigned>(_RHS)); }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline _LIBCPP_CONSTEXPR perms operator^(perms _LHS, perms _RHS)
	-{ return static_cast<perms>(static_cast<unsigned>(_LHS) ^ static_cast<unsigned>(_RHS)); }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline _LIBCPP_CONSTEXPR perms operator~(perms _LHS)
	-{ return static_cast<perms>(~static_cast<unsigned>(_LHS)); }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline perms& operator&=(perms& _LHS, perms _RHS)
	-{ return _LHS = _LHS & _RHS; }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline perms& operator\|=(perms& _LHS, perms _RHS)
	-{ return _LHS = _LHS \| _RHS; }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline perms& operator^=(perms& _LHS, perms _RHS)
	-{ return _LHS = _LHS ^ _RHS; }
	-
	-enum class _LIBCPP_ENUM_VIS copy_options : unsigned short
	-{
	- none = 0,
	- skip_existing = 1,
	- overwrite_existing = 2,
	- update_existing = 4,
	- recursive = 8,
	- copy_symlinks = 16,
	- skip_symlinks = 32,
	- directories_only = 64,
	- create_symlinks = 128,
	- create_hard_links = 256,
	- __in_recursive_copy = 512,
	-};
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline _LIBCPP_CONSTEXPR copy_options operator&(copy_options _LHS, copy_options _RHS)
	-{ return static_cast<copy_options>(static_cast<unsigned short>(_LHS) & static_cast<unsigned short>(_RHS)); }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline _LIBCPP_CONSTEXPR copy_options operator\|(copy_options _LHS, copy_options _RHS)
	-{ return static_cast<copy_options>(static_cast<unsigned short>(_LHS) \| static_cast<unsigned short>(_RHS)); }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline _LIBCPP_CONSTEXPR copy_options operator^(copy_options _LHS, copy_options _RHS)
	-{ return static_cast<copy_options>(static_cast<unsigned short>(_LHS) ^ static_cast<unsigned short>(_RHS)); }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline _LIBCPP_CONSTEXPR copy_options operator~(copy_options _LHS)
	-{ return static_cast<copy_options>(~static_cast<unsigned short>(_LHS)); }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline copy_options& operator&=(copy_options& _LHS, copy_options _RHS)
	-{ return _LHS = _LHS & _RHS; }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline copy_options& operator\|=(copy_options& _LHS, copy_options _RHS)
	-{ return _LHS = _LHS \| _RHS; }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline copy_options& operator^=(copy_options& _LHS, copy_options _RHS)
	-{ return _LHS = _LHS ^ _RHS; }
	-
	-
	-enum class _LIBCPP_ENUM_VIS directory_options : unsigned char
	-{
	- none = 0,
	- follow_directory_symlink = 1,
	- skip_permission_denied = 2
	-};
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline _LIBCPP_CONSTEXPR directory_options operator&(directory_options _LHS, directory_options _RHS)
	-{ return static_cast<directory_options>(static_cast<unsigned char>(_LHS) & static_cast<unsigned char>(_RHS)); }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline _LIBCPP_CONSTEXPR directory_options operator\|(directory_options _LHS, directory_options _RHS)
	-{ return static_cast<directory_options>(static_cast<unsigned char>(_LHS) \| static_cast<unsigned char>(_RHS)); }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline _LIBCPP_CONSTEXPR directory_options operator^(directory_options _LHS, directory_options _RHS)
	-{ return static_cast<directory_options>(static_cast<unsigned char>(_LHS) ^ static_cast<unsigned char>(_RHS)); }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline _LIBCPP_CONSTEXPR directory_options operator~(directory_options _LHS)
	-{ return static_cast<directory_options>(~static_cast<unsigned char>(_LHS)); }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline directory_options& operator&=(directory_options& _LHS, directory_options _RHS)
	-{ return _LHS = _LHS & _RHS; }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline directory_options& operator\|=(directory_options& _LHS, directory_options _RHS)
	-{ return _LHS = _LHS \| _RHS; }
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline directory_options& operator^=(directory_options& _LHS, directory_options _RHS)
	-{ return _LHS = _LHS ^ _RHS; }
	-
	-
	-class _LIBCPP_TYPE_VIS file_status
	-{
	-public:
	- // constructors
	- _LIBCPP_INLINE_VISIBILITY
	- file_status() _NOEXCEPT : file_status(file_type::none) {}
	- _LIBCPP_INLINE_VISIBILITY
	- explicit file_status(file_type __ft,
	- perms __prms = perms::unknown) _NOEXCEPT
	- : __ft_(__ft), __prms_(__prms)
	- {}
	-
	- file_status(const file_status&) _NOEXCEPT = default;
	- file_status(file_status&&) _NOEXCEPT = default;
	-
	- _LIBCPP_INLINE_VISIBILITY
	- ~file_status() {}
	-
	- file_status& operator=(const file_status&) _NOEXCEPT = default;
	- file_status& operator=(file_status&&) _NOEXCEPT = default;
	-
	- // observers
	- _LIBCPP_ALWAYS_INLINE
	- file_type type() const _NOEXCEPT {
	- return __ft_;
	- }
	-
	- _LIBCPP_ALWAYS_INLINE
	- perms permissions() const _NOEXCEPT {
	- return __prms_;
	- }
	-
	- // modifiers
	- _LIBCPP_ALWAYS_INLINE
	- void type(file_type __ft) _NOEXCEPT {
	- __ft_ = __ft;
	- }
	-
	- _LIBCPP_ALWAYS_INLINE
	- void permissions(perms __p) _NOEXCEPT {
	- __prms_ = __p;
	- }
	-private:
	- file_type __ft_;
	- perms __prms_;
	-};
	-
	-class _LIBCPP_TYPE_VIS directory_entry;
	-
	-template <class _Tp> struct __can_convert_char {
	- static const bool value = false;
	-};
	-template <class _Tp> struct __can_convert_char<const _Tp>
	- : public __can_convert_char<_Tp> {
	-};
	-template <> struct __can_convert_char<char> {
	- static const bool value = true;
	- using __char_type = char;
	-};
	-template <> struct __can_convert_char<wchar_t> {
	- static const bool value = true;
	- using __char_type = wchar_t;
	-};
	-template <> struct __can_convert_char<char16_t> {
	- static const bool value = true;
	- using __char_type = char16_t;
	-};
	-template <> struct __can_convert_char<char32_t> {
	- static const bool value = true;
	- using __char_type = char32_t;
	-};
	-
	-template <class _ECharT>
	-typename enable_if<__can_convert_char<_ECharT>::value, bool>::type
	-__is_separator(_ECharT __e) {
	- return __e == _ECharT('/');
	-};
	-
	-struct _NullSentinal {};
	-
	-template <class _Tp>
	-using _Void = void;
	-
	-template <class _Tp, class = void>
	-struct __is_pathable_string : public false_type {};
	-
	-template <class _ECharT, class _Traits, class _Alloc>
	-struct __is_pathable_string<basic_string<_ECharT, _Traits, _Alloc>,
	- _Void<typename __can_convert_char<_ECharT>::__char_type>>
	-: public __can_convert_char<_ECharT>
	-{
	- using _Str = basic_string<_ECharT, _Traits, _Alloc>;
	- using _Base = __can_convert_char<_ECharT>;
	- static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
	- static _ECharT const* __range_end(_Str const& __s) { return __s.data() + __s.length(); }
	- static _ECharT __first_or_null(_Str const& __s) {
	- return __s.empty() ? _ECharT{} : __s[0];
	- }
	-};
	-
	-
	-template <class _ECharT, class _Traits>
	-struct __is_pathable_string<basic_string_view<_ECharT, _Traits>,
	- _Void<typename __can_convert_char<_ECharT>::__char_type>>
	-: public __can_convert_char<_ECharT>
	-{
	- using _Str = basic_string_view<_ECharT, _Traits>;
	- using _Base = __can_convert_char<_ECharT>;
	- static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
	- static _ECharT const* __range_end(_Str const& __s) { return __s.data() + __s.length(); }
	- static _ECharT __first_or_null(_Str const& __s) {
	- return __s.empty() ? _ECharT{} : __s[0];
	- }
	-};
	-
	-template <class _Source,
	- class _DS = typename decay<_Source>::type,
	- class _UnqualPtrType = typename remove_const<
	- typename remove_pointer<_DS>::type>::type,
	- bool _IsCharPtr = is_pointer<_DS>::value &&
	- __can_convert_char<_UnqualPtrType>::value
	- >
	-struct __is_pathable_char_array : false_type {};
	-
	-template <class _Source, class _ECharT, class _UPtr>
	-struct __is_pathable_char_array<_Source, _ECharT*, _UPtr, true>
	- : __can_convert_char<typename remove_const<_ECharT>::type>
	-{
	- using _Base = __can_convert_char<typename remove_const<_ECharT>::type>;
	-
	- static _ECharT const* __range_begin(const _ECharT* __b) { return __b; }
	- static _ECharT const* __range_end(const _ECharT* __b)
	- {
	- using _Iter = const _ECharT*;
	- const _ECharT __sentinal = _ECharT{};
	- _Iter __e = __b;
	- for (; *__e != __sentinal; ++__e)
	- ;
	- return __e;
	- }
	-
	- static _ECharT __first_or_null(const _ECharT* __b) { return *__b; }
	-};
	-
	-template <class _Iter, bool _IsIt = __is_input_iterator<_Iter>::value, class = void>
	-struct __is_pathable_iter : false_type {};
	-
	-template <class _Iter>
	-struct __is_pathable_iter<_Iter, true,
	- _Void<typename __can_convert_char<typename iterator_traits<_Iter>::value_type>::__char_type>>
	- : __can_convert_char<typename iterator_traits<_Iter>::value_type>
	-{
	- using _ECharT = typename iterator_traits<_Iter>::value_type;
	- using _Base = __can_convert_char<_ECharT>;
	-
	- static _Iter __range_begin(_Iter __b) { return __b; }
	- static _NullSentinal __range_end(_Iter) { return _NullSentinal{}; }
	-
	- static _ECharT __first_or_null(_Iter __b) { return *__b; }
	-};
	-
	-template <class _Tp, bool _IsStringT = __is_pathable_string<_Tp>::value,
	- bool _IsCharIterT = __is_pathable_char_array<_Tp>::value,
	- bool _IsIterT = !_IsCharIterT && __is_pathable_iter<_Tp>::value
	- >
	-struct __is_pathable : false_type {
	- static_assert(!_IsStringT && !_IsCharIterT && !_IsIterT, "Must all be false");
	-};
	-
	-template <class _Tp>
	-struct __is_pathable<_Tp, true, false, false> : __is_pathable_string<_Tp> {};
	-
	-
	-template <class _Tp>
	-struct __is_pathable<_Tp, false, true, false> : __is_pathable_char_array<_Tp> {};
	-
	-
	-template <class _Tp>
	-struct __is_pathable<_Tp, false, false, true> : __is_pathable_iter<_Tp> {};
	-
	-
	-template <class _ECharT>
	-struct _PathCVT {
	- static_assert(__can_convert_char<_ECharT>::value, "Char type not convertible");
	-
	- typedef __narrow_to_utf8<sizeof(_ECharT)*__CHAR_BIT__> _Narrower;
	-
	- static void __append_range(string& __dest, _ECharT const* __b, _ECharT const* __e) {
	- _Narrower()(back_inserter(__dest), __b, __e);
	- }
	-
	- template <class _Iter>
	- static void __append_range(string& __dest, _Iter __b, _Iter __e) {
	- static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
	- if (__b == __e) return;
	- basic_string<_ECharT> __tmp(__b, __e);
	- _Narrower()(back_inserter(__dest), __tmp.data(),
	- __tmp.data() + __tmp.length());
	- }
	-
	- template <class _Iter>
	- static void __append_range(string& __dest, _Iter __b, _NullSentinal) {
	- static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
	- const _ECharT __sentinal = _ECharT{};
	- if (*__b == __sentinal) return;
	- basic_string<_ECharT> __tmp;
	- for (; *__b != __sentinal; ++__b)
	- __tmp.push_back(*__b);
	- _Narrower()(back_inserter(__dest), __tmp.data(),
	- __tmp.data() + __tmp.length());
	- }
	-
	- template <class _Source>
	- static void __append_source(string& __dest, _Source const& __s)
	- {
	- using _Traits = __is_pathable<_Source>;
	- __append_range(__dest, _Traits::__range_begin(__s), _Traits::__range_end(__s));
	- }
	-};
	-
	-template <>
	-struct _PathCVT<char> {
	-
	- template <class _Iter>
	- static typename enable_if<
	- __is_exactly_input_iterator<_Iter>::value
	- >::type __append_range(string& __dest, _Iter __b, _Iter __e) {
	- for (; __b != __e; ++__b)
	- __dest.push_back(*__b);
	- }
	-
	- template <class _Iter>
	- static typename enable_if<
	- __is_forward_iterator<_Iter>::value
	- >::type __append_range(string& __dest, _Iter __b, _Iter __e) {
	- __dest.__append_forward_unsafe(__b, __e);
	- }
	-
	- template <class _Iter>
	- static void __append_range(string& __dest, _Iter __b, _NullSentinal) {
	- const char __sentinal = char{};
	- for (; *__b != __sentinal; ++__b)
	- __dest.push_back(*__b);
	- }
	-
	- template <class _Source>
	- static void __append_source(string& __dest, _Source const& __s)
	- {
	- using _Traits = __is_pathable<_Source>;
	- __append_range(__dest, _Traits::__range_begin(__s),
	- _Traits::__range_end(__s));
	- }
	-};
	-
	-
	-class _LIBCPP_TYPE_VIS path
	-{
	- template <class _SourceOrIter, class _Tp = path&>
	- using _EnableIfPathable = typename
	- enable_if<__is_pathable<_SourceOrIter>::value, _Tp>::type;
	-
	- template <class _Tp>
	- using _SourceChar = typename __is_pathable<_Tp>::__char_type;
	-
	- template <class _Tp>
	- using _SourceCVT = _PathCVT<_SourceChar<_Tp>>;
	-
	-public:
	- typedef char value_type;
	- typedef basic_string<value_type> string_type;
	- typedef _VSTD::string_view __string_view;
	- static _LIBCPP_CONSTEXPR value_type preferred_separator = '/';
	-
	- // constructors and destructor
	- _LIBCPP_INLINE_VISIBILITY path() _NOEXCEPT {}
	- _LIBCPP_INLINE_VISIBILITY path(const path& __p) : __pn_(__p.__pn_) {}
	- _LIBCPP_INLINE_VISIBILITY path(path&& __p) _NOEXCEPT : __pn_(_VSTD::move(__p.__pn_)) {}
	-
	- _LIBCPP_INLINE_VISIBILITY
	- path(string_type&& __s) _NOEXCEPT : __pn_(_VSTD::move(__s)) {}
	-
	- template <
	- class _Source,
	- class = _EnableIfPathable<_Source, void>
	- >
	- path(const _Source& __src) {
	- _SourceCVT<_Source>::__append_source(__pn_, __src);
	- }
	-
	- template <class _InputIt>
	- path(_InputIt __first, _InputIt __last) {
	- typedef typename iterator_traits<_InputIt>::value_type _ItVal;
	- _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
	- }
	-
	- // TODO Implement locale conversions.
	- template <class _Source,
	- class = _EnableIfPathable<_Source, void>
	- >
	- path(const _Source& __src, const locale& __loc);
	- template <class _InputIt>
	- path(_InputIt __first, _InputIt _last, const locale& __loc);
	-
	- _LIBCPP_INLINE_VISIBILITY
	- ~path() = default;
	-
	- // assignments
	- _LIBCPP_INLINE_VISIBILITY
	- path& operator=(const path& __p) {
	- __pn_ = __p.__pn_;
	- return *this;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- path& operator=(path&& __p) _NOEXCEPT {
	- __pn_ = _VSTD::move(__p.__pn_);
	- return *this;
	- }
	-
	- template <class = void>
	- _LIBCPP_INLINE_VISIBILITY
	- path& operator=(string_type&& __s) _NOEXCEPT {
	- __pn_ = _VSTD::move(__s);
	- return *this;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- path& assign(string_type&& __s) _NOEXCEPT {
	- __pn_ = _VSTD::move(__s);
	- return *this;
	- }
	-
	- template <class _Source>
	- _LIBCPP_INLINE_VISIBILITY
	- _EnableIfPathable<_Source>
	- operator=(const _Source& __src)
	- { return this->assign(__src); }
	-
	-
	- template <class _Source>
	- _EnableIfPathable<_Source>
	- assign(const _Source& __src) {
	- __pn_.clear();
	- _SourceCVT<_Source>::__append_source(__pn_, __src);
	- return *this;
	- }
	-
	- template <class _InputIt>
	- path& assign(_InputIt __first, _InputIt __last) {
	- typedef typename iterator_traits<_InputIt>::value_type _ItVal;
	- __pn_.clear();
	- _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
	- return *this;
	- }
	-
	-private:
	- template <class _ECharT>
	- void __append_sep_if_needed(_ECharT __first_or_null) {
	- const _ECharT __null_val = {};
	- bool __append_sep = !empty() &&
	- !__is_separator(__pn_.back()) &&
	- __first_or_null != __null_val && // non-empty
	- !__is_separator(__first_or_null);
	- if (__append_sep)
	- __pn_ += preferred_separator;
	- }
	-
	-public:
	- // appends
	- path& operator/=(const path& __p) {
	- _LIBCPP_ASSERT(!__p.has_root_name(),
	- "cannot append to a path with a root name");
	- __append_sep_if_needed(__p.empty() ? char{} : __p.__pn_[0]);
	- __pn_ += __p.native();
	- return *this;
	- }
	-
	- template <class _Source>
	- _LIBCPP_INLINE_VISIBILITY
	- _EnableIfPathable<_Source>
	- operator/=(const _Source& __src) {
	- return this->append(__src);
	- }
	-
	- template <class _Source>
	- _EnableIfPathable<_Source>
	- append(const _Source& __src) {
	- using _Traits = __is_pathable<_Source>;
	- using _CVT = _PathCVT<_SourceChar<_Source>>;
	- __append_sep_if_needed(_Traits::__first_or_null(__src));
	- _CVT::__append_source(__pn_, __src);
	- return *this;
	- }
	-
	- template <class _InputIt>
	- path& append(_InputIt __first, _InputIt __last) {
	- typedef typename iterator_traits<_InputIt>::value_type _ItVal;
	- static_assert(__can_convert_char<_ItVal>::value, "Must convertible");
	- using _CVT = _PathCVT<_ItVal>;
	- if (__first != __last) {
	- __append_sep_if_needed(*__first);
	- _CVT::__append_range(__pn_, __first, __last);
	- }
	- return *this;
	- }
	-
	- // concatenation
	- _LIBCPP_INLINE_VISIBILITY
	- path& operator+=(const path& __x) {
	- __pn_ += __x.__pn_;
	- return *this;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- path& operator+=(const string_type& __x) {
	- __pn_ += __x;
	- return *this;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- path& operator+=(__string_view __x) {
	- __pn_ += __x;
	- return *this;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- path& operator+=(const value_type* __x) {
	- __pn_ += __x;
	- return *this;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- path& operator+=(value_type __x) {
	- __pn_ += __x;
	- return *this;
	- }
	-
	- template <class _ECharT>
	- typename enable_if<__can_convert_char<_ECharT>::value, path&>::type
	- operator+=(_ECharT __x)
	- {
	- basic_string<_ECharT> __tmp;
	- __tmp += __x;
	- _PathCVT<_ECharT>::__append_source(__pn_, __tmp);
	- return *this;
	- }
	-
	- template <class _Source>
	- _EnableIfPathable<_Source>
	- operator+=(const _Source& __x) {
	- return this->concat(__x);
	- }
	-
	- template <class _Source>
	- _EnableIfPathable<_Source>
	- concat(const _Source& __x) {
	- _SourceCVT<_Source>::__append_source(__pn_, __x);
	- return *this;
	- }
	-
	- template <class _InputIt>
	- path& concat(_InputIt __first, _InputIt __last) {
	- typedef typename iterator_traits<_InputIt>::value_type _ItVal;
	- _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
	- return *this;
	- }
	-
	- // modifiers
	- _LIBCPP_INLINE_VISIBILITY
	- void clear() _NOEXCEPT {
	- __pn_.clear();
	- }
	-
	- path& make_preferred() { return *this; }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- path& remove_filename() {
	- if (__pn_.size() == __root_path_raw().size())
	- clear();
	- else
	- __pn_ = __parent_path();
	- return *this;
	- }
	-
	- path& replace_filename(const path& __replacement) {
	- remove_filename();
	- return (*this /= __replacement);
	- }
	-
	- path& replace_extension(const path& __replacement = path());
	-
	- _LIBCPP_INLINE_VISIBILITY
	- void swap(path& __rhs) _NOEXCEPT {
	- __pn_.swap(__rhs.__pn_);
	- }
	-
	- // native format observers
	- _LIBCPP_INLINE_VISIBILITY
	- const string_type& native() const _NOEXCEPT {
	- return __pn_;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- const value_type* c_str() const _NOEXCEPT { return __pn_.c_str(); }
	-
	- _LIBCPP_INLINE_VISIBILITY operator string_type() const { return __pn_; }
	-
	- template <class _ECharT, class _Traits = char_traits<_ECharT>,
	- class _Allocator = allocator<_ECharT> >
	- basic_string<_ECharT, _Traits, _Allocator>
	- string(const _Allocator& __a = _Allocator()) const {
	- using _CVT = __widen_from_utf8<sizeof(_ECharT)*__CHAR_BIT__>;
	- using _Str = basic_string<_ECharT, _Traits, _Allocator>;
	- _Str __s(__a);
	- __s.reserve(__pn_.size());
	- _CVT()(back_inserter(__s), __pn_.data(), __pn_.data() + __pn_.size());
	- return __s;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY std::string string() const { return __pn_; }
	- _LIBCPP_INLINE_VISIBILITY std::wstring wstring() const { return string<wchar_t>(); }
	- _LIBCPP_INLINE_VISIBILITY std::string u8string() const { return __pn_; }
	- _LIBCPP_INLINE_VISIBILITY std::u16string u16string() const { return string<char16_t>(); }
	- _LIBCPP_INLINE_VISIBILITY std::u32string u32string() const { return string<char32_t>(); }
	-
	- // generic format observers
	- template <class _ECharT, class _Traits = char_traits<_ECharT>,
	- class _Allocator = allocator<_ECharT>
	- >
	- basic_string<_ECharT, _Traits, _Allocator>
	- generic_string(const _Allocator& __a = _Allocator()) const {
	- return string<_ECharT, _Traits, _Allocator>(__a);
	- }
	-
	- std::string generic_string() const { return __pn_; }
	- std::wstring generic_wstring() const { return string<wchar_t>(); }
	- std::string generic_u8string() const { return __pn_; }
	- std::u16string generic_u16string() const { return string<char16_t>(); }
	- std::u32string generic_u32string() const { return string<char32_t>(); }
	-
	-private:
	- int __compare(__string_view) const;
	- __string_view __root_name() const;
	- __string_view __root_directory() const;
	- __string_view __root_path_raw() const;
	- __string_view __relative_path() const;
	- __string_view __parent_path() const;
	- __string_view __filename() const;
	- __string_view __stem() const;
	- __string_view __extension() const;
	-
	-public:
	- // compare
	- _LIBCPP_INLINE_VISIBILITY int compare(const path& __p) const _NOEXCEPT { return __compare(__p.__pn_);}
	- _LIBCPP_INLINE_VISIBILITY int compare(const string_type& __s) const { return __compare(__s); }
	- _LIBCPP_INLINE_VISIBILITY int compare(__string_view __s) const { return __compare(__s); }
	- _LIBCPP_INLINE_VISIBILITY int compare(const value_type* __s) const { return __compare(__s); }
	-
	- // decomposition
	- _LIBCPP_INLINE_VISIBILITY path root_name() const { return string_type(__root_name()); }
	- _LIBCPP_INLINE_VISIBILITY path root_directory() const { return string_type(__root_directory()); }
	- _LIBCPP_INLINE_VISIBILITY path root_path() const { return root_name().append(string_type(__root_directory())); }
	- _LIBCPP_INLINE_VISIBILITY path relative_path() const { return string_type(__relative_path()); }
	- _LIBCPP_INLINE_VISIBILITY path parent_path() const { return string_type(__parent_path()); }
	- _LIBCPP_INLINE_VISIBILITY path filename() const { return string_type(__filename()); }
	- _LIBCPP_INLINE_VISIBILITY path stem() const { return string_type(__stem());}
	- _LIBCPP_INLINE_VISIBILITY path extension() const { return string_type(__extension()); }
	-
	- // query
	- _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(); }
	- _LIBCPP_INLINE_VISIBILITY bool has_root_path() const { return !__root_path_raw().empty(); }
	- _LIBCPP_INLINE_VISIBILITY bool has_relative_path() const { return !__relative_path().empty(); }
	- _LIBCPP_INLINE_VISIBILITY bool has_parent_path() const { return !__parent_path().empty(); }
	- _LIBCPP_INLINE_VISIBILITY bool has_filename() const { return !__filename().empty(); }
	- _LIBCPP_INLINE_VISIBILITY bool has_stem() const { return !__stem().empty(); }
	- _LIBCPP_INLINE_VISIBILITY bool has_extension() const { return !__extension().empty(); }
	-
	- _LIBCPP_INLINE_VISIBILITY bool is_absolute() const { return has_root_directory(); }
	- _LIBCPP_INLINE_VISIBILITY bool is_relative() const { return !is_absolute(); }
	-
	- // iterators
	- class _LIBCPP_TYPE_VIS iterator;
	- typedef iterator const_iterator;
	-
	- iterator begin() const;
	- iterator end() const;
	-
	-private:
	- inline _LIBCPP_INLINE_VISIBILITY
	- path& __assign_view(__string_view const& __s) noexcept { __pn_ = string_type(__s); return *this; }
	- string_type __pn_;
	-};
	-
	-inline _LIBCPP_ALWAYS_INLINE
	-void swap(path& __lhs, path& __rhs) _NOEXCEPT {
	- __lhs.swap(__rhs);
	-}
	-
	-_LIBCPP_FUNC_VIS
	-size_t hash_value(const path& __p) _NOEXCEPT;
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool operator==(const path& __lhs, const path& __rhs) _NOEXCEPT
	-{ return __lhs.compare(__rhs) == 0; }
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool operator!=(const path& __lhs, const path& __rhs) _NOEXCEPT
	-{ return __lhs.compare(__rhs) != 0; }
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool operator<(const path& __lhs, const path& __rhs) _NOEXCEPT
	-{ return __lhs.compare(__rhs) < 0; }
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool operator<=(const path& __lhs, const path& __rhs) _NOEXCEPT
	-{ return __lhs.compare(__rhs) <= 0; }
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool operator>(const path& __lhs, const path& __rhs) _NOEXCEPT
	-{ return __lhs.compare(__rhs) > 0; }
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool operator>=(const path& __lhs, const path& __rhs) _NOEXCEPT
	-{ return __lhs.compare(__rhs) >= 0; }
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-path operator/(const path& __lhs, const path& __rhs) {
	- return path(__lhs) /= __rhs;
	-}
	-
	-template <class _CharT, class _Traits>
	-_LIBCPP_INLINE_VISIBILITY
	-typename enable_if<is_same<_CharT, char>::value &&
	- is_same<_Traits, char_traits<char>>::value,
	- basic_ostream<_CharT, _Traits>&
	->::type
	-operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
	- __os << std::__quoted(__p.native());
	- return __os;
	-}
	-
	-template <class _CharT, class _Traits>
	-_LIBCPP_INLINE_VISIBILITY
	-typename enable_if<!is_same<_CharT, char>::value \|\|
	- !is_same<_Traits, char_traits<char>>::value,
	- basic_ostream<_CharT, _Traits>&
	->::type
	-operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
	- __os << std::__quoted(__p.string<_CharT, _Traits>());
	- return __os;
	-}
	-
	-template <class _CharT, class _Traits>
	-_LIBCPP_INLINE_VISIBILITY
	-basic_istream<_CharT, _Traits>&
	-operator>>(basic_istream<_CharT, _Traits>& __is, path& __p)
	-{
	- basic_string<_CharT, _Traits> __tmp;
	- __is >> __quoted(__tmp);
	- __p = __tmp;
	- return __is;
	-}
	-
	-template <class _Source>
	-_LIBCPP_INLINE_VISIBILITY
	-typename enable_if<__is_pathable<_Source>::value, path>::type
	-u8path(const _Source& __s){
	- static_assert(is_same<typename __is_pathable<_Source>::__char_type, char>::value,
	- "u8path(Source const&) requires Source have a character type of type 'char'");
	- return path(__s);
	-}
	-
	-template <class _InputIt>
	-_LIBCPP_INLINE_VISIBILITY
	-typename enable_if<__is_pathable<_InputIt>::value, path>::type
	-u8path(_InputIt __f, _InputIt __l) {
	- static_assert(is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
	- "u8path(Iter, Iter) requires Iter have a value_type of type 'char'");
	- return path(__f, __l);
	-}
	-
	-class _LIBCPP_TYPE_VIS path::iterator
	-{
	-public:
	- typedef bidirectional_iterator_tag iterator_category;
	-
	- typedef path value_type;
	- typedef std::ptrdiff_t difference_type;
	- typedef const path* pointer;
	- typedef const path& reference;
	-
	- typedef void __stashing_iterator_tag; // See reverse_iterator and __is_stashing_iterator
	-public:
	- _LIBCPP_INLINE_VISIBILITY
	- iterator() : __stashed_elem_(), __path_ptr_(nullptr),
	- __entry_(), __state_(__singular) {}
	-
	- iterator(const iterator&) = default;
	- ~iterator() = default;
	-
	- iterator& operator=(const iterator&) = default;
	-
	- _LIBCPP_INLINE_VISIBILITY
	- reference operator*() const {
	- return __stashed_elem_;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- pointer operator->() const {
	- return &__stashed_elem_;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- iterator& operator++() {
	- _LIBCPP_ASSERT(__state_ != __singular,
	- "attempting to increment a singular iterator");
	- _LIBCPP_ASSERT(__state_ != __at_end,
	- "attempting to increment the end iterator");
	- return __increment();
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- iterator operator++(int) {
	- iterator __it(*this);
	- this->operator++();
	- return __it;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- iterator& operator--() {
	- _LIBCPP_ASSERT(__state_ != __singular,
	- "attempting to decrement a singular iterator");
	- _LIBCPP_ASSERT(__entry_.data() != __path_ptr_->native().data(),
	- "attempting to decrement the begin iterator");
	- return __decrement();
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- iterator operator--(int) {
	- iterator __it(*this);
	- this->operator--();
	- return __it;
	- }
	-
	-private:
	- friend class path;
	-
	- static constexpr unsigned char __singular = 0;
	- static constexpr unsigned char __at_end = 6;
	-
	- inline _LIBCPP_INLINE_VISIBILITY
	- friend bool operator==(const iterator&, const iterator&);
	-
	- iterator& __increment();
	- iterator& __decrement();
	-
	- path __stashed_elem_;
	- const path* __path_ptr_;
	- path::__string_view __entry_;
	- unsigned char __state_;
	-};
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool operator==(const path::iterator& __lhs, const path::iterator& __rhs) {
	- return __lhs.__path_ptr_ == __rhs.__path_ptr_ &&
	- __lhs.__entry_.data() == __rhs.__entry_.data();
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool operator!=(const path::iterator& __lhs, const path::iterator& __rhs) {
	- return !(__lhs == __rhs);
	-}
	-
	-class _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error
	-{
	-public:
	- _LIBCPP_INLINE_VISIBILITY
	- filesystem_error(const string& __what, error_code __ec)
	- : system_error(__ec, __what),
	- __paths_(make_shared<_Storage>(path(), path()))
	- {}
	-
	- _LIBCPP_INLINE_VISIBILITY
	- filesystem_error(const string& __what, const path& __p1, error_code __ec)
	- : system_error(__ec, __what),
	- __paths_(make_shared<_Storage>(__p1, path()))
	- {}
	-
	- _LIBCPP_INLINE_VISIBILITY
	- filesystem_error(const string& __what, const path& __p1, const path& __p2,
	- error_code __ec)
	- : system_error(__ec, __what),
	- __paths_(make_shared<_Storage>(__p1, __p2))
	- {}
	-
	- _LIBCPP_INLINE_VISIBILITY
	- const path& path1() const _NOEXCEPT {
	- return __paths_->first;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- const path& path2() const _NOEXCEPT {
	- return __paths_->second;
	- }
	-
	- ~filesystem_error() override; // key function
	-
	- // TODO(ericwf): Create a custom error message.
	- //const char* what() const _NOEXCEPT;
	-
	-private:
	- typedef pair<path, path> _Storage;
	- shared_ptr<_Storage> __paths_;
	-};
	-
	-template <class... _Args>
	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	-void __throw_filesystem_error(_Args && ...__args)
	-{
	- throw filesystem_error(std::forward<_Args>(__args)...);
	-}
	-#else
	-void __throw_filesystem_error(_Args&&...)
	-{
	- _VSTD::abort();
	-}
	-#endif
	-
	-
	-// operational functions
	-
	-_LIBCPP_FUNC_VIS
	-path __canonical(const path&, const path&, error_code *__ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-void __copy(const path& __from, const path& __to, copy_options __opt,
	- error_code *__ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-bool __copy_file(const path& __from, const path& __to, copy_options __opt,
	- error_code *__ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-void __copy_symlink(const path& __existing_symlink, const path& __new_symlink,
	- error_code *__ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-bool __create_directories(const path& p, error_code *ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-bool __create_directory(const path& p, error_code *ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-bool __create_directory(const path& p, const path & attributes,
	- error_code *ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-void __create_directory_symlink(const path& __to, const path& __new_symlink,
	- error_code *__ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-void __create_hard_link(const path& __to, const path& __new_hard_link,
	- error_code *__ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-void __create_symlink(const path& __to, const path& __new_symlink,
	- error_code *__ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-path __current_path(error_code *__ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-void __current_path(const path&, error_code *__ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-bool __equivalent(const path&, const path&, error_code *__ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-uintmax_t __file_size(const path&, error_code *__ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-uintmax_t __hard_link_count(const path&, error_code *__ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-bool __fs_is_empty(const path& p, error_code *ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-file_time_type __last_write_time(const path& p, error_code *ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-void __last_write_time(const path& p, file_time_type new_time,
	- error_code *ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-void __permissions(const path& p, perms prms, error_code *ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-path __read_symlink(const path& p, error_code *ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-bool __remove(const path& p, error_code *ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-uintmax_t __remove_all(const path& p, error_code *ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-void __rename(const path& from, const path& to, error_code *ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-void __resize_file(const path& p, uintmax_t size, error_code *ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-space_info __space(const path&, error_code *__ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-file_status __status(const path&, error_code *__ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-file_status __symlink_status(const path&, error_code *__ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-path __system_complete(const path&, error_code *__ec=nullptr);
	-_LIBCPP_FUNC_VIS
	-path __temp_directory_path(error_code *__ec=nullptr);
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-path current_path() {
	- return __current_path();
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-path current_path(error_code& __ec) {
	- return __current_path(&__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void current_path(const path& __p) {
	- __current_path(__p);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void current_path(const path& __p, error_code& __ec) _NOEXCEPT {
	- __current_path(__p, &__ec);
	-}
	-
	-_LIBCPP_FUNC_VIS
	-path absolute(const path&, const path& __p2 = current_path());
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-path canonical(const path& __p, const path& __base = current_path()) {
	- return __canonical(__p, __base);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-path canonical(const path& __p, error_code& __ec) {
	- path __base = __current_path(&__ec);
	- if (__ec) return {};
	- return __canonical(__p, __base, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-path canonical(const path& __p, const path& __base, error_code& __ec) {
	- return __canonical(__p, __base, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void copy(const path& __from, const path& __to) {
	- __copy(__from, __to, copy_options::none);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void copy(const path& __from, const path& __to, error_code& __ec) {
	- __copy(__from, __to, copy_options::none, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void copy(const path& __from, const path& __to, copy_options __opt) {
	- __copy(__from, __to, __opt);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void copy(const path& __from, const path& __to,
	- copy_options __opt, error_code& __ec) {
	- __copy(__from, __to, __opt, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool copy_file(const path& __from, const path& __to) {
	- return __copy_file(__from, __to, copy_options::none);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool copy_file(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT {
	- return __copy_file(__from, __to, copy_options::none, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool copy_file(const path& __from, const path& __to, copy_options __opt) {
	- return __copy_file(__from, __to, __opt);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool copy_file(const path& __from, const path& __to,
	- copy_options __opt, error_code& __ec) _NOEXCEPT {
	- return __copy_file(__from, __to, __opt, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void copy_symlink(const path& __existing, const path& __new) {
	- __copy_symlink(__existing, __new);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void copy_symlink(const path& __ext, const path& __new, error_code& __ec) _NOEXCEPT {
	- __copy_symlink(__ext, __new, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool create_directories(const path& __p) {
	- return __create_directories(__p);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool create_directories(const path& __p, error_code& __ec) _NOEXCEPT {
	- return __create_directories(__p, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool create_directory(const path& __p) {
	- return __create_directory(__p);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool create_directory(const path& __p, error_code& __ec) _NOEXCEPT {
	- return __create_directory(__p, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool create_directory(const path& __p, const path& __attrs) {
	- return __create_directory(__p, __attrs);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool create_directory(const path& __p, const path& __attrs, error_code& __ec) _NOEXCEPT {
	- return __create_directory(__p, __attrs, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void create_directory_symlink(const path& __to, const path& __new) {
	- __create_directory_symlink(__to, __new);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void create_directory_symlink(const path& __to, const path& __new,
	- error_code& __ec) _NOEXCEPT {
	- __create_directory_symlink(__to, __new, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void create_hard_link(const path& __to, const path& __new) {
	- __create_hard_link(__to, __new);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void create_hard_link(const path& __to, const path& __new, error_code& __ec) _NOEXCEPT {
	- __create_hard_link(__to, __new, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void create_symlink(const path& __to, const path& __new) {
	- __create_symlink(__to, __new);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void create_symlink(const path& __to, const path& __new, error_code& __ec) _NOEXCEPT {
	- return __create_symlink(__to, __new, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool status_known(file_status __s) _NOEXCEPT {
	- return __s.type() != file_type::none;
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool exists(file_status __s) _NOEXCEPT {
	- return status_known(__s) && __s.type() != file_type::not_found;
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool exists(const path& __p) {
	- return exists(__status(__p));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool exists(const path& __p, error_code& __ec) _NOEXCEPT {
	- auto __s = __status(__p, &__ec);
	- if (status_known(__s)) __ec.clear();
	- return exists(__s);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool equivalent(const path& __p1, const path& __p2) {
	- return __equivalent(__p1, __p2);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool equivalent(const path& __p1, const path& __p2, error_code& __ec) _NOEXCEPT {
	- return __equivalent(__p1, __p2, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-uintmax_t file_size(const path& __p) {
	- return __file_size(__p);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-uintmax_t file_size(const path& __p, error_code& __ec) _NOEXCEPT {
	- return __file_size(__p, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-uintmax_t hard_link_count(const path& __p) {
	- return __hard_link_count(__p);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-uintmax_t hard_link_count(const path& __p, error_code& __ec) _NOEXCEPT {
	- return __hard_link_count(__p, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_block_file(file_status __s) _NOEXCEPT {
	- return __s.type() == file_type::block;
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_block_file(const path& __p) {
	- return is_block_file(__status(__p));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_block_file(const path& __p, error_code& __ec) _NOEXCEPT {
	- return is_block_file(__status(__p, &__ec));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_character_file(file_status __s) _NOEXCEPT {
	- return __s.type() == file_type::character;
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_character_file(const path& __p) {
	- return is_character_file(__status(__p));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_character_file(const path& __p, error_code& __ec) _NOEXCEPT {
	- return is_character_file(__status(__p, &__ec));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_directory(file_status __s) _NOEXCEPT {
	- return __s.type() == file_type::directory;
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_directory(const path& __p) {
	- return is_directory(__status(__p));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_directory(const path& __p, error_code& __ec) _NOEXCEPT {
	- return is_directory(__status(__p, &__ec));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_empty(const path& __p) {
	- return __fs_is_empty(__p);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_empty(const path& __p, error_code& __ec) {
	- return __fs_is_empty(__p, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_fifo(file_status __s) _NOEXCEPT {
	- return __s.type() == file_type::fifo;
	-}
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_fifo(const path& __p) {
	- return is_fifo(__status(__p));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_fifo(const path& __p, error_code& __ec) _NOEXCEPT {
	- return is_fifo(__status(__p, &__ec));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_regular_file(file_status __s) _NOEXCEPT {
	- return __s.type() == file_type::regular;
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_regular_file(const path& __p) {
	- return is_regular_file(__status(__p));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_regular_file(const path& __p, error_code& __ec) _NOEXCEPT {
	- return is_regular_file(__status(__p, &__ec));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_socket(file_status __s) _NOEXCEPT {
	- return __s.type() == file_type::socket;
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_socket(const path& __p) {
	- return is_socket(__status(__p));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_socket(const path& __p, error_code& __ec) _NOEXCEPT {
	- return is_socket(__status(__p, &__ec));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_symlink(file_status __s) _NOEXCEPT {
	- return __s.type() == file_type::symlink;
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_symlink(const path& __p) {
	- return is_symlink(__symlink_status(__p));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_symlink(const path& __p, error_code& __ec) _NOEXCEPT {
	- return is_symlink(__symlink_status(__p, &__ec));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_other(file_status __s) _NOEXCEPT {
	- return exists(__s)
	- && !is_regular_file(__s) && !is_directory(__s) && !is_symlink(__s);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_other(const path& __p) {
	- return is_other(__status(__p));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool is_other(const path& __p, error_code& __ec) _NOEXCEPT {
	- return is_other(__status(__p, &__ec));
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-file_time_type last_write_time(const path& __p) {
	- return __last_write_time(__p);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-file_time_type last_write_time(const path& __p, error_code& __ec) _NOEXCEPT {
	- return __last_write_time(__p, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void last_write_time(const path& __p, file_time_type __t) {
	- __last_write_time(__p, __t);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void last_write_time(const path& __p, file_time_type __t, error_code& __ec) _NOEXCEPT {
	- __last_write_time(__p, __t, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void permissions(const path& __p, perms __prms) {
	- __permissions(__p, __prms);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void permissions(const path& __p, perms __prms, error_code& __ec) {
	- __permissions(__p, __prms, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-path read_symlink(const path& __p) {
	- return __read_symlink(__p);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-path read_symlink(const path& __p, error_code& __ec) {
	- return __read_symlink(__p, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool remove(const path& __p) {
	- return __remove(__p);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool remove(const path& __p, error_code& __ec) _NOEXCEPT {
	- return __remove(__p, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-uintmax_t remove_all(const path& __p) {
	- return __remove_all(__p);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-uintmax_t remove_all(const path& __p, error_code& __ec) _NOEXCEPT {
	- return __remove_all(__p, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void rename(const path& __from, const path& __to) {
	- return __rename(__from, __to);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void rename(const path& __from, const path& __to, error_code& __ec) _NOEXCEPT {
	- return __rename(__from, __to, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void resize_file(const path& __p, uintmax_t __ns) {
	- return __resize_file(__p, __ns);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-void resize_file(const path& __p, uintmax_t __ns, error_code& __ec) _NOEXCEPT {
	- return __resize_file(__p, __ns, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-space_info space(const path& __p) {
	- return __space(__p);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-space_info space(const path& __p, error_code& __ec) _NOEXCEPT {
	- return __space(__p, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-file_status status(const path& __p) {
	- return __status(__p);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-file_status status(const path& __p, error_code& __ec) _NOEXCEPT {
	- return __status(__p, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-file_status symlink_status(const path& __p) {
	- return __symlink_status(__p);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-file_status symlink_status(const path& __p, error_code& __ec) _NOEXCEPT {
	- return __symlink_status(__p, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-path system_complete(const path& __p) {
	- return __system_complete(__p);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-path system_complete(const path& __p, error_code& __ec) {
	- return __system_complete(__p, &__ec);
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-path temp_directory_path() {
	- return __temp_directory_path();
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-path temp_directory_path(error_code& __ec) {
	- return __temp_directory_path(&__ec);
	-}
	-
	-
	-class directory_entry
	-{
	- typedef _VSTD_FS::path _Path;
	-
	-public:
	- // constructors and destructors
	- directory_entry() _NOEXCEPT = default;
	- directory_entry(directory_entry const&) = default;
	- directory_entry(directory_entry&&) _NOEXCEPT = default;
	-
	- _LIBCPP_INLINE_VISIBILITY
	- explicit directory_entry(_Path const& __p) : __p_(__p) {}
	-
	- ~directory_entry() {}
	-
	- directory_entry& operator=(directory_entry const&) = default;
	- directory_entry& operator=(directory_entry&&) _NOEXCEPT = default;
	-
	- _LIBCPP_INLINE_VISIBILITY
	- void assign(_Path const& __p) {
	- __p_ = __p;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- void replace_filename(_Path const& __p) {
	- __p_ = __p_.parent_path() / __p;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- _Path const& path() const _NOEXCEPT {
	- return __p_;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- operator const _Path&() const _NOEXCEPT {
	- return __p_;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- file_status status() const {
	- return _VSTD_FS::status(__p_);
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- file_status status(error_code& __ec) const _NOEXCEPT {
	- return _VSTD_FS::status(__p_, __ec);
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- file_status symlink_status() const {
	- return _VSTD_FS::symlink_status(__p_);
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- file_status symlink_status(error_code& __ec) const _NOEXCEPT {
	- return _VSTD_FS::symlink_status(__p_, __ec);
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- bool operator< (directory_entry const& __rhs) const _NOEXCEPT {
	- return __p_ < __rhs.__p_;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- bool operator==(directory_entry const& __rhs) const _NOEXCEPT {
	- return __p_ == __rhs.__p_;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- bool operator!=(directory_entry const& __rhs) const _NOEXCEPT {
	- return __p_ != __rhs.__p_;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- bool operator<=(directory_entry const& __rhs) const _NOEXCEPT {
	- return __p_ <= __rhs.__p_;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- bool operator> (directory_entry const& __rhs) const _NOEXCEPT {
	- return __p_ > __rhs.__p_;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- bool operator>=(directory_entry const& __rhs) const _NOEXCEPT {
	- return __p_ >= __rhs.__p_;
	- }
	-private:
	- _Path __p_;
	-};
	-
	-
	-class directory_iterator;
	-class recursive_directory_iterator;
	-class __dir_stream;
	-
	-class __dir_element_proxy {
	-public:
	-
	- inline _LIBCPP_INLINE_VISIBILITY
	- directory_entry operator*() { return _VSTD::move(__elem_); }
	-
	-private:
	- friend class directory_iterator;
	- friend class recursive_directory_iterator;
	- explicit __dir_element_proxy(directory_entry const& __e) : __elem_(__e) {}
	- __dir_element_proxy(__dir_element_proxy&& __o) : __elem_(_VSTD::move(__o.__elem_)) {}
	- directory_entry __elem_;
	-};
	-
	-class directory_iterator
	-{
	-public:
	- typedef directory_entry value_type;
	- typedef ptrdiff_t difference_type;
	- typedef value_type const* pointer;
	- typedef value_type const& reference;
	- typedef input_iterator_tag iterator_category;
	-
	-public:
	- //ctor & dtor
	- directory_iterator() _NOEXCEPT
	- { }
	-
	- explicit directory_iterator(const path& __p)
	- : directory_iterator(__p, nullptr)
	- { }
	-
	- directory_iterator(const path& __p, directory_options __opts)
	- : directory_iterator(__p, nullptr, __opts)
	- { }
	-
	- directory_iterator(const path& __p, error_code& __ec)
	- : directory_iterator(__p, &__ec)
	- { }
	-
	- directory_iterator(const path& __p, directory_options __opts,
	- error_code& __ec)
	- : directory_iterator(__p, &__ec, __opts)
	- { }
	-
	- directory_iterator(const directory_iterator&) = default;
	- directory_iterator(directory_iterator&&) = default;
	- directory_iterator& operator=(const directory_iterator&) = default;
	-
	- directory_iterator& operator=(directory_iterator&& __o) _NOEXCEPT {
	- // non-default implementation provided to support self-move assign.
	- if (this != &__o) {
	- __imp_ = _VSTD::move(__o.__imp_);
	- }
	- return *this;
	- }
	-
	- ~directory_iterator() = default;
	-
	- const directory_entry& operator*() const {
	- _LIBCPP_ASSERT(__imp_, "The end iterator cannot be dereferenced");
	- return __dereference();
	- }
	-
	- const directory_entry* operator->() const
	- { return &**this; }
	-
	- directory_iterator& operator++()
	- { return __increment(); }
	-
	- __dir_element_proxy operator++(int) {
	- __dir_element_proxy __p(**this);
	- __increment();
	- return __p;
	- }
	-
	- directory_iterator& increment(error_code& __ec)
	- { return __increment(&__ec); }
	-
	-private:
	- inline _LIBCPP_INLINE_VISIBILITY
	- friend bool operator==(const directory_iterator& __lhs,
	- const directory_iterator& __rhs) _NOEXCEPT;
	-
	- // construct the dir_stream
	- _LIBCPP_FUNC_VIS
	- directory_iterator(const path&, error_code *,
	- directory_options = directory_options::none);
	-
	- _LIBCPP_FUNC_VIS
	- directory_iterator& __increment(error_code * __ec = nullptr);
	-
	- _LIBCPP_FUNC_VIS
	- const directory_entry& __dereference() const;
	-
	-private:
	- shared_ptr<__dir_stream> __imp_;
	-};
	-
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool operator==(const directory_iterator& __lhs,
	- const directory_iterator& __rhs) _NOEXCEPT {
	- return __lhs.__imp_ == __rhs.__imp_;
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool operator!=(const directory_iterator& __lhs,
	- const directory_iterator& __rhs) _NOEXCEPT {
	- return !(__lhs == __rhs);
	-}
	-
	-// enable directory_iterator range-based for statements
	-inline _LIBCPP_INLINE_VISIBILITY
	-directory_iterator begin(directory_iterator __iter) _NOEXCEPT {
	- return __iter;
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-directory_iterator end(const directory_iterator&) _NOEXCEPT {
	- return directory_iterator();
	-}
	-
	-class recursive_directory_iterator {
	-public:
	- using value_type = directory_entry;
	- using difference_type = std::ptrdiff_t;
	- using pointer = directory_entry const *;
	- using reference = directory_entry const &;
	- using iterator_category = std::input_iterator_tag;
	-
	-public:
	- // constructors and destructor
	- _LIBCPP_INLINE_VISIBILITY
	- recursive_directory_iterator() _NOEXCEPT
	- : __rec_(false)
	- {}
	-
	- _LIBCPP_INLINE_VISIBILITY
	- explicit recursive_directory_iterator(const path& __p,
	- directory_options __xoptions = directory_options::none)
	- : recursive_directory_iterator(__p, __xoptions, nullptr)
	- { }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- recursive_directory_iterator(const path& __p,
	- directory_options __xoptions, error_code& __ec)
	- : recursive_directory_iterator(__p, __xoptions, &__ec)
	- { }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- recursive_directory_iterator(const path& __p, error_code& __ec)
	- : recursive_directory_iterator(__p, directory_options::none, &__ec)
	- { }
	-
	- recursive_directory_iterator(const recursive_directory_iterator&) = default;
	- recursive_directory_iterator(recursive_directory_iterator&&) = default;
	-
	- recursive_directory_iterator &
	- operator=(const recursive_directory_iterator&) = default;
	-
	- _LIBCPP_INLINE_VISIBILITY
	- recursive_directory_iterator &
	- operator=(recursive_directory_iterator&& __o) noexcept {
	- // non-default implementation provided to support self-move assign.
	- if (this != &__o) {
	- __imp_ = _VSTD::move(__o.__imp_);
	- __rec_ = __o.__rec_;
	- }
	- return *this;
	- }
	-
	- ~recursive_directory_iterator() = default;
	-
	- _LIBCPP_INLINE_VISIBILITY
	- const directory_entry& operator*() const
	- { return __dereference(); }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- const directory_entry* operator->() const
	- { return &__dereference(); }
	-
	- recursive_directory_iterator& operator++()
	- { return __increment(); }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- __dir_element_proxy operator++(int) {
	- __dir_element_proxy __p(**this);
	- __increment();
	- return __p;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- recursive_directory_iterator& increment(error_code& __ec)
	- { return __increment(&__ec); }
	-
	- _LIBCPP_FUNC_VIS directory_options options() const;
	- _LIBCPP_FUNC_VIS int depth() const;
	-
	- _LIBCPP_INLINE_VISIBILITY
	- void pop() { __pop(); }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- void pop(error_code& __ec)
	- { __pop(&__ec); }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- bool recursion_pending() const
	- { return __rec_; }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- void disable_recursion_pending()
	- { __rec_ = false; }
	-
	-private:
	- recursive_directory_iterator(const path& __p, directory_options __opt,
	- error_code *__ec);
	-
	- _LIBCPP_FUNC_VIS
	- const directory_entry& __dereference() const;
	-
	- _LIBCPP_FUNC_VIS
	- bool __try_recursion(error_code* __ec);
	-
	- _LIBCPP_FUNC_VIS
	- void __advance(error_code* __ec=nullptr);
	-
	- _LIBCPP_FUNC_VIS
	- recursive_directory_iterator& __increment(error_code *__ec=nullptr);
	-
	- _LIBCPP_FUNC_VIS
	- void __pop(error_code* __ec=nullptr);
	-
	- inline _LIBCPP_INLINE_VISIBILITY
	- friend bool operator==(const recursive_directory_iterator&,
	- const recursive_directory_iterator&) _NOEXCEPT;
	-
	- struct __shared_imp;
	- shared_ptr<__shared_imp> __imp_;
	- bool __rec_;
	-}; // class recursive_directory_iterator
	-
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-bool operator==(const recursive_directory_iterator& __lhs,
	- const recursive_directory_iterator& __rhs) _NOEXCEPT
	-{
	- return __lhs.__imp_ == __rhs.__imp_;
	-}
	-
	-_LIBCPP_INLINE_VISIBILITY
	-inline bool operator!=(const recursive_directory_iterator& __lhs,
	- const recursive_directory_iterator& __rhs) _NOEXCEPT
	-{
	- return !(__lhs == __rhs);
	-}
	-// enable recursive_directory_iterator range-based for statements
	-inline _LIBCPP_INLINE_VISIBILITY
	-recursive_directory_iterator begin(recursive_directory_iterator __iter) _NOEXCEPT {
	- return __iter;
	-}
	-
	-inline _LIBCPP_INLINE_VISIBILITY
	-recursive_directory_iterator end(const recursive_directory_iterator&) _NOEXCEPT {
	- return recursive_directory_iterator();
	-}
	-
	-_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM
	+_LIBCPP_POP_MACROS

	#endif // _LIBCPP_EXPERIMENTAL_FILESYSTEM
	Index: projects/clang700-import/contrib/libc++/include/experimental/functional
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/functional (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/functional (revision 337135)
	@@ -1,462 +1,462 @@
	// -- C++ --
	//===-------------------------- functional --------------------------------===//
	//
	// 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_EXPERIMENTAL_FUNCTIONAL
	#define _LIBCPP_EXPERIMENTAL_FUNCTIONAL

	/*
	experimental/functional synopsis

	#include <algorithm>

	namespace std {
	namespace experimental {
	inline namespace fundamentals_v1 {

	// See C++14 20.9.9, Function object binders
	template <class T> constexpr bool is_bind_expression_v
	= is_bind_expression<T>::value;
	template <class T> constexpr int is_placeholder_v
	= is_placeholder<T>::value;

	// 4.2, Class template function
	template<class> class function; // undefined
	template<class R, class... ArgTypes> class function<R(ArgTypes...)>;

	template<class R, class... ArgTypes>
	void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&);

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

	// 4.3, Searchers
	template<class ForwardIterator, class BinaryPredicate = equal_to<>>
	class default_searcher;

	template<class RandomAccessIterator,
	class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
	class BinaryPredicate = equal_to<>>
	class boyer_moore_searcher;

	template<class RandomAccessIterator,
	class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
	class BinaryPredicate = equal_to<>>
	class boyer_moore_horspool_searcher;

	template<class ForwardIterator, class BinaryPredicate = equal_to<>>
	default_searcher<ForwardIterator, BinaryPredicate>
	make_default_searcher(ForwardIterator pat_first, ForwardIterator pat_last,
	BinaryPredicate pred = BinaryPredicate());

	template<class RandomAccessIterator,
	class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
	class BinaryPredicate = equal_to<>>
	boyer_moore_searcher<RandomAccessIterator, Hash, BinaryPredicate>
	make_boyer_moore_searcher(
	RandomAccessIterator pat_first, RandomAccessIterator pat_last,
	Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());

	template<class RandomAccessIterator,
	class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
	class BinaryPredicate = equal_to<>>
	boyer_moore_horspool_searcher<RandomAccessIterator, Hash, BinaryPredicate>
	make_boyer_moore_horspool_searcher(
	RandomAccessIterator pat_first, RandomAccessIterator pat_last,
	Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());

	} // namespace fundamentals_v1
	} // namespace experimental

	template<class R, class... ArgTypes, class Alloc>
	struct uses_allocator<experimental::function<R(ArgTypes...)>, Alloc>;

	} // namespace std

	*/

	#include <experimental/__config>
	#include <functional>
	#include <algorithm>
	#include <type_traits>
	#include <vector>
	#include <array>
	#include <unordered_map>

	#include <__debug>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_LFTS

	#if _LIBCPP_STD_VER > 11
	// default searcher
	template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
	_LIBCPP_TYPE_VIS
	class default_searcher {
	public:
	_LIBCPP_INLINE_VISIBILITY
	default_searcher(_ForwardIterator __f, _ForwardIterator __l,
	_BinaryPredicate __p = _BinaryPredicate())
	: __first_(__f), __last_(__l), __pred_(__p) {}

	template <typename _ForwardIterator2>
	_LIBCPP_INLINE_VISIBILITY
	pair<_ForwardIterator2, _ForwardIterator2>
	operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const
	{
	return _VSTD::__search(__f, __l, __first_, __last_, __pred_,
	typename _VSTD::iterator_traits<_ForwardIterator>::iterator_category(),
	typename _VSTD::iterator_traits<_ForwardIterator2>::iterator_category());
	}

	private:
	_ForwardIterator __first_;
	_ForwardIterator __last_;
	_BinaryPredicate __pred_;
	};

	template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
	_LIBCPP_INLINE_VISIBILITY
	default_searcher<_ForwardIterator, _BinaryPredicate>
	make_default_searcher( _ForwardIterator __f, _ForwardIterator __l, _BinaryPredicate __p = _BinaryPredicate ())
	{
	return default_searcher<_ForwardIterator, _BinaryPredicate>(__f, __l, __p);
	}

	template<class _Key, class _Value, class _Hash, class _BinaryPredicate, bool /useArray/> class _BMSkipTable;

	// General case for BM data searching; use a map
	template<class _Key, typename _Value, class _Hash, class _BinaryPredicate>
	class _BMSkipTable<_Key, _Value, _Hash, _BinaryPredicate, false> {
	public: // TODO private:
	typedef _Value value_type;
	typedef _Key key_type;

	const _Value __default_value_;
	std::unordered_map<_Key, _Value, _Hash, _BinaryPredicate> __table;

	public:
	_LIBCPP_INLINE_VISIBILITY
	_BMSkipTable(std::size_t __sz, _Value __default, _Hash __hf, _BinaryPredicate __pred)
	: __default_value_(__default), __table(__sz, __hf, __pred) {}

	_LIBCPP_INLINE_VISIBILITY
	void insert(const key_type &__key, value_type __val)
	{
	__table [__key] = __val; // Would skip_.insert (val) be better here?
	}

	_LIBCPP_INLINE_VISIBILITY
	value_type operator [](const key_type & __key) const
	{
	auto __it = __table.find (__key);
	return __it == __table.end() ? __default_value_ : __it->second;
	}
	};


	// Special case small numeric values; use an array
	template<class _Key, typename _Value, class _Hash, class _BinaryPredicate>
	class _BMSkipTable<_Key, _Value, _Hash, _BinaryPredicate, true> {
	private:
	typedef _Value value_type;
	typedef _Key key_type;

	typedef typename std::make_unsigned<key_type>::type unsigned_key_type;
	typedef std::array<value_type, _VSTD::numeric_limits<unsigned_key_type>::max()> skip_map;
	skip_map __table;

	public:
	_LIBCPP_INLINE_VISIBILITY
	_BMSkipTable(std::size_t /__sz/, _Value __default, _Hash /__hf/, _BinaryPredicate /__pred/)
	{
	std::fill_n(__table.begin(), __table.size(), __default);
	}

	_LIBCPP_INLINE_VISIBILITY
	void insert(key_type __key, value_type __val)
	{
	__table[static_cast<unsigned_key_type>(__key)] = __val;
	}

	_LIBCPP_INLINE_VISIBILITY
	value_type operator [](key_type __key) const
	{
	return __table[static_cast<unsigned_key_type>(__key)];
	}
	};


	template <class _RandomAccessIterator1,
	class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>,
	class _BinaryPredicate = equal_to<>>
	_LIBCPP_TYPE_VIS
	class boyer_moore_searcher {
	private:
	typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type difference_type;
	typedef typename std::iterator_traits<_RandomAccessIterator1>::value_type value_type;
	typedef _BMSkipTable<value_type, difference_type, _Hash, _BinaryPredicate,
	_VSTD::is_integral<value_type>::value && // what about enums?
	sizeof(value_type) == 1 &&
	is_same<_Hash, hash<value_type>>::value &&
	is_same<_BinaryPredicate, equal_to<>>::value
	> skip_table_type;

	public:
	boyer_moore_searcher(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l,
	_Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate())
	: __first_(__f), __last_(__l), __pred_(__pred),
	__pattern_length_(_VSTD::distance(__first_, __last_)),
	__skip_{make_shared<skip_table_type>(__pattern_length_, -1, __hf, __pred_)},
	__suffix_{make_shared<vector<difference_type>>(__pattern_length_ + 1)}
	{
	// build the skip table
	for ( difference_type __i = 0; __f != __l; ++__f, (void) ++__i )
	__skip_->insert(*__f, __i);

	this->__build_suffix_table ( __first_, __last_, __pred_ );
	}

	template <typename _RandomAccessIterator2>
	pair<_RandomAccessIterator2, _RandomAccessIterator2>
	operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const
	{
	static_assert ( std::is_same<
	- typename std::decay<typename std::iterator_traits<_RandomAccessIterator1>::value_type>::type,
	- typename std::decay<typename std::iterator_traits<_RandomAccessIterator2>::value_type>::type
	+ typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator1>::value_type>::type,
	+ typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator2>::value_type>::type
	>::value,
	"Corpus and Pattern iterators must point to the same type" );

	if (__f == __l ) return make_pair(__l, __l); // empty corpus
	if (__first_ == __last_) return make_pair(__f, __f); // empty pattern

	// If the pattern is larger than the corpus, we can't find it!
	if ( __pattern_length_ > _VSTD::distance (__f, __l))
	return make_pair(__l, __l);

	// Do the search
	return this->__search(__f, __l);
	}

	public: // TODO private:
	_RandomAccessIterator1 __first_;
	_RandomAccessIterator1 __last_;
	_BinaryPredicate __pred_;
	difference_type __pattern_length_;
	shared_ptr<skip_table_type> __skip_;
	shared_ptr<vector<difference_type>> __suffix_;

	template <typename _RandomAccessIterator2>
	pair<_RandomAccessIterator2, _RandomAccessIterator2>
	__search(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const
	{
	_RandomAccessIterator2 __cur = __f;
	const _RandomAccessIterator2 __last = __l - __pattern_length_;
	const skip_table_type & __skip = *__skip_.get();
	const vector<difference_type> & __suffix = *__suffix_.get();

	while (__cur <= __last)
	{

	// Do we match right where we are?
	difference_type __j = __pattern_length_;
	while (__pred_(__first_ [__j-1], __cur [__j-1])) {
	__j--;
	// We matched - we're done!
	if ( __j == 0 )
	return make_pair(__cur, __cur + __pattern_length_);
	}

	// Since we didn't match, figure out how far to skip forward
	difference_type __k = __skip[__cur [ __j - 1 ]];
	difference_type __m = __j - __k - 1;
	if (__k < __j && __m > __suffix[ __j ])
	__cur += __m;
	else
	__cur += __suffix[ __j ];
	}

	return make_pair(__l, __l); // We didn't find anything
	}


	template<typename _Iterator, typename _Container>
	void __compute_bm_prefix ( _Iterator __f, _Iterator __l, _BinaryPredicate __pred, _Container &__prefix )
	{
	const std::size_t __count = _VSTD::distance(__f, __l);

	__prefix[0] = 0;
	std::size_t __k = 0;
	for ( std::size_t __i = 1; __i < __count; ++__i )
	{
	while ( __k > 0 && !__pred ( __f[__k], __f[__i] ))
	__k = __prefix [ __k - 1 ];

	if ( __pred ( __f[__k], __f[__i] ))
	__k++;
	__prefix [ __i ] = __k;
	}
	}

	void __build_suffix_table(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l,
	_BinaryPredicate __pred)
	{
	const std::size_t __count = _VSTD::distance(__f, __l);
	vector<difference_type> & __suffix = *__suffix_.get();
	if (__count > 0)
	{
	_VSTD::vector<value_type> __scratch(__count);

	__compute_bm_prefix(__f, __l, __pred, __scratch);
	for ( std::size_t __i = 0; __i <= __count; __i++ )
	__suffix[__i] = __count - __scratch[__count-1];

	typedef _VSTD::reverse_iterator<_RandomAccessIterator1> _RevIter;
	__compute_bm_prefix(_RevIter(__l), _RevIter(__f), __pred, __scratch);

	for ( std::size_t __i = 0; __i < __count; __i++ )
	{
	const std::size_t __j = __count - __scratch[__i];
	const difference_type __k = __i - __scratch[__i] + 1;

	if (__suffix[__j] > __k)
	__suffix[__j] = __k;
	}
	}
	}

	};

	template<class _RandomAccessIterator,
	class _Hash = hash<typename iterator_traits<_RandomAccessIterator>::value_type>,
	class _BinaryPredicate = equal_to<>>
	_LIBCPP_INLINE_VISIBILITY
	boyer_moore_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>
	make_boyer_moore_searcher( _RandomAccessIterator __f, _RandomAccessIterator __l,
	_Hash __hf = _Hash(), _BinaryPredicate __p = _BinaryPredicate ())
	{
	return boyer_moore_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>(__f, __l, __hf, __p);
	}

	// boyer-moore-horspool
	template <class _RandomAccessIterator1,
	class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>,
	class _BinaryPredicate = equal_to<>>
	_LIBCPP_TYPE_VIS
	class boyer_moore_horspool_searcher {
	private:
	typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type difference_type;
	typedef typename std::iterator_traits<_RandomAccessIterator1>::value_type value_type;
	typedef _BMSkipTable<value_type, difference_type, _Hash, _BinaryPredicate,
	_VSTD::is_integral<value_type>::value && // what about enums?
	sizeof(value_type) == 1 &&
	is_same<_Hash, hash<value_type>>::value &&
	is_same<_BinaryPredicate, equal_to<>>::value
	> skip_table_type;

	public:
	boyer_moore_horspool_searcher(_RandomAccessIterator1 __f, _RandomAccessIterator1 __l,
	_Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate())
	: __first_(__f), __last_(__l), __pred_(__pred),
	__pattern_length_(_VSTD::distance(__first_, __last_)),
	__skip_{_VSTD::make_shared<skip_table_type>(__pattern_length_, __pattern_length_, __hf, __pred_)}
	{
	// build the skip table
	if ( __f != __l )
	{
	__l = __l - 1;
	for ( difference_type __i = 0; __f != __l; ++__f, (void) ++__i )
	__skip_->insert(*__f, __pattern_length_ - 1 - __i);
	}
	}

	template <typename _RandomAccessIterator2>
	pair<_RandomAccessIterator2, _RandomAccessIterator2>
	operator ()(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const
	{
	static_assert ( std::is_same<
	- typename std::decay<typename std::iterator_traits<_RandomAccessIterator1>::value_type>::type,
	- typename std::decay<typename std::iterator_traits<_RandomAccessIterator2>::value_type>::type
	+ typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator1>::value_type>::type,
	+ typename std::__uncvref<typename std::iterator_traits<_RandomAccessIterator2>::value_type>::type
	>::value,
	"Corpus and Pattern iterators must point to the same type" );

	if (__f == __l ) return make_pair(__l, __l); // empty corpus
	if (__first_ == __last_) return make_pair(__f, __f); // empty pattern

	// If the pattern is larger than the corpus, we can't find it!
	if ( __pattern_length_ > _VSTD::distance (__f, __l))
	return make_pair(__l, __l);

	// Do the search
	return this->__search(__f, __l);
	}

	private:
	_RandomAccessIterator1 __first_;
	_RandomAccessIterator1 __last_;
	_BinaryPredicate __pred_;
	difference_type __pattern_length_;
	shared_ptr<skip_table_type> __skip_;

	template <typename _RandomAccessIterator2>
	pair<_RandomAccessIterator2, _RandomAccessIterator2>
	__search ( _RandomAccessIterator2 __f, _RandomAccessIterator2 __l ) const {
	_RandomAccessIterator2 __cur = __f;
	const _RandomAccessIterator2 __last = __l - __pattern_length_;
	const skip_table_type & __skip = *__skip_.get();

	while (__cur <= __last)
	{
	// Do we match right where we are?
	difference_type __j = __pattern_length_;
	while (__pred_(__first_[__j-1], __cur[__j-1]))
	{
	__j--;
	// We matched - we're done!
	if ( __j == 0 )
	return make_pair(__cur, __cur + __pattern_length_);
	}
	__cur += __skip[__cur[__pattern_length_-1]];
	}

	return make_pair(__l, __l);
	}
	};

	template<class _RandomAccessIterator,
	class _Hash = hash<typename iterator_traits<_RandomAccessIterator>::value_type>,
	class _BinaryPredicate = equal_to<>>
	_LIBCPP_INLINE_VISIBILITY
	boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>
	make_boyer_moore_horspool_searcher( _RandomAccessIterator __f, _RandomAccessIterator __l,
	_Hash __hf = _Hash(), _BinaryPredicate __p = _BinaryPredicate ())
	{
	return boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>(__f, __l, __hf, __p);
	}

	#endif // _LIBCPP_STD_VER > 11

	_LIBCPP_END_NAMESPACE_LFTS

	_LIBCPP_POP_MACROS

	#endif /* _LIBCPP_EXPERIMENTAL_FUNCTIONAL */
	Index: projects/clang700-import/contrib/libc++/include/experimental/memory_resource
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/memory_resource (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/memory_resource (revision 337135)
	@@ -1,427 +1,427 @@
	// -- C++ --
	//===------------------------ memory_resource -----------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE
	#define _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE

	/**
	experimental/memory_resource synopsis

	// C++1y

	namespace std {
	namespace experimental {
	inline namespace fundamentals_v1 {
	namespace pmr {

	class memory_resource;

	bool operator==(const memory_resource& a,
	const memory_resource& b) noexcept;
	bool operator!=(const memory_resource& a,
	const memory_resource& b) noexcept;

	template <class Tp> class polymorphic_allocator;

	template <class T1, class T2>
	bool operator==(const polymorphic_allocator<T1>& a,
	const polymorphic_allocator<T2>& b) noexcept;
	template <class T1, class T2>
	bool operator!=(const polymorphic_allocator<T1>& a,
	const polymorphic_allocator<T2>& b) noexcept;

	// The name resource_adaptor_imp is for exposition only.
	template <class Allocator> class resource_adaptor_imp;

	template <class Allocator>
	using resource_adaptor = resource_adaptor_imp<
	allocator_traits<Allocator>::rebind_alloc<char>>;

	// Global memory resources
	memory_resource* new_delete_resource() noexcept;
	memory_resource* null_memory_resource() noexcept;

	// The default memory resource
	memory_resource* set_default_resource(memory_resource* r) noexcept;
	memory_resource* get_default_resource() noexcept;

	// Standard memory resources
	struct pool_options;
	class synchronized_pool_resource;
	class unsynchronized_pool_resource;
	class monotonic_buffer_resource;

	} // namespace pmr
	} // namespace fundamentals_v1
	} // namespace experimental
	} // namespace std

	*/

	#include <experimental/__config>
	#include <experimental/__memory>
	#include <limits>
	#include <memory>
	#include <new>
	#include <stdexcept>
	-#include <tuple>
	+#include <__tuple>
	#include <type_traits>
	#include <utility>
	#include <cstddef>
	#include <cstdlib>
	#include <__debug>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>

	_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR

	// Round __s up to next multiple of __a.
	inline _LIBCPP_INLINE_VISIBILITY
	size_t __aligned_allocation_size(size_t __s, size_t __a) _NOEXCEPT
	{
	_LIBCPP_ASSERT(__s + __a > __s, "aligned allocation size overflows");
	return (__s + __a - 1) & ~(__a - 1);
	}

	// 8.5, memory.resource
	-class _LIBCPP_TEMPLATE_VIS memory_resource
	+class _LIBCPP_TYPE_VIS memory_resource
	{
	static const size_t __max_align = alignof(max_align_t);

	// 8.5.2, memory.resource.public
	public:
	virtual ~memory_resource() = default;

	_LIBCPP_INLINE_VISIBILITY
	void* allocate(size_t __bytes, size_t __align = __max_align)
	{ return do_allocate(__bytes, __align); }

	_LIBCPP_INLINE_VISIBILITY
	void deallocate(void * __p, size_t __bytes, size_t __align = __max_align)
	{ do_deallocate(__p, __bytes, __align); }

	_LIBCPP_INLINE_VISIBILITY
	bool is_equal(memory_resource const & __other) const _NOEXCEPT
	{ return do_is_equal(__other); }

	// 8.5.3, memory.resource.priv
	protected:
	virtual void* do_allocate(size_t, size_t) = 0;
	virtual void do_deallocate(void*, size_t, size_t) = 0;
	virtual bool do_is_equal(memory_resource const &) const _NOEXCEPT = 0;
	};

	// 8.5.4, memory.resource.eq
	inline _LIBCPP_INLINE_VISIBILITY
	bool operator==(memory_resource const & __lhs,
	memory_resource const & __rhs) _NOEXCEPT
	{
	return &__lhs == &__rhs \|\| __lhs.is_equal(__rhs);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool operator!=(memory_resource const & __lhs,
	memory_resource const & __rhs) _NOEXCEPT
	{
	return !(__lhs == __rhs);
	}

	_LIBCPP_FUNC_VIS
	memory_resource * new_delete_resource() _NOEXCEPT;

	_LIBCPP_FUNC_VIS
	memory_resource * null_memory_resource() _NOEXCEPT;

	_LIBCPP_FUNC_VIS
	memory_resource * get_default_resource() _NOEXCEPT;

	_LIBCPP_FUNC_VIS
	memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT;

	// 8.6, memory.polymorphic.allocator.class

	// 8.6.1, memory.polymorphic.allocator.overview
	template <class _ValueType>
	class _LIBCPP_TEMPLATE_VIS polymorphic_allocator
	{
	public:
	typedef _ValueType value_type;

	// 8.6.2, memory.polymorphic.allocator.ctor
	_LIBCPP_INLINE_VISIBILITY
	polymorphic_allocator() _NOEXCEPT
	: __res_(_VSTD_LFTS_PMR::get_default_resource())
	{}

	_LIBCPP_INLINE_VISIBILITY
	polymorphic_allocator(memory_resource * __r) _NOEXCEPT
	: __res_(__r)
	{}

	polymorphic_allocator(polymorphic_allocator const &) = default;

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	polymorphic_allocator(polymorphic_allocator<_Tp> const & __other) _NOEXCEPT
	: __res_(__other.resource())
	{}

	polymorphic_allocator &
	operator=(polymorphic_allocator const &) = delete;

	// 8.6.3, memory.polymorphic.allocator.mem
	_LIBCPP_INLINE_VISIBILITY
	_ValueType* allocate(size_t __n) {
	if (__n > __max_size()) {
	__throw_length_error(
	"std::experimental::pmr::polymorphic_allocator<T>::allocate(size_t n)"
	" 'n' exceeds maximum supported size");
	}
	return static_cast<_ValueType*>(
	__res_->allocate(__n * sizeof(_ValueType), alignof(_ValueType))
	);
	}

	_LIBCPP_INLINE_VISIBILITY
	void deallocate(_ValueType * __p, size_t __n) _NOEXCEPT {
	_LIBCPP_ASSERT(__n <= __max_size(),
	"deallocate called for size which exceeds max_size()");
	__res_->deallocate(__p, __n * sizeof(_ValueType), alignof(_ValueType));
	}

	template <class _Tp, class ..._Ts>
	_LIBCPP_INLINE_VISIBILITY
	void construct(_Tp* __p, _Ts &&... __args)
	{
	_VSTD_LFTS::__lfts_user_alloc_construct(
	- __p, resource(), _VSTD::forward<_Ts>(__args)...
	+ __p, *this, _VSTD::forward<_Ts>(__args)...
	);
	}

	template <class _T1, class _T2, class ..._Args1, class ..._Args2>
	_LIBCPP_INLINE_VISIBILITY
	void construct(pair<_T1, _T2>* __p, piecewise_construct_t,
	tuple<_Args1...> __x, tuple<_Args2...> __y)
	{
	::new ((void*)__p) pair<_T1, _T2>(piecewise_construct
	, __transform_tuple(
	typename __lfts_uses_alloc_ctor<
	- _T1, memory_resource*, _Args1...
	+ _T1, polymorphic_allocator&, _Args1...
	>::type()
	, _VSTD::move(__x)
	, typename __make_tuple_indices<sizeof...(_Args1)>::type{}
	)
	, __transform_tuple(
	typename __lfts_uses_alloc_ctor<
	- _T2, memory_resource*, _Args2...
	+ _T2, polymorphic_allocator&, _Args2...
	>::type()
	, _VSTD::move(__y)
	, typename __make_tuple_indices<sizeof...(_Args2)>::type{}
	)
	);
	}

	template <class _T1, class _T2>
	_LIBCPP_INLINE_VISIBILITY
	void construct(pair<_T1, _T2>* __p) {
	construct(__p, piecewise_construct, tuple<>(), tuple<>());
	}

	template <class _T1, class _T2, class _Up, class _Vp>
	_LIBCPP_INLINE_VISIBILITY
	void construct(pair<_T1, _T2> * __p, _Up && __u, _Vp && __v) {
	construct(__p, piecewise_construct
	, _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__u))
	, _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__v)));
	}

	template <class _T1, class _T2, class _U1, class _U2>
	_LIBCPP_INLINE_VISIBILITY
	void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> const & __pr) {
	construct(__p, piecewise_construct
	, _VSTD::forward_as_tuple(__pr.first)
	, _VSTD::forward_as_tuple(__pr.second));
	}

	template <class _T1, class _T2, class _U1, class _U2>
	_LIBCPP_INLINE_VISIBILITY
	void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> && __pr){
	construct(__p, piecewise_construct
	, _VSTD::forward_as_tuple(_VSTD::forward<_U1>(__pr.first))
	, _VSTD::forward_as_tuple(_VSTD::forward<_U2>(__pr.second)));
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	void destroy(_Tp * __p) _NOEXCEPT
	{ __p->~_Tp(); }

	_LIBCPP_INLINE_VISIBILITY
	polymorphic_allocator
	select_on_container_copy_construction() const _NOEXCEPT
	{ return polymorphic_allocator(); }

	_LIBCPP_INLINE_VISIBILITY
	memory_resource * resource() const _NOEXCEPT
	{ return __res_; }

	private:
	template <class ..._Args, size_t ..._Idx>
	_LIBCPP_INLINE_VISIBILITY
	tuple<_Args&&...>
	__transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t,
	__tuple_indices<_Idx...>) const
	{
	return _VSTD::forward_as_tuple(_VSTD::get<_Idx>(_VSTD::move(__t))...);
	}

	template <class ..._Args, size_t ..._Idx>
	_LIBCPP_INLINE_VISIBILITY
	- tuple<allocator_arg_t const&, memory_resource*, _Args&&...>
	+ tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>
	__transform_tuple(integral_constant<int, 1>, tuple<_Args...> && __t,
	- __tuple_indices<_Idx...>) const
	+ __tuple_indices<_Idx...>)
	{
	- using _Tup = tuple<allocator_arg_t const&, memory_resource*, _Args&&...>;
	- return _Tup(allocator_arg, resource(),
	+ using _Tup = tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>;
	+ return _Tup(allocator_arg, *this,
	_VSTD::get<_Idx>(_VSTD::move(__t))...);
	}

	template <class ..._Args, size_t ..._Idx>
	_LIBCPP_INLINE_VISIBILITY
	- tuple<_Args&&..., memory_resource*>
	+ tuple<_Args&&..., polymorphic_allocator&>
	__transform_tuple(integral_constant<int, 2>, tuple<_Args...> && __t,
	- __tuple_indices<_Idx...>) const
	+ __tuple_indices<_Idx...>)
	{
	- using _Tup = tuple<_Args&&..., memory_resource*>;
	- return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., resource());
	+ using _Tup = tuple<_Args&&..., polymorphic_allocator&>;
	+ return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., *this);
	}

	_LIBCPP_INLINE_VISIBILITY
	size_t __max_size() const _NOEXCEPT
	{ return numeric_limits<size_t>::max() / sizeof(value_type); }

	memory_resource * __res_;
	};

	// 8.6.4, memory.polymorphic.allocator.eq

	template <class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	bool operator==(polymorphic_allocator<_Tp> const & __lhs,
	polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
	{
	return __lhs.resource() == __rhs.resource();
	}

	template <class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	bool operator!=(polymorphic_allocator<_Tp> const & __lhs,
	polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
	{
	return !(__lhs == __rhs);
	}

	// 8.7, memory.resource.adaptor

	// 8.7.1, memory.resource.adaptor.overview
	template <class _CharAlloc>
	class _LIBCPP_TEMPLATE_VIS __resource_adaptor_imp
	: public memory_resource
	{
	using _CTraits = allocator_traits<_CharAlloc>;
	static_assert(is_same<typename _CTraits::value_type, char>::value
	&& is_same<typename _CTraits::pointer, char*>::value
	&& is_same<typename _CTraits::void_pointer, void*>::value, "");

	static const size_t _MaxAlign = alignof(max_align_t);

	using _Alloc = typename _CTraits::template rebind_alloc<
	typename aligned_storage<_MaxAlign, _MaxAlign>::type
	>;

	using _ValueType = typename _Alloc::value_type;

	_Alloc __alloc_;

	public:
	typedef _CharAlloc allocator_type;

	__resource_adaptor_imp() = default;
	__resource_adaptor_imp(__resource_adaptor_imp const &) = default;
	__resource_adaptor_imp(__resource_adaptor_imp &&) = default;

	// 8.7.2, memory.resource.adaptor.ctor

	_LIBCPP_INLINE_VISIBILITY
	explicit __resource_adaptor_imp(allocator_type const & __a)
	: __alloc_(__a)
	{}

	_LIBCPP_INLINE_VISIBILITY
	explicit __resource_adaptor_imp(allocator_type && __a)
	: __alloc_(_VSTD::move(__a))
	{}

	__resource_adaptor_imp &
	operator=(__resource_adaptor_imp const &) = default;

	_LIBCPP_INLINE_VISIBILITY
	allocator_type get_allocator() const
	{ return __alloc_; }

	// 8.7.3, memory.resource.adaptor.mem
	protected:
	virtual void * do_allocate(size_t __bytes, size_t)
	{
	if (__bytes > __max_size()) {
	__throw_length_error(
	"std::experimental::pmr::resource_adaptor<T>::do_allocate(size_t bytes, size_t align)"
	" 'bytes' exceeds maximum supported size");
	}
	size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign;
	return __alloc_.allocate(__s);
	}

	virtual void do_deallocate(void * __p, size_t __bytes, size_t)
	{
	_LIBCPP_ASSERT(__bytes <= __max_size(),
	"do_deallocate called for size which exceeds the maximum allocation size");
	size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign;
	__alloc_.deallocate((_ValueType*)__p, __s);
	}

	virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT {
	__resource_adaptor_imp const * __p
	= dynamic_cast<__resource_adaptor_imp const *>(&__other);
	return __p ? __alloc_ == __p->__alloc_ : false;
	}

	private:
	_LIBCPP_INLINE_VISIBILITY
	size_t __max_size() const _NOEXCEPT {
	return numeric_limits<size_t>::max() - _MaxAlign;
	}
	};

	template <class _Alloc>
	using resource_adaptor = __resource_adaptor_imp<
	typename allocator_traits<_Alloc>::template rebind_alloc<char>
	>;

	_LIBCPP_END_NAMESPACE_LFTS_PMR

	_LIBCPP_POP_MACROS

	#endif /* _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE */
	Index: projects/clang700-import/contrib/libc++/include/experimental/numeric
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/numeric (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/numeric (revision 337135)
	@@ -1,119 +1,11 @@
	// -- C++ --
	//===--------------------------- numeric ----------------------------------===//
	//
	// 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_EXPERIMENTAL_NUMERIC
	-#define _LIBCPP_EXPERIMENTAL_NUMERIC
	-/*
	- experimental/numeric synopsis
	-
	-// C++1z
	-namespace std {
	-namespace experimental {
	-inline namespace fundamentals_v2 {
	-
	- // 13.1.2, Greatest common divisor
	- template<class M, class N>
	- constexpr common_type_t<M,N> gcd(M m, N n);
	-
	- // 13.1.3, Least common multiple
	- template<class M, class N>
	- constexpr common_type_t<M,N> lcm(M m, N n);
	-
	-} // namespace fundamentals_v2
	-} // namespace experimental
	-} // namespace std
	-
	- */
	-
	-#include <experimental/__config>
	-#include <numeric>
	-#include <type_traits> // is_integral
	-#include <limits> // numeric_limits
	-
	-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	-#pragma GCC system_header
	-#endif
	-
	-_LIBCPP_PUSH_MACROS
	-#include <__undef_macros>
	-
	-#if _LIBCPP_STD_VER > 11
	-
	-_LIBCPP_BEGIN_NAMESPACE_LFTS_V2
	-
	-template <typename _Result, typename _Source, bool _IsSigned = is_signed<_Source>::value> struct __abs;
	-
	-template <typename _Result, typename _Source>
	-struct __abs<_Result, _Source, true> {
	- _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
	- _Result operator()(_Source __t) const noexcept
	- {
	- if (__t >= 0) return __t;
	- if (__t == numeric_limits<_Source>::min()) return -static_cast<_Result>(__t);
	- return -__t;
	- }
	-};
	-
	-template <typename _Result, typename _Source>
	-struct __abs<_Result, _Source, false> {
	- _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
	- _Result operator()(_Source __t) const noexcept { return __t; }
	-};
	-
	-
	-template<class _Tp>
	-_LIBCPP_CONSTEXPR _LIBCPP_HIDDEN
	-inline _Tp __gcd(_Tp __m, _Tp __n)
	-{
	- static_assert((!is_signed<_Tp>::value), "" );
	- return __n == 0 ? __m : _VSTD_LFTS_V2::__gcd<_Tp>(__n, __m % __n);
	-}
	-
	-
	-template<class _Tp, class _Up>
	-_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
	-common_type_t<_Tp,_Up>
	-gcd(_Tp __m, _Up __n)
	-{
	- static_assert((is_integral<_Tp>::value && is_integral<_Up>::value), "Arguments to gcd must be integer types");
	- static_assert((!is_same<typename remove_cv<_Tp>::type, bool>::value), "First argument to gcd cannot be bool" );
	- static_assert((!is_same<typename remove_cv<_Up>::type, bool>::value), "Second argument to gcd cannot be bool" );
	- using _Rp = common_type_t<_Tp,_Up>;
	- using _Wp = make_unsigned_t<_Rp>;
	- return static_cast<_Rp>(_VSTD_LFTS_V2::__gcd(
	- static_cast<_Wp>(__abs<_Rp, _Tp>()(__m)),
	- static_cast<_Wp>(__abs<_Rp, _Up>()(__n))));
	-}
	-
	-template<class _Tp, class _Up>
	-_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
	-common_type_t<_Tp,_Up>
	-lcm(_Tp __m, _Up __n)
	-{
	- static_assert((is_integral<_Tp>::value && is_integral<_Up>::value), "Arguments to lcm must be integer types");
	- static_assert((!is_same<typename remove_cv<_Tp>::type, bool>::value), "First argument to lcm cannot be bool" );
	- static_assert((!is_same<typename remove_cv<_Up>::type, bool>::value), "Second argument to lcm cannot be bool" );
	- if (__m == 0 \|\| __n == 0)
	- return 0;
	-
	- using _Rp = common_type_t<_Tp,_Up>;
	- _Rp __val1 = __abs<_Rp, _Tp>()(__m) / _VSTD_LFTS_V2::gcd(__m, __n);
	- _Rp __val2 = __abs<_Rp, _Up>()(__n);
	- _LIBCPP_ASSERT((numeric_limits<_Rp>::max() / __val1 > __val2), "Overflow in lcm");
	- return __val1 * __val2;
	-}
	-
	-_LIBCPP_END_NAMESPACE_LFTS_V2
	-
	-#endif /* _LIBCPP_STD_VER > 11 */
	-
	-_LIBCPP_POP_MACROS
	-
	-#endif /* _LIBCPP_EXPERIMENTAL_NUMERIC */
	+#error "<experimental/numeric> has been removed. Use <numeric> instead."
	Index: projects/clang700-import/contrib/libc++/include/experimental/optional
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/optional (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/optional (revision 337135)
	@@ -1,922 +1,11 @@
	// -- C++ --
	//===-------------------------- optional ----------------------------------===//
	//
	// 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_EXPERIMENTAL_OPTIONAL
	-#define _LIBCPP_EXPERIMENTAL_OPTIONAL
	-
	-/*
	- optional synopsis
	-
	-// C++1y
	-
	-namespace std { namespace experimental { inline namespace fundamentals_v1 {
	-
	- // 5.3, optional for object types
	- template <class T> class optional;
	-
	- // 5.4, In-place construction
	- struct in_place_t{};
	- constexpr in_place_t in_place{};
	-
	- // 5.5, No-value state indicator
	- struct nullopt_t{see below};
	- constexpr nullopt_t nullopt(unspecified);
	-
	- // 5.6, Class bad_optional_access
	- class bad_optional_access;
	-
	- // 5.7, Relational operators
	- template <class T>
	- constexpr bool operator==(const optional<T>&, const optional<T>&);
	- template <class T>
	- constexpr bool operator!=(const optional<T>&, const optional<T>&);
	- template <class T>
	- constexpr bool operator<(const optional<T>&, const optional<T>&);
	- template <class T>
	- constexpr bool operator>(const optional<T>&, const optional<T>&);
	- template <class T>
	- constexpr bool operator<=(const optional<T>&, const optional<T>&);
	- template <class T>
	- constexpr bool operator>=(const optional<T>&, const optional<T>&);
	-
	- // 5.8, Comparison with nullopt
	- template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
	- template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept;
	- template <class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept;
	- template <class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept;
	- template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept;
	- template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept;
	- template <class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept;
	- template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept;
	- template <class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept;
	- template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept;
	- template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept;
	- template <class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept;
	-
	- // 5.9, Comparison with T
	- template <class T> constexpr bool operator==(const optional<T>&, const T&);
	- template <class T> constexpr bool operator==(const T&, const optional<T>&);
	- template <class T> constexpr bool operator!=(const optional<T>&, const T&);
	- template <class T> constexpr bool operator!=(const T&, const optional<T>&);
	- template <class T> constexpr bool operator<(const optional<T>&, const T&);
	- template <class T> constexpr bool operator<(const T&, const optional<T>&);
	- template <class T> constexpr bool operator<=(const optional<T>&, const T&);
	- template <class T> constexpr bool operator<=(const T&, const optional<T>&);
	- template <class T> constexpr bool operator>(const optional<T>&, const T&);
	- template <class T> constexpr bool operator>(const T&, const optional<T>&);
	- template <class T> constexpr bool operator>=(const optional<T>&, const T&);
	- template <class T> constexpr bool operator>=(const T&, const optional<T>&);
	-
	- // 5.10, Specialized algorithms
	- template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below);
	- template <class T> constexpr optional<see below> make_optional(T&&);
	-
	- template <class T>
	- class optional
	- {
	- public:
	- typedef T value_type;
	-
	- // 5.3.1, Constructors
	- constexpr optional() noexcept;
	- constexpr optional(nullopt_t) noexcept;
	- optional(const optional&);
	- optional(optional&&) noexcept(see below);
	- constexpr optional(const T&);
	- constexpr optional(T&&);
	- template <class... Args> constexpr explicit optional(in_place_t, Args&&...);
	- template <class U, class... Args>
	- constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);
	-
	- // 5.3.2, Destructor
	- ~optional();
	-
	- // 5.3.3, Assignment
	- optional& operator=(nullopt_t) noexcept;
	- optional& operator=(const optional&);
	- optional& operator=(optional&&) noexcept(see below);
	- template <class U> optional& operator=(U&&);
	- template <class... Args> void emplace(Args&&...);
	- template <class U, class... Args>
	- void emplace(initializer_list<U>, Args&&...);
	-
	- // 5.3.4, Swap
	- void swap(optional&) noexcept(see below);
	-
	- // 5.3.5, Observers
	- constexpr T const* operator ->() const;
	- constexpr T* operator ->();
	- constexpr T const& operator *() const &;
	- constexpr T& operator *() &;
	- constexpr T&& operator *() &&;
	- constexpr const T&& operator *() const &&;
	- constexpr explicit operator bool() const noexcept;
	- constexpr T const& value() const &;
	- constexpr T& value() &;
	- constexpr T&& value() &&;
	- constexpr const T&& value() const &&;
	- template <class U> constexpr T value_or(U&&) const &;
	- template <class U> constexpr T value_or(U&&) &&;
	-
	- private:
	- T* val; // exposition only
	- };
	-
	- } // namespace fundamentals_v1
	- } // namespace experimental
	-
	- // 5.11, Hash support
	- template <class T> struct hash;
	- template <class T> struct hash<experimental::optional<T>>;
	-
	-} // namespace std
	-
	-*/
	-
	-#include <experimental/__config>
	-#include <functional>
	-#include <stdexcept>
	-#if _LIBCPP_STD_VER > 11
	-#include <initializer_list>
	-#include <type_traits>
	-#include <new>
	-#include <__functional_base>
	-#include <__debug>
	-#endif
	-
	-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	-#pragma GCC system_header
	-#endif
	-
	-_LIBCPP_PUSH_MACROS
	-#include <__undef_macros>
	-
	-
	-_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
	-class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access
	- : public std::logic_error
	-{
	-public:
	- bad_optional_access() : std::logic_error("Bad optional Access") {}
	-
	-// Get the key function ~bad_optional_access() into the dylib
	- virtual ~bad_optional_access() _NOEXCEPT;
	-};
	-
	-_LIBCPP_END_NAMESPACE_EXPERIMENTAL
	-
	-
	-#if _LIBCPP_STD_VER > 11
	-
	-_LIBCPP_BEGIN_NAMESPACE_LFTS
	-
	-struct in_place_t {};
	-constexpr in_place_t in_place{};
	-
	-struct nullopt_t
	-{
	- explicit constexpr nullopt_t(int) noexcept {}
	-};
	-
	-constexpr nullopt_t nullopt{0};
	-
	-template <class _Tp, bool = is_trivially_destructible<_Tp>::value>
	-class __optional_storage
	-{
	-protected:
	- typedef _Tp value_type;
	- union
	- {
	- char __null_state_;
	- value_type __val_;
	- };
	- bool __engaged_ = false;
	-
	- _LIBCPP_INLINE_VISIBILITY
	- ~__optional_storage()
	- {
	- if (__engaged_)
	- __val_.~value_type();
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- constexpr __optional_storage() noexcept
	- : __null_state_('\0') {}
	-
	- _LIBCPP_INLINE_VISIBILITY
	- __optional_storage(const __optional_storage& __x)
	- : __engaged_(__x.__engaged_)
	- {
	- if (__engaged_)
	- ::new((void*)_VSTD::addressof(__val_)) value_type(__x.__val_);
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- __optional_storage(__optional_storage&& __x)
	- noexcept(is_nothrow_move_constructible<value_type>::value)
	- : __engaged_(__x.__engaged_)
	- {
	- if (__engaged_)
	- ::new((void*)_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_));
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- constexpr __optional_storage(const value_type& __v)
	- : __val_(__v),
	- __engaged_(true) {}
	-
	- _LIBCPP_INLINE_VISIBILITY
	- constexpr __optional_storage(value_type&& __v)
	- : __val_(_VSTD::move(__v)),
	- __engaged_(true) {}
	-
	- template <class... _Args>
	- _LIBCPP_INLINE_VISIBILITY
	- constexpr
	- explicit __optional_storage(in_place_t, _Args&&... __args)
	- : __val_(_VSTD::forward<_Args>(__args)...),
	- __engaged_(true) {}
	-};
	-
	-template <class _Tp>
	-class __optional_storage<_Tp, true>
	-{
	-protected:
	- typedef _Tp value_type;
	- union
	- {
	- char __null_state_;
	- value_type __val_;
	- };
	- bool __engaged_ = false;
	-
	- _LIBCPP_INLINE_VISIBILITY
	- constexpr __optional_storage() noexcept
	- : __null_state_('\0') {}
	-
	- _LIBCPP_INLINE_VISIBILITY
	- __optional_storage(const __optional_storage& __x)
	- : __engaged_(__x.__engaged_)
	- {
	- if (__engaged_)
	- ::new((void*)_VSTD::addressof(__val_)) value_type(__x.__val_);
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- __optional_storage(__optional_storage&& __x)
	- noexcept(is_nothrow_move_constructible<value_type>::value)
	- : __engaged_(__x.__engaged_)
	- {
	- if (__engaged_)
	- ::new((void*)_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_));
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- constexpr __optional_storage(const value_type& __v)
	- : __val_(__v),
	- __engaged_(true) {}
	-
	- _LIBCPP_INLINE_VISIBILITY
	- constexpr __optional_storage(value_type&& __v)
	- : __val_(_VSTD::move(__v)),
	- __engaged_(true) {}
	-
	- template <class... _Args>
	- _LIBCPP_INLINE_VISIBILITY
	- constexpr
	- explicit __optional_storage(in_place_t, _Args&&... __args)
	- : __val_(_VSTD::forward<_Args>(__args)...),
	- __engaged_(true) {}
	-};
	-
	-template <class _Tp>
	-class optional
	- : private __optional_storage<_Tp>
	-{
	- typedef __optional_storage<_Tp> __base;
	-public:
	- typedef _Tp value_type;
	-
	- static_assert(!is_reference<value_type>::value,
	- "Instantiation of optional with a reference type is ill-formed.");
	- static_assert(!is_same<typename remove_cv<value_type>::type, in_place_t>::value,
	- "Instantiation of optional with a in_place_t type is ill-formed.");
	- static_assert(!is_same<typename remove_cv<value_type>::type, nullopt_t>::value,
	- "Instantiation of optional with a nullopt_t type is ill-formed.");
	- static_assert(is_object<value_type>::value,
	- "Instantiation of optional with a non-object type is undefined behavior.");
	- static_assert(is_nothrow_destructible<value_type>::value,
	- "Instantiation of optional with an object type that is not noexcept destructible is undefined behavior.");
	-
	- _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {}
	- _LIBCPP_INLINE_VISIBILITY optional(const optional&) = default;
	- _LIBCPP_INLINE_VISIBILITY optional(optional&&) = default;
	- _LIBCPP_INLINE_VISIBILITY ~optional() = default;
	- _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {}
	- _LIBCPP_INLINE_VISIBILITY constexpr optional(const value_type& __v)
	- : __base(__v) {}
	- _LIBCPP_INLINE_VISIBILITY constexpr optional(value_type&& __v)
	- : __base(_VSTD::move(__v)) {}
	-
	- template <class... _Args,
	- class = typename enable_if
	- <
	- is_constructible<value_type, _Args...>::value
	- >::type
	- >
	- _LIBCPP_INLINE_VISIBILITY
	- constexpr
	- explicit optional(in_place_t, _Args&&... __args)
	- : __base(in_place, _VSTD::forward<_Args>(__args)...) {}
	-
	- template <class _Up, class... _Args,
	- class = typename enable_if
	- <
	- is_constructible<value_type, initializer_list<_Up>&, _Args...>::value
	- >::type
	- >
	- _LIBCPP_INLINE_VISIBILITY
	- constexpr
	- explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
	- : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {}
	-
	- _LIBCPP_INLINE_VISIBILITY
	- optional& operator=(nullopt_t) noexcept
	- {
	- if (this->__engaged_)
	- {
	- this->__val_.~value_type();
	- this->__engaged_ = false;
	- }
	- return *this;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- optional&
	- operator=(const optional& __opt)
	- {
	- if (this->__engaged_ == __opt.__engaged_)
	- {
	- if (this->__engaged_)
	- this->__val_ = __opt.__val_;
	- }
	- else
	- {
	- if (this->__engaged_)
	- this->__val_.~value_type();
	- else
	- ::new((void*)_VSTD::addressof(this->__val_)) value_type(__opt.__val_);
	- this->__engaged_ = __opt.__engaged_;
	- }
	- return *this;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- optional&
	- operator=(optional&& __opt)
	- noexcept(is_nothrow_move_assignable<value_type>::value &&
	- is_nothrow_move_constructible<value_type>::value)
	- {
	- if (this->__engaged_ == __opt.__engaged_)
	- {
	- if (this->__engaged_)
	- this->__val_ = _VSTD::move(__opt.__val_);
	- }
	- else
	- {
	- if (this->__engaged_)
	- this->__val_.~value_type();
	- else
	- ::new((void*)_VSTD::addressof(this->__val_))
	- value_type(_VSTD::move(__opt.__val_));
	- this->__engaged_ = __opt.__engaged_;
	- }
	- return *this;
	- }
	-
	- template <class _Up,
	- class = typename enable_if
	- <
	- is_same<typename remove_reference<_Up>::type, value_type>::value &&
	- is_constructible<value_type, _Up>::value &&
	- is_assignable<value_type&, _Up>::value
	- >::type
	- >
	- _LIBCPP_INLINE_VISIBILITY
	- optional&
	- operator=(_Up&& __v)
	- {
	- if (this->__engaged_)
	- this->__val_ = _VSTD::forward<_Up>(__v);
	- else
	- {
	- ::new((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Up>(__v));
	- this->__engaged_ = true;
	- }
	- return *this;
	- }
	-
	- template <class... _Args,
	- class = typename enable_if
	- <
	- is_constructible<value_type, _Args...>::value
	- >::type
	- >
	- _LIBCPP_INLINE_VISIBILITY
	- void
	- emplace(_Args&&... __args)
	- {
	- *this = nullopt;
	- ::new((void*)_VSTD::addressof(this->__val_))
	- value_type(_VSTD::forward<_Args>(__args)...);
	- this->__engaged_ = true;
	- }
	-
	- template <class _Up, class... _Args,
	- class = typename enable_if
	- <
	- is_constructible<value_type, initializer_list<_Up>&, _Args...>::value
	- >::type
	- >
	- _LIBCPP_INLINE_VISIBILITY
	- void
	- emplace(initializer_list<_Up> __il, _Args&&... __args)
	- {
	- *this = nullopt;
	- ::new((void*)_VSTD::addressof(this->__val_))
	- value_type(__il, _VSTD::forward<_Args>(__args)...);
	- this->__engaged_ = true;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- void
	- swap(optional& __opt)
	- noexcept(is_nothrow_move_constructible<value_type>::value &&
	- __is_nothrow_swappable<value_type>::value)
	- {
	- using _VSTD::swap;
	- if (this->__engaged_ == __opt.__engaged_)
	- {
	- if (this->__engaged_)
	- swap(this->__val_, __opt.__val_);
	- }
	- else
	- {
	- if (this->__engaged_)
	- {
	- ::new((void*)_VSTD::addressof(__opt.__val_))
	- value_type(_VSTD::move(this->__val_));
	- this->__val_.~value_type();
	- }
	- else
	- {
	- ::new((void*)_VSTD::addressof(this->__val_))
	- value_type(_VSTD::move(__opt.__val_));
	- __opt.__val_.~value_type();
	- }
	- swap(this->__engaged_, __opt.__engaged_);
	- }
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- constexpr
	- value_type const*
	- operator->() const
	- {
	- _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value");
	-#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
	- return __builtin_addressof(this->__val_);
	-#else
	- return __operator_arrow(__has_operator_addressof<value_type>{});
	-#endif
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- value_type*
	- operator->()
	- {
	- _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value");
	- return _VSTD::addressof(this->__val_);
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- constexpr
	- const value_type&
	- operator*() const
	- {
	- _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value");
	- return this->__val_;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- value_type&
	- operator*()
	- {
	- _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value");
	- return this->__val_;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- constexpr explicit operator bool() const noexcept {return this->__engaged_;}
	-
	- _LIBCPP_NORETURN _LIBCPP_INLINE_VISIBILITY
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	-_LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
	-#endif
	- constexpr void __throw_bad_optional_access() const
	- {
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- throw bad_optional_access();
	-#else
	- _VSTD::abort();
	-#endif
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
	- constexpr value_type const& value() const
	- {
	- if (!this->__engaged_)
	- __throw_bad_optional_access();
	- return this->__val_;
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
	- value_type& value()
	- {
	- if (!this->__engaged_)
	- __throw_bad_optional_access();
	- return this->__val_;
	- }
	-
	- template <class _Up>
	- _LIBCPP_INLINE_VISIBILITY
	- constexpr value_type value_or(_Up&& __v) const&
	- {
	- static_assert(is_copy_constructible<value_type>::value,
	- "optional<T>::value_or: T must be copy constructible");
	- static_assert(is_convertible<_Up, value_type>::value,
	- "optional<T>::value_or: U must be convertible to T");
	- return this->__engaged_ ? this->__val_ :
	- static_cast<value_type>(_VSTD::forward<_Up>(__v));
	- }
	-
	- template <class _Up>
	- _LIBCPP_INLINE_VISIBILITY
	- value_type value_or(_Up&& __v) &&
	- {
	- static_assert(is_move_constructible<value_type>::value,
	- "optional<T>::value_or: T must be move constructible");
	- static_assert(is_convertible<_Up, value_type>::value,
	- "optional<T>::value_or: U must be convertible to T");
	- return this->__engaged_ ? _VSTD::move(this->__val_) :
	- static_cast<value_type>(_VSTD::forward<_Up>(__v));
	- }
	-
	-private:
	- _LIBCPP_INLINE_VISIBILITY
	- value_type const*
	- __operator_arrow(true_type) const
	- {
	- return _VSTD::addressof(this->__val_);
	- }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- constexpr
	- value_type const*
	- __operator_arrow(false_type) const
	- {
	- return &this->__val_;
	- }
	-};
	-
	-// Comparisons between optionals
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator==(const optional<_Tp>& __x, const optional<_Tp>& __y)
	-{
	- if (static_cast<bool>(__x) != static_cast<bool>(__y))
	- return false;
	- if (!static_cast<bool>(__x))
	- return true;
	- return __x == __y;
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator!=(const optional<_Tp>& __x, const optional<_Tp>& __y)
	-{
	- return !(__x == __y);
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator<(const optional<_Tp>& __x, const optional<_Tp>& __y)
	-{
	- if (!static_cast<bool>(__y))
	- return false;
	- if (!static_cast<bool>(__x))
	- return true;
	- return __x < __y;
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator>(const optional<_Tp>& __x, const optional<_Tp>& __y)
	-{
	- return __y < __x;
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator<=(const optional<_Tp>& __x, const optional<_Tp>& __y)
	-{
	- return !(__y < __x);
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator>=(const optional<_Tp>& __x, const optional<_Tp>& __y)
	-{
	- return !(__x < __y);
	-}
	-
	-
	-// Comparisons with nullopt
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator==(const optional<_Tp>& __x, nullopt_t) noexcept
	-{
	- return !static_cast<bool>(__x);
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator==(nullopt_t, const optional<_Tp>& __x) noexcept
	-{
	- return !static_cast<bool>(__x);
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator!=(const optional<_Tp>& __x, nullopt_t) noexcept
	-{
	- return static_cast<bool>(__x);
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator!=(nullopt_t, const optional<_Tp>& __x) noexcept
	-{
	- return static_cast<bool>(__x);
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator<(const optional<_Tp>&, nullopt_t) noexcept
	-{
	- return false;
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator<(nullopt_t, const optional<_Tp>& __x) noexcept
	-{
	- return static_cast<bool>(__x);
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator<=(const optional<_Tp>& __x, nullopt_t) noexcept
	-{
	- return !static_cast<bool>(__x);
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator<=(nullopt_t, const optional<_Tp>&) noexcept
	-{
	- return true;
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator>(const optional<_Tp>& __x, nullopt_t) noexcept
	-{
	- return static_cast<bool>(__x);
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator>(nullopt_t, const optional<_Tp>&) noexcept
	-{
	- return false;
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator>=(const optional<_Tp>&, nullopt_t) noexcept
	-{
	- return true;
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator>=(nullopt_t, const optional<_Tp>& __x) noexcept
	-{
	- return !static_cast<bool>(__x);
	-}
	-
	-// Comparisons with T
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator==(const optional<_Tp>& __x, const _Tp& __v)
	-{
	- return static_cast<bool>(__x) ? *__x == __v : false;
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator==(const _Tp& __v, const optional<_Tp>& __x)
	-{
	- return static_cast<bool>(__x) ? *__x == __v : false;
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator!=(const optional<_Tp>& __x, const _Tp& __v)
	-{
	- return static_cast<bool>(__x) ? !(*__x == __v) : true;
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator!=(const _Tp& __v, const optional<_Tp>& __x)
	-{
	- return static_cast<bool>(__x) ? !(*__x == __v) : true;
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator<(const optional<_Tp>& __x, const _Tp& __v)
	-{
	- return static_cast<bool>(__x) ? less<_Tp>{}(*__x, __v) : true;
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator<(const _Tp& __v, const optional<_Tp>& __x)
	-{
	- return static_cast<bool>(__x) ? less<_Tp>{}(__v, *__x) : false;
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator<=(const optional<_Tp>& __x, const _Tp& __v)
	-{
	- return !(__x > __v);
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator<=(const _Tp& __v, const optional<_Tp>& __x)
	-{
	- return !(__v > __x);
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator>(const optional<_Tp>& __x, const _Tp& __v)
	-{
	- return static_cast<bool>(__x) ? __v < __x : false;
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator>(const _Tp& __v, const optional<_Tp>& __x)
	-{
	- return static_cast<bool>(__x) ? __x < __v : true;
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator>=(const optional<_Tp>& __x, const _Tp& __v)
	-{
	- return !(__x < __v);
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-bool
	-operator>=(const _Tp& __v, const optional<_Tp>& __x)
	-{
	- return !(__v < __x);
	-}
	-
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-void
	-swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
	-{
	- __x.swap(__y);
	-}
	-
	-template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	-constexpr
	-optional<typename decay<_Tp>::type>
	-make_optional(_Tp&& __v)
	-{
	- return optional<typename decay<_Tp>::type>(_VSTD::forward<_Tp>(__v));
	-}
	-
	-_LIBCPP_END_NAMESPACE_LFTS
	-
	-_LIBCPP_BEGIN_NAMESPACE_STD
	-
	-template <class _Tp>
	-struct _LIBCPP_TEMPLATE_VIS hash<std::experimental::optional<_Tp> >
	-{
	- typedef std::experimental::optional<_Tp> argument_type;
	- typedef size_t result_type;
	-
	- _LIBCPP_INLINE_VISIBILITY
	- result_type operator()(const argument_type& __opt) const _NOEXCEPT
	- {
	- return static_cast<bool>(__opt) ? hash<_Tp>()(*__opt) : 0;
	- }
	-};
	-
	-_LIBCPP_END_NAMESPACE_STD
	-
	-#endif // _LIBCPP_STD_VER > 11
	-
	-_LIBCPP_POP_MACROS
	-
	-#endif // _LIBCPP_EXPERIMENTAL_OPTIONAL
	+#error "<experimental/optional> has been removed. Use <optional> instead."
	Index: projects/clang700-import/contrib/libc++/include/experimental/propagate_const
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/propagate_const (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/propagate_const (revision 337135)
	@@ -1,580 +1,579 @@
	// -- C++ --
	//===------------------------ propagate_const -----------------------------===//
	//
	// 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_EXPERIMENTAL_PROPAGATE_CONST
	#define _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST
	/*
	propagate_const synopsis

	namespace std { namespace experimental { inline namespace fundamentals_v2 {

	// [propagate_const]
	template <class T> class propagate_const;

	// [propagate_const.underlying], underlying pointer access
	constexpr const _Tp& _VSTD_LFTS_V2::get_underlying(const propagate_const<T>& pt) noexcept;
	constexpr T& _VSTD_LFTS_V2::get_underlying(propagate_const<T>& pt) noexcept;

	// [propagate_const.relational], relational operators
	template <class T> constexpr bool operator==(const propagate_const<T>& pt, nullptr_t);
	template <class T> constexpr bool operator==(nullptr_t, const propagate_const<T>& pu);
	template <class T> constexpr bool operator!=(const propagate_const<T>& pt, nullptr_t);
	template <class T> constexpr bool operator!=(nullptr_t, const propagate_const<T>& pu);
	template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
	template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
	template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
	template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
	template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
	template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const propagate_const<_Up>& pu);
	template <class T, class U> constexpr bool operator==(const propagate_const<T>& pt, const _Up& u);
	template <class T, class U> constexpr bool operator!=(const propagate_const<T>& pt, const _Up& u);
	template <class T, class U> constexpr bool operator<(const propagate_const<T>& pt, const _Up& u);
	template <class T, class U> constexpr bool operator>(const propagate_const<T>& pt, const _Up& u);
	template <class T, class U> constexpr bool operator<=(const propagate_const<T>& pt, const _Up& u);
	template <class T, class U> constexpr bool operator>=(const propagate_const<T>& pt, const _Up& u);
	template <class T, class U> constexpr bool operator==(const _Tp& t, const propagate_const<_Up>& pu);
	template <class T, class U> constexpr bool operator!=(const _Tp& t, const propagate_const<_Up>& pu);
	template <class T, class U> constexpr bool operator<(const _Tp& t, const propagate_const<_Up>& pu);
	template <class T, class U> constexpr bool operator>(const _Tp& t, const propagate_const<_Up>& pu);
	template <class T, class U> constexpr bool operator<=(const _Tp& t, const propagate_const<_Up>& pu);
	template <class T, class U> constexpr bool operator>=(const _Tp& t, const propagate_const<_Up>& pu);

	// [propagate_const.algorithms], specialized algorithms
	template <class T> constexpr void swap(propagate_const<T>& pt, propagate_const<T>& pu) noexcept(see below);

	template <class T>
	class propagate_const
	{

	public:
	typedef remove_reference_t<decltype(*declval<T&>())> element_type;

	// [propagate_const.ctor], constructors
	constexpr propagate_const() = default;
	propagate_const(const propagate_const& p) = delete;
	constexpr propagate_const(propagate_const&& p) = default;
	template <class U> EXPLICIT constexpr propagate_const(propagate_const<_Up>&& pu); // see below
	template <class U> EXPLICIT constexpr propagate_const(U&& u); // see below

	// [propagate_const.assignment], assignment
	propagate_const& operator=(const propagate_const& p) = delete;
	constexpr propagate_const& operator=(propagate_const&& p) = default;
	template <class U> constexpr propagate_const& operator=(propagate_const<_Up>&& pu);
	template <class U> constexpr propagate_const& operator=(U&& u); // see below

	// [propagate_const.const_observers], const observers
	explicit constexpr operator bool() const;
	constexpr const element_type* operator->() const;
	constexpr operator const element_type*() const; // Not always defined
	constexpr const element_type& operator*() const;
	constexpr const element_type* get() const;

	// [propagate_const.non_const_observers], non-const observers
	constexpr element_type* operator->();
	constexpr operator element_type*(); // Not always defined
	constexpr element_type& operator*();
	constexpr element_type* get();

	// [propagate_const.modifiers], modifiers
	constexpr void swap(propagate_const& pt) noexcept(see below)

	private:
	T t_; // exposition only
	};

	} // namespace fundamentals_v2
	} // namespace experimental

	// [propagate_const.hash], hash support
	template <class T> struct hash<experimental::fundamentals_v2::propagate_const<T>>;

	// [propagate_const.comparison_function_objects], comparison function objects
	template <class T> struct equal_to<experimental::fundamentals_v2::propagate_const<T>>;
	template <class T> struct not_equal_to<experimental::fundamentals_v2::propagate_const<T>>;
	template <class T> struct less<experimental::fundamentals_v2::propagate_const<T>>;
	template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>;
	template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
	template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>;

	} // namespace std

	*/

	#include <experimental/__config>
	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	#if _LIBCPP_STD_VER > 11

	#include <type_traits>
	#include <utility>
	#include <functional>

	_LIBCPP_BEGIN_NAMESPACE_LFTS_V2


	template <class _Tp>
	class propagate_const;

	template <class _Up>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	const _Up& get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;

	template <class _Up>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	_Up& get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;

	template <class _Tp>
	class propagate_const
	{
	public:
	typedef remove_reference_t<decltype(*_VSTD::declval<_Tp&>())> element_type;

	static_assert(!is_array<_Tp>::value,
	"Instantiation of propagate_const with an array type is ill-formed.");
	static_assert(!is_reference<_Tp>::value,
	"Instantiation of propagate_const with a reference type is ill-formed.");
	static_assert(!(is_pointer<_Tp>::value && is_function<typename remove_pointer<_Tp>::type>::value),
	"Instantiation of propagate_const with a function-pointer type is ill-formed.");
	static_assert(!(is_pointer<_Tp>::value && is_same<typename remove_cv<typename remove_pointer<_Tp>::type>::type, void>::value),
	"Instantiation of propagate_const with a pointer to (possibly cv-qualified) void is ill-formed.");

	private:
	template <class _Up>
	static _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up* __u)
	{
	return __u;
	}

	template <class _Up>
	static _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up& __u)
	{
	return __get_pointer(__u.get());
	}

	template <class _Up>
	static _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up* __u)
	{
	return __u;
	}

	template <class _Up>
	static _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up& __u)
	{
	return __get_pointer(__u.get());
	}

	template <class _Up>
	struct __is_propagate_const : false_type
	{
	};

	template <class _Up>
	struct __is_propagate_const<propagate_const<_Up>> : true_type
	{
	};

	_Tp __t_;

	public:

	template <class _Up> friend _LIBCPP_CONSTEXPR const _Up& ::_VSTD_LFTS_V2::get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
	template <class _Up> friend _LIBCPP_CONSTEXPR _Up& ::_VSTD_LFTS_V2::get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;

	_LIBCPP_CONSTEXPR propagate_const() = default;

	propagate_const(const propagate_const&) = delete;

	_LIBCPP_CONSTEXPR propagate_const(propagate_const&&) = default;

	template <class _Up, enable_if_t<!is_convertible<_Up, _Tp>::value &&
	is_constructible<_Tp, _Up&&>::value,bool> = true>
	explicit _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
	: __t_(std::move(_VSTD_LFTS_V2::get_underlying(__pu)))
	{
	}

	template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
	is_constructible<_Tp, _Up&&>::value,bool> = false>
	_LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
	: __t_(std::move(_VSTD_LFTS_V2::get_underlying(__pu)))
	{
	}

	template <class _Up, enable_if_t<!is_convertible<_Up&&, _Tp>::value &&
	is_constructible<_Tp, _Up&&>::value &&
	!__is_propagate_const<decay_t<_Up>>::value,bool> = true>
	explicit _LIBCPP_CONSTEXPR propagate_const(_Up&& __u)
	: __t_(std::forward<_Up>(__u))
	{
	}

	template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
	is_constructible<_Tp, _Up&&>::value &&
	!__is_propagate_const<decay_t<_Up>>::value,bool> = false>
	_LIBCPP_CONSTEXPR propagate_const(_Up&& __u)
	: __t_(std::forward<_Up>(__u))
	{
	}

	propagate_const& operator=(const propagate_const&) = delete;

	_LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const&&) = default;

	template <class _Up>
	_LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const<_Up>&& __pu)
	{
	__t_ = std::move(_VSTD_LFTS_V2::get_underlying(__pu));
	return *this;
	}

	template <class _Up, class _Vp = enable_if_t<!__is_propagate_const<decay_t<_Up>>::value>>
	_LIBCPP_CONSTEXPR propagate_const& operator=(_Up&& __u)
	{
	__t_ = std::forward<_Up>(__u);
	return *this;
	}

	_LIBCPP_CONSTEXPR const element_type* get() const
	{
	return __get_pointer(__t_);
	}

	_LIBCPP_CONSTEXPR element_type* get()
	{
	return __get_pointer(__t_);
	}

	explicit _LIBCPP_CONSTEXPR operator bool() const
	{
	return get() != nullptr;
	}

	_LIBCPP_CONSTEXPR const element_type* operator->() const
	{
	return get();
	}

	template <class _Tp_ = _Tp, class _Up = enable_if_t<is_convertible<
	const _Tp_, const element_type *>::value>>
	_LIBCPP_CONSTEXPR operator const element_type *() const {
	return get();
	}

	_LIBCPP_CONSTEXPR const element_type& operator*() const
	{
	return *get();
	}

	_LIBCPP_CONSTEXPR element_type* operator->()
	{
	return get();
	}

	template <class _Tp_ = _Tp, class _Up = enable_if_t<
	is_convertible<_Tp_, element_type *>::value>>
	_LIBCPP_CONSTEXPR operator element_type *() {
	return get();
	}

	_LIBCPP_CONSTEXPR element_type& operator*()
	{
	return *get();
	}

	_LIBCPP_CONSTEXPR void swap(propagate_const& __pt) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
	{
	using _VSTD::swap;
	swap(__t_, __pt.__t_);
	}
	};


	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, nullptr_t)
	{
	return _VSTD_LFTS_V2::get_underlying(__pt) == nullptr;
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator==(nullptr_t, const propagate_const<_Tp>& __pt)
	{
	return nullptr == _VSTD_LFTS_V2::get_underlying(__pt);
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, nullptr_t)
	{
	return _VSTD_LFTS_V2::get_underlying(__pt) != nullptr;
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator!=(nullptr_t, const propagate_const<_Tp>& __pt)
	{
	return nullptr != _VSTD_LFTS_V2::get_underlying(__pt);
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt,
	const propagate_const<_Up>& __pu)
	{
	return _VSTD_LFTS_V2::get_underlying(__pt) == _VSTD_LFTS_V2::get_underlying(__pu);
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt,
	const propagate_const<_Up>& __pu)
	{
	return _VSTD_LFTS_V2::get_underlying(__pt) != _VSTD_LFTS_V2::get_underlying(__pu);
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt,
	const propagate_const<_Up>& __pu)
	{
	return _VSTD_LFTS_V2::get_underlying(__pt) < _VSTD_LFTS_V2::get_underlying(__pu);
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt,
	const propagate_const<_Up>& __pu)
	{
	return _VSTD_LFTS_V2::get_underlying(__pt) > _VSTD_LFTS_V2::get_underlying(__pu);
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt,
	const propagate_const<_Up>& __pu)
	{
	return _VSTD_LFTS_V2::get_underlying(__pt) <= _VSTD_LFTS_V2::get_underlying(__pu);
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt,
	const propagate_const<_Up>& __pu)
	{
	return _VSTD_LFTS_V2::get_underlying(__pt) >= _VSTD_LFTS_V2::get_underlying(__pu);
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, const _Up& __u)
	{
	return _VSTD_LFTS_V2::get_underlying(__pt) == __u;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, const _Up& __u)
	{
	return _VSTD_LFTS_V2::get_underlying(__pt) != __u;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt, const _Up& __u)
	{
	return _VSTD_LFTS_V2::get_underlying(__pt) < __u;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt, const _Up& __u)
	{
	return _VSTD_LFTS_V2::get_underlying(__pt) > __u;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt, const _Up& __u)
	{
	return _VSTD_LFTS_V2::get_underlying(__pt) <= __u;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt, const _Up& __u)
	{
	return _VSTD_LFTS_V2::get_underlying(__pt) >= __u;
	}


	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator==(const _Tp& __t, const propagate_const<_Up>& __pu)
	{
	return __t == _VSTD_LFTS_V2::get_underlying(__pu);
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator!=(const _Tp& __t, const propagate_const<_Up>& __pu)
	{
	return __t != _VSTD_LFTS_V2::get_underlying(__pu);
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator<(const _Tp& __t, const propagate_const<_Up>& __pu)
	{
	return __t < _VSTD_LFTS_V2::get_underlying(__pu);
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator>(const _Tp& __t, const propagate_const<_Up>& __pu)
	{
	return __t > _VSTD_LFTS_V2::get_underlying(__pu);
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator<=(const _Tp& __t, const propagate_const<_Up>& __pu)
	{
	return __t <= _VSTD_LFTS_V2::get_underlying(__pu);
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR bool operator>=(const _Tp& __t, const propagate_const<_Up>& __pu)
	{
	return __t >= _VSTD_LFTS_V2::get_underlying(__pu);
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR void swap(propagate_const<_Tp>& __pc1, propagate_const<_Tp>& __pc2) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
	{
	- using _VSTD::swap;
	- swap(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
	+ __pc1.swap(__pc2);
	}

	template <class _Tp>
	_LIBCPP_CONSTEXPR const _Tp& get_underlying(const propagate_const<_Tp>& __pt) _NOEXCEPT
	{
	return __pt.__t_;
	}

	template <class _Tp>
	_LIBCPP_CONSTEXPR _Tp& get_underlying(propagate_const<_Tp>& __pt) _NOEXCEPT
	{
	return __pt.__t_;
	}

	_LIBCPP_END_NAMESPACE_LFTS_V2

	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _Tp>
	struct hash<experimental::fundamentals_v2::propagate_const<_Tp>>
	{
	typedef size_t result_type;
	typedef experimental::fundamentals_v2::propagate_const<_Tp> argument_type;

	size_t operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1) const
	{
	return std::hash<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1));
	}
	};

	template <class _Tp>
	struct equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
	{
	typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
	typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;

	bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
	const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
	{
	return std::equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
	}
	};

	template <class _Tp>
	struct not_equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
	{
	typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
	typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;

	bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
	const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
	{
	return std::not_equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
	}
	};

	template <class _Tp>
	struct less<experimental::fundamentals_v2::propagate_const<_Tp>>
	{
	typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
	typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;

	bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
	const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
	{
	return std::less<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
	}
	};

	template <class _Tp>
	struct greater<experimental::fundamentals_v2::propagate_const<_Tp>>
	{
	typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
	typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;

	bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
	const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
	{
	return std::greater<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
	}
	};

	template <class _Tp>
	struct less_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
	{
	typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
	typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;

	bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
	const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
	{
	return std::less_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
	}
	};

	template <class _Tp>
	struct greater_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
	{
	typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
	typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;

	bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
	const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
	{
	return std::greater_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
	}
	};

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_STD_VER > 11
	#endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST

	Index: projects/clang700-import/contrib/libc++/include/experimental/ratio
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/ratio (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/ratio (revision 337135)
	@@ -1,77 +1,11 @@
	// -- C++ --
	//===------------------------------ ratio ---------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	-#ifndef _LIBCPP_EXPERIMENTAL_RATIO
	-#define _LIBCPP_EXPERIMENTAL_RATIO
	-
	-/**
	- experimental/ratio synopsis
	- C++1y
	-#include <ratio>
	-
	-namespace std {
	-namespace experimental {
	-inline namespace fundamentals_v1 {
	-
	- // See C++14 20.11.5, ratio comparison
	- template <class R1, class R2> constexpr bool ratio_equal_v
	- = ratio_equal<R1, R2>::value;
	- template <class R1, class R2> constexpr bool ratio_not_equal_v
	- = ratio_not_equal<R1, R2>::value;
	- template <class R1, class R2> constexpr bool ratio_less_v
	- = ratio_less<R1, R2>::value;
	- template <class R1, class R2> constexpr bool ratio_less_equal_v
	- = ratio_less_equal<R1, R2>::value;
	- template <class R1, class R2> constexpr bool ratio_greater_v
	- = ratio_greater<R1, R2>::value;
	- template <class R1, class R2> constexpr bool ratio_greater_equal_v
	- = ratio_greater_equal<R1, R2>::value;
	-
	-} // namespace fundamentals_v1
	-} // namespace experimental
	-} // namespace std
	-
	-*/
	-
	-#include <experimental/__config>
	-
	-#if _LIBCPP_STD_VER > 11
	-
	-#include <ratio>
	-
	-_LIBCPP_BEGIN_NAMESPACE_LFTS
	-
	-#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
	-
	-template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_equal_v
	- = ratio_equal<_R1, _R2>::value;
	-
	-template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_not_equal_v
	- = ratio_not_equal<_R1, _R2>::value;
	-
	-template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_less_v
	- = ratio_less<_R1, _R2>::value;
	-
	-template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_less_equal_v
	- = ratio_less_equal<_R1, _R2>::value;
	-
	-template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_greater_v
	- = ratio_greater<_R1, _R2>::value;
	-
	-template <class _R1, class _R2> _LIBCPP_CONSTEXPR bool ratio_greater_equal_v
	- = ratio_greater_equal<_R1, _R2>::value;
	-
	-#endif /* _LIBCPP_HAS_NO_VARIABLE_TEMPLATES */
	-
	-_LIBCPP_END_NAMESPACE_LFTS
	-
	-#endif /* _LIBCPP_STD_VER > 11 */
	-
	-#endif // _LIBCPP_EXPERIMENTAL_RATIO
	+#error "<experimental/ratio> has been removed. Use <ratio> instead."
	Index: projects/clang700-import/contrib/libc++/include/experimental/simd
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/simd (nonexistent)
	+++ projects/clang700-import/contrib/libc++/include/experimental/simd (revision 337135)
	@@ -0,0 +1,1285 @@
	+// -- C++ --
	+//===------------------------------- simd ---------------------------------===//
	+//
	+// 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_EXPERIMENTAL_SIMD
	+#define _LIBCPP_EXPERIMENTAL_SIMD
	+
	+/*
	+ experimental/simd synopsis
	+
	+namespace std::experimental {
	+
	+inline namespace parallelism_v2 {
	+
	+namespace simd_abi {
	+
	+struct scalar {};
	+template <int N> struct fixed_size {};
	+template <typename T> inline constexpr int max_fixed_size = implementation-defined;
	+template <typename T> using compatible = implementation-defined;
	+template <typename T> using native = implementation-defined;
	+
	+} // simd_abi
	+
	+struct element_aligned_tag {};
	+struct vector_aligned_tag {};
	+template <size_t> struct overaligned_tag {};
	+inline constexpr element_aligned_tag element_aligned{};
	+inline constexpr vector_aligned_tag vector_aligned{};
	+template <size_t N> inline constexpr overaligned_tag<N> overaligned{};
	+
	+// traits [simd.traits]
	+template <class T> struct is_abi_tag;
	+template <class T> inline constexpr bool is_abi_tag_v = is_abi_tag<T>::value;
	+
	+template <class T> struct is_simd;
	+template <class T> inline constexpr bool is_simd_v = is_simd<T>::value;
	+
	+template <class T> struct is_simd_mask;
	+template <class T> inline constexpr bool is_simd_mask_v = is_simd_mask<T>::value;
	+
	+template <class T> struct is_simd_flag_type;
	+template <class T> inline constexpr bool is_simd_flag_type_v = is_simd_flag_type<T>::value;
	+
	+template <class T, size_t N> struct abi_for_size { using type = see below; };
	+template <class T, size_t N> using abi_for_size_t = typename abi_for_size<T, N>::type;
	+
	+template <class T, class Abi = simd_abi::compatible<T>> struct simd_size;
	+template <class T, class Abi = simd_abi::compatible<T>>
	+inline constexpr size_t simd_size_v = simd_size<T, Abi>::value;
	+
	+template <class T, class U = typename T::value_type> struct memory_alignment;
	+template <class T, class U = typename T::value_type>
	+inline constexpr size_t memory_alignment_v = memory_alignment<T, U>::value;
	+
	+// class template simd [simd.class]
	+template <class T, class Abi = simd_abi::compatible<T>> class simd;
	+template <class T> using native_simd = simd<T, simd_abi::native<T>>;
	+template <class T, int N> using fixed_size_simd = simd<T, simd_abi::fixed_size<N>>;
	+
	+// class template simd_mask [simd.mask.class]
	+template <class T, class Abi = simd_abi::compatible<T>> class simd_mask;
	+template <class T> using native_simd_mask = simd_mask<T, simd_abi::native<T>>;
	+template <class T, int N> using fixed_size_simd_mask = simd_mask<T, simd_abi::fixed_size<N>>;
	+
	+// casts [simd.casts]
	+template <class T, class U, class Abi> see below simd_cast(const simd<U, Abi>&);
	+template <class T, class U, class Abi> see below static_simd_cast(const simd<U, Abi>&);
	+
	+template <class T, class Abi>
	+fixed_size_simd<T, simd_size_v<T, Abi>> to_fixed_size(const simd<T, Abi>&) noexcept;
	+template <class T, class Abi>
	+fixed_size_simd_mask<T, simd_size_v<T, Abi>> to_fixed_size(const simd_mask<T, Abi>&) noexcept;
	+template <class T, size_t N> native_simd<T> to_native(const fixed_size_simd<T, N>&) noexcept;
	+template <class T, size_t N>
	+native_simd_mask<T> to_native(const fixed_size_simd_mask<T, N>> &) noexcept;
	+template <class T, size_t N> simd<T> to_compatible(const fixed_size_simd<T, N>&) noexcept;
	+template <class T, size_t N> simd_mask<T> to_compatible(const fixed_size_simd_mask<T, N>&) noexcept;
	+
	+template <size_t... Sizes, class T, class Abi>
	+tuple<simd<T, abi_for_size_t<Sizes>>...> split(const simd<T, Abi>&);
	+template <size_t... Sizes, class T, class Abi>
	+tuple<simd_mask<T, abi_for_size_t<Sizes>>...> split(const simd_mask<T, Abi>&);
	+template <class V, class Abi>
	+array<V, simd_size_v<typename V::value_type, Abi> / V::size()> split(
	+const simd<typename V::value_type, Abi>&);
	+template <class V, class Abi>
	+array<V, simd_size_v<typename V::value_type, Abi> / V::size()> split(
	+const simd_mask<typename V::value_type, Abi>&);
	+
	+template <class T, class... Abis>
	+simd<T, abi_for_size_t<T, (simd_size_v<T, Abis> + ...)>> concat(const simd<T, Abis>&...);
	+template <class T, class... Abis>
	+simd_mask<T, abi_for_size_t<T, (simd_size_v<T, Abis> + ...)>> concat(const simd_mask<T, Abis>&...);
	+
	+// reductions [simd.mask.reductions]
	+template <class T, class Abi> bool all_of(const simd_mask<T, Abi>&) noexcept;
	+template <class T, class Abi> bool any_of(const simd_mask<T, Abi>&) noexcept;
	+template <class T, class Abi> bool none_of(const simd_mask<T, Abi>&) noexcept;
	+template <class T, class Abi> bool some_of(const simd_mask<T, Abi>&) noexcept;
	+template <class T, class Abi> int popcount(const simd_mask<T, Abi>&) noexcept;
	+template <class T, class Abi> int find_first_set(const simd_mask<T, Abi>&);
	+template <class T, class Abi> int find_last_set(const simd_mask<T, Abi>&);
	+
	+bool all_of(see below) noexcept;
	+bool any_of(see below) noexcept;
	+bool none_of(see below) noexcept;
	+bool some_of(see below) noexcept;
	+int popcount(see below) noexcept;
	+int find_first_set(see below) noexcept;
	+int find_last_set(see below) noexcept;
	+
	+// masked assignment [simd.whereexpr]
	+template <class M, class T> class const_where_expression;
	+template <class M, class T> class where_expression;
	+
	+// masked assignment [simd.mask.where]
	+template <class T> struct nodeduce { using type = T; }; // exposition only
	+
	+template <class T> using nodeduce_t = typename nodeduce<T>::type; // exposition only
	+
	+template <class T, class Abi>
	+where_expression<simd_mask<T, Abi>, simd<T, Abi>>
	+where(const typename simd<T, Abi>::mask_type&, simd<T, Abi>&) noexcept;
	+
	+template <class T, class Abi>
	+const_where_expression<simd_mask<T, Abi>, const simd<T, Abi>>
	+where(const typename simd<T, Abi>::mask_type&, const simd<T, Abi>&) noexcept;
	+
	+template <class T, class Abi>
	+where_expression<simd_mask<T, Abi>, simd_mask<T, Abi>>
	+where(const nodeduce_t<simd_mask<T, Abi>>&, simd_mask<T, Abi>&) noexcept;
	+
	+template <class T, class Abi>
	+const_where_expression<simd_mask<T, Abi>, const simd_mask<T, Abi>>
	+where(const nodeduce_t<simd_mask<T, Abi>>&, const simd_mask<T, Abi>&) noexcept;
	+
	+template <class T> where_expression<bool, T> where(see below k, T& d) noexcept;
	+
	+template <class T>
	+const_where_expression<bool, const T> where(see below k, const T& d) noexcept;
	+
	+// reductions [simd.reductions]
	+template <class T, class Abi, class BinaryOperation = std::plus<>>
	+T reduce(const simd<T, Abi>&, BinaryOperation = BinaryOperation());
	+
	+template <class M, class V, class BinaryOperation>
	+typename V::value_type reduce(const const_where_expression<M, V>& x,
	+typename V::value_type neutral_element, BinaryOperation binary_op);
	+
	+template <class M, class V>
	+typename V::value_type reduce(const const_where_expression<M, V>& x, plus<> binary_op = plus<>());
	+
	+template <class M, class V>
	+typename V::value_type reduce(const const_where_expression<M, V>& x, multiplies<> binary_op);
	+
	+template <class M, class V>
	+typename V::value_type reduce(const const_where_expression<M, V>& x, bit_and<> binary_op);
	+
	+template <class M, class V>
	+typename V::value_type reduce(const const_where_expression<M, V>& x, bit_or<> binary_op);
	+
	+template <class M, class V>
	+typename V::value_type reduce(const const_where_expression<M, V>& x, bit_xor<> binary_op);
	+
	+template <class T, class Abi> T hmin(const simd<T, Abi>&);
	+template <class M, class V> T hmin(const const_where_expression<M, V>&);
	+template <class T, class Abi> T hmax(const simd<T, Abi>&);
	+template <class M, class V> T hmax(const const_where_expression<M, V>&);
	+
	+// algorithms [simd.alg]
	+template <class T, class Abi> simd<T, Abi> min(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;
	+
	+template <class T, class Abi> simd<T, Abi> max(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;
	+
	+template <class T, class Abi>
	+std::pair<simd<T, Abi>, simd<T, Abi>> minmax(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;
	+
	+template <class T, class Abi>
	+simd<T, Abi> clamp(const simd<T, Abi>& v, const simd<T, Abi>& lo, const simd<T, Abi>& hi);
	+
	+// [simd.whereexpr]
	+template <class M, class T>
	+class const_where_expression {
	+ const M& mask; // exposition only
	+ T& data; // exposition only
	+public:
	+ const_where_expression(const const_where_expression&) = delete;
	+ const_where_expression& operator=(const const_where_expression&) = delete;
	+ remove_const_t<T> operator-() const &&;
	+ template <class U, class Flags> void copy_to(U* mem, Flags f) const &&;
	+};
	+
	+template <class M, class T>
	+class where_expression : public const_where_expression<M, T> {
	+public:
	+ where_expression(const where_expression&) = delete;
	+ where_expression& operator=(const where_expression&) = delete;
	+ template <class U> void operator=(U&& x);
	+ template <class U> void operator+=(U&& x);
	+ template <class U> void operator-=(U&& x);
	+ template <class U> void operator*=(U&& x);
	+ template <class U> void operator/=(U&& x);
	+ template <class U> void operator%=(U&& x);
	+ template <class U> void operator&=(U&& x);
	+ template <class U> void operator\|=(U&& x);
	+ template <class U> void operator^=(U&& x);
	+ template <class U> void operator<<=(U&& x);
	+ template <class U> void operator>>=(U&& x);
	+ void operator++();
	+ void operator++(int);
	+ void operator--();
	+ void operator--(int);
	+ template <class U, class Flags> void copy_from(const U* mem, Flags);
	+};
	+
	+// [simd.class]
	+template <class T, class Abi> class simd {
	+public:
	+ using value_type = T;
	+ using reference = see below;
	+ using mask_type = simd_mask<T, Abi>;
	+
	+ using abi_type = Abi;
	+ static constexpr size_t size() noexcept;
	+ simd() = default;
	+
	+ // implicit type conversion constructor
	+ template <class U> simd(const simd<U, simd_abi::fixed_size<size()>>&);
	+
	+ // implicit broadcast constructor (see below for constraints)
	+ template <class U> simd(U&& value);
	+
	+ // generator constructor (see below for constraints)
	+ template <class G> explicit simd(G&& gen);
	+
	+ // load constructor
	+ template <class U, class Flags> simd(const U* mem, Flags f);
	+
	+ // loads [simd.load]
	+ template <class U, class Flags> void copy_from(const U* mem, Flags f);
	+
	+ // stores [simd.store]
	+ template <class U, class Flags> void copy_to(U* mem, Flags f) const;
	+
	+ // scalar access [simd.subscr]
	+ reference operator[](size_t);
	+ value_type operator[](size_t) const;
	+
	+ // unary operators [simd.unary]
	+ simd& operator++();
	+ simd operator++(int);
	+ simd& operator--();
	+ simd operator--(int);
	+ mask_type operator!() const;
	+ simd operator~() const; // see below
	+ simd operator+() const;
	+ simd operator-() const;
	+
	+ // binary operators [simd.binary]
	+ friend simd operator+ (const simd&, const simd&);
	+ friend simd operator- (const simd&, const simd&);
	+ friend simd operator* (const simd&, const simd&);
	+ friend simd operator/ (const simd&, const simd&);
	+ friend simd operator% (const simd&, const simd&);
	+ friend simd operator& (const simd&, const simd&);
	+ friend simd operator\| (const simd&, const simd&);
	+ friend simd operator^ (const simd&, const simd&);
	+ friend simd operator<<(const simd&, const simd&);
	+ friend simd operator>>(const simd&, const simd&);
	+ friend simd operator<<(const simd&, int);
	+ friend simd operator>>(const simd&, int);
	+
	+ // compound assignment [simd.cassign]
	+ friend simd& operator+= (simd&, const simd&);
	+ friend simd& operator-= (simd&, const simd&);
	+ friend simd& operator*= (simd&, const simd&);
	+ friend simd& operator/= (simd&, const simd&);
	+ friend simd& operator%= (simd&, const simd&);
	+
	+ friend simd& operator&= (simd&, const simd&);
	+ friend simd& operator\|= (simd&, const simd&);
	+ friend simd& operator^= (simd&, const simd&);
	+ friend simd& operator<<=(simd&, const simd&);
	+ friend simd& operator>>=(simd&, const simd&);
	+ friend simd& operator<<=(simd&, int);
	+ friend simd& operator>>=(simd&, int);
	+
	+ // compares [simd.comparison]
	+ friend mask_type operator==(const simd&, const simd&);
	+ friend mask_type operator!=(const simd&, const simd&);
	+ friend mask_type operator>=(const simd&, const simd&);
	+ friend mask_type operator<=(const simd&, const simd&);
	+ friend mask_type operator> (const simd&, const simd&);
	+ friend mask_type operator< (const simd&, const simd&);
	+};
	+
	+// [simd.math]
	+template <class Abi> using scharv = simd<signed char, Abi>; // exposition only
	+template <class Abi> using shortv = simd<short, Abi>; // exposition only
	+template <class Abi> using intv = simd<int, Abi>; // exposition only
	+template <class Abi> using longv = simd<long int, Abi>; // exposition only
	+template <class Abi> using llongv = simd<long long int, Abi>; // exposition only
	+template <class Abi> using floatv = simd<float, Abi>; // exposition only
	+template <class Abi> using doublev = simd<double, Abi>; // exposition only
	+template <class Abi> using ldoublev = simd<long double, Abi>; // exposition only
	+template <class T, class V> using samesize = fixed_size_simd<T, V::size()>; // exposition only
	+
	+template <class Abi> floatv<Abi> acos(floatv<Abi> x);
	+template <class Abi> doublev<Abi> acos(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> acos(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> asin(floatv<Abi> x);
	+template <class Abi> doublev<Abi> asin(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> asin(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> atan(floatv<Abi> x);
	+template <class Abi> doublev<Abi> atan(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> atan(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> atan2(floatv<Abi> y, floatv<Abi> x);
	+template <class Abi> doublev<Abi> atan2(doublev<Abi> y, doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> atan2(ldoublev<Abi> y, ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> cos(floatv<Abi> x);
	+template <class Abi> doublev<Abi> cos(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> cos(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> sin(floatv<Abi> x);
	+template <class Abi> doublev<Abi> sin(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> sin(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> tan(floatv<Abi> x);
	+template <class Abi> doublev<Abi> tan(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> tan(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> acosh(floatv<Abi> x);
	+template <class Abi> doublev<Abi> acosh(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> acosh(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> asinh(floatv<Abi> x);
	+template <class Abi> doublev<Abi> asinh(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> asinh(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> atanh(floatv<Abi> x);
	+template <class Abi> doublev<Abi> atanh(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> atanh(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> cosh(floatv<Abi> x);
	+template <class Abi> doublev<Abi> cosh(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> cosh(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> sinh(floatv<Abi> x);
	+template <class Abi> doublev<Abi> sinh(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> sinh(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> tanh(floatv<Abi> x);
	+template <class Abi> doublev<Abi> tanh(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> tanh(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> exp(floatv<Abi> x);
	+template <class Abi> doublev<Abi> exp(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> exp(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> exp2(floatv<Abi> x);
	+template <class Abi> doublev<Abi> exp2(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> exp2(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> expm1(floatv<Abi> x);
	+template <class Abi> doublev<Abi> expm1(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> expm1(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> frexp(floatv<Abi> value, samesize<int, floatv<Abi>>* exp);
	+template <class Abi> doublev<Abi> frexp(doublev<Abi> value, samesize<int, doublev<Abi>>* exp);
	+template <class Abi> ldoublev<Abi> frexp(ldoublev<Abi> value, samesize<int, ldoublev<Abi>>* exp);
	+
	+template <class Abi> samesize<int, floatv<Abi>> ilogb(floatv<Abi> x);
	+template <class Abi> samesize<int, doublev<Abi>> ilogb(doublev<Abi> x);
	+template <class Abi> samesize<int, ldoublev<Abi>> ilogb(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> ldexp(floatv<Abi> x, samesize<int, floatv<Abi>> exp);
	+template <class Abi> doublev<Abi> ldexp(doublev<Abi> x, samesize<int, doublev<Abi>> exp);
	+template <class Abi> ldoublev<Abi> ldexp(ldoublev<Abi> x, samesize<int, ldoublev<Abi>> exp);
	+
	+template <class Abi> floatv<Abi> log(floatv<Abi> x);
	+template <class Abi> doublev<Abi> log(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> log(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> log10(floatv<Abi> x);
	+template <class Abi> doublev<Abi> log10(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> log10(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> log1p(floatv<Abi> x);
	+template <class Abi> doublev<Abi> log1p(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> log1p(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> log2(floatv<Abi> x);
	+template <class Abi> doublev<Abi> log2(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> log2(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> logb(floatv<Abi> x);
	+template <class Abi> doublev<Abi> logb(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> logb(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> modf(floatv<Abi> value, floatv<Abi>* iptr);
	+template <class Abi> doublev<Abi> modf(doublev<Abi> value, doublev<Abi>* iptr);
	+template <class Abi> ldoublev<Abi> modf(ldoublev<Abi> value, ldoublev<Abi>* iptr);
	+
	+template <class Abi> floatv<Abi> scalbn(floatv<Abi> x, samesize<int, floatv<Abi>> n);
	+template <class Abi> doublev<Abi> scalbn(doublev<Abi> x, samesize<int, doublev<Abi>> n);
	+template <class Abi> ldoublev<Abi> scalbn(ldoublev<Abi> x, samesize<int, ldoublev<Abi>> n);
	+template <class Abi> floatv<Abi> scalbln(floatv<Abi> x, samesize<long int, floatv<Abi>> n);
	+template <class Abi> doublev<Abi> scalbln(doublev<Abi> x, samesize<long int, doublev<Abi>> n);
	+template <class Abi> ldoublev<Abi> scalbln(ldoublev<Abi> x, samesize<long int, ldoublev<Abi>> n);
	+
	+template <class Abi> floatv<Abi> cbrt(floatv<Abi> x);
	+template <class Abi> doublev<Abi> cbrt(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> cbrt(ldoublev<Abi> x);
	+
	+template <class Abi> scharv<Abi> abs(scharv<Abi> j);
	+template <class Abi> shortv<Abi> abs(shortv<Abi> j);
	+template <class Abi> intv<Abi> abs(intv<Abi> j);
	+template <class Abi> longv<Abi> abs(longv<Abi> j);
	+template <class Abi> llongv<Abi> abs(llongv<Abi> j);
	+template <class Abi> floatv<Abi> abs(floatv<Abi> j);
	+template <class Abi> doublev<Abi> abs(doublev<Abi> j);
	+template <class Abi> ldoublev<Abi> abs(ldoublev<Abi> j);
	+
	+template <class Abi> floatv<Abi> hypot(floatv<Abi> x, floatv<Abi> y);
	+template <class Abi> doublev<Abi> hypot(doublev<Abi> x, doublev<Abi> y);
	+template <class Abi> ldoublev<Abi> hypot(doublev<Abi> x, doublev<Abi> y);
	+template <class Abi> floatv<Abi> hypot(floatv<Abi> x, floatv<Abi> y, floatv<Abi> z);
	+template <class Abi> doublev<Abi> hypot(doublev<Abi> x, doublev<Abi> y, doublev<Abi> z);
	+template <class Abi> ldoublev<Abi> hypot(ldoublev<Abi> x, ldoublev<Abi> y, ldoublev<Abi> z);
	+
	+template <class Abi> floatv<Abi> pow(floatv<Abi> x, floatv<Abi> y);
	+template <class Abi> doublev<Abi> pow(doublev<Abi> x, doublev<Abi> y);
	+template <class Abi> ldoublev<Abi> pow(ldoublev<Abi> x, ldoublev<Abi> y);
	+
	+template <class Abi> floatv<Abi> sqrt(floatv<Abi> x);
	+template <class Abi> doublev<Abi> sqrt(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> sqrt(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> erf(floatv<Abi> x);
	+template <class Abi> doublev<Abi> erf(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> erf(ldoublev<Abi> x);
	+template <class Abi> floatv<Abi> erfc(floatv<Abi> x);
	+template <class Abi> doublev<Abi> erfc(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> erfc(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> lgamma(floatv<Abi> x);
	+template <class Abi> doublev<Abi> lgamma(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> lgamma(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> tgamma(floatv<Abi> x);
	+template <class Abi> doublev<Abi> tgamma(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> tgamma(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> ceil(floatv<Abi> x);
	+template <class Abi> doublev<Abi> ceil(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> ceil(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> floor(floatv<Abi> x);
	+template <class Abi> doublev<Abi> floor(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> floor(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> nearbyint(floatv<Abi> x);
	+template <class Abi> doublev<Abi> nearbyint(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> nearbyint(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> rint(floatv<Abi> x);
	+template <class Abi> doublev<Abi> rint(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> rint(ldoublev<Abi> x);
	+
	+template <class Abi> samesize<long int, floatv<Abi>> lrint(floatv<Abi> x);
	+template <class Abi> samesize<long int, doublev<Abi>> lrint(doublev<Abi> x);
	+template <class Abi> samesize<long int, ldoublev<Abi>> lrint(ldoublev<Abi> x);
	+template <class Abi> samesize<long long int, floatv<Abi>> llrint(floatv<Abi> x);
	+template <class Abi> samesize<long long int, doublev<Abi>> llrint(doublev<Abi> x);
	+template <class Abi> samesize<long long int, ldoublev<Abi>> llrint(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> round(floatv<Abi> x);
	+template <class Abi> doublev<Abi> round(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> round(ldoublev<Abi> x);
	+template <class Abi> samesize<long int, floatv<Abi>> lround(floatv<Abi> x);
	+template <class Abi> samesize<long int, doublev<Abi>> lround(doublev<Abi> x);
	+template <class Abi> samesize<long int, ldoublev<Abi>> lround(ldoublev<Abi> x);
	+template <class Abi> samesize<long long int, floatv<Abi>> llround(floatv<Abi> x);
	+template <class Abi> samesize<long long int, doublev<Abi>> llround(doublev<Abi> x);
	+template <class Abi> samesize<long long int, ldoublev<Abi>> llround(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> trunc(floatv<Abi> x);
	+template <class Abi> doublev<Abi> trunc(doublev<Abi> x);
	+template <class Abi> ldoublev<Abi> trunc(ldoublev<Abi> x);
	+
	+template <class Abi> floatv<Abi> fmod(floatv<Abi> x, floatv<Abi> y);
	+template <class Abi> doublev<Abi> fmod(doublev<Abi> x, doublev<Abi> y);
	+template <class Abi> ldoublev<Abi> fmod(ldoublev<Abi> x, ldoublev<Abi> y);
	+
	+template <class Abi> floatv<Abi> remainder(floatv<Abi> x, floatv<Abi> y);
	+template <class Abi> doublev<Abi> remainder(doublev<Abi> x, doublev<Abi> y);
	+template <class Abi> ldoublev<Abi> remainder(ldoublev<Abi> x, ldoublev<Abi> y);
	+
	+template <class Abi> floatv<Abi> remquo(floatv<Abi> x, floatv<Abi> y, samesize<int, floatv<Abi>>* quo);
	+template <class Abi> doublev<Abi> remquo(doublev<Abi> x, doublev<Abi> y, samesize<int, doublev<Abi>>* quo);
	+template <class Abi> ldoublev<Abi> remquo(ldoublev<Abi> x, ldoublev<Abi> y, samesize<int, ldoublev<Abi>>* quo);
	+
	+template <class Abi> floatv<Abi> copysign(floatv<Abi> x, floatv<Abi> y);
	+template <class Abi> doublev<Abi> copysign(doublev<Abi> x, doublev<Abi> y);
	+template <class Abi> ldoublev<Abi> copysign(ldoublev<Abi> x, ldoublev<Abi> y);
	+
	+template <class Abi> doublev<Abi> nan(const char* tagp);
	+template <class Abi> floatv<Abi> nanf(const char* tagp);
	+template <class Abi> ldoublev<Abi> nanl(const char* tagp);
	+
	+template <class Abi> floatv<Abi> nextafter(floatv<Abi> x, floatv<Abi> y);
	+template <class Abi> doublev<Abi> nextafter(doublev<Abi> x, doublev<Abi> y);
	+template <class Abi> ldoublev<Abi> nextafter(ldoublev<Abi> x, ldoublev<Abi> y);
	+
	+template <class Abi> floatv<Abi> nexttoward(floatv<Abi> x, ldoublev<Abi> y);
	+template <class Abi> doublev<Abi> nexttoward(doublev<Abi> x, ldoublev<Abi> y);
	+template <class Abi> ldoublev<Abi> nexttoward(ldoublev<Abi> x, ldoublev<Abi> y);
	+
	+template <class Abi> floatv<Abi> fdim(floatv<Abi> x, floatv<Abi> y);
	+template <class Abi> doublev<Abi> fdim(doublev<Abi> x, doublev<Abi> y);
	+template <class Abi> ldoublev<Abi> fdim(ldoublev<Abi> x, ldoublev<Abi> y);
	+
	+template <class Abi> floatv<Abi> fmax(floatv<Abi> x, floatv<Abi> y);
	+template <class Abi> doublev<Abi> fmax(doublev<Abi> x, doublev<Abi> y);
	+template <class Abi> ldoublev<Abi> fmax(ldoublev<Abi> x, ldoublev<Abi> y);
	+
	+template <class Abi> floatv<Abi> fmin(floatv<Abi> x, floatv<Abi> y);
	+template <class Abi> doublev<Abi> fmin(doublev<Abi> x, doublev<Abi> y);
	+template <class Abi> ldoublev<Abi> fmin(ldoublev<Abi> x, ldoublev<Abi> y);
	+
	+template <class Abi> floatv<Abi> fma(floatv<Abi> x, floatv<Abi> y, floatv<Abi> z);
	+template <class Abi> doublev<Abi> fma(doublev<Abi> x, doublev<Abi> y, doublev<Abi> z);
	+template <class Abi> ldoublev<Abi> fma(ldoublev<Abi> x, ldoublev<Abi> y, ldoublev<Abi> z);
	+
	+template <class Abi> samesize<int, floatv<Abi>> fpclassify(floatv<Abi> x);
	+template <class Abi> samesize<int, doublev<Abi>> fpclassify(doublev<Abi> x);
	+template <class Abi> samesize<int, ldoublev<Abi>> fpclassify(ldoublev<Abi> x);
	+
	+template <class Abi> simd_mask<float, Abi> isfinite(floatv<Abi> x);
	+template <class Abi> simd_mask<double, Abi> isfinite(doublev<Abi> x);
	+template <class Abi> simd_mask<long double, Abi> isfinite(ldoublev<Abi> x);
	+
	+template <class Abi> simd_mask<float, Abi> isinf(floatv<Abi> x);
	+template <class Abi> simd_mask<double, Abi> isinf(doublev<Abi> x);
	+template <class Abi> simd_mask<long double, Abi> isinf(ldoublev<Abi> x);
	+
	+template <class Abi> simd_mask<float, Abi> isnan(floatv<Abi> x);
	+template <class Abi> simd_mask<double, Abi> isnan(doublev<Abi> x);
	+template <class Abi> simd_mask<long double, Abi> isnan(ldoublev<Abi> x);
	+
	+template <class Abi> simd_mask<float, Abi> isnormal(floatv<Abi> x);
	+template <class Abi> simd_mask<double, Abi> isnormal(doublev<Abi> x);
	+template <class Abi> simd_mask<long double, Abi> isnormal(ldoublev<Abi> x);
	+
	+template <class Abi> simd_mask<float, Abi> signbit(floatv<Abi> x);
	+template <class Abi> simd_mask<double, Abi> signbit(doublev<Abi> x);
	+template <class Abi> simd_mask<long double, Abi> signbit(ldoublev<Abi> x);
	+
	+template <class Abi> simd_mask<float, Abi> isgreater(floatv<Abi> x, floatv<Abi> y);
	+template <class Abi> simd_mask<double, Abi> isgreater(doublev<Abi> x, doublev<Abi> y);
	+template <class Abi> simd_mask<long double, Abi> isgreater(ldoublev<Abi> x, ldoublev<Abi> y);
	+
	+template <class Abi> simd_mask<float, Abi> isgreaterequal(floatv<Abi> x, floatv<Abi> y);
	+template <class Abi> simd_mask<double, Abi> isgreaterequal(doublev<Abi> x, doublev<Abi> y);
	+template <class Abi> simd_mask<long double, Abi> isgreaterequal(ldoublev<Abi> x, ldoublev<Abi> y);
	+
	+template <class Abi> simd_mask<float, Abi> isless(floatv<Abi> x, floatv<Abi> y);
	+template <class Abi> simd_mask<double, Abi> isless(doublev<Abi> x, doublev<Abi> y);
	+template <class Abi> simd_mask<long double, Abi> isless(ldoublev<Abi> x, ldoublev<Abi> y);
	+
	+template <class Abi> simd_mask<float, Abi> islessequal(floatv<Abi> x, floatv<Abi> y);
	+template <class Abi> simd_mask<double, Abi> islessequal(doublev<Abi> x, doublev<Abi> y);
	+template <class Abi> simd_mask<long double, Abi> islessequal(ldoublev<Abi> x, ldoublev<Abi> y);
	+
	+template <class Abi> simd_mask<float, Abi> islessgreater(floatv<Abi> x, floatv<Abi> y);
	+template <class Abi> simd_mask<double, Abi> islessgreater(doublev<Abi> x, doublev<Abi> y);
	+template <class Abi> simd_mask<long double, Abi> islessgreater(ldoublev<Abi> x, ldoublev<Abi> y);
	+
	+template <class Abi> simd_mask<float, Abi> isunordered(floatv<Abi> x, floatv<Abi> y);
	+template <class Abi> simd_mask<double, Abi> isunordered(doublev<Abi> x, doublev<Abi> y);
	+template <class Abi> simd_mask<long double, Abi> isunordered(ldoublev<Abi> x, ldoublev<Abi> y);
	+
	+template <class V> struct simd_div_t { V quot, rem; };
	+template <class Abi> simd_div_t<scharv<Abi>> div(scharv<Abi> numer, scharv<Abi> denom);
	+template <class Abi> simd_div_t<shortv<Abi>> div(shortv<Abi> numer, shortv<Abi> denom);
	+template <class Abi> simd_div_t<intv<Abi>> div(intv<Abi> numer, intv<Abi> denom);
	+template <class Abi> simd_div_t<longv<Abi>> div(longv<Abi> numer, longv<Abi> denom);
	+template <class Abi> simd_div_t<llongv<Abi>> div(llongv<Abi> numer, llongv<Abi> denom);
	+
	+// [simd.mask.class]
	+template <class T, class Abi>
	+class simd_mask {
	+public:
	+ using value_type = bool;
	+ using reference = see below;
	+ using simd_type = simd<T, Abi>;
	+ using abi_type = Abi;
	+ static constexpr size_t size() noexcept;
	+ simd_mask() = default;
	+
	+ // broadcast constructor
	+ explicit simd_mask(value_type) noexcept;
	+
	+ // implicit type conversion constructor
	+ template <class U> simd_mask(const simd_mask<U, simd_abi::fixed_size<size()>>&) noexcept;
	+
	+ // load constructor
	+ template <class Flags> simd_mask(const value_type* mem, Flags);
	+
	+ // loads [simd.mask.copy]
	+ template <class Flags> void copy_from(const value_type* mem, Flags);
	+ template <class Flags> void copy_to(value_type* mem, Flags) const;
	+
	+ // scalar access [simd.mask.subscr]
	+ reference operator[](size_t);
	+ value_type operator[](size_t) const;
	+
	+ // unary operators [simd.mask.unary]
	+ simd_mask operator!() const noexcept;
	+
	+ // simd_mask binary operators [simd.mask.binary]
	+ friend simd_mask operator&&(const simd_mask&, const simd_mask&) noexcept;
	+ friend simd_mask operator\|\|(const simd_mask&, const simd_mask&) noexcept;
	+ friend simd_mask operator& (const simd_mask&, const simd_mask&) noexcept;
	+ friend simd_mask operator\| (const simd_mask&, const simd_mask&) noexcept;
	+ friend simd_mask operator^ (const simd_mask&, const simd_mask&) noexcept;
	+
	+ // simd_mask compound assignment [simd.mask.cassign]
	+ friend simd_mask& operator&=(simd_mask&, const simd_mask&) noexcept;
	+ friend simd_mask& operator\|=(simd_mask&, const simd_mask&) noexcept;
	+ friend simd_mask& operator^=(simd_mask&, const simd_mask&) noexcept;
	+
	+ // simd_mask compares [simd.mask.comparison]
	+ friend simd_mask operator==(const simd_mask&, const simd_mask&) noexcept;
	+ friend simd_mask operator!=(const simd_mask&, const simd_mask&) noexcept;
	+};
	+
	+} // parallelism_v2
	+} // std::experimental
	+
	+*/
	+
	+#include <experimental/__config>
	+#include <array>
	+#include <cstddef>
	+#include <functional>
	+
	+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	+#pragma GCC system_header
	+#endif
	+
	+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
	+
	+enum class _StorageKind {
	+ _Scalar,
	+ _Array,
	+};
	+
	+template <_StorageKind __kind, int _Np>
	+struct __simd_abi {};
	+
	+template <class _Tp, class _Abi>
	+struct __simd_storage_traits {};
	+
	+template <class _Tp, int __num_element>
	+struct __simd_storage_traits<_Tp,
	+ __simd_abi<_StorageKind::_Array, __num_element>> {
	+ using type = std::array<_Tp, __num_element>;
	+};
	+
	+template <class _Tp>
	+struct __simd_storage_traits<_Tp, __simd_abi<_StorageKind::_Scalar, 1>> {
	+ using type = _Tp;
	+};
	+
	+template <class _To, class _From>
	+constexpr decltype(_To{std::declval<_From>()}, true)
	+__is_non_narrowing_convertible_impl(_From) {
	+ return true;
	+}
	+
	+template <class _To>
	+constexpr bool __is_non_narrowing_convertible_impl(...) {
	+ return false;
	+}
	+
	+template <class _From, class _To>
	+constexpr typename std::enable_if<std::is_arithmetic<_To>::value &&
	+ std::is_arithmetic<_From>::value,
	+ bool>::type
	+__is_non_narrowing_arithmetic_convertible() {
	+ return __is_non_narrowing_convertible_impl<_To>(_From{});
	+}
	+
	+template <class _From, class _To>
	+constexpr typename std::enable_if<!(std::is_arithmetic<_To>::value &&
	+ std::is_arithmetic<_From>::value),
	+ bool>::type
	+__is_non_narrowing_arithmetic_convertible() {
	+ return false;
	+}
	+
	+template <class _Tp>
	+constexpr _Tp __variadic_sum() {
	+ return _Tp{};
	+}
	+
	+template <class _Tp, class _Up, class... _Args>
	+constexpr _Tp __variadic_sum(_Up __first, _Args... __rest) {
	+ return static_cast<_Tp>(__first) + __variadic_sum<_Tp>(__rest...);
	+}
	+
	+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
	+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI
	+
	+using scalar = __simd_abi<_StorageKind::_Scalar, 1>;
	+
	+template <int _Np>
	+using fixed_size = __simd_abi<_StorageKind::_Array, _Np>;
	+
	+#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	+template <class _Tp>
	+_LIBCPP_INLINE_VAR constexpr int max_fixed_size = 32;
	+#endif
	+template <class _Tp>
	+using compatible = fixed_size<16 / sizeof(_Tp)>;
	+template <class _Tp>
	+using native = compatible<_Tp>;
	+
	+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI
	+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
	+
	+template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
	+class simd;
	+template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
	+class simd_mask;
	+
	+struct element_aligned_tag {};
	+struct vector_aligned_tag {};
	+template <size_t>
	+struct overaligned_tag {};
	+#if _LIBCPP_STD_VER > 14
	+_LIBCPP_INLINE_VAR constexpr element_aligned_tag element_aligned{};
	+_LIBCPP_INLINE_VAR constexpr vector_aligned_tag vector_aligned{};
	+#if !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	+template <size_t _Np>
	+_LIBCPP_INLINE_VAR constexpr overaligned_tag<_Np> overaligned{};
	+#endif
	+#endif
	+
	+// traits [simd.traits]
	+template <class _Tp>
	+struct is_abi_tag : std::integral_constant<bool, false> {};
	+
	+template <_StorageKind __kind, int _Np>
	+struct is_abi_tag<__simd_abi<__kind, _Np>>
	+ : std::integral_constant<bool, true> {};
	+
	+template <class _Tp>
	+struct is_simd : std::integral_constant<bool, false> {};
	+
	+template <class _Tp, class _Abi>
	+struct is_simd<simd<_Tp, _Abi>> : std::integral_constant<bool, true> {};
	+
	+template <class _Tp>
	+struct is_simd_mask : std::integral_constant<bool, false> {};
	+
	+template <class _Tp, class _Abi>
	+struct is_simd_mask<simd_mask<_Tp, _Abi>> : std::integral_constant<bool, true> {
	+};
	+
	+template <class _Tp>
	+struct is_simd_flag_type : std::integral_constant<bool, false> {};
	+
	+template <>
	+struct is_simd_flag_type<element_aligned_tag>
	+ : std::integral_constant<bool, true> {};
	+
	+template <>
	+struct is_simd_flag_type<vector_aligned_tag>
	+ : std::integral_constant<bool, true> {};
	+
	+template <size_t _Align>
	+struct is_simd_flag_type<overaligned_tag<_Align>>
	+ : std::integral_constant<bool, true> {};
	+
	+#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	+template <class _Tp>
	+_LIBCPP_INLINE_VAR constexpr bool is_abi_tag_v = is_abi_tag<_Tp>::value;
	+template <class _Tp>
	+_LIBCPP_INLINE_VAR constexpr bool is_simd_v = is_simd<_Tp>::value;
	+template <class _Tp>
	+_LIBCPP_INLINE_VAR constexpr bool is_simd_mask_v = is_simd_mask<_Tp>::value;
	+template <class _Tp>
	+_LIBCPP_INLINE_VAR constexpr bool is_simd_flag_type_v =
	+ is_simd_flag_type<_Tp>::value;
	+#endif
	+template <class _Tp, size_t _Np>
	+struct abi_for_size {
	+ using type = simd_abi::fixed_size<_Np>;
	+};
	+template <class _Tp, size_t _Np>
	+using abi_for_size_t = typename abi_for_size<_Tp, _Np>::type;
	+
	+template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
	+struct simd_size;
	+
	+template <class _Tp, _StorageKind __kind, int _Np>
	+struct simd_size<_Tp, __simd_abi<__kind, _Np>>
	+ : std::integral_constant<size_t, _Np> {
	+ static_assert(
	+ std::is_arithmetic<_Tp>::value &&
	+ !std::is_same<typename std::remove_const<_Tp>::type, bool>::value,
	+ "Element type should be vectorizable");
	+};
	+
	+template <class _Tp, class _Up = typename _Tp::value_type>
	+struct memory_alignment;
	+
	+#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	+template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
	+_LIBCPP_INLINE_VAR constexpr size_t simd_size_v = simd_size<_Tp, _Abi>::value;
	+
	+template <class _Tp, class _Up = typename _Tp::value_type>
	+_LIBCPP_INLINE_VAR constexpr size_t memory_alignment_v =
	+ memory_alignment<_Tp, _Up>::value;
	+#endif
	+
	+// class template simd [simd.class]
	+template <class _Tp>
	+using native_simd = simd<_Tp, simd_abi::native<_Tp>>;
	+template <class _Tp, int _Np>
	+using fixed_size_simd = simd<_Tp, simd_abi::fixed_size<_Np>>;
	+
	+// class template simd_mask [simd.mask.class]
	+template <class _Tp>
	+using native_simd_mask = simd_mask<_Tp, simd_abi::native<_Tp>>;
	+
	+template <class _Tp, int _Np>
	+using fixed_size_simd_mask = simd_mask<_Tp, simd_abi::fixed_size<_Np>>;
	+
	+// casts [simd.casts]
	+template <class _Tp>
	+struct __static_simd_cast_traits {
	+ template <class _Up, class _Abi>
	+ static simd<_Tp, _Abi> __apply(const simd<_Up, _Abi>& __v);
	+};
	+
	+template <class _Tp, class _NewAbi>
	+struct __static_simd_cast_traits<simd<_Tp, _NewAbi>> {
	+ template <class _Up, class _Abi>
	+ static typename std::enable_if<simd<_Up, _Abi>::size() ==
	+ simd<_Tp, _NewAbi>::size(),
	+ simd<_Tp, _NewAbi>>::type
	+ __apply(const simd<_Up, _Abi>& __v);
	+};
	+
	+template <class _Tp>
	+struct __simd_cast_traits {
	+ template <class _Up, class _Abi>
	+ static typename std::enable_if<
	+ __is_non_narrowing_arithmetic_convertible<_Up, _Tp>(),
	+ simd<_Tp, _Abi>>::type
	+ __apply(const simd<_Up, _Abi>& __v);
	+};
	+
	+template <class _Tp, class _NewAbi>
	+struct __simd_cast_traits<simd<_Tp, _NewAbi>> {
	+ template <class _Up, class _Abi>
	+ static typename std::enable_if<
	+ __is_non_narrowing_arithmetic_convertible<_Up, _Tp>() &&
	+ simd<_Up, _Abi>::size() == simd<_Tp, _NewAbi>::size(),
	+ simd<_Tp, _NewAbi>>::type
	+ __apply(const simd<_Up, _Abi>& __v);
	+};
	+
	+template <class _Tp, class _Up, class _Abi>
	+auto simd_cast(const simd<_Up, _Abi>& __v)
	+ -> decltype(__simd_cast_traits<_Tp>::__apply(__v)) {
	+ return __simd_cast_traits<_Tp>::__apply(__v);
	+}
	+
	+template <class _Tp, class _Up, class _Abi>
	+auto static_simd_cast(const simd<_Up, _Abi>& __v)
	+ -> decltype(__static_simd_cast_traits<_Tp>::__apply(__v)) {
	+ return __static_simd_cast_traits<_Tp>::__apply(__v);
	+}
	+
	+template <class _Tp, class _Abi>
	+fixed_size_simd<_Tp, simd_size<_Tp, _Abi>::value>
	+to_fixed_size(const simd<_Tp, _Abi>&) noexcept;
	+
	+template <class _Tp, class _Abi>
	+fixed_size_simd_mask<_Tp, simd_size<_Tp, _Abi>::value>
	+to_fixed_size(const simd_mask<_Tp, _Abi>&) noexcept;
	+
	+template <class _Tp, size_t _Np>
	+native_simd<_Tp> to_native(const fixed_size_simd<_Tp, _Np>&) noexcept;
	+
	+template <class _Tp, size_t _Np>
	+native_simd_mask<_Tp> to_native(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;
	+
	+template <class _Tp, size_t _Np>
	+simd<_Tp> to_compatible(const fixed_size_simd<_Tp, _Np>&) noexcept;
	+
	+template <class _Tp, size_t _Np>
	+simd_mask<_Tp> to_compatible(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;
	+
	+template <size_t... __sizes, class _Tp, class _Abi>
	+tuple<simd<_Tp, abi_for_size_t<_Tp, __sizes>>...> split(const simd<_Tp, _Abi>&);
	+
	+template <size_t... __sizes, class _Tp, class _Abi>
	+tuple<simd_mask<_Tp, abi_for_size_t<_Tp, __sizes>>...>
	+split(const simd_mask<_Tp, _Abi>&);
	+
	+template <class _SimdType, class _Abi>
	+array<_SimdType, simd_size<typename _SimdType::value_type, _Abi>::value /
	+ _SimdType::size()>
	+split(const simd<typename _SimdType::value_type, _Abi>&);
	+
	+template <class _SimdType, class _Abi>
	+array<_SimdType, simd_size<typename _SimdType::value_type, _Abi>::value /
	+ _SimdType::size()>
	+split(const simd_mask<typename _SimdType::value_type, _Abi>&);
	+
	+template <class _Tp, class... _Abis>
	+simd<_Tp, abi_for_size_t<_Tp, __variadic_sum(simd_size<_Tp, _Abis>::value...)>>
	+concat(const simd<_Tp, _Abis>&...);
	+
	+template <class _Tp, class... _Abis>
	+simd_mask<_Tp,
	+ abi_for_size_t<_Tp, __variadic_sum(simd_size<_Tp, _Abis>::value...)>>
	+concat(const simd_mask<_Tp, _Abis>&...);
	+
	+// reductions [simd.mask.reductions]
	+template <class _Tp, class _Abi>
	+bool all_of(const simd_mask<_Tp, _Abi>&) noexcept;
	+template <class _Tp, class _Abi>
	+bool any_of(const simd_mask<_Tp, _Abi>&) noexcept;
	+template <class _Tp, class _Abi>
	+bool none_of(const simd_mask<_Tp, _Abi>&) noexcept;
	+template <class _Tp, class _Abi>
	+bool some_of(const simd_mask<_Tp, _Abi>&) noexcept;
	+template <class _Tp, class _Abi>
	+int popcount(const simd_mask<_Tp, _Abi>&) noexcept;
	+template <class _Tp, class _Abi>
	+int find_first_set(const simd_mask<_Tp, _Abi>&);
	+template <class _Tp, class _Abi>
	+int find_last_set(const simd_mask<_Tp, _Abi>&);
	+bool all_of(bool) noexcept;
	+bool any_of(bool) noexcept;
	+bool none_of(bool) noexcept;
	+bool some_of(bool) noexcept;
	+int popcount(bool) noexcept;
	+int find_first_set(bool) noexcept;
	+int find_last_set(bool) noexcept;
	+
	+// masked assignment [simd.whereexpr]
	+template <class _MaskType, class _Tp>
	+class const_where_expression;
	+template <class _MaskType, class _Tp>
	+class where_expression;
	+
	+// masked assignment [simd.mask.where]
	+template <class _Tp>
	+struct __nodeduce {
	+ using type = _Tp;
	+};
	+
	+template <class _Tp, class _Abi>
	+where_expression<simd_mask<_Tp, _Abi>, simd<_Tp, _Abi>>
	+where(const typename simd<_Tp, _Abi>::mask_type&, simd<_Tp, _Abi>&) noexcept;
	+
	+template <class _Tp, class _Abi>
	+const_where_expression<simd_mask<_Tp, _Abi>, const simd<_Tp, _Abi>>
	+where(const typename simd<_Tp, _Abi>::mask_type&,
	+ const simd<_Tp, _Abi>&) noexcept;
	+
	+template <class _Tp, class _Abi>
	+where_expression<simd_mask<_Tp, _Abi>, simd_mask<_Tp, _Abi>>
	+where(const typename __nodeduce<simd_mask<_Tp, _Abi>>::type&,
	+ simd_mask<_Tp, _Abi>&) noexcept;
	+
	+template <class _Tp, class _Abi>
	+const_where_expression<simd_mask<_Tp, _Abi>, const simd_mask<_Tp, _Abi>>
	+where(const typename __nodeduce<simd_mask<_Tp, _Abi>>::type&,
	+ const simd_mask<_Tp, _Abi>&) noexcept;
	+
	+template <class _Tp>
	+where_expression<bool, _Tp> where(bool, _Tp&) noexcept;
	+
	+template <class _Tp>
	+const_where_expression<bool, const _Tp> where(bool, const _Tp&) noexcept;
	+
	+// reductions [simd.reductions]
	+template <class _Tp, class _Abi, class _BinaryOp = std::plus<_Tp>>
	+_Tp reduce(const simd<_Tp, _Abi>&, _BinaryOp = _BinaryOp());
	+
	+template <class _MaskType, class _SimdType, class _BinaryOp>
	+typename _SimdType::value_type
	+reduce(const const_where_expression<_MaskType, _SimdType>&,
	+ typename _SimdType::value_type neutral_element, _BinaryOp binary_op);
	+
	+template <class _MaskType, class _SimdType>
	+typename _SimdType::value_type
	+reduce(const const_where_expression<_MaskType, _SimdType>&,
	+ plus<typename _SimdType::value_type> binary_op = {});
	+
	+template <class _MaskType, class _SimdType>
	+typename _SimdType::value_type
	+reduce(const const_where_expression<_MaskType, _SimdType>&,
	+ multiplies<typename _SimdType::value_type> binary_op);
	+
	+template <class _MaskType, class _SimdType>
	+typename _SimdType::value_type
	+reduce(const const_where_expression<_MaskType, _SimdType>&,
	+ bit_and<typename _SimdType::value_type> binary_op);
	+
	+template <class _MaskType, class _SimdType>
	+typename _SimdType::value_type
	+reduce(const const_where_expression<_MaskType, _SimdType>&,
	+ bit_or<typename _SimdType::value_type> binary_op);
	+
	+template <class _MaskType, class _SimdType>
	+typename _SimdType::value_type
	+reduce(const const_where_expression<_MaskType, _SimdType>&,
	+ bit_xor<typename _SimdType::value_type> binary_op);
	+
	+template <class _Tp, class _Abi>
	+_Tp hmin(const simd<_Tp, _Abi>&);
	+template <class _MaskType, class _SimdType>
	+typename _SimdType::value_type
	+hmin(const const_where_expression<_MaskType, _SimdType>&);
	+template <class _Tp, class _Abi>
	+_Tp hmax(const simd<_Tp, _Abi>&);
	+template <class _MaskType, class _SimdType>
	+typename _SimdType::value_type
	+hmax(const const_where_expression<_MaskType, _SimdType>&);
	+
	+// algorithms [simd.alg]
	+template <class _Tp, class _Abi>
	+simd<_Tp, _Abi> min(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept;
	+
	+template <class _Tp, class _Abi>
	+simd<_Tp, _Abi> max(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept;
	+
	+template <class _Tp, class _Abi>
	+std::pair<simd<_Tp, _Abi>, simd<_Tp, _Abi>>
	+minmax(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept;
	+
	+template <class _Tp, class _Abi>
	+simd<_Tp, _Abi> clamp(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&,
	+ const simd<_Tp, _Abi>&);
	+
	+// [simd.whereexpr]
	+// TODO implement where expressions.
	+template <class _MaskType, class _Tp>
	+class const_where_expression {
	+public:
	+ const_where_expression(const const_where_expression&) = delete;
	+ const_where_expression& operator=(const const_where_expression&) = delete;
	+ typename remove_const<_Tp>::type operator-() const&&;
	+ template <class _Up, class _Flags>
	+ void copy_to(_Up*, _Flags) const&&;
	+};
	+
	+template <class _MaskType, class _Tp>
	+class where_expression : public const_where_expression<_MaskType, _Tp> {
	+public:
	+ where_expression(const where_expression&) = delete;
	+ where_expression& operator=(const where_expression&) = delete;
	+ template <class _Up>
	+ void operator=(_Up&&);
	+ template <class _Up>
	+ void operator+=(_Up&&);
	+ template <class _Up>
	+ void operator-=(_Up&&);
	+ template <class _Up>
	+ void operator*=(_Up&&);
	+ template <class _Up>
	+ void operator/=(_Up&&);
	+ template <class _Up>
	+ void operator%=(_Up&&);
	+ template <class _Up>
	+ void operator&=(_Up&&);
	+ template <class _Up>
	+ void operator\|=(_Up&&);
	+ template <class _Up>
	+ void operator^=(_Up&&);
	+ template <class _Up>
	+ void operator<<=(_Up&&);
	+ template <class _Up>
	+ void operator>>=(_Up&&);
	+ void operator++();
	+ void operator++(int);
	+ void operator--();
	+ void operator--(int);
	+ template <class _Up, class _Flags>
	+ void copy_from(const _Up*, _Flags);
	+};
	+
	+// [simd.class]
	+// TODO: implement simd
	+template <class _Tp, class _Abi>
	+class simd {
	+private:
	+ template <class _Up>
	+ static constexpr bool __can_broadcast() {
	+ return (std::is_arithmetic<_Up>::value &&
	+ __is_non_narrowing_arithmetic_convertible<_Up, _Tp>()) \|\|
	+ (!std::is_arithmetic<_Up>::value &&
	+ std::is_convertible<_Up, _Tp>::value) \|\|
	+ std::is_same<typename std::remove_const<_Up>::type, int>::value \|\|
	+ (std::is_same<typename std::remove_const<_Up>::type,
	+ unsigned int>::value &&
	+ std::is_unsigned<_Tp>::value);
	+ }
	+
	+public:
	+ using value_type = _Tp;
	+ // TODO: this is strawman implementation. Turn it into a proxy type.
	+ using reference = _Tp&;
	+ using mask_type = simd_mask<_Tp, _Abi>;
	+
	+ using abi_type = _Abi;
	+
	+ static constexpr size_t size() noexcept {
	+ return simd_size<_Tp, _Abi>::value;
	+ }
	+
	+ simd() = default;
	+
	+ // implicit type conversion constructor
	+ template <class _Up,
	+ class = typename std::enable_if<
	+ std::is_same<_Abi, simd_abi::fixed_size<size()>>::value &&
	+ __is_non_narrowing_arithmetic_convertible<_Up, _Tp>()>::type>
	+ simd(const simd<_Up, simd_abi::fixed_size<size()>>&) {}
	+
	+ // implicit broadcast constructor
	+ template <class _Up,
	+ class = typename std::enable_if<__can_broadcast<_Up>()>::type>
	+ simd(_Up&&);
	+
	+ // generator constructor
	+ // TODO: for now only check for the index 0. This is because C++11 doesn't
	+ // have index_sequence, and it's hard to check for all indicies without using
	+ // index_sequence.
	+ template <class _Generator,
	+ int = decltype(simd(std::declval<_Generator>()(
	+ std::integral_constant<size_t, 0>())),
	+ int())()>
	+ explicit simd(_Generator&&);
	+
	+ // load constructor
	+ template <class _Up, class _Flags>
	+ simd(const _Up*, _Flags);
	+
	+ // loads [simd.load]
	+ template <class _Up, class _Flags>
	+ void copy_from(const _Up*, _Flags);
	+
	+ // stores [simd.store]
	+ template <class _Up, class _Flags>
	+ void copy_to(_Up*, _Flags) const;
	+
	+ // scalar access [simd.subscr]
	+ reference operator[](size_t);
	+ value_type operator[](size_t) const;
	+
	+ // unary operators [simd.unary]
	+ simd& operator++();
	+ simd operator++(int);
	+ simd& operator--();
	+ simd operator--(int);
	+ mask_type operator!() const;
	+ simd operator~() const;
	+ simd operator+() const;
	+ simd operator-() const;
	+
	+ // binary operators [simd.binary]
	+ friend simd operator+(const simd&, const simd&);
	+ friend simd operator-(const simd&, const simd&);
	+ friend simd operator*(const simd&, const simd&);
	+ friend simd operator/(const simd&, const simd&);
	+ friend simd operator%(const simd&, const simd&);
	+ friend simd operator&(const simd&, const simd&);
	+ friend simd operator\|(const simd&, const simd&);
	+ friend simd operator^(const simd&, const simd&);
	+ friend simd operator<<(const simd&, const simd&);
	+ friend simd operator>>(const simd&, const simd&);
	+ friend simd operator<<(const simd&, int);
	+ friend simd operator>>(const simd&, int);
	+
	+ // compound assignment [simd.cassign]
	+ friend simd& operator+=(simd&, const simd&);
	+ friend simd& operator-=(simd&, const simd&);
	+ friend simd& operator*=(simd&, const simd&);
	+ friend simd& operator/=(simd&, const simd&);
	+ friend simd& operator%=(simd&, const simd&);
	+
	+ friend simd& operator&=(simd&, const simd&);
	+ friend simd& operator\|=(simd&, const simd&);
	+ friend simd& operator^=(simd&, const simd&);
	+ friend simd& operator<<=(simd&, const simd&);
	+ friend simd& operator>>=(simd&, const simd&);
	+ friend simd& operator<<=(simd&, int);
	+ friend simd& operator>>=(simd&, int);
	+
	+ // compares [simd.comparison]
	+ friend mask_type operator==(const simd&, const simd&);
	+ friend mask_type operator!=(const simd&, const simd&);
	+ friend mask_type operator>=(const simd&, const simd&);
	+ friend mask_type operator<=(const simd&, const simd&);
	+ friend mask_type operator>(const simd&, const simd&);
	+ friend mask_type operator<(const simd&, const simd&);
	+};
	+
	+// [simd.mask.class]
	+template <class _Tp, class _Abi>
	+// TODO: implement simd_mask
	+class simd_mask {
	+public:
	+ using value_type = bool;
	+ // TODO: this is strawman implementation. Turn it into a proxy type.
	+ using reference = bool&;
	+ using simd_type = simd<_Tp, _Abi>;
	+ using abi_type = _Abi;
	+ static constexpr size_t size() noexcept;
	+ simd_mask() = default;
	+
	+ // broadcast constructor
	+ explicit simd_mask(value_type) noexcept;
	+
	+ // implicit type conversion constructor
	+ template <class _Up>
	+ simd_mask(const simd_mask<_Up, simd_abi::fixed_size<size()>>&) noexcept;
	+
	+ // load constructor
	+ template <class _Flags>
	+ simd_mask(const value_type*, _Flags);
	+
	+ // loads [simd.mask.copy]
	+ template <class _Flags>
	+ void copy_from(const value_type*, _Flags);
	+ template <class _Flags>
	+ void copy_to(value_type*, _Flags) const;
	+
	+ // scalar access [simd.mask.subscr]
	+ reference operator[](size_t);
	+ value_type operator[](size_t) const;
	+
	+ // unary operators [simd.mask.unary]
	+ simd_mask operator!() const noexcept;
	+
	+ // simd_mask binary operators [simd.mask.binary]
	+ friend simd_mask operator&&(const simd_mask&, const simd_mask&) noexcept;
	+ friend simd_mask operator\|\|(const simd_mask&, const simd_mask&) noexcept;
	+ friend simd_mask operator&(const simd_mask&, const simd_mask&)noexcept;
	+ friend simd_mask operator\|(const simd_mask&, const simd_mask&) noexcept;
	+ friend simd_mask operator^(const simd_mask&, const simd_mask&) noexcept;
	+
	+ // simd_mask compound assignment [simd.mask.cassign]
	+ friend simd_mask& operator&=(simd_mask&, const simd_mask&) noexcept;
	+ friend simd_mask& operator\|=(simd_mask&, const simd_mask&) noexcept;
	+ friend simd_mask& operator^=(simd_mask&, const simd_mask&) noexcept;
	+
	+ // simd_mask compares [simd.mask.comparison]
	+ friend simd_mask operator==(const simd_mask&, const simd_mask&) noexcept;
	+ friend simd_mask operator!=(const simd_mask&, const simd_mask&) noexcept;
	+};
	+
	+_LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
	+
	+#endif /* _LIBCPP_EXPERIMENTAL_SIMD */
	Index: projects/clang700-import/contrib/libc++/include/experimental/string_view
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/string_view (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/string_view (revision 337135)
	@@ -1,818 +1,11 @@
	// -- C++ --
	//===------------------------ string_view ---------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	-#ifndef _LIBCPP_LFTS_STRING_VIEW
	-#define _LIBCPP_LFTS_STRING_VIEW
	-
	-/*
	-string_view synopsis
	-
	-namespace std {
	- namespace experimental {
	- inline namespace library_fundamentals_v1 {
	-
	- // 7.2, Class template basic_string_view
	- template<class charT, class traits = char_traits<charT>>
	- class basic_string_view;
	-
	- // 7.9, basic_string_view non-member comparison functions
	- template<class charT, class traits>
	- constexpr bool operator==(basic_string_view<charT, traits> x,
	- basic_string_view<charT, traits> y) noexcept;
	- template<class charT, class traits>
	- constexpr bool operator!=(basic_string_view<charT, traits> x,
	- basic_string_view<charT, traits> y) noexcept;
	- template<class charT, class traits>
	- constexpr bool operator< (basic_string_view<charT, traits> x,
	- basic_string_view<charT, traits> y) noexcept;
	- template<class charT, class traits>
	- constexpr bool operator> (basic_string_view<charT, traits> x,
	- basic_string_view<charT, traits> y) noexcept;
	- template<class charT, class traits>
	- constexpr bool operator<=(basic_string_view<charT, traits> x,
	- basic_string_view<charT, traits> y) noexcept;
	- template<class charT, class traits>
	- constexpr bool operator>=(basic_string_view<charT, traits> x,
	- basic_string_view<charT, traits> y) noexcept;
	- // see below, sufficient additional overloads of comparison functions
	-
	- // 7.10, Inserters and extractors
	- template<class charT, class traits>
	- basic_ostream<charT, traits>&
	- operator<<(basic_ostream<charT, traits>& os,
	- basic_string_view<charT, traits> str);
	-
	- // basic_string_view typedef names
	- typedef basic_string_view<char> string_view;
	- typedef basic_string_view<char16_t> u16string_view;
	- typedef basic_string_view<char32_t> u32string_view;
	- typedef basic_string_view<wchar_t> wstring_view;
	-
	- template<class charT, class traits = char_traits<charT>>
	- class basic_string_view {
	- public:
	- // types
	- typedef traits traits_type;
	- typedef charT value_type;
	- typedef charT* pointer;
	- typedef const charT* const_pointer;
	- typedef charT& reference;
	- typedef const charT& const_reference;
	- typedef implementation-defined const_iterator;
	- typedef const_iterator iterator;
	- typedef reverse_iterator<const_iterator> const_reverse_iterator;
	- typedef const_reverse_iterator reverse_iterator;
	- typedef size_t size_type;
	- typedef ptrdiff_t difference_type;
	- static constexpr size_type npos = size_type(-1);
	-
	- // 7.3, basic_string_view constructors and assignment operators
	- constexpr basic_string_view() noexcept;
	- constexpr basic_string_view(const basic_string_view&) noexcept = default;
	- basic_string_view& operator=(const basic_string_view&) noexcept = default;
	- template<class Allocator>
	- basic_string_view(const basic_string<charT, traits, Allocator>& str) noexcept;
	- constexpr basic_string_view(const charT* str);
	- constexpr basic_string_view(const charT* str, size_type len);
	-
	- // 7.4, basic_string_view iterator support
	- constexpr const_iterator begin() const noexcept;
	- constexpr const_iterator end() const noexcept;
	- constexpr const_iterator cbegin() const noexcept;
	- constexpr const_iterator cend() const noexcept;
	- const_reverse_iterator rbegin() const noexcept;
	- const_reverse_iterator rend() const noexcept;
	- const_reverse_iterator crbegin() const noexcept;
	- const_reverse_iterator crend() const noexcept;
	-
	- // 7.5, basic_string_view capacity
	- constexpr size_type size() const noexcept;
	- constexpr size_type length() const noexcept;
	- constexpr size_type max_size() const noexcept;
	- constexpr bool empty() const noexcept;
	-
	- // 7.6, basic_string_view element access
	- constexpr const_reference operator[](size_type pos) const;
	- constexpr const_reference at(size_type pos) const;
	- constexpr const_reference front() const;
	- constexpr const_reference back() const;
	- constexpr const_pointer data() const noexcept;
	-
	- // 7.7, basic_string_view modifiers
	- constexpr void clear() noexcept;
	- constexpr void remove_prefix(size_type n);
	- constexpr void remove_suffix(size_type n);
	- constexpr void swap(basic_string_view& s) noexcept;
	-
	- // 7.8, basic_string_view string operations
	- template<class Allocator>
	- explicit operator basic_string<charT, traits, Allocator>() const;
	- template<class Allocator = allocator<charT>>
	- basic_string<charT, traits, Allocator> to_string(
	- const Allocator& a = Allocator()) const;
	-
	- size_type copy(charT* s, size_type n, size_type pos = 0) const;
	-
	- constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
	- constexpr int compare(basic_string_view s) const noexcept;
	- constexpr int compare(size_type pos1, size_type n1, basic_string_view s) const;
	- constexpr int compare(size_type pos1, size_type n1,
	- basic_string_view s, size_type pos2, size_type n2) const;
	- constexpr int compare(const charT* s) const;
	- constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
	- constexpr int compare(size_type pos1, size_type n1,
	- const charT* s, size_type n2) const;
	- constexpr size_type find(basic_string_view s, size_type pos = 0) const noexcept;
	- constexpr size_type find(charT c, size_type pos = 0) const noexcept;
	- constexpr size_type find(const charT* s, size_type pos, size_type n) const;
	- constexpr size_type find(const charT* s, size_type pos = 0) const;
	- constexpr size_type rfind(basic_string_view s, size_type pos = npos) const noexcept;
	- constexpr size_type rfind(charT c, size_type pos = npos) const noexcept;
	- constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
	- constexpr size_type rfind(const charT* s, size_type pos = npos) const;
	- constexpr size_type find_first_of(basic_string_view s, size_type pos = 0) const noexcept;
	- constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept;
	- constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
	- constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
	- constexpr size_type find_last_of(basic_string_view s, size_type pos = npos) const noexcept;
	- constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept;
	- constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
	- constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
	- constexpr size_type find_first_not_of(basic_string_view s, size_type pos = 0) const noexcept;
	- constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept;
	- constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
	- constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const;
	- constexpr size_type find_last_not_of(basic_string_view s, size_type pos = npos) const noexcept;
	- constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;
	- 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;
	-
	- private:
	- const_pointer data_; // exposition only
	- size_type size_; // exposition only
	- };
	-
	- } // namespace fundamentals_v1
	- } // namespace experimental
	-
	- // 7.11, Hash support
	- template <class T> struct hash;
	- template <> struct hash<experimental::string_view>;
	- template <> struct hash<experimental::u16string_view>;
	- template <> struct hash<experimental::u32string_view>;
	- template <> struct hash<experimental::wstring_view>;
	-
	-} // namespace std
	-
	-
	-*/
	-
	-#include <experimental/__config>
	-
	-#include <string>
	-#include <algorithm>
	-#include <iterator>
	-#include <ostream>
	-#include <stdexcept>
	-#include <iomanip>
	-
	-#include <__debug>
	-
	-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	-#pragma GCC system_header
	-#endif
	-
	-_LIBCPP_PUSH_MACROS
	-#include <__undef_macros>
	-
	-_LIBCPP_BEGIN_NAMESPACE_LFTS
	-
	- template<class _CharT, class _Traits = _VSTD::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);
	-
	- // [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_INLINE_VISIBILITY
	- basic_string_view& operator=(const basic_string_view&) _NOEXCEPT = default;
	-
	- template<class _Allocator>
	- _LIBCPP_INLINE_VISIBILITY
	- basic_string_view(const basic_string<_CharT, _Traits, _Allocator>& __str) _NOEXCEPT
	- : __data (__str.data()), __size(__str.size()) {}
	-
	- _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
	- basic_string_view(const _CharT* __s, size_type __len)
	- : __data(__s), __size(__len)
	- {
	-// _LIBCPP_ASSERT(__len == 0 \|\| __s != nullptr, "string_view::string_view(_CharT *, size_t): received nullptr");
	- }
	-
	- _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_INLINE_VISIBILITY
	- const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(cend()); }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
	-
	- _LIBCPP_INLINE_VISIBILITY
	- const_reverse_iterator crbegin() const _NOEXCEPT { return const_reverse_iterator(cend()); }
	-
	- _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 _VSTD::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 { 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 clear() _NOEXCEPT
	- {
	- __data = nullptr;
	- __size = 0;
	- }
	-
	- _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;
	-// _VSTD::swap( __data, __other.__data );
	-// _VSTD::swap( __size, __other.__size );
	- }
	-
	- // [string.view.ops], string operations:
	- template<class _Allocator>
	- _LIBCPP_INLINE_VISIBILITY
	- _LIBCPP_EXPLICIT operator basic_string<_CharT, _Traits, _Allocator>() const
	- { return basic_string<_CharT, _Traits, _Allocator>( begin(), end()); }
	-
	- template<class _Allocator = allocator<_CharT> >
	- _LIBCPP_INLINE_VISIBILITY
	- basic_string<_CharT, _Traits, _Allocator>
	- to_string( const _Allocator& __a = _Allocator()) const
	- { return basic_string<_CharT, _Traits, _Allocator> ( begin(), end(), __a ); }
	-
	- 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 );
	- _VSTD::copy_n(begin() + __pos, __rlen, __s );
	- return __rlen;
	- }
	-
	- _LIBCPP_CONSTEXPR
	- basic_string_view substr(size_type __pos = 0, size_type __n = npos) const
	- {
	-// if (__pos > size())
	-// __throw_out_of_range("string_view::substr");
	-// size_type __rlen = _VSTD::min( __n, size() - __pos );
	-// return basic_string_view(data() + __pos, __rlen);
	- 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
	- {
	- 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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__str_find_last_not_of<value_type, size_type, traits_type, npos>
	- (data(), size(), __s, __pos, traits_type::length(__s));
	- }
	-
	- private:
	- const value_type* __data;
	- size_type __size;
	- };
	-
	-
	- // [string.view.comparison]
	- // operator ==
	- 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 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 _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
	- {
	- 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 _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
	- basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
	- {
	- if ( __lhs.size() != __rhs.size()) return false;
	- return __lhs.compare(__rhs) == 0;
	- }
	-
	-
	- // operator !=
	- 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;
	- }
	-
	- template<class _CharT, class _Traits>
	- _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	- bool operator!=(basic_string_view<_CharT, _Traits> __lhs,
	- typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
	- {
	- 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 _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
	- basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
	- {
	- if ( __lhs.size() != __rhs.size())
	- return true;
	- return __lhs.compare(__rhs) != 0;
	- }
	-
	-
	- // operator <
	- 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;
	- }
	-
	- template<class _CharT, class _Traits>
	- _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	- bool operator<(basic_string_view<_CharT, _Traits> __lhs,
	- typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
	- {
	- return __lhs.compare(__rhs) < 0;
	- }
	-
	- template<class _CharT, class _Traits>
	- _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	- bool operator<(typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
	- basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
	- {
	- return __lhs.compare(__rhs) < 0;
	- }
	-
	-
	- // operator >
	- 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;
	- }
	-
	- template<class _CharT, class _Traits>
	- _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	- bool operator>(basic_string_view<_CharT, _Traits> __lhs,
	- typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
	- {
	- return __lhs.compare(__rhs) > 0;
	- }
	-
	- template<class _CharT, class _Traits>
	- _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	- bool operator>(typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
	- basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
	- {
	- return __lhs.compare(__rhs) > 0;
	- }
	-
	-
	- // operator <=
	- 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;
	- }
	-
	- template<class _CharT, class _Traits>
	- _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	- bool operator<=(basic_string_view<_CharT, _Traits> __lhs,
	- typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
	- {
	- return __lhs.compare(__rhs) <= 0;
	- }
	-
	- template<class _CharT, class _Traits>
	- _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	- bool operator<=(typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
	- basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
	- {
	- return __lhs.compare(__rhs) <= 0;
	- }
	-
	-
	- // operator >=
	- 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;
	- }
	-
	-
	- template<class _CharT, class _Traits>
	- _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	- bool operator>=(basic_string_view<_CharT, _Traits> __lhs,
	- typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __rhs) _NOEXCEPT
	- {
	- return __lhs.compare(__rhs) >= 0;
	- }
	-
	- template<class _CharT, class _Traits>
	- _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	- bool operator>=(typename _VSTD::common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
	- basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
	- {
	- return __lhs.compare(__rhs) >= 0;
	- }
	-
	-
	- // [string.view.io]
	- template<class _CharT, class _Traits>
	- basic_ostream<_CharT, _Traits>&
	- operator<<(basic_ostream<_CharT, _Traits>& __os, basic_string_view<_CharT, _Traits> __sv)
	- {
	- return _VSTD::__put_character_sequence(__os, __sv.data(), __sv.size());
	- }
	-
	- typedef basic_string_view<char> string_view;
	- typedef basic_string_view<char16_t> u16string_view;
	- typedef basic_string_view<char32_t> u32string_view;
	- typedef basic_string_view<wchar_t> wstring_view;
	-
	-_LIBCPP_END_NAMESPACE_LFTS
	-_LIBCPP_BEGIN_NAMESPACE_STD
	-
	-// [string.view.hash]
	-// Shamelessly stolen from <string>
	-template<class _CharT, class _Traits>
	-struct _LIBCPP_TEMPLATE_VIS hash<std::experimental::basic_string_view<_CharT, _Traits> >
	- : public unary_function<std::experimental::basic_string_view<_CharT, _Traits>, size_t>
	-{
	- size_t operator()(const std::experimental::basic_string_view<_CharT, _Traits>& __val) const _NOEXCEPT;
	-};
	-
	-template<class _CharT, class _Traits>
	-size_t
	-hash<std::experimental::basic_string_view<_CharT, _Traits> >::operator()(
	- const std::experimental::basic_string_view<_CharT, _Traits>& __val) const _NOEXCEPT
	-{
	- return __do_string_hash(__val.data(), __val.data() + __val.size());
	-}
	-
	-#if _LIBCPP_STD_VER > 11
	-template <class _CharT, class _Traits>
	-__quoted_output_proxy<_CharT, const _CharT *, _Traits>
	-quoted ( std::experimental::basic_string_view <_CharT, _Traits> __sv,
	- _CharT __delim = _CharT('"'), _CharT __escape=_CharT('\\'))
	-{
	- return __quoted_output_proxy<_CharT, const _CharT *, _Traits>
	- ( __sv.data(), __sv.data() + __sv.size(), __delim, __escape );
	-}
	-#endif
	-
	-_LIBCPP_END_NAMESPACE_STD
	-
	-_LIBCPP_POP_MACROS
	-
	-#endif // _LIBCPP_LFTS_STRING_VIEW
	+#error "<experimental/string_view> has been removed. Use <string_view> instead."
	Index: projects/clang700-import/contrib/libc++/include/experimental/system_error
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/system_error (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/system_error (revision 337135)
	@@ -1,63 +1,11 @@
	// -- C++ --
	//===-------------------------- system_error ------------------------------===//
	//
	// 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_EXPERIMENTAL_SYSTEM_ERROR
	-#define _LIBCPP_EXPERIMENTAL_SYSTEM_ERROR
	-
	-/**
	- experimental/system_error synopsis
	-
	-// C++1y
	-
	-#include <system_error>
	-
	-namespace std {
	-namespace experimental {
	-inline namespace fundamentals_v1 {
	-
	- // See C++14 19.5, System error support
	- template <class T> constexpr bool is_error_code_enum_v
	- = is_error_code_enum<T>::value;
	- template <class T> constexpr bool is_error_condition_enum_v
	- = is_error_condition_enum<T>::value;
	-
	-} // namespace fundamentals_v1
	-} // namespace experimental
	-} // namespace std
	-
	-*/
	-
	-#include <experimental/__config>
	-
	-#if _LIBCPP_STD_VER > 11
	-
	-#include <system_error>
	-
	-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	-#pragma GCC system_header
	-#endif
	-
	-_LIBCPP_BEGIN_NAMESPACE_LFTS
	-
	-#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_error_code_enum_v
	- = is_error_code_enum<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_error_condition_enum_v
	- = is_error_condition_enum<_Tp>::value;
	-
	-#endif /* _LIBCPP_HAS_NO_VARIABLE_TEMPLATES */
	-
	-_LIBCPP_END_NAMESPACE_LFTS
	-
	-#endif /* _LIBCPP_STD_VER > 11 */
	-
	-#endif /* _LIBCPP_EXPERIMENTAL_SYSTEM_ERROR */
	+#error "<experimental/system_error> has been removed. Use <system_error> instead."
	Index: projects/clang700-import/contrib/libc++/include/experimental/tuple
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/tuple (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/tuple (revision 337135)
	@@ -1,82 +1,11 @@
	// -- C++ --
	//===----------------------------- tuple ----------------------------------===//
	//
	// 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_EXPERIMENTAL_TUPLE
	-#define _LIBCPP_EXPERIMENTAL_TUPLE
	-
	-/*
	- experimental/tuple synopsis
	-
	-// C++1y
	-
	-#include <tuple>
	-
	-namespace std {
	-namespace experimental {
	-inline namespace fundamentals_v1 {
	-
	- // See C++14 20.4.2.5, tuple helper classes
	- template <class T> constexpr size_t tuple_size_v
	- = tuple_size<T>::value;
	-
	- // 3.2.2, Calling a function with a tuple of arguments
	- template <class F, class Tuple>
	- constexpr decltype(auto) apply(F&& f, Tuple&& t);
	-
	-} // namespace fundamentals_v1
	-} // namespace experimental
	-} // namespace std
	-
	- */
	-
	-# include <experimental/__config>
	-
	-#if _LIBCPP_STD_VER > 11
	-
	-# include <tuple>
	-# include <utility>
	-# include <__functional_base>
	-
	-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	-#pragma GCC system_header
	-#endif
	-
	-_LIBCPP_BEGIN_NAMESPACE_LFTS
	-
	-#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
	-template <class _Tp>
	-_LIBCPP_CONSTEXPR size_t tuple_size_v = tuple_size<_Tp>::value;
	-#endif
	-
	-template <class _Fn, class _Tuple, size_t ..._Id>
	-inline _LIBCPP_INLINE_VISIBILITY
	-_LIBCPP_CONSTEXPR_AFTER_CXX11
	-decltype(auto) __apply_tuple_impl(_Fn && __f, _Tuple && __t,
	- integer_sequence<size_t, _Id...>) {
	- return _VSTD::__invoke_constexpr(
	- _VSTD::forward<_Fn>(__f),
	- _VSTD::get<_Id>(_VSTD::forward<_Tuple>(__t))...
	- );
	-}
	-
	-template <class _Fn, class _Tuple>
	-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	-decltype(auto) apply(_Fn && __f, _Tuple && __t) {
	- return _VSTD_LFTS::__apply_tuple_impl(
	- _VSTD::forward<_Fn>(__f), _VSTD::forward<_Tuple>(__t),
	- make_index_sequence<tuple_size<typename decay<_Tuple>::type>::value>()
	- );
	-}
	-
	-_LIBCPP_END_NAMESPACE_LFTS
	-
	-#endif /* _LIBCPP_STD_VER > 11 */
	-
	-#endif /* _LIBCPP_EXPERIMENTAL_TUPLE */
	+#error "<experimental/tuple> has been removed. Use <tuple> instead."
	Index: projects/clang700-import/contrib/libc++/include/experimental/type_traits
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/experimental/type_traits (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/experimental/type_traits (revision 337135)
	@@ -1,530 +1,155 @@
	// -- C++ --
	//===-------------------------- type_traits -------------------------------===//
	//
	// 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_EXPERIMENTAL_TYPE_TRAITS
	#define _LIBCPP_EXPERIMENTAL_TYPE_TRAITS

	/**
	experimental/type_traits synopsis

	// C++1y
	#include <type_traits>

	namespace std {
	namespace experimental {
	inline namespace fundamentals_v1 {

	- // See C++14 20.10.4.1, primary type categories
	- template <class T> constexpr bool is_void_v
	- = is_void<T>::value;
	- template <class T> constexpr bool is_null_pointer_v
	- = is_null_pointer<T>::value;
	- template <class T> constexpr bool is_integral_v
	- = is_integral<T>::value;
	- template <class T> constexpr bool is_floating_point_v
	- = is_floating_point<T>::value;
	- template <class T> constexpr bool is_array_v
	- = is_array<T>::value;
	- template <class T> constexpr bool is_pointer_v
	- = is_pointer<T>::value;
	- template <class T> constexpr bool is_lvalue_reference_v
	- = is_lvalue_reference<T>::value;
	- template <class T> constexpr bool is_rvalue_reference_v
	- = is_rvalue_reference<T>::value;
	- template <class T> constexpr bool is_member_object_pointer_v
	- = is_member_object_pointer<T>::value;
	- template <class T> constexpr bool is_member_function_pointer_v
	- = is_member_function_pointer<T>::value;
	- template <class T> constexpr bool is_enum_v
	- = is_enum<T>::value;
	- template <class T> constexpr bool is_union_v
	- = is_union<T>::value;
	- template <class T> constexpr bool is_class_v
	- = is_class<T>::value;
	- template <class T> constexpr bool is_function_v
	- = is_function<T>::value;
	-
	- // See C++14 20.10.4.2, composite type categories
	- template <class T> constexpr bool is_reference_v
	- = is_reference<T>::value;
	- template <class T> constexpr bool is_arithmetic_v
	- = is_arithmetic<T>::value;
	- template <class T> constexpr bool is_fundamental_v
	- = is_fundamental<T>::value;
	- template <class T> constexpr bool is_object_v
	- = is_object<T>::value;
	- template <class T> constexpr bool is_scalar_v
	- = is_scalar<T>::value;
	- template <class T> constexpr bool is_compound_v
	- = is_compound<T>::value;
	- template <class T> constexpr bool is_member_pointer_v
	- = is_member_pointer<T>::value;
	-
	- // See C++14 20.10.4.3, type properties
	- template <class T> constexpr bool is_const_v
	- = is_const<T>::value;
	- template <class T> constexpr bool is_volatile_v
	- = is_volatile<T>::value;
	- template <class T> constexpr bool is_trivial_v
	- = is_trivial<T>::value;
	- template <class T> constexpr bool is_trivially_copyable_v
	- = is_trivially_copyable<T>::value;
	- template <class T> constexpr bool is_standard_layout_v
	- = is_standard_layout<T>::value;
	- template <class T> constexpr bool is_pod_v
	- = is_pod<T>::value;
	- template <class T> constexpr bool is_literal_type_v
	- = is_literal_type<T>::value;
	- template <class T> constexpr bool is_empty_v
	- = is_empty<T>::value;
	- template <class T> constexpr bool is_polymorphic_v
	- = is_polymorphic<T>::value;
	- template <class T> constexpr bool is_abstract_v
	- = is_abstract<T>::value;
	- template <class T> constexpr bool is_final_v
	- = is_final<T>::value;
	- template <class T> constexpr bool is_signed_v
	- = is_signed<T>::value;
	- template <class T> constexpr bool is_unsigned_v
	- = is_unsigned<T>::value;
	- template <class T, class... Args> constexpr bool is_constructible_v
	- = is_constructible<T, Args...>::value;
	- template <class T> constexpr bool is_default_constructible_v
	- = is_default_constructible<T>::value;
	- template <class T> constexpr bool is_copy_constructible_v
	- = is_copy_constructible<T>::value;
	- template <class T> constexpr bool is_move_constructible_v
	- = is_move_constructible<T>::value;
	- template <class T, class U> constexpr bool is_assignable_v
	- = is_assignable<T, U>::value;
	- template <class T> constexpr bool is_copy_assignable_v
	- = is_copy_assignable<T>::value;
	- template <class T> constexpr bool is_move_assignable_v
	- = is_move_assignable<T>::value;
	- template <class T> constexpr bool is_destructible_v
	- = is_destructible<T>::value;
	- template <class T, class... Args> constexpr bool is_trivially_constructible_v
	- = is_trivially_constructible<T, Args...>::value;
	- template <class T> constexpr bool is_trivially_default_constructible_v
	- = is_trivially_default_constructible<T>::value;
	- template <class T> constexpr bool is_trivially_copy_constructible_v
	- = is_trivially_copy_constructible<T>::value;
	- template <class T> constexpr bool is_trivially_move_constructible_v
	- = is_trivially_move_constructible<T>::value;
	- template <class T, class U> constexpr bool is_trivially_assignable_v
	- = is_trivially_assignable<T, U>::value;
	- template <class T> constexpr bool is_trivially_copy_assignable_v
	- = is_trivially_copy_assignable<T>::value;
	- template <class T> constexpr bool is_trivially_move_assignable_v
	- = is_trivially_move_assignable<T>::value;
	- template <class T> constexpr bool is_trivially_destructible_v
	- = is_trivially_destructible<T>::value;
	- template <class T, class... Args> constexpr bool is_nothrow_constructible_v
	- = is_nothrow_constructible<T, Args...>::value;
	- template <class T> constexpr bool is_nothrow_default_constructible_v
	- = is_nothrow_default_constructible<T>::value;
	- template <class T> constexpr bool is_nothrow_copy_constructible_v
	- = is_nothrow_copy_constructible<T>::value;
	- template <class T> constexpr bool is_nothrow_move_constructible_v
	- = is_nothrow_move_constructible<T>::value;
	- template <class T, class U> constexpr bool is_nothrow_assignable_v
	- = is_nothrow_assignable<T, U>::value;
	- template <class T> constexpr bool is_nothrow_copy_assignable_v
	- = is_nothrow_copy_assignable<T>::value;
	- template <class T> constexpr bool is_nothrow_move_assignable_v
	- = is_nothrow_move_assignable<T>::value;
	- template <class T> constexpr bool is_nothrow_destructible_v
	- = is_nothrow_destructible<T>::value;
	- template <class T> constexpr bool has_virtual_destructor_v
	- = has_virtual_destructor<T>::value;
	-
	- // See C++14 20.10.5, type property queries
	- template <class T> constexpr size_t alignment_of_v
	- = alignment_of<T>::value;
	- template <class T> constexpr size_t rank_v
	- = rank<T>::value;
	- template <class T, unsigned I = 0> constexpr size_t extent_v
	- = extent<T, I>::value;
	-
	- // See C++14 20.10.6, type relations
	- template <class T, class U> constexpr bool is_same_v
	- = is_same<T, U>::value;
	- template <class Base, class Derived> constexpr bool is_base_of_v
	- = is_base_of<Base, Derived>::value;
	- template <class From, class To> constexpr bool is_convertible_v
	- = is_convertible<From, To>::value;
	-
	// 3.3.2, Other type transformations
	template <class> class invocation_type; // not defined
	template <class F, class... ArgTypes> class invocation_type<F(ArgTypes...)>;
	template <class> class raw_invocation_type; // not defined
	template <class F, class... ArgTypes> class raw_invocation_type<F(ArgTypes...)>;

	template <class T>
	using invocation_type_t = typename invocation_type<T>::type;
	template <class T>
	using raw_invocation_type_t = typename raw_invocation_type<T>::type;

	- // 3.3.3, Logical operator traits
	- template<class... B> struct conjunction;
	- template<class... B> constexpr bool conjunction_v = conjunction<B...>::value;
	- template<class... B> struct disjunction;
	- template<class... B> constexpr bool disjunction_v = disjunction<B...>::value;
	- template<class B> struct negation;
	- template<class B> constexpr bool negation_v = negation<B>::value;
	-
	// 3.3.4, Detection idiom
	template <class...> using void_t = void;

	struct nonesuch {
	nonesuch() = delete;
	~nonesuch() = delete;
	nonesuch(nonesuch const&) = delete;
	void operator=(nonesuch const&) = delete;
	};

	template <template<class...> class Op, class... Args>
	using is_detected = see below;
	template <template<class...> class Op, class... Args>
	constexpr bool is_detected_v = is_detected<Op, Args...>::value;
	template <template<class...> class Op, class... Args>
	using detected_t = see below;
	template <class Default, template<class...> class Op, class... Args>
	using detected_or = see below;
	template <class Default, template<class...> class Op, class... Args>
	using detected_or_t = typename detected_or<Default, Op, Args...>::type;
	template <class Expected, template<class...> class Op, class... Args>
	using is_detected_exact = is_same<Expected, detected_t<Op, Args...>>;
	template <class Expected, template<class...> class Op, class... Args>
	constexpr bool is_detected_exact_v
	= is_detected_exact<Expected, Op, Args...>::value;
	template <class To, template<class...> class Op, class... Args>
	using is_detected_convertible = is_convertible<detected_t<Op, Args...>, To>;
	template <class To, template<class...> class Op, class... Args>
	constexpr bool is_detected_convertible_v
	= is_detected_convertible<To, Op, Args...>::value;

	} // namespace fundamentals_v1
	} // namespace experimental
	} // namespace std

	*/

	#include <experimental/__config>

	#if _LIBCPP_STD_VER > 11

	#include <type_traits>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_LFTS

	-#ifndef _LIBCPP_HAS_NO_VARIABLE_TEMPLATES
	-
	-// C++14 20.10.4.1, primary type categories
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_void_v
	- = is_void<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_null_pointer_v
	- = is_null_pointer<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_integral_v
	- = is_integral<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_floating_point_v
	- = is_floating_point<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_array_v
	- = is_array<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_pointer_v
	- = is_pointer<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_lvalue_reference_v
	- = is_lvalue_reference<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_rvalue_reference_v
	- = is_rvalue_reference<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_member_object_pointer_v
	- = is_member_object_pointer<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_member_function_pointer_v
	- = is_member_function_pointer<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_enum_v
	- = is_enum<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_union_v
	- = is_union<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_class_v
	- = is_class<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_function_v
	- = is_function<_Tp>::value;
	-
	-// C++14 20.10.4.2, composite type categories
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_reference_v
	- = is_reference<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_arithmetic_v
	- = is_arithmetic<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_fundamental_v
	- = is_fundamental<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_object_v
	- = is_object<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_scalar_v
	- = is_scalar<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_compound_v
	- = is_compound<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_member_pointer_v
	- = is_member_pointer<_Tp>::value;
	-
	-// C++14 20.10.4.3, type properties
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_const_v
	- = is_const<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_volatile_v
	- = is_volatile<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivial_v
	- = is_trivial<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_copyable_v
	- = is_trivially_copyable<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_standard_layout_v
	- = is_standard_layout<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_pod_v
	- = is_pod<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_literal_type_v
	- = is_literal_type<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_empty_v
	- = is_empty<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_polymorphic_v
	- = is_polymorphic<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_abstract_v
	- = is_abstract<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_final_v
	- = is_final<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_signed_v
	- = is_signed<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_unsigned_v
	- = is_unsigned<_Tp>::value;
	-
	-template <class _Tp, class ..._Ts> _LIBCPP_CONSTEXPR bool is_constructible_v
	- = is_constructible<_Tp, _Ts...>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_default_constructible_v
	- = is_default_constructible<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_copy_constructible_v
	- = is_copy_constructible<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_move_constructible_v
	- = is_move_constructible<_Tp>::value;
	-
	-template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_assignable_v
	- = is_assignable<_Tp, _Up>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_copy_assignable_v
	- = is_copy_assignable<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_move_assignable_v
	- = is_move_assignable<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_destructible_v
	- = is_destructible<_Tp>::value;
	-
	-template <class _Tp, class ..._Ts> _LIBCPP_CONSTEXPR bool is_trivially_constructible_v
	- = is_trivially_constructible<_Tp, _Ts...>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_default_constructible_v
	- = is_trivially_default_constructible<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_copy_constructible_v
	- = is_trivially_copy_constructible<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_move_constructible_v
	- = is_trivially_move_constructible<_Tp>::value;
	-
	-template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_trivially_assignable_v
	- = is_trivially_assignable<_Tp, _Up>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_copy_assignable_v
	- = is_trivially_copy_assignable<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_move_assignable_v
	- = is_trivially_move_assignable<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_trivially_destructible_v
	- = is_trivially_destructible<_Tp>::value;
	-
	-template <class _Tp, class ..._Ts> _LIBCPP_CONSTEXPR bool is_nothrow_constructible_v
	- = is_nothrow_constructible<_Tp, _Ts...>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_default_constructible_v
	- = is_nothrow_default_constructible<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_copy_constructible_v
	- = is_nothrow_copy_constructible<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_move_constructible_v
	- = is_nothrow_move_constructible<_Tp>::value;
	-
	-template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_nothrow_assignable_v
	- = is_nothrow_assignable<_Tp, _Up>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_copy_assignable_v
	- = is_nothrow_copy_assignable<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_move_assignable_v
	- = is_nothrow_move_assignable<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool is_nothrow_destructible_v
	- = is_nothrow_destructible<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR bool has_virtual_destructor_v
	- = has_virtual_destructor<_Tp>::value;
	-
	-// C++14 20.10.5, type properties queries
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR size_t alignment_of_v
	- = alignment_of<_Tp>::value;
	-
	-template <class _Tp> _LIBCPP_CONSTEXPR size_t rank_v
	- = rank<_Tp>::value;
	-
	-template <class _Tp, unsigned _Id = 0> _LIBCPP_CONSTEXPR size_t extent_v
	- = extent<_Tp, _Id>::value;
	-
	-// C++14 20.10.6, type relations
	-
	-template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_same_v
	- = is_same<_Tp, _Up>::value;
	-
	-template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_base_of_v
	- = is_base_of<_Tp, _Up>::value;
	-
	-template <class _Tp, class _Up> _LIBCPP_CONSTEXPR bool is_convertible_v
	- = is_convertible<_Tp, _Up>::value;
	-
	-#endif /* _LIBCPP_HAS_NO_VARIABLE_TEMPLATES */
	-
	// 3.3.2, Other type transformations
	/*
	template <class>
	class _LIBCPP_TEMPLATE_VIS raw_invocation_type;

	template <class _Fn, class ..._Args>
	class _LIBCPP_TEMPLATE_VIS raw_invocation_type<_Fn(_Args...)>;

	template <class>
	class _LIBCPP_TEMPLATE_VIS invokation_type;

	template <class _Fn, class ..._Args>
	class _LIBCPP_TEMPLATE_VIS invokation_type<_Fn(_Args...)>;

	template <class _Tp>
	using invokation_type_t = typename invokation_type<_Tp>::type;

	template <class _Tp>
	using raw_invocation_type_t = typename raw_invocation_type<_Tp>::type;
	*/
	-
	-// 3.3.3, Logical operator traits
	-template <class...> using void_t = void;
	-
	-template <class... _Args>
	-struct conjunction : _VSTD::__and_<_Args...> {};
	-template <class... _Args>
	-_LIBCPP_CONSTEXPR bool conjunction_v = conjunction<_Args...>::value;
	-
	-template <class... _Args>
	-struct disjunction : _VSTD::__or_<_Args...> {};
	-template <class... _Args>
	-_LIBCPP_CONSTEXPR bool disjunction_v = disjunction<_Args...>::value;
	-
	-template <class _Tp>
	-struct negation : _VSTD::__not_<_Tp> {};
	-template<class _Tp>
	-_LIBCPP_CONSTEXPR bool negation_v = negation<_Tp>::value;

	// 3.3.4, Detection idiom
	template <class...> using void_t = void;

	struct nonesuch {
	nonesuch() = delete;
	~nonesuch() = delete;
	nonesuch (nonesuch const&) = delete;
	void operator=(nonesuch const&) = delete;
	};

	template <class _Default, class _AlwaysVoid, template <class...> class _Op, class... _Args>
	struct _DETECTOR {
	using value_t = false_type;
	using type = _Default;
	};

	template <class _Default, template <class...> class _Op, class... _Args>
	struct _DETECTOR<_Default, void_t<_Op<_Args...>>, _Op, _Args...> {
	using value_t = true_type;
	using type = _Op<_Args...>;
	};


	template <template<class...> class _Op, class... _Args>
	using is_detected = typename _DETECTOR<nonesuch, void, _Op, _Args...>::value_t;
	template <template<class...> class _Op, class... _Args>
	using detected_t = typename _DETECTOR<nonesuch, void, _Op, _Args...>::type;
	template <template<class...> class _Op, class... _Args>
	_LIBCPP_CONSTEXPR bool is_detected_v = is_detected<_Op, _Args...>::value;

	template <class Default, template<class...> class _Op, class... _Args>
	using detected_or = _DETECTOR<Default, void, _Op, _Args...>;
	template <class Default, template<class...> class _Op, class... _Args>
	using detected_or_t = typename detected_or<Default, _Op, _Args...>::type;

	template <class Expected, template<class...> class _Op, class... _Args>
	using is_detected_exact = is_same<Expected, detected_t<_Op, _Args...>>;
	template <class Expected, template<class...> class _Op, class... _Args>
	_LIBCPP_CONSTEXPR bool is_detected_exact_v = is_detected_exact<Expected, _Op, _Args...>::value;

	template <class To, template<class...> class _Op, class... _Args>
	using is_detected_convertible = is_convertible<detected_t<_Op, _Args...>, To>;
	template <class To, template<class...> class _Op, class... _Args>
	_LIBCPP_CONSTEXPR bool is_detected_convertible_v = is_detected_convertible<To, _Op, _Args...>::value;


	_LIBCPP_END_NAMESPACE_LFTS

	#endif /* _LIBCPP_STD_VER > 11 */

	#endif /* _LIBCPP_EXPERIMENTAL_TYPE_TRAITS */
	Index: projects/clang700-import/contrib/libc++/include/filesystem
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/filesystem (nonexistent)
	+++ projects/clang700-import/contrib/libc++/include/filesystem (revision 337135)
	@@ -0,0 +1,2682 @@
	+// -- C++ --
	+//===--------------------------- filesystem -------------------------------===//
	+//
	+// 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_FILESYSTEM
	+#define _LIBCPP_FILESYSTEM
	+/*
	+ filesystem synopsis
	+
	+ namespace std { namespace filesystem {
	+
	+ class path;
	+
	+ void swap(path& lhs, path& rhs) noexcept;
	+ size_t hash_value(const path& p) noexcept;
	+
	+ bool operator==(const path& lhs, const path& rhs) noexcept;
	+ bool operator!=(const path& lhs, const path& rhs) noexcept;
	+ bool operator< (const path& lhs, const path& rhs) noexcept;
	+ bool operator<=(const path& lhs, const path& rhs) noexcept;
	+ bool operator> (const path& lhs, const path& rhs) noexcept;
	+ bool operator>=(const path& lhs, const path& rhs) noexcept;
	+
	+ path operator/ (const path& lhs, const path& rhs);
	+
	+ // fs.path.io operators are friends of path.
	+ template <class charT, class traits>
	+ friend basic_ostream<charT, traits>&
	+ operator<<(basic_ostream<charT, traits>& os, const path& p);
	+
	+ template <class charT, class traits>
	+ friend basic_istream<charT, traits>&
	+ operator>>(basic_istream<charT, traits>& is, path& p);
	+
	+ template <class Source>
	+ path u8path(const Source& source);
	+ template <class InputIterator>
	+ path u8path(InputIterator first, InputIterator last);
	+
	+ class filesystem_error;
	+ class directory_entry;
	+
	+ class directory_iterator;
	+
	+ // enable directory_iterator range-based for statements
	+ directory_iterator begin(directory_iterator iter) noexcept;
	+ directory_iterator end(const directory_iterator&) noexcept;
	+
	+ class recursive_directory_iterator;
	+
	+ // enable recursive_directory_iterator range-based for statements
	+ recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
	+ recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;
	+
	+ class file_status;
	+
	+ struct space_info
	+ {
	+ uintmax_t capacity;
	+ uintmax_t free;
	+ uintmax_t available;
	+ };
	+
	+ enum class file_type;
	+ enum class perms;
	+ enum class perm_options;
	+ enum class copy_options;
	+ enum class directory_options;
	+
	+ typedef chrono::time_point<trivial-clock> file_time_type;
	+
	+ // operational functions
	+
	+ path absolute(const path& p);
	+ path absolute(const path& p, error_code &ec);
	+
	+ path canonical(const path& p);
	+ path canonical(const path& p, error_code& ec);
	+
	+ void copy(const path& from, const path& to);
	+ 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);
	+
	+ bool copy_file(const path& from, const path& to);
	+ bool copy_file(const path& from, const path& to, error_code& ec);
	+ bool copy_file(const path& from, const path& to, copy_options option);
	+ bool copy_file(const path& from, const path& to, copy_options option,
	+ error_code& ec);
	+
	+ void copy_symlink(const path& existing_symlink, const path& new_symlink);
	+ void copy_symlink(const path& existing_symlink, const path& new_symlink,
	+ error_code& ec) noexcept;
	+
	+ bool create_directories(const path& p);
	+ bool create_directories(const path& p, error_code& ec);
	+
	+ bool create_directory(const path& p);
	+ bool create_directory(const path& p, error_code& ec) noexcept;
	+
	+ bool create_directory(const path& p, const path& attributes);
	+ bool create_directory(const path& p, const path& attributes,
	+ error_code& ec) noexcept;
	+
	+ void create_directory_symlink(const path& to, const path& new_symlink);
	+ void create_directory_symlink(const path& to, const path& new_symlink,
	+ error_code& ec) noexcept;
	+
	+ void create_hard_link(const path& to, const path& new_hard_link);
	+ void create_hard_link(const path& to, const path& new_hard_link,
	+ error_code& ec) noexcept;
	+
	+ void create_symlink(const path& to, const path& new_symlink);
	+ void create_symlink(const path& to, const path& new_symlink,
	+ error_code& ec) noexcept;
	+
	+ path current_path();
	+ path current_path(error_code& ec);
	+ void current_path(const path& p);
	+ void current_path(const path& p, error_code& ec) noexcept;
	+
	+ bool exists(file_status s) noexcept;
	+ bool exists(const path& p);
	+ bool exists(const path& p, error_code& ec) noexcept;
	+
	+ bool equivalent(const path& p1, const path& p2);
	+ bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept;
	+
	+ uintmax_t file_size(const path& p);
	+ uintmax_t file_size(const path& p, error_code& ec) noexcept;
	+
	+ uintmax_t hard_link_count(const path& p);
	+ uintmax_t hard_link_count(const path& p, error_code& ec) noexcept;
	+
	+ bool is_block_file(file_status s) noexcept;
	+ bool is_block_file(const path& p);
	+ bool is_block_file(const path& p, error_code& ec) noexcept;
	+
	+ bool is_character_file(file_status s) noexcept;
	+ bool is_character_file(const path& p);
	+ bool is_character_file(const path& p, error_code& ec) noexcept;
	+
	+ bool is_directory(file_status s) noexcept;
	+ bool is_directory(const path& p);
	+ bool is_directory(const path& p, error_code& ec) noexcept;
	+
	+ bool is_empty(const path& p);
	+ bool is_empty(const path& p, error_code& ec) noexcept;
	+
	+ bool is_fifo(file_status s) noexcept;
	+ bool is_fifo(const path& p);
	+ bool is_fifo(const path& p, error_code& ec) noexcept;
	+
	+ bool is_other(file_status s) noexcept;
	+ bool is_other(const path& p);
	+ bool is_other(const path& p, error_code& ec) noexcept;
	+
	+ bool is_regular_file(file_status s) noexcept;
	+ bool is_regular_file(const path& p);
	+ bool is_regular_file(const path& p, error_code& ec) noexcept;
	+
	+ bool is_socket(file_status s) noexcept;
	+ bool is_socket(const path& p);
	+ bool is_socket(const path& p, error_code& ec) noexcept;
	+
	+ bool is_symlink(file_status s) noexcept;
	+ bool is_symlink(const path& p);
	+ bool is_symlink(const path& p, error_code& ec) noexcept;
	+
	+ file_time_type last_write_time(const path& p);
	+ file_time_type last_write_time(const path& p, error_code& ec) noexcept;
	+ void last_write_time(const path& p, file_time_type new_time);
	+ void last_write_time(const path& p, file_time_type new_time,
	+ error_code& ec) noexcept;
	+
	+ void permissions(const path& p, perms prms,
	+ perm_options opts=perm_options::replace);
	+ void permissions(const path& p, perms prms, error_code& ec) noexcept;
	+ void permissions(const path& p, perms prms, perm_options opts,
	+ error_code& ec);
	+
	+ path proximate(const path& p, error_code& ec);
	+ path proximate(const path& p, const path& base = current_path());
	+ path proximate(const path& p, const path& base, error_code &ec);
	+
	+ path read_symlink(const path& p);
	+ path read_symlink(const path& p, error_code& ec);
	+
	+ path relative(const path& p, error_code& ec);
	+ path relative(const path& p, const path& base=current_path());
	+ path relative(const path& p, const path& base, error_code& ec);
	+
	+ bool remove(const path& p);
	+ bool remove(const path& p, error_code& ec) noexcept;
	+
	+ uintmax_t remove_all(const path& p);
	+ uintmax_t remove_all(const path& p, error_code& ec);
	+
	+ void rename(const path& from, const path& to);
	+ void rename(const path& from, const path& to, error_code& ec) noexcept;
	+
	+ void resize_file(const path& p, uintmax_t size);
	+ void resize_file(const path& p, uintmax_t size, error_code& ec) noexcept;
	+
	+ space_info space(const path& p);
	+ space_info space(const path& p, error_code& ec) noexcept;
	+
	+ file_status status(const path& p);
	+ file_status status(const path& p, error_code& ec) noexcept;
	+
	+ bool status_known(file_status s) noexcept;
	+
	+ file_status symlink_status(const path& p);
	+ file_status symlink_status(const path& p, error_code& ec) noexcept;
	+
	+ path temp_directory_path();
	+ path temp_directory_path(error_code& ec);
	+
	+ path weakly_canonical(path const& p);
	+ path weakly_canonical(path const& p, error_code& ec);
	+
	+
	+} } // namespaces std::filesystem
	+
	+*/
	+
	+#include <__config>
	+#include <cstddef>
	+#include <cstdlib>
	+#include <chrono>
	+#include <iterator>
	+#include <iosfwd>
	+#include <locale>
	+#include <memory>
	+#include <stack>
	+#include <string>
	+#include <system_error>
	+#include <utility>
	+#include <iomanip> // for quoted
	+#include <string_view>
	+
	+#include <__debug>
	+
	+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	+#pragma GCC system_header
	+#endif
	+
	+_LIBCPP_PUSH_MACROS
	+#include <__undef_macros>
	+
	+#ifndef _LIBCPP_CXX03_LANG
	+
	+#if _LIBCPP_STD_VER >= 17
	+#define __cpp_lib_filesystem 201703
	+#endif
	+
	+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
	+
	+struct _FilesystemClock {
	+#if !defined(_LIBCPP_HAS_NO_INT128)
	+ typedef __int128_t rep;
	+ typedef nano period;
	+#else
	+ typedef long long rep;
	+ typedef nano period;
	+#endif
	+
	+ typedef chrono::duration<rep, period> duration;
	+ typedef chrono::time_point<_FilesystemClock> time_point;
	+
	+ static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false;
	+
	+ _LIBCPP_FUNC_VIS static time_point now() noexcept;
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ static time_t to_time_t(const time_point& __t) noexcept {
	+ typedef chrono::duration<rep> __secs;
	+ return time_t(
	+ chrono::duration_cast<__secs>(__t.time_since_epoch()).count());
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ static time_point from_time_t(time_t __t) noexcept {
	+ typedef chrono::duration<rep> __secs;
	+ return time_point(__secs(__t));
	+ }
	+};
	+
	+typedef chrono::time_point<_FilesystemClock> file_time_type;
	+
	+struct _LIBCPP_TYPE_VIS space_info {
	+ uintmax_t capacity;
	+ uintmax_t free;
	+ uintmax_t available;
	+};
	+
	+enum class _LIBCPP_ENUM_VIS file_type : signed char {
	+ none = 0,
	+ not_found = -1,
	+ regular = 1,
	+ directory = 2,
	+ symlink = 3,
	+ block = 4,
	+ character = 5,
	+ fifo = 6,
	+ socket = 7,
	+ unknown = 8
	+};
	+
	+enum class _LIBCPP_ENUM_VIS perms : unsigned {
	+ none = 0,
	+
	+ owner_read = 0400,
	+ owner_write = 0200,
	+ owner_exec = 0100,
	+ owner_all = 0700,
	+
	+ group_read = 040,
	+ group_write = 020,
	+ group_exec = 010,
	+ group_all = 070,
	+
	+ others_read = 04,
	+ others_write = 02,
	+ others_exec = 01,
	+ others_all = 07,
	+
	+ all = 0777,
	+
	+ set_uid = 04000,
	+ set_gid = 02000,
	+ sticky_bit = 01000,
	+ mask = 07777,
	+ unknown = 0xFFFF,
	+};
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr perms operator&(perms _LHS, perms _RHS) {
	+ return static_cast<perms>(static_cast<unsigned>(_LHS) &
	+ static_cast<unsigned>(_RHS));
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr perms operator\|(perms _LHS, perms _RHS) {
	+ return static_cast<perms>(static_cast<unsigned>(_LHS) \|
	+ static_cast<unsigned>(_RHS));
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr perms operator^(perms _LHS, perms _RHS) {
	+ return static_cast<perms>(static_cast<unsigned>(_LHS) ^
	+ static_cast<unsigned>(_RHS));
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr perms operator~(perms _LHS) {
	+ return static_cast<perms>(~static_cast<unsigned>(_LHS));
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline perms& operator&=(perms& _LHS, perms _RHS) { return _LHS = _LHS & _RHS; }
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline perms& operator\|=(perms& _LHS, perms _RHS) { return _LHS = _LHS \| _RHS; }
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline perms& operator^=(perms& _LHS, perms _RHS) { return _LHS = _LHS ^ _RHS; }
	+
	+enum class _LIBCPP_ENUM_VIS perm_options : unsigned char {
	+ replace = 1,
	+ add = 2,
	+ remove = 4,
	+ nofollow = 8
	+};
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr perm_options operator&(perm_options _LHS, perm_options _RHS) {
	+ return static_cast<perm_options>(static_cast<unsigned>(_LHS) &
	+ static_cast<unsigned>(_RHS));
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr perm_options operator\|(perm_options _LHS, perm_options _RHS) {
	+ return static_cast<perm_options>(static_cast<unsigned>(_LHS) \|
	+ static_cast<unsigned>(_RHS));
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr perm_options operator^(perm_options _LHS, perm_options _RHS) {
	+ return static_cast<perm_options>(static_cast<unsigned>(_LHS) ^
	+ static_cast<unsigned>(_RHS));
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr perm_options operator~(perm_options _LHS) {
	+ return static_cast<perm_options>(~static_cast<unsigned>(_LHS));
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline perm_options& operator&=(perm_options& _LHS, perm_options _RHS) {
	+ return _LHS = _LHS & _RHS;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline perm_options& operator\|=(perm_options& _LHS, perm_options _RHS) {
	+ return _LHS = _LHS \| _RHS;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline perm_options& operator^=(perm_options& _LHS, perm_options _RHS) {
	+ return _LHS = _LHS ^ _RHS;
	+}
	+
	+enum class _LIBCPP_ENUM_VIS copy_options : unsigned short {
	+ none = 0,
	+ skip_existing = 1,
	+ overwrite_existing = 2,
	+ update_existing = 4,
	+ recursive = 8,
	+ copy_symlinks = 16,
	+ skip_symlinks = 32,
	+ directories_only = 64,
	+ create_symlinks = 128,
	+ create_hard_links = 256,
	+ __in_recursive_copy = 512,
	+};
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr copy_options operator&(copy_options _LHS, copy_options _RHS) {
	+ return static_cast<copy_options>(static_cast<unsigned short>(_LHS) &
	+ static_cast<unsigned short>(_RHS));
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr copy_options operator\|(copy_options _LHS, copy_options _RHS) {
	+ return static_cast<copy_options>(static_cast<unsigned short>(_LHS) \|
	+ static_cast<unsigned short>(_RHS));
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr copy_options operator^(copy_options _LHS, copy_options _RHS) {
	+ return static_cast<copy_options>(static_cast<unsigned short>(_LHS) ^
	+ static_cast<unsigned short>(_RHS));
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr copy_options operator~(copy_options _LHS) {
	+ return static_cast<copy_options>(~static_cast<unsigned short>(_LHS));
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline copy_options& operator&=(copy_options& _LHS, copy_options _RHS) {
	+ return _LHS = _LHS & _RHS;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline copy_options& operator\|=(copy_options& _LHS, copy_options _RHS) {
	+ return _LHS = _LHS \| _RHS;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline copy_options& operator^=(copy_options& _LHS, copy_options _RHS) {
	+ return _LHS = _LHS ^ _RHS;
	+}
	+
	+enum class _LIBCPP_ENUM_VIS directory_options : unsigned char {
	+ none = 0,
	+ follow_directory_symlink = 1,
	+ skip_permission_denied = 2
	+};
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr directory_options operator&(directory_options _LHS,
	+ directory_options _RHS) {
	+ return static_cast<directory_options>(static_cast<unsigned char>(_LHS) &
	+ static_cast<unsigned char>(_RHS));
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr directory_options operator\|(directory_options _LHS,
	+ directory_options _RHS) {
	+ return static_cast<directory_options>(static_cast<unsigned char>(_LHS) \|
	+ static_cast<unsigned char>(_RHS));
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr directory_options operator^(directory_options _LHS,
	+ directory_options _RHS) {
	+ return static_cast<directory_options>(static_cast<unsigned char>(_LHS) ^
	+ static_cast<unsigned char>(_RHS));
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline constexpr directory_options operator~(directory_options _LHS) {
	+ return static_cast<directory_options>(~static_cast<unsigned char>(_LHS));
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline directory_options& operator&=(directory_options& _LHS,
	+ directory_options _RHS) {
	+ return _LHS = _LHS & _RHS;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline directory_options& operator\|=(directory_options& _LHS,
	+ directory_options _RHS) {
	+ return _LHS = _LHS \| _RHS;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline directory_options& operator^=(directory_options& _LHS,
	+ directory_options _RHS) {
	+ return _LHS = _LHS ^ _RHS;
	+}
	+
	+class _LIBCPP_TYPE_VIS file_status {
	+public:
	+ // constructors
	+ _LIBCPP_INLINE_VISIBILITY
	+ file_status() noexcept : file_status(file_type::none) {}
	+ _LIBCPP_INLINE_VISIBILITY
	+ explicit file_status(file_type __ft, perms __prms = perms::unknown) noexcept
	+ : __ft_(__ft),
	+ __prms_(__prms) {}
	+
	+ file_status(const file_status&) noexcept = default;
	+ file_status(file_status&&) noexcept = default;
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ ~file_status() {}
	+
	+ file_status& operator=(const file_status&) noexcept = default;
	+ file_status& operator=(file_status&&) noexcept = default;
	+
	+ // observers
	+ _LIBCPP_INLINE_VISIBILITY
	+ file_type type() const noexcept { return __ft_; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ perms permissions() const noexcept { return __prms_; }
	+
	+ // modifiers
	+ _LIBCPP_INLINE_VISIBILITY
	+ void type(file_type __ft) noexcept { __ft_ = __ft; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void permissions(perms __p) noexcept { __prms_ = __p; }
	+
	+private:
	+ file_type __ft_;
	+ perms __prms_;
	+};
	+
	+class _LIBCPP_TYPE_VIS directory_entry;
	+
	+template <class _Tp>
	+struct __can_convert_char {
	+ static const bool value = false;
	+};
	+template <class _Tp>
	+struct __can_convert_char<const _Tp> : public __can_convert_char<_Tp> {};
	+template <>
	+struct __can_convert_char<char> {
	+ static const bool value = true;
	+ using __char_type = char;
	+};
	+template <>
	+struct __can_convert_char<wchar_t> {
	+ static const bool value = true;
	+ using __char_type = wchar_t;
	+};
	+template <>
	+struct __can_convert_char<char16_t> {
	+ static const bool value = true;
	+ using __char_type = char16_t;
	+};
	+template <>
	+struct __can_convert_char<char32_t> {
	+ static const bool value = true;
	+ using __char_type = char32_t;
	+};
	+
	+template <class _ECharT>
	+typename enable_if<__can_convert_char<_ECharT>::value, bool>::type
	+__is_separator(_ECharT __e) {
	+ return __e == _ECharT('/');
	+};
	+
	+struct _NullSentinal {};
	+
	+template <class _Tp>
	+using _Void = void;
	+
	+template <class _Tp, class = void>
	+struct __is_pathable_string : public false_type {};
	+
	+template <class _ECharT, class _Traits, class _Alloc>
	+struct __is_pathable_string<
	+ basic_string<_ECharT, _Traits, _Alloc>,
	+ _Void<typename __can_convert_char<_ECharT>::__char_type> >
	+ : public __can_convert_char<_ECharT> {
	+ using _Str = basic_string<_ECharT, _Traits, _Alloc>;
	+ using _Base = __can_convert_char<_ECharT>;
	+ static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
	+ static _ECharT const* __range_end(_Str const& __s) {
	+ return __s.data() + __s.length();
	+ }
	+ static _ECharT __first_or_null(_Str const& __s) {
	+ return __s.empty() ? _ECharT{} : __s[0];
	+ }
	+};
	+
	+template <class _ECharT, class _Traits>
	+struct __is_pathable_string<
	+ basic_string_view<_ECharT, _Traits>,
	+ _Void<typename __can_convert_char<_ECharT>::__char_type> >
	+ : public __can_convert_char<_ECharT> {
	+ using _Str = basic_string_view<_ECharT, _Traits>;
	+ using _Base = __can_convert_char<_ECharT>;
	+ static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
	+ static _ECharT const* __range_end(_Str const& __s) {
	+ return __s.data() + __s.length();
	+ }
	+ static _ECharT __first_or_null(_Str const& __s) {
	+ return __s.empty() ? _ECharT{} : __s[0];
	+ }
	+};
	+
	+template <class _Source, class _DS = typename decay<_Source>::type,
	+ class _UnqualPtrType =
	+ typename remove_const<typename remove_pointer<_DS>::type>::type,
	+ bool _IsCharPtr = is_pointer<_DS>::value&&
	+ __can_convert_char<_UnqualPtrType>::value>
	+struct __is_pathable_char_array : false_type {};
	+
	+template <class _Source, class _ECharT, class _UPtr>
	+struct __is_pathable_char_array<_Source, _ECharT*, _UPtr, true>
	+ : __can_convert_char<typename remove_const<_ECharT>::type> {
	+ using _Base = __can_convert_char<typename remove_const<_ECharT>::type>;
	+
	+ static _ECharT const* __range_begin(const _ECharT* __b) { return __b; }
	+ static _ECharT const* __range_end(const _ECharT* __b) {
	+ using _Iter = const _ECharT*;
	+ const _ECharT __sentinal = _ECharT{};
	+ _Iter __e = __b;
	+ for (; *__e != __sentinal; ++__e)
	+ ;
	+ return __e;
	+ }
	+
	+ static _ECharT __first_or_null(const _ECharT* __b) { return *__b; }
	+};
	+
	+template <class _Iter, bool _IsIt = __is_input_iterator<_Iter>::value,
	+ class = void>
	+struct __is_pathable_iter : false_type {};
	+
	+template <class _Iter>
	+struct __is_pathable_iter<
	+ _Iter, true,
	+ _Void<typename __can_convert_char<
	+ typename iterator_traits<_Iter>::value_type>::__char_type> >
	+ : __can_convert_char<typename iterator_traits<_Iter>::value_type> {
	+ using _ECharT = typename iterator_traits<_Iter>::value_type;
	+ using _Base = __can_convert_char<_ECharT>;
	+
	+ static _Iter __range_begin(_Iter __b) { return __b; }
	+ static _NullSentinal __range_end(_Iter) { return _NullSentinal{}; }
	+
	+ static _ECharT __first_or_null(_Iter __b) { return *__b; }
	+};
	+
	+template <class _Tp, bool _IsStringT = __is_pathable_string<_Tp>::value,
	+ bool _IsCharIterT = __is_pathable_char_array<_Tp>::value,
	+ bool _IsIterT = !_IsCharIterT && __is_pathable_iter<_Tp>::value>
	+struct __is_pathable : false_type {
	+ static_assert(!_IsStringT && !_IsCharIterT && !_IsIterT, "Must all be false");
	+};
	+
	+template <class _Tp>
	+struct __is_pathable<_Tp, true, false, false> : __is_pathable_string<_Tp> {};
	+
	+template <class _Tp>
	+struct __is_pathable<_Tp, false, true, false> : __is_pathable_char_array<_Tp> {
	+};
	+
	+template <class _Tp>
	+struct __is_pathable<_Tp, false, false, true> : __is_pathable_iter<_Tp> {};
	+
	+template <class _ECharT>
	+struct _PathCVT {
	+ static_assert(__can_convert_char<_ECharT>::value,
	+ "Char type not convertible");
	+
	+ typedef __narrow_to_utf8<sizeof(_ECharT) * __CHAR_BIT__> _Narrower;
	+
	+ static void __append_range(string& __dest, _ECharT const* __b,
	+ _ECharT const* __e) {
	+ _Narrower()(back_inserter(__dest), __b, __e);
	+ }
	+
	+ template <class _Iter>
	+ static void __append_range(string& __dest, _Iter __b, _Iter __e) {
	+ static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
	+ if (__b == __e)
	+ return;
	+ basic_string<_ECharT> __tmp(__b, __e);
	+ _Narrower()(back_inserter(__dest), __tmp.data(),
	+ __tmp.data() + __tmp.length());
	+ }
	+
	+ template <class _Iter>
	+ static void __append_range(string& __dest, _Iter __b, _NullSentinal) {
	+ static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
	+ const _ECharT __sentinal = _ECharT{};
	+ if (*__b == __sentinal)
	+ return;
	+ basic_string<_ECharT> __tmp;
	+ for (; *__b != __sentinal; ++__b)
	+ __tmp.push_back(*__b);
	+ _Narrower()(back_inserter(__dest), __tmp.data(),
	+ __tmp.data() + __tmp.length());
	+ }
	+
	+ template <class _Source>
	+ static void __append_source(string& __dest, _Source const& __s) {
	+ using _Traits = __is_pathable<_Source>;
	+ __append_range(__dest, _Traits::__range_begin(__s),
	+ _Traits::__range_end(__s));
	+ }
	+};
	+
	+template <>
	+struct _PathCVT<char> {
	+
	+ template <class _Iter>
	+ static typename enable_if<__is_exactly_input_iterator<_Iter>::value>::type
	+ __append_range(string& __dest, _Iter __b, _Iter __e) {
	+ for (; __b != __e; ++__b)
	+ __dest.push_back(*__b);
	+ }
	+
	+ template <class _Iter>
	+ static typename enable_if<__is_forward_iterator<_Iter>::value>::type
	+ __append_range(string& __dest, _Iter __b, _Iter __e) {
	+ __dest.__append_forward_unsafe(__b, __e);
	+ }
	+
	+ template <class _Iter>
	+ static void __append_range(string& __dest, _Iter __b, _NullSentinal) {
	+ const char __sentinal = char{};
	+ for (; *__b != __sentinal; ++__b)
	+ __dest.push_back(*__b);
	+ }
	+
	+ template <class _Source>
	+ static void __append_source(string& __dest, _Source const& __s) {
	+ using _Traits = __is_pathable<_Source>;
	+ __append_range(__dest, _Traits::__range_begin(__s),
	+ _Traits::__range_end(__s));
	+ }
	+};
	+
	+class _LIBCPP_TYPE_VIS path {
	+ template <class _SourceOrIter, class _Tp = path&>
	+ using _EnableIfPathable =
	+ typename enable_if<__is_pathable<_SourceOrIter>::value, _Tp>::type;
	+
	+ template <class _Tp>
	+ using _SourceChar = typename __is_pathable<_Tp>::__char_type;
	+
	+ template <class _Tp>
	+ using _SourceCVT = _PathCVT<_SourceChar<_Tp> >;
	+
	+public:
	+ typedef char value_type;
	+ typedef basic_string<value_type> string_type;
	+ typedef _VSTD::string_view __string_view;
	+ static constexpr value_type preferred_separator = '/';
	+
	+ enum class _LIBCPP_ENUM_VIS format : unsigned char {
	+ auto_format,
	+ native_format,
	+ generic_format
	+ };
	+
	+ // constructors and destructor
	+ _LIBCPP_INLINE_VISIBILITY path() noexcept {}
	+ _LIBCPP_INLINE_VISIBILITY path(const path& __p) : __pn_(__p.__pn_) {}
	+ _LIBCPP_INLINE_VISIBILITY path(path&& __p) noexcept
	+ : __pn_(_VSTD::move(__p.__pn_)) {}
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ path(string_type&& __s, format = format::auto_format) noexcept
	+ : __pn_(_VSTD::move(__s)) {}
	+
	+ template <class _Source, class = _EnableIfPathable<_Source, void> >
	+ path(const _Source& __src, format = format::auto_format) {
	+ _SourceCVT<_Source>::__append_source(__pn_, __src);
	+ }
	+
	+ template <class _InputIt>
	+ path(_InputIt __first, _InputIt __last, format = format::auto_format) {
	+ typedef typename iterator_traits<_InputIt>::value_type _ItVal;
	+ _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
	+ }
	+
	+ // TODO Implement locale conversions.
	+ template <class _Source, class = _EnableIfPathable<_Source, void> >
	+ path(const _Source& __src, const locale& __loc, format = format::auto_format);
	+ template <class _InputIt>
	+ path(_InputIt __first, _InputIt _last, const locale& __loc,
	+ format = format::auto_format);
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ ~path() = default;
	+
	+ // assignments
	+ _LIBCPP_INLINE_VISIBILITY
	+ path& operator=(const path& __p) {
	+ __pn_ = __p.__pn_;
	+ return *this;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ path& operator=(path&& __p) noexcept {
	+ __pn_ = _VSTD::move(__p.__pn_);
	+ return *this;
	+ }
	+
	+ template <class = void>
	+ _LIBCPP_INLINE_VISIBILITY path& operator=(string_type&& __s) noexcept {
	+ __pn_ = _VSTD::move(__s);
	+ return *this;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ path& assign(string_type&& __s) noexcept {
	+ __pn_ = _VSTD::move(__s);
	+ return *this;
	+ }
	+
	+ template <class _Source>
	+ _LIBCPP_INLINE_VISIBILITY _EnableIfPathable<_Source>
	+ operator=(const _Source& __src) {
	+ return this->assign(__src);
	+ }
	+
	+ template <class _Source>
	+ _EnableIfPathable<_Source> assign(const _Source& __src) {
	+ __pn_.clear();
	+ _SourceCVT<_Source>::__append_source(__pn_, __src);
	+ return *this;
	+ }
	+
	+ template <class _InputIt>
	+ path& assign(_InputIt __first, _InputIt __last) {
	+ typedef typename iterator_traits<_InputIt>::value_type _ItVal;
	+ __pn_.clear();
	+ _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
	+ return *this;
	+ }
	+
	+private:
	+ template <class _ECharT>
	+ static bool __source_is_absolute(_ECharT __first_or_null) {
	+ return __is_separator(__first_or_null);
	+ }
	+
	+public:
	+ // appends
	+ path& operator/=(const path& __p) {
	+ if (__p.is_absolute()) {
	+ __pn_ = __p.__pn_;
	+ return *this;
	+ }
	+ if (has_filename())
	+ __pn_ += preferred_separator;
	+ __pn_ += __p.native();
	+ return *this;
	+ }
	+
	+ // FIXME: Use _LIBCPP_DIAGNOSE_WARNING to produce a diagnostic when __src
	+ // is known at compile time to be "/' since the user almost certainly intended
	+ // to append a separator instead of overwriting the path with "/"
	+ template <class _Source>
	+ _LIBCPP_INLINE_VISIBILITY _EnableIfPathable<_Source>
	+ operator/=(const _Source& __src) {
	+ return this->append(__src);
	+ }
	+
	+ template <class _Source>
	+ _EnableIfPathable<_Source> append(const _Source& __src) {
	+ using _Traits = __is_pathable<_Source>;
	+ using _CVT = _PathCVT<_SourceChar<_Source> >;
	+ if (__source_is_absolute(_Traits::__first_or_null(__src)))
	+ __pn_.clear();
	+ else if (has_filename())
	+ __pn_ += preferred_separator;
	+ _CVT::__append_source(__pn_, __src);
	+ return *this;
	+ }
	+
	+ template <class _InputIt>
	+ path& append(_InputIt __first, _InputIt __last) {
	+ typedef typename iterator_traits<_InputIt>::value_type _ItVal;
	+ static_assert(__can_convert_char<_ItVal>::value, "Must convertible");
	+ using _CVT = _PathCVT<_ItVal>;
	+ if (__first != __last && __source_is_absolute(*__first))
	+ __pn_.clear();
	+ else if (has_filename())
	+ __pn_ += preferred_separator;
	+ _CVT::__append_range(__pn_, __first, __last);
	+ return *this;
	+ }
	+
	+ // concatenation
	+ _LIBCPP_INLINE_VISIBILITY
	+ path& operator+=(const path& __x) {
	+ __pn_ += __x.__pn_;
	+ return *this;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ path& operator+=(const string_type& __x) {
	+ __pn_ += __x;
	+ return *this;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ path& operator+=(__string_view __x) {
	+ __pn_ += __x;
	+ return *this;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ path& operator+=(const value_type* __x) {
	+ __pn_ += __x;
	+ return *this;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ path& operator+=(value_type __x) {
	+ __pn_ += __x;
	+ return *this;
	+ }
	+
	+ template <class _ECharT>
	+ typename enable_if<__can_convert_char<_ECharT>::value, path&>::type
	+ operator+=(_ECharT __x) {
	+ basic_string<_ECharT> __tmp;
	+ __tmp += __x;
	+ _PathCVT<_ECharT>::__append_source(__pn_, __tmp);
	+ return *this;
	+ }
	+
	+ template <class _Source>
	+ _EnableIfPathable<_Source> operator+=(const _Source& __x) {
	+ return this->concat(__x);
	+ }
	+
	+ template <class _Source>
	+ _EnableIfPathable<_Source> concat(const _Source& __x) {
	+ _SourceCVT<_Source>::__append_source(__pn_, __x);
	+ return *this;
	+ }
	+
	+ template <class _InputIt>
	+ path& concat(_InputIt __first, _InputIt __last) {
	+ typedef typename iterator_traits<_InputIt>::value_type _ItVal;
	+ _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
	+ return *this;
	+ }
	+
	+ // modifiers
	+ _LIBCPP_INLINE_VISIBILITY
	+ void clear() noexcept { __pn_.clear(); }
	+
	+ path& make_preferred() { return *this; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ path& remove_filename() {
	+ auto __fname = __filename();
	+ if (!__fname.empty())
	+ __pn_.erase(__fname.data() - __pn_.data());
	+ return *this;
	+ }
	+
	+ path& replace_filename(const path& __replacement) {
	+ remove_filename();
	+ return (*this /= __replacement);
	+ }
	+
	+ path& replace_extension(const path& __replacement = path());
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void swap(path& __rhs) noexcept { __pn_.swap(__rhs.__pn_); }
	+
	+ // private helper to allow reserving memory in the path
	+ _LIBCPP_INLINE_VISIBILITY
	+ void __reserve(size_t __s) { __pn_.reserve(__s); }
	+
	+ // native format observers
	+ _LIBCPP_INLINE_VISIBILITY
	+ const string_type& native() const noexcept { return __pn_; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ const value_type* c_str() const noexcept { return __pn_.c_str(); }
	+
	+ _LIBCPP_INLINE_VISIBILITY operator string_type() const { return __pn_; }
	+
	+ template <class _ECharT, class _Traits = char_traits<_ECharT>,
	+ class _Allocator = allocator<_ECharT> >
	+ basic_string<_ECharT, _Traits, _Allocator>
	+ string(const _Allocator& __a = _Allocator()) const {
	+ using _CVT = __widen_from_utf8<sizeof(_ECharT) * __CHAR_BIT__>;
	+ using _Str = basic_string<_ECharT, _Traits, _Allocator>;
	+ _Str __s(__a);
	+ __s.reserve(__pn_.size());
	+ _CVT()(back_inserter(__s), __pn_.data(), __pn_.data() + __pn_.size());
	+ return __s;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY std::string string() const { return __pn_; }
	+ _LIBCPP_INLINE_VISIBILITY std::wstring wstring() const {
	+ return string<wchar_t>();
	+ }
	+ _LIBCPP_INLINE_VISIBILITY std::string u8string() const { return __pn_; }
	+ _LIBCPP_INLINE_VISIBILITY std::u16string u16string() const {
	+ return string<char16_t>();
	+ }
	+ _LIBCPP_INLINE_VISIBILITY std::u32string u32string() const {
	+ return string<char32_t>();
	+ }
	+
	+ // generic format observers
	+ template <class _ECharT, class _Traits = char_traits<_ECharT>,
	+ class _Allocator = allocator<_ECharT> >
	+ basic_string<_ECharT, _Traits, _Allocator>
	+ generic_string(const _Allocator& __a = _Allocator()) const {
	+ return string<_ECharT, _Traits, _Allocator>(__a);
	+ }
	+
	+ std::string generic_string() const { return __pn_; }
	+ std::wstring generic_wstring() const { return string<wchar_t>(); }
	+ std::string generic_u8string() const { return __pn_; }
	+ std::u16string generic_u16string() const { return string<char16_t>(); }
	+ std::u32string generic_u32string() const { return string<char32_t>(); }
	+
	+private:
	+ int __compare(__string_view) const;
	+ __string_view __root_name() const;
	+ __string_view __root_directory() const;
	+ __string_view __root_path_raw() const;
	+ __string_view __relative_path() const;
	+ __string_view __parent_path() const;
	+ __string_view __filename() const;
	+ __string_view __stem() const;
	+ __string_view __extension() const;
	+
	+public:
	+ // compare
	+ _LIBCPP_INLINE_VISIBILITY int compare(const path& __p) const noexcept {
	+ return __compare(__p.__pn_);
	+ }
	+ _LIBCPP_INLINE_VISIBILITY int compare(const string_type& __s) const {
	+ return __compare(__s);
	+ }
	+ _LIBCPP_INLINE_VISIBILITY int compare(__string_view __s) const {
	+ return __compare(__s);
	+ }
	+ _LIBCPP_INLINE_VISIBILITY int compare(const value_type* __s) const {
	+ return __compare(__s);
	+ }
	+
	+ // decomposition
	+ _LIBCPP_INLINE_VISIBILITY path root_name() const {
	+ return string_type(__root_name());
	+ }
	+ _LIBCPP_INLINE_VISIBILITY path root_directory() const {
	+ return string_type(__root_directory());
	+ }
	+ _LIBCPP_INLINE_VISIBILITY path root_path() const {
	+ return root_name().append(string_type(__root_directory()));
	+ }
	+ _LIBCPP_INLINE_VISIBILITY path relative_path() const {
	+ return string_type(__relative_path());
	+ }
	+ _LIBCPP_INLINE_VISIBILITY path parent_path() const {
	+ return string_type(__parent_path());
	+ }
	+ _LIBCPP_INLINE_VISIBILITY path filename() const {
	+ return string_type(__filename());
	+ }
	+ _LIBCPP_INLINE_VISIBILITY path stem() const { return string_type(__stem()); }
	+ _LIBCPP_INLINE_VISIBILITY path extension() const {
	+ return string_type(__extension());
	+ }
	+
	+ // query
	+ _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();
	+ }
	+ _LIBCPP_INLINE_VISIBILITY bool has_root_path() const {
	+ return !__root_path_raw().empty();
	+ }
	+ _LIBCPP_INLINE_VISIBILITY bool has_relative_path() const {
	+ return !__relative_path().empty();
	+ }
	+ _LIBCPP_INLINE_VISIBILITY bool has_parent_path() const {
	+ return !__parent_path().empty();
	+ }
	+ _LIBCPP_INLINE_VISIBILITY bool has_filename() const {
	+ return !__filename().empty();
	+ }
	+ _LIBCPP_INLINE_VISIBILITY bool has_stem() const { return !__stem().empty(); }
	+ _LIBCPP_INLINE_VISIBILITY bool has_extension() const {
	+ return !__extension().empty();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY bool is_absolute() const {
	+ return has_root_directory();
	+ }
	+ _LIBCPP_INLINE_VISIBILITY bool is_relative() const { return !is_absolute(); }
	+
	+ // relative paths
	+ path lexically_normal() const;
	+ path lexically_relative(const path& __base) const;
	+
	+ _LIBCPP_INLINE_VISIBILITY path lexically_proximate(const path& __base) const {
	+ path __result = this->lexically_relative(__base);
	+ if (__result.native().empty())
	+ return *this;
	+ return __result;
	+ }
	+
	+ // iterators
	+ class _LIBCPP_TYPE_VIS iterator;
	+ typedef iterator const_iterator;
	+
	+ iterator begin() const;
	+ iterator end() const;
	+
	+ template <class _CharT, class _Traits>
	+ _LIBCPP_INLINE_VISIBILITY friend
	+ typename enable_if<is_same<_CharT, char>::value &&
	+ is_same<_Traits, char_traits<char> >::value,
	+ basic_ostream<_CharT, _Traits>&>::type
	+ operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
	+ __os << std::__quoted(__p.native());
	+ return __os;
	+ }
	+
	+ template <class _CharT, class _Traits>
	+ _LIBCPP_INLINE_VISIBILITY friend
	+ typename enable_if<!is_same<_CharT, char>::value \|\|
	+ !is_same<_Traits, char_traits<char> >::value,
	+ basic_ostream<_CharT, _Traits>&>::type
	+ operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
	+ __os << std::__quoted(__p.string<_CharT, _Traits>());
	+ return __os;
	+ }
	+
	+ template <class _CharT, class _Traits>
	+ _LIBCPP_INLINE_VISIBILITY friend basic_istream<_CharT, _Traits>&
	+ operator>>(basic_istream<_CharT, _Traits>& __is, path& __p) {
	+ basic_string<_CharT, _Traits> __tmp;
	+ __is >> __quoted(__tmp);
	+ __p = __tmp;
	+ return __is;
	+ }
	+
	+private:
	+ inline _LIBCPP_INLINE_VISIBILITY path&
	+ __assign_view(__string_view const& __s) noexcept {
	+ __pn_ = string_type(__s);
	+ return *this;
	+ }
	+ string_type __pn_;
	+};
	+
	+inline _LIBCPP_INLINE_VISIBILITY void swap(path& __lhs, path& __rhs) noexcept {
	+ __lhs.swap(__rhs);
	+}
	+
	+_LIBCPP_FUNC_VIS
	+size_t hash_value(const path& __p) noexcept;
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool operator==(const path& __lhs,
	+ const path& __rhs) noexcept {
	+ return __lhs.compare(__rhs) == 0;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const path& __lhs,
	+ const path& __rhs) noexcept {
	+ return __lhs.compare(__rhs) != 0;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool operator<(const path& __lhs,
	+ const path& __rhs) noexcept {
	+ return __lhs.compare(__rhs) < 0;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool operator<=(const path& __lhs,
	+ const path& __rhs) noexcept {
	+ return __lhs.compare(__rhs) <= 0;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool operator>(const path& __lhs,
	+ const path& __rhs) noexcept {
	+ return __lhs.compare(__rhs) > 0;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool operator>=(const path& __lhs,
	+ const path& __rhs) noexcept {
	+ return __lhs.compare(__rhs) >= 0;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path operator/(const path& __lhs,
	+ const path& __rhs) {
	+ path __result(__lhs);
	+ __result /= __rhs;
	+ return __result;
	+}
	+
	+template <class _Source>
	+_LIBCPP_INLINE_VISIBILITY
	+ typename enable_if<__is_pathable<_Source>::value, path>::type
	+ u8path(const _Source& __s) {
	+ static_assert(
	+ is_same<typename __is_pathable<_Source>::__char_type, char>::value,
	+ "u8path(Source const&) requires Source have a character type of type "
	+ "'char'");
	+ return path(__s);
	+}
	+
	+template <class _InputIt>
	+_LIBCPP_INLINE_VISIBILITY
	+ typename enable_if<__is_pathable<_InputIt>::value, path>::type
	+ u8path(_InputIt __f, _InputIt __l) {
	+ static_assert(
	+ is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
	+ "u8path(Iter, Iter) requires Iter have a value_type of type 'char'");
	+ return path(__f, __l);
	+}
	+
	+class _LIBCPP_TYPE_VIS path::iterator {
	+public:
	+ enum _ParserState : unsigned char {
	+ _Singular,
	+ _BeforeBegin,
	+ _InRootName,
	+ _InRootDir,
	+ _InFilenames,
	+ _InTrailingSep,
	+ _AtEnd
	+ };
	+
	+public:
	+ typedef bidirectional_iterator_tag iterator_category;
	+
	+ typedef path value_type;
	+ typedef std::ptrdiff_t difference_type;
	+ typedef const path* pointer;
	+ typedef const path& reference;
	+
	+ typedef void
	+ __stashing_iterator_tag; // See reverse_iterator and __is_stashing_iterator
	+
	+public:
	+ _LIBCPP_INLINE_VISIBILITY
	+ iterator()
	+ : __stashed_elem_(), __path_ptr_(nullptr), __entry_(),
	+ __state_(_Singular) {}
	+
	+ iterator(const iterator&) = default;
	+ ~iterator() = default;
	+
	+ iterator& operator=(const iterator&) = default;
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ reference operator*() const { return __stashed_elem_; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ pointer operator->() const { return &__stashed_elem_; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ iterator& operator++() {
	+ _LIBCPP_ASSERT(__state_ != _Singular,
	+ "attempting to increment a singular iterator");
	+ _LIBCPP_ASSERT(__state_ != _AtEnd,
	+ "attempting to increment the end iterator");
	+ return __increment();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ iterator operator++(int) {
	+ iterator __it(*this);
	+ this->operator++();
	+ return __it;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ iterator& operator--() {
	+ _LIBCPP_ASSERT(__state_ != _Singular,
	+ "attempting to decrement a singular iterator");
	+ _LIBCPP_ASSERT(__entry_.data() != __path_ptr_->native().data(),
	+ "attempting to decrement the begin iterator");
	+ return __decrement();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ iterator operator--(int) {
	+ iterator __it(*this);
	+ this->operator--();
	+ return __it;
	+ }
	+
	+private:
	+ friend class path;
	+
	+ inline _LIBCPP_INLINE_VISIBILITY friend bool operator==(const iterator&,
	+ const iterator&);
	+
	+ iterator& __increment();
	+ iterator& __decrement();
	+
	+ path __stashed_elem_;
	+ const path* __path_ptr_;
	+ path::__string_view __entry_;
	+ _ParserState __state_;
	+};
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool operator==(const path::iterator& __lhs,
	+ const path::iterator& __rhs) {
	+ return __lhs.__path_ptr_ == __rhs.__path_ptr_ &&
	+ __lhs.__entry_.data() == __rhs.__entry_.data();
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const path::iterator& __lhs,
	+ const path::iterator& __rhs) {
	+ return !(__lhs == __rhs);
	+}
	+
	+class _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error {
	+public:
	+ _LIBCPP_INLINE_VISIBILITY
	+ filesystem_error(const string& __what, error_code __ec)
	+ : system_error(__ec, __what),
	+ __storage_(make_shared<_Storage>(path(), path())) {
	+ __create_what(0);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ filesystem_error(const string& __what, const path& __p1, error_code __ec)
	+ : system_error(__ec, __what),
	+ __storage_(make_shared<_Storage>(__p1, path())) {
	+ __create_what(1);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ filesystem_error(const string& __what, const path& __p1, const path& __p2,
	+ error_code __ec)
	+ : system_error(__ec, __what),
	+ __storage_(make_shared<_Storage>(__p1, __p2)) {
	+ __create_what(2);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ const path& path1() const noexcept { return __storage_->__p1_; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ const path& path2() const noexcept { return __storage_->__p2_; }
	+
	+ ~filesystem_error() override; // key function
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ const char* what() const noexcept override {
	+ return __storage_->__what_.c_str();
	+ }
	+
	+ _LIBCPP_FUNC_VIS
	+ void __create_what(int __num_paths);
	+
	+private:
	+ struct _Storage {
	+ _LIBCPP_INLINE_VISIBILITY
	+ _Storage(const path& __p1, const path& __p2) : __p1_(__p1), __p2_(__p2) {}
	+
	+ path __p1_;
	+ path __p2_;
	+ string __what_;
	+ };
	+ shared_ptr<_Storage> __storage_;
	+};
	+
	+template <class... _Args>
	+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
	+#ifndef _LIBCPP_NO_EXCEPTIONS
	+ void
	+ __throw_filesystem_error(_Args&&... __args) {
	+ throw filesystem_error(std::forward<_Args>(__args)...);
	+}
	+#else
	+ void
	+ __throw_filesystem_error(_Args&&...) {
	+ _VSTD::abort();
	+}
	+#endif
	+
	+// operational functions
	+
	+_LIBCPP_FUNC_VIS
	+path __absolute(const path&, error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+path __canonical(const path&, error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+void __copy(const path& __from, const path& __to, copy_options __opt,
	+ error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+bool __copy_file(const path& __from, const path& __to, copy_options __opt,
	+ error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+void __copy_symlink(const path& __existing_symlink, const path& __new_symlink,
	+ error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+bool __create_directories(const path& p, error_code* ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+bool __create_directory(const path& p, error_code* ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+bool __create_directory(const path& p, const path& attributes,
	+ error_code* ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+void __create_directory_symlink(const path& __to, const path& __new_symlink,
	+ error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+void __create_hard_link(const path& __to, const path& __new_hard_link,
	+ error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+void __create_symlink(const path& __to, const path& __new_symlink,
	+ error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+path __current_path(error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+void __current_path(const path&, error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+bool __equivalent(const path&, const path&, error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+uintmax_t __file_size(const path&, error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+uintmax_t __hard_link_count(const path&, error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+bool __fs_is_empty(const path& p, error_code* ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+file_time_type __last_write_time(const path& p, error_code* ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+void __last_write_time(const path& p, file_time_type new_time,
	+ error_code* ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+void __permissions(const path&, perms, perm_options, error_code* = nullptr);
	+_LIBCPP_FUNC_VIS
	+path __read_symlink(const path& p, error_code* ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+bool __remove(const path& p, error_code* ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+uintmax_t __remove_all(const path& p, error_code* ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+void __rename(const path& from, const path& to, error_code* ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+void __resize_file(const path& p, uintmax_t size, error_code* ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+space_info __space(const path&, error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+file_status __status(const path&, error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+file_status __symlink_status(const path&, error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+path __system_complete(const path&, error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+path __temp_directory_path(error_code* __ec = nullptr);
	+_LIBCPP_FUNC_VIS
	+path __weakly_canonical(path const& __p, error_code* __ec = nullptr);
	+
	+inline _LIBCPP_INLINE_VISIBILITY path current_path() {
	+ return __current_path();
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path current_path(error_code& __ec) {
	+ return __current_path(&__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void current_path(const path& __p) {
	+ __current_path(__p);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void current_path(const path& __p,
	+ error_code& __ec) noexcept {
	+ __current_path(__p, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path absolute(const path& __p) {
	+ return __absolute(__p);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path absolute(const path& __p,
	+ error_code& __ec) {
	+ return __absolute(__p, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path canonical(const path& __p) {
	+ return __canonical(__p);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path canonical(const path& __p,
	+ error_code& __ec) {
	+ return __canonical(__p, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from,
	+ const path& __to) {
	+ __copy(__from, __to, copy_options::none);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
	+ error_code& __ec) {
	+ __copy(__from, __to, copy_options::none, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
	+ copy_options __opt) {
	+ __copy(__from, __to, __opt);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
	+ copy_options __opt,
	+ error_code& __ec) {
	+ __copy(__from, __to, __opt, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool copy_file(const path& __from,
	+ const path& __to) {
	+ return __copy_file(__from, __to, copy_options::none);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool
	+copy_file(const path& __from, const path& __to, error_code& __ec) {
	+ return __copy_file(__from, __to, copy_options::none, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool
	+copy_file(const path& __from, const path& __to, copy_options __opt) {
	+ return __copy_file(__from, __to, __opt);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool copy_file(const path& __from,
	+ const path& __to,
	+ copy_options __opt,
	+ error_code& __ec) {
	+ return __copy_file(__from, __to, __opt, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void copy_symlink(const path& __existing,
	+ const path& __new) {
	+ __copy_symlink(__existing, __new);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void
	+copy_symlink(const path& __ext, const path& __new, error_code& __ec) noexcept {
	+ __copy_symlink(__ext, __new, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool create_directories(const path& __p) {
	+ return __create_directories(__p);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool create_directories(const path& __p,
	+ error_code& __ec) {
	+ return __create_directories(__p, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool create_directory(const path& __p) {
	+ return __create_directory(__p);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool
	+create_directory(const path& __p, error_code& __ec) noexcept {
	+ return __create_directory(__p, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool create_directory(const path& __p,
	+ const path& __attrs) {
	+ return __create_directory(__p, __attrs);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool
	+create_directory(const path& __p, const path& __attrs,
	+ error_code& __ec) noexcept {
	+ return __create_directory(__p, __attrs, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void
	+create_directory_symlink(const path& __to, const path& __new) {
	+ __create_directory_symlink(__to, __new);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void
	+create_directory_symlink(const path& __to, const path& __new,
	+ error_code& __ec) noexcept {
	+ __create_directory_symlink(__to, __new, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void create_hard_link(const path& __to,
	+ const path& __new) {
	+ __create_hard_link(__to, __new);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void
	+create_hard_link(const path& __to, const path& __new,
	+ error_code& __ec) noexcept {
	+ __create_hard_link(__to, __new, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void create_symlink(const path& __to,
	+ const path& __new) {
	+ __create_symlink(__to, __new);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void
	+create_symlink(const path& __to, const path& __new, error_code& __ec) noexcept {
	+ return __create_symlink(__to, __new, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool status_known(file_status __s) noexcept {
	+ return __s.type() != file_type::none;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool exists(file_status __s) noexcept {
	+ return status_known(__s) && __s.type() != file_type::not_found;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool exists(const path& __p) {
	+ return exists(__status(__p));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool exists(const path& __p,
	+ error_code& __ec) noexcept {
	+ auto __s = __status(__p, &__ec);
	+ if (status_known(__s))
	+ __ec.clear();
	+ return exists(__s);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool equivalent(const path& __p1,
	+ const path& __p2) {
	+ return __equivalent(__p1, __p2);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool
	+equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept {
	+ return __equivalent(__p1, __p2, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY uintmax_t file_size(const path& __p) {
	+ return __file_size(__p);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY uintmax_t
	+file_size(const path& __p, error_code& __ec) noexcept {
	+ return __file_size(__p, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY uintmax_t hard_link_count(const path& __p) {
	+ return __hard_link_count(__p);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY uintmax_t
	+hard_link_count(const path& __p, error_code& __ec) noexcept {
	+ return __hard_link_count(__p, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(file_status __s) noexcept {
	+ return __s.type() == file_type::block;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(const path& __p) {
	+ return is_block_file(__status(__p));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(const path& __p,
	+ error_code& __ec) noexcept {
	+ return is_block_file(__status(__p, &__ec));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool
	+is_character_file(file_status __s) noexcept {
	+ return __s.type() == file_type::character;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_character_file(const path& __p) {
	+ return is_character_file(__status(__p));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool
	+is_character_file(const path& __p, error_code& __ec) noexcept {
	+ return is_character_file(__status(__p, &__ec));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_directory(file_status __s) noexcept {
	+ return __s.type() == file_type::directory;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_directory(const path& __p) {
	+ return is_directory(__status(__p));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_directory(const path& __p,
	+ error_code& __ec) noexcept {
	+ return is_directory(__status(__p, &__ec));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_empty(const path& __p) {
	+ return __fs_is_empty(__p);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_empty(const path& __p,
	+ error_code& __ec) {
	+ return __fs_is_empty(__p, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(file_status __s) noexcept {
	+ return __s.type() == file_type::fifo;
	+}
	+inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(const path& __p) {
	+ return is_fifo(__status(__p));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(const path& __p,
	+ error_code& __ec) noexcept {
	+ return is_fifo(__status(__p, &__ec));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool
	+is_regular_file(file_status __s) noexcept {
	+ return __s.type() == file_type::regular;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_regular_file(const path& __p) {
	+ return is_regular_file(__status(__p));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool
	+is_regular_file(const path& __p, error_code& __ec) noexcept {
	+ return is_regular_file(__status(__p, &__ec));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_socket(file_status __s) noexcept {
	+ return __s.type() == file_type::socket;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_socket(const path& __p) {
	+ return is_socket(__status(__p));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_socket(const path& __p,
	+ error_code& __ec) noexcept {
	+ return is_socket(__status(__p, &__ec));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(file_status __s) noexcept {
	+ return __s.type() == file_type::symlink;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(const path& __p) {
	+ return is_symlink(__symlink_status(__p));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(const path& __p,
	+ error_code& __ec) noexcept {
	+ return is_symlink(__symlink_status(__p, &__ec));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_other(file_status __s) noexcept {
	+ return exists(__s) && !is_regular_file(__s) && !is_directory(__s) &&
	+ !is_symlink(__s);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_other(const path& __p) {
	+ return is_other(__status(__p));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool is_other(const path& __p,
	+ error_code& __ec) noexcept {
	+ return is_other(__status(__p, &__ec));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY file_time_type
	+last_write_time(const path& __p) {
	+ return __last_write_time(__p);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY file_time_type
	+last_write_time(const path& __p, error_code& __ec) noexcept {
	+ return __last_write_time(__p, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void last_write_time(const path& __p,
	+ file_time_type __t) {
	+ __last_write_time(__p, __t);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void
	+last_write_time(const path& __p, file_time_type __t,
	+ error_code& __ec) noexcept {
	+ __last_write_time(__p, __t, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void
	+permissions(const path& __p, perms __prms,
	+ perm_options __opts = perm_options::replace) {
	+ __permissions(__p, __prms, __opts);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void permissions(const path& __p, perms __prms,
	+ error_code& __ec) noexcept {
	+ __permissions(__p, __prms, perm_options::replace, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void permissions(const path& __p, perms __prms,
	+ perm_options __opts,
	+ error_code& __ec) {
	+ __permissions(__p, __prms, __opts, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p,
	+ const path& __base,
	+ error_code& __ec) {
	+ path __tmp = __weakly_canonical(__p, &__ec);
	+ if (__ec)
	+ return {};
	+ path __tmp_base = __weakly_canonical(__base, &__ec);
	+ if (__ec)
	+ return {};
	+ return __tmp.lexically_proximate(__tmp_base);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p,
	+ error_code& __ec) {
	+ return proximate(__p, current_path(), __ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path
	+proximate(const path& __p, const path& __base = current_path()) {
	+ return __weakly_canonical(__p).lexically_proximate(
	+ __weakly_canonical(__base));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path read_symlink(const path& __p) {
	+ return __read_symlink(__p);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path read_symlink(const path& __p,
	+ error_code& __ec) {
	+ return __read_symlink(__p, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p,
	+ const path& __base,
	+ error_code& __ec) {
	+ path __tmp = __weakly_canonical(__p, &__ec);
	+ if (__ec)
	+ return path();
	+ path __tmpbase = __weakly_canonical(__base, &__ec);
	+ if (__ec)
	+ return path();
	+ return __tmp.lexically_relative(__tmpbase);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p,
	+ error_code& __ec) {
	+ return relative(__p, current_path(), __ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path
	+relative(const path& __p, const path& __base = current_path()) {
	+ return __weakly_canonical(__p).lexically_relative(__weakly_canonical(__base));
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool remove(const path& __p) {
	+ return __remove(__p);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool remove(const path& __p,
	+ error_code& __ec) noexcept {
	+ return __remove(__p, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY uintmax_t remove_all(const path& __p) {
	+ return __remove_all(__p);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY uintmax_t remove_all(const path& __p,
	+ error_code& __ec) {
	+ return __remove_all(__p, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void rename(const path& __from,
	+ const path& __to) {
	+ return __rename(__from, __to);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void
	+rename(const path& __from, const path& __to, error_code& __ec) noexcept {
	+ return __rename(__from, __to, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void resize_file(const path& __p,
	+ uintmax_t __ns) {
	+ return __resize_file(__p, __ns);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void
	+resize_file(const path& __p, uintmax_t __ns, error_code& __ec) noexcept {
	+ return __resize_file(__p, __ns, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY space_info space(const path& __p) {
	+ return __space(__p);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY space_info space(const path& __p,
	+ error_code& __ec) noexcept {
	+ return __space(__p, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY file_status status(const path& __p) {
	+ return __status(__p);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY file_status status(const path& __p,
	+ error_code& __ec) noexcept {
	+ return __status(__p, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY file_status symlink_status(const path& __p) {
	+ return __symlink_status(__p);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY file_status
	+symlink_status(const path& __p, error_code& __ec) noexcept {
	+ return __symlink_status(__p, &__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path temp_directory_path() {
	+ return __temp_directory_path();
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path temp_directory_path(error_code& __ec) {
	+ return __temp_directory_path(&__ec);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p) {
	+ return __weakly_canonical(__p);
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p,
	+ error_code& __ec) {
	+ return __weakly_canonical(__p, &__ec);
	+}
	+
	+class directory_iterator;
	+class recursive_directory_iterator;
	+class __dir_stream;
	+
	+class directory_entry {
	+ typedef _VSTD_FS::path _Path;
	+
	+public:
	+ // constructors and destructors
	+ directory_entry() noexcept = default;
	+ directory_entry(directory_entry const&) = default;
	+ directory_entry(directory_entry&&) noexcept = default;
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ explicit directory_entry(_Path const& __p) : __p_(__p) {
	+ error_code __ec;
	+ __refresh(&__ec);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ directory_entry(_Path const& __p, error_code& __ec) : __p_(__p) {
	+ __refresh(&__ec);
	+ }
	+
	+ ~directory_entry() {}
	+
	+ directory_entry& operator=(directory_entry const&) = default;
	+ directory_entry& operator=(directory_entry&&) noexcept = default;
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void assign(_Path const& __p) {
	+ __p_ = __p;
	+ error_code __ec;
	+ __refresh(&__ec);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void assign(_Path const& __p, error_code& __ec) {
	+ __p_ = __p;
	+ __refresh(&__ec);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void replace_filename(_Path const& __p) {
	+ __p_.replace_filename(__p);
	+ error_code __ec;
	+ __refresh(&__ec);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void replace_filename(_Path const& __p, error_code& __ec) {
	+ __p_ = __p_.parent_path() / __p;
	+ __refresh(&__ec);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void refresh() { __refresh(); }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void refresh(error_code& __ec) noexcept { __refresh(&__ec); }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ _Path const& path() const noexcept { return __p_; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ operator const _Path&() const noexcept { return __p_; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool exists() const { return _VSTD_FS::exists(file_status{__get_ft()}); }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool exists(error_code& __ec) const noexcept {
	+ return _VSTD_FS::exists(file_status{__get_ft(&__ec)});
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool is_block_file() const { return __get_ft() == file_type::block; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool is_block_file(error_code& __ec) const noexcept {
	+ return __get_ft(&__ec) == file_type::block;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool is_character_file() const { return __get_ft() == file_type::character; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool is_character_file(error_code& __ec) const noexcept {
	+ return __get_ft(&__ec) == file_type::character;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool is_directory() const { return __get_ft() == file_type::directory; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool is_directory(error_code& __ec) const noexcept {
	+ return __get_ft(&__ec) == file_type::directory;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool is_fifo() const { return __get_ft() == file_type::fifo; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool is_fifo(error_code& __ec) const noexcept {
	+ return __get_ft(&__ec) == file_type::fifo;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool is_other() const { return _VSTD_FS::is_other(file_status{__get_ft()}); }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool is_other(error_code& __ec) const noexcept {
	+ return _VSTD_FS::is_other(file_status{__get_ft(&__ec)});
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool is_regular_file() const { return __get_ft() == file_type::regular; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool is_regular_file(error_code& __ec) const noexcept {
	+ return __get_ft(&__ec) == file_type::regular;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool is_socket() const { return __get_ft() == file_type::socket; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool is_socket(error_code& __ec) const noexcept {
	+ return __get_ft(&__ec) == file_type::socket;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool is_symlink() const { return __get_sym_ft() == file_type::symlink; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool is_symlink(error_code& __ec) const noexcept {
	+ return __get_sym_ft(&__ec) == file_type::symlink;
	+ }
	+ _LIBCPP_INLINE_VISIBILITY
	+ uintmax_t file_size() const { return __get_size(); }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ uintmax_t file_size(error_code& __ec) const noexcept {
	+ return __get_size(&__ec);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ uintmax_t hard_link_count() const { return __get_nlink(); }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ uintmax_t hard_link_count(error_code& __ec) const noexcept {
	+ return __get_nlink(&__ec);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ file_time_type last_write_time() const { return __get_write_time(); }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ file_time_type last_write_time(error_code& __ec) const noexcept {
	+ return __get_write_time(&__ec);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ file_status status() const { return __get_status(); }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ file_status status(error_code& __ec) const noexcept {
	+ return __get_status(&__ec);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ file_status symlink_status() const { return __get_symlink_status(); }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ file_status symlink_status(error_code& __ec) const noexcept {
	+ return __get_symlink_status(&__ec);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool operator<(directory_entry const& __rhs) const noexcept {
	+ return __p_ < __rhs.__p_;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool operator==(directory_entry const& __rhs) const noexcept {
	+ return __p_ == __rhs.__p_;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool operator!=(directory_entry const& __rhs) const noexcept {
	+ return __p_ != __rhs.__p_;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool operator<=(directory_entry const& __rhs) const noexcept {
	+ return __p_ <= __rhs.__p_;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool operator>(directory_entry const& __rhs) const noexcept {
	+ return __p_ > __rhs.__p_;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool operator>=(directory_entry const& __rhs) const noexcept {
	+ return __p_ >= __rhs.__p_;
	+ }
	+
	+private:
	+ friend class directory_iterator;
	+ friend class recursive_directory_iterator;
	+ friend class __dir_stream;
	+
	+ enum _CacheType : unsigned char {
	+ _Empty,
	+ _IterSymlink,
	+ _IterNonSymlink,
	+ _RefreshSymlink,
	+ _RefreshSymlinkUnresolved,
	+ _RefreshNonSymlink
	+ };
	+
	+ struct __cached_data {
	+ uintmax_t __size_;
	+ uintmax_t __nlink_;
	+ file_time_type __write_time_;
	+ perms __sym_perms_;
	+ perms __non_sym_perms_;
	+ file_type __type_;
	+ _CacheType __cache_type_;
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ __cached_data() noexcept { __reset(); }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void __reset() {
	+ __cache_type_ = _Empty;
	+ __type_ = file_type::none;
	+ __sym_perms_ = __non_sym_perms_ = perms::unknown;
	+ __size_ = __nlink_ = uintmax_t(-1);
	+ __write_time_ = file_time_type::min();
	+ }
	+ };
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ static __cached_data __create_iter_result(file_type __ft) {
	+ __cached_data __data;
	+ __data.__type_ = __ft;
	+ __data.__cache_type_ = [&]() {
	+ switch (__ft) {
	+ case file_type::none:
	+ return _Empty;
	+ case file_type::symlink:
	+ return _IterSymlink;
	+ default:
	+ return _IterNonSymlink;
	+ }
	+ }();
	+ return __data;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void __assign_iter_entry(_Path&& __p, __cached_data __dt) {
	+ __p_ = std::move(__p);
	+ __data_ = __dt;
	+ }
	+
	+ _LIBCPP_FUNC_VIS
	+ error_code __do_refresh() noexcept;
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ static bool __is_dne_error(error_code const& __ec) {
	+ if (!__ec)
	+ return true;
	+ switch (static_cast<errc>(__ec.value())) {
	+ case errc::no_such_file_or_directory:
	+ case errc::not_a_directory:
	+ return true;
	+ default:
	+ return false;
	+ }
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void __handle_error(const char* __msg, error_code* __dest_ec,
	+ error_code const& __ec, bool __allow_dne = false) const {
	+ if (__dest_ec) {
	+ *__dest_ec = __ec;
	+ return;
	+ }
	+ if (__ec && (!__allow_dne \|\| !__is_dne_error(__ec)))
	+ __throw_filesystem_error(__msg, __p_, __ec);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void __refresh(error_code* __ec = nullptr) {
	+ __handle_error("in directory_entry::refresh", __ec, __do_refresh(),
	+ /allow_dne/ true);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ file_type __get_sym_ft(error_code* __ec = nullptr) const {
	+ switch (__data_.__cache_type_) {
	+ case _Empty:
	+ return __symlink_status(__p_, __ec).type();
	+ case _IterSymlink:
	+ case _RefreshSymlink:
	+ case _RefreshSymlinkUnresolved:
	+ if (__ec)
	+ __ec->clear();
	+ return file_type::symlink;
	+ case _IterNonSymlink:
	+ case _RefreshNonSymlink:
	+ file_status __st(__data_.__type_);
	+ if (__ec && !_VSTD_FS::exists(__st))
	+ *__ec = make_error_code(errc::no_such_file_or_directory);
	+ else if (__ec)
	+ __ec->clear();
	+ return __data_.__type_;
	+ }
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ file_type __get_ft(error_code* __ec = nullptr) const {
	+ switch (__data_.__cache_type_) {
	+ case _Empty:
	+ case _IterSymlink:
	+ case _RefreshSymlinkUnresolved:
	+ return __status(__p_, __ec).type();
	+ case _IterNonSymlink:
	+ case _RefreshNonSymlink:
	+ case _RefreshSymlink: {
	+ file_status __st(__data_.__type_);
	+ if (__ec && !_VSTD_FS::exists(__st))
	+ *__ec = make_error_code(errc::no_such_file_or_directory);
	+ else if (__ec)
	+ __ec->clear();
	+ return __data_.__type_;
	+ }
	+ }
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ file_status __get_status(error_code* __ec = nullptr) const {
	+ switch (__data_.__cache_type_) {
	+ case _Empty:
	+ case _IterNonSymlink:
	+ case _IterSymlink:
	+ case _RefreshSymlinkUnresolved:
	+ return __status(__p_, __ec);
	+ case _RefreshNonSymlink:
	+ case _RefreshSymlink:
	+ return file_status(__get_ft(__ec), __data_.__non_sym_perms_);
	+ }
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ file_status __get_symlink_status(error_code* __ec = nullptr) const {
	+ switch (__data_.__cache_type_) {
	+ case _Empty:
	+ case _IterNonSymlink:
	+ case _IterSymlink:
	+ return __symlink_status(__p_, __ec);
	+ case _RefreshNonSymlink:
	+ return file_status(__get_sym_ft(__ec), __data_.__non_sym_perms_);
	+ case _RefreshSymlink:
	+ case _RefreshSymlinkUnresolved:
	+ return file_status(__get_sym_ft(__ec), __data_.__sym_perms_);
	+ }
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ uintmax_t __get_size(error_code* __ec = nullptr) const {
	+ switch (__data_.__cache_type_) {
	+ case _Empty:
	+ case _IterNonSymlink:
	+ case _IterSymlink:
	+ case _RefreshSymlinkUnresolved:
	+ return _VSTD_FS::__file_size(__p_, __ec);
	+ case _RefreshSymlink:
	+ case _RefreshNonSymlink: {
	+ error_code __m_ec;
	+ file_status __st(__get_ft(&__m_ec));
	+ __handle_error("in directory_entry::file_size", __ec, __m_ec);
	+ if (_VSTD_FS::exists(__st) && !_VSTD_FS::is_regular_file(__st)) {
	+ errc __err_kind = _VSTD_FS::is_directory(__st) ? errc::is_a_directory
	+ : errc::not_supported;
	+ __handle_error("in directory_entry::file_size", __ec,
	+ make_error_code(__err_kind));
	+ }
	+ return __data_.__size_;
	+ }
	+ }
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ uintmax_t __get_nlink(error_code* __ec = nullptr) const {
	+ switch (__data_.__cache_type_) {
	+ case _Empty:
	+ case _IterNonSymlink:
	+ case _IterSymlink:
	+ case _RefreshSymlinkUnresolved:
	+ return _VSTD_FS::__hard_link_count(__p_, __ec);
	+ case _RefreshSymlink:
	+ case _RefreshNonSymlink: {
	+ error_code __m_ec;
	+ (void)__get_ft(&__m_ec);
	+ __handle_error("in directory_entry::hard_link_count", __ec, __m_ec);
	+ return __data_.__nlink_;
	+ }
	+ }
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ file_time_type __get_write_time(error_code* __ec = nullptr) const {
	+ switch (__data_.__cache_type_) {
	+ case _Empty:
	+ case _IterNonSymlink:
	+ case _IterSymlink:
	+ case _RefreshSymlinkUnresolved:
	+ return _VSTD_FS::__last_write_time(__p_, __ec);
	+ case _RefreshSymlink:
	+ case _RefreshNonSymlink: {
	+ error_code __m_ec;
	+ file_status __st(__get_ft(&__m_ec));
	+ __handle_error("in directory_entry::last_write_time", __ec, __m_ec);
	+ if (_VSTD_FS::exists(__st) &&
	+ __data_.__write_time_ == file_time_type::min())
	+ __handle_error("in directory_entry::last_write_time", __ec,
	+ make_error_code(errc::value_too_large));
	+ return __data_.__write_time_;
	+ }
	+ }
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+private:
	+ _Path __p_;
	+ __cached_data __data_;
	+};
	+
	+class __dir_element_proxy {
	+public:
	+ inline _LIBCPP_INLINE_VISIBILITY directory_entry operator*() {
	+ return _VSTD::move(__elem_);
	+ }
	+
	+private:
	+ friend class directory_iterator;
	+ friend class recursive_directory_iterator;
	+ explicit __dir_element_proxy(directory_entry const& __e) : __elem_(__e) {}
	+ __dir_element_proxy(__dir_element_proxy&& __o)
	+ : __elem_(_VSTD::move(__o.__elem_)) {}
	+ directory_entry __elem_;
	+};
	+
	+class directory_iterator {
	+public:
	+ typedef directory_entry value_type;
	+ typedef ptrdiff_t difference_type;
	+ typedef value_type const* pointer;
	+ typedef value_type const& reference;
	+ typedef input_iterator_tag iterator_category;
	+
	+public:
	+ //ctor & dtor
	+ directory_iterator() noexcept {}
	+
	+ explicit directory_iterator(const path& __p)
	+ : directory_iterator(__p, nullptr) {}
	+
	+ directory_iterator(const path& __p, directory_options __opts)
	+ : directory_iterator(__p, nullptr, __opts) {}
	+
	+ directory_iterator(const path& __p, error_code& __ec)
	+ : directory_iterator(__p, &__ec) {}
	+
	+ directory_iterator(const path& __p, directory_options __opts,
	+ error_code& __ec)
	+ : directory_iterator(__p, &__ec, __opts) {}
	+
	+ directory_iterator(const directory_iterator&) = default;
	+ directory_iterator(directory_iterator&&) = default;
	+ directory_iterator& operator=(const directory_iterator&) = default;
	+
	+ directory_iterator& operator=(directory_iterator&& __o) noexcept {
	+ // non-default implementation provided to support self-move assign.
	+ if (this != &__o) {
	+ __imp_ = _VSTD::move(__o.__imp_);
	+ }
	+ return *this;
	+ }
	+
	+ ~directory_iterator() = default;
	+
	+ const directory_entry& operator*() const {
	+ _LIBCPP_ASSERT(__imp_, "The end iterator cannot be dereferenced");
	+ return __dereference();
	+ }
	+
	+ const directory_entry* operator->() const { return &**this; }
	+
	+ directory_iterator& operator++() { return __increment(); }
	+
	+ __dir_element_proxy operator++(int) {
	+ __dir_element_proxy __p(**this);
	+ __increment();
	+ return __p;
	+ }
	+
	+ directory_iterator& increment(error_code& __ec) { return __increment(&__ec); }
	+
	+private:
	+ inline _LIBCPP_INLINE_VISIBILITY friend bool
	+ operator==(const directory_iterator& __lhs,
	+ const directory_iterator& __rhs) noexcept;
	+
	+ // construct the dir_stream
	+ _LIBCPP_FUNC_VIS
	+ directory_iterator(const path&, error_code*,
	+ directory_options = directory_options::none);
	+
	+ _LIBCPP_FUNC_VIS
	+ directory_iterator& __increment(error_code* __ec = nullptr);
	+
	+ _LIBCPP_FUNC_VIS
	+ const directory_entry& __dereference() const;
	+
	+private:
	+ shared_ptr<__dir_stream> __imp_;
	+};
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool
	+operator==(const directory_iterator& __lhs,
	+ const directory_iterator& __rhs) noexcept {
	+ return __lhs.__imp_ == __rhs.__imp_;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool
	+operator!=(const directory_iterator& __lhs,
	+ const directory_iterator& __rhs) noexcept {
	+ return !(__lhs == __rhs);
	+}
	+
	+// enable directory_iterator range-based for statements
	+inline _LIBCPP_INLINE_VISIBILITY directory_iterator
	+begin(directory_iterator __iter) noexcept {
	+ return __iter;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY directory_iterator
	+end(const directory_iterator&) noexcept {
	+ return directory_iterator();
	+}
	+
	+class recursive_directory_iterator {
	+public:
	+ using value_type = directory_entry;
	+ using difference_type = std::ptrdiff_t;
	+ using pointer = directory_entry const*;
	+ using reference = directory_entry const&;
	+ using iterator_category = std::input_iterator_tag;
	+
	+public:
	+ // constructors and destructor
	+ _LIBCPP_INLINE_VISIBILITY
	+ recursive_directory_iterator() noexcept : __rec_(false) {}
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ explicit recursive_directory_iterator(
	+ const path& __p, directory_options __xoptions = directory_options::none)
	+ : recursive_directory_iterator(__p, __xoptions, nullptr) {}
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ recursive_directory_iterator(const path& __p, directory_options __xoptions,
	+ error_code& __ec)
	+ : recursive_directory_iterator(__p, __xoptions, &__ec) {}
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ recursive_directory_iterator(const path& __p, error_code& __ec)
	+ : recursive_directory_iterator(__p, directory_options::none, &__ec) {}
	+
	+ recursive_directory_iterator(const recursive_directory_iterator&) = default;
	+ recursive_directory_iterator(recursive_directory_iterator&&) = default;
	+
	+ recursive_directory_iterator&
	+ operator=(const recursive_directory_iterator&) = default;
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ recursive_directory_iterator&
	+ operator=(recursive_directory_iterator&& __o) noexcept {
	+ // non-default implementation provided to support self-move assign.
	+ if (this != &__o) {
	+ __imp_ = _VSTD::move(__o.__imp_);
	+ __rec_ = __o.__rec_;
	+ }
	+ return *this;
	+ }
	+
	+ ~recursive_directory_iterator() = default;
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ const directory_entry& operator*() const { return __dereference(); }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ const directory_entry* operator->() const { return &__dereference(); }
	+
	+ recursive_directory_iterator& operator++() { return __increment(); }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ __dir_element_proxy operator++(int) {
	+ __dir_element_proxy __p(**this);
	+ __increment();
	+ return __p;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ recursive_directory_iterator& increment(error_code& __ec) {
	+ return __increment(&__ec);
	+ }
	+
	+ _LIBCPP_FUNC_VIS directory_options options() const;
	+ _LIBCPP_FUNC_VIS int depth() const;
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void pop() { __pop(); }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void pop(error_code& __ec) { __pop(&__ec); }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ bool recursion_pending() const { return __rec_; }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void disable_recursion_pending() { __rec_ = false; }
	+
	+private:
	+ recursive_directory_iterator(const path& __p, directory_options __opt,
	+ error_code* __ec);
	+
	+ _LIBCPP_FUNC_VIS
	+ const directory_entry& __dereference() const;
	+
	+ _LIBCPP_FUNC_VIS
	+ bool __try_recursion(error_code* __ec);
	+
	+ _LIBCPP_FUNC_VIS
	+ void __advance(error_code* __ec = nullptr);
	+
	+ _LIBCPP_FUNC_VIS
	+ recursive_directory_iterator& __increment(error_code* __ec = nullptr);
	+
	+ _LIBCPP_FUNC_VIS
	+ void __pop(error_code* __ec = nullptr);
	+
	+ inline _LIBCPP_INLINE_VISIBILITY friend bool
	+ operator==(const recursive_directory_iterator&,
	+ const recursive_directory_iterator&) noexcept;
	+
	+ struct __shared_imp;
	+ shared_ptr<__shared_imp> __imp_;
	+ bool __rec_;
	+}; // class recursive_directory_iterator
	+
	+inline _LIBCPP_INLINE_VISIBILITY bool
	+operator==(const recursive_directory_iterator& __lhs,
	+ const recursive_directory_iterator& __rhs) noexcept {
	+ return __lhs.__imp_ == __rhs.__imp_;
	+}
	+
	+_LIBCPP_INLINE_VISIBILITY
	+inline bool operator!=(const recursive_directory_iterator& __lhs,
	+ const recursive_directory_iterator& __rhs) noexcept {
	+ return !(__lhs == __rhs);
	+}
	+// enable recursive_directory_iterator range-based for statements
	+inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator
	+begin(recursive_directory_iterator __iter) noexcept {
	+ return __iter;
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator
	+end(const recursive_directory_iterator&) noexcept {
	+ return recursive_directory_iterator();
	+}
	+
	+_LIBCPP_END_NAMESPACE_FILESYSTEM
	+
	+#endif // !_LIBCPP_CXX03_LANG
	+
	+_LIBCPP_POP_MACROS
	+
	+#endif // _LIBCPP_FILESYSTEM
	Index: projects/clang700-import/contrib/libc++/include/float.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/float.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/float.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/include/float.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/forward_list
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/forward_list (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/forward_list (revision 337135)
	@@ -1,1725 +1,1750 @@
	// -- C++ --
	//===----------------------- forward_list ---------------------------------===//
	//
	// 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_FORWARD_LIST
	#define _LIBCPP_FORWARD_LIST

	/*
	forward_list synopsis

	namespace std
	{

	template <class T, class Allocator = allocator<T>>
	class forward_list
	{
	public:
	typedef T value_type;
	typedef Allocator allocator_type;

	typedef value_type& reference;
	typedef const value_type& const_reference;
	typedef typename allocator_traits<allocator_type>::pointer pointer;
	typedef typename allocator_traits<allocator_type>::const_pointer const_pointer;
	typedef typename allocator_traits<allocator_type>::size_type size_type;
	typedef typename allocator_traits<allocator_type>::difference_type difference_type;

	typedef <details> iterator;
	typedef <details> const_iterator;

	forward_list()
	noexcept(is_nothrow_default_constructible<allocator_type>::value);
	explicit forward_list(const allocator_type& a);
	explicit forward_list(size_type n);
	explicit forward_list(size_type n, const allocator_type& a); // C++14
	forward_list(size_type n, const value_type& v);
	forward_list(size_type n, const value_type& v, const allocator_type& a);
	template <class InputIterator>
	forward_list(InputIterator first, InputIterator last);
	template <class InputIterator>
	forward_list(InputIterator first, InputIterator last, const allocator_type& a);
	forward_list(const forward_list& x);
	forward_list(const forward_list& x, const allocator_type& a);
	forward_list(forward_list&& x)
	noexcept(is_nothrow_move_constructible<allocator_type>::value);
	forward_list(forward_list&& x, const allocator_type& a);
	forward_list(initializer_list<value_type> il);
	forward_list(initializer_list<value_type> il, const allocator_type& a);

	~forward_list();

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

	template <class InputIterator>
	void assign(InputIterator first, InputIterator last);
	void assign(size_type n, const value_type& v);
	void assign(initializer_list<value_type> il);

	allocator_type get_allocator() const noexcept;

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

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

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

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

	reference front();
	const_reference front() const;

	template <class... Args> reference emplace_front(Args&&... args); // reference in C++17
	void push_front(const value_type& v);
	void push_front(value_type&& v);

	void pop_front();

	template <class... Args>
	iterator emplace_after(const_iterator p, Args&&... args);
	iterator insert_after(const_iterator p, const value_type& v);
	iterator insert_after(const_iterator p, value_type&& v);
	iterator insert_after(const_iterator p, size_type n, const value_type& v);
	template <class InputIterator>
	iterator insert_after(const_iterator p,
	InputIterator first, InputIterator last);
	iterator insert_after(const_iterator p, initializer_list<value_type> il);

	iterator erase_after(const_iterator p);
	iterator erase_after(const_iterator first, const_iterator last);

	void swap(forward_list& x)
	noexcept(allocator_traits<allocator_type>::is_always_equal::value); // C++17

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

	void splice_after(const_iterator p, forward_list& x);
	void splice_after(const_iterator p, forward_list&& x);
	void splice_after(const_iterator p, forward_list& x, const_iterator i);
	void splice_after(const_iterator p, forward_list&& x, const_iterator i);
	void splice_after(const_iterator p, forward_list& x,
	const_iterator first, const_iterator last);
	void splice_after(const_iterator p, forward_list&& x,
	const_iterator first, const_iterator last);
	void remove(const value_type& v);
	template <class Predicate> void remove_if(Predicate pred);
	void unique();
	template <class BinaryPredicate> void unique(BinaryPredicate binary_pred);
	void merge(forward_list& x);
	void merge(forward_list&& x);
	template <class Compare> void merge(forward_list& x, Compare comp);
	template <class Compare> void merge(forward_list&& x, Compare comp);
	void sort();
	template <class Compare> void sort(Compare comp);
	void reverse() noexcept;
	};

	+
	+template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
	+ forward_list(InputIterator, InputIterator, Allocator = Allocator())
	+ -> forward_list<typename iterator_traits<InputIterator>::value_type, Allocator>; // C++17
	+
	template <class T, class Allocator>
	bool operator==(const forward_list<T, Allocator>& x,
	const forward_list<T, Allocator>& y);

	template <class T, class Allocator>
	bool operator< (const forward_list<T, Allocator>& x,
	const forward_list<T, Allocator>& y);

	template <class T, class Allocator>
	bool operator!=(const forward_list<T, Allocator>& x,
	const forward_list<T, Allocator>& y);

	template <class T, class Allocator>
	bool operator> (const forward_list<T, Allocator>& x,
	const forward_list<T, Allocator>& y);

	template <class T, class Allocator>
	bool operator>=(const forward_list<T, Allocator>& x,
	const forward_list<T, Allocator>& y);

	template <class T, class Allocator>
	bool operator<=(const forward_list<T, Allocator>& x,
	const forward_list<T, Allocator>& y);

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

	} // std

	*/

	#include <__config>
	#include <initializer_list>
	#include <memory>
	#include <limits>
	#include <iterator>
	#include <algorithm>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _Tp, class _VoidPtr> struct __forward_list_node;
	template <class _NodePtr> struct __forward_begin_node;


	template <class>
	struct __forward_list_node_value_type;

	template <class _Tp, class _VoidPtr>
	struct __forward_list_node_value_type<__forward_list_node<_Tp, _VoidPtr> > {
	typedef _Tp type;
	};

	template <class _NodePtr>
	struct __forward_node_traits {

	typedef typename remove_cv<
	typename pointer_traits<_NodePtr>::element_type>::type __node;
	typedef typename __forward_list_node_value_type<__node>::type __node_value_type;
	typedef _NodePtr __node_pointer;
	typedef __forward_begin_node<_NodePtr> __begin_node;
	typedef typename __rebind_pointer<_NodePtr, __begin_node>::type
	__begin_node_pointer;
	typedef typename __rebind_pointer<_NodePtr, void>::type __void_pointer;

	#if defined(_LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB)
	typedef __begin_node_pointer __iter_node_pointer;
	#else
	typedef typename conditional<
	is_pointer<__void_pointer>::value,
	__begin_node_pointer,
	__node_pointer
	>::type __iter_node_pointer;
	#endif

	typedef typename conditional<
	is_same<__iter_node_pointer, __node_pointer>::value,
	__begin_node_pointer,
	__node_pointer
	>::type __non_iter_node_pointer;

	_LIBCPP_INLINE_VISIBILITY
	static __iter_node_pointer __as_iter_node(__iter_node_pointer __p) {
	return __p;
	}
	_LIBCPP_INLINE_VISIBILITY
	static __iter_node_pointer __as_iter_node(__non_iter_node_pointer __p) {
	return static_cast<__iter_node_pointer>(static_cast<__void_pointer>(__p));
	}
	};

	template <class _NodePtr>
	struct __forward_begin_node
	{
	typedef _NodePtr pointer;
	typedef typename __rebind_pointer<_NodePtr, __forward_begin_node>::type __begin_node_pointer;

	pointer __next_;

	_LIBCPP_INLINE_VISIBILITY __forward_begin_node() : __next_(nullptr) {}

	_LIBCPP_INLINE_VISIBILITY
	__begin_node_pointer __next_as_begin() const {
	return static_cast<__begin_node_pointer>(__next_);
	}
	};

	template <class _Tp, class _VoidPtr>
	struct _LIBCPP_HIDDEN __begin_node_of
	{
	typedef __forward_begin_node<
	typename __rebind_pointer<_VoidPtr, __forward_list_node<_Tp, _VoidPtr> >::type
	> type;
	};

	template <class _Tp, class _VoidPtr>
	struct __forward_list_node
	: public __begin_node_of<_Tp, _VoidPtr>::type
	{
	typedef _Tp value_type;

	value_type __value_;
	};


	template <class _Tp, class _Alloc = allocator<_Tp> > class _LIBCPP_TEMPLATE_VIS forward_list;
	template<class _NodeConstPtr> class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator;

	template <class _NodePtr>
	class _LIBCPP_TEMPLATE_VIS __forward_list_iterator
	{
	typedef __forward_node_traits<_NodePtr> __traits;
	typedef typename __traits::__node_pointer __node_pointer;
	typedef typename __traits::__begin_node_pointer __begin_node_pointer;
	typedef typename __traits::__iter_node_pointer __iter_node_pointer;
	typedef typename __traits::__void_pointer __void_pointer;

	__iter_node_pointer __ptr_;

	_LIBCPP_INLINE_VISIBILITY
	__begin_node_pointer __get_begin() const {
	return static_cast<__begin_node_pointer>(
	static_cast<__void_pointer>(__ptr_));
	}
	_LIBCPP_INLINE_VISIBILITY
	__node_pointer __get_unsafe_node_pointer() const {
	return static_cast<__node_pointer>(
	static_cast<__void_pointer>(__ptr_));
	}

	_LIBCPP_INLINE_VISIBILITY
	explicit __forward_list_iterator(nullptr_t) _NOEXCEPT : __ptr_(nullptr) {}

	_LIBCPP_INLINE_VISIBILITY
	explicit __forward_list_iterator(__begin_node_pointer __p) _NOEXCEPT
	: __ptr_(__traits::__as_iter_node(__p)) {}

	_LIBCPP_INLINE_VISIBILITY
	explicit __forward_list_iterator(__node_pointer __p) _NOEXCEPT
	: __ptr_(__traits::__as_iter_node(__p)) {}

	template<class, class> friend class _LIBCPP_TEMPLATE_VIS forward_list;
	template<class> friend class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator;

	public:
	typedef forward_iterator_tag iterator_category;
	typedef typename __traits::__node_value_type value_type;
	typedef value_type& reference;
	typedef typename pointer_traits<__node_pointer>::difference_type
	difference_type;
	typedef typename __rebind_pointer<__node_pointer, value_type>::type pointer;

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

	_LIBCPP_INLINE_VISIBILITY
	reference operator*() const {return __get_unsafe_node_pointer()->__value_;}
	_LIBCPP_INLINE_VISIBILITY
	pointer operator->() const {
	return pointer_traits<pointer>::pointer_to(__get_unsafe_node_pointer()->__value_);
	}

	_LIBCPP_INLINE_VISIBILITY
	__forward_list_iterator& operator++()
	{
	__ptr_ = __traits::__as_iter_node(__ptr_->__next_);
	return *this;
	}
	_LIBCPP_INLINE_VISIBILITY
	__forward_list_iterator operator++(int)
	{
	__forward_list_iterator __t(*this);
	++(*this);
	return __t;
	}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const __forward_list_iterator& __x,
	const __forward_list_iterator& __y)
	{return __x.__ptr_ == __y.__ptr_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const __forward_list_iterator& __x,
	const __forward_list_iterator& __y)
	{return !(__x == __y);}
	};

	template <class _NodeConstPtr>
	class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator
	{
	static_assert((!is_const<typename pointer_traits<_NodeConstPtr>::element_type>::value), "");
	typedef _NodeConstPtr _NodePtr;

	typedef __forward_node_traits<_NodePtr> __traits;
	typedef typename __traits::__node __node;
	typedef typename __traits::__node_pointer __node_pointer;
	typedef typename __traits::__begin_node_pointer __begin_node_pointer;
	typedef typename __traits::__iter_node_pointer __iter_node_pointer;
	typedef typename __traits::__void_pointer __void_pointer;

	__iter_node_pointer __ptr_;

	__begin_node_pointer __get_begin() const {
	return static_cast<__begin_node_pointer>(
	static_cast<__void_pointer>(__ptr_));
	}
	__node_pointer __get_unsafe_node_pointer() const {
	return static_cast<__node_pointer>(
	static_cast<__void_pointer>(__ptr_));
	}

	_LIBCPP_INLINE_VISIBILITY
	explicit __forward_list_const_iterator(nullptr_t) _NOEXCEPT
	: __ptr_(nullptr) {}

	_LIBCPP_INLINE_VISIBILITY
	explicit __forward_list_const_iterator(__begin_node_pointer __p) _NOEXCEPT
	: __ptr_(__traits::__as_iter_node(__p)) {}

	_LIBCPP_INLINE_VISIBILITY
	explicit __forward_list_const_iterator(__node_pointer __p) _NOEXCEPT
	: __ptr_(__traits::__as_iter_node(__p)) {}


	template<class, class> friend class forward_list;

	public:
	typedef forward_iterator_tag iterator_category;
	typedef typename __traits::__node_value_type value_type;
	typedef const value_type& reference;
	typedef typename pointer_traits<__node_pointer>::difference_type
	difference_type;
	typedef typename __rebind_pointer<__node_pointer, const value_type>::type
	pointer;

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

	_LIBCPP_INLINE_VISIBILITY
	reference operator*() const {return __get_unsafe_node_pointer()->__value_;}
	_LIBCPP_INLINE_VISIBILITY
	pointer operator->() const {return pointer_traits<pointer>::pointer_to(
	__get_unsafe_node_pointer()->__value_);}

	_LIBCPP_INLINE_VISIBILITY
	__forward_list_const_iterator& operator++()
	{
	__ptr_ = __traits::__as_iter_node(__ptr_->__next_);
	return *this;
	}
	_LIBCPP_INLINE_VISIBILITY
	__forward_list_const_iterator operator++(int)
	{
	__forward_list_const_iterator __t(*this);
	++(*this);
	return __t;
	}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const __forward_list_const_iterator& __x,
	const __forward_list_const_iterator& __y)
	{return __x.__ptr_ == __y.__ptr_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const __forward_list_const_iterator& __x,
	const __forward_list_const_iterator& __y)
	{return !(__x == __y);}
	};

	template <class _Tp, class _Alloc>
	class __forward_list_base
	{
	protected:
	typedef _Tp value_type;
	typedef _Alloc allocator_type;

	typedef typename allocator_traits<allocator_type>::void_pointer void_pointer;
	typedef __forward_list_node<value_type, void_pointer> __node;
	typedef typename __begin_node_of<value_type, void_pointer>::type __begin_node;
	typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>, __node>::type __node_allocator;
	typedef allocator_traits<__node_allocator> __node_traits;
	typedef typename __node_traits::pointer __node_pointer;

	typedef typename __rebind_alloc_helper<
	allocator_traits<allocator_type>, __begin_node
	>::type __begin_node_allocator;
	typedef typename allocator_traits<__begin_node_allocator>::pointer
	__begin_node_pointer;

	+ static_assert((!is_same<allocator_type, __node_allocator>::value),
	+ "internal allocator type must differ from user-specified "
	+ "type; otherwise overload resolution breaks");
	+
	__compressed_pair<__begin_node, __node_allocator> __before_begin_;

	_LIBCPP_INLINE_VISIBILITY
	__begin_node_pointer __before_begin() _NOEXCEPT
	{return pointer_traits<__begin_node_pointer>::pointer_to(__before_begin_.first());}
	_LIBCPP_INLINE_VISIBILITY
	__begin_node_pointer __before_begin() const _NOEXCEPT
	{return pointer_traits<__begin_node_pointer>::pointer_to(const_cast<__begin_node&>(__before_begin_.first()));}

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

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

	_LIBCPP_INLINE_VISIBILITY
	__forward_list_base()
	_NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
	: __before_begin_(__begin_node()) {}
	_LIBCPP_INLINE_VISIBILITY
	- __forward_list_base(const allocator_type& __a)
	+ explicit __forward_list_base(const allocator_type& __a)
	: __before_begin_(__begin_node(), __node_allocator(__a)) {}
	-
	+ _LIBCPP_INLINE_VISIBILITY
	+ explicit __forward_list_base(const __node_allocator& __a)
	+ : __before_begin_(__begin_node(), __a) {}
	#ifndef _LIBCPP_CXX03_LANG
	public:
	_LIBCPP_INLINE_VISIBILITY
	__forward_list_base(__forward_list_base&& __x)
	_NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value);
	_LIBCPP_INLINE_VISIBILITY
	__forward_list_base(__forward_list_base&& __x, const allocator_type& __a);
	#endif // _LIBCPP_CXX03_LANG

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

	public:
	~__forward_list_base();

	protected:
	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const __forward_list_base& __x)
	{__copy_assign_alloc(__x, integral_constant<bool,
	__node_traits::propagate_on_container_copy_assignment::value>());}

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

	public:
	_LIBCPP_INLINE_VISIBILITY
	void swap(__forward_list_base& __x)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT;
	#else
	_NOEXCEPT_(!__node_traits::propagate_on_container_move_assignment::value \|\|
	__is_nothrow_swappable<__node_allocator>::value);
	#endif
	protected:
	void clear() _NOEXCEPT;

	private:
	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const __forward_list_base&, false_type) {}
	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const __forward_list_base& __x, true_type)
	{
	if (__alloc() != __x.__alloc())
	clear();
	__alloc() = __x.__alloc();
	}

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

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Alloc>
	inline
	__forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x)
	_NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value)
	: __before_begin_(_VSTD::move(__x.__before_begin_))
	{
	__x.__before_begin()->__next_ = nullptr;
	}

	template <class _Tp, class _Alloc>
	inline
	__forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x,
	const allocator_type& __a)
	: __before_begin_(__begin_node(), __node_allocator(__a))
	{
	if (__alloc() == __x.__alloc())
	{
	__before_begin()->__next_ = __x.__before_begin()->__next_;
	__x.__before_begin()->__next_ = nullptr;
	}
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Alloc>
	__forward_list_base<_Tp, _Alloc>::~__forward_list_base()
	{
	clear();
	}

	template <class _Tp, class _Alloc>
	inline
	void
	__forward_list_base<_Tp, _Alloc>::swap(__forward_list_base& __x)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT
	#else
	_NOEXCEPT_(!__node_traits::propagate_on_container_move_assignment::value \|\|
	__is_nothrow_swappable<__node_allocator>::value)
	#endif
	{
	__swap_allocator(__alloc(), __x.__alloc(),
	integral_constant<bool, __node_traits::propagate_on_container_swap::value>());
	using _VSTD::swap;
	swap(__before_begin()->__next_, __x.__before_begin()->__next_);
	}

	template <class _Tp, class _Alloc>
	void
	__forward_list_base<_Tp, _Alloc>::clear() _NOEXCEPT
	{
	__node_allocator& __a = __alloc();
	for (__node_pointer __p = __before_begin()->__next_; __p != nullptr;)
	{
	__node_pointer __next = __p->__next_;
	__node_traits::destroy(__a, _VSTD::addressof(__p->__value_));
	__node_traits::deallocate(__a, __p, 1);
	__p = __next;
	}
	__before_begin()->__next_ = nullptr;
	}

	template <class _Tp, class _Alloc /= allocator<_Tp>/>
	class _LIBCPP_TEMPLATE_VIS forward_list
	: private __forward_list_base<_Tp, _Alloc>
	{
	typedef __forward_list_base<_Tp, _Alloc> base;
	typedef typename base::__node_allocator __node_allocator;
	typedef typename base::__node __node;
	typedef typename base::__node_traits __node_traits;
	typedef typename base::__node_pointer __node_pointer;
	typedef typename base::__begin_node_pointer __begin_node_pointer;

	public:
	typedef _Tp value_type;
	typedef _Alloc allocator_type;

	static_assert((is_same<typename allocator_type::value_type, value_type>::value),
	"Allocator::value_type must be same type as value_type");

	typedef value_type& reference;
	typedef const value_type& const_reference;
	typedef typename allocator_traits<allocator_type>::pointer pointer;
	typedef typename allocator_traits<allocator_type>::const_pointer const_pointer;
	typedef typename allocator_traits<allocator_type>::size_type size_type;
	typedef typename allocator_traits<allocator_type>::difference_type difference_type;

	typedef typename base::iterator iterator;
	typedef typename base::const_iterator const_iterator;

	_LIBCPP_INLINE_VISIBILITY
	forward_list()
	_NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
	{} // = default;
	_LIBCPP_INLINE_VISIBILITY
	explicit forward_list(const allocator_type& __a);
	explicit forward_list(size_type __n);
	#if _LIBCPP_STD_VER > 11
	explicit forward_list(size_type __n, const allocator_type& __a);
	#endif
	forward_list(size_type __n, const value_type& __v);
	forward_list(size_type __n, const value_type& __v, const allocator_type& __a);
	template <class _InputIterator>
	forward_list(_InputIterator __f, _InputIterator __l,
	typename enable_if<
	__is_input_iterator<_InputIterator>::value
	>::type* = nullptr);
	template <class _InputIterator>
	forward_list(_InputIterator __f, _InputIterator __l,
	const allocator_type& __a,
	typename enable_if<
	__is_input_iterator<_InputIterator>::value
	>::type* = nullptr);
	forward_list(const forward_list& __x);
	forward_list(const forward_list& __x, const allocator_type& __a);

	forward_list& operator=(const forward_list& __x);

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	forward_list(forward_list&& __x)
	_NOEXCEPT_(is_nothrow_move_constructible<base>::value)
	: base(_VSTD::move(__x)) {}
	forward_list(forward_list&& __x, const allocator_type& __a);

	forward_list(initializer_list<value_type> __il);
	forward_list(initializer_list<value_type> __il, const allocator_type& __a);

	_LIBCPP_INLINE_VISIBILITY
	forward_list& operator=(forward_list&& __x)
	_NOEXCEPT_(
	__node_traits::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<allocator_type>::value);

	_LIBCPP_INLINE_VISIBILITY
	forward_list& operator=(initializer_list<value_type> __il);

	_LIBCPP_INLINE_VISIBILITY
	void assign(initializer_list<value_type> __il);
	#endif // _LIBCPP_CXX03_LANG

	// ~forward_list() = default;

	template <class _InputIterator>
	typename enable_if
	<
	__is_input_iterator<_InputIterator>::value,
	void
	>::type
	assign(_InputIterator __f, _InputIterator __l);
	void assign(size_type __n, const value_type& __v);

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

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

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

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

	_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
	bool empty() const _NOEXCEPT
	{return base::__before_begin()->__next_ == nullptr;}
	_LIBCPP_INLINE_VISIBILITY
	size_type max_size() const _NOEXCEPT {
	return std::min<size_type>(
	__node_traits::max_size(base::__alloc()),
	numeric_limits<difference_type>::max());
	}

	_LIBCPP_INLINE_VISIBILITY
	reference front() {return base::__before_begin()->__next_->__value_;}
	_LIBCPP_INLINE_VISIBILITY
	const_reference front() const {return base::__before_begin()->__next_->__value_;}

	#ifndef _LIBCPP_CXX03_LANG
	#if _LIBCPP_STD_VER > 14
	template <class... _Args> reference emplace_front(_Args&&... __args);
	#else
	template <class... _Args> void emplace_front(_Args&&... __args);
	#endif
	void push_front(value_type&& __v);
	#endif // _LIBCPP_CXX03_LANG
	void push_front(const value_type& __v);

	void pop_front();

	#ifndef _LIBCPP_CXX03_LANG
	template <class... _Args>
	iterator emplace_after(const_iterator __p, _Args&&... __args);

	iterator insert_after(const_iterator __p, value_type&& __v);
	iterator insert_after(const_iterator __p, initializer_list<value_type> __il)
	{return insert_after(__p, __il.begin(), __il.end());}
	#endif // _LIBCPP_CXX03_LANG
	iterator insert_after(const_iterator __p, const value_type& __v);
	iterator insert_after(const_iterator __p, size_type __n, const value_type& __v);
	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_input_iterator<_InputIterator>::value,
	iterator
	>::type
	insert_after(const_iterator __p, _InputIterator __f, _InputIterator __l);

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

	_LIBCPP_INLINE_VISIBILITY
	void swap(forward_list& __x)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT
	#else
	_NOEXCEPT_(!__node_traits::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<__node_allocator>::value)
	#endif
	{base::swap(__x);}

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

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	void splice_after(const_iterator __p, forward_list&& __x);
	_LIBCPP_INLINE_VISIBILITY
	void splice_after(const_iterator __p, forward_list&& __x, const_iterator __i);
	_LIBCPP_INLINE_VISIBILITY
	void splice_after(const_iterator __p, forward_list&& __x,
	const_iterator __f, const_iterator __l);
	#endif // _LIBCPP_CXX03_LANG
	void splice_after(const_iterator __p, forward_list& __x);
	void splice_after(const_iterator __p, forward_list& __x, const_iterator __i);
	void splice_after(const_iterator __p, forward_list& __x,
	const_iterator __f, const_iterator __l);
	void remove(const value_type& __v);
	template <class _Predicate> void remove_if(_Predicate __pred);
	_LIBCPP_INLINE_VISIBILITY
	void unique() {unique(__equal_to<value_type>());}
	template <class _BinaryPredicate> void unique(_BinaryPredicate __binary_pred);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	void merge(forward_list&& __x) {merge(__x, __less<value_type>());}
	template <class _Compare>
	_LIBCPP_INLINE_VISIBILITY
	void merge(forward_list&& __x, _Compare __comp)
	{merge(__x, _VSTD::move(__comp));}
	#endif // _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	void merge(forward_list& __x) {merge(__x, __less<value_type>());}
	template <class _Compare> void merge(forward_list& __x, _Compare __comp);
	_LIBCPP_INLINE_VISIBILITY
	void sort() {sort(__less<value_type>());}
	template <class _Compare> _LIBCPP_INLINE_VISIBILITY void sort(_Compare __comp);
	void reverse() _NOEXCEPT;

	private:

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

	template <class _Compare>
	static
	__node_pointer
	__merge(__node_pointer __f1, __node_pointer __f2, _Compare& __comp);

	template <class _Compare>
	static
	__node_pointer
	__sort(__node_pointer __f, difference_type __sz, _Compare& __comp);
	};

	+
	+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
	+template<class _InputIterator,
	+ class _Alloc = typename std::allocator<typename iterator_traits<_InputIterator>::value_type>,
	+ class = typename enable_if<__is_allocator<_Alloc>::value, void>::type
	+ >
	+forward_list(_InputIterator, _InputIterator)
	+ -> forward_list<typename iterator_traits<_InputIterator>::value_type, _Alloc>;
	+
	+template<class _InputIterator,
	+ class _Alloc,
	+ class = typename enable_if<__is_allocator<_Alloc>::value, void>::type
	+ >
	+forward_list(_InputIterator, _InputIterator, _Alloc)
	+ -> forward_list<typename iterator_traits<_InputIterator>::value_type, _Alloc>;
	+#endif
	+
	template <class _Tp, class _Alloc>
	inline
	forward_list<_Tp, _Alloc>::forward_list(const allocator_type& __a)
	: base(__a)
	{
	}

	template <class _Tp, class _Alloc>
	forward_list<_Tp, _Alloc>::forward_list(size_type __n)
	{
	if (__n > 0)
	{
	__node_allocator& __a = base::__alloc();
	typedef __allocator_destructor<__node_allocator> _Dp;
	unique_ptr<__node, _Dp> __h(nullptr, _Dp(__a, 1));
	for (__begin_node_pointer __p = base::__before_begin(); __n > 0; --__n,
	__p = __p->__next_as_begin())
	{
	__h.reset(__node_traits::allocate(__a, 1));
	__node_traits::construct(__a, _VSTD::addressof(__h->__value_));
	__h->__next_ = nullptr;
	__p->__next_ = __h.release();
	}
	}
	}

	#if _LIBCPP_STD_VER > 11
	template <class _Tp, class _Alloc>
	forward_list<_Tp, _Alloc>::forward_list(size_type __n,
	const allocator_type& __base_alloc)
	: base ( __base_alloc )
	{
	if (__n > 0)
	{
	__node_allocator& __a = base::__alloc();
	typedef __allocator_destructor<__node_allocator> _Dp;
	unique_ptr<__node, _Dp> __h(nullptr, _Dp(__a, 1));
	for (__begin_node_pointer __p = base::__before_begin(); __n > 0; --__n,
	__p = __p->__next_as_begin())
	{
	__h.reset(__node_traits::allocate(__a, 1));
	__node_traits::construct(__a, _VSTD::addressof(__h->__value_));
	__h->__next_ = nullptr;
	__p->__next_ = __h.release();
	}
	}
	}
	#endif

	template <class _Tp, class _Alloc>
	forward_list<_Tp, _Alloc>::forward_list(size_type __n, const value_type& __v)
	{
	insert_after(cbefore_begin(), __n, __v);
	}

	template <class _Tp, class _Alloc>
	forward_list<_Tp, _Alloc>::forward_list(size_type __n, const value_type& __v,
	const allocator_type& __a)
	: base(__a)
	{
	insert_after(cbefore_begin(), __n, __v);
	}

	template <class _Tp, class _Alloc>
	template <class _InputIterator>
	forward_list<_Tp, _Alloc>::forward_list(_InputIterator __f, _InputIterator __l,
	typename enable_if<
	__is_input_iterator<_InputIterator>::value
	>::type*)
	{
	insert_after(cbefore_begin(), __f, __l);
	}

	template <class _Tp, class _Alloc>
	template <class _InputIterator>
	forward_list<_Tp, _Alloc>::forward_list(_InputIterator __f, _InputIterator __l,
	const allocator_type& __a,
	typename enable_if<
	__is_input_iterator<_InputIterator>::value
	>::type*)
	: base(__a)
	{
	insert_after(cbefore_begin(), __f, __l);
	}

	template <class _Tp, class _Alloc>
	forward_list<_Tp, _Alloc>::forward_list(const forward_list& __x)
	- : base(allocator_type(
	- __node_traits::select_on_container_copy_construction(__x.__alloc())
	- )
	- )
	-{
	- insert_after(cbefore_begin(), __x.begin(), __x.end());
	+ : base(
	+ __node_traits::select_on_container_copy_construction(__x.__alloc())) {
	+ insert_after(cbefore_begin(), __x.begin(), __x.end());
	}

	template <class _Tp, class _Alloc>
	forward_list<_Tp, _Alloc>::forward_list(const forward_list& __x,
	const allocator_type& __a)
	: base(__a)
	{
	insert_after(cbefore_begin(), __x.begin(), __x.end());
	}

	template <class _Tp, class _Alloc>
	forward_list<_Tp, _Alloc>&
	forward_list<_Tp, _Alloc>::operator=(const forward_list& __x)
	{
	if (this != &__x)
	{
	base::__copy_assign_alloc(__x);
	assign(__x.begin(), __x.end());
	}
	return *this;
	}

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Tp, class _Alloc>
	forward_list<_Tp, _Alloc>::forward_list(forward_list&& __x,
	const allocator_type& __a)
	: base(_VSTD::move(__x), __a)
	{
	if (base::__alloc() != __x.__alloc())
	{
	typedef move_iterator<iterator> _Ip;
	insert_after(cbefore_begin(), _Ip(__x.begin()), _Ip(__x.end()));
	}
	}

	template <class _Tp, class _Alloc>
	forward_list<_Tp, _Alloc>::forward_list(initializer_list<value_type> __il)
	{
	insert_after(cbefore_begin(), __il.begin(), __il.end());
	}

	template <class _Tp, class _Alloc>
	forward_list<_Tp, _Alloc>::forward_list(initializer_list<value_type> __il,
	const allocator_type& __a)
	: base(__a)
	{
	insert_after(cbefore_begin(), __il.begin(), __il.end());
	}

	template <class _Tp, class _Alloc>
	void
	forward_list<_Tp, _Alloc>::__move_assign(forward_list& __x, true_type)
	_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
	{
	clear();
	base::__move_assign_alloc(__x);
	base::__before_begin()->__next_ = __x.__before_begin()->__next_;
	__x.__before_begin()->__next_ = nullptr;
	}

	template <class _Tp, class _Alloc>
	void
	forward_list<_Tp, _Alloc>::__move_assign(forward_list& __x, false_type)
	{
	if (base::__alloc() == __x.__alloc())
	__move_assign(__x, true_type());
	else
	{
	typedef move_iterator<iterator> _Ip;
	assign(_Ip(__x.begin()), _Ip(__x.end()));
	}
	}

	template <class _Tp, class _Alloc>
	inline
	forward_list<_Tp, _Alloc>&
	forward_list<_Tp, _Alloc>::operator=(forward_list&& __x)
	_NOEXCEPT_(
	__node_traits::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<allocator_type>::value)
	{
	__move_assign(__x, integral_constant<bool,
	__node_traits::propagate_on_container_move_assignment::value>());
	return *this;
	}

	template <class _Tp, class _Alloc>
	inline
	forward_list<_Tp, _Alloc>&
	forward_list<_Tp, _Alloc>::operator=(initializer_list<value_type> __il)
	{
	assign(__il.begin(), __il.end());
	return *this;
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Alloc>
	template <class _InputIterator>
	typename enable_if
	<
	__is_input_iterator<_InputIterator>::value,
	void
	>::type
	forward_list<_Tp, _Alloc>::assign(_InputIterator __f, _InputIterator __l)
	{
	iterator __i = before_begin();
	iterator __j = _VSTD::next(__i);
	iterator __e = end();
	for (; __j != __e && __f != __l; ++__i, (void) ++__j, ++__f)
	__j = __f;
	if (__j == __e)
	insert_after(__i, __f, __l);
	else
	erase_after(__i, __e);
	}

	template <class _Tp, class _Alloc>
	void
	forward_list<_Tp, _Alloc>::assign(size_type __n, const value_type& __v)
	{
	iterator __i = before_begin();
	iterator __j = _VSTD::next(__i);
	iterator __e = end();
	for (; __j != __e && __n > 0; --__n, ++__i, ++__j)
	*__j = __v;
	if (__j == __e)
	insert_after(__i, __n, __v);
	else
	erase_after(__i, __e);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Alloc>
	inline
	void
	forward_list<_Tp, _Alloc>::assign(initializer_list<value_type> __il)
	{
	assign(__il.begin(), __il.end());
	}

	template <class _Tp, class _Alloc>
	template <class... _Args>
	#if _LIBCPP_STD_VER > 14
	typename forward_list<_Tp, _Alloc>::reference
	#else
	void
	#endif
	forward_list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
	{
	__node_allocator& __a = base::__alloc();
	typedef __allocator_destructor<__node_allocator> _Dp;
	unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
	__node_traits::construct(__a, _VSTD::addressof(__h->__value_),
	_VSTD::forward<_Args>(__args)...);
	__h->__next_ = base::__before_begin()->__next_;
	base::__before_begin()->__next_ = __h.release();
	#if _LIBCPP_STD_VER > 14
	return base::__before_begin()->__next_->__value_;
	#endif
	}

	template <class _Tp, class _Alloc>
	void
	forward_list<_Tp, _Alloc>::push_front(value_type&& __v)
	{
	__node_allocator& __a = base::__alloc();
	typedef __allocator_destructor<__node_allocator> _Dp;
	unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
	__node_traits::construct(__a, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
	__h->__next_ = base::__before_begin()->__next_;
	base::__before_begin()->__next_ = __h.release();
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Alloc>
	void
	forward_list<_Tp, _Alloc>::push_front(const value_type& __v)
	{
	__node_allocator& __a = base::__alloc();
	typedef __allocator_destructor<__node_allocator> _Dp;
	unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
	__node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
	__h->__next_ = base::__before_begin()->__next_;
	base::__before_begin()->__next_ = __h.release();
	}

	template <class _Tp, class _Alloc>
	void
	forward_list<_Tp, _Alloc>::pop_front()
	{
	__node_allocator& __a = base::__alloc();
	__node_pointer __p = base::__before_begin()->__next_;
	base::__before_begin()->__next_ = __p->__next_;
	__node_traits::destroy(__a, _VSTD::addressof(__p->__value_));
	__node_traits::deallocate(__a, __p, 1);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Alloc>
	template <class... _Args>
	typename forward_list<_Tp, _Alloc>::iterator
	forward_list<_Tp, _Alloc>::emplace_after(const_iterator __p, _Args&&... __args)
	{
	__begin_node_pointer const __r = __p.__get_begin();
	__node_allocator& __a = base::__alloc();
	typedef __allocator_destructor<__node_allocator> _Dp;
	unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
	__node_traits::construct(__a, _VSTD::addressof(__h->__value_),
	_VSTD::forward<_Args>(__args)...);
	__h->__next_ = __r->__next_;
	__r->__next_ = __h.release();
	return iterator(__r->__next_);
	}

	template <class _Tp, class _Alloc>
	typename forward_list<_Tp, _Alloc>::iterator
	forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, value_type&& __v)
	{
	__begin_node_pointer const __r = __p.__get_begin();
	__node_allocator& __a = base::__alloc();
	typedef __allocator_destructor<__node_allocator> _Dp;
	unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
	__node_traits::construct(__a, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
	__h->__next_ = __r->__next_;
	__r->__next_ = __h.release();
	return iterator(__r->__next_);
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Alloc>
	typename forward_list<_Tp, _Alloc>::iterator
	forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, const value_type& __v)
	{
	__begin_node_pointer const __r = __p.__get_begin();
	__node_allocator& __a = base::__alloc();
	typedef __allocator_destructor<__node_allocator> _Dp;
	unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
	__node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
	__h->__next_ = __r->__next_;
	__r->__next_ = __h.release();
	return iterator(__r->__next_);
	}

	template <class _Tp, class _Alloc>
	typename forward_list<_Tp, _Alloc>::iterator
	forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
	const value_type& __v)
	{
	__begin_node_pointer __r = __p.__get_begin();
	if (__n > 0)
	{
	__node_allocator& __a = base::__alloc();
	typedef __allocator_destructor<__node_allocator> _Dp;
	unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
	__node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
	__node_pointer __first = __h.release();
	__node_pointer __last = __first;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (--__n; __n != 0; --__n, __last = __last->__next_)
	{
	__h.reset(__node_traits::allocate(__a, 1));
	__node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
	__last->__next_ = __h.release();
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	while (__first != nullptr)
	{
	__node_pointer __next = __first->__next_;
	__node_traits::destroy(__a, _VSTD::addressof(__first->__value_));
	__node_traits::deallocate(__a, __first, 1);
	__first = __next;
	}
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	__last->__next_ = __r->__next_;
	__r->__next_ = __first;
	__r = static_cast<__begin_node_pointer>(__last);
	}
	return iterator(__r);
	}

	template <class _Tp, class _Alloc>
	template <class _InputIterator>
	typename enable_if
	<
	__is_input_iterator<_InputIterator>::value,
	typename forward_list<_Tp, _Alloc>::iterator
	>::type
	forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
	_InputIterator __f, _InputIterator __l)
	{
	__begin_node_pointer __r = __p.__get_begin();
	if (__f != __l)
	{
	__node_allocator& __a = base::__alloc();
	typedef __allocator_destructor<__node_allocator> _Dp;
	unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
	__node_traits::construct(__a, _VSTD::addressof(__h->__value_), *__f);
	__node_pointer __first = __h.release();
	__node_pointer __last = __first;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (++__f; __f != __l; ++__f, ((void)(__last = __last->__next_)))
	{
	__h.reset(__node_traits::allocate(__a, 1));
	__node_traits::construct(__a, _VSTD::addressof(__h->__value_), *__f);
	__last->__next_ = __h.release();
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	while (__first != nullptr)
	{
	__node_pointer __next = __first->__next_;
	__node_traits::destroy(__a, _VSTD::addressof(__first->__value_));
	__node_traits::deallocate(__a, __first, 1);
	__first = __next;
	}
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	__last->__next_ = __r->__next_;
	__r->__next_ = __first;
	__r = static_cast<__begin_node_pointer>(__last);
	}
	return iterator(__r);
	}

	template <class _Tp, class _Alloc>
	typename forward_list<_Tp, _Alloc>::iterator
	forward_list<_Tp, _Alloc>::erase_after(const_iterator __f)
	{
	__begin_node_pointer __p = __f.__get_begin();
	__node_pointer __n = __p->__next_;
	__p->__next_ = __n->__next_;
	__node_allocator& __a = base::__alloc();
	__node_traits::destroy(__a, _VSTD::addressof(__n->__value_));
	__node_traits::deallocate(__a, __n, 1);
	return iterator(__p->__next_);
	}

	template <class _Tp, class _Alloc>
	typename forward_list<_Tp, _Alloc>::iterator
	forward_list<_Tp, _Alloc>::erase_after(const_iterator __f, const_iterator __l)
	{
	__node_pointer __e = __l.__get_unsafe_node_pointer();
	if (__f != __l)
	{
	__begin_node_pointer __bp = __f.__get_begin();

	__node_pointer __n = __bp->__next_;
	if (__n != __e)
	{
	__bp->__next_ = __e;
	__node_allocator& __a = base::__alloc();
	do
	{
	__node_pointer __tmp = __n->__next_;
	__node_traits::destroy(__a, _VSTD::addressof(__n->__value_));
	__node_traits::deallocate(__a, __n, 1);
	__n = __tmp;
	} while (__n != __e);
	}
	}
	return iterator(__e);
	}

	template <class _Tp, class _Alloc>
	void
	forward_list<_Tp, _Alloc>::resize(size_type __n)
	{
	size_type __sz = 0;
	iterator __p = before_begin();
	iterator __i = begin();
	iterator __e = end();
	for (; __i != __e && __sz < __n; ++__p, ++__i, ++__sz)
	;
	if (__i != __e)
	erase_after(__p, __e);
	else
	{
	__n -= __sz;
	if (__n > 0)
	{
	__node_allocator& __a = base::__alloc();
	typedef __allocator_destructor<__node_allocator> _Dp;
	unique_ptr<__node, _Dp> __h(nullptr, _Dp(__a, 1));
	for (__begin_node_pointer __ptr = __p.__get_begin(); __n > 0; --__n,
	__ptr = __ptr->__next_as_begin())
	{
	__h.reset(__node_traits::allocate(__a, 1));
	__node_traits::construct(__a, _VSTD::addressof(__h->__value_));
	__h->__next_ = nullptr;
	__ptr->__next_ = __h.release();
	}
	}
	}
	}

	template <class _Tp, class _Alloc>
	void
	forward_list<_Tp, _Alloc>::resize(size_type __n, const value_type& __v)
	{
	size_type __sz = 0;
	iterator __p = before_begin();
	iterator __i = begin();
	iterator __e = end();
	for (; __i != __e && __sz < __n; ++__p, ++__i, ++__sz)
	;
	if (__i != __e)
	erase_after(__p, __e);
	else
	{
	__n -= __sz;
	if (__n > 0)
	{
	__node_allocator& __a = base::__alloc();
	typedef __allocator_destructor<__node_allocator> _Dp;
	unique_ptr<__node, _Dp> __h(nullptr, _Dp(__a, 1));
	for (__begin_node_pointer __ptr = __p.__get_begin(); __n > 0; --__n,
	__ptr = __ptr->__next_as_begin())
	{
	__h.reset(__node_traits::allocate(__a, 1));
	__node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
	__h->__next_ = nullptr;
	__ptr->__next_ = __h.release();
	}
	}
	}
	}

	template <class _Tp, class _Alloc>
	void
	forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
	forward_list& __x)
	{
	if (!__x.empty())
	{
	if (__p.__get_begin()->__next_ != nullptr)
	{
	const_iterator __lm1 = __x.before_begin();
	while (__lm1.__get_begin()->__next_ != nullptr)
	++__lm1;
	__lm1.__get_begin()->__next_ = __p.__get_begin()->__next_;
	}
	__p.__get_begin()->__next_ = __x.__before_begin()->__next_;
	__x.__before_begin()->__next_ = nullptr;
	}
	}

	template <class _Tp, class _Alloc>
	void
	forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
	forward_list& /__other/,
	const_iterator __i)
	{
	const_iterator __lm1 = _VSTD::next(__i);
	if (__p != __i && __p != __lm1)
	{
	__i.__get_begin()->__next_ = __lm1.__get_begin()->__next_;
	__lm1.__get_begin()->__next_ = __p.__get_begin()->__next_;
	__p.__get_begin()->__next_ = __lm1.__get_unsafe_node_pointer();
	}
	}

	template <class _Tp, class _Alloc>
	void
	forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
	forward_list& /__other/,
	const_iterator __f, const_iterator __l)
	{
	if (__f != __l && __p != __f)
	{
	const_iterator __lm1 = __f;
	while (__lm1.__get_begin()->__next_ != __l.__get_begin())
	++__lm1;
	if (__f != __lm1)
	{
	__lm1.__get_begin()->__next_ = __p.__get_begin()->__next_;
	__p.__get_begin()->__next_ = __f.__get_begin()->__next_;
	__f.__get_begin()->__next_ = __l.__get_unsafe_node_pointer();
	}
	}
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
	forward_list&& __x)
	{
	splice_after(__p, __x);
	}

	template <class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
	forward_list&& __x,
	const_iterator __i)
	{
	splice_after(__p, __x, __i);
	}

	template <class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
	forward_list&& __x,
	const_iterator __f, const_iterator __l)
	{
	splice_after(__p, __x, __f, __l);
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Alloc>
	void
	forward_list<_Tp, _Alloc>::remove(const value_type& __v)
	{
	forward_list<_Tp, _Alloc> __deleted_nodes; // collect the nodes we're removing
	iterator __e = end();
	for (iterator __i = before_begin(); __i.__get_begin()->__next_ != nullptr;)
	{
	if (__i.__get_begin()->__next_->__value_ == __v)
	{
	iterator __j = _VSTD::next(__i, 2);
	for (; __j != __e && *__j == __v; ++__j)
	;
	__deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);
	if (__j == __e)
	break;
	__i = __j;
	}
	else
	++__i;
	}
	}

	template <class _Tp, class _Alloc>
	template <class _Predicate>
	void
	forward_list<_Tp, _Alloc>::remove_if(_Predicate __pred)
	{
	iterator __e = end();
	for (iterator __i = before_begin(); __i.__get_begin()->__next_ != nullptr;)
	{
	if (__pred(__i.__get_begin()->__next_->__value_))
	{
	iterator __j = _VSTD::next(__i, 2);
	for (; __j != __e && __pred(*__j); ++__j)
	;
	erase_after(__i, __j);
	if (__j == __e)
	break;
	__i = __j;
	}
	else
	++__i;
	}
	}

	template <class _Tp, class _Alloc>
	template <class _BinaryPredicate>
	void
	forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
	{
	for (iterator __i = begin(), __e = end(); __i != __e;)
	{
	iterator __j = _VSTD::next(__i);
	for (; __j != __e && __binary_pred(__i, __j); ++__j)
	;
	if (__i.__get_begin()->__next_ != __j.__get_unsafe_node_pointer())
	erase_after(__i, __j);
	__i = __j;
	}
	}

	template <class _Tp, class _Alloc>
	template <class _Compare>
	void
	forward_list<_Tp, _Alloc>::merge(forward_list& __x, _Compare __comp)
	{
	if (this != &__x)
	{
	base::__before_begin()->__next_ = __merge(base::__before_begin()->__next_,
	__x.__before_begin()->__next_,
	__comp);
	__x.__before_begin()->__next_ = nullptr;
	}
	}

	template <class _Tp, class _Alloc>
	template <class _Compare>
	typename forward_list<_Tp, _Alloc>::__node_pointer
	forward_list<_Tp, _Alloc>::__merge(__node_pointer __f1, __node_pointer __f2,
	_Compare& __comp)
	{
	if (__f1 == nullptr)
	return __f2;
	if (__f2 == nullptr)
	return __f1;
	__node_pointer __r;
	if (__comp(__f2->__value_, __f1->__value_))
	{
	__node_pointer __t = __f2;
	while (__t->__next_ != nullptr &&
	__comp(__t->__next_->__value_, __f1->__value_))
	__t = __t->__next_;
	__r = __f2;
	__f2 = __t->__next_;
	__t->__next_ = __f1;
	}
	else
	__r = __f1;
	__node_pointer __p = __f1;
	__f1 = __f1->__next_;
	while (__f1 != nullptr && __f2 != nullptr)
	{
	if (__comp(__f2->__value_, __f1->__value_))
	{
	__node_pointer __t = __f2;
	while (__t->__next_ != nullptr &&
	__comp(__t->__next_->__value_, __f1->__value_))
	__t = __t->__next_;
	__p->__next_ = __f2;
	__f2 = __t->__next_;
	__t->__next_ = __f1;
	}
	__p = __f1;
	__f1 = __f1->__next_;
	}
	if (__f2 != nullptr)
	__p->__next_ = __f2;
	return __r;
	}

	template <class _Tp, class _Alloc>
	template <class _Compare>
	inline
	void
	forward_list<_Tp, _Alloc>::sort(_Compare __comp)
	{
	base::__before_begin()->__next_ = __sort(base::__before_begin()->__next_,
	_VSTD::distance(begin(), end()), __comp);
	}

	template <class _Tp, class _Alloc>
	template <class _Compare>
	typename forward_list<_Tp, _Alloc>::__node_pointer
	forward_list<_Tp, _Alloc>::__sort(__node_pointer __f1, difference_type __sz,
	_Compare& __comp)
	{
	switch (__sz)
	{
	case 0:
	case 1:
	return __f1;
	case 2:
	if (__comp(__f1->__next_->__value_, __f1->__value_))
	{
	__node_pointer __t = __f1->__next_;
	__t->__next_ = __f1;
	__f1->__next_ = nullptr;
	__f1 = __t;
	}
	return __f1;
	}
	difference_type __sz1 = __sz / 2;
	difference_type __sz2 = __sz - __sz1;
	__node_pointer __t = _VSTD::next(iterator(__f1), __sz1 - 1).__get_unsafe_node_pointer();
	__node_pointer __f2 = __t->__next_;
	__t->__next_ = nullptr;
	return __merge(__sort(__f1, __sz1, __comp),
	__sort(__f2, __sz2, __comp), __comp);
	}

	template <class _Tp, class _Alloc>
	void
	forward_list<_Tp, _Alloc>::reverse() _NOEXCEPT
	{
	__node_pointer __p = base::__before_begin()->__next_;
	if (__p != nullptr)
	{
	__node_pointer __f = __p->__next_;
	__p->__next_ = nullptr;
	while (__f != nullptr)
	{
	__node_pointer __t = __f->__next_;
	__f->__next_ = __p;
	__p = __f;
	__f = __t;
	}
	base::__before_begin()->__next_ = __p;
	}
	}

	template <class _Tp, class _Alloc>
	bool operator==(const forward_list<_Tp, _Alloc>& __x,
	const forward_list<_Tp, _Alloc>& __y)
	{
	typedef forward_list<_Tp, _Alloc> _Cp;
	typedef typename _Cp::const_iterator _Ip;
	_Ip __ix = __x.begin();
	_Ip __ex = __x.end();
	_Ip __iy = __y.begin();
	_Ip __ey = __y.end();
	for (; __ix != __ex && __iy != __ey; ++__ix, ++__iy)
	if (!(__ix == __iy))
	return false;
	return (__ix == __ex) == (__iy == __ey);
	}

	template <class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const forward_list<_Tp, _Alloc>& __x,
	const forward_list<_Tp, _Alloc>& __y)
	{
	return !(__x == __y);
	}

	template <class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	bool operator< (const forward_list<_Tp, _Alloc>& __x,
	const forward_list<_Tp, _Alloc>& __y)
	{
	return _VSTD::lexicographical_compare(__x.begin(), __x.end(),
	__y.begin(), __y.end());
	}

	template <class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	bool operator> (const forward_list<_Tp, _Alloc>& __x,
	const forward_list<_Tp, _Alloc>& __y)
	{
	return __y < __x;
	}

	template <class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	bool operator>=(const forward_list<_Tp, _Alloc>& __x,
	const forward_list<_Tp, _Alloc>& __y)
	{
	return !(__x < __y);
	}

	template <class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	bool operator<=(const forward_list<_Tp, _Alloc>& __x,
	const forward_list<_Tp, _Alloc>& __y)
	{
	return !(__y < __x);
	}

	template <class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(forward_list<_Tp, _Alloc>& __x, forward_list<_Tp, _Alloc>& __y)
	_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
	{
	__x.swap(__y);
	}

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_FORWARD_LIST
	Index: projects/clang700-import/contrib/libc++/include/fstream
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/fstream (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/fstream (revision 337135)
	@@ -1,1484 +1,1764 @@
	// -- C++ --
	//===------------------------- fstream ------------------------------------===//
	//
	// 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_FSTREAM
	#define _LIBCPP_FSTREAM

	/*
	fstream synopsis

	template <class charT, class traits = char_traits<charT> >
	class basic_filebuf
	: public basic_streambuf<charT, traits>
	{
	public:
	typedef charT char_type;
	typedef traits traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;

	// 27.9.1.2 Constructors/destructor:
	basic_filebuf();
	basic_filebuf(basic_filebuf&& rhs);
	virtual ~basic_filebuf();

	// 27.9.1.3 Assign/swap:
	basic_filebuf& operator=(basic_filebuf&& rhs);
	void swap(basic_filebuf& rhs);

	// 27.9.1.4 Members:
	bool is_open() const;
	basic_filebuf* open(const char* s, ios_base::openmode mode);
	basic_filebuf* open(const string& s, ios_base::openmode mode);
	+ basic_filebuf* open(const filesystem::path& p, ios_base::openmode mode); // C++17
	basic_filebuf* close();

	protected:
	// 27.9.1.5 Overridden virtual functions:
	virtual streamsize showmanyc();
	virtual int_type underflow();
	virtual int_type uflow();
	virtual int_type pbackfail(int_type c = traits_type::eof());
	virtual int_type overflow (int_type c = traits_type::eof());
	virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* s, streamsize n);
	virtual pos_type seekoff(off_type off, ios_base::seekdir way,
	ios_base::openmode which = ios_base::in \| ios_base::out);
	virtual pos_type seekpos(pos_type sp,
	ios_base::openmode which = ios_base::in \| ios_base::out);
	virtual int sync();
	virtual void imbue(const locale& loc);
	};

	template <class charT, class traits>
	void
	swap(basic_filebuf<charT, traits>& x, basic_filebuf<charT, traits>& y);

	typedef basic_filebuf<char> filebuf;
	typedef basic_filebuf<wchar_t> wfilebuf;

	template <class charT, class traits = char_traits<charT> >
	class basic_ifstream
	: public basic_istream<charT,traits>
	{
	public:
	typedef charT char_type;
	typedef traits traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;

	basic_ifstream();
	explicit basic_ifstream(const char* s, ios_base::openmode mode = ios_base::in);
	explicit basic_ifstream(const string& s, ios_base::openmode mode = ios_base::in);
	+ explicit basic_ifstream(const filesystem::path& p,
	+ ios_base::openmode mode = ios_base::in); // C++17
	basic_ifstream(basic_ifstream&& rhs);

	basic_ifstream& operator=(basic_ifstream&& rhs);
	void swap(basic_ifstream& rhs);

	basic_filebuf<char_type, traits_type>* rdbuf() const;
	bool is_open() const;
	void open(const char* s, ios_base::openmode mode = ios_base::in);
	void open(const string& s, ios_base::openmode mode = ios_base::in);
	+ void open(const filesystem::path& s, ios_base::openmode mode = ios_base::in); // C++17
	+
	void close();
	};

	template <class charT, class traits>
	void
	swap(basic_ifstream<charT, traits>& x, basic_ifstream<charT, traits>& y);

	typedef basic_ifstream<char> ifstream;
	typedef basic_ifstream<wchar_t> wifstream;

	template <class charT, class traits = char_traits<charT> >
	class basic_ofstream
	: public basic_ostream<charT,traits>
	{
	public:
	typedef charT char_type;
	typedef traits traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;

	basic_ofstream();
	explicit basic_ofstream(const char* s, ios_base::openmode mode = ios_base::out);
	explicit basic_ofstream(const string& s, ios_base::openmode mode = ios_base::out);
	+ explicit basic_ofstream(const filesystem::path& p,
	+ ios_base::openmode mode = ios_base::out); // C++17
	basic_ofstream(basic_ofstream&& rhs);

	basic_ofstream& operator=(basic_ofstream&& rhs);
	void swap(basic_ofstream& rhs);

	basic_filebuf<char_type, traits_type>* rdbuf() const;
	bool is_open() const;
	void open(const char* s, ios_base::openmode mode = ios_base::out);
	void open(const string& s, ios_base::openmode mode = ios_base::out);
	+ void open(const filesystem::path& p,
	+ ios_base::openmode mode = ios_base::out); // C++17
	+
	void close();
	};

	template <class charT, class traits>
	void
	swap(basic_ofstream<charT, traits>& x, basic_ofstream<charT, traits>& y);

	typedef basic_ofstream<char> ofstream;
	typedef basic_ofstream<wchar_t> wofstream;

	template <class charT, class traits=char_traits<charT> >
	class basic_fstream
	: public basic_iostream<charT,traits>
	{
	public:
	typedef charT char_type;
	typedef traits traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;

	basic_fstream();
	explicit basic_fstream(const char* s, ios_base::openmode mode = ios_base::in\|ios_base::out);
	explicit basic_fstream(const string& s, ios_base::openmode mode = ios_base::in\|ios_base::out);
	+ explicit basic_fstream(const filesystem::path& p,
	+ ios_base::openmode mode = ios_base::in\|ios_base::out); C++17
	basic_fstream(basic_fstream&& rhs);

	basic_fstream& operator=(basic_fstream&& rhs);
	void swap(basic_fstream& rhs);

	basic_filebuf<char_type, traits_type>* rdbuf() const;
	bool is_open() const;
	void open(const char* s, ios_base::openmode mode = ios_base::in\|ios_base::out);
	void open(const string& s, ios_base::openmode mode = ios_base::in\|ios_base::out);
	+ void open(const filesystem::path& s,
	+ ios_base::openmode mode = ios_base::in\|ios_base::out); // C++17
	+
	void close();
	};

	template <class charT, class traits>
	void swap(basic_fstream<charT, traits>& x, basic_fstream<charT, traits>& y);

	typedef basic_fstream<char> fstream;
	typedef basic_fstream<wchar_t> wfstream;

	} // std

	*/

	#include <__config>
	#include <ostream>
	#include <istream>
	#include <__locale>
	#include <cstdio>
	+#include <cstdlib>
	+#include <filesystem>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _CharT, class _Traits>
	class _LIBCPP_TEMPLATE_VIS basic_filebuf
	: public basic_streambuf<_CharT, _Traits>
	{
	public:
	typedef _CharT char_type;
	typedef _Traits traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;
	typedef typename traits_type::state_type state_type;

	// 27.9.1.2 Constructors/destructor:
	basic_filebuf();
	#ifndef _LIBCPP_CXX03_LANG
	basic_filebuf(basic_filebuf&& __rhs);
	#endif
	virtual ~basic_filebuf();

	// 27.9.1.3 Assign/swap:
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	basic_filebuf& operator=(basic_filebuf&& __rhs);
	#endif
	void swap(basic_filebuf& __rhs);

	// 27.9.1.4 Members:
	_LIBCPP_INLINE_VISIBILITY
	bool is_open() const;
	#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
	basic_filebuf* open(const char* __s, ios_base::openmode __mode);
	+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
	+ basic_filebuf* open(const wchar_t* __s, ios_base::openmode __mode);
	+#endif
	_LIBCPP_INLINE_VISIBILITY
	basic_filebuf* open(const string& __s, ios_base::openmode __mode);
	+
	+#if _LIBCPP_STD_VER >= 17
	+ _LIBCPP_INLINE_VISIBILITY
	+ basic_filebuf* open(const _VSTD_FS::path& __p, ios_base::openmode __mode) {
	+ return open(__p.c_str(), __mode);
	+ }
	#endif
	+ _LIBCPP_INLINE_VISIBILITY
	+ basic_filebuf* __open(int __fd, ios_base::openmode __mode);
	+#endif
	basic_filebuf* close();

	-protected:
	+ _LIBCPP_INLINE_VISIBILITY
	+ inline static const char*
	+ __make_mdstring(ios_base::openmode __mode) _NOEXCEPT;
	+
	+ protected:
	// 27.9.1.5 Overridden virtual functions:
	virtual int_type underflow();
	virtual int_type pbackfail(int_type __c = traits_type::eof());
	virtual int_type overflow (int_type __c = traits_type::eof());
	virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, streamsize __n);
	virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
	ios_base::openmode __wch = ios_base::in \| ios_base::out);
	virtual pos_type seekpos(pos_type __sp,
	ios_base::openmode __wch = ios_base::in \| ios_base::out);
	virtual int sync();
	virtual void imbue(const locale& __loc);

	private:
	- char* __extbuf_;
	- const char* __extbufnext_;
	- const char* __extbufend_;
	- char __extbuf_min_[8];
	- size_t __ebs_;
	- char_type* __intbuf_;
	- size_t __ibs_;
	- FILE* __file_;
	- const codecvt<char_type, char, state_type>* __cv_;
	- state_type __st_;
	- state_type __st_last_;
	- ios_base::openmode __om_;
	- ios_base::openmode __cm_;
	- bool __owns_eb_;
	- bool __owns_ib_;
	- bool __always_noconv_;
	+ char* __extbuf_;
	+ const char* __extbufnext_;
	+ const char* __extbufend_;
	+ char __extbuf_min_[8];
	+ size_t __ebs_;
	+ char_type* __intbuf_;
	+ size_t __ibs_;
	+ FILE* __file_;
	+ const codecvt<char_type, char, state_type>* __cv_;
	+ state_type __st_;
	+ state_type __st_last_;
	+ ios_base::openmode __om_;
	+ ios_base::openmode __cm_;
	+ bool __owns_eb_;
	+ bool __owns_ib_;
	+ bool __always_noconv_;

	- bool __read_mode();
	- void __write_mode();
	+ bool __read_mode();
	+ void __write_mode();
	};

	template <class _CharT, class _Traits>
	basic_filebuf<_CharT, _Traits>::basic_filebuf()
	: __extbuf_(0),
	__extbufnext_(0),
	__extbufend_(0),
	__ebs_(0),
	__intbuf_(0),
	__ibs_(0),
	__file_(0),
	__cv_(nullptr),
	__st_(),
	__st_last_(),
	__om_(0),
	__cm_(0),
	__owns_eb_(false),
	__owns_ib_(false),
	__always_noconv_(false)
	{
	if (has_facet<codecvt<char_type, char, state_type> >(this->getloc()))
	{
	__cv_ = &use_facet<codecvt<char_type, char, state_type> >(this->getloc());
	__always_noconv_ = __cv_->always_noconv();
	}
	setbuf(0, 4096);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits>
	basic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs)
	: basic_streambuf<_CharT, _Traits>(__rhs)
	{
	if (__rhs.__extbuf_ == __rhs.__extbuf_min_)
	{
	__extbuf_ = __extbuf_min_;
	__extbufnext_ = __extbuf_ + (__rhs.__extbufnext_ - __rhs.__extbuf_);
	__extbufend_ = __extbuf_ + (__rhs.__extbufend_ - __rhs.__extbuf_);
	}
	else
	{
	__extbuf_ = __rhs.__extbuf_;
	__extbufnext_ = __rhs.__extbufnext_;
	__extbufend_ = __rhs.__extbufend_;
	}
	__ebs_ = __rhs.__ebs_;
	__intbuf_ = __rhs.__intbuf_;
	__ibs_ = __rhs.__ibs_;
	__file_ = __rhs.__file_;
	__cv_ = __rhs.__cv_;
	__st_ = __rhs.__st_;
	__st_last_ = __rhs.__st_last_;
	__om_ = __rhs.__om_;
	__cm_ = __rhs.__cm_;
	__owns_eb_ = __rhs.__owns_eb_;
	__owns_ib_ = __rhs.__owns_ib_;
	__always_noconv_ = __rhs.__always_noconv_;
	if (__rhs.pbase())
	{
	if (__rhs.pbase() == __rhs.__intbuf_)
	this->setp(__intbuf_, __intbuf_ + (__rhs. epptr() - __rhs.pbase()));
	else
	this->setp((char_type*)__extbuf_,
	(char_type*)__extbuf_ + (__rhs. epptr() - __rhs.pbase()));
	this->__pbump(__rhs. pptr() - __rhs.pbase());
	}
	else if (__rhs.eback())
	{
	if (__rhs.eback() == __rhs.__intbuf_)
	this->setg(__intbuf_, __intbuf_ + (__rhs.gptr() - __rhs.eback()),
	__intbuf_ + (__rhs.egptr() - __rhs.eback()));
	else
	this->setg((char_type*)__extbuf_,
	(char_type*)__extbuf_ + (__rhs.gptr() - __rhs.eback()),
	(char_type*)__extbuf_ + (__rhs.egptr() - __rhs.eback()));
	}
	__rhs.__extbuf_ = 0;
	__rhs.__extbufnext_ = 0;
	__rhs.__extbufend_ = 0;
	__rhs.__ebs_ = 0;
	__rhs.__intbuf_ = 0;
	__rhs.__ibs_ = 0;
	__rhs.__file_ = 0;
	__rhs.__st_ = state_type();
	__rhs.__st_last_ = state_type();
	__rhs.__om_ = 0;
	__rhs.__cm_ = 0;
	__rhs.__owns_eb_ = false;
	__rhs.__owns_ib_ = false;
	__rhs.setg(0, 0, 0);
	__rhs.setp(0, 0);
	}

	template <class _CharT, class _Traits>
	inline
	basic_filebuf<_CharT, _Traits>&
	basic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs)
	{
	close();
	swap(__rhs);
	return *this;
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits>
	basic_filebuf<_CharT, _Traits>::~basic_filebuf()
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	close();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	if (__owns_eb_)
	delete [] __extbuf_;
	if (__owns_ib_)
	delete [] __intbuf_;
	}

	template <class _CharT, class _Traits>
	void
	basic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs)
	{
	basic_streambuf<char_type, traits_type>::swap(__rhs);
	if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_)
	{
	_VSTD::swap(__extbuf_, __rhs.__extbuf_);
	_VSTD::swap(__extbufnext_, __rhs.__extbufnext_);
	_VSTD::swap(__extbufend_, __rhs.__extbufend_);
	}
	else
	{
	ptrdiff_t __ln = __extbufnext_ - __extbuf_;
	ptrdiff_t __le = __extbufend_ - __extbuf_;
	ptrdiff_t __rn = __rhs.__extbufnext_ - __rhs.__extbuf_;
	ptrdiff_t __re = __rhs.__extbufend_ - __rhs.__extbuf_;
	if (__extbuf_ == __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_)
	{
	__extbuf_ = __rhs.__extbuf_;
	__rhs.__extbuf_ = __rhs.__extbuf_min_;
	}
	else if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ == __rhs.__extbuf_min_)
	{
	__rhs.__extbuf_ = __extbuf_;
	__extbuf_ = __extbuf_min_;
	}
	__extbufnext_ = __extbuf_ + __rn;
	__extbufend_ = __extbuf_ + __re;
	__rhs.__extbufnext_ = __rhs.__extbuf_ + __ln;
	__rhs.__extbufend_ = __rhs.__extbuf_ + __le;
	}
	_VSTD::swap(__ebs_, __rhs.__ebs_);
	_VSTD::swap(__intbuf_, __rhs.__intbuf_);
	_VSTD::swap(__ibs_, __rhs.__ibs_);
	_VSTD::swap(__file_, __rhs.__file_);
	_VSTD::swap(__cv_, __rhs.__cv_);
	_VSTD::swap(__st_, __rhs.__st_);
	_VSTD::swap(__st_last_, __rhs.__st_last_);
	_VSTD::swap(__om_, __rhs.__om_);
	_VSTD::swap(__cm_, __rhs.__cm_);
	_VSTD::swap(__owns_eb_, __rhs.__owns_eb_);
	_VSTD::swap(__owns_ib_, __rhs.__owns_ib_);
	_VSTD::swap(__always_noconv_, __rhs.__always_noconv_);
	if (this->eback() == (char_type*)__rhs.__extbuf_min_)
	{
	ptrdiff_t __n = this->gptr() - this->eback();
	ptrdiff_t __e = this->egptr() - this->eback();
	this->setg((char_type*)__extbuf_min_,
	(char_type*)__extbuf_min_ + __n,
	(char_type*)__extbuf_min_ + __e);
	}
	else if (this->pbase() == (char_type*)__rhs.__extbuf_min_)
	{
	ptrdiff_t __n = this->pptr() - this->pbase();
	ptrdiff_t __e = this->epptr() - this->pbase();
	this->setp((char_type*)__extbuf_min_,
	(char_type*)__extbuf_min_ + __e);
	this->__pbump(__n);
	}
	if (__rhs.eback() == (char_type*)__extbuf_min_)
	{
	ptrdiff_t __n = __rhs.gptr() - __rhs.eback();
	ptrdiff_t __e = __rhs.egptr() - __rhs.eback();
	__rhs.setg((char_type*)__rhs.__extbuf_min_,
	(char_type*)__rhs.__extbuf_min_ + __n,
	(char_type*)__rhs.__extbuf_min_ + __e);
	}
	else if (__rhs.pbase() == (char_type*)__extbuf_min_)
	{
	ptrdiff_t __n = __rhs.pptr() - __rhs.pbase();
	ptrdiff_t __e = __rhs.epptr() - __rhs.pbase();
	__rhs.setp((char_type*)__rhs.__extbuf_min_,
	(char_type*)__rhs.__extbuf_min_ + __e);
	__rhs.__pbump(__n);
	}
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(basic_filebuf<_CharT, _Traits>& __x, basic_filebuf<_CharT, _Traits>& __y)
	{
	__x.swap(__y);
	}

	template <class _CharT, class _Traits>
	inline
	bool
	basic_filebuf<_CharT, _Traits>::is_open() const
	{
	return __file_ != 0;
	}

	+template <class _CharT, class _Traits>
	+const char* basic_filebuf<_CharT, _Traits>::__make_mdstring(
	+ ios_base::openmode __mode) _NOEXCEPT {
	+ switch (__mode & ~ios_base::ate) {
	+ case ios_base::out:
	+ case ios_base::out \| ios_base::trunc:
	+ return "w";
	+ case ios_base::out \| ios_base::app:
	+ case ios_base::app:
	+ return "a";
	+ case ios_base::in:
	+ return "r";
	+ case ios_base::in \| ios_base::out:
	+ return "r+";
	+ case ios_base::in \| ios_base::out \| ios_base::trunc:
	+ return "w+";
	+ case ios_base::in \| ios_base::out \| ios_base::app:
	+ case ios_base::in \| ios_base::app:
	+ return "a+";
	+ case ios_base::out \| ios_base::binary:
	+ case ios_base::out \| ios_base::trunc \| ios_base::binary:
	+ return "wb";
	+ case ios_base::out \| ios_base::app \| ios_base::binary:
	+ case ios_base::app \| ios_base::binary:
	+ return "ab";
	+ case ios_base::in \| ios_base::binary:
	+ return "rb";
	+ case ios_base::in \| ios_base::out \| ios_base::binary:
	+ return "r+b";
	+ case ios_base::in \| ios_base::out \| ios_base::trunc \| ios_base::binary:
	+ return "w+b";
	+ case ios_base::in \| ios_base::out \| ios_base::app \| ios_base::binary:
	+ case ios_base::in \| ios_base::app \| ios_base::binary:
	+ return "a+b";
	+ default:
	+ return nullptr;
	+ }
	+ _LIBCPP_UNREACHABLE();
	+}
	+
	#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
	template <class _CharT, class _Traits>
	basic_filebuf<_CharT, _Traits>*
	basic_filebuf<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
	{
	basic_filebuf<_CharT, _Traits>* __rt = 0;
	if (__file_ == 0)
	{
	+ if (const char* __mdstr = __make_mdstring(__mode)) {
	__rt = this;
	- const char* __mdstr;
	+ __file_ = fopen(__s, __mdstr);
	+ if (__file_) {
	+ __om_ = __mode;
	+ if (__mode & ios_base::ate) {
	+ if (fseek(__file_, 0, SEEK_END)) {
	+ fclose(__file_);
	+ __file_ = 0;
	+ __rt = 0;
	+ }
	+ }
	+ } else
	+ __rt = 0;
	+ }
	+ }
	+ return __rt;
	+}
	+
	+template <class _CharT, class _Traits>
	+_LIBCPP_INLINE_VISIBILITY basic_filebuf<_CharT, _Traits>*
	+basic_filebuf<_CharT, _Traits>::__open(int __fd, ios_base::openmode __mode) {
	+ basic_filebuf<_CharT, _Traits>* __rt = 0;
	+ if (__file_ == 0) {
	+ if (const char* __mdstr = __make_mdstring(__mode)) {
	+ __rt = this;
	+ __file_ = fdopen(__fd, __mdstr);
	+ if (__file_) {
	+ __om_ = __mode;
	+ if (__mode & ios_base::ate) {
	+ if (fseek(__file_, 0, SEEK_END)) {
	+ fclose(__file_);
	+ __file_ = 0;
	+ __rt = 0;
	+ }
	+ }
	+ } else
	+ __rt = 0;
	+ }
	+ }
	+ return __rt;
	+}
	+
	+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
	+// This is basically the same as the char* overload except that it uses _wfopen
	+// and long mode strings.
	+template <class _CharT, class _Traits>
	+basic_filebuf<_CharT, _Traits>*
	+basic_filebuf<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
	+{
	+ basic_filebuf<_CharT, _Traits>* __rt = 0;
	+ if (__file_ == 0)
	+ {
	+ __rt = this;
	+ const wchar_t* __mdstr;
	switch (__mode & ~ios_base::ate)
	{
	case ios_base::out:
	case ios_base::out \| ios_base::trunc:
	- __mdstr = "w";
	+ __mdstr = L"w";
	break;
	case ios_base::out \| ios_base::app:
	case ios_base::app:
	- __mdstr = "a";
	+ __mdstr = L"a";
	break;
	case ios_base::in:
	- __mdstr = "r";
	+ __mdstr = L"r";
	break;
	case ios_base::in \| ios_base::out:
	- __mdstr = "r+";
	+ __mdstr = L"r+";
	break;
	case ios_base::in \| ios_base::out \| ios_base::trunc:
	- __mdstr = "w+";
	+ __mdstr = L"w+";
	break;
	case ios_base::in \| ios_base::out \| ios_base::app:
	case ios_base::in \| ios_base::app:
	- __mdstr = "a+";
	+ __mdstr = L"a+";
	break;
	case ios_base::out \| ios_base::binary:
	case ios_base::out \| ios_base::trunc \| ios_base::binary:
	- __mdstr = "wb";
	+ __mdstr = L"wb";
	break;
	case ios_base::out \| ios_base::app \| ios_base::binary:
	case ios_base::app \| ios_base::binary:
	- __mdstr = "ab";
	+ __mdstr = L"ab";
	break;
	case ios_base::in \| ios_base::binary:
	- __mdstr = "rb";
	+ __mdstr = L"rb";
	break;
	case ios_base::in \| ios_base::out \| ios_base::binary:
	- __mdstr = "r+b";
	+ __mdstr = L"r+b";
	break;
	case ios_base::in \| ios_base::out \| ios_base::trunc \| ios_base::binary:
	- __mdstr = "w+b";
	+ __mdstr = L"w+b";
	break;
	case ios_base::in \| ios_base::out \| ios_base::app \| ios_base::binary:
	case ios_base::in \| ios_base::app \| ios_base::binary:
	- __mdstr = "a+b";
	+ __mdstr = L"a+b";
	break;
	default:
	__rt = 0;
	break;
	}
	if (__rt)
	{
	- __file_ = fopen(__s, __mdstr);
	+ __file_ = _wfopen(__s, __mdstr);
	if (__file_)
	{
	__om_ = __mode;
	if (__mode & ios_base::ate)
	{
	if (fseek(__file_, 0, SEEK_END))
	{
	fclose(__file_);
	__file_ = 0;
	__rt = 0;
	}
	}
	}
	else
	__rt = 0;
	}
	}
	return __rt;
	}
	+#endif

	template <class _CharT, class _Traits>
	inline
	basic_filebuf<_CharT, _Traits>*
	basic_filebuf<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
	{
	return open(__s.c_str(), __mode);
	}
	#endif

	template <class _CharT, class _Traits>
	basic_filebuf<_CharT, _Traits>*
	basic_filebuf<_CharT, _Traits>::close()
	{
	basic_filebuf<_CharT, _Traits>* __rt = 0;
	if (__file_)
	{
	__rt = this;
	unique_ptr<FILE, int()(FILE)> __h(__file_, fclose);
	if (sync())
	__rt = 0;
	if (fclose(__h.release()) == 0)
	__file_ = 0;
	else
	__rt = 0;
	}
	return __rt;
	}

	template <class _CharT, class _Traits>
	typename basic_filebuf<_CharT, _Traits>::int_type
	basic_filebuf<_CharT, _Traits>::underflow()
	{
	if (__file_ == 0)
	return traits_type::eof();
	bool __initial = __read_mode();
	char_type __1buf;
	if (this->gptr() == 0)
	this->setg(&__1buf, &__1buf+1, &__1buf+1);
	const size_t __unget_sz = __initial ? 0 : min<size_t>((this->egptr() - this->eback()) / 2, 4);
	int_type __c = traits_type::eof();
	if (this->gptr() == this->egptr())
	{
	memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type));
	if (__always_noconv_)
	{
	size_t __nmemb = static_cast<size_t>(this->egptr() - this->eback() - __unget_sz);
	__nmemb = fread(this->eback() + __unget_sz, 1, __nmemb, __file_);
	if (__nmemb != 0)
	{
	this->setg(this->eback(),
	this->eback() + __unget_sz,
	this->eback() + __unget_sz + __nmemb);
	__c = traits_type::to_int_type(*this->gptr());
	}
	}
	else
	{
	_LIBCPP_ASSERT ( !(__extbufnext_ == NULL && (__extbufend_ != __extbufnext_)), "underflow moving from NULL" );
	if (__extbufend_ != __extbufnext_)
	memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
	__extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
	__extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
	size_t __nmemb = _VSTD::min(static_cast<size_t>(__ibs_ - __unget_sz),
	static_cast<size_t>(__extbufend_ - __extbufnext_));
	codecvt_base::result __r;
	__st_last_ = __st_;
	size_t __nr = fread((void) const_cast<char >(__extbufnext_), 1, __nmemb, __file_);
	if (__nr != 0)
	{
	if (!__cv_)
	__throw_bad_cast();

	__extbufend_ = __extbufnext_ + __nr;
	char_type* __inext;
	__r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_,
	this->eback() + __unget_sz,
	this->eback() + __ibs_, __inext);
	if (__r == codecvt_base::noconv)
	{
	this->setg((char_type)__extbuf_, (char_type)__extbuf_,
	(char_type)const_cast<char >(__extbufend_));
	__c = traits_type::to_int_type(*this->gptr());
	}
	else if (__inext != this->eback() + __unget_sz)
	{
	this->setg(this->eback(), this->eback() + __unget_sz, __inext);
	__c = traits_type::to_int_type(*this->gptr());
	}
	}
	}
	}
	else
	__c = traits_type::to_int_type(*this->gptr());
	if (this->eback() == &__1buf)
	this->setg(0, 0, 0);
	return __c;
	}

	template <class _CharT, class _Traits>
	typename basic_filebuf<_CharT, _Traits>::int_type
	basic_filebuf<_CharT, _Traits>::pbackfail(int_type __c)
	{
	if (__file_ && this->eback() < this->gptr())
	{
	if (traits_type::eq_int_type(__c, traits_type::eof()))
	{
	this->gbump(-1);
	return traits_type::not_eof(__c);
	}
	if ((__om_ & ios_base::out) \|\|
	traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1]))
	{
	this->gbump(-1);
	*this->gptr() = traits_type::to_char_type(__c);
	return __c;
	}
	}
	return traits_type::eof();
	}

	template <class _CharT, class _Traits>
	typename basic_filebuf<_CharT, _Traits>::int_type
	basic_filebuf<_CharT, _Traits>::overflow(int_type __c)
	{
	if (__file_ == 0)
	return traits_type::eof();
	__write_mode();
	char_type __1buf;
	char_type* __pb_save = this->pbase();
	char_type* __epb_save = this->epptr();
	if (!traits_type::eq_int_type(__c, traits_type::eof()))
	{
	if (this->pptr() == 0)
	this->setp(&__1buf, &__1buf+1);
	*this->pptr() = traits_type::to_char_type(__c);
	this->pbump(1);
	}
	if (this->pptr() != this->pbase())
	{
	if (__always_noconv_)
	{
	size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
	if (fwrite(this->pbase(), sizeof(char_type), __nmemb, __file_) != __nmemb)
	return traits_type::eof();
	}
	else
	{
	char* __extbe = __extbuf_;
	codecvt_base::result __r;
	do
	{
	if (!__cv_)
	__throw_bad_cast();

	const char_type* __e;
	__r = __cv_->out(__st_, this->pbase(), this->pptr(), __e,
	__extbuf_, __extbuf_ + __ebs_, __extbe);
	if (__e == this->pbase())
	return traits_type::eof();
	if (__r == codecvt_base::noconv)
	{
	size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
	if (fwrite(this->pbase(), 1, __nmemb, __file_) != __nmemb)
	return traits_type::eof();
	}
	else if (__r == codecvt_base::ok \|\| __r == codecvt_base::partial)
	{
	size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_);
	if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb)
	return traits_type::eof();
	if (__r == codecvt_base::partial)
	{
	this->setp(const_cast<char_type*>(__e), this->pptr());
	this->__pbump(this->epptr() - this->pbase());
	}
	}
	else
	return traits_type::eof();
	} while (__r == codecvt_base::partial);
	}
	this->setp(__pb_save, __epb_save);
	}
	return traits_type::not_eof(__c);
	}

	template <class _CharT, class _Traits>
	basic_streambuf<_CharT, _Traits>*
	basic_filebuf<_CharT, _Traits>::setbuf(char_type* __s, streamsize __n)
	{
	this->setg(0, 0, 0);
	this->setp(0, 0);
	if (__owns_eb_)
	delete [] __extbuf_;
	if (__owns_ib_)
	delete [] __intbuf_;
	__ebs_ = __n;
	if (__ebs_ > sizeof(__extbuf_min_))
	{
	if (__always_noconv_ && __s)
	{
	__extbuf_ = (char*)__s;
	__owns_eb_ = false;
	}
	else
	{
	__extbuf_ = new char[__ebs_];
	__owns_eb_ = true;
	}
	}
	else
	{
	__extbuf_ = __extbuf_min_;
	__ebs_ = sizeof(__extbuf_min_);
	__owns_eb_ = false;
	}
	if (!__always_noconv_)
	{
	__ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_));
	if (__s && __ibs_ >= sizeof(__extbuf_min_))
	{
	__intbuf_ = __s;
	__owns_ib_ = false;
	}
	else
	{
	__intbuf_ = new char_type[__ibs_];
	__owns_ib_ = true;
	}
	}
	else
	{
	__ibs_ = 0;
	__intbuf_ = 0;
	__owns_ib_ = false;
	}
	return this;
	}

	template <class _CharT, class _Traits>
	typename basic_filebuf<_CharT, _Traits>::pos_type
	basic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way,
	ios_base::openmode)
	{
	if (!__cv_)
	__throw_bad_cast();

	int __width = __cv_->encoding();
	if (__file_ == 0 \|\| (__width <= 0 && __off != 0) \|\| sync())
	return pos_type(off_type(-1));
	// __width > 0 \|\| __off == 0
	int __whence;
	switch (__way)
	{
	case ios_base::beg:
	__whence = SEEK_SET;
	break;
	case ios_base::cur:
	__whence = SEEK_CUR;
	break;
	case ios_base::end:
	__whence = SEEK_END;
	break;
	default:
	return pos_type(off_type(-1));
	}
	#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
	if (fseek(__file_, __width > 0 ? __width * __off : 0, __whence))
	return pos_type(off_type(-1));
	pos_type __r = ftell(__file_);
	#else
	if (fseeko(__file_, __width > 0 ? __width * __off : 0, __whence))
	return pos_type(off_type(-1));
	pos_type __r = ftello(__file_);
	#endif
	__r.state(__st_);
	return __r;
	}

	template <class _CharT, class _Traits>
	typename basic_filebuf<_CharT, _Traits>::pos_type
	basic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode)
	{
	if (__file_ == 0 \|\| sync())
	return pos_type(off_type(-1));
	#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
	if (fseek(__file_, __sp, SEEK_SET))
	return pos_type(off_type(-1));
	#else
	if (fseeko(__file_, __sp, SEEK_SET))
	return pos_type(off_type(-1));
	#endif
	__st_ = __sp.state();
	return __sp;
	}

	template <class _CharT, class _Traits>
	int
	basic_filebuf<_CharT, _Traits>::sync()
	{
	if (__file_ == 0)
	return 0;
	if (!__cv_)
	__throw_bad_cast();

	if (__cm_ & ios_base::out)
	{
	if (this->pptr() != this->pbase())
	if (overflow() == traits_type::eof())
	return -1;
	codecvt_base::result __r;
	do
	{
	char* __extbe;
	__r = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe);
	size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_);
	if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb)
	return -1;
	} while (__r == codecvt_base::partial);
	if (__r == codecvt_base::error)
	return -1;
	if (fflush(__file_))
	return -1;
	}
	else if (__cm_ & ios_base::in)
	{
	off_type __c;
	state_type __state = __st_last_;
	bool __update_st = false;
	if (__always_noconv_)
	__c = this->egptr() - this->gptr();
	else
	{
	int __width = __cv_->encoding();
	__c = __extbufend_ - __extbufnext_;
	if (__width > 0)
	__c += __width * (this->egptr() - this->gptr());
	else
	{
	if (this->gptr() != this->egptr())
	{
	const int __off = __cv_->length(__state, __extbuf_,
	__extbufnext_,
	this->gptr() - this->eback());
	__c += __extbufnext_ - __extbuf_ - __off;
	__update_st = true;
	}
	}
	}
	#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
	if (fseek(__file_, -__c, SEEK_CUR))
	return -1;
	#else
	if (fseeko(__file_, -__c, SEEK_CUR))
	return -1;
	#endif
	if (__update_st)
	__st_ = __state;
	__extbufnext_ = __extbufend_ = __extbuf_;
	this->setg(0, 0, 0);
	__cm_ = 0;
	}
	return 0;
	}

	template <class _CharT, class _Traits>
	void
	basic_filebuf<_CharT, _Traits>::imbue(const locale& __loc)
	{
	sync();
	__cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
	bool __old_anc = __always_noconv_;
	__always_noconv_ = __cv_->always_noconv();
	if (__old_anc != __always_noconv_)
	{
	this->setg(0, 0, 0);
	this->setp(0, 0);
	// invariant, char_type is char, else we couldn't get here
	if (__always_noconv_) // need to dump __intbuf_
	{
	if (__owns_eb_)
	delete [] __extbuf_;
	__owns_eb_ = __owns_ib_;
	__ebs_ = __ibs_;
	__extbuf_ = (char*)__intbuf_;
	__ibs_ = 0;
	__intbuf_ = 0;
	__owns_ib_ = false;
	}
	else // need to obtain an __intbuf_.
	{ // If __extbuf_ is user-supplied, use it, else new __intbuf_
	if (!__owns_eb_ && __extbuf_ != __extbuf_min_)
	{
	__ibs_ = __ebs_;
	__intbuf_ = (char_type*)__extbuf_;
	__owns_ib_ = false;
	__extbuf_ = new char[__ebs_];
	__owns_eb_ = true;
	}
	else
	{
	__ibs_ = __ebs_;
	__intbuf_ = new char_type[__ibs_];
	__owns_ib_ = true;
	}
	}
	}
	}

	template <class _CharT, class _Traits>
	bool
	basic_filebuf<_CharT, _Traits>::__read_mode()
	{
	if (!(__cm_ & ios_base::in))
	{
	this->setp(0, 0);
	if (__always_noconv_)
	this->setg((char_type*)__extbuf_,
	(char_type*)__extbuf_ + __ebs_,
	(char_type*)__extbuf_ + __ebs_);
	else
	this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_);
	__cm_ = ios_base::in;
	return true;
	}
	return false;
	}

	template <class _CharT, class _Traits>
	void
	basic_filebuf<_CharT, _Traits>::__write_mode()
	{
	if (!(__cm_ & ios_base::out))
	{
	this->setg(0, 0, 0);
	if (__ebs_ > sizeof(__extbuf_min_))
	{
	if (__always_noconv_)
	this->setp((char_type*)__extbuf_,
	(char_type*)__extbuf_ + (__ebs_ - 1));
	else
	this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1));
	}
	else
	this->setp(0, 0);
	__cm_ = ios_base::out;
	}
	}

	// basic_ifstream

	template <class _CharT, class _Traits>
	class _LIBCPP_TEMPLATE_VIS basic_ifstream
	: public basic_istream<_CharT, _Traits>
	{
	public:
	typedef _CharT char_type;
	typedef _Traits traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;

	_LIBCPP_INLINE_VISIBILITY
	basic_ifstream();
	#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
	_LIBCPP_INLINE_VISIBILITY
	explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in);
	+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
	_LIBCPP_INLINE_VISIBILITY
	+ explicit basic_ifstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in);
	+#endif
	+ _LIBCPP_INLINE_VISIBILITY
	explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in);
	+#if _LIBCPP_STD_VER >= 17
	+ _LIBCPP_INLINE_VISIBILITY
	+ explicit basic_ifstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in)
	+ : basic_ifstream(__p.c_str(), __mode) {}
	+#endif // _LIBCPP_STD_VER >= 17
	#endif
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	basic_ifstream(basic_ifstream&& __rhs);

	_LIBCPP_INLINE_VISIBILITY
	basic_ifstream& operator=(basic_ifstream&& __rhs);
	#endif
	_LIBCPP_INLINE_VISIBILITY
	void swap(basic_ifstream& __rhs);

	_LIBCPP_INLINE_VISIBILITY
	basic_filebuf<char_type, traits_type>* rdbuf() const;
	_LIBCPP_INLINE_VISIBILITY
	bool is_open() const;
	#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
	void open(const char* __s, ios_base::openmode __mode = ios_base::in);
	+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
	+ void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in);
	+#endif
	void open(const string& __s, ios_base::openmode __mode = ios_base::in);
	+#if _LIBCPP_STD_VER >= 17
	+ _LIBCPP_INLINE_VISIBILITY
	+ void open(const filesystem::path& __p,
	+ ios_base::openmode __mode = ios_base::in) {
	+ return open(__p.c_str(), __mode);
	+ }
	+#endif // _LIBCPP_STD_VER >= 17
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void __open(int __fd, ios_base::openmode __mode);
	#endif
	_LIBCPP_INLINE_VISIBILITY
	void close();

	private:
	basic_filebuf<char_type, traits_type> __sb_;
	};

	template <class _CharT, class _Traits>
	inline
	basic_ifstream<_CharT, _Traits>::basic_ifstream()
	: basic_istream<char_type, traits_type>(&__sb_)
	{
	}

	#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
	template <class _CharT, class _Traits>
	inline
	basic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openmode __mode)
	: basic_istream<char_type, traits_type>(&__sb_)
	{
	if (__sb_.open(__s, __mode \| ios_base::in) == 0)
	this->setstate(ios_base::failbit);
	}

	+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
	template <class _CharT, class _Traits>
	inline
	+basic_ifstream<_CharT, _Traits>::basic_ifstream(const wchar_t* __s, ios_base::openmode __mode)
	+ : basic_istream<char_type, traits_type>(&__sb_)
	+{
	+ if (__sb_.open(__s, __mode \| ios_base::in) == 0)
	+ this->setstate(ios_base::failbit);
	+}
	+#endif
	+
	+template <class _CharT, class _Traits>
	+inline
	basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::openmode __mode)
	: basic_istream<char_type, traits_type>(&__sb_)
	{
	if (__sb_.open(__s, __mode \| ios_base::in) == 0)
	this->setstate(ios_base::failbit);
	}
	#endif

	#ifndef _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits>
	inline
	basic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs)
	: basic_istream<char_type, traits_type>(_VSTD::move(__rhs)),
	__sb_(_VSTD::move(__rhs.__sb_))
	{
	this->set_rdbuf(&__sb_);
	}

	template <class _CharT, class _Traits>
	inline
	basic_ifstream<_CharT, _Traits>&
	basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs)
	{
	basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
	__sb_ = _VSTD::move(__rhs.__sb_);
	return *this;
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits>
	inline
	void
	basic_ifstream<_CharT, _Traits>::swap(basic_ifstream& __rhs)
	{
	basic_istream<char_type, traits_type>::swap(__rhs);
	__sb_.swap(__rhs.__sb_);
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(basic_ifstream<_CharT, _Traits>& __x, basic_ifstream<_CharT, _Traits>& __y)
	{
	__x.swap(__y);
	}

	template <class _CharT, class _Traits>
	inline
	basic_filebuf<_CharT, _Traits>*
	basic_ifstream<_CharT, _Traits>::rdbuf() const
	{
	return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
	}

	template <class _CharT, class _Traits>
	inline
	bool
	basic_ifstream<_CharT, _Traits>::is_open() const
	{
	return __sb_.is_open();
	}

	#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
	template <class _CharT, class _Traits>
	void
	basic_ifstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
	{
	if (__sb_.open(__s, __mode \| ios_base::in))
	this->clear();
	else
	this->setstate(ios_base::failbit);
	}

	+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
	template <class _CharT, class _Traits>
	void
	+basic_ifstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
	+{
	+ if (__sb_.open(__s, __mode \| ios_base::in))
	+ this->clear();
	+ else
	+ this->setstate(ios_base::failbit);
	+}
	+#endif
	+
	+template <class _CharT, class _Traits>
	+void
	basic_ifstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
	{
	if (__sb_.open(__s, __mode \| ios_base::in))
	this->clear();
	else
	this->setstate(ios_base::failbit);
	}
	+
	+template <class _CharT, class _Traits>
	+void basic_ifstream<_CharT, _Traits>::__open(int __fd,
	+ ios_base::openmode __mode) {
	+ if (__sb_.__open(__fd, __mode \| ios_base::in))
	+ this->clear();
	+ else
	+ this->setstate(ios_base::failbit);
	+}
	#endif

	template <class _CharT, class _Traits>
	inline
	void
	basic_ifstream<_CharT, _Traits>::close()
	{
	if (__sb_.close() == 0)
	this->setstate(ios_base::failbit);
	}

	// basic_ofstream

	template <class _CharT, class _Traits>
	class _LIBCPP_TEMPLATE_VIS basic_ofstream
	: public basic_ostream<_CharT, _Traits>
	{
	public:
	typedef _CharT char_type;
	typedef _Traits traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;

	_LIBCPP_INLINE_VISIBILITY
	basic_ofstream();
	_LIBCPP_INLINE_VISIBILITY
	explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out);
	+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
	_LIBCPP_INLINE_VISIBILITY
	+ explicit basic_ofstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::out);
	+#endif
	+ _LIBCPP_INLINE_VISIBILITY
	explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out);
	+
	+#if _LIBCPP_STD_VER >= 17
	+ _LIBCPP_INLINE_VISIBILITY
	+ explicit basic_ofstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out)
	+ : basic_ofstream(__p.c_str(), __mode) {}
	+#endif // _LIBCPP_STD_VER >= 17
	+
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	basic_ofstream(basic_ofstream&& __rhs);

	_LIBCPP_INLINE_VISIBILITY
	basic_ofstream& operator=(basic_ofstream&& __rhs);
	#endif
	_LIBCPP_INLINE_VISIBILITY
	void swap(basic_ofstream& __rhs);

	_LIBCPP_INLINE_VISIBILITY
	basic_filebuf<char_type, traits_type>* rdbuf() const;
	_LIBCPP_INLINE_VISIBILITY
	bool is_open() const;
	#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
	void open(const char* __s, ios_base::openmode __mode = ios_base::out);
	+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
	+ void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::out);
	+#endif
	void open(const string& __s, ios_base::openmode __mode = ios_base::out);
	+
	+#if _LIBCPP_STD_VER >= 17
	+ _LIBCPP_INLINE_VISIBILITY
	+ void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out)
	+ { return open(__p.c_str(), __mode); }
	+#endif // _LIBCPP_STD_VER >= 17
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ void __open(int __fd, ios_base::openmode __mode);
	#endif
	_LIBCPP_INLINE_VISIBILITY
	void close();

	private:
	basic_filebuf<char_type, traits_type> __sb_;
	};

	template <class _CharT, class _Traits>
	inline
	basic_ofstream<_CharT, _Traits>::basic_ofstream()
	: basic_ostream<char_type, traits_type>(&__sb_)
	{
	}

	#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
	template <class _CharT, class _Traits>
	inline
	basic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openmode __mode)
	: basic_ostream<char_type, traits_type>(&__sb_)
	{
	if (__sb_.open(__s, __mode \| ios_base::out) == 0)
	this->setstate(ios_base::failbit);
	}

	+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
	template <class _CharT, class _Traits>
	inline
	+basic_ofstream<_CharT, _Traits>::basic_ofstream(const wchar_t* __s, ios_base::openmode __mode)
	+ : basic_ostream<char_type, traits_type>(&__sb_)
	+{
	+ if (__sb_.open(__s, __mode \| ios_base::out) == 0)
	+ this->setstate(ios_base::failbit);
	+}
	+#endif
	+
	+template <class _CharT, class _Traits>
	+inline
	basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::openmode __mode)
	: basic_ostream<char_type, traits_type>(&__sb_)
	{
	if (__sb_.open(__s, __mode \| ios_base::out) == 0)
	this->setstate(ios_base::failbit);
	}
	#endif

	#ifndef _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits>
	inline
	basic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs)
	: basic_ostream<char_type, traits_type>(_VSTD::move(__rhs)),
	__sb_(_VSTD::move(__rhs.__sb_))
	{
	this->set_rdbuf(&__sb_);
	}

	template <class _CharT, class _Traits>
	inline
	basic_ofstream<_CharT, _Traits>&
	basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs)
	{
	basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
	__sb_ = _VSTD::move(__rhs.__sb_);
	return *this;
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits>
	inline
	void
	basic_ofstream<_CharT, _Traits>::swap(basic_ofstream& __rhs)
	{
	basic_ostream<char_type, traits_type>::swap(__rhs);
	__sb_.swap(__rhs.__sb_);
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(basic_ofstream<_CharT, _Traits>& __x, basic_ofstream<_CharT, _Traits>& __y)
	{
	__x.swap(__y);
	}

	template <class _CharT, class _Traits>
	inline
	basic_filebuf<_CharT, _Traits>*
	basic_ofstream<_CharT, _Traits>::rdbuf() const
	{
	return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
	}

	template <class _CharT, class _Traits>
	inline
	bool
	basic_ofstream<_CharT, _Traits>::is_open() const
	{
	return __sb_.is_open();
	}

	#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
	template <class _CharT, class _Traits>
	void
	basic_ofstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
	{
	if (__sb_.open(__s, __mode \| ios_base::out))
	this->clear();
	else
	this->setstate(ios_base::failbit);
	}

	+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
	template <class _CharT, class _Traits>
	void
	+basic_ofstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
	+{
	+ if (__sb_.open(__s, __mode \| ios_base::out))
	+ this->clear();
	+ else
	+ this->setstate(ios_base::failbit);
	+}
	+#endif
	+
	+template <class _CharT, class _Traits>
	+void
	basic_ofstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
	{
	if (__sb_.open(__s, __mode \| ios_base::out))
	this->clear();
	else
	this->setstate(ios_base::failbit);
	}
	+
	+template <class _CharT, class _Traits>
	+void basic_ofstream<_CharT, _Traits>::__open(int __fd,
	+ ios_base::openmode __mode) {
	+ if (__sb_.__open(__fd, __mode \| ios_base::out))
	+ this->clear();
	+ else
	+ this->setstate(ios_base::failbit);
	+}
	#endif

	template <class _CharT, class _Traits>
	inline
	void
	basic_ofstream<_CharT, _Traits>::close()
	{
	if (__sb_.close() == 0)
	this->setstate(ios_base::failbit);
	}

	// basic_fstream

	template <class _CharT, class _Traits>
	class _LIBCPP_TEMPLATE_VIS basic_fstream
	: public basic_iostream<_CharT, _Traits>
	{
	public:
	typedef _CharT char_type;
	typedef _Traits traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;

	_LIBCPP_INLINE_VISIBILITY
	basic_fstream();
	#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
	_LIBCPP_INLINE_VISIBILITY
	explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in \| ios_base::out);
	+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
	_LIBCPP_INLINE_VISIBILITY
	+ explicit basic_fstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in \| ios_base::out);
	+#endif
	+ _LIBCPP_INLINE_VISIBILITY
	explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in \| ios_base::out);
	+
	+#if _LIBCPP_STD_VER >= 17
	+ _LIBCPP_INLINE_VISIBILITY
	+ explicit basic_fstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in \| ios_base::out)
	+ : basic_fstream(__p.c_str(), __mode) {}
	+#endif // _LIBCPP_STD_VER >= 17
	+
	#endif
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	basic_fstream(basic_fstream&& __rhs);

	_LIBCPP_INLINE_VISIBILITY
	basic_fstream& operator=(basic_fstream&& __rhs);
	#endif
	_LIBCPP_INLINE_VISIBILITY
	void swap(basic_fstream& __rhs);

	_LIBCPP_INLINE_VISIBILITY
	basic_filebuf<char_type, traits_type>* rdbuf() const;
	_LIBCPP_INLINE_VISIBILITY
	bool is_open() const;
	#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
	void open(const char* __s, ios_base::openmode __mode = ios_base::in \| ios_base::out);
	+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
	+ void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in \| ios_base::out);
	+#endif
	void open(const string& __s, ios_base::openmode __mode = ios_base::in \| ios_base::out);
	+
	+#if _LIBCPP_STD_VER >= 17
	+ _LIBCPP_INLINE_VISIBILITY
	+ void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in\|ios_base::out)
	+ { return open(__p.c_str(), __mode); }
	+#endif // _LIBCPP_STD_VER >= 17
	+
	#endif
	_LIBCPP_INLINE_VISIBILITY
	void close();

	private:
	basic_filebuf<char_type, traits_type> __sb_;
	};

	template <class _CharT, class _Traits>
	inline
	basic_fstream<_CharT, _Traits>::basic_fstream()
	: basic_iostream<char_type, traits_type>(&__sb_)
	{
	}

	#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
	template <class _CharT, class _Traits>
	inline
	basic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmode __mode)
	: basic_iostream<char_type, traits_type>(&__sb_)
	{
	if (__sb_.open(__s, __mode) == 0)
	this->setstate(ios_base::failbit);
	}

	+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
	template <class _CharT, class _Traits>
	inline
	+basic_fstream<_CharT, _Traits>::basic_fstream(const wchar_t* __s, ios_base::openmode __mode)
	+ : basic_iostream<char_type, traits_type>(&__sb_)
	+{
	+ if (__sb_.open(__s, __mode) == 0)
	+ this->setstate(ios_base::failbit);
	+}
	+#endif
	+
	+template <class _CharT, class _Traits>
	+inline
	basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openmode __mode)
	: basic_iostream<char_type, traits_type>(&__sb_)
	{
	if (__sb_.open(__s, __mode) == 0)
	this->setstate(ios_base::failbit);
	}
	#endif

	#ifndef _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits>
	inline
	basic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs)
	: basic_iostream<char_type, traits_type>(_VSTD::move(__rhs)),
	__sb_(_VSTD::move(__rhs.__sb_))
	{
	this->set_rdbuf(&__sb_);
	}

	template <class _CharT, class _Traits>
	inline
	basic_fstream<_CharT, _Traits>&
	basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs)
	{
	basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
	__sb_ = _VSTD::move(__rhs.__sb_);
	return *this;
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits>
	inline
	void
	basic_fstream<_CharT, _Traits>::swap(basic_fstream& __rhs)
	{
	basic_iostream<char_type, traits_type>::swap(__rhs);
	__sb_.swap(__rhs.__sb_);
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(basic_fstream<_CharT, _Traits>& __x, basic_fstream<_CharT, _Traits>& __y)
	{
	__x.swap(__y);
	}

	template <class _CharT, class _Traits>
	inline
	basic_filebuf<_CharT, _Traits>*
	basic_fstream<_CharT, _Traits>::rdbuf() const
	{
	return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
	}

	template <class _CharT, class _Traits>
	inline
	bool
	basic_fstream<_CharT, _Traits>::is_open() const
	{
	return __sb_.is_open();
	}

	#ifndef _LIBCPP_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
	template <class _CharT, class _Traits>
	void
	basic_fstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
	{
	if (__sb_.open(__s, __mode))
	this->clear();
	else
	this->setstate(ios_base::failbit);
	}
	+
	+#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
	+template <class _CharT, class _Traits>
	+void
	+basic_fstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
	+{
	+ if (__sb_.open(__s, __mode))
	+ this->clear();
	+ else
	+ this->setstate(ios_base::failbit);
	+}
	+#endif

	template <class _CharT, class _Traits>
	void
	basic_fstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
	{
	if (__sb_.open(__s, __mode))
	this->clear();
	else
	this->setstate(ios_base::failbit);
	}
	#endif

	template <class _CharT, class _Traits>
	inline
	void
	basic_fstream<_CharT, _Traits>::close()
	{
	if (__sb_.close() == 0)
	this->setstate(ios_base::failbit);
	}

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_FSTREAM
	Index: projects/clang700-import/contrib/libc++/include/functional
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/functional (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/functional (revision 337135)
	@@ -1,2416 +1,2524 @@
	// -- C++ --
	//===------------------------ functional ----------------------------------===//
	//
	// 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_FUNCTIONAL
	#define _LIBCPP_FUNCTIONAL

	/*
	functional synopsis

	namespace std
	{

	template <class Arg, class Result>
	struct unary_function
	{
	typedef Arg argument_type;
	typedef Result result_type;
	};

	template <class Arg1, class Arg2, class Result>
	struct binary_function
	{
	typedef Arg1 first_argument_type;
	typedef Arg2 second_argument_type;
	typedef Result result_type;
	};

	template <class T>
	class reference_wrapper
	: public unary_function<T1, R> // if wrapping a unary functor
	: public binary_function<T1, T2, R> // if wraping a binary functor
	{
	public:
	// types
	typedef T type;
	typedef see below result_type; // Not always defined

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

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

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

	// invoke
	template <class... ArgTypes>
	typename result_of<T&(ArgTypes&&...)>::type
	operator() (ArgTypes&&...) const;
	};

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

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

	template <class T> // <class T=void> in C++14
	struct plus : binary_function<T, T, T>
	{
	T operator()(const T& x, const T& y) const;
	};

	template <class T> // <class T=void> in C++14
	struct minus : binary_function<T, T, T>
	{
	T operator()(const T& x, const T& y) const;
	};

	template <class T> // <class T=void> in C++14
	struct multiplies : binary_function<T, T, T>
	{
	T operator()(const T& x, const T& y) const;
	};

	template <class T> // <class T=void> in C++14
	struct divides : binary_function<T, T, T>
	{
	T operator()(const T& x, const T& y) const;
	};

	template <class T> // <class T=void> in C++14
	struct modulus : binary_function<T, T, T>
	{
	T operator()(const T& x, const T& y) const;
	};

	template <class T> // <class T=void> in C++14
	struct negate : unary_function<T, T>
	{
	T operator()(const T& x) const;
	};

	template <class T> // <class T=void> in C++14
	struct equal_to : binary_function<T, T, bool>
	{
	bool operator()(const T& x, const T& y) const;
	};

	template <class T> // <class T=void> in C++14
	struct not_equal_to : binary_function<T, T, bool>
	{
	bool operator()(const T& x, const T& y) const;
	};

	template <class T> // <class T=void> in C++14
	struct greater : binary_function<T, T, bool>
	{
	bool operator()(const T& x, const T& y) const;
	};

	template <class T> // <class T=void> in C++14
	struct less : binary_function<T, T, bool>
	{
	bool operator()(const T& x, const T& y) const;
	};

	template <class T> // <class T=void> in C++14
	struct greater_equal : binary_function<T, T, bool>
	{
	bool operator()(const T& x, const T& y) const;
	};

	template <class T> // <class T=void> in C++14
	struct less_equal : binary_function<T, T, bool>
	{
	bool operator()(const T& x, const T& y) const;
	};

	template <class T> // <class T=void> in C++14
	struct logical_and : binary_function<T, T, bool>
	{
	bool operator()(const T& x, const T& y) const;
	};

	template <class T> // <class T=void> in C++14
	struct logical_or : binary_function<T, T, bool>
	{
	bool operator()(const T& x, const T& y) const;
	};

	template <class T> // <class T=void> in C++14
	struct logical_not : unary_function<T, bool>
	{
	bool operator()(const T& x) const;
	};

	template <class T> // <class T=void> in C++14
	struct bit_and : unary_function<T, bool>
	{
	bool operator()(const T& x, const T& y) const;
	};

	template <class T> // <class T=void> in C++14
	struct bit_or : unary_function<T, bool>
	{
	bool operator()(const T& x, const T& y) const;
	};

	template <class T> // <class T=void> in C++14
	struct bit_xor : unary_function<T, bool>
	{
	bool operator()(const T& x, const T& y) const;
	};

	template <class T=void> // C++14
	struct bit_xor : unary_function<T, bool>
	{
	bool operator()(const T& x) const;
	};

	template <class Predicate>
	class unary_negate
	: public unary_function<typename Predicate::argument_type, bool>
	{
	public:
	explicit unary_negate(const Predicate& pred);
	bool operator()(const typename Predicate::argument_type& x) const;
	};

	template <class Predicate> unary_negate<Predicate> not1(const Predicate& pred);

	template <class Predicate>
	class binary_negate
	: public binary_function<typename Predicate::first_argument_type,
	typename Predicate::second_argument_type,
	bool>
	{
	public:
	explicit binary_negate(const Predicate& pred);
	bool operator()(const typename Predicate::first_argument_type& x,
	const typename Predicate::second_argument_type& y) const;
	};

	template <class Predicate> binary_negate<Predicate> not2(const Predicate& pred);

	template <class F> unspecified not_fn(F&& f); // C++17

	template<class T> struct is_bind_expression;
	template<class T> struct is_placeholder;

	// See C++14 20.9.9, Function object binders
	template <class T> inline constexpr bool is_bind_expression_v
	= is_bind_expression<T>::value; // C++17
	template <class T> inline constexpr int is_placeholder_v
	= is_placeholder<T>::value; // C++17


	template<class Fn, class... BoundArgs>
	unspecified bind(Fn&&, BoundArgs&&...);
	template<class R, class Fn, class... BoundArgs>
	unspecified bind(Fn&&, BoundArgs&&...);

	namespace placeholders {
	// M is the implementation-defined number of placeholders
	extern unspecified _1;
	extern unspecified _2;
	.
	.
	.
	extern unspecified _Mp;
	}

	template <class Operation>
	class binder1st // deprecated in C++11, removed in C++17
	: public unary_function<typename Operation::second_argument_type,
	typename Operation::result_type>
	{
	protected:
	Operation op;
	typename Operation::first_argument_type value;
	public:
	binder1st(const Operation& x, const typename Operation::first_argument_type y);
	typename Operation::result_type operator()( typename Operation::second_argument_type& x) const;
	typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const;
	};

	template <class Operation, class T>
	binder1st<Operation> bind1st(const Operation& op, const T& x); // deprecated in C++11, removed in C++17

	template <class Operation>
	class binder2nd // deprecated in C++11, removed in C++17
	: public unary_function<typename Operation::first_argument_type,
	typename Operation::result_type>
	{
	protected:
	Operation op;
	typename Operation::second_argument_type value;
	public:
	binder2nd(const Operation& x, const typename Operation::second_argument_type y);
	typename Operation::result_type operator()( typename Operation::first_argument_type& x) const;
	typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const;
	};

	template <class Operation, class T>
	binder2nd<Operation> bind2nd(const Operation& op, const T& x); // deprecated in C++11, removed in C++17

	template <class Arg, class Result> // deprecated in C++11, removed in C++17
	class pointer_to_unary_function : public unary_function<Arg, Result>
	{
	public:
	explicit pointer_to_unary_function(Result (*f)(Arg));
	Result operator()(Arg x) const;
	};

	template <class Arg, class Result>
	pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg)); // deprecated in C++11, removed in C++17

	template <class Arg1, class Arg2, class Result> // deprecated in C++11, removed in C++17
	class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result>
	{
	public:
	explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));
	Result operator()(Arg1 x, Arg2 y) const;
	};

	template <class Arg1, class Arg2, class Result>
	pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1,Arg2)); // deprecated in C++11, removed in C++17

	template<class S, class T> // deprecated in C++11, removed in C++17
	class mem_fun_t : public unary_function<T*, S>
	{
	public:
	explicit mem_fun_t(S (T::*p)());
	S operator()(T* p) const;
	};

	template<class S, class T, class A>
	class mem_fun1_t : public binary_function<T*, A, S> // deprecated in C++11, removed in C++17
	{
	public:
	explicit mem_fun1_t(S (T::*p)(A));
	S operator()(T* p, A x) const;
	};

	template<class S, class T> mem_fun_t<S,T> mem_fun(S (T::*f)()); // deprecated in C++11, removed in C++17
	template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A)); // deprecated in C++11, removed in C++17

	template<class S, class T>
	class mem_fun_ref_t : public unary_function<T, S> // deprecated in C++11, removed in C++17
	{
	public:
	explicit mem_fun_ref_t(S (T::*p)());
	S operator()(T& p) const;
	};

	template<class S, class T, class A>
	class mem_fun1_ref_t : public binary_function<T, A, S> // deprecated in C++11, removed in C++17
	{
	public:
	explicit mem_fun1_ref_t(S (T::*p)(A));
	S operator()(T& p, A x) const;
	};

	template<class S, class T> mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)()); // deprecated in C++11, removed in C++17
	template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A)); // deprecated in C++11, removed in C++17

	template <class S, class T>
	class const_mem_fun_t : public unary_function<const T*, S> // deprecated in C++11, removed in C++17
	{
	public:
	explicit const_mem_fun_t(S (T::*p)() const);
	S operator()(const T* p) const;
	};

	template <class S, class T, class A>
	class const_mem_fun1_t : public binary_function<const T*, A, S> // deprecated in C++11, removed in C++17
	{
	public:
	explicit const_mem_fun1_t(S (T::*p)(A) const);
	S operator()(const T* p, A x) const;
	};

	template <class S, class T> const_mem_fun_t<S,T> mem_fun(S (T::*f)() const); // deprecated in C++11, removed in C++17
	template <class S, class T, class A> const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const); // deprecated in C++11, removed in C++17

	template <class S, class T>
	class const_mem_fun_ref_t : public unary_function<T, S> // deprecated in C++11, removed in C++17
	{
	public:
	explicit const_mem_fun_ref_t(S (T::*p)() const);
	S operator()(const T& p) const;
	};

	template <class S, class T, class A>
	class const_mem_fun1_ref_t : public binary_function<T, A, S> // deprecated in C++11, removed in C++17
	{
	public:
	explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
	S operator()(const T& p, A x) const;
	};

	template <class S, class T> const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const); // deprecated in C++11, removed in C++17
	template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const); // deprecated in C++11, removed in C++17

	template<class R, class T> unspecified mem_fn(R T::*);

	class bad_function_call
	: public exception
	{
	};

	template<class> class function; // undefined

	template<class R, class... ArgTypes>
	class function<R(ArgTypes...)>
	: public unary_function<T1, R> // iff sizeof...(ArgTypes) == 1 and
	// ArgTypes contains T1
	: public binary_function<T1, T2, R> // iff sizeof...(ArgTypes) == 2 and
	// ArgTypes contains T1 and T2
	{
	public:
	typedef R result_type;

	// construct/copy/destroy:
	function() noexcept;
	function(nullptr_t) noexcept;
	function(const function&);
	function(function&&) noexcept;
	template<class F>
	function(F);
	template<Allocator Alloc>
	function(allocator_arg_t, const Alloc&) noexcept; // removed in C++17
	template<Allocator Alloc>
	function(allocator_arg_t, const Alloc&, nullptr_t) noexcept; // removed in C++17
	template<Allocator Alloc>
	function(allocator_arg_t, const Alloc&, const function&); // removed in C++17
	template<Allocator Alloc>
	function(allocator_arg_t, const Alloc&, function&&); // removed in C++17
	template<class F, Allocator Alloc>
	function(allocator_arg_t, const Alloc&, F); // removed in C++17

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

	~function();

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

	// function capacity:
	explicit operator bool() const noexcept;

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

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

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

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

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

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

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

	template <class T> struct hash;

	template <> struct hash<bool>;
	template <> struct hash<char>;
	template <> struct hash<signed char>;
	template <> struct hash<unsigned char>;
	template <> struct hash<char16_t>;
	template <> struct hash<char32_t>;
	template <> struct hash<wchar_t>;
	template <> struct hash<short>;
	template <> struct hash<unsigned short>;
	template <> struct hash<int>;
	template <> struct hash<unsigned int>;
	template <> struct hash<long>;
	template <> struct hash<long long>;
	template <> struct hash<unsigned long>;
	template <> struct hash<unsigned long long>;

	template <> struct hash<float>;
	template <> struct hash<double>;
	template <> struct hash<long double>;

	template<class T> struct hash<T*>;
	template <> struct hash<nullptr_t>; // C++17

	} // std

	POLICY: For non-variadic implementations, the number of arguments is limited
	to 3. It is hoped that the need for non-variadic implementations
	will be minimal.

	*/

	#include <__config>
	#include <type_traits>
	#include <typeinfo>
	#include <exception>
	#include <memory>
	#include <tuple>
	#include <utility>

	#include <__functional_base>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS plus : binary_function<_Tp, _Tp, _Tp>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x, const _Tp& __y) const
	{return __x + __y;}
	};

	#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


	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS minus : binary_function<_Tp, _Tp, _Tp>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x, const _Tp& __y) const
	{return __x - __y;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS minus<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


	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS multiplies : binary_function<_Tp, _Tp, _Tp>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x, const _Tp& __y) const
	{return __x * __y;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS multiplies<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


	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS divides : binary_function<_Tp, _Tp, _Tp>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x, const _Tp& __y) const
	{return __x / __y;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS divides<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


	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS modulus : binary_function<_Tp, _Tp, _Tp>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x, const _Tp& __y) const
	{return __x % __y;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS modulus<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


	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS negate : unary_function<_Tp, _Tp>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return -__x;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS negate<void>
	{
	template <class _Tp>
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	auto operator()(_Tp&& __x) const
	_NOEXCEPT_(noexcept(- _VSTD::forward<_Tp>(__x)))
	-> decltype (- _VSTD::forward<_Tp>(__x))
	{ return - _VSTD::forward<_Tp>(__x); }
	typedef void is_transparent;
	};
	#endif


	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS equal_to : binary_function<_Tp, _Tp, bool>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Tp& __x, const _Tp& __y) const
	{return __x == __y;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS equal_to<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


	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS not_equal_to : binary_function<_Tp, _Tp, bool>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Tp& __x, const _Tp& __y) const
	{return __x != __y;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS not_equal_to<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


	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS greater : binary_function<_Tp, _Tp, bool>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Tp& __x, const _Tp& __y) const
	{return __x > __y;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS greater<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


	// less in <__functional_base>

	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS greater_equal : binary_function<_Tp, _Tp, bool>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Tp& __x, const _Tp& __y) const
	{return __x >= __y;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS greater_equal<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


	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS less_equal : binary_function<_Tp, _Tp, bool>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Tp& __x, const _Tp& __y) const
	{return __x <= __y;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS less_equal<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


	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS logical_and : binary_function<_Tp, _Tp, bool>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Tp& __x, const _Tp& __y) const
	{return __x && __y;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS logical_and<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


	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS logical_or : binary_function<_Tp, _Tp, bool>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Tp& __x, const _Tp& __y) const
	{return __x \|\| __y;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS logical_or<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


	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS logical_not : unary_function<_Tp, bool>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Tp& __x) const
	{return !__x;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS logical_not<void>
	{
	template <class _Tp>
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	auto operator()(_Tp&& __x) const
	_NOEXCEPT_(noexcept(!_VSTD::forward<_Tp>(__x)))
	-> decltype (!_VSTD::forward<_Tp>(__x))
	{ return !_VSTD::forward<_Tp>(__x); }
	typedef void is_transparent;
	};
	#endif


	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS bit_and : binary_function<_Tp, _Tp, _Tp>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x, const _Tp& __y) const
	{return __x & __y;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS bit_and<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


	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS bit_or : binary_function<_Tp, _Tp, _Tp>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x, const _Tp& __y) const
	{return __x \| __y;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS bit_or<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


	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	#else
	template <class _Tp>
	#endif
	struct _LIBCPP_TEMPLATE_VIS bit_xor : binary_function<_Tp, _Tp, _Tp>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x, const _Tp& __y) const
	{return __x ^ __y;}
	};

	#if _LIBCPP_STD_VER > 11
	template <>
	struct _LIBCPP_TEMPLATE_VIS bit_xor<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


	#if _LIBCPP_STD_VER > 11
	template <class _Tp = void>
	struct _LIBCPP_TEMPLATE_VIS bit_not : unary_function<_Tp, _Tp>
	{
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return ~__x;}
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS bit_not<void>
	{
	template <class _Tp>
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	auto operator()(_Tp&& __x) const
	_NOEXCEPT_(noexcept(~_VSTD::forward<_Tp>(__x)))
	-> decltype (~_VSTD::forward<_Tp>(__x))
	{ return ~_VSTD::forward<_Tp>(__x); }
	typedef void is_transparent;
	};
	#endif

	template <class _Predicate>
	class _LIBCPP_TEMPLATE_VIS unary_negate
	: public unary_function<typename _Predicate::argument_type, bool>
	{
	_Predicate __pred_;
	public:
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	explicit unary_negate(const _Predicate& __pred)
	: __pred_(__pred) {}
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	bool operator()(const typename _Predicate::argument_type& __x) const
	{return !__pred_(__x);}
	};

	template <class _Predicate>
	inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	unary_negate<_Predicate>
	not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);}

	template <class _Predicate>
	class _LIBCPP_TEMPLATE_VIS binary_negate
	: public binary_function<typename _Predicate::first_argument_type,
	typename _Predicate::second_argument_type,
	bool>
	{
	_Predicate __pred_;
	public:
	_LIBCPP_INLINE_VISIBILITY explicit _LIBCPP_CONSTEXPR_AFTER_CXX11
	binary_negate(const _Predicate& __pred) : __pred_(__pred) {}

	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	bool operator()(const typename _Predicate::first_argument_type& __x,
	const typename _Predicate::second_argument_type& __y) const
	{return !__pred_(__x, __y);}
	};

	template <class _Predicate>
	inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	binary_negate<_Predicate>
	not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}

	#if _LIBCPP_STD_VER <= 14 \|\| defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
	template <class __Operation>
	class _LIBCPP_TEMPLATE_VIS binder1st
	: public unary_function<typename __Operation::second_argument_type,
	typename __Operation::result_type>
	{
	protected:
	__Operation op;
	typename __Operation::first_argument_type value;
	public:
	_LIBCPP_INLINE_VISIBILITY binder1st(const __Operation& __x,
	const typename __Operation::first_argument_type __y)
	: op(__x), value(__y) {}
	_LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
	(typename __Operation::second_argument_type& __x) const
	{return op(value, __x);}
	_LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
	(const typename __Operation::second_argument_type& __x) const
	{return op(value, __x);}
	};

	template <class __Operation, class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	binder1st<__Operation>
	bind1st(const __Operation& __op, const _Tp& __x)
	{return binder1st<__Operation>(__op, __x);}

	template <class __Operation>
	class _LIBCPP_TEMPLATE_VIS binder2nd
	: public unary_function<typename __Operation::first_argument_type,
	typename __Operation::result_type>
	{
	protected:
	__Operation op;
	typename __Operation::second_argument_type value;
	public:
	_LIBCPP_INLINE_VISIBILITY
	binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y)
	: op(__x), value(__y) {}
	_LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
	( typename __Operation::first_argument_type& __x) const
	{return op(__x, value);}
	_LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
	(const typename __Operation::first_argument_type& __x) const
	{return op(__x, value);}
	};

	template <class __Operation, class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	binder2nd<__Operation>
	bind2nd(const __Operation& __op, const _Tp& __x)
	{return binder2nd<__Operation>(__op, __x);}

	template <class _Arg, class _Result>
	class _LIBCPP_TEMPLATE_VIS pointer_to_unary_function
	: public unary_function<_Arg, _Result>
	{
	_Result (*__f_)(_Arg);
	public:
	_LIBCPP_INLINE_VISIBILITY explicit pointer_to_unary_function(_Result (*__f)(_Arg))
	: __f_(__f) {}
	_LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg __x) const
	{return __f_(__x);}
	};

	template <class _Arg, class _Result>
	inline _LIBCPP_INLINE_VISIBILITY
	pointer_to_unary_function<_Arg,_Result>
	ptr_fun(_Result (*__f)(_Arg))
	{return pointer_to_unary_function<_Arg,_Result>(__f);}

	template <class _Arg1, class _Arg2, class _Result>
	class _LIBCPP_TEMPLATE_VIS pointer_to_binary_function
	: public binary_function<_Arg1, _Arg2, _Result>
	{
	_Result (*__f_)(_Arg1, _Arg2);
	public:
	_LIBCPP_INLINE_VISIBILITY explicit pointer_to_binary_function(_Result (*__f)(_Arg1, _Arg2))
	: __f_(__f) {}
	_LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg1 __x, _Arg2 __y) const
	{return __f_(__x, __y);}
	};

	template <class _Arg1, class _Arg2, class _Result>
	inline _LIBCPP_INLINE_VISIBILITY
	pointer_to_binary_function<_Arg1,_Arg2,_Result>
	ptr_fun(_Result (*__f)(_Arg1,_Arg2))
	{return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);}

	template<class _Sp, class _Tp>
	class _LIBCPP_TEMPLATE_VIS mem_fun_t : public unary_function<_Tp*, _Sp>
	{
	_Sp (_Tp::*__p_)();
	public:
	_LIBCPP_INLINE_VISIBILITY explicit mem_fun_t(_Sp (_Tp::*__p)())
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p) const
	{return (__p->*__p_)();}
	};

	template<class _Sp, class _Tp, class _Ap>
	class _LIBCPP_TEMPLATE_VIS mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp>
	{
	_Sp (_Tp::*__p_)(_Ap);
	public:
	_LIBCPP_INLINE_VISIBILITY explicit mem_fun1_t(_Sp (_Tp::*__p)(_Ap))
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p, _Ap __x) const
	{return (__p->*__p_)(__x);}
	};

	template<class _Sp, class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	mem_fun_t<_Sp,_Tp>
	mem_fun(_Sp (_Tp::*__f)())
	{return mem_fun_t<_Sp,_Tp>(__f);}

	template<class _Sp, class _Tp, class _Ap>
	inline _LIBCPP_INLINE_VISIBILITY
	mem_fun1_t<_Sp,_Tp,_Ap>
	mem_fun(_Sp (_Tp::*__f)(_Ap))
	{return mem_fun1_t<_Sp,_Tp,_Ap>(__f);}

	template<class _Sp, class _Tp>
	class _LIBCPP_TEMPLATE_VIS mem_fun_ref_t : public unary_function<_Tp, _Sp>
	{
	_Sp (_Tp::*__p_)();
	public:
	_LIBCPP_INLINE_VISIBILITY explicit mem_fun_ref_t(_Sp (_Tp::*__p)())
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p) const
	{return (__p.*__p_)();}
	};

	template<class _Sp, class _Tp, class _Ap>
	class _LIBCPP_TEMPLATE_VIS mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp>
	{
	_Sp (_Tp::*__p_)(_Ap);
	public:
	_LIBCPP_INLINE_VISIBILITY explicit mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap))
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p, _Ap __x) const
	{return (__p.*__p_)(__x);}
	};

	template<class _Sp, class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	mem_fun_ref_t<_Sp,_Tp>
	mem_fun_ref(_Sp (_Tp::*__f)())
	{return mem_fun_ref_t<_Sp,_Tp>(__f);}

	template<class _Sp, class _Tp, class _Ap>
	inline _LIBCPP_INLINE_VISIBILITY
	mem_fun1_ref_t<_Sp,_Tp,_Ap>
	mem_fun_ref(_Sp (_Tp::*__f)(_Ap))
	{return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}

	template <class _Sp, class _Tp>
	class _LIBCPP_TEMPLATE_VIS const_mem_fun_t : public unary_function<const _Tp*, _Sp>
	{
	_Sp (_Tp::*__p_)() const;
	public:
	_LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_t(_Sp (_Tp::*__p)() const)
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p) const
	{return (__p->*__p_)();}
	};

	template <class _Sp, class _Tp, class _Ap>
	class _LIBCPP_TEMPLATE_VIS const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp>
	{
	_Sp (_Tp::*__p_)(_Ap) const;
	public:
	_LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_t(_Sp (_Tp::*__p)(_Ap) const)
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p, _Ap __x) const
	{return (__p->*__p_)(__x);}
	};

	template <class _Sp, class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	const_mem_fun_t<_Sp,_Tp>
	mem_fun(_Sp (_Tp::*__f)() const)
	{return const_mem_fun_t<_Sp,_Tp>(__f);}

	template <class _Sp, class _Tp, class _Ap>
	inline _LIBCPP_INLINE_VISIBILITY
	const_mem_fun1_t<_Sp,_Tp,_Ap>
	mem_fun(_Sp (_Tp::*__f)(_Ap) const)
	{return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);}

	template <class _Sp, class _Tp>
	class _LIBCPP_TEMPLATE_VIS const_mem_fun_ref_t : public unary_function<_Tp, _Sp>
	{
	_Sp (_Tp::*__p_)() const;
	public:
	_LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_ref_t(_Sp (_Tp::*__p)() const)
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p) const
	{return (__p.*__p_)();}
	};

	template <class _Sp, class _Tp, class _Ap>
	class _LIBCPP_TEMPLATE_VIS const_mem_fun1_ref_t
	: public binary_function<_Tp, _Ap, _Sp>
	{
	_Sp (_Tp::*__p_)(_Ap) const;
	public:
	_LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap) const)
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p, _Ap __x) const
	{return (__p.*__p_)(__x);}
	};

	template <class _Sp, class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	const_mem_fun_ref_t<_Sp,_Tp>
	mem_fun_ref(_Sp (_Tp::*__f)() const)
	{return const_mem_fun_ref_t<_Sp,_Tp>(__f);}

	template <class _Sp, class _Tp, class _Ap>
	inline _LIBCPP_INLINE_VISIBILITY
	const_mem_fun1_ref_t<_Sp,_Tp,_Ap>
	mem_fun_ref(_Sp (_Tp::*__f)(_Ap) const)
	{return const_mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
	#endif

	////////////////////////////////////////////////////////////////////////////////
	// MEMFUN
	//==============================================================================

	template <class _Tp>
	class __mem_fn
	: public __weak_result_type<_Tp>
	{
	public:
	// types
	typedef _Tp type;
	private:
	type __f_;

	public:
	_LIBCPP_INLINE_VISIBILITY __mem_fn(type __f) _NOEXCEPT : __f_(__f) {}

	#ifndef _LIBCPP_CXX03_LANG
	// invoke
	template <class... _ArgTypes>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return<type, _ArgTypes...>::type
	operator() (_ArgTypes&&... __args) const {
	return __invoke(__f_, _VSTD::forward<_ArgTypes>(__args)...);
	}
	#else

	template <class _A0>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return0<type, _A0>::type
	operator() (_A0& __a0) const {
	return __invoke(__f_, __a0);
	}

	template <class _A0>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return0<type, _A0 const>::type
	operator() (_A0 const& __a0) const {
	return __invoke(__f_, __a0);
	}

	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return1<type, _A0, _A1>::type
	operator() (_A0& __a0, _A1& __a1) const {
	return __invoke(__f_, __a0, __a1);
	}

	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return1<type, _A0 const, _A1>::type
	operator() (_A0 const& __a0, _A1& __a1) const {
	return __invoke(__f_, __a0, __a1);
	}

	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return1<type, _A0, _A1 const>::type
	operator() (_A0& __a0, _A1 const& __a1) const {
	return __invoke(__f_, __a0, __a1);
	}

	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return1<type, _A0 const, _A1 const>::type
	operator() (_A0 const& __a0, _A1 const& __a1) const {
	return __invoke(__f_, __a0, __a1);
	}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return2<type, _A0, _A1, _A2>::type
	operator() (_A0& __a0, _A1& __a1, _A2& __a2) const {
	return __invoke(__f_, __a0, __a1, __a2);
	}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return2<type, _A0 const, _A1, _A2>::type
	operator() (_A0 const& __a0, _A1& __a1, _A2& __a2) const {
	return __invoke(__f_, __a0, __a1, __a2);
	}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return2<type, _A0, _A1 const, _A2>::type
	operator() (_A0& __a0, _A1 const& __a1, _A2& __a2) const {
	return __invoke(__f_, __a0, __a1, __a2);
	}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return2<type, _A0, _A1, _A2 const>::type
	operator() (_A0& __a0, _A1& __a1, _A2 const& __a2) const {
	return __invoke(__f_, __a0, __a1, __a2);
	}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return2<type, _A0 const, _A1 const, _A2>::type
	operator() (_A0 const& __a0, _A1 const& __a1, _A2& __a2) const {
	return __invoke(__f_, __a0, __a1, __a2);
	}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return2<type, _A0 const, _A1, _A2 const>::type
	operator() (_A0 const& __a0, _A1& __a1, _A2 const& __a2) const {
	return __invoke(__f_, __a0, __a1, __a2);
	}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return2<type, _A0, _A1 const, _A2 const>::type
	operator() (_A0& __a0, _A1 const& __a1, _A2 const& __a2) const {
	return __invoke(__f_, __a0, __a1, __a2);
	}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	typename __invoke_return2<type, _A0 const, _A1 const, _A2 const>::type
	operator() (_A0 const& __a0, _A1 const& __a1, _A2 const& __a2) const {
	return __invoke(__f_, __a0, __a1, __a2);
	}
	#endif
	};

	template<class _Rp, class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	__mem_fn<_Rp _Tp::*>
	mem_fn(_Rp _Tp::* __pm) _NOEXCEPT
	{
	return __mem_fn<_Rp _Tp::*>(__pm);
	}

	////////////////////////////////////////////////////////////////////////////////
	// FUNCTION
	//==============================================================================

	// bad_function_call

	class _LIBCPP_EXCEPTION_ABI bad_function_call
	: public exception
	{
	#ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
	public:
	virtual ~bad_function_call() _NOEXCEPT;

	virtual const char* what() const _NOEXCEPT;
	#endif
	};

	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
	void __throw_bad_function_call()
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw bad_function_call();
	#else
	_VSTD::abort();
	#endif
	}

	template<class _Fp> class _LIBCPP_TEMPLATE_VIS function; // undefined

	namespace __function
	{

	template<class _Rp>
	struct __maybe_derive_from_unary_function
	{
	};

	template<class _Rp, class _A1>
	struct __maybe_derive_from_unary_function<_Rp(_A1)>
	: public unary_function<_A1, _Rp>
	{
	};

	template<class _Rp>
	struct __maybe_derive_from_binary_function
	{
	};

	template<class _Rp, class _A1, class _A2>
	struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)>
	: public binary_function<_A1, _A2, _Rp>
	{
	};

	template <class _Fp>
	_LIBCPP_INLINE_VISIBILITY
	bool __not_null(_Fp const&) { return true; }

	template <class _Fp>
	_LIBCPP_INLINE_VISIBILITY
	bool __not_null(_Fp* __ptr) { return __ptr; }

	template <class _Ret, class _Class>
	_LIBCPP_INLINE_VISIBILITY
	bool __not_null(_Ret _Class::*__ptr) { return __ptr; }

	template <class _Fp>
	_LIBCPP_INLINE_VISIBILITY
	bool __not_null(function<_Fp> const& __f) { return !!__f; }

	} // namespace __function

	#ifndef _LIBCPP_CXX03_LANG

	namespace __function {

	template<class _Fp> class __base;

	template<class _Rp, class ..._ArgTypes>
	class __base<_Rp(_ArgTypes...)>
	{
	__base(const __base&);
	__base& operator=(const __base&);
	public:
	_LIBCPP_INLINE_VISIBILITY __base() {}
	_LIBCPP_INLINE_VISIBILITY virtual ~__base() {}
	virtual __base* __clone() const = 0;
	virtual void __clone(__base*) const = 0;
	virtual void destroy() _NOEXCEPT = 0;
	virtual void destroy_deallocate() _NOEXCEPT = 0;
	virtual _Rp operator()(_ArgTypes&& ...) = 0;
	#ifndef _LIBCPP_NO_RTTI
	virtual const void* target(const type_info&) const _NOEXCEPT = 0;
	virtual const std::type_info& target_type() const _NOEXCEPT = 0;
	#endif // _LIBCPP_NO_RTTI
	};

	template<class _FD, class _Alloc, class _FB> class __func;

	template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
	class __func<_Fp, _Alloc, _Rp(_ArgTypes...)>
	: public __base<_Rp(_ArgTypes...)>
	{
	__compressed_pair<_Fp, _Alloc> __f_;
	public:
	_LIBCPP_INLINE_VISIBILITY
	explicit __func(_Fp&& __f)
	: __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),
	_VSTD::forward_as_tuple()) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit __func(const _Fp& __f, const _Alloc& __a)
	: __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),
	_VSTD::forward_as_tuple(__a)) {}

	_LIBCPP_INLINE_VISIBILITY
	explicit __func(const _Fp& __f, _Alloc&& __a)
	: __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),
	_VSTD::forward_as_tuple(_VSTD::move(__a))) {}

	_LIBCPP_INLINE_VISIBILITY
	explicit __func(_Fp&& __f, _Alloc&& __a)
	: __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),
	_VSTD::forward_as_tuple(_VSTD::move(__a))) {}
	virtual __base<_Rp(_ArgTypes...)>* __clone() const;
	virtual void __clone(__base<_Rp(_ArgTypes...)>*) const;
	virtual void destroy() _NOEXCEPT;
	virtual void destroy_deallocate() _NOEXCEPT;
	virtual _Rp operator()(_ArgTypes&& ... __arg);
	#ifndef _LIBCPP_NO_RTTI
	virtual const void* target(const type_info&) const _NOEXCEPT;
	virtual const std::type_info& target_type() const _NOEXCEPT;
	#endif // _LIBCPP_NO_RTTI
	};

	template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
	__base<_Rp(_ArgTypes...)>*
	__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const
	{
	typedef allocator_traits<_Alloc> __alloc_traits;
	typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
	_Ap __a(__f_.second());
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (__hold.get()) __func(__f_.first(), _Alloc(__a));
	return __hold.release();
	}

	template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
	void
	__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const
	{
	::new (__p) __func(__f_.first(), __f_.second());
	}

	template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
	void
	__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT
	{
	__f_.~__compressed_pair<_Fp, _Alloc>();
	}

	template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
	void
	__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT
	{
	typedef allocator_traits<_Alloc> __alloc_traits;
	typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
	_Ap __a(__f_.second());
	__f_.~__compressed_pair<_Fp, _Alloc>();
	__a.deallocate(this, 1);
	}

	template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
	_Rp
	__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
	{
	typedef __invoke_void_return_wrapper<_Rp> _Invoker;
	return _Invoker::__call(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
	}

	#ifndef _LIBCPP_NO_RTTI

	template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
	const void*
	__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT
	{
	if (__ti == typeid(_Fp))
	return &__f_.first();
	return (const void*)0;
	}

	template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
	const std::type_info&
	__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
	{
	return typeid(_Fp);
	}

	#endif // _LIBCPP_NO_RTTI

	} // __function

	template<class _Rp, class ..._ArgTypes>
	class _LIBCPP_TEMPLATE_VIS function<_Rp(_ArgTypes...)>
	: public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>,
	public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)>
	{
	typedef __function::__base<_Rp(_ArgTypes...)> __base;
	typename aligned_storage<3sizeof(void)>::type __buf_;
	__base* __f_;

	_LIBCPP_NO_CFI static __base __as_base(void p) {
	return reinterpret_cast<__base*>(p);
	}

	template <class _Fp, bool = __lazy_and<
	integral_constant<bool, !is_same<__uncvref_t<_Fp>, function>::value>,
	__invokable<_Fp&, _ArgTypes...>
	>::value>
	struct __callable;
	template <class _Fp>
	struct __callable<_Fp, true>
	{
	static const bool value = is_same<void, _Rp>::value \|\|
	is_convertible<typename __invoke_of<_Fp&, _ArgTypes...>::type,
	_Rp>::value;
	};
	template <class _Fp>
	struct __callable<_Fp, false>
	{
	static const bool value = false;
	};

	template <class _Fp>
	using _EnableIfCallable = typename enable_if<__callable<_Fp>::value>::type;
	public:
	typedef _Rp result_type;

	// construct/copy/destroy:
	_LIBCPP_INLINE_VISIBILITY
	function() _NOEXCEPT : __f_(0) {}
	_LIBCPP_INLINE_VISIBILITY
	function(nullptr_t) _NOEXCEPT : __f_(0) {}
	function(const function&);
	function(function&&) _NOEXCEPT;
	template<class _Fp, class = _EnableIfCallable<_Fp>>
	function(_Fp);

	#if _LIBCPP_STD_VER <= 14
	template<class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	function(allocator_arg_t, const _Alloc&) _NOEXCEPT : __f_(0) {}
	template<class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT : __f_(0) {}
	template<class _Alloc>
	function(allocator_arg_t, const _Alloc&, const function&);
	template<class _Alloc>
	function(allocator_arg_t, const _Alloc&, function&&);
	template<class _Fp, class _Alloc, class = _EnableIfCallable<_Fp>>
	function(allocator_arg_t, const _Alloc& __a, _Fp __f);
	#endif

	function& operator=(const function&);
	function& operator=(function&&) _NOEXCEPT;
	function& operator=(nullptr_t) _NOEXCEPT;
	template<class _Fp, class = _EnableIfCallable<_Fp>>
	function& operator=(_Fp&&);

	~function();

	// function modifiers:
	void swap(function&) _NOEXCEPT;

	#if _LIBCPP_STD_VER <= 14
	template<class _Fp, class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	void assign(_Fp&& __f, const _Alloc& __a)
	{function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);}
	#endif

	// function capacity:
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return __f_;}

	// deleted overloads close possible hole in the type system
	template<class _R2, class... _ArgTypes2>
	bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete;
	template<class _R2, class... _ArgTypes2>
	bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete;
	public:
	// function invocation:
	_Rp operator()(_ArgTypes...) const;

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

	template<class _Rp, class ..._ArgTypes>
	function<_Rp(_ArgTypes...)>::function(const function& __f)
	{
	if (__f.__f_ == 0)
	__f_ = 0;
	else if ((void *)__f.__f_ == &__f.__buf_)
	{
	__f_ = __as_base(&__buf_);
	__f.__f_->__clone(__f_);
	}
	else
	__f_ = __f.__f_->__clone();
	}

	#if _LIBCPP_STD_VER <= 14
	template<class _Rp, class ..._ArgTypes>
	template <class _Alloc>
	function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
	const function& __f)
	{
	if (__f.__f_ == 0)
	__f_ = 0;
	else if ((void *)__f.__f_ == &__f.__buf_)
	{
	__f_ = __as_base(&__buf_);
	__f.__f_->__clone(__f_);
	}
	else
	__f_ = __f.__f_->__clone();
	}
	#endif

	template<class _Rp, class ..._ArgTypes>
	function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT
	{
	if (__f.__f_ == 0)
	__f_ = 0;
	else if ((void *)__f.__f_ == &__f.__buf_)
	{
	__f_ = __as_base(&__buf_);
	__f.__f_->__clone(__f_);
	}
	else
	{
	__f_ = __f.__f_;
	__f.__f_ = 0;
	}
	}

	#if _LIBCPP_STD_VER <= 14
	template<class _Rp, class ..._ArgTypes>
	template <class _Alloc>
	function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
	function&& __f)
	{
	if (__f.__f_ == 0)
	__f_ = 0;
	else if ((void *)__f.__f_ == &__f.__buf_)
	{
	__f_ = __as_base(&__buf_);
	__f.__f_->__clone(__f_);
	}
	else
	{
	__f_ = __f.__f_;
	__f.__f_ = 0;
	}
	}
	#endif

	template<class _Rp, class ..._ArgTypes>
	template <class _Fp, class>
	function<_Rp(_ArgTypes...)>::function(_Fp __f)
	: __f_(0)
	{
	if (__function::__not_null(__f))
	{
	typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_ArgTypes...)> _FF;
	if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value)
	{
	__f_ = ::new((void*)&__buf_) _FF(_VSTD::move(__f));
	}
	else
	{
	typedef allocator<_FF> _Ap;
	_Ap __a;
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (__hold.get()) _FF(_VSTD::move(__f), allocator<_Fp>(__a));
	__f_ = __hold.release();
	}
	}
	}

	#if _LIBCPP_STD_VER <= 14
	template<class _Rp, class ..._ArgTypes>
	template <class _Fp, class _Alloc, class>
	function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f)
	: __f_(0)
	{
	typedef allocator_traits<_Alloc> __alloc_traits;
	if (__function::__not_null(__f))
	{
	typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _FF;
	typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap;
	_Ap __a(__a0);
	if (sizeof(_FF) <= sizeof(__buf_) &&
	is_nothrow_copy_constructible<_Fp>::value && is_nothrow_copy_constructible<_Ap>::value)
	{
	__f_ = ::new((void*)&__buf_) _FF(_VSTD::move(__f), _Alloc(__a));
	}
	else
	{
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (__hold.get()) _FF(_VSTD::move(__f), _Alloc(__a));
	__f_ = __hold.release();
	}
	}
	}
	#endif

	template<class _Rp, class ..._ArgTypes>
	function<_Rp(_ArgTypes...)>&
	function<_Rp(_ArgTypes...)>::operator=(const function& __f)
	{
	function(__f).swap(*this);
	return *this;
	}

	template<class _Rp, class ..._ArgTypes>
	function<_Rp(_ArgTypes...)>&
	function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT
	{
	- if ((void *)__f_ == &__buf_)
	- __f_->destroy();
	- else if (__f_)
	- __f_->destroy_deallocate();
	- __f_ = 0;
	+ *this = nullptr;
	if (__f.__f_ == 0)
	__f_ = 0;
	else if ((void *)__f.__f_ == &__f.__buf_)
	{
	__f_ = __as_base(&__buf_);
	__f.__f_->__clone(__f_);
	}
	else
	{
	__f_ = __f.__f_;
	__f.__f_ = 0;
	}
	return *this;
	}

	template<class _Rp, class ..._ArgTypes>
	function<_Rp(_ArgTypes...)>&
	function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT
	{
	- if ((void *)__f_ == &__buf_)
	- __f_->destroy();
	- else if (__f_)
	- __f_->destroy_deallocate();
	+ __base* __t = __f_;
	__f_ = 0;
	+ if ((void *)__t == &__buf_)
	+ __t->destroy();
	+ else if (__t)
	+ __t->destroy_deallocate();
	return *this;
	}

	template<class _Rp, class ..._ArgTypes>
	template <class _Fp, class>
	function<_Rp(_ArgTypes...)>&
	function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f)
	{
	function(_VSTD::forward<_Fp>(__f)).swap(*this);
	return *this;
	}

	template<class _Rp, class ..._ArgTypes>
	function<_Rp(_ArgTypes...)>::~function()
	{
	if ((void *)__f_ == &__buf_)
	__f_->destroy();
	else if (__f_)
	__f_->destroy_deallocate();
	}

	template<class _Rp, class ..._ArgTypes>
	void
	function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
	{
	if (_VSTD::addressof(__f) == this)
	return;
	if ((void )__f_ == &__buf_ && (void )__f.__f_ == &__f.__buf_)
	{
	typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
	__base* __t = __as_base(&__tempbuf);
	__f_->__clone(__t);
	__f_->destroy();
	__f_ = 0;
	__f.__f_->__clone(__as_base(&__buf_));
	__f.__f_->destroy();
	__f.__f_ = 0;
	__f_ = __as_base(&__buf_);
	__t->__clone(__as_base(&__f.__buf_));
	__t->destroy();
	__f.__f_ = __as_base(&__f.__buf_);
	}
	else if ((void *)__f_ == &__buf_)
	{
	__f_->__clone(__as_base(&__f.__buf_));
	__f_->destroy();
	__f_ = __f.__f_;
	__f.__f_ = __as_base(&__f.__buf_);
	}
	else if ((void *)__f.__f_ == &__f.__buf_)
	{
	__f.__f_->__clone(__as_base(&__buf_));
	__f.__f_->destroy();
	__f.__f_ = __f_;
	__f_ = __as_base(&__buf_);
	}
	else
	_VSTD::swap(__f_, __f.__f_);
	}

	template<class _Rp, class ..._ArgTypes>
	_Rp
	function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
	{
	if (__f_ == 0)
	__throw_bad_function_call();
	return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
	}

	#ifndef _LIBCPP_NO_RTTI

	template<class _Rp, class ..._ArgTypes>
	const std::type_info&
	function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
	{
	if (__f_ == 0)
	return typeid(void);
	return __f_->target_type();
	}

	template<class _Rp, class ..._ArgTypes>
	template <typename _Tp>
	_Tp*
	function<_Rp(_ArgTypes...)>::target() _NOEXCEPT
	{
	if (__f_ == 0)
	return nullptr;
	return (_Tp) const_cast<void >(__f_->target(typeid(_Tp)));
	}

	template<class _Rp, class ..._ArgTypes>
	template <typename _Tp>
	const _Tp*
	function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT
	{
	if (__f_ == 0)
	return nullptr;
	return (const _Tp*)__f_->target(typeid(_Tp));
	}

	#endif // _LIBCPP_NO_RTTI

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

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

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

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

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

	#else // _LIBCPP_CXX03_LANG

	#include <__functional_03>

	#endif

	////////////////////////////////////////////////////////////////////////////////
	// BIND
	//==============================================================================

	template<class _Tp> struct __is_bind_expression : public false_type {};
	template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_bind_expression
	: public __is_bind_expression<typename remove_cv<_Tp>::type> {};

	#if _LIBCPP_STD_VER > 14
	template <class _Tp>
	_LIBCPP_INLINE_VAR constexpr size_t is_bind_expression_v = is_bind_expression<_Tp>::value;
	#endif

	template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {};
	template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_placeholder
	: public __is_placeholder<typename remove_cv<_Tp>::type> {};

	#if _LIBCPP_STD_VER > 14
	template <class _Tp>
	_LIBCPP_INLINE_VAR constexpr size_t is_placeholder_v = is_placeholder<_Tp>::value;
	#endif

	namespace placeholders
	{

	template <int _Np> struct __ph {};

	#if defined(_LIBCPP_CXX03_LANG) \|\| defined(_LIBCPP_BUILDING_BIND)
	_LIBCPP_FUNC_VIS extern const __ph<1> _1;
	_LIBCPP_FUNC_VIS extern const __ph<2> _2;
	_LIBCPP_FUNC_VIS extern const __ph<3> _3;
	_LIBCPP_FUNC_VIS extern const __ph<4> _4;
	_LIBCPP_FUNC_VIS extern const __ph<5> _5;
	_LIBCPP_FUNC_VIS extern const __ph<6> _6;
	_LIBCPP_FUNC_VIS extern const __ph<7> _7;
	_LIBCPP_FUNC_VIS extern const __ph<8> _8;
	_LIBCPP_FUNC_VIS extern const __ph<9> _9;
	_LIBCPP_FUNC_VIS extern const __ph<10> _10;
	#else
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<1> _1{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<2> _2{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<3> _3{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<4> _4{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<5> _5{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<6> _6{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<7> _7{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<8> _8{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<9> _9{};
	/* _LIBCPP_INLINE_VAR */ constexpr __ph<10> _10{};
	#endif // defined(_LIBCPP_CXX03_LANG) \|\| defined(_LIBCPP_BUILDING_BIND)

	} // placeholders

	template<int _Np>
	struct __is_placeholder<placeholders::__ph<_Np> >
	: public integral_constant<int, _Np> {};


	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Uj>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp&
	__mu(reference_wrapper<_Tp> __t, _Uj&)
	{
	return __t.get();
	}

	template <class _Ti, class ..._Uj, size_t ..._Indx>
	inline _LIBCPP_INLINE_VISIBILITY
	typename __invoke_of<_Ti&, _Uj...>::type
	__mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
	{
	return __ti(_VSTD::forward<_Uj>(_VSTD::get<_Indx>(__uj))...);
	}

	template <class _Ti, class ..._Uj>
	inline _LIBCPP_INLINE_VISIBILITY
	typename __lazy_enable_if
	<
	is_bind_expression<_Ti>::value,
	__invoke_of<_Ti&, _Uj...>
	>::type
	__mu(_Ti& __ti, tuple<_Uj...>& __uj)
	{
	typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices;
	return __mu_expand(__ti, __uj, __indices());
	}

	template <bool IsPh, class _Ti, class _Uj>
	struct __mu_return2 {};

	template <class _Ti, class _Uj>
	struct __mu_return2<true, _Ti, _Uj>
	{
	typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type;
	};

	template <class _Ti, class _Uj>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	0 < is_placeholder<_Ti>::value,
	typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type
	>::type
	__mu(_Ti&, _Uj& __uj)
	{
	const size_t _Indx = is_placeholder<_Ti>::value - 1;
	return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(_VSTD::get<_Indx>(__uj));
	}

	template <class _Ti, class _Uj>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	!is_bind_expression<_Ti>::value &&
	is_placeholder<_Ti>::value == 0 &&
	!__is_reference_wrapper<_Ti>::value,
	_Ti&
	>::type
	__mu(_Ti& __ti, _Uj&)
	{
	return __ti;
	}

	template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh,
	class _TupleUj>
	struct ____mu_return;

	template <bool _Invokable, class _Ti, class ..._Uj>
	struct ____mu_return_invokable // false
	{
	typedef __nat type;
	};

	template <class _Ti, class ..._Uj>
	struct ____mu_return_invokable<true, _Ti, _Uj...>
	{
	typedef typename __invoke_of<_Ti&, _Uj...>::type type;
	};

	template <class _Ti, class ..._Uj>
	struct ____mu_return<_Ti, false, true, false, tuple<_Uj...> >
	: public ____mu_return_invokable<__invokable<_Ti&, _Uj...>::value, _Ti, _Uj...>
	{
	};

	template <class _Ti, class _TupleUj>
	struct ____mu_return<_Ti, false, false, true, _TupleUj>
	{
	typedef typename tuple_element<is_placeholder<_Ti>::value - 1,
	_TupleUj>::type&& type;
	};

	template <class _Ti, class _TupleUj>
	struct ____mu_return<_Ti, true, false, false, _TupleUj>
	{
	typedef typename _Ti::type& type;
	};

	template <class _Ti, class _TupleUj>
	struct ____mu_return<_Ti, false, false, false, _TupleUj>
	{
	typedef _Ti& type;
	};

	template <class _Ti, class _TupleUj>
	struct __mu_return
	: public ____mu_return<_Ti,
	__is_reference_wrapper<_Ti>::value,
	is_bind_expression<_Ti>::value,
	0 < is_placeholder<_Ti>::value &&
	is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value,
	_TupleUj>
	{
	};

	template <class _Fp, class _BoundArgs, class _TupleUj>
	struct __is_valid_bind_return
	{
	static const bool value = false;
	};

	template <class _Fp, class ..._BoundArgs, class _TupleUj>
	struct __is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj>
	{
	static const bool value = __invokable<_Fp,
	typename __mu_return<_BoundArgs, _TupleUj>::type...>::value;
	};

	template <class _Fp, class ..._BoundArgs, class _TupleUj>
	struct __is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj>
	{
	static const bool value = __invokable<_Fp,
	typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value;
	};

	template <class _Fp, class _BoundArgs, class _TupleUj,
	bool = __is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value>
	struct __bind_return;

	template <class _Fp, class ..._BoundArgs, class _TupleUj>
	struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true>
	{
	typedef typename __invoke_of
	<
	_Fp&,
	typename __mu_return
	<
	_BoundArgs,
	_TupleUj
	>::type...
	>::type type;
	};

	template <class _Fp, class ..._BoundArgs, class _TupleUj>
	struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true>
	{
	typedef typename __invoke_of
	<
	_Fp&,
	typename __mu_return
	<
	const _BoundArgs,
	_TupleUj
	>::type...
	>::type type;
	};

	template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args>
	inline _LIBCPP_INLINE_VISIBILITY
	typename __bind_return<_Fp, _BoundArgs, _Args>::type
	__apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>,
	_Args&& __args)
	{
	return _VSTD::__invoke(__f, _VSTD::__mu(_VSTD::get<_Indx>(__bound_args), __args)...);
	}

	template<class _Fp, class ..._BoundArgs>
	class __bind
	: public __weak_result_type<typename decay<_Fp>::type>
	{
	protected:
	typedef typename decay<_Fp>::type _Fd;
	typedef tuple<typename decay<_BoundArgs>::type...> _Td;
	private:
	_Fd __f_;
	_Td __bound_args_;

	typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;
	public:
	template <class _Gp, class ..._BA,
	class = typename enable_if
	<
	is_constructible<_Fd, _Gp>::value &&
	!is_same<typename remove_reference<_Gp>::type,
	__bind>::value
	>::type>
	_LIBCPP_INLINE_VISIBILITY
	explicit __bind(_Gp&& __f, _BA&& ...__bound_args)
	: __f_(_VSTD::forward<_Gp>(__f)),
	__bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY
	typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
	operator()(_Args&& ...__args)
	{
	return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),
	tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
	}

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY
	typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type
	operator()(_Args&& ...__args) const
	{
	return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),
	tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
	}
	};

	template<class _Fp, class ..._BoundArgs>
	struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {};

	template<class _Rp, class _Fp, class ..._BoundArgs>
	class __bind_r
	: public __bind<_Fp, _BoundArgs...>
	{
	typedef __bind<_Fp, _BoundArgs...> base;
	typedef typename base::_Fd _Fd;
	typedef typename base::_Td _Td;
	public:
	typedef _Rp result_type;


	template <class _Gp, class ..._BA,
	class = typename enable_if
	<
	is_constructible<_Fd, _Gp>::value &&
	!is_same<typename remove_reference<_Gp>::type,
	__bind_r>::value
	>::type>
	_LIBCPP_INLINE_VISIBILITY
	explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
	: base(_VSTD::forward<_Gp>(__f),
	_VSTD::forward<_BA>(__bound_args)...) {}

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type,
	result_type>::value \|\| is_void<_Rp>::value,
	result_type
	>::type
	operator()(_Args&& ...__args)
	{
	typedef __invoke_void_return_wrapper<_Rp> _Invoker;
	return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...);
	}

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type,
	result_type>::value \|\| is_void<_Rp>::value,
	result_type
	>::type
	operator()(_Args&& ...__args) const
	{
	typedef __invoke_void_return_wrapper<_Rp> _Invoker;
	return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...);
	}
	};

	template<class _Rp, class _Fp, class ..._BoundArgs>
	struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};

	template<class _Fp, class ..._BoundArgs>
	inline _LIBCPP_INLINE_VISIBILITY
	__bind<_Fp, _BoundArgs...>
	bind(_Fp&& __f, _BoundArgs&&... __bound_args)
	{
	typedef __bind<_Fp, _BoundArgs...> type;
	return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
	}

	template<class _Rp, class _Fp, class ..._BoundArgs>
	inline _LIBCPP_INLINE_VISIBILITY
	__bind_r<_Rp, _Fp, _BoundArgs...>
	bind(_Fp&& __f, _BoundArgs&&... __bound_args)
	{
	typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;
	return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
	}

	#endif // _LIBCPP_CXX03_LANG

	#if _LIBCPP_STD_VER > 14

	#define __cpp_lib_invoke 201411

	template <class _Fn, class ..._Args>
	result_of_t<_Fn&&(_Args&&...)>
	invoke(_Fn&& __f, _Args&&... __args)
	noexcept(noexcept(_VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...)))
	{
	return _VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...);
	}

	template <class _DecayFunc>
	class _LIBCPP_TEMPLATE_VIS __not_fn_imp {
	_DecayFunc __fd;

	public:
	__not_fn_imp() = delete;

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY
	auto operator()(_Args&& ...__args) &
	noexcept(noexcept(!_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...)))
	-> decltype( !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...))
	{ return !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...); }

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY
	auto operator()(_Args&& ...__args) &&
	noexcept(noexcept(!_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...)))
	-> decltype( !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...))
	{ return !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...); }

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY
	auto operator()(_Args&& ...__args) const&
	noexcept(noexcept(!_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...)))
	-> decltype( !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...))
	{ return !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...); }


	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY
	auto operator()(_Args&& ...__args) const&&
	noexcept(noexcept(!_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...)))
	-> decltype( !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...))
	{ return !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...); }

	private:
	template <class _RawFunc,
	class = enable_if_t<!is_same<decay_t<_RawFunc>, __not_fn_imp>::value>>
	_LIBCPP_INLINE_VISIBILITY
	explicit __not_fn_imp(_RawFunc&& __rf)
	: __fd(_VSTD::forward<_RawFunc>(__rf)) {}

	template <class _RawFunc>
	friend inline _LIBCPP_INLINE_VISIBILITY
	__not_fn_imp<decay_t<_RawFunc>> not_fn(_RawFunc&&);
	};

	template <class _RawFunc>
	inline _LIBCPP_INLINE_VISIBILITY
	__not_fn_imp<decay_t<_RawFunc>> not_fn(_RawFunc&& __fn) {
	return __not_fn_imp<decay_t<_RawFunc>>(_VSTD::forward<_RawFunc>(__fn));
	}

	#endif

	// struct hash<T*> in <memory>
	+
	+template <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
	+pair<_ForwardIterator1, _ForwardIterator1> _LIBCPP_CONSTEXPR_AFTER_CXX11
	+__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
	+ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred,
	+ forward_iterator_tag, forward_iterator_tag)
	+{
	+ if (__first2 == __last2)
	+ return make_pair(__first1, __first1); // Everything matches an empty sequence
	+ while (true)
	+ {
	+ // Find first element in sequence 1 that matchs *__first2, with a mininum of loop checks
	+ while (true)
	+ {
	+ if (__first1 == __last1) // return __last1 if no element matches *__first2
	+ return make_pair(__last1, __last1);
	+ if (__pred(__first1, __first2))
	+ break;
	+ ++__first1;
	+ }
	+ // __first1 matches __first2, now match elements after here
	+ _ForwardIterator1 __m1 = __first1;
	+ _ForwardIterator2 __m2 = __first2;
	+ while (true)
	+ {
	+ if (++__m2 == __last2) // If pattern exhausted, __first1 is the answer (works for 1 element pattern)
	+ return make_pair(__first1, __m1);
	+ if (++__m1 == __last1) // Otherwise if source exhaused, pattern not found
	+ return make_pair(__last1, __last1);
	+ if (!__pred(__m1, __m2)) // if there is a mismatch, restart with a new __first1
	+ {
	+ ++__first1;
	+ break;
	+ } // else there is a match, check next elements
	+ }
	+ }
	+}
	+
	+template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
	+_LIBCPP_CONSTEXPR_AFTER_CXX11
	+pair<_RandomAccessIterator1, _RandomAccessIterator1>
	+__search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
	+ _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
	+ random_access_iterator_tag, random_access_iterator_tag)
	+{
	+ typedef typename iterator_traits<_RandomAccessIterator1>::difference_type _D1;
	+ typedef typename iterator_traits<_RandomAccessIterator2>::difference_type _D2;
	+ // Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern
	+ const _D2 __len2 = __last2 - __first2;
	+ if (__len2 == 0)
	+ return make_pair(__first1, __first1);
	+ const _D1 __len1 = __last1 - __first1;
	+ if (__len1 < __len2)
	+ return make_pair(__last1, __last1);
	+ const _RandomAccessIterator1 __s = __last1 - (__len2 - 1); // Start of pattern match can't go beyond here
	+
	+ while (true)
	+ {
	+ while (true)
	+ {
	+ if (__first1 == __s)
	+ return make_pair(__last1, __last1);
	+ if (__pred(__first1, __first2))
	+ break;
	+ ++__first1;
	+ }
	+
	+ _RandomAccessIterator1 __m1 = __first1;
	+ _RandomAccessIterator2 __m2 = __first2;
	+ while (true)
	+ {
	+ if (++__m2 == __last2)
	+ return make_pair(__first1, __first1 + __len2);
	+ ++__m1; // no need to check range on __m1 because __s guarantees we have enough source
	+ if (!__pred(__m1, __m2))
	+ {
	+ ++__first1;
	+ break;
	+ }
	+ }
	+ }
	+}
	+
	+#if _LIBCPP_STD_VER > 14
	+
	+// default searcher
	+template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
	+class _LIBCPP_TYPE_VIS default_searcher {
	+public:
	+ _LIBCPP_INLINE_VISIBILITY
	+ default_searcher(_ForwardIterator __f, _ForwardIterator __l,
	+ _BinaryPredicate __p = _BinaryPredicate())
	+ : __first_(__f), __last_(__l), __pred_(__p) {}
	+
	+ template <typename _ForwardIterator2>
	+ _LIBCPP_INLINE_VISIBILITY
	+ pair<_ForwardIterator2, _ForwardIterator2>
	+ operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const
	+ {
	+ return _VSTD::__search(__f, __l, __first_, __last_, __pred_,
	+ typename _VSTD::iterator_traits<_ForwardIterator>::iterator_category(),
	+ typename _VSTD::iterator_traits<_ForwardIterator2>::iterator_category());
	+ }
	+
	+private:
	+ _ForwardIterator __first_;
	+ _ForwardIterator __last_;
	+ _BinaryPredicate __pred_;
	+ };
	+
	+#endif // _LIBCPP_STD_VER > 14

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_FUNCTIONAL
	Index: projects/clang700-import/contrib/libc++/include/future
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/future (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/future (revision 337135)
	@@ -1,2618 +1,2618 @@
	// -- C++ --
	//===--------------------------- future -----------------------------------===//
	//
	// 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_FUTURE
	#define _LIBCPP_FUTURE

	/*
	future synopsis

	namespace std
	{

	enum class future_errc
	{
	future_already_retrieved = 1,
	promise_already_satisfied,
	no_state,
	broken_promise
	};

	enum class launch
	{
	async = 1,
	deferred = 2,
	any = async \| deferred
	};

	enum class future_status
	{
	ready,
	timeout,
	deferred
	};

	template <> struct is_error_code_enum<future_errc> : public true_type { };
	error_code make_error_code(future_errc e) noexcept;
	error_condition make_error_condition(future_errc e) noexcept;

	const error_category& future_category() noexcept;

	class future_error
	: public logic_error
	{
	public:
	future_error(error_code ec); // exposition only
	explicit future_error(future_errc); // C++17
	const error_code& code() const noexcept;
	const char* what() const noexcept;
	};

	template <class R>
	class promise
	{
	public:
	promise();
	template <class Allocator>
	promise(allocator_arg_t, const Allocator& a);
	promise(promise&& rhs) noexcept;
	promise(const promise& rhs) = delete;
	~promise();

	// assignment
	promise& operator=(promise&& rhs) noexcept;
	promise& operator=(const promise& rhs) = delete;
	void swap(promise& other) noexcept;

	// retrieving the result
	future<R> get_future();

	// setting the result
	void set_value(const R& r);
	void set_value(R&& r);
	void set_exception(exception_ptr p);

	// setting the result with deferred notification
	void set_value_at_thread_exit(const R& r);
	void set_value_at_thread_exit(R&& r);
	void set_exception_at_thread_exit(exception_ptr p);
	};

	template <class R>
	class promise<R&>
	{
	public:
	promise();
	template <class Allocator>
	promise(allocator_arg_t, const Allocator& a);
	promise(promise&& rhs) noexcept;
	promise(const promise& rhs) = delete;
	~promise();

	// assignment
	promise& operator=(promise&& rhs) noexcept;
	promise& operator=(const promise& rhs) = delete;
	void swap(promise& other) noexcept;

	// retrieving the result
	future<R&> get_future();

	// setting the result
	void set_value(R& r);
	void set_exception(exception_ptr p);

	// setting the result with deferred notification
	void set_value_at_thread_exit(R&);
	void set_exception_at_thread_exit(exception_ptr p);
	};

	template <>
	class promise<void>
	{
	public:
	promise();
	template <class Allocator>
	promise(allocator_arg_t, const Allocator& a);
	promise(promise&& rhs) noexcept;
	promise(const promise& rhs) = delete;
	~promise();

	// assignment
	promise& operator=(promise&& rhs) noexcept;
	promise& operator=(const promise& rhs) = delete;
	void swap(promise& other) noexcept;

	// retrieving the result
	future<void> get_future();

	// setting the result
	void set_value();
	void set_exception(exception_ptr p);

	// setting the result with deferred notification
	void set_value_at_thread_exit();
	void set_exception_at_thread_exit(exception_ptr p);
	};

	template <class R> void swap(promise<R>& x, promise<R>& y) noexcept;

	template <class R, class Alloc>
	struct uses_allocator<promise<R>, Alloc> : public true_type {};

	template <class R>
	class future
	{
	public:
	future() noexcept;
	future(future&&) noexcept;
	future(const future& rhs) = delete;
	~future();
	future& operator=(const future& rhs) = delete;
	future& operator=(future&&) noexcept;
	shared_future<R> share() noexcept;

	// retrieving the value
	R get();

	// functions to check state
	bool valid() const noexcept;

	void wait() const;
	template <class Rep, class Period>
	future_status
	wait_for(const chrono::duration<Rep, Period>& rel_time) const;
	template <class Clock, class Duration>
	future_status
	wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
	};

	template <class R>
	class future<R&>
	{
	public:
	future() noexcept;
	future(future&&) noexcept;
	future(const future& rhs) = delete;
	~future();
	future& operator=(const future& rhs) = delete;
	future& operator=(future&&) noexcept;
	shared_future<R&> share() noexcept;

	// retrieving the value
	R& get();

	// functions to check state
	bool valid() const noexcept;

	void wait() const;
	template <class Rep, class Period>
	future_status
	wait_for(const chrono::duration<Rep, Period>& rel_time) const;
	template <class Clock, class Duration>
	future_status
	wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
	};

	template <>
	class future<void>
	{
	public:
	future() noexcept;
	future(future&&) noexcept;
	future(const future& rhs) = delete;
	~future();
	future& operator=(const future& rhs) = delete;
	future& operator=(future&&) noexcept;
	shared_future<void> share() noexcept;

	// retrieving the value
	void get();

	// functions to check state
	bool valid() const noexcept;

	void wait() const;
	template <class Rep, class Period>
	future_status
	wait_for(const chrono::duration<Rep, Period>& rel_time) const;
	template <class Clock, class Duration>
	future_status
	wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
	};

	template <class R>
	class shared_future
	{
	public:
	shared_future() noexcept;
	shared_future(const shared_future& rhs);
	shared_future(future<R>&&) noexcept;
	shared_future(shared_future&& rhs) noexcept;
	~shared_future();
	shared_future& operator=(const shared_future& rhs);
	shared_future& operator=(shared_future&& rhs) noexcept;

	// retrieving the value
	const R& get() const;

	// functions to check state
	bool valid() const noexcept;

	void wait() const;
	template <class Rep, class Period>
	future_status
	wait_for(const chrono::duration<Rep, Period>& rel_time) const;
	template <class Clock, class Duration>
	future_status
	wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
	};

	template <class R>
	class shared_future<R&>
	{
	public:
	shared_future() noexcept;
	shared_future(const shared_future& rhs);
	shared_future(future<R&>&&) noexcept;
	shared_future(shared_future&& rhs) noexcept;
	~shared_future();
	shared_future& operator=(const shared_future& rhs);
	shared_future& operator=(shared_future&& rhs) noexcept;

	// retrieving the value
	R& get() const;

	// functions to check state
	bool valid() const noexcept;

	void wait() const;
	template <class Rep, class Period>
	future_status
	wait_for(const chrono::duration<Rep, Period>& rel_time) const;
	template <class Clock, class Duration>
	future_status
	wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
	};

	template <>
	class shared_future<void>
	{
	public:
	shared_future() noexcept;
	shared_future(const shared_future& rhs);
	shared_future(future<void>&&) noexcept;
	shared_future(shared_future&& rhs) noexcept;
	~shared_future();
	shared_future& operator=(const shared_future& rhs);
	shared_future& operator=(shared_future&& rhs) noexcept;

	// retrieving the value
	void get() const;

	// functions to check state
	bool valid() const noexcept;

	void wait() const;
	template <class Rep, class Period>
	future_status
	wait_for(const chrono::duration<Rep, Period>& rel_time) const;
	template <class Clock, class Duration>
	future_status
	wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
	};

	template <class F, class... Args>
	future<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type>
	async(F&& f, Args&&... args);

	template <class F, class... Args>
	future<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type>
	async(launch policy, F&& f, Args&&... args);

	template <class> class packaged_task; // undefined

	template <class R, class... ArgTypes>
	class packaged_task<R(ArgTypes...)>
	{
	public:
	typedef R result_type; // extension

	// construction and destruction
	packaged_task() noexcept;
	template <class F>
	explicit packaged_task(F&& f);
	template <class F, class Allocator>
	packaged_task(allocator_arg_t, const Allocator& a, F&& f);
	~packaged_task();

	// no copy
	packaged_task(const packaged_task&) = delete;
	packaged_task& operator=(const packaged_task&) = delete;

	// move support
	packaged_task(packaged_task&& other) noexcept;
	packaged_task& operator=(packaged_task&& other) noexcept;
	void swap(packaged_task& other) noexcept;

	bool valid() const noexcept;

	// result retrieval
	future<R> get_future();

	// execution
	void operator()(ArgTypes... );
	void make_ready_at_thread_exit(ArgTypes...);

	void reset();
	};

	template <class R>
	void swap(packaged_task<R(ArgTypes...)&, packaged_task<R(ArgTypes...)>&) noexcept;

	template <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>;

	} // std

	*/

	#include <__config>
	#include <system_error>
	#include <memory>
	#include <chrono>
	#include <exception>
	#include <mutex>
	#include <thread>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	#ifdef _LIBCPP_HAS_NO_THREADS
	#error <future> is not supported on this single threaded system
	#else // !_LIBCPP_HAS_NO_THREADS

	_LIBCPP_BEGIN_NAMESPACE_STD

	//enum class future_errc
	_LIBCPP_DECLARE_STRONG_ENUM(future_errc)
	{
	future_already_retrieved = 1,
	promise_already_satisfied,
	no_state,
	broken_promise
	};
	_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc)

	template <>
	struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc> : public true_type {};

	#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
	template <>
	struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc::__lx> : public true_type { };
	#endif

	//enum class launch
	_LIBCPP_DECLARE_STRONG_ENUM(launch)
	{
	async = 1,
	deferred = 2,
	any = async \| deferred
	};
	_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(launch)

	#ifndef _LIBCPP_HAS_NO_STRONG_ENUMS

	-#ifdef _LIBCXX_UNDERLYING_TYPE
	+#ifdef _LIBCPP_UNDERLYING_TYPE
	typedef underlying_type<launch>::type __launch_underlying_type;
	#else
	typedef int __launch_underlying_type;
	#endif

	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	launch
	operator&(launch __x, launch __y)
	{
	return static_cast<launch>(static_cast<__launch_underlying_type>(__x) &
	static_cast<__launch_underlying_type>(__y));
	}

	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	launch
	operator\|(launch __x, launch __y)
	{
	return static_cast<launch>(static_cast<__launch_underlying_type>(__x) \|
	static_cast<__launch_underlying_type>(__y));
	}

	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	launch
	operator^(launch __x, launch __y)
	{
	return static_cast<launch>(static_cast<__launch_underlying_type>(__x) ^
	static_cast<__launch_underlying_type>(__y));
	}

	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	launch
	operator~(launch __x)
	{
	return static_cast<launch>(~static_cast<__launch_underlying_type>(__x) & 3);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	launch&
	operator&=(launch& __x, launch __y)
	{
	__x = __x & __y; return __x;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	launch&
	operator\|=(launch& __x, launch __y)
	{
	__x = __x \| __y; return __x;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	launch&
	operator^=(launch& __x, launch __y)
	{
	__x = __x ^ __y; return __x;
	}

	#endif // !_LIBCPP_HAS_NO_STRONG_ENUMS

	//enum class future_status
	_LIBCPP_DECLARE_STRONG_ENUM(future_status)
	{
	ready,
	timeout,
	deferred
	};
	_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_status)

	_LIBCPP_FUNC_VIS
	const error_category& future_category() _NOEXCEPT;

	inline _LIBCPP_INLINE_VISIBILITY
	error_code
	make_error_code(future_errc __e) _NOEXCEPT
	{
	return error_code(static_cast<int>(__e), future_category());
	}

	inline _LIBCPP_INLINE_VISIBILITY
	error_condition
	make_error_condition(future_errc __e) _NOEXCEPT
	{
	return error_condition(static_cast<int>(__e), future_category());
	}

	class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_FUTURE_ERROR future_error
	: public logic_error
	{
	error_code __ec_;
	public:
	future_error(error_code __ec);
	#if _LIBCPP_STD_VERS > 14
	explicit future_error(future_errc _Ev) : logic_error(), __ec_(make_error_code(_Ev)) {}
	#endif
	_LIBCPP_INLINE_VISIBILITY
	const error_code& code() const _NOEXCEPT {return __ec_;}

	virtual ~future_error() _NOEXCEPT;
	};

	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
	#ifndef _LIBCPP_NO_EXCEPTIONS
	_LIBCPP_AVAILABILITY_FUTURE_ERROR
	#endif
	void __throw_future_error(future_errc _Ev)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw future_error(make_error_code(_Ev));
	#else
	((void)_Ev);
	_VSTD::abort();
	#endif
	}

	class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state
	: public __shared_count
	{
	protected:
	exception_ptr __exception_;
	mutable mutex __mut_;
	mutable condition_variable __cv_;
	unsigned __state_;

	virtual void __on_zero_shared() _NOEXCEPT;
	void __sub_wait(unique_lock<mutex>& __lk);
	public:
	enum
	{
	__constructed = 1,
	__future_attached = 2,
	ready = 4,
	deferred = 8
	};

	_LIBCPP_INLINE_VISIBILITY
	__assoc_sub_state() : __state_(0) {}

	_LIBCPP_INLINE_VISIBILITY
	bool __has_value() const
	{return (__state_ & __constructed) \|\| (__exception_ != nullptr);}

	_LIBCPP_INLINE_VISIBILITY
	void __set_future_attached()
	{
	lock_guard<mutex> __lk(__mut_);
	__state_ \|= __future_attached;
	}
	_LIBCPP_INLINE_VISIBILITY
	bool __has_future_attached() const {return (__state_ & __future_attached) != 0;}

	_LIBCPP_INLINE_VISIBILITY
	void __set_deferred() {__state_ \|= deferred;}

	void __make_ready();
	_LIBCPP_INLINE_VISIBILITY
	bool __is_ready() const {return (__state_ & ready) != 0;}

	void set_value();
	void set_value_at_thread_exit();

	void set_exception(exception_ptr __p);
	void set_exception_at_thread_exit(exception_ptr __p);

	void copy();

	void wait();
	template <class _Rep, class _Period>
	future_status
	_LIBCPP_INLINE_VISIBILITY
	wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const;
	template <class _Clock, class _Duration>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	future_status
	wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const;

	virtual void __execute();
	};

	template <class _Clock, class _Duration>
	future_status
	__assoc_sub_state::wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
	{
	unique_lock<mutex> __lk(__mut_);
	if (__state_ & deferred)
	return future_status::deferred;
	while (!(__state_ & ready) && _Clock::now() < __abs_time)
	__cv_.wait_until(__lk, __abs_time);
	if (__state_ & ready)
	return future_status::ready;
	return future_status::timeout;
	}

	template <class _Rep, class _Period>
	inline
	future_status
	__assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
	{
	return wait_until(chrono::steady_clock::now() + __rel_time);
	}

	template <class _Rp>
	class _LIBCPP_AVAILABILITY_FUTURE __assoc_state
	: public __assoc_sub_state
	{
	typedef __assoc_sub_state base;
	typedef typename aligned_storage<sizeof(_Rp), alignment_of<_Rp>::value>::type _Up;
	protected:
	_Up __value_;

	virtual void __on_zero_shared() _NOEXCEPT;
	public:

	template <class _Arg>
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	void set_value(_Arg&& __arg);
	#else
	void set_value(_Arg& __arg);
	#endif

	template <class _Arg>
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	void set_value_at_thread_exit(_Arg&& __arg);
	#else
	void set_value_at_thread_exit(_Arg& __arg);
	#endif

	_Rp move();
	typename add_lvalue_reference<_Rp>::type copy();
	};

	template <class _Rp>
	void
	__assoc_state<_Rp>::__on_zero_shared() _NOEXCEPT
	{
	if (this->__state_ & base::__constructed)
	reinterpret_cast<_Rp*>(&__value_)->~_Rp();
	delete this;
	}

	template <class _Rp>
	template <class _Arg>
	_LIBCPP_AVAILABILITY_FUTURE
	void
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	__assoc_state<_Rp>::set_value(_Arg&& __arg)
	#else
	__assoc_state<_Rp>::set_value(_Arg& __arg)
	#endif
	{
	unique_lock<mutex> __lk(this->__mut_);
	if (this->__has_value())
	__throw_future_error(future_errc::promise_already_satisfied);
	::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg));
	this->__state_ \|= base::__constructed \| base::ready;
	__cv_.notify_all();
	}

	template <class _Rp>
	template <class _Arg>
	void
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	__assoc_state<_Rp>::set_value_at_thread_exit(_Arg&& __arg)
	#else
	__assoc_state<_Rp>::set_value_at_thread_exit(_Arg& __arg)
	#endif
	{
	unique_lock<mutex> __lk(this->__mut_);
	if (this->__has_value())
	__throw_future_error(future_errc::promise_already_satisfied);
	::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg));
	this->__state_ \|= base::__constructed;
	__thread_local_data()->__make_ready_at_thread_exit(this);
	}

	template <class _Rp>
	_Rp
	__assoc_state<_Rp>::move()
	{
	unique_lock<mutex> __lk(this->__mut_);
	this->__sub_wait(__lk);
	if (this->__exception_ != nullptr)
	rethrow_exception(this->__exception_);
	return _VSTD::move(reinterpret_cast<_Rp>(&__value_));
	}

	template <class _Rp>
	typename add_lvalue_reference<_Rp>::type
	__assoc_state<_Rp>::copy()
	{
	unique_lock<mutex> __lk(this->__mut_);
	this->__sub_wait(__lk);
	if (this->__exception_ != nullptr)
	rethrow_exception(this->__exception_);
	return reinterpret_cast<_Rp>(&__value_);
	}

	template <class _Rp>
	class _LIBCPP_AVAILABILITY_FUTURE __assoc_state<_Rp&>
	: public __assoc_sub_state
	{
	typedef __assoc_sub_state base;
	typedef _Rp* _Up;
	protected:
	_Up __value_;

	virtual void __on_zero_shared() _NOEXCEPT;
	public:

	void set_value(_Rp& __arg);
	void set_value_at_thread_exit(_Rp& __arg);

	_Rp& copy();
	};

	template <class _Rp>
	void
	__assoc_state<_Rp&>::__on_zero_shared() _NOEXCEPT
	{
	delete this;
	}

	template <class _Rp>
	void
	__assoc_state<_Rp&>::set_value(_Rp& __arg)
	{
	unique_lock<mutex> __lk(this->__mut_);
	if (this->__has_value())
	__throw_future_error(future_errc::promise_already_satisfied);
	__value_ = _VSTD::addressof(__arg);
	this->__state_ \|= base::__constructed \| base::ready;
	__cv_.notify_all();
	}

	template <class _Rp>
	void
	__assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg)
	{
	unique_lock<mutex> __lk(this->__mut_);
	if (this->__has_value())
	__throw_future_error(future_errc::promise_already_satisfied);
	__value_ = _VSTD::addressof(__arg);
	this->__state_ \|= base::__constructed;
	__thread_local_data()->__make_ready_at_thread_exit(this);
	}

	template <class _Rp>
	_Rp&
	__assoc_state<_Rp&>::copy()
	{
	unique_lock<mutex> __lk(this->__mut_);
	this->__sub_wait(__lk);
	if (this->__exception_ != nullptr)
	rethrow_exception(this->__exception_);
	return *__value_;
	}

	template <class _Rp, class _Alloc>
	class _LIBCPP_AVAILABILITY_FUTURE __assoc_state_alloc
	: public __assoc_state<_Rp>
	{
	typedef __assoc_state<_Rp> base;
	_Alloc __alloc_;

	virtual void __on_zero_shared() _NOEXCEPT;
	public:
	_LIBCPP_INLINE_VISIBILITY
	explicit __assoc_state_alloc(const _Alloc& __a)
	: __alloc_(__a) {}
	};

	template <class _Rp, class _Alloc>
	void
	__assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT
	{
	if (this->__state_ & base::__constructed)
	reinterpret_cast<_Rp*>(_VSTD::addressof(this->__value_))->~_Rp();
	typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al;
	typedef allocator_traits<_Al> _ATraits;
	typedef pointer_traits<typename _ATraits::pointer> _PTraits;
	_Al __a(__alloc_);
	this->~__assoc_state_alloc();
	__a.deallocate(_PTraits::pointer_to(*this), 1);
	}

	template <class _Rp, class _Alloc>
	class _LIBCPP_AVAILABILITY_FUTURE __assoc_state_alloc<_Rp&, _Alloc>
	: public __assoc_state<_Rp&>
	{
	typedef __assoc_state<_Rp&> base;
	_Alloc __alloc_;

	virtual void __on_zero_shared() _NOEXCEPT;
	public:
	_LIBCPP_INLINE_VISIBILITY
	explicit __assoc_state_alloc(const _Alloc& __a)
	: __alloc_(__a) {}
	};

	template <class _Rp, class _Alloc>
	void
	__assoc_state_alloc<_Rp&, _Alloc>::__on_zero_shared() _NOEXCEPT
	{
	typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al;
	typedef allocator_traits<_Al> _ATraits;
	typedef pointer_traits<typename _ATraits::pointer> _PTraits;
	_Al __a(__alloc_);
	this->~__assoc_state_alloc();
	__a.deallocate(_PTraits::pointer_to(*this), 1);
	}

	template <class _Alloc>
	class _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state_alloc
	: public __assoc_sub_state
	{
	typedef __assoc_sub_state base;
	_Alloc __alloc_;

	virtual void __on_zero_shared() _NOEXCEPT;
	public:
	_LIBCPP_INLINE_VISIBILITY
	explicit __assoc_sub_state_alloc(const _Alloc& __a)
	: __alloc_(__a) {}
	};

	template <class _Alloc>
	void
	__assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT
	{
	typedef typename __allocator_traits_rebind<_Alloc, __assoc_sub_state_alloc>::type _Al;
	typedef allocator_traits<_Al> _ATraits;
	typedef pointer_traits<typename _ATraits::pointer> _PTraits;
	_Al __a(__alloc_);
	this->~__assoc_sub_state_alloc();
	__a.deallocate(_PTraits::pointer_to(*this), 1);
	}

	template <class _Rp, class _Fp>
	class _LIBCPP_AVAILABILITY_FUTURE __deferred_assoc_state
	: public __assoc_state<_Rp>
	{
	typedef __assoc_state<_Rp> base;

	_Fp __func_;

	public:
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	explicit __deferred_assoc_state(_Fp&& __f);
	#endif

	virtual void __execute();
	};

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Rp, class _Fp>
	inline
	__deferred_assoc_state<_Rp, _Fp>::__deferred_assoc_state(_Fp&& __f)
	: __func_(_VSTD::forward<_Fp>(__f))
	{
	this->__set_deferred();
	}

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Rp, class _Fp>
	void
	__deferred_assoc_state<_Rp, _Fp>::__execute()
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	this->set_value(__func_());
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->set_exception(current_exception());
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	template <class _Fp>
	class _LIBCPP_AVAILABILITY_FUTURE __deferred_assoc_state<void, _Fp>
	: public __assoc_sub_state
	{
	typedef __assoc_sub_state base;

	_Fp __func_;

	public:
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	explicit __deferred_assoc_state(_Fp&& __f);
	#endif

	virtual void __execute();
	};

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Fp>
	inline
	__deferred_assoc_state<void, _Fp>::__deferred_assoc_state(_Fp&& __f)
	: __func_(_VSTD::forward<_Fp>(__f))
	{
	this->__set_deferred();
	}

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Fp>
	void
	__deferred_assoc_state<void, _Fp>::__execute()
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	__func_();
	this->set_value();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->set_exception(current_exception());
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	template <class _Rp, class _Fp>
	class _LIBCPP_AVAILABILITY_FUTURE __async_assoc_state
	: public __assoc_state<_Rp>
	{
	typedef __assoc_state<_Rp> base;

	_Fp __func_;

	virtual void __on_zero_shared() _NOEXCEPT;
	public:
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	explicit __async_assoc_state(_Fp&& __f);
	#endif

	virtual void __execute();
	};

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Rp, class _Fp>
	inline
	__async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f)
	: __func_(_VSTD::forward<_Fp>(__f))
	{
	}

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Rp, class _Fp>
	void
	__async_assoc_state<_Rp, _Fp>::__execute()
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	this->set_value(__func_());
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->set_exception(current_exception());
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

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

	template <class _Fp>
	class _LIBCPP_AVAILABILITY_FUTURE __async_assoc_state<void, _Fp>
	: public __assoc_sub_state
	{
	typedef __assoc_sub_state base;

	_Fp __func_;

	virtual void __on_zero_shared() _NOEXCEPT;
	public:
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	explicit __async_assoc_state(_Fp&& __f);
	#endif

	virtual void __execute();
	};

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Fp>
	inline
	__async_assoc_state<void, _Fp>::__async_assoc_state(_Fp&& __f)
	: __func_(_VSTD::forward<_Fp>(__f))
	{
	}

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Fp>
	void
	__async_assoc_state<void, _Fp>::__execute()
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	__func_();
	this->set_value();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->set_exception(current_exception());
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

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

	template <class _Rp> class _LIBCPP_TEMPLATE_VIS promise;
	template <class _Rp> class _LIBCPP_TEMPLATE_VIS shared_future;

	// future

	template <class _Rp> class _LIBCPP_TEMPLATE_VIS future;

	template <class _Rp, class _Fp>
	future<_Rp>
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	__make_deferred_assoc_state(_Fp&& __f);
	#else
	__make_deferred_assoc_state(_Fp __f);
	#endif

	template <class _Rp, class _Fp>
	future<_Rp>
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	__make_async_assoc_state(_Fp&& __f);
	#else
	__make_async_assoc_state(_Fp __f);
	#endif

	template <class _Rp>
	class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE future
	{
	__assoc_state<_Rp>* __state_;

	explicit future(__assoc_state<_Rp>* __state);

	template <class> friend class promise;
	template <class> friend class shared_future;

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	template <class _R1, class _Fp>
	friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
	template <class _R1, class _Fp>
	friend future<_R1> __make_async_assoc_state(_Fp&& __f);
	#else
	template <class _R1, class _Fp>
	friend future<_R1> __make_deferred_assoc_state(_Fp __f);
	template <class _R1, class _Fp>
	friend future<_R1> __make_async_assoc_state(_Fp __f);
	#endif

	public:
	_LIBCPP_INLINE_VISIBILITY
	future() _NOEXCEPT : __state_(nullptr) {}
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	future(future&& __rhs) _NOEXCEPT
	: __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
	future(const future&) = delete;
	future& operator=(const future&) = delete;
	_LIBCPP_INLINE_VISIBILITY
	future& operator=(future&& __rhs) _NOEXCEPT
	{
	future(std::move(__rhs)).swap(*this);
	return *this;
	}
	#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	private:
	future(const future&);
	future& operator=(const future&);
	public:
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	~future();
	_LIBCPP_INLINE_VISIBILITY
	shared_future<_Rp> share() _NOEXCEPT;

	// retrieving the value
	_Rp get();

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

	// functions to check state
	_LIBCPP_INLINE_VISIBILITY
	bool valid() const _NOEXCEPT {return __state_ != nullptr;}

	_LIBCPP_INLINE_VISIBILITY
	void wait() const {__state_->wait();}
	template <class _Rep, class _Period>
	_LIBCPP_INLINE_VISIBILITY
	future_status
	wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
	{return __state_->wait_for(__rel_time);}
	template <class _Clock, class _Duration>
	_LIBCPP_INLINE_VISIBILITY
	future_status
	wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
	{return __state_->wait_until(__abs_time);}
	};

	template <class _Rp>
	future<_Rp>::future(__assoc_state<_Rp>* __state)
	: __state_(__state)
	{
	if (__state_->__has_future_attached())
	__throw_future_error(future_errc::future_already_retrieved);
	__state_->__add_shared();
	__state_->__set_future_attached();
	}

	struct __release_shared_count
	{
	void operator()(__shared_count* p) {p->__release_shared();}
	};

	template <class _Rp>
	future<_Rp>::~future()
	{
	if (__state_)
	__state_->__release_shared();
	}

	template <class _Rp>
	_Rp
	future<_Rp>::get()
	{
	unique_ptr<__shared_count, __release_shared_count> __(__state_);
	__assoc_state<_Rp>* __s = __state_;
	__state_ = nullptr;
	return __s->move();
	}

	template <class _Rp>
	class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE future<_Rp&>
	{
	__assoc_state<_Rp&>* __state_;

	explicit future(__assoc_state<_Rp&>* __state);

	template <class> friend class promise;
	template <class> friend class shared_future;

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	template <class _R1, class _Fp>
	friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
	template <class _R1, class _Fp>
	friend future<_R1> __make_async_assoc_state(_Fp&& __f);
	#else
	template <class _R1, class _Fp>
	friend future<_R1> __make_deferred_assoc_state(_Fp __f);
	template <class _R1, class _Fp>
	friend future<_R1> __make_async_assoc_state(_Fp __f);
	#endif

	public:
	_LIBCPP_INLINE_VISIBILITY
	future() _NOEXCEPT : __state_(nullptr) {}
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	future(future&& __rhs) _NOEXCEPT
	: __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
	future(const future&) = delete;
	future& operator=(const future&) = delete;
	_LIBCPP_INLINE_VISIBILITY
	future& operator=(future&& __rhs) _NOEXCEPT
	{
	future(std::move(__rhs)).swap(*this);
	return *this;
	}
	#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	private:
	future(const future&);
	future& operator=(const future&);
	public:
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	~future();
	_LIBCPP_INLINE_VISIBILITY
	shared_future<_Rp&> share() _NOEXCEPT;

	// retrieving the value
	_Rp& get();

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

	// functions to check state
	_LIBCPP_INLINE_VISIBILITY
	bool valid() const _NOEXCEPT {return __state_ != nullptr;}

	_LIBCPP_INLINE_VISIBILITY
	void wait() const {__state_->wait();}
	template <class _Rep, class _Period>
	_LIBCPP_INLINE_VISIBILITY
	future_status
	wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
	{return __state_->wait_for(__rel_time);}
	template <class _Clock, class _Duration>
	_LIBCPP_INLINE_VISIBILITY
	future_status
	wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
	{return __state_->wait_until(__abs_time);}
	};

	template <class _Rp>
	future<_Rp&>::future(__assoc_state<_Rp&>* __state)
	: __state_(__state)
	{
	if (__state_->__has_future_attached())
	__throw_future_error(future_errc::future_already_retrieved);
	__state_->__add_shared();
	__state_->__set_future_attached();
	}

	template <class _Rp>
	future<_Rp&>::~future()
	{
	if (__state_)
	__state_->__release_shared();
	}

	template <class _Rp>
	_Rp&
	future<_Rp&>::get()
	{
	unique_ptr<__shared_count, __release_shared_count> __(__state_);
	__assoc_state<_Rp&>* __s = __state_;
	__state_ = nullptr;
	return __s->copy();
	}

	template <>
	class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE future<void>
	{
	__assoc_sub_state* __state_;

	explicit future(__assoc_sub_state* __state);

	template <class> friend class promise;
	template <class> friend class shared_future;

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	template <class _R1, class _Fp>
	friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
	template <class _R1, class _Fp>
	friend future<_R1> __make_async_assoc_state(_Fp&& __f);
	#else
	template <class _R1, class _Fp>
	friend future<_R1> __make_deferred_assoc_state(_Fp __f);
	template <class _R1, class _Fp>
	friend future<_R1> __make_async_assoc_state(_Fp __f);
	#endif

	public:
	_LIBCPP_INLINE_VISIBILITY
	future() _NOEXCEPT : __state_(nullptr) {}
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	future(future&& __rhs) _NOEXCEPT
	: __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
	future(const future&) = delete;
	future& operator=(const future&) = delete;
	_LIBCPP_INLINE_VISIBILITY
	future& operator=(future&& __rhs) _NOEXCEPT
	{
	future(std::move(__rhs)).swap(*this);
	return *this;
	}
	#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	private:
	future(const future&);
	future& operator=(const future&);
	public:
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	~future();
	_LIBCPP_INLINE_VISIBILITY
	shared_future<void> share() _NOEXCEPT;

	// retrieving the value
	void get();

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

	// functions to check state
	_LIBCPP_INLINE_VISIBILITY
	bool valid() const _NOEXCEPT {return __state_ != nullptr;}

	_LIBCPP_INLINE_VISIBILITY
	void wait() const {__state_->wait();}
	template <class _Rep, class _Period>
	_LIBCPP_INLINE_VISIBILITY
	future_status
	wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
	{return __state_->wait_for(__rel_time);}
	template <class _Clock, class _Duration>
	_LIBCPP_INLINE_VISIBILITY
	future_status
	wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
	{return __state_->wait_until(__abs_time);}
	};

	template <class _Rp>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(future<_Rp>& __x, future<_Rp>& __y) _NOEXCEPT
	{
	__x.swap(__y);
	}

	// promise<R>

	template <class _Callable> class packaged_task;

	template <class _Rp>
	class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE promise
	{
	__assoc_state<_Rp>* __state_;

	_LIBCPP_INLINE_VISIBILITY
	explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}

	template <class> friend class packaged_task;
	public:
	promise();
	template <class _Alloc>
	promise(allocator_arg_t, const _Alloc& __a);
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	promise(promise&& __rhs) _NOEXCEPT
	: __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
	promise(const promise& __rhs) = delete;
	#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	private:
	promise(const promise& __rhs);
	public:
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	~promise();

	// assignment
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	promise& operator=(promise&& __rhs) _NOEXCEPT
	{
	promise(std::move(__rhs)).swap(*this);
	return *this;
	}
	promise& operator=(const promise& __rhs) = delete;
	#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	private:
	promise& operator=(const promise& __rhs);
	public:
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}

	// retrieving the result
	future<_Rp> get_future();

	// setting the result
	void set_value(const _Rp& __r);
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	void set_value(_Rp&& __r);
	#endif
	void set_exception(exception_ptr __p);

	// setting the result with deferred notification
	void set_value_at_thread_exit(const _Rp& __r);
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	void set_value_at_thread_exit(_Rp&& __r);
	#endif
	void set_exception_at_thread_exit(exception_ptr __p);
	};

	template <class _Rp>
	promise<_Rp>::promise()
	: __state_(new __assoc_state<_Rp>)
	{
	}

	template <class _Rp>
	template <class _Alloc>
	promise<_Rp>::promise(allocator_arg_t, const _Alloc& __a0)
	{
	typedef __assoc_state_alloc<_Rp, _Alloc> _State;
	typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
	typedef __allocator_destructor<_A2> _D2;
	_A2 __a(__a0);
	unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
	::new(static_cast<void>(_VSTD::addressof(__hold.get()))) _State(__a0);
	__state_ = _VSTD::addressof(*__hold.release());
	}

	template <class _Rp>
	promise<_Rp>::~promise()
	{
	if (__state_)
	{
	if (!__state_->__has_value() && __state_->use_count() > 1)
	__state_->set_exception(make_exception_ptr(
	future_error(make_error_code(future_errc::broken_promise))
	));
	__state_->__release_shared();
	}
	}

	template <class _Rp>
	future<_Rp>
	promise<_Rp>::get_future()
	{
	if (__state_ == nullptr)
	__throw_future_error(future_errc::no_state);
	return future<_Rp>(__state_);
	}

	template <class _Rp>
	void
	promise<_Rp>::set_value(const _Rp& __r)
	{
	if (__state_ == nullptr)
	__throw_future_error(future_errc::no_state);
	__state_->set_value(__r);
	}

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Rp>
	void
	promise<_Rp>::set_value(_Rp&& __r)
	{
	if (__state_ == nullptr)
	__throw_future_error(future_errc::no_state);
	__state_->set_value(_VSTD::move(__r));
	}

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Rp>
	void
	promise<_Rp>::set_exception(exception_ptr __p)
	{
	_LIBCPP_ASSERT( __p != nullptr, "promise::set_exception: received nullptr" );
	if (__state_ == nullptr)
	__throw_future_error(future_errc::no_state);
	__state_->set_exception(__p);
	}

	template <class _Rp>
	void
	promise<_Rp>::set_value_at_thread_exit(const _Rp& __r)
	{
	if (__state_ == nullptr)
	__throw_future_error(future_errc::no_state);
	__state_->set_value_at_thread_exit(__r);
	}

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Rp>
	void
	promise<_Rp>::set_value_at_thread_exit(_Rp&& __r)
	{
	if (__state_ == nullptr)
	__throw_future_error(future_errc::no_state);
	__state_->set_value_at_thread_exit(_VSTD::move(__r));
	}

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Rp>
	void
	promise<_Rp>::set_exception_at_thread_exit(exception_ptr __p)
	{
	_LIBCPP_ASSERT( __p != nullptr, "promise::set_exception_at_thread_exit: received nullptr" );
	if (__state_ == nullptr)
	__throw_future_error(future_errc::no_state);
	__state_->set_exception_at_thread_exit(__p);
	}

	// promise<R&>

	template <class _Rp>
	class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE promise<_Rp&>
	{
	__assoc_state<_Rp&>* __state_;

	_LIBCPP_INLINE_VISIBILITY
	explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}

	template <class> friend class packaged_task;

	public:
	promise();
	template <class _Allocator>
	promise(allocator_arg_t, const _Allocator& __a);
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	promise(promise&& __rhs) _NOEXCEPT
	: __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
	promise(const promise& __rhs) = delete;
	#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	private:
	promise(const promise& __rhs);
	public:
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	~promise();

	// assignment
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	promise& operator=(promise&& __rhs) _NOEXCEPT
	{
	promise(std::move(__rhs)).swap(*this);
	return *this;
	}
	promise& operator=(const promise& __rhs) = delete;
	#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	private:
	promise& operator=(const promise& __rhs);
	public:
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}

	// retrieving the result
	future<_Rp&> get_future();

	// setting the result
	void set_value(_Rp& __r);
	void set_exception(exception_ptr __p);

	// setting the result with deferred notification
	void set_value_at_thread_exit(_Rp&);
	void set_exception_at_thread_exit(exception_ptr __p);
	};

	template <class _Rp>
	promise<_Rp&>::promise()
	: __state_(new __assoc_state<_Rp&>)
	{
	}

	template <class _Rp>
	template <class _Alloc>
	promise<_Rp&>::promise(allocator_arg_t, const _Alloc& __a0)
	{
	typedef __assoc_state_alloc<_Rp&, _Alloc> _State;
	typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
	typedef __allocator_destructor<_A2> _D2;
	_A2 __a(__a0);
	unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
	::new(static_cast<void>(_VSTD::addressof(__hold.get()))) _State(__a0);
	__state_ = _VSTD::addressof(*__hold.release());
	}

	template <class _Rp>
	promise<_Rp&>::~promise()
	{
	if (__state_)
	{
	if (!__state_->__has_value() && __state_->use_count() > 1)
	__state_->set_exception(make_exception_ptr(
	future_error(make_error_code(future_errc::broken_promise))
	));
	__state_->__release_shared();
	}
	}

	template <class _Rp>
	future<_Rp&>
	promise<_Rp&>::get_future()
	{
	if (__state_ == nullptr)
	__throw_future_error(future_errc::no_state);
	return future<_Rp&>(__state_);
	}

	template <class _Rp>
	void
	promise<_Rp&>::set_value(_Rp& __r)
	{
	if (__state_ == nullptr)
	__throw_future_error(future_errc::no_state);
	__state_->set_value(__r);
	}

	template <class _Rp>
	void
	promise<_Rp&>::set_exception(exception_ptr __p)
	{
	_LIBCPP_ASSERT( __p != nullptr, "promise::set_exception: received nullptr" );
	if (__state_ == nullptr)
	__throw_future_error(future_errc::no_state);
	__state_->set_exception(__p);
	}

	template <class _Rp>
	void
	promise<_Rp&>::set_value_at_thread_exit(_Rp& __r)
	{
	if (__state_ == nullptr)
	__throw_future_error(future_errc::no_state);
	__state_->set_value_at_thread_exit(__r);
	}

	template <class _Rp>
	void
	promise<_Rp&>::set_exception_at_thread_exit(exception_ptr __p)
	{
	_LIBCPP_ASSERT( __p != nullptr, "promise::set_exception_at_thread_exit: received nullptr" );
	if (__state_ == nullptr)
	__throw_future_error(future_errc::no_state);
	__state_->set_exception_at_thread_exit(__p);
	}

	// promise<void>

	template <>
	class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE promise<void>
	{
	__assoc_sub_state* __state_;

	_LIBCPP_INLINE_VISIBILITY
	explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}

	template <class> friend class packaged_task;

	public:
	promise();
	template <class _Allocator>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	promise(allocator_arg_t, const _Allocator& __a);
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	promise(promise&& __rhs) _NOEXCEPT
	: __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
	promise(const promise& __rhs) = delete;
	#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	private:
	promise(const promise& __rhs);
	public:
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	~promise();

	// assignment
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	promise& operator=(promise&& __rhs) _NOEXCEPT
	{
	promise(std::move(__rhs)).swap(*this);
	return *this;
	}
	promise& operator=(const promise& __rhs) = delete;
	#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	private:
	promise& operator=(const promise& __rhs);
	public:
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}

	// retrieving the result
	future<void> get_future();

	// setting the result
	void set_value();
	void set_exception(exception_ptr __p);

	// setting the result with deferred notification
	void set_value_at_thread_exit();
	void set_exception_at_thread_exit(exception_ptr __p);
	};

	template <class _Alloc>
	promise<void>::promise(allocator_arg_t, const _Alloc& __a0)
	{
	typedef __assoc_sub_state_alloc<_Alloc> _State;
	typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
	typedef __allocator_destructor<_A2> _D2;
	_A2 __a(__a0);
	unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
	::new(static_cast<void>(_VSTD::addressof(__hold.get()))) _State(__a0);
	__state_ = _VSTD::addressof(*__hold.release());
	}

	template <class _Rp>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(promise<_Rp>& __x, promise<_Rp>& __y) _NOEXCEPT
	{
	__x.swap(__y);
	}

	template <class _Rp, class _Alloc>
	struct _LIBCPP_TEMPLATE_VIS uses_allocator<promise<_Rp>, _Alloc>
	: public true_type {};

	#ifndef _LIBCPP_HAS_NO_VARIADICS

	// packaged_task

	template<class _Fp> class __packaged_task_base;

	template<class _Rp, class ..._ArgTypes>
	class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_base<_Rp(_ArgTypes...)>
	{
	__packaged_task_base(const __packaged_task_base&);
	__packaged_task_base& operator=(const __packaged_task_base&);
	public:
	_LIBCPP_INLINE_VISIBILITY
	__packaged_task_base() {}
	_LIBCPP_INLINE_VISIBILITY
	virtual ~__packaged_task_base() {}
	virtual void __move_to(__packaged_task_base*) _NOEXCEPT = 0;
	virtual void destroy() = 0;
	virtual void destroy_deallocate() = 0;
	virtual _Rp operator()(_ArgTypes&& ...) = 0;
	};

	template<class _FD, class _Alloc, class _FB> class __packaged_task_func;

	template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
	class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>
	: public __packaged_task_base<_Rp(_ArgTypes...)>
	{
	__compressed_pair<_Fp, _Alloc> __f_;
	public:
	_LIBCPP_INLINE_VISIBILITY
	explicit __packaged_task_func(const _Fp& __f) : __f_(__f) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit __packaged_task_func(_Fp&& __f) : __f_(_VSTD::move(__f)) {}
	_LIBCPP_INLINE_VISIBILITY
	__packaged_task_func(const _Fp& __f, const _Alloc& __a)
	: __f_(__f, __a) {}
	_LIBCPP_INLINE_VISIBILITY
	__packaged_task_func(_Fp&& __f, const _Alloc& __a)
	: __f_(_VSTD::move(__f), __a) {}
	virtual void __move_to(__packaged_task_base<_Rp(_ArgTypes...)>*) _NOEXCEPT;
	virtual void destroy();
	virtual void destroy_deallocate();
	virtual _Rp operator()(_ArgTypes&& ... __args);
	};

	template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
	void
	__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__move_to(
	__packaged_task_base<_Rp(_ArgTypes...)>* __p) _NOEXCEPT
	{
	::new (__p) __packaged_task_func(_VSTD::move(__f_.first()), _VSTD::move(__f_.second()));
	}

	template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
	void
	__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy()
	{
	__f_.~__compressed_pair<_Fp, _Alloc>();
	}

	template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
	void
	__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate()
	{
	typedef typename __allocator_traits_rebind<_Alloc, __packaged_task_func>::type _Ap;
	typedef allocator_traits<_Ap> _ATraits;
	typedef pointer_traits<typename _ATraits::pointer> _PTraits;
	_Ap __a(__f_.second());
	__f_.~__compressed_pair<_Fp, _Alloc>();
	__a.deallocate(_PTraits::pointer_to(*this), 1);
	}

	template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
	_Rp
	__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
	{
	return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
	}

	template <class _Callable> class __packaged_task_function;

	template<class _Rp, class ..._ArgTypes>
	class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_function<_Rp(_ArgTypes...)>
	{
	typedef __packaged_task_base<_Rp(_ArgTypes...)> __base;
	typename aligned_storage<3sizeof(void)>::type __buf_;
	__base* __f_;

	public:
	typedef _Rp result_type;

	// construct/copy/destroy:
	_LIBCPP_INLINE_VISIBILITY
	__packaged_task_function() _NOEXCEPT : __f_(nullptr) {}
	template<class _Fp>
	__packaged_task_function(_Fp&& __f);
	template<class _Fp, class _Alloc>
	__packaged_task_function(allocator_arg_t, const _Alloc& __a, _Fp&& __f);

	__packaged_task_function(__packaged_task_function&&) _NOEXCEPT;
	__packaged_task_function& operator=(__packaged_task_function&&) _NOEXCEPT;

	__packaged_task_function(const __packaged_task_function&) = delete;
	__packaged_task_function& operator=(const __packaged_task_function&) = delete;

	~__packaged_task_function();

	void swap(__packaged_task_function&) _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY
	_Rp operator()(_ArgTypes...) const;
	};

	template<class _Rp, class ..._ArgTypes>
	__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f) _NOEXCEPT
	{
	if (__f.__f_ == nullptr)
	__f_ = nullptr;
	else if (__f.__f_ == (__base*)&__f.__buf_)
	{
	__f_ = (__base*)&__buf_;
	__f.__f_->__move_to(__f_);
	}
	else
	{
	__f_ = __f.__f_;
	__f.__f_ = nullptr;
	}
	}

	template<class _Rp, class ..._ArgTypes>
	template <class _Fp>
	__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(_Fp&& __f)
	: __f_(nullptr)
	{
	typedef typename remove_reference<typename decay<_Fp>::type>::type _FR;
	typedef __packaged_task_func<_FR, allocator<_FR>, _Rp(_ArgTypes...)> _FF;
	if (sizeof(_FF) <= sizeof(__buf_))
	{
	__f_ = (__base*)&__buf_;
	::new (__f_) _FF(_VSTD::forward<_Fp>(__f));
	}
	else
	{
	typedef allocator<_FF> _Ap;
	_Ap __a;
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (__hold.get()) _FF(_VSTD::forward<_Fp>(__f), allocator<_FR>(__a));
	__f_ = __hold.release();
	}
	}

	template<class _Rp, class ..._ArgTypes>
	template <class _Fp, class _Alloc>
	__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(
	allocator_arg_t, const _Alloc& __a0, _Fp&& __f)
	: __f_(nullptr)
	{
	typedef typename remove_reference<typename decay<_Fp>::type>::type _FR;
	typedef __packaged_task_func<_FR, _Alloc, _Rp(_ArgTypes...)> _FF;
	if (sizeof(_FF) <= sizeof(__buf_))
	{
	__f_ = (__base*)&__buf_;
	::new (__f_) _FF(_VSTD::forward<_Fp>(__f));
	}
	else
	{
	typedef typename __allocator_traits_rebind<_Alloc, _FF>::type _Ap;
	_Ap __a(__a0);
	typedef __allocator_destructor<_Ap> _Dp;
	unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
	::new (static_cast<void>(_VSTD::addressof(__hold.get())))
	_FF(_VSTD::forward<_Fp>(__f), _Alloc(__a));
	__f_ = _VSTD::addressof(*__hold.release());
	}
	}

	template<class _Rp, class ..._ArgTypes>
	__packaged_task_function<_Rp(_ArgTypes...)>&
	__packaged_task_function<_Rp(_ArgTypes...)>::operator=(__packaged_task_function&& __f) _NOEXCEPT
	{
	if (__f_ == (__base*)&__buf_)
	__f_->destroy();
	else if (__f_)
	__f_->destroy_deallocate();
	__f_ = nullptr;
	if (__f.__f_ == nullptr)
	__f_ = nullptr;
	else if (__f.__f_ == (__base*)&__f.__buf_)
	{
	__f_ = (__base*)&__buf_;
	__f.__f_->__move_to(__f_);
	}
	else
	{
	__f_ = __f.__f_;
	__f.__f_ = nullptr;
	}
	return *this;
	}

	template<class _Rp, class ..._ArgTypes>
	__packaged_task_function<_Rp(_ArgTypes...)>::~__packaged_task_function()
	{
	if (__f_ == (__base*)&__buf_)
	__f_->destroy();
	else if (__f_)
	__f_->destroy_deallocate();
	}

	template<class _Rp, class ..._ArgTypes>
	void
	__packaged_task_function<_Rp(_ArgTypes...)>::swap(__packaged_task_function& __f) _NOEXCEPT
	{
	if (__f_ == (__base)&__buf_ && __f.__f_ == (__base)&__f.__buf_)
	{
	typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
	__base* __t = (__base*)&__tempbuf;
	__f_->__move_to(__t);
	__f_->destroy();
	__f_ = nullptr;
	__f.__f_->__move_to((__base*)&__buf_);
	__f.__f_->destroy();
	__f.__f_ = nullptr;
	__f_ = (__base*)&__buf_;
	__t->__move_to((__base*)&__f.__buf_);
	__t->destroy();
	__f.__f_ = (__base*)&__f.__buf_;
	}
	else if (__f_ == (__base*)&__buf_)
	{
	__f_->__move_to((__base*)&__f.__buf_);
	__f_->destroy();
	__f_ = __f.__f_;
	__f.__f_ = (__base*)&__f.__buf_;
	}
	else if (__f.__f_ == (__base*)&__f.__buf_)
	{
	__f.__f_->__move_to((__base*)&__buf_);
	__f.__f_->destroy();
	__f.__f_ = __f_;
	__f_ = (__base*)&__buf_;
	}
	else
	_VSTD::swap(__f_, __f.__f_);
	}

	template<class _Rp, class ..._ArgTypes>
	inline
	_Rp
	__packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
	{
	return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
	}

	template<class _Rp, class ..._ArgTypes>
	class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE packaged_task<_Rp(_ArgTypes...)>
	{
	public:
	typedef _Rp result_type; // extension

	private:
	__packaged_task_function<result_type(_ArgTypes...)> __f_;
	promise<result_type> __p_;

	public:
	// construction and destruction
	_LIBCPP_INLINE_VISIBILITY
	packaged_task() _NOEXCEPT : __p_(nullptr) {}
	template <class _Fp,
	class = typename enable_if
	<
	!is_same<
	- typename decay<_Fp>::type,
	+ typename __uncvref<_Fp>::type,
	packaged_task
	>::value
	>::type
	>
	_LIBCPP_INLINE_VISIBILITY
	explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
	template <class _Fp, class _Allocator,
	class = typename enable_if
	<
	!is_same<
	- typename decay<_Fp>::type,
	+ typename __uncvref<_Fp>::type,
	packaged_task
	>::value
	>::type
	>
	_LIBCPP_INLINE_VISIBILITY
	packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
	: __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)),
	__p_(allocator_arg, __a) {}
	// ~packaged_task() = default;

	// no copy
	packaged_task(const packaged_task&) = delete;
	packaged_task& operator=(const packaged_task&) = delete;

	// move support
	_LIBCPP_INLINE_VISIBILITY
	packaged_task(packaged_task&& __other) _NOEXCEPT
	: __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
	_LIBCPP_INLINE_VISIBILITY
	packaged_task& operator=(packaged_task&& __other) _NOEXCEPT
	{
	__f_ = _VSTD::move(__other.__f_);
	__p_ = _VSTD::move(__other.__p_);
	return *this;
	}
	_LIBCPP_INLINE_VISIBILITY
	void swap(packaged_task& __other) _NOEXCEPT
	{
	__f_.swap(__other.__f_);
	__p_.swap(__other.__p_);
	}

	_LIBCPP_INLINE_VISIBILITY
	bool valid() const _NOEXCEPT {return __p_.__state_ != nullptr;}

	// result retrieval
	_LIBCPP_INLINE_VISIBILITY
	future<result_type> get_future() {return __p_.get_future();}

	// execution
	void operator()(_ArgTypes... __args);
	void make_ready_at_thread_exit(_ArgTypes... __args);

	void reset();
	};

	template<class _Rp, class ..._ArgTypes>
	void
	packaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args)
	{
	if (__p_.__state_ == nullptr)
	__throw_future_error(future_errc::no_state);
	if (__p_.__state_->__has_value())
	__throw_future_error(future_errc::promise_already_satisfied);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	__p_.set_value(__f_(_VSTD::forward<_ArgTypes>(__args)...));
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__p_.set_exception(current_exception());
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	template<class _Rp, class ..._ArgTypes>
	void
	packaged_task<_Rp(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
	{
	if (__p_.__state_ == nullptr)
	__throw_future_error(future_errc::no_state);
	if (__p_.__state_->__has_value())
	__throw_future_error(future_errc::promise_already_satisfied);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	__p_.set_value_at_thread_exit(__f_(_VSTD::forward<_ArgTypes>(__args)...));
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__p_.set_exception_at_thread_exit(current_exception());
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	template<class _Rp, class ..._ArgTypes>
	void
	packaged_task<_Rp(_ArgTypes...)>::reset()
	{
	if (!valid())
	__throw_future_error(future_errc::no_state);
	__p_ = promise<result_type>();
	}

	template<class ..._ArgTypes>
	class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE packaged_task<void(_ArgTypes...)>
	{
	public:
	typedef void result_type; // extension

	private:
	__packaged_task_function<result_type(_ArgTypes...)> __f_;
	promise<result_type> __p_;

	public:
	// construction and destruction
	_LIBCPP_INLINE_VISIBILITY
	packaged_task() _NOEXCEPT : __p_(nullptr) {}
	template <class _Fp,
	class = typename enable_if
	<
	!is_same<
	- typename decay<_Fp>::type,
	+ typename __uncvref<_Fp>::type,
	packaged_task
	>::value
	>::type
	>
	_LIBCPP_INLINE_VISIBILITY
	explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
	template <class _Fp, class _Allocator,
	class = typename enable_if
	<
	!is_same<
	- typename decay<_Fp>::type,
	+ typename __uncvref<_Fp>::type,
	packaged_task
	>::value
	>::type
	>
	_LIBCPP_INLINE_VISIBILITY
	packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
	: __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)),
	__p_(allocator_arg, __a) {}
	// ~packaged_task() = default;

	// no copy
	packaged_task(const packaged_task&) = delete;
	packaged_task& operator=(const packaged_task&) = delete;

	// move support
	_LIBCPP_INLINE_VISIBILITY
	packaged_task(packaged_task&& __other) _NOEXCEPT
	: __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
	_LIBCPP_INLINE_VISIBILITY
	packaged_task& operator=(packaged_task&& __other) _NOEXCEPT
	{
	__f_ = _VSTD::move(__other.__f_);
	__p_ = _VSTD::move(__other.__p_);
	return *this;
	}
	_LIBCPP_INLINE_VISIBILITY
	void swap(packaged_task& __other) _NOEXCEPT
	{
	__f_.swap(__other.__f_);
	__p_.swap(__other.__p_);
	}

	_LIBCPP_INLINE_VISIBILITY
	bool valid() const _NOEXCEPT {return __p_.__state_ != nullptr;}

	// result retrieval
	_LIBCPP_INLINE_VISIBILITY
	future<result_type> get_future() {return __p_.get_future();}

	// execution
	void operator()(_ArgTypes... __args);
	void make_ready_at_thread_exit(_ArgTypes... __args);

	void reset();
	};

	template<class ..._ArgTypes>
	void
	packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args)
	{
	if (__p_.__state_ == nullptr)
	__throw_future_error(future_errc::no_state);
	if (__p_.__state_->__has_value())
	__throw_future_error(future_errc::promise_already_satisfied);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	__f_(_VSTD::forward<_ArgTypes>(__args)...);
	__p_.set_value();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__p_.set_exception(current_exception());
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	template<class ..._ArgTypes>
	void
	packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
	{
	if (__p_.__state_ == nullptr)
	__throw_future_error(future_errc::no_state);
	if (__p_.__state_->__has_value())
	__throw_future_error(future_errc::promise_already_satisfied);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	__f_(_VSTD::forward<_ArgTypes>(__args)...);
	__p_.set_value_at_thread_exit();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__p_.set_exception_at_thread_exit(current_exception());
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	template<class ..._ArgTypes>
	void
	packaged_task<void(_ArgTypes...)>::reset()
	{
	if (!valid())
	__throw_future_error(future_errc::no_state);
	__p_ = promise<result_type>();
	}

	template <class _Callable>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(packaged_task<_Callable>& __x, packaged_task<_Callable>& __y) _NOEXCEPT
	{
	__x.swap(__y);
	}

	template <class _Callable, class _Alloc>
	struct _LIBCPP_TEMPLATE_VIS uses_allocator<packaged_task<_Callable>, _Alloc>
	: public true_type {};

	template <class _Rp, class _Fp>
	future<_Rp>
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	__make_deferred_assoc_state(_Fp&& __f)
	#else
	__make_deferred_assoc_state(_Fp __f)
	#endif
	{
	unique_ptr<__deferred_assoc_state<_Rp, _Fp>, __release_shared_count>
	__h(new __deferred_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f)));
	return future<_Rp>(__h.get());
	}

	template <class _Rp, class _Fp>
	future<_Rp>
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	__make_async_assoc_state(_Fp&& __f)
	#else
	__make_async_assoc_state(_Fp __f)
	#endif
	{
	unique_ptr<__async_assoc_state<_Rp, _Fp>, __release_shared_count>
	__h(new __async_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f)));
	_VSTD::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach();
	return future<_Rp>(__h.get());
	}

	template <class _Fp, class... _Args>
	class __async_func
	{
	tuple<_Fp, _Args...> __f_;

	public:
	typedef typename __invoke_of<_Fp, _Args...>::type _Rp;

	_LIBCPP_INLINE_VISIBILITY
	explicit __async_func(_Fp&& __f, _Args&&... __args)
	: __f_(_VSTD::move(__f), _VSTD::move(__args)...) {}

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

	_Rp operator()()
	{
	typedef typename __make_tuple_indices<1+sizeof...(_Args), 1>::type _Index;
	return __execute(_Index());
	}
	private:
	template <size_t ..._Indices>
	_Rp
	__execute(__tuple_indices<_Indices...>)
	{
	return __invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...);
	}
	};

	inline _LIBCPP_INLINE_VISIBILITY bool __does_policy_contain(launch __policy, launch __value )
	{ 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)
	{
	typedef __async_func<typename decay<_Fp>::type, typename decay<_Args>::type...> _BF;
	typedef typename _BF::_Rp _Rp;

	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif
	if (__does_policy_contain(__policy, launch::async))
	return _VSTD::__make_async_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)),
	__decay_copy(_VSTD::forward<_Args>(__args))...));
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch ( ... ) { if (__policy == launch::async) throw ; }
	#endif

	if (__does_policy_contain(__policy, launch::deferred))
	return _VSTD::__make_deferred_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)),
	__decay_copy(_VSTD::forward<_Args>(__args))...));
	return future<_Rp>{};
	}

	template <class _Fp, class... _Args>
	_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)
	{
	return _VSTD::async(launch::any, _VSTD::forward<_Fp>(__f),
	_VSTD::forward<_Args>(__args)...);
	}

	#endif // _LIBCPP_HAS_NO_VARIADICS

	// shared_future

	template <class _Rp>
	class _LIBCPP_TEMPLATE_VIS shared_future
	{
	__assoc_state<_Rp>* __state_;

	public:
	_LIBCPP_INLINE_VISIBILITY
	shared_future() _NOEXCEPT : __state_(nullptr) {}
	_LIBCPP_INLINE_VISIBILITY
	shared_future(const shared_future& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
	{if (__state_) __state_->__add_shared();}
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	shared_future(future<_Rp>&& __f) _NOEXCEPT : __state_(__f.__state_)
	{__f.__state_ = nullptr;}
	_LIBCPP_INLINE_VISIBILITY
	shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
	{__rhs.__state_ = nullptr;}
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	~shared_future();
	shared_future& operator=(const shared_future& __rhs) _NOEXCEPT;
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
	{
	shared_future(std::move(__rhs)).swap(*this);
	return *this;
	}
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	// retrieving the value
	_LIBCPP_INLINE_VISIBILITY
	const _Rp& get() const {return __state_->copy();}

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

	// functions to check state
	_LIBCPP_INLINE_VISIBILITY
	bool valid() const _NOEXCEPT {return __state_ != nullptr;}

	_LIBCPP_INLINE_VISIBILITY
	void wait() const {__state_->wait();}
	template <class _Rep, class _Period>
	_LIBCPP_INLINE_VISIBILITY
	future_status
	wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
	{return __state_->wait_for(__rel_time);}
	template <class _Clock, class _Duration>
	_LIBCPP_INLINE_VISIBILITY
	future_status
	wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
	{return __state_->wait_until(__abs_time);}
	};

	template <class _Rp>
	shared_future<_Rp>::~shared_future()
	{
	if (__state_)
	__state_->__release_shared();
	}

	template <class _Rp>
	shared_future<_Rp>&
	shared_future<_Rp>::operator=(const shared_future& __rhs) _NOEXCEPT
	{
	if (__rhs.__state_)
	__rhs.__state_->__add_shared();
	if (__state_)
	__state_->__release_shared();
	__state_ = __rhs.__state_;
	return *this;
	}

	template <class _Rp>
	class _LIBCPP_TEMPLATE_VIS shared_future<_Rp&>
	{
	__assoc_state<_Rp&>* __state_;

	public:
	_LIBCPP_INLINE_VISIBILITY
	shared_future() _NOEXCEPT : __state_(nullptr) {}
	_LIBCPP_INLINE_VISIBILITY
	shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
	{if (__state_) __state_->__add_shared();}
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	shared_future(future<_Rp&>&& __f) _NOEXCEPT : __state_(__f.__state_)
	{__f.__state_ = nullptr;}
	_LIBCPP_INLINE_VISIBILITY
	shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
	{__rhs.__state_ = nullptr;}
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	~shared_future();
	shared_future& operator=(const shared_future& __rhs);
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
	{
	shared_future(std::move(__rhs)).swap(*this);
	return *this;
	}
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	// retrieving the value
	_LIBCPP_INLINE_VISIBILITY
	_Rp& get() const {return __state_->copy();}

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

	// functions to check state
	_LIBCPP_INLINE_VISIBILITY
	bool valid() const _NOEXCEPT {return __state_ != nullptr;}

	_LIBCPP_INLINE_VISIBILITY
	void wait() const {__state_->wait();}
	template <class _Rep, class _Period>
	_LIBCPP_INLINE_VISIBILITY
	future_status
	wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
	{return __state_->wait_for(__rel_time);}
	template <class _Clock, class _Duration>
	_LIBCPP_INLINE_VISIBILITY
	future_status
	wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
	{return __state_->wait_until(__abs_time);}
	};

	template <class _Rp>
	shared_future<_Rp&>::~shared_future()
	{
	if (__state_)
	__state_->__release_shared();
	}

	template <class _Rp>
	shared_future<_Rp&>&
	shared_future<_Rp&>::operator=(const shared_future& __rhs)
	{
	if (__rhs.__state_)
	__rhs.__state_->__add_shared();
	if (__state_)
	__state_->__release_shared();
	__state_ = __rhs.__state_;
	return *this;
	}

	template <>
	class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE shared_future<void>
	{
	__assoc_sub_state* __state_;

	public:
	_LIBCPP_INLINE_VISIBILITY
	shared_future() _NOEXCEPT : __state_(nullptr) {}
	_LIBCPP_INLINE_VISIBILITY
	shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
	{if (__state_) __state_->__add_shared();}
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	shared_future(future<void>&& __f) _NOEXCEPT : __state_(__f.__state_)
	{__f.__state_ = nullptr;}
	_LIBCPP_INLINE_VISIBILITY
	shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
	{__rhs.__state_ = nullptr;}
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	~shared_future();
	shared_future& operator=(const shared_future& __rhs);
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
	{
	shared_future(std::move(__rhs)).swap(*this);
	return *this;
	}
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	// retrieving the value
	_LIBCPP_INLINE_VISIBILITY
	void get() const {__state_->copy();}

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

	// functions to check state
	_LIBCPP_INLINE_VISIBILITY
	bool valid() const _NOEXCEPT {return __state_ != nullptr;}

	_LIBCPP_INLINE_VISIBILITY
	void wait() const {__state_->wait();}
	template <class _Rep, class _Period>
	_LIBCPP_INLINE_VISIBILITY
	future_status
	wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
	{return __state_->wait_for(__rel_time);}
	template <class _Clock, class _Duration>
	_LIBCPP_INLINE_VISIBILITY
	future_status
	wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
	{return __state_->wait_until(__abs_time);}
	};

	template <class _Rp>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(shared_future<_Rp>& __x, shared_future<_Rp>& __y) _NOEXCEPT
	{
	__x.swap(__y);
	}

	template <class _Rp>
	inline
	shared_future<_Rp>
	future<_Rp>::share() _NOEXCEPT
	{
	return shared_future<_Rp>(_VSTD::move(*this));
	}

	template <class _Rp>
	inline
	shared_future<_Rp&>
	future<_Rp&>::share() _NOEXCEPT
	{
	return shared_future<_Rp&>(_VSTD::move(*this));
	}

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	inline
	shared_future<void>
	future<void>::share() _NOEXCEPT
	{
	return shared_future<void>(_VSTD::move(*this));
	}

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	_LIBCPP_END_NAMESPACE_STD

	#endif // !_LIBCPP_HAS_NO_THREADS

	#endif // _LIBCPP_FUTURE
	Index: projects/clang700-import/contrib/libc++/include/initializer_list
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/initializer_list (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/initializer_list (revision 337135)
	@@ -1,118 +1,118 @@
	// -- C++ --
	//===----------------------- initializer_list -----------------------------===//
	//
	// 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_INITIALIZER_LIST
	#define _LIBCPP_INITIALIZER_LIST

	/*
	initializer_list synopsis

	namespace std
	{

	template<class E>
	class initializer_list
	{
	public:
	typedef E value_type;
	typedef const E& reference;
	typedef const E& const_reference;
	typedef size_t size_type;

	typedef const E* iterator;
	typedef const E* const_iterator;

	initializer_list() noexcept; // constexpr in C++14

	size_t size() const noexcept; // constexpr in C++14
	const E* begin() const noexcept; // constexpr in C++14
	const E* end() const noexcept; // constexpr in C++14
	};

	template<class E> const E* begin(initializer_list<E> il) noexcept; // constexpr in C++14
	template<class E> const E* end(initializer_list<E> il) noexcept; // constexpr in C++14

	} // std

	*/

	#include <__config>
	#include <cstddef>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	namespace std // purposefully not versioned
	{

	#ifndef _LIBCPP_CXX03_LANG

	template<class _Ep>
	class _LIBCPP_TEMPLATE_VIS initializer_list
	{
	const _Ep* __begin_;
	size_t __size_;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR_AFTER_CXX11
	initializer_list(const _Ep* __b, size_t __s) _NOEXCEPT
	: __begin_(__b),
	__size_(__s)
	{}
	public:
	typedef _Ep value_type;
	typedef const _Ep& reference;
	typedef const _Ep& const_reference;
	typedef size_t size_type;

	typedef const _Ep* iterator;
	typedef const _Ep* const_iterator;

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

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR_AFTER_CXX11
	size_t size() const _NOEXCEPT {return __size_;}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR_AFTER_CXX11
	const _Ep* begin() const _NOEXCEPT {return __begin_;}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR_AFTER_CXX11
	const _Ep* end() const _NOEXCEPT {return __begin_ + __size_;}
	};

	template<class _Ep>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR_AFTER_CXX11
	const _Ep*
	begin(initializer_list<_Ep> __il) _NOEXCEPT
	{
	return __il.begin();
	}

	template<class _Ep>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR_AFTER_CXX11
	const _Ep*
	end(initializer_list<_Ep> __il) _NOEXCEPT
	{
	return __il.end();
	}

	#endif // !defined(_LIBCPP_CXX03_LANG)

	} // std

	#endif // _LIBCPP_INITIALIZER_LIST
	Index: projects/clang700-import/contrib/libc++/include/inttypes.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/inttypes.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/inttypes.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/include/inttypes.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/ios
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/ios (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/ios (revision 337135)
	@@ -1,1045 +1,1048 @@
	// -- C++ --
	//===---------------------------- ios -------------------------------------===//
	//
	// 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_IOS
	#define _LIBCPP_IOS

	/*
	ios synopsis

	#include <iosfwd>

	namespace std
	{

	typedef OFF_T streamoff;
	typedef SZ_T streamsize;
	template <class stateT> class fpos;

	class ios_base
	{
	public:
	class failure;

	typedef T1 fmtflags;
	static constexpr fmtflags boolalpha;
	static constexpr fmtflags dec;
	static constexpr fmtflags fixed;
	static constexpr fmtflags hex;
	static constexpr fmtflags internal;
	static constexpr fmtflags left;
	static constexpr fmtflags oct;
	static constexpr fmtflags right;
	static constexpr fmtflags scientific;
	static constexpr fmtflags showbase;
	static constexpr fmtflags showpoint;
	static constexpr fmtflags showpos;
	static constexpr fmtflags skipws;
	static constexpr fmtflags unitbuf;
	static constexpr fmtflags uppercase;
	static constexpr fmtflags adjustfield;
	static constexpr fmtflags basefield;
	static constexpr fmtflags floatfield;

	typedef T2 iostate;
	static constexpr iostate badbit;
	static constexpr iostate eofbit;
	static constexpr iostate failbit;
	static constexpr iostate goodbit;

	typedef T3 openmode;
	static constexpr openmode app;
	static constexpr openmode ate;
	static constexpr openmode binary;
	static constexpr openmode in;
	static constexpr openmode out;
	static constexpr openmode trunc;

	typedef T4 seekdir;
	static constexpr seekdir beg;
	static constexpr seekdir cur;
	static constexpr seekdir end;

	class Init;

	// 27.5.2.2 fmtflags state:
	fmtflags flags() const;
	fmtflags flags(fmtflags fmtfl);
	fmtflags setf(fmtflags fmtfl);
	fmtflags setf(fmtflags fmtfl, fmtflags mask);
	void unsetf(fmtflags mask);

	streamsize precision() const;
	streamsize precision(streamsize prec);
	streamsize width() const;
	streamsize width(streamsize wide);

	// 27.5.2.3 locales:
	locale imbue(const locale& loc);
	locale getloc() const;

	// 27.5.2.5 storage:
	static int xalloc();
	long& iword(int index);
	void*& pword(int index);

	// destructor
	virtual ~ios_base();

	// 27.5.2.6 callbacks;
	enum event { erase_event, imbue_event, copyfmt_event };
	typedef void (*event_callback)(event, ios_base&, int index);
	void register_callback(event_callback fn, int index);

	ios_base(const ios_base&) = delete;
	ios_base& operator=(const ios_base&) = delete;

	static bool sync_with_stdio(bool sync = true);

	protected:
	ios_base();
	};

	template <class charT, class traits = char_traits<charT> >
	class basic_ios
	: public ios_base
	{
	public:
	// types:
	typedef charT char_type;
	typedef typename traits::int_type int_type; // removed in C++17
	typedef typename traits::pos_type pos_type; // removed in C++17
	typedef typename traits::off_type off_type; // removed in C++17
	typedef traits traits_type;

	operator unspecified-bool-type() const;
	bool operator!() const;
	iostate rdstate() const;
	void clear(iostate state = goodbit);
	void setstate(iostate state);
	bool good() const;
	bool eof() const;
	bool fail() const;
	bool bad() const;

	iostate exceptions() const;
	void exceptions(iostate except);

	// 27.5.4.1 Constructor/destructor:
	explicit basic_ios(basic_streambuf<charT,traits>* sb);
	virtual ~basic_ios();

	// 27.5.4.2 Members:
	basic_ostream<charT,traits>* tie() const;
	basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr);

	basic_streambuf<charT,traits>* rdbuf() const;
	basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb);

	basic_ios& copyfmt(const basic_ios& rhs);

	char_type fill() const;
	char_type fill(char_type ch);

	locale imbue(const locale& loc);

	char narrow(char_type c, char dfault) const;
	char_type widen(char c) const;

	basic_ios(const basic_ios& ) = delete;
	basic_ios& operator=(const basic_ios&) = delete;

	protected:
	basic_ios();
	void init(basic_streambuf<charT,traits>* sb);
	void move(basic_ios& rhs);
	void swap(basic_ios& rhs) noexcept;
	void set_rdbuf(basic_streambuf<charT, traits>* sb);
	};

	// 27.5.5, manipulators:
	ios_base& boolalpha (ios_base& str);
	ios_base& noboolalpha(ios_base& str);
	ios_base& showbase (ios_base& str);
	ios_base& noshowbase (ios_base& str);
	ios_base& showpoint (ios_base& str);
	ios_base& noshowpoint(ios_base& str);
	ios_base& showpos (ios_base& str);
	ios_base& noshowpos (ios_base& str);
	ios_base& skipws (ios_base& str);
	ios_base& noskipws (ios_base& str);
	ios_base& uppercase (ios_base& str);
	ios_base& nouppercase(ios_base& str);
	ios_base& unitbuf (ios_base& str);
	ios_base& nounitbuf (ios_base& str);

	// 27.5.5.2 adjustfield:
	ios_base& internal (ios_base& str);
	ios_base& left (ios_base& str);
	ios_base& right (ios_base& str);

	// 27.5.5.3 basefield:
	ios_base& dec (ios_base& str);
	ios_base& hex (ios_base& str);
	ios_base& oct (ios_base& str);

	// 27.5.5.4 floatfield:
	ios_base& fixed (ios_base& str);
	ios_base& scientific (ios_base& str);
	ios_base& hexfloat (ios_base& str);
	ios_base& defaultfloat(ios_base& str);

	// 27.5.5.5 error reporting:
	enum class io_errc
	{
	stream = 1
	};

	concept_map ErrorCodeEnum<io_errc> { };
	error_code make_error_code(io_errc e) noexcept;
	error_condition make_error_condition(io_errc e) noexcept;
	storage-class-specifier const error_category& iostream_category() noexcept;

	} // std

	*/

	#include <__config>
	#include <iosfwd>
	#include <__locale>
	#include <system_error>

	#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
	#include <atomic> // for __xindex_
	#endif

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	typedef ptrdiff_t streamsize;

	class _LIBCPP_TYPE_VIS ios_base
	{
	public:
	class _LIBCPP_EXCEPTION_ABI failure;

	typedef unsigned int fmtflags;
	static const fmtflags boolalpha = 0x0001;
	static const fmtflags dec = 0x0002;
	static const fmtflags fixed = 0x0004;
	static const fmtflags hex = 0x0008;
	static const fmtflags internal = 0x0010;
	static const fmtflags left = 0x0020;
	static const fmtflags oct = 0x0040;
	static const fmtflags right = 0x0080;
	static const fmtflags scientific = 0x0100;
	static const fmtflags showbase = 0x0200;
	static const fmtflags showpoint = 0x0400;
	static const fmtflags showpos = 0x0800;
	static const fmtflags skipws = 0x1000;
	static const fmtflags unitbuf = 0x2000;
	static const fmtflags uppercase = 0x4000;
	static const fmtflags adjustfield = left \| right \| internal;
	static const fmtflags basefield = dec \| oct \| hex;
	static const fmtflags floatfield = scientific \| fixed;

	typedef unsigned int iostate;
	static const iostate badbit = 0x1;
	static const iostate eofbit = 0x2;
	static const iostate failbit = 0x4;
	static const iostate goodbit = 0x0;

	typedef unsigned int openmode;
	static const openmode app = 0x01;
	static const openmode ate = 0x02;
	static const openmode binary = 0x04;
	static const openmode in = 0x08;
	static const openmode out = 0x10;
	static const openmode trunc = 0x20;

	enum seekdir {beg, cur, end};

	#if _LIBCPP_STD_VER <= 14
	typedef iostate io_state;
	typedef openmode open_mode;
	typedef seekdir seek_dir;

	typedef _VSTD::streamoff streamoff;
	typedef _VSTD::streampos streampos;
	#endif

	class _LIBCPP_TYPE_VIS Init;

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

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

	// 27.5.2.3 locales:
	locale imbue(const locale& __loc);
	locale getloc() const;

	// 27.5.2.5 storage:
	static int xalloc();
	long& iword(int __index);
	void*& pword(int __index);

	// destructor
	virtual ~ios_base();

	// 27.5.2.6 callbacks;
	enum event { erase_event, imbue_event, copyfmt_event };
	typedef void (*event_callback)(event, ios_base&, int __index);
	void register_callback(event_callback __fn, int __index);

	private:
	ios_base(const ios_base&); // = delete;
	ios_base& operator=(const ios_base&); // = delete;

	public:
	static bool sync_with_stdio(bool __sync = true);

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

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

	_LIBCPP_INLINE_VISIBILITY iostate exceptions() const;
	_LIBCPP_INLINE_VISIBILITY void exceptions(iostate __iostate);

	void __set_badbit_and_consider_rethrow();
	void __set_failbit_and_consider_rethrow();

	protected:
	_LIBCPP_INLINE_VISIBILITY
	ios_base() {// purposefully does no initialization
	}

	void init(void* __sb);
	- _LIBCPP_ALWAYS_INLINE void* rdbuf() const {return __rdbuf_;}
	+ _LIBCPP_INLINE_VISIBILITY void* rdbuf() const {return __rdbuf_;}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void rdbuf(void* __sb)
	{
	__rdbuf_ = __sb;
	clear();
	}

	void __call_callbacks(event);
	void copyfmt(const ios_base&);
	void move(ios_base&);
	void swap(ios_base&) _NOEXCEPT;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void set_rdbuf(void* __sb)
	{
	__rdbuf_ = __sb;
	}

	private:
	// All data members must be scalars
	fmtflags __fmtflags_;
	streamsize __precision_;
	streamsize __width_;
	iostate __rdstate_;
	iostate __exceptions_;
	void* __rdbuf_;
	void* __loc_;
	event_callback* __fn_;
	int* __index_;
	size_t __event_size_;
	size_t __event_cap_;
	// TODO(EricWF): Enable this for both Clang and GCC. Currently it is only
	// enabled with clang.
	#if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
	static atomic<int> __xindex_;
	#else
	static int __xindex_;
	#endif
	long* __iarray_;
	size_t __iarray_size_;
	size_t __iarray_cap_;
	void** __parray_;
	size_t __parray_size_;
	size_t __parray_cap_;
	};

	//enum class io_errc
	_LIBCPP_DECLARE_STRONG_ENUM(io_errc)
	{
	stream = 1
	};
	_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc)

	template <>
	struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc> : public true_type { };

	#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
	template <>
	struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc::__lx> : public true_type { };
	#endif

	_LIBCPP_FUNC_VIS
	const error_category& iostream_category() _NOEXCEPT;

	inline _LIBCPP_INLINE_VISIBILITY
	error_code
	make_error_code(io_errc __e) _NOEXCEPT
	{
	return error_code(static_cast<int>(__e), iostream_category());
	}

	inline _LIBCPP_INLINE_VISIBILITY
	error_condition
	make_error_condition(io_errc __e) _NOEXCEPT
	{
	return error_condition(static_cast<int>(__e), iostream_category());
	}

	class _LIBCPP_EXCEPTION_ABI ios_base::failure
	: public system_error
	{
	public:
	explicit failure(const string& __msg, const error_code& __ec = io_errc::stream);
	explicit failure(const char* __msg, const error_code& __ec = io_errc::stream);
	virtual ~failure() throw();
	};

	class _LIBCPP_TYPE_VIS ios_base::Init
	{
	public:
	Init();
	~Init();
	};

	// fmtflags

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base::fmtflags
	ios_base::flags() const
	{
	return __fmtflags_;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base::fmtflags
	ios_base::flags(fmtflags __fmtfl)
	{
	fmtflags __r = __fmtflags_;
	__fmtflags_ = __fmtfl;
	return __r;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base::fmtflags
	ios_base::setf(fmtflags __fmtfl)
	{
	fmtflags __r = __fmtflags_;
	__fmtflags_ \|= __fmtfl;
	return __r;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	void
	ios_base::unsetf(fmtflags __mask)
	{
	__fmtflags_ &= ~__mask;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base::fmtflags
	ios_base::setf(fmtflags __fmtfl, fmtflags __mask)
	{
	fmtflags __r = __fmtflags_;
	unsetf(__mask);
	__fmtflags_ \|= __fmtfl & __mask;
	return __r;
	}

	// precision

	inline _LIBCPP_INLINE_VISIBILITY
	streamsize
	ios_base::precision() const
	{
	return __precision_;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	streamsize
	ios_base::precision(streamsize __prec)
	{
	streamsize __r = __precision_;
	__precision_ = __prec;
	return __r;
	}

	// width

	inline _LIBCPP_INLINE_VISIBILITY
	streamsize
	ios_base::width() const
	{
	return __width_;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	streamsize
	ios_base::width(streamsize __wide)
	{
	streamsize __r = __width_;
	__width_ = __wide;
	return __r;
	}

	// iostate

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base::iostate
	ios_base::rdstate() const
	{
	return __rdstate_;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	void
	ios_base::setstate(iostate __state)
	{
	clear(__rdstate_ \| __state);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	ios_base::good() const
	{
	return __rdstate_ == 0;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	ios_base::eof() const
	{
	return (__rdstate_ & eofbit) != 0;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	ios_base::fail() const
	{
	return (__rdstate_ & (failbit \| badbit)) != 0;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	ios_base::bad() const
	{
	return (__rdstate_ & badbit) != 0;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base::iostate
	ios_base::exceptions() const
	{
	return __exceptions_;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	void
	ios_base::exceptions(iostate __iostate)
	{
	__exceptions_ = __iostate;
	clear(__rdstate_);
	}

	#if defined(_LIBCPP_CXX03_LANG)
	struct _LIBCPP_TYPE_VIS __cxx03_bool {
	typedef void (__cxx03_bool::*__bool_type)();
	void __true_value() {}
	};
	#endif

	template <class _CharT, class _Traits>
	class _LIBCPP_TEMPLATE_VIS basic_ios
	: public ios_base
	{
	public:
	// types:
	typedef _CharT char_type;
	typedef _Traits traits_type;

	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;

	+ static_assert((is_same<_CharT, typename traits_type::char_type>::value),
	+ "traits_type::char_type must be the same type as CharT");
	+
	// __true_value will generate undefined references when linking unless
	// we give it internal linkage.

	#if defined(_LIBCPP_CXX03_LANG)
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	operator __cxx03_bool::__bool_type() const {
	return !fail() ? &__cxx03_bool::__true_value : nullptr;
	}
	#else
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_EXPLICIT operator bool() const {return !fail();}
	#endif

	- _LIBCPP_ALWAYS_INLINE bool operator!() const {return fail();}
	- _LIBCPP_ALWAYS_INLINE iostate rdstate() const {return ios_base::rdstate();}
	- _LIBCPP_ALWAYS_INLINE void clear(iostate __state = goodbit) {ios_base::clear(__state);}
	- _LIBCPP_ALWAYS_INLINE void setstate(iostate __state) {ios_base::setstate(__state);}
	- _LIBCPP_ALWAYS_INLINE bool good() const {return ios_base::good();}
	- _LIBCPP_ALWAYS_INLINE bool eof() const {return ios_base::eof();}
	- _LIBCPP_ALWAYS_INLINE bool fail() const {return ios_base::fail();}
	- _LIBCPP_ALWAYS_INLINE bool bad() const {return ios_base::bad();}
	+ _LIBCPP_INLINE_VISIBILITY bool operator!() const {return fail();}
	+ _LIBCPP_INLINE_VISIBILITY iostate rdstate() const {return ios_base::rdstate();}
	+ _LIBCPP_INLINE_VISIBILITY void clear(iostate __state = goodbit) {ios_base::clear(__state);}
	+ _LIBCPP_INLINE_VISIBILITY void setstate(iostate __state) {ios_base::setstate(__state);}
	+ _LIBCPP_INLINE_VISIBILITY bool good() const {return ios_base::good();}
	+ _LIBCPP_INLINE_VISIBILITY bool eof() const {return ios_base::eof();}
	+ _LIBCPP_INLINE_VISIBILITY bool fail() const {return ios_base::fail();}
	+ _LIBCPP_INLINE_VISIBILITY bool bad() const {return ios_base::bad();}

	- _LIBCPP_ALWAYS_INLINE iostate exceptions() const {return ios_base::exceptions();}
	- _LIBCPP_ALWAYS_INLINE void exceptions(iostate __iostate) {ios_base::exceptions(__iostate);}
	+ _LIBCPP_INLINE_VISIBILITY iostate exceptions() const {return ios_base::exceptions();}
	+ _LIBCPP_INLINE_VISIBILITY void exceptions(iostate __iostate) {ios_base::exceptions(__iostate);}

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

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

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

	basic_ios& copyfmt(const basic_ios& __rhs);

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

	_LIBCPP_INLINE_VISIBILITY
	locale imbue(const locale& __loc);

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

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

	_LIBCPP_INLINE_VISIBILITY
	void move(basic_ios& __rhs);
	#ifndef _LIBCPP_CXX03_LANG
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void move(basic_ios&& __rhs) {move(__rhs);}
	#endif
	_LIBCPP_INLINE_VISIBILITY
	void swap(basic_ios& __rhs) _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	void set_rdbuf(basic_streambuf<char_type, traits_type>* __sb);
	private:
	basic_ostream<char_type, traits_type>* __tie_;
	- mutable int_type __fill_;
	+ mutable int_type __fill_;
	};

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ios<_CharT, _Traits>::basic_ios(basic_streambuf<char_type,traits_type>* __sb)
	{
	init(__sb);
	}

	template <class _CharT, class _Traits>
	basic_ios<_CharT, _Traits>::~basic_ios()
	{
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	basic_ios<_CharT, _Traits>::init(basic_streambuf<char_type, traits_type>* __sb)
	{
	ios_base::init(__sb);
	__tie_ = 0;
	__fill_ = traits_type::eof();
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ostream<_CharT, _Traits>*
	basic_ios<_CharT, _Traits>::tie() const
	{
	return __tie_;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ostream<_CharT, _Traits>*
	basic_ios<_CharT, _Traits>::tie(basic_ostream<char_type, traits_type>* __tiestr)
	{
	basic_ostream<char_type, traits_type>* __r = __tie_;
	__tie_ = __tiestr;
	return __r;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_streambuf<_CharT, _Traits>*
	basic_ios<_CharT, _Traits>::rdbuf() const
	{
	return static_cast<basic_streambuf<char_type, traits_type>*>(ios_base::rdbuf());
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_streambuf<_CharT, _Traits>*
	basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<char_type, traits_type>* __sb)
	{
	basic_streambuf<char_type, traits_type>* __r = rdbuf();
	ios_base::rdbuf(__sb);
	return __r;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	locale
	basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
	{
	locale __r = getloc();
	ios_base::imbue(__loc);
	if (rdbuf())
	rdbuf()->pubimbue(__loc);
	return __r;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	char
	basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const
	{
	return use_facet<ctype<char_type> >(getloc()).narrow(__c, __dfault);
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	_CharT
	basic_ios<_CharT, _Traits>::widen(char __c) const
	{
	return use_facet<ctype<char_type> >(getloc()).widen(__c);
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	_CharT
	basic_ios<_CharT, _Traits>::fill() const
	{
	if (traits_type::eq_int_type(traits_type::eof(), __fill_))
	__fill_ = widen(' ');
	return __fill_;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	_CharT
	basic_ios<_CharT, _Traits>::fill(char_type __ch)
	{
	char_type __r = __fill_;
	__fill_ = __ch;
	return __r;
	}

	template <class _CharT, class _Traits>
	basic_ios<_CharT, _Traits>&
	basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
	{
	if (this != &__rhs)
	{
	__call_callbacks(erase_event);
	ios_base::copyfmt(__rhs);
	__tie_ = __rhs.__tie_;
	__fill_ = __rhs.__fill_;
	__call_callbacks(copyfmt_event);
	exceptions(__rhs.exceptions());
	}
	return *this;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	basic_ios<_CharT, _Traits>::move(basic_ios& __rhs)
	{
	ios_base::move(__rhs);
	__tie_ = __rhs.__tie_;
	__rhs.__tie_ = 0;
	__fill_ = __rhs.__fill_;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	basic_ios<_CharT, _Traits>::swap(basic_ios& __rhs) _NOEXCEPT
	{
	ios_base::swap(__rhs);
	_VSTD::swap(__tie_, __rhs.__tie_);
	_VSTD::swap(__fill_, __rhs.__fill_);
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	basic_ios<_CharT, _Traits>::set_rdbuf(basic_streambuf<char_type, traits_type>* __sb)
	{
	ios_base::set_rdbuf(__sb);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	boolalpha(ios_base& __str)
	{
	__str.setf(ios_base::boolalpha);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	noboolalpha(ios_base& __str)
	{
	__str.unsetf(ios_base::boolalpha);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	showbase(ios_base& __str)
	{
	__str.setf(ios_base::showbase);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	noshowbase(ios_base& __str)
	{
	__str.unsetf(ios_base::showbase);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	showpoint(ios_base& __str)
	{
	__str.setf(ios_base::showpoint);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	noshowpoint(ios_base& __str)
	{
	__str.unsetf(ios_base::showpoint);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	showpos(ios_base& __str)
	{
	__str.setf(ios_base::showpos);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	noshowpos(ios_base& __str)
	{
	__str.unsetf(ios_base::showpos);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	skipws(ios_base& __str)
	{
	__str.setf(ios_base::skipws);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	noskipws(ios_base& __str)
	{
	__str.unsetf(ios_base::skipws);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	uppercase(ios_base& __str)
	{
	__str.setf(ios_base::uppercase);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	nouppercase(ios_base& __str)
	{
	__str.unsetf(ios_base::uppercase);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	unitbuf(ios_base& __str)
	{
	__str.setf(ios_base::unitbuf);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	nounitbuf(ios_base& __str)
	{
	__str.unsetf(ios_base::unitbuf);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	internal(ios_base& __str)
	{
	__str.setf(ios_base::internal, ios_base::adjustfield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	left(ios_base& __str)
	{
	__str.setf(ios_base::left, ios_base::adjustfield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	right(ios_base& __str)
	{
	__str.setf(ios_base::right, ios_base::adjustfield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	dec(ios_base& __str)
	{
	__str.setf(ios_base::dec, ios_base::basefield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	hex(ios_base& __str)
	{
	__str.setf(ios_base::hex, ios_base::basefield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	oct(ios_base& __str)
	{
	__str.setf(ios_base::oct, ios_base::basefield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	fixed(ios_base& __str)
	{
	__str.setf(ios_base::fixed, ios_base::floatfield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	scientific(ios_base& __str)
	{
	__str.setf(ios_base::scientific, ios_base::floatfield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	hexfloat(ios_base& __str)
	{
	__str.setf(ios_base::fixed \| ios_base::scientific, ios_base::floatfield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	defaultfloat(ios_base& __str)
	{
	__str.unsetf(ios_base::floatfield);
	return __str;
	}

	template <class _CharT, class _Traits>
	class __save_flags
	{
	typedef basic_ios<_CharT, _Traits> __stream_type;
	typedef typename __stream_type::fmtflags fmtflags;

	__stream_type& __stream_;
	fmtflags __fmtflags_;
	_CharT __fill_;

	__save_flags(const __save_flags&);
	__save_flags& operator=(const __save_flags&);
	public:
	_LIBCPP_INLINE_VISIBILITY
	explicit __save_flags(__stream_type& __stream)
	: __stream_(__stream),
	__fmtflags_(__stream.flags()),
	__fill_(__stream.fill())
	{}
	_LIBCPP_INLINE_VISIBILITY
	~__save_flags()
	{
	__stream_.flags(__fmtflags_);
	__stream_.fill(__fill_);
	}
	};

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_IOS
	Index: projects/clang700-import/contrib/libc++/include/istream
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/istream (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/istream (revision 337135)
	@@ -1,1692 +1,1476 @@
	// -- C++ --
	//===--------------------------- istream ----------------------------------===//
	//
	// 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_ISTREAM
	#define _LIBCPP_ISTREAM

	/*
	istream synopsis

	template <class charT, class traits = char_traits<charT> >
	class basic_istream
	: virtual public basic_ios<charT,traits>
	{
	public:
	// types (inherited from basic_ios (27.5.4)):
	typedef charT char_type;
	typedef traits traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;

	// 27.7.1.1.1 Constructor/destructor:
	explicit basic_istream(basic_streambuf<char_type, traits_type>* sb);
	basic_istream(basic_istream&& rhs);
	virtual ~basic_istream();

	// 27.7.1.1.2 Assign/swap:
	basic_istream& operator=(basic_istream&& rhs);
	void swap(basic_istream& rhs);

	// 27.7.1.1.3 Prefix/suffix:
	class sentry;

	// 27.7.1.2 Formatted input:
	basic_istream& operator>>(basic_istream& (*pf)(basic_istream&));
	basic_istream& operator>>(basic_ios<char_type, traits_type>&
	(*pf)(basic_ios<char_type, traits_type>&));
	basic_istream& operator>>(ios_base& (*pf)(ios_base&));
	basic_istream& operator>>(basic_streambuf<char_type, traits_type>* sb);
	basic_istream& operator>>(bool& n);
	basic_istream& operator>>(short& n);
	basic_istream& operator>>(unsigned short& n);
	basic_istream& operator>>(int& n);
	basic_istream& operator>>(unsigned int& n);
	basic_istream& operator>>(long& n);
	basic_istream& operator>>(unsigned long& n);
	basic_istream& operator>>(long long& n);
	basic_istream& operator>>(unsigned long long& n);
	basic_istream& operator>>(float& f);
	basic_istream& operator>>(double& f);
	basic_istream& operator>>(long double& f);
	basic_istream& operator>>(void*& p);

	// 27.7.1.3 Unformatted input:
	streamsize gcount() const;
	int_type get();
	basic_istream& get(char_type& c);
	basic_istream& get(char_type* s, streamsize n);
	basic_istream& get(char_type* s, streamsize n, char_type delim);
	basic_istream& get(basic_streambuf<char_type,traits_type>& sb);
	basic_istream& get(basic_streambuf<char_type,traits_type>& sb, char_type delim);

	basic_istream& getline(char_type* s, streamsize n);
	basic_istream& getline(char_type* s, streamsize n, char_type delim);

	basic_istream& ignore(streamsize n = 1, int_type delim = traits_type::eof());
	int_type peek();
	basic_istream& read (char_type* s, streamsize n);
	streamsize readsome(char_type* s, streamsize n);

	basic_istream& putback(char_type c);
	basic_istream& unget();
	int sync();

	pos_type tellg();
	basic_istream& seekg(pos_type);
	basic_istream& seekg(off_type, ios_base::seekdir);
	protected:
	basic_istream(const basic_istream& rhs) = delete;
	basic_istream(basic_istream&& rhs);
	// 27.7.2.1.2 Assign/swap:
	basic_istream& operator=(const basic_istream& rhs) = delete;
	basic_istream& operator=(basic_istream&& rhs);
	void swap(basic_istream& rhs);
	};

	// 27.7.1.2.3 character extraction templates:
	template<class charT, class traits>
	basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&, charT&);

	template<class traits>
	basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, unsigned char&);

	template<class traits>
	basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, signed char&);

	template<class charT, class traits>
	basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&, charT*);

	template<class traits>
	basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, unsigned char*);

	template<class traits>
	basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, signed char*);

	template <class charT, class traits>
	void
	swap(basic_istream<charT, traits>& x, basic_istream<charT, traits>& y);

	typedef basic_istream<char> istream;
	typedef basic_istream<wchar_t> wistream;

	template <class charT, class traits = char_traits<charT> >
	class basic_iostream :
	public basic_istream<charT,traits>,
	public basic_ostream<charT,traits>
	{
	public:
	// types:
	typedef charT char_type;
	typedef traits traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;

	// constructor/destructor
	explicit basic_iostream(basic_streambuf<char_type, traits_type>* sb);
	basic_iostream(basic_iostream&& rhs);
	virtual ~basic_iostream();

	// assign/swap
	basic_iostream& operator=(basic_iostream&& rhs);
	void swap(basic_iostream& rhs);
	};

	template <class charT, class traits>
	void
	swap(basic_iostream<charT, traits>& x, basic_iostream<charT, traits>& y);

	typedef basic_iostream<char> iostream;
	typedef basic_iostream<wchar_t> wiostream;

	template <class charT, class traits>
	basic_istream<charT,traits>&
	ws(basic_istream<charT,traits>& is);

	template <class charT, class traits, class T>
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>&& is, T& x);

	} // std

	*/

	#include <__config>
	#include <ostream>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _CharT, class _Traits>
	class _LIBCPP_TEMPLATE_VIS basic_istream
	: virtual public basic_ios<_CharT, _Traits>
	{
	streamsize __gc_;
	public:
	// types (inherited from basic_ios (27.5.4)):
	typedef _CharT char_type;
	typedef _Traits traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;

	// 27.7.1.1.1 Constructor/destructor:
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	explicit basic_istream(basic_streambuf<char_type, traits_type>* __sb) : __gc_(0)
	{ this->init(__sb); }
	virtual ~basic_istream();
	protected:
	#ifndef _LIBCPP_CXX03_LANG
	inline _LIBCPP_INLINE_VISIBILITY
	basic_istream(basic_istream&& __rhs);

	// 27.7.1.1.2 Assign/swap:
	inline _LIBCPP_INLINE_VISIBILITY
	basic_istream& operator=(basic_istream&& __rhs);
	#endif

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	void swap(basic_istream& __rhs) {
	_VSTD::swap(__gc_, __rhs.__gc_);
	basic_ios<char_type, traits_type>::swap(__rhs);
	}

	#ifndef _LIBCPP_CXX03_LANG
	basic_istream (const basic_istream& __rhs) = delete;
	basic_istream& operator=(const basic_istream& __rhs) = delete;
	#endif
	public:

	// 27.7.1.1.3 Prefix/suffix:
	class _LIBCPP_TEMPLATE_VIS sentry;

	// 27.7.1.2 Formatted input:
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&))
	{ return __pf(*this); }

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	basic_istream& operator>>(basic_ios<char_type, traits_type>&
	(*__pf)(basic_ios<char_type, traits_type>&))
	{ __pf(this); return this; }

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	basic_istream& operator>>(ios_base& (*__pf)(ios_base&))
	{ __pf(this); return this; }

	basic_istream& operator>>(basic_streambuf<char_type, traits_type>* __sb);
	basic_istream& operator>>(bool& __n);
	basic_istream& operator>>(short& __n);
	basic_istream& operator>>(unsigned short& __n);
	basic_istream& operator>>(int& __n);
	basic_istream& operator>>(unsigned int& __n);
	basic_istream& operator>>(long& __n);
	basic_istream& operator>>(unsigned long& __n);
	basic_istream& operator>>(long long& __n);
	basic_istream& operator>>(unsigned long long& __n);
	basic_istream& operator>>(float& __f);
	basic_istream& operator>>(double& __f);
	basic_istream& operator>>(long double& __f);
	basic_istream& operator>>(void*& __p);

	// 27.7.1.3 Unformatted input:
	_LIBCPP_INLINE_VISIBILITY
	streamsize gcount() const {return __gc_;}
	int_type get();

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	basic_istream& get(char_type& __c) {
	int_type __ch = get();
	if (__ch != traits_type::eof())
	__c = traits_type::to_char_type(__ch);
	return *this;
	}

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	basic_istream& get(char_type* __s, streamsize __n)
	{ return get(__s, __n, this->widen('\n')); }

	basic_istream& get(char_type* __s, streamsize __n, char_type __dlm);

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	basic_istream& get(basic_streambuf<char_type, traits_type>& __sb)
	{ return get(__sb, this->widen('\n')); }

	basic_istream& get(basic_streambuf<char_type, traits_type>& __sb, char_type __dlm);

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	basic_istream& getline(char_type* __s, streamsize __n)
	{ return getline(__s, __n, this->widen('\n')); }

	basic_istream& getline(char_type* __s, streamsize __n, char_type __dlm);

	basic_istream& ignore(streamsize __n = 1, int_type __dlm = traits_type::eof());
	int_type peek();
	basic_istream& read (char_type* __s, streamsize __n);
	streamsize readsome(char_type* __s, streamsize __n);

	basic_istream& putback(char_type __c);
	basic_istream& unget();
	int sync();

	pos_type tellg();
	basic_istream& seekg(pos_type __pos);
	basic_istream& seekg(off_type __off, ios_base::seekdir __dir);
	};

	template <class _CharT, class _Traits>
	class _LIBCPP_TEMPLATE_VIS basic_istream<_CharT, _Traits>::sentry
	{
	bool __ok_;

	sentry(const sentry&); // = delete;
	sentry& operator=(const sentry&); // = delete;

	public:
	explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
	// ~sentry() = default;

	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_EXPLICIT
	operator bool() const {return __ok_;}
	};

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>::sentry::sentry(basic_istream<_CharT, _Traits>& __is,
	bool __noskipws)
	: __ok_(false)
	{
	if (__is.good())
	{
	if (__is.tie())
	__is.tie()->flush();
	if (!__noskipws && (__is.flags() & ios_base::skipws))
	{
	typedef istreambuf_iterator<_CharT, _Traits> _Ip;
	const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
	_Ip __i(__is);
	_Ip __eof;
	for (; __i != __eof; ++__i)
	if (!__ct.is(__ct.space, *__i))
	break;
	if (__i == __eof)
	__is.setstate(ios_base::failbit \| ios_base::eofbit);
	}
	__ok_ = __is.good();
	}
	else
	__is.setstate(ios_base::failbit);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>::basic_istream(basic_istream&& __rhs)
	: __gc_(__rhs.__gc_)
	{
	__rhs.__gc_ = 0;
	this->move(__rhs);
	}

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::operator=(basic_istream&& __rhs)
	{
	swap(__rhs);
	return *this;
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>::~basic_istream()
	{
	}

	-template <class _CharT, class _Traits>
	+template <class _Tp, class _CharT, class _Traits>
	+_LIBCPP_INLINE_VISIBILITY
	basic_istream<_CharT, _Traits>&
	-basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n)
	-{
	+__input_arithmetic(basic_istream<_CharT, _Traits>& __is, _Tp& __n) {
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	- sentry __s(*this);
	+ typename basic_istream<_CharT, _Traits>::sentry __s(__is);
	if (__s)
	{
	- typedef istreambuf_iterator<char_type, traits_type> _Ip;
	- typedef num_get<char_type, _Ip> _Fp;
	+ typedef istreambuf_iterator<_CharT, _Traits> _Ip;
	+ typedef num_get<_CharT, _Ip> _Fp;
	ios_base::iostate __err = ios_base::goodbit;
	- use_facet<_Fp>(this->getloc()).get(_Ip(this), _Ip(), this, __err, __n);
	- this->setstate(__err);
	+ use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __err, __n);
	+ __is.setstate(__err);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	- this->__set_badbit_and_consider_rethrow();
	+ __is.__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	- return *this;
	+ return __is;
	}

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	+basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n)
	+{
	+ return _VSTD::__input_arithmetic<unsigned short>(*this, __n);
	+}
	+
	+template <class _CharT, class _Traits>
	+basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::operator>>(unsigned int& __n)
	{
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- try
	- {
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- sentry __s(*this);
	- if (__s)
	- {
	- typedef istreambuf_iterator<char_type, traits_type> _Ip;
	- typedef num_get<char_type, _Ip> _Fp;
	- ios_base::iostate __err = ios_base::goodbit;
	- use_facet<_Fp>(this->getloc()).get(_Ip(this), _Ip(), this, __err, __n);
	- this->setstate(__err);
	- }
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- }
	- catch (...)
	- {
	- this->__set_badbit_and_consider_rethrow();
	- }
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- return *this;
	+ return _VSTD::__input_arithmetic<unsigned int>(*this, __n);
	}

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::operator>>(long& __n)
	{
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- try
	- {
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- sentry __s(*this);
	- if (__s)
	- {
	- typedef istreambuf_iterator<char_type, traits_type> _Ip;
	- typedef num_get<char_type, _Ip> _Fp;
	- ios_base::iostate __err = ios_base::goodbit;
	- use_facet<_Fp>(this->getloc()).get(_Ip(this), _Ip(), this, __err, __n);
	- this->setstate(__err);
	- }
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- }
	- catch (...)
	- {
	- this->__set_badbit_and_consider_rethrow();
	- }
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- return *this;
	+ return _VSTD::__input_arithmetic<long>(*this, __n);
	}

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::operator>>(unsigned long& __n)
	{
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- try
	- {
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- sentry __s(*this);
	- if (__s)
	- {
	- typedef istreambuf_iterator<char_type, traits_type> _Ip;
	- typedef num_get<char_type, _Ip> _Fp;
	- ios_base::iostate __err = ios_base::goodbit;
	- use_facet<_Fp>(this->getloc()).get(_Ip(this), _Ip(), this, __err, __n);
	- this->setstate(__err);
	- }
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- }
	- catch (...)
	- {
	- this->__set_badbit_and_consider_rethrow();
	- }
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- return *this;
	+ return _VSTD::__input_arithmetic<unsigned long>(*this, __n);
	}

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::operator>>(long long& __n)
	{
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- try
	- {
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- sentry __s(*this);
	- if (__s)
	- {
	- typedef istreambuf_iterator<char_type, traits_type> _Ip;
	- typedef num_get<char_type, _Ip> _Fp;
	- ios_base::iostate __err = ios_base::goodbit;
	- use_facet<_Fp>(this->getloc()).get(_Ip(this), _Ip(), this, __err, __n);
	- this->setstate(__err);
	- }
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- }
	- catch (...)
	- {
	- this->__set_badbit_and_consider_rethrow();
	- }
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- return *this;
	+ return _VSTD::__input_arithmetic<long long>(*this, __n);
	}

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::operator>>(unsigned long long& __n)
	{
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- try
	- {
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- sentry __s(*this);
	- if (__s)
	- {
	- typedef istreambuf_iterator<char_type, traits_type> _Ip;
	- typedef num_get<char_type, _Ip> _Fp;
	- ios_base::iostate __err = ios_base::goodbit;
	- use_facet<_Fp>(this->getloc()).get(_Ip(this), _Ip(), this, __err, __n);
	- this->setstate(__err);
	- }
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- }
	- catch (...)
	- {
	- this->__set_badbit_and_consider_rethrow();
	- }
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- return *this;
	+ return _VSTD::__input_arithmetic<unsigned long long>(*this, __n);
	}

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::operator>>(float& __n)
	{
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- try
	- {
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- sentry __s(*this);
	- if (__s)
	- {
	- typedef istreambuf_iterator<char_type, traits_type> _Ip;
	- typedef num_get<char_type, _Ip> _Fp;
	- ios_base::iostate __err = ios_base::goodbit;
	- use_facet<_Fp>(this->getloc()).get(_Ip(this), _Ip(), this, __err, __n);
	- this->setstate(__err);
	- }
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- }
	- catch (...)
	- {
	- this->__set_badbit_and_consider_rethrow();
	- }
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- return *this;
	+ return _VSTD::__input_arithmetic<float>(*this, __n);
	}

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::operator>>(double& __n)
	{
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- try
	- {
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- sentry __s(*this);
	- if (__s)
	- {
	- typedef istreambuf_iterator<char_type, traits_type> _Ip;
	- typedef num_get<char_type, _Ip> _Fp;
	- ios_base::iostate __err = ios_base::goodbit;
	- use_facet<_Fp>(this->getloc()).get(_Ip(this), _Ip(), this, __err, __n);
	- this->setstate(__err);
	- }
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- }
	- catch (...)
	- {
	- this->__set_badbit_and_consider_rethrow();
	- }
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- return *this;
	+ return _VSTD::__input_arithmetic<double>(*this, __n);
	}

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::operator>>(long double& __n)
	{
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- try
	- {
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- sentry __s(*this);
	- if (__s)
	- {
	- typedef istreambuf_iterator<char_type, traits_type> _Ip;
	- typedef num_get<char_type, _Ip> _Fp;
	- ios_base::iostate __err = ios_base::goodbit;
	- use_facet<_Fp>(this->getloc()).get(_Ip(this), _Ip(), this, __err, __n);
	- this->setstate(__err);
	- }
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- }
	- catch (...)
	- {
	- this->__set_badbit_and_consider_rethrow();
	- }
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- return *this;
	+ return _VSTD::__input_arithmetic<long double>(*this, __n);
	}

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::operator>>(bool& __n)
	{
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- try
	- {
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- sentry __s(*this);
	- if (__s)
	- {
	- typedef istreambuf_iterator<char_type, traits_type> _Ip;
	- typedef num_get<char_type, _Ip> _Fp;
	- ios_base::iostate __err = ios_base::goodbit;
	- use_facet<_Fp>(this->getloc()).get(_Ip(this), _Ip(), this, __err, __n);
	- this->setstate(__err);
	- }
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- }
	- catch (...)
	- {
	- this->__set_badbit_and_consider_rethrow();
	- }
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- return *this;
	+ return _VSTD::__input_arithmetic<bool>(*this, __n);
	}

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::operator>>(void*& __n)
	{
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- try
	- {
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- sentry __s(*this);
	- if (__s)
	- {
	- typedef istreambuf_iterator<char_type, traits_type> _Ip;
	- typedef num_get<char_type, _Ip> _Fp;
	- ios_base::iostate __err = ios_base::goodbit;
	- use_facet<_Fp>(this->getloc()).get(_Ip(this), _Ip(), this, __err, __n);
	- this->setstate(__err);
	- }
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- }
	- catch (...)
	- {
	- this->__set_badbit_and_consider_rethrow();
	- }
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- return *this;
	+ return _VSTD::__input_arithmetic<void>(this, __n);
	}

	-template <class _CharT, class _Traits>
	+template <class _Tp, class _CharT, class _Traits>
	+_LIBCPP_INLINE_VISIBILITY
	basic_istream<_CharT, _Traits>&
	-basic_istream<_CharT, _Traits>::operator>>(short& __n)
	-{
	+__input_arithmetic_with_numeric_limits(basic_istream<_CharT, _Traits>& __is, _Tp& __n) {
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	- sentry __s(*this);
	+ typename basic_istream<_CharT, _Traits>::sentry __s(__is);
	if (__s)
	{
	- typedef istreambuf_iterator<char_type, traits_type> _Ip;
	- typedef num_get<char_type, _Ip> _Fp;
	+ typedef istreambuf_iterator<_CharT, _Traits> _Ip;
	+ typedef num_get<_CharT, _Ip> _Fp;
	ios_base::iostate __err = ios_base::goodbit;
	long __temp;
	- use_facet<_Fp>(this->getloc()).get(_Ip(this), _Ip(), this, __err, __temp);
	- if (__temp < numeric_limits<short>::min())
	+ use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __err, __temp);
	+ if (__temp < numeric_limits<_Tp>::min())
	{
	__err \|= ios_base::failbit;
	- __n = numeric_limits<short>::min();
	+ __n = numeric_limits<_Tp>::min();
	}
	- else if (__temp > numeric_limits<short>::max())
	+ else if (__temp > numeric_limits<_Tp>::max())
	{
	__err \|= ios_base::failbit;
	- __n = numeric_limits<short>::max();
	+ __n = numeric_limits<_Tp>::max();
	}
	else
	- __n = static_cast<short>(__temp);
	- this->setstate(__err);
	+ __n = static_cast<_Tp>(__temp);
	+ __is.setstate(__err);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	- this->__set_badbit_and_consider_rethrow();
	+ __is.__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	- return *this;
	+ return __is;
	}

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	+basic_istream<_CharT, _Traits>::operator>>(short& __n)
	+{
	+ return _VSTD::__input_arithmetic_with_numeric_limits<short>(*this, __n);
	+}
	+
	+template <class _CharT, class _Traits>
	+basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::operator>>(int& __n)
	{
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- try
	- {
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- sentry __s(*this);
	- if (__s)
	- {
	- typedef istreambuf_iterator<char_type, traits_type> _Ip;
	- typedef num_get<char_type, _Ip> _Fp;
	- ios_base::iostate __err = ios_base::goodbit;
	- long __temp;
	- use_facet<_Fp>(this->getloc()).get(_Ip(this), _Ip(), this, __err, __temp);
	- if (__temp < numeric_limits<int>::min())
	- {
	- __err \|= ios_base::failbit;
	- __n = numeric_limits<int>::min();
	- }
	- else if (__temp > numeric_limits<int>::max())
	- {
	- __err \|= ios_base::failbit;
	- __n = numeric_limits<int>::max();
	- }
	- else
	- __n = static_cast<int>(__temp);
	- this->setstate(__err);
	- }
	-#ifndef _LIBCPP_NO_EXCEPTIONS
	- }
	- catch (...)
	- {
	- this->__set_badbit_and_consider_rethrow();
	- }
	-#endif // _LIBCPP_NO_EXCEPTIONS
	- return *this;
	+ return _VSTD::__input_arithmetic_with_numeric_limits<int>(*this, __n);
	}

	template<class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is, _CharT* __s)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
	if (__sen)
	{
	streamsize __n = __is.width();
	if (__n <= 0)
	__n = numeric_limits<streamsize>::max() / sizeof(_CharT) - 1;
	streamsize __c = 0;
	const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
	ios_base::iostate __err = ios_base::goodbit;
	while (__c < __n-1)
	{
	typename _Traits::int_type __i = __is.rdbuf()->sgetc();
	if (_Traits::eq_int_type(__i, _Traits::eof()))
	{
	__err \|= ios_base::eofbit;
	break;
	}
	_CharT __ch = _Traits::to_char_type(__i);
	if (__ct.is(__ct.space, __ch))
	break;
	*__s++ = __ch;
	++__c;
	__is.rdbuf()->sbumpc();
	}
	*__s = _CharT();
	__is.width(0);
	if (__c == 0)
	__err \|= ios_base::failbit;
	__is.setstate(__err);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__is.__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return __is;
	}

	template<class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_istream<char, _Traits>&
	operator>>(basic_istream<char, _Traits>& __is, unsigned char* __s)
	{
	return __is >> (char*)__s;
	}

	template<class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_istream<char, _Traits>&
	operator>>(basic_istream<char, _Traits>& __is, signed char* __s)
	{
	return __is >> (char*)__s;
	}

	template<class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
	if (__sen)
	{
	typename _Traits::int_type __i = __is.rdbuf()->sbumpc();
	if (_Traits::eq_int_type(__i, _Traits::eof()))
	__is.setstate(ios_base::eofbit \| ios_base::failbit);
	else
	__c = _Traits::to_char_type(__i);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__is.__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return __is;
	}

	template<class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_istream<char, _Traits>&
	operator>>(basic_istream<char, _Traits>& __is, unsigned char& __c)
	{
	return __is >> (char&)__c;
	}

	template<class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_istream<char, _Traits>&
	operator>>(basic_istream<char, _Traits>& __is, signed char& __c)
	{
	return __is >> (char&)__c;
	}

	template<class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_type>* __sb)
	{
	__gc_ = 0;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this, true);
	if (__s)
	{
	if (__sb)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	ios_base::iostate __err = ios_base::goodbit;
	while (true)
	{
	typename traits_type::int_type __i = this->rdbuf()->sgetc();
	if (traits_type::eq_int_type(__i, _Traits::eof()))
	{
	__err \|= ios_base::eofbit;
	break;
	}
	if (traits_type::eq_int_type(
	__sb->sputc(traits_type::to_char_type(__i)),
	traits_type::eof()))
	break;
	++__gc_;
	this->rdbuf()->sbumpc();
	}
	if (__gc_ == 0)
	__err \|= ios_base::failbit;
	this->setstate(__err);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	if (__gc_ == 0)
	this->__set_failbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}
	else
	this->setstate(ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template<class _CharT, class _Traits>
	typename basic_istream<_CharT, _Traits>::int_type
	basic_istream<_CharT, _Traits>::get()
	{
	__gc_ = 0;
	int_type __r = traits_type::eof();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this, true);
	if (__s)
	{
	__r = this->rdbuf()->sbumpc();
	if (traits_type::eq_int_type(__r, traits_type::eof()))
	this->setstate(ios_base::failbit \| ios_base::eofbit);
	else
	__gc_ = 1;
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return __r;
	}

	template<class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __dlm)
	{
	__gc_ = 0;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __sen(*this, true);
	if (__sen)
	{
	if (__n > 0)
	{
	ios_base::iostate __err = ios_base::goodbit;
	while (__gc_ < __n-1)
	{
	int_type __i = this->rdbuf()->sgetc();
	if (traits_type::eq_int_type(__i, traits_type::eof()))
	{
	__err \|= ios_base::eofbit;
	break;
	}
	char_type __ch = traits_type::to_char_type(__i);
	if (traits_type::eq(__ch, __dlm))
	break;
	*__s++ = __ch;
	++__gc_;
	this->rdbuf()->sbumpc();
	}
	- *__s = char_type();
	if (__gc_ == 0)
	__err \|= ios_base::failbit;
	this->setstate(__err);
	}
	else
	this->setstate(ios_base::failbit);
	}
	+ 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
	return *this;
	}

	template<class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __sb,
	char_type __dlm)
	{
	__gc_ = 0;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __sen(*this, true);
	if (__sen)
	{
	ios_base::iostate __err = ios_base::goodbit;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	while (true)
	{
	typename traits_type::int_type __i = this->rdbuf()->sgetc();
	if (traits_type::eq_int_type(__i, traits_type::eof()))
	{
	__err \|= ios_base::eofbit;
	break;
	}
	char_type __ch = traits_type::to_char_type(__i);
	if (traits_type::eq(__ch, __dlm))
	break;
	if (traits_type::eq_int_type(__sb.sputc(__ch), traits_type::eof()))
	break;
	++__gc_;
	this->rdbuf()->sbumpc();
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	if (__gc_ == 0)
	__err \|= ios_base::failbit;
	this->setstate(__err);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template<class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_type __dlm)
	{
	__gc_ = 0;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __sen(*this, true);
	if (__sen)
	{
	ios_base::iostate __err = ios_base::goodbit;
	while (true)
	{
	typename traits_type::int_type __i = this->rdbuf()->sgetc();
	if (traits_type::eq_int_type(__i, traits_type::eof()))
	{
	__err \|= ios_base::eofbit;
	break;
	}
	char_type __ch = traits_type::to_char_type(__i);
	if (traits_type::eq(__ch, __dlm))
	{
	this->rdbuf()->sbumpc();
	++__gc_;
	break;
	}
	if (__gc_ >= __n-1)
	{
	__err \|= ios_base::failbit;
	break;
	}
	*__s++ = __ch;
	this->rdbuf()->sbumpc();
	++__gc_;
	}
	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
	return *this;
	}

	template<class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm)
	{
	__gc_ = 0;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __sen(*this, true);
	if (__sen)
	{
	ios_base::iostate __err = ios_base::goodbit;
	if (__n == numeric_limits<streamsize>::max())
	{
	while (true)
	{
	typename traits_type::int_type __i = this->rdbuf()->sbumpc();
	if (traits_type::eq_int_type(__i, traits_type::eof()))
	{
	__err \|= ios_base::eofbit;
	break;
	}
	++__gc_;
	if (traits_type::eq_int_type(__i, __dlm))
	break;
	}
	}
	else
	{
	while (__gc_ < __n)
	{
	typename traits_type::int_type __i = this->rdbuf()->sbumpc();
	if (traits_type::eq_int_type(__i, traits_type::eof()))
	{
	__err \|= ios_base::eofbit;
	break;
	}
	++__gc_;
	if (traits_type::eq_int_type(__i, __dlm))
	break;
	}
	}
	this->setstate(__err);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template<class _CharT, class _Traits>
	typename basic_istream<_CharT, _Traits>::int_type
	basic_istream<_CharT, _Traits>::peek()
	{
	__gc_ = 0;
	int_type __r = traits_type::eof();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __sen(*this, true);
	if (__sen)
	{
	__r = this->rdbuf()->sgetc();
	if (traits_type::eq_int_type(__r, traits_type::eof()))
	this->setstate(ios_base::eofbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return __r;
	}

	template<class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n)
	{
	__gc_ = 0;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __sen(*this, true);
	if (__sen)
	{
	__gc_ = this->rdbuf()->sgetn(__s, __n);
	if (__gc_ != __n)
	this->setstate(ios_base::failbit \| ios_base::eofbit);
	}
	else
	this->setstate(ios_base::failbit);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template<class _CharT, class _Traits>
	streamsize
	basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
	{
	__gc_ = 0;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __sen(*this, true);
	if (__sen)
	{
	streamsize __c = this->rdbuf()->in_avail();
	switch (__c)
	{
	case -1:
	this->setstate(ios_base::eofbit);
	break;
	case 0:
	break;
	default:
	read(__s, _VSTD::min(__c, __n));
	break;
	}
	}
	else
	this->setstate(ios_base::failbit);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return __gc_;
	}

	template<class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::putback(char_type __c)
	{
	__gc_ = 0;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	this->clear(this->rdstate() & ~ios_base::eofbit);
	sentry __sen(*this, true);
	if (__sen)
	{
	if (this->rdbuf() == 0 \|\| this->rdbuf()->sputbackc(__c) == traits_type::eof())
	this->setstate(ios_base::badbit);
	}
	else
	this->setstate(ios_base::failbit);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template<class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::unget()
	{
	__gc_ = 0;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	this->clear(this->rdstate() & ~ios_base::eofbit);
	sentry __sen(*this, true);
	if (__sen)
	{
	if (this->rdbuf() == 0 \|\| this->rdbuf()->sungetc() == traits_type::eof())
	this->setstate(ios_base::badbit);
	}
	else
	this->setstate(ios_base::failbit);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template<class _CharT, class _Traits>
	int
	basic_istream<_CharT, _Traits>::sync()
	{
	int __r = 0;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __sen(*this, true);
	if (__sen)
	{
	if (this->rdbuf() == 0)
	return -1;
	if (this->rdbuf()->pubsync() == -1)
	{
	this->setstate(ios_base::badbit);
	return -1;
	}
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return __r;
	}

	template<class _CharT, class _Traits>
	typename basic_istream<_CharT, _Traits>::pos_type
	basic_istream<_CharT, _Traits>::tellg()
	{
	pos_type __r(-1);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __sen(*this, true);
	if (__sen)
	__r = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return __r;
	}

	template<class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::seekg(pos_type __pos)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	this->clear(this->rdstate() & ~ios_base::eofbit);
	sentry __sen(*this, true);
	if (__sen)
	{
	if (this->rdbuf()->pubseekpos(__pos, ios_base::in) == pos_type(-1))
	this->setstate(ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template<class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	this->clear(this->rdstate() & ~ios_base::eofbit);
	sentry __sen(*this, true);
	if (__sen)
	{
	if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::in) == pos_type(-1))
	this->setstate(ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	ws(basic_istream<_CharT, _Traits>& __is)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
	if (__sen)
	{
	const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
	while (true)
	{
	typename _Traits::int_type __i = __is.rdbuf()->sgetc();
	if (_Traits::eq_int_type(__i, _Traits::eof()))
	{
	__is.setstate(ios_base::eofbit);
	break;
	}
	if (!__ct.is(__ct.space, _Traits::to_char_type(__i)))
	break;
	__is.rdbuf()->sbumpc();
	}
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__is.__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return __is;
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits, class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp&& __x)
	{
	__is >> _VSTD::forward<_Tp>(__x);
	return __is;
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits>
	class _LIBCPP_TEMPLATE_VIS basic_iostream
	: public basic_istream<_CharT, _Traits>,
	public basic_ostream<_CharT, _Traits>
	{
	public:
	// types:
	typedef _CharT char_type;
	typedef _Traits traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;

	// constructor/destructor
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	explicit basic_iostream(basic_streambuf<char_type, traits_type>* __sb)
	: basic_istream<_CharT, _Traits>(__sb)
	{}

	virtual ~basic_iostream();
	protected:
	#ifndef _LIBCPP_CXX03_LANG
	inline _LIBCPP_INLINE_VISIBILITY
	basic_iostream(basic_iostream&& __rhs);

	// assign/swap
	inline _LIBCPP_INLINE_VISIBILITY
	basic_iostream& operator=(basic_iostream&& __rhs);
	#endif
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	void swap(basic_iostream& __rhs)
	{ basic_istream<char_type, traits_type>::swap(__rhs); }
	public:
	};

	#ifndef _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits>
	basic_iostream<_CharT, _Traits>::basic_iostream(basic_iostream&& __rhs)
	: basic_istream<_CharT, _Traits>(_VSTD::move(__rhs))
	{
	}

	template <class _CharT, class _Traits>
	basic_iostream<_CharT, _Traits>&
	basic_iostream<_CharT, _Traits>::operator=(basic_iostream&& __rhs)
	{
	swap(__rhs);
	return *this;
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits>
	basic_iostream<_CharT, _Traits>::~basic_iostream()
	{
	}

	template<class _CharT, class _Traits, class _Allocator>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	basic_string<_CharT, _Traits, _Allocator>& __str)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
	if (__sen)
	{
	__str.clear();
	streamsize __n = __is.width();
	if (__n <= 0)
	__n = __str.max_size();
	if (__n <= 0)
	__n = numeric_limits<streamsize>::max();
	streamsize __c = 0;
	const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
	ios_base::iostate __err = ios_base::goodbit;
	while (__c < __n)
	{
	typename _Traits::int_type __i = __is.rdbuf()->sgetc();
	if (_Traits::eq_int_type(__i, _Traits::eof()))
	{
	__err \|= ios_base::eofbit;
	break;
	}
	_CharT __ch = _Traits::to_char_type(__i);
	if (__ct.is(__ct.space, __ch))
	break;
	__str.push_back(__ch);
	++__c;
	__is.rdbuf()->sbumpc();
	}
	__is.width(0);
	if (__c == 0)
	__err \|= ios_base::failbit;
	__is.setstate(__err);
	}
	else
	__is.setstate(ios_base::failbit);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__is.__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return __is;
	}

	template<class _CharT, class _Traits, class _Allocator>
	basic_istream<_CharT, _Traits>&
	getline(basic_istream<_CharT, _Traits>& __is,
	basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
	if (__sen)
	{
	__str.clear();
	ios_base::iostate __err = ios_base::goodbit;
	streamsize __extr = 0;
	while (true)
	{
	typename _Traits::int_type __i = __is.rdbuf()->sbumpc();
	if (_Traits::eq_int_type(__i, _Traits::eof()))
	{
	__err \|= ios_base::eofbit;
	break;
	}
	++__extr;
	_CharT __ch = _Traits::to_char_type(__i);
	if (_Traits::eq(__ch, __dlm))
	break;
	__str.push_back(__ch);
	if (__str.size() == __str.max_size())
	{
	__err \|= ios_base::failbit;
	break;
	}
	}
	if (__extr == 0)
	__err \|= ios_base::failbit;
	__is.setstate(__err);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__is.__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return __is;
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_istream<_CharT, _Traits>&
	getline(basic_istream<_CharT, _Traits>& __is,
	basic_string<_CharT, _Traits, _Allocator>& __str)
	{
	return getline(__is, __str, __is.widen('\n'));
	}

	#ifndef _LIBCPP_CXX03_LANG

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_istream<_CharT, _Traits>&
	getline(basic_istream<_CharT, _Traits>&& __is,
	basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm)
	{
	return getline(__is, __str, __dlm);
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_istream<_CharT, _Traits>&
	getline(basic_istream<_CharT, _Traits>&& __is,
	basic_string<_CharT, _Traits, _Allocator>& __str)
	{
	return getline(__is, __str, __is.widen('\n'));
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits, size_t _Size>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
	if (__sen)
	{
	basic_string<_CharT, _Traits> __str;
	const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
	size_t __c = 0;
	ios_base::iostate __err = ios_base::goodbit;
	_CharT __zero = __ct.widen('0');
	_CharT __one = __ct.widen('1');
	while (__c < _Size)
	{
	typename _Traits::int_type __i = __is.rdbuf()->sgetc();
	if (_Traits::eq_int_type(__i, _Traits::eof()))
	{
	__err \|= ios_base::eofbit;
	break;
	}
	_CharT __ch = _Traits::to_char_type(__i);
	if (!_Traits::eq(__ch, __zero) && !_Traits::eq(__ch, __one))
	break;
	__str.push_back(__ch);
	++__c;
	__is.rdbuf()->sbumpc();
	}
	__x = bitset<_Size>(__str);
	if (__c == 0)
	__err \|= ios_base::failbit;
	__is.setstate(__err);
	}
	else
	__is.setstate(ios_base::failbit);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__is.__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return __is;
	}

	#ifndef _LIBCPP_AVAILABILITY_NO_STREAMS_EXTERN_TEMPLATE
	_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_istream<char>)
	_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_istream<wchar_t>)
	_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_iostream<char>)
	#endif

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_ISTREAM
	Index: projects/clang700-import/contrib/libc++/include/iterator
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/iterator (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/iterator (revision 337135)
	@@ -1,1882 +1,1885 @@
	// -- C++ --
	//===-------------------------- iterator ----------------------------------===//
	//
	// 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_ITERATOR
	#define _LIBCPP_ITERATOR

	/*
	iterator synopsis

	namespace std
	{

	template<class Iterator>
	struct iterator_traits
	{
	typedef typename Iterator::difference_type difference_type;
	typedef typename Iterator::value_type value_type;
	typedef typename Iterator::pointer pointer;
	typedef typename Iterator::reference reference;
	typedef typename Iterator::iterator_category iterator_category;
	};

	template<class T>
	struct iterator_traits<T*>
	{
	typedef ptrdiff_t difference_type;
	typedef T value_type;
	typedef T* pointer;
	typedef 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
	{
	typedef T value_type;
	typedef Distance difference_type;
	typedef Pointer pointer;
	typedef Reference reference;
	typedef Category iterator_category;
	};

	struct input_iterator_tag {};
	struct output_iterator_tag {};
	struct forward_iterator_tag : public input_iterator_tag {};
	struct bidirectional_iterator_tag : public forward_iterator_tag {};
	struct random_access_iterator_tag : public bidirectional_iterator_tag {};

	// 27.4.3, iterator operations
	// extension: second argument not conforming to C++03
	template <class InputIterator> // constexpr in C++17
	constexpr void advance(InputIterator& i,
	typename iterator_traits<InputIterator>::difference_type n);

	template <class InputIterator> // constexpr in C++17
	constexpr typename iterator_traits<InputIterator>::difference_type
	distance(InputIterator first, InputIterator last);

	template <class InputIterator> // constexpr in C++17
	constexpr InputIterator next(InputIterator x,
	typename iterator_traits<InputIterator>::difference_type n = 1);

	template <class BidirectionalIterator> // constexpr in C++17
	constexpr BidirectionalIterator prev(BidirectionalIterator x,
	typename iterator_traits<BidirectionalIterator>::difference_type n = 1);

	template <class Iterator>
	class reverse_iterator
	: public iterator<typename iterator_traits<Iterator>::iterator_category,
	typename iterator_traits<Iterator>::value_type,
	typename iterator_traits<Iterator>::difference_type,
	typename iterator_traits<Iterator>::pointer,
	typename iterator_traits<Iterator>::reference>
	{
	protected:
	Iterator current;
	public:
	typedef Iterator iterator_type;
	typedef typename iterator_traits<Iterator>::difference_type difference_type;
	typedef typename iterator_traits<Iterator>::reference reference;
	typedef typename iterator_traits<Iterator>::pointer pointer;

	constexpr reverse_iterator();
	constexpr explicit reverse_iterator(Iterator x);
	template <class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
	template <class U> constexpr reverse_iterator& operator=(const reverse_iterator<U>& u);
	constexpr Iterator base() const;
	constexpr reference operator*() const;
	constexpr pointer operator->() const;
	constexpr reverse_iterator& operator++();
	constexpr reverse_iterator operator++(int);
	constexpr reverse_iterator& operator--();
	constexpr reverse_iterator operator--(int);
	constexpr reverse_iterator operator+ (difference_type n) const;
	constexpr reverse_iterator& operator+=(difference_type n);
	constexpr reverse_iterator operator- (difference_type n) const;
	constexpr reverse_iterator& operator-=(difference_type n);
	constexpr reference operator[](difference_type n) const;
	};

	template <class Iterator1, class Iterator2>
	constexpr bool // constexpr in C++17
	operator==(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);

	template <class Iterator1, class Iterator2>
	constexpr bool // constexpr in C++17
	operator<(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);

	template <class Iterator1, class Iterator2>
	constexpr bool // constexpr in C++17
	operator!=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);

	template <class Iterator1, class Iterator2>
	constexpr bool // constexpr in C++17
	operator>(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);

	template <class Iterator1, class Iterator2>
	constexpr bool // constexpr in C++17
	operator>=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);

	template <class Iterator1, class Iterator2>
	constexpr bool // constexpr in C++17
	operator<=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);

	template <class Iterator1, class Iterator2>
	constexpr auto
	operator-(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y)
	-> decltype(__y.base() - __x.base()); // constexpr in C++17

	template <class Iterator>
	constexpr reverse_iterator<Iterator>
	operator+(typename reverse_iterator<Iterator>::difference_type n,
	const reverse_iterator<Iterator>& x); // constexpr in C++17

	template <class Iterator>
	constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i); // C++14, constexpr in C++17

	template <class Container>
	class back_insert_iterator
	{
	protected:
	Container* container;
	public:
	typedef Container container_type;
	typedef void value_type;
	typedef void difference_type;
	typedef void reference;
	typedef void pointer;

	explicit back_insert_iterator(Container& x);
	back_insert_iterator& operator=(const typename Container::value_type& value);
	back_insert_iterator& operator*();
	back_insert_iterator& operator++();
	back_insert_iterator operator++(int);
	};

	template <class Container> back_insert_iterator<Container> back_inserter(Container& x);

	template <class Container>
	class front_insert_iterator
	{
	protected:
	Container* container;
	public:
	typedef Container container_type;
	typedef void value_type;
	typedef void difference_type;
	typedef void reference;
	typedef void pointer;

	explicit front_insert_iterator(Container& x);
	front_insert_iterator& operator=(const typename Container::value_type& value);
	front_insert_iterator& operator*();
	front_insert_iterator& operator++();
	front_insert_iterator operator++(int);
	};

	template <class Container> front_insert_iterator<Container> front_inserter(Container& x);

	template <class Container>
	class insert_iterator
	{
	protected:
	Container* container;
	typename Container::iterator iter;
	public:
	typedef Container container_type;
	typedef void value_type;
	typedef void difference_type;
	typedef void reference;
	typedef void pointer;

	insert_iterator(Container& x, typename Container::iterator i);
	insert_iterator& operator=(const typename Container::value_type& value);
	insert_iterator& operator*();
	insert_iterator& operator++();
	insert_iterator& operator++(int);
	};

	template <class Container, class Iterator>
	insert_iterator<Container> inserter(Container& x, Iterator i);

	template <class Iterator>
	class move_iterator {
	public:
	typedef Iterator iterator_type;
	typedef typename iterator_traits<Iterator>::difference_type difference_type;
	typedef Iterator pointer;
	typedef typename iterator_traits<Iterator>::value_type value_type;
	typedef typename iterator_traits<Iterator>::iterator_category iterator_category;
	typedef value_type&& reference;

	constexpr move_iterator(); // all the constexprs are in C++17
	constexpr explicit move_iterator(Iterator i);
	template <class U>
	constexpr move_iterator(const move_iterator<U>& u);
	template <class U>
	constexpr move_iterator& operator=(const move_iterator<U>& u);
	constexpr iterator_type base() const;
	constexpr reference operator*() const;
	constexpr pointer operator->() const;
	constexpr move_iterator& operator++();
	constexpr move_iterator operator++(int);
	constexpr move_iterator& operator--();
	constexpr move_iterator operator--(int);
	constexpr move_iterator operator+(difference_type n) const;
	constexpr move_iterator& operator+=(difference_type n);
	constexpr move_iterator operator-(difference_type n) const;
	constexpr move_iterator& operator-=(difference_type n);
	constexpr unspecified operator[](difference_type n) const;
	private:
	Iterator current; // exposition only
	};

	template <class Iterator1, class Iterator2>
	constexpr bool // constexpr in C++17
	operator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);

	template <class Iterator1, class Iterator2>
	constexpr bool // constexpr in C++17
	operator!=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);

	template <class Iterator1, class Iterator2>
	constexpr bool // constexpr in C++17
	operator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);

	template <class Iterator1, class Iterator2>
	constexpr bool // constexpr in C++17
	operator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);

	template <class Iterator1, class Iterator2>
	constexpr bool // constexpr in C++17
	operator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);

	template <class Iterator1, class Iterator2>
	constexpr bool // constexpr in C++17
	operator>=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);

	template <class Iterator1, class Iterator2>
	constexpr auto // constexpr in C++17
	operator-(const move_iterator<Iterator1>& x,
	const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());

	template <class Iterator>
	constexpr move_iterator<Iterator> operator+( // constexpr in C++17
	typename move_iterator<Iterator>::difference_type n,
	const move_iterator<Iterator>& x);

	template <class Iterator> // constexpr in C++17
	constexpr move_iterator<Iterator> make_move_iterator(const Iterator& i);


	template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t>
	class istream_iterator
	: public iterator<input_iterator_tag, T, Distance, const T*, const T&>
	{
	public:
	typedef charT char_type;
	typedef traits traits_type;
	typedef basic_istream<charT,traits> istream_type;

	constexpr istream_iterator();
	istream_iterator(istream_type& s);
	istream_iterator(const istream_iterator& x);
	~istream_iterator();

	const T& operator*() const;
	const T* operator->() const;
	istream_iterator& operator++();
	istream_iterator operator++(int);
	};

	template <class T, class charT, class traits, class Distance>
	bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
	const istream_iterator<T,charT,traits,Distance>& y);
	template <class T, class charT, class traits, class Distance>
	bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
	const istream_iterator<T,charT,traits,Distance>& y);

	template <class T, class charT = char, class traits = char_traits<charT> >
	class ostream_iterator
	: public iterator<output_iterator_tag, void, void, void ,void>
	{
	public:
	typedef charT char_type;
	typedef traits traits_type;
	typedef basic_ostream<charT,traits> ostream_type;

	ostream_iterator(ostream_type& s);
	ostream_iterator(ostream_type& s, const charT* delimiter);
	ostream_iterator(const ostream_iterator& x);
	~ostream_iterator();
	ostream_iterator& operator=(const T& value);

	ostream_iterator& operator*();
	ostream_iterator& operator++();
	ostream_iterator& operator++(int);
	};

	template<class charT, class traits = char_traits<charT> >
	class istreambuf_iterator
	: public iterator<input_iterator_tag, charT,
	typename traits::off_type, unspecified,
	charT>
	{
	public:
	typedef charT char_type;
	typedef traits traits_type;
	typedef typename traits::int_type int_type;
	typedef basic_streambuf<charT,traits> streambuf_type;
	typedef basic_istream<charT,traits> istream_type;

	istreambuf_iterator() noexcept;
	istreambuf_iterator(istream_type& s) noexcept;
	istreambuf_iterator(streambuf_type* s) noexcept;
	istreambuf_iterator(a-private-type) noexcept;

	charT operator*() const;
	pointer operator->() const;
	istreambuf_iterator& operator++();
	a-private-type operator++(int);

	bool equal(const istreambuf_iterator& b) const;
	};

	template <class charT, class traits>
	bool operator==(const istreambuf_iterator<charT,traits>& a,
	const istreambuf_iterator<charT,traits>& b);
	template <class charT, class traits>
	bool operator!=(const istreambuf_iterator<charT,traits>& a,
	const istreambuf_iterator<charT,traits>& b);

	template <class charT, class traits = char_traits<charT> >
	class ostreambuf_iterator
	: public iterator<output_iterator_tag, void, void, void, void>
	{
	public:
	typedef charT char_type;
	typedef traits traits_type;
	typedef basic_streambuf<charT,traits> streambuf_type;
	typedef basic_ostream<charT,traits> ostream_type;

	ostreambuf_iterator(ostream_type& s) noexcept;
	ostreambuf_iterator(streambuf_type* s) noexcept;
	ostreambuf_iterator& operator=(charT c);
	ostreambuf_iterator& operator*();
	ostreambuf_iterator& operator++();
	ostreambuf_iterator& operator++(int);
	bool failed() const noexcept;
	};

	template <class C> constexpr auto begin(C& c) -> decltype(c.begin());
	template <class C> constexpr auto begin(const C& c) -> decltype(c.begin());
	template <class C> constexpr auto end(C& c) -> decltype(c.end());
	template <class C> constexpr auto end(const C& c) -> decltype(c.end());
	template <class T, size_t N> constexpr T* begin(T (&array)[N]);
	template <class T, size_t N> constexpr T* end(T (&array)[N]);

	template <class C> auto constexpr cbegin(const C& c) -> decltype(std::begin(c)); // C++14
	template <class C> auto constexpr cend(const C& c) -> decltype(std::end(c)); // C++14
	template <class C> auto constexpr rbegin(C& c) -> decltype(c.rbegin()); // C++14
	template <class C> auto constexpr rbegin(const C& c) -> decltype(c.rbegin()); // C++14
	template <class C> auto constexpr rend(C& c) -> decltype(c.rend()); // C++14
	template <class C> constexpr auto rend(const C& c) -> decltype(c.rend()); // C++14
	template <class E> reverse_iterator<const E*> constexpr rbegin(initializer_list<E> il); // C++14
	template <class E> reverse_iterator<const E*> constexpr rend(initializer_list<E> il); // C++14
	template <class T, size_t N> reverse_iterator<T*> constexpr rbegin(T (&array)[N]); // C++14
	template <class T, size_t N> reverse_iterator<T*> constexpr rend(T (&array)[N]); // C++14
	template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c)); // C++14
	template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c)); // C++14

	// 24.8, container access:
	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
	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
	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

	} // std

	*/

	#include <__config>
	#include <iosfwd> // for forward declarations of vector and string.
	#include <__functional_base>
	#include <type_traits>
	#include <cstddef>
	#include <initializer_list>
	#ifdef __APPLE__
	#include <Availability.h>
	#endif

	#include <__debug>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	struct _LIBCPP_TEMPLATE_VIS input_iterator_tag {};
	struct _LIBCPP_TEMPLATE_VIS output_iterator_tag {};
	struct _LIBCPP_TEMPLATE_VIS forward_iterator_tag : public input_iterator_tag {};
	struct _LIBCPP_TEMPLATE_VIS bidirectional_iterator_tag : public forward_iterator_tag {};
	struct _LIBCPP_TEMPLATE_VIS random_access_iterator_tag : public bidirectional_iterator_tag {};

	template <class _Tp>
	struct __has_iterator_category
	{
	private:
	struct __two {char __lx; char __lxx;};
	template <class _Up> static __two __test(...);
	template <class _Up> static char __test(typename _Up::iterator_category* = 0);
	public:
	static const bool value = sizeof(__test<_Tp>(0)) == 1;
	};

	template <class _Iter, bool> struct __iterator_traits_impl {};

	template <class _Iter>
	struct __iterator_traits_impl<_Iter, true>
	{
	typedef typename _Iter::difference_type difference_type;
	typedef typename _Iter::value_type value_type;
	typedef typename _Iter::pointer pointer;
	typedef typename _Iter::reference reference;
	typedef typename _Iter::iterator_category iterator_category;
	};

	template <class _Iter, bool> struct __iterator_traits {};

	template <class _Iter>
	struct __iterator_traits<_Iter, true>
	: __iterator_traits_impl
	<
	_Iter,
	is_convertible<typename _Iter::iterator_category, input_iterator_tag>::value \|\|
	is_convertible<typename _Iter::iterator_category, output_iterator_tag>::value
	>
	{};

	// iterator_traits<Iterator> will only have the nested types if Iterator::iterator_category
	// exists. Else iterator_traits<Iterator> will be an empty class. This is a
	// conforming extension which allows some programs to compile and behave as
	// the client expects instead of failing at compile time.

	template <class _Iter>
	struct _LIBCPP_TEMPLATE_VIS iterator_traits
	: __iterator_traits<_Iter, __has_iterator_category<_Iter>::value> {};

	template<class _Tp>
	struct _LIBCPP_TEMPLATE_VIS iterator_traits<_Tp*>
	{
	typedef ptrdiff_t difference_type;
	typedef typename remove_cv<_Tp>::type value_type;
	typedef _Tp* pointer;
	typedef _Tp& reference;
	typedef random_access_iterator_tag iterator_category;
	};

	template <class _Tp, class _Up, bool = __has_iterator_category<iterator_traits<_Tp> >::value>
	struct __has_iterator_category_convertible_to
	: public integral_constant<bool, is_convertible<typename iterator_traits<_Tp>::iterator_category, _Up>::value>
	{};

	template <class _Tp, class _Up>
	struct __has_iterator_category_convertible_to<_Tp, _Up, false> : public false_type {};

	template <class _Tp>
	struct __is_input_iterator : public __has_iterator_category_convertible_to<_Tp, input_iterator_tag> {};

	template <class _Tp>
	struct __is_forward_iterator : public __has_iterator_category_convertible_to<_Tp, forward_iterator_tag> {};

	template <class _Tp>
	struct __is_bidirectional_iterator : public __has_iterator_category_convertible_to<_Tp, bidirectional_iterator_tag> {};

	template <class _Tp>
	struct __is_random_access_iterator : public __has_iterator_category_convertible_to<_Tp, random_access_iterator_tag> {};

	template <class _Tp>
	struct __is_exactly_input_iterator
	: public integral_constant<bool,
	__has_iterator_category_convertible_to<_Tp, input_iterator_tag>::value &&
	!__has_iterator_category_convertible_to<_Tp, forward_iterator_tag>::value> {};

	template<class _Category, class _Tp, class _Distance = ptrdiff_t,
	class _Pointer = _Tp*, class _Reference = _Tp&>
	struct _LIBCPP_TEMPLATE_VIS iterator
	{
	typedef _Tp value_type;
	typedef _Distance difference_type;
	typedef _Pointer pointer;
	typedef _Reference reference;
	typedef _Category iterator_category;
	};

	template <class _InputIter>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	void __advance(_InputIter& __i,
	typename iterator_traits<_InputIter>::difference_type __n, input_iterator_tag)
	{
	for (; __n > 0; --__n)
	++__i;
	}

	template <class _BiDirIter>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	void __advance(_BiDirIter& __i,
	typename iterator_traits<_BiDirIter>::difference_type __n, bidirectional_iterator_tag)
	{
	if (__n >= 0)
	for (; __n > 0; --__n)
	++__i;
	else
	for (; __n < 0; ++__n)
	--__i;
	}

	template <class _RandIter>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	void __advance(_RandIter& __i,
	typename iterator_traits<_RandIter>::difference_type __n, random_access_iterator_tag)
	{
	__i += __n;
	}

	template <class _InputIter>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	void advance(_InputIter& __i,
	typename iterator_traits<_InputIter>::difference_type __n)
	{
	__advance(__i, __n, typename iterator_traits<_InputIter>::iterator_category());
	}

	template <class _InputIter>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	typename iterator_traits<_InputIter>::difference_type
	__distance(_InputIter __first, _InputIter __last, input_iterator_tag)
	{
	typename iterator_traits<_InputIter>::difference_type __r(0);
	for (; __first != __last; ++__first)
	++__r;
	return __r;
	}

	template <class _RandIter>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	typename iterator_traits<_RandIter>::difference_type
	__distance(_RandIter __first, _RandIter __last, random_access_iterator_tag)
	{
	return __last - __first;
	}

	template <class _InputIter>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	typename iterator_traits<_InputIter>::difference_type
	distance(_InputIter __first, _InputIter __last)
	{
	return __distance(__first, __last, typename iterator_traits<_InputIter>::iterator_category());
	}

	template <class _InputIter>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	typename enable_if
	<
	__is_input_iterator<_InputIter>::value,
	_InputIter
	>::type
	next(_InputIter __x,
	typename iterator_traits<_InputIter>::difference_type __n = 1)
	{
	_VSTD::advance(__x, __n);
	return __x;
	}

	template <class _BidirectionalIter>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	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;
	}


	template <class _Tp, class = void>
	struct __is_stashing_iterator : false_type {};

	template <class _Tp>
	struct __is_stashing_iterator<_Tp, typename __void_t<typename _Tp::__stashing_iterator_tag>::type>
	: true_type {};

	template <class _Iter>
	class _LIBCPP_TEMPLATE_VIS reverse_iterator
	: public iterator<typename iterator_traits<_Iter>::iterator_category,
	typename iterator_traits<_Iter>::value_type,
	typename iterator_traits<_Iter>::difference_type,
	typename iterator_traits<_Iter>::pointer,
	typename iterator_traits<_Iter>::reference>
	{
	private:
	/mutable/ _Iter __t; // no longer used as of LWG #2360, not removed due to ABI break

	static_assert(!__is_stashing_iterator<_Iter>::value,
	"The specified iterator type cannot be used with reverse_iterator; "
	"Using stashing iterators with reverse_iterator causes undefined behavior");

	protected:
	_Iter current;
	public:
	typedef _Iter iterator_type;
	typedef typename iterator_traits<_Iter>::difference_type difference_type;
	typedef typename iterator_traits<_Iter>::reference reference;
	typedef typename iterator_traits<_Iter>::pointer pointer;

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator() : __t(), current() {}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	explicit reverse_iterator(_Iter __x) : __t(__x), current(__x) {}
	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator(const reverse_iterator<_Up>& __u) : __t(__u.base()), current(__u.base()) {}
	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator& operator=(const reverse_iterator<_Up>& __u)
	{ __t = current = __u.base(); return *this; }
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	_Iter base() const {return current;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reference operator() const {_Iter __tmp = current; return --__tmp;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	pointer operator->() const {return _VSTD::addressof(operator*());}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator& operator++() {--current; return *this;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator operator++(int) {reverse_iterator __tmp(*this); --current; return __tmp;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator& operator--() {++current; return *this;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator operator--(int) {reverse_iterator __tmp(*this); ++current; return __tmp;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator operator+ (difference_type __n) const {return reverse_iterator(current - __n);}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator& operator+=(difference_type __n) {current -= __n; return *this;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator operator- (difference_type __n) const {return reverse_iterator(current + __n);}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reference operator[](difference_type __n) const {return (this + __n);}
	};

	template <class _Iter1, class _Iter2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	bool
	operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
	{
	return __x.base() == __y.base();
	}

	template <class _Iter1, class _Iter2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	bool
	operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
	{
	return __x.base() > __y.base();
	}

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

	template <class _Iter1, class _Iter2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	bool
	operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
	{
	return __x.base() < __y.base();
	}

	template <class _Iter1, class _Iter2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	bool
	operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
	{
	return __x.base() <= __y.base();
	}

	template <class _Iter1, class _Iter2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	bool
	operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
	{
	return __x.base() >= __y.base();
	}

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Iter1, class _Iter2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	auto
	operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
	-> decltype(__y.base() - __x.base())
	{
	return __y.base() - __x.base();
	}
	#else
	template <class _Iter1, class _Iter2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename reverse_iterator<_Iter1>::difference_type
	operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
	{
	return __y.base() - __x.base();
	}
	#endif

	template <class _Iter>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator<_Iter>
	operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x)
	{
	return reverse_iterator<_Iter>(__x.base() - __n);
	}

	#if _LIBCPP_STD_VER > 11
	template <class _Iter>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator<_Iter> make_reverse_iterator(_Iter __i)
	{
	return reverse_iterator<_Iter>(__i);
	}
	#endif

	template <class _Container>
	class _LIBCPP_TEMPLATE_VIS back_insert_iterator
	: public iterator<output_iterator_tag,
	void,
	void,
	void,
	void>
	{
	protected:
	_Container* container;
	public:
	typedef _Container container_type;

	_LIBCPP_INLINE_VISIBILITY explicit back_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
	_LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(const typename _Container::value_type& __value_)
	{container->push_back(__value_); return *this;}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(typename _Container::value_type&& __value_)
	{container->push_back(_VSTD::move(__value_)); return *this;}
	#endif // _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator() {return this;}
	_LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator++() {return *this;}
	_LIBCPP_INLINE_VISIBILITY back_insert_iterator operator++(int) {return *this;}
	};

	template <class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	back_insert_iterator<_Container>
	back_inserter(_Container& __x)
	{
	return back_insert_iterator<_Container>(__x);
	}

	template <class _Container>
	class _LIBCPP_TEMPLATE_VIS front_insert_iterator
	: public iterator<output_iterator_tag,
	void,
	void,
	void,
	void>
	{
	protected:
	_Container* container;
	public:
	typedef _Container container_type;

	_LIBCPP_INLINE_VISIBILITY explicit front_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
	_LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(const typename _Container::value_type& __value_)
	{container->push_front(__value_); return *this;}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(typename _Container::value_type&& __value_)
	{container->push_front(_VSTD::move(__value_)); return *this;}
	#endif // _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator() {return this;}
	_LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator++() {return *this;}
	_LIBCPP_INLINE_VISIBILITY front_insert_iterator operator++(int) {return *this;}
	};

	template <class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	front_insert_iterator<_Container>
	front_inserter(_Container& __x)
	{
	return front_insert_iterator<_Container>(__x);
	}

	template <class _Container>
	class _LIBCPP_TEMPLATE_VIS insert_iterator
	: public iterator<output_iterator_tag,
	void,
	void,
	void,
	void>
	{
	protected:
	_Container* container;
	typename _Container::iterator iter;
	public:
	typedef _Container container_type;

	_LIBCPP_INLINE_VISIBILITY insert_iterator(_Container& __x, typename _Container::iterator __i)
	: container(_VSTD::addressof(__x)), iter(__i) {}
	_LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(const typename _Container::value_type& __value_)
	{iter = container->insert(iter, __value_); ++iter; return *this;}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(typename _Container::value_type&& __value_)
	{iter = container->insert(iter, _VSTD::move(__value_)); ++iter; return *this;}
	#endif // _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY insert_iterator& operator() {return this;}
	_LIBCPP_INLINE_VISIBILITY insert_iterator& operator++() {return *this;}
	_LIBCPP_INLINE_VISIBILITY insert_iterator& operator++(int) {return *this;}
	};

	template <class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	insert_iterator<_Container>
	inserter(_Container& __x, typename _Container::iterator __i)
	{
	return insert_iterator<_Container>(__x, __i);
	}

	template <class _Tp, class _CharT = char,
	class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t>
	class _LIBCPP_TEMPLATE_VIS istream_iterator
	: public iterator<input_iterator_tag, _Tp, _Distance, const _Tp*, const _Tp&>
	{
	public:
	typedef _CharT char_type;
	typedef _Traits traits_type;
	typedef basic_istream<_CharT,_Traits> istream_type;
	private:
	istream_type* __in_stream_;
	_Tp __value_;
	public:
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istream_iterator() : __in_stream_(0), __value_() {}
	_LIBCPP_INLINE_VISIBILITY istream_iterator(istream_type& __s) : __in_stream_(_VSTD::addressof(__s))
	{
	if (!(*__in_stream_ >> __value_))
	__in_stream_ = 0;
	}

	_LIBCPP_INLINE_VISIBILITY const _Tp& operator*() const {return __value_;}
	_LIBCPP_INLINE_VISIBILITY const _Tp* operator->() const {return _VSTD::addressof((operator*()));}
	_LIBCPP_INLINE_VISIBILITY istream_iterator& operator++()
	{
	if (!(*__in_stream_ >> __value_))
	__in_stream_ = 0;
	return *this;
	}
	_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<_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<_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>
	{
	public:
	typedef _CharT char_type;
	typedef _Traits traits_type;
	typedef basic_ostream<_CharT,_Traits> ostream_type;
	private:
	ostream_type* __out_stream_;
	const char_type* __delim_;
	public:
	_LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s) _NOEXCEPT
	: __out_stream_(_VSTD::addressof(__s)), __delim_(0) {}
	_LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s, const _CharT* __delimiter) _NOEXCEPT
	: __out_stream_(_VSTD::addressof(__s)), __delim_(__delimiter) {}
	_LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value_)
	{
	*__out_stream_ << __value_;
	if (__delim_)
	*__out_stream_ << __delim_;
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY ostream_iterator& operator() {return this;}
	_LIBCPP_INLINE_VISIBILITY ostream_iterator& operator++() {return *this;}
	_LIBCPP_INLINE_VISIBILITY ostream_iterator& operator++(int) {return *this;}
	};

	template<class _CharT, class _Traits>
	class _LIBCPP_TEMPLATE_VIS istreambuf_iterator
	: public iterator<input_iterator_tag, _CharT,
	typename _Traits::off_type, _CharT*,
	_CharT>
	{
	public:
	typedef _CharT char_type;
	typedef _Traits traits_type;
	typedef typename _Traits::int_type int_type;
	typedef basic_streambuf<_CharT,_Traits> streambuf_type;
	typedef basic_istream<_CharT,_Traits> istream_type;
	private:
	mutable streambuf_type* __sbuf_;

	class __proxy
	{
	char_type __keep_;
	streambuf_type* __sbuf_;
	_LIBCPP_INLINE_VISIBILITY __proxy(char_type __c, streambuf_type* __s)
	: __keep_(__c), __sbuf_(__s) {}
	friend class istreambuf_iterator;
	public:
	_LIBCPP_INLINE_VISIBILITY char_type operator*() const {return __keep_;}
	};

	_LIBCPP_INLINE_VISIBILITY
	bool __test_for_eof() const
	{
	if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sgetc(), traits_type::eof()))
	__sbuf_ = 0;
	return __sbuf_ == 0;
	}
	public:
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istreambuf_iterator() _NOEXCEPT : __sbuf_(0) {}
	_LIBCPP_INLINE_VISIBILITY istreambuf_iterator(istream_type& __s) _NOEXCEPT
	: __sbuf_(__s.rdbuf()) {}
	_LIBCPP_INLINE_VISIBILITY istreambuf_iterator(streambuf_type* __s) _NOEXCEPT
	: __sbuf_(__s) {}
	_LIBCPP_INLINE_VISIBILITY istreambuf_iterator(const __proxy& __p) _NOEXCEPT
	: __sbuf_(__p.__sbuf_) {}

	_LIBCPP_INLINE_VISIBILITY char_type operator*() const
	{return static_cast<char_type>(__sbuf_->sgetc());}
	_LIBCPP_INLINE_VISIBILITY istreambuf_iterator& operator++()
	{
	__sbuf_->sbumpc();
	return *this;
	}
	_LIBCPP_INLINE_VISIBILITY __proxy operator++(int)
	{
	return __proxy(__sbuf_->sbumpc(), __sbuf_);
	}

	_LIBCPP_INLINE_VISIBILITY bool equal(const istreambuf_iterator& __b) const
	{return __test_for_eof() == __b.__test_for_eof();}
	};

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	bool operator==(const istreambuf_iterator<_CharT,_Traits>& __a,
	const istreambuf_iterator<_CharT,_Traits>& __b)
	{return __a.equal(__b);}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const istreambuf_iterator<_CharT,_Traits>& __a,
	const istreambuf_iterator<_CharT,_Traits>& __b)
	{return !__a.equal(__b);}

	template <class _CharT, class _Traits>
	class _LIBCPP_TEMPLATE_VIS ostreambuf_iterator
	: public iterator<output_iterator_tag, void, void, void, void>
	{
	public:
	typedef _CharT char_type;
	typedef _Traits traits_type;
	typedef basic_streambuf<_CharT,_Traits> streambuf_type;
	typedef basic_ostream<_CharT,_Traits> ostream_type;
	private:
	streambuf_type* __sbuf_;
	public:
	_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(ostream_type& __s) _NOEXCEPT
	: __sbuf_(__s.rdbuf()) {}
	_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(streambuf_type* __s) _NOEXCEPT
	: __sbuf_(__s) {}
	_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator=(_CharT __c)
	{
	if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sputc(__c), traits_type::eof()))
	__sbuf_ = 0;
	return *this;
	}
	_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator() {return this;}
	_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator++() {return *this;}
	_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator++(int) {return *this;}
	_LIBCPP_INLINE_VISIBILITY bool failed() const _NOEXCEPT {return __sbuf_ == 0;}

	#if !defined(__APPLE__) \|\| \
	(defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED > __MAC_10_8) \|\| \
	(defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED > __IPHONE_6_0)

	template <class _Ch, class _Tr>
	friend
	_LIBCPP_HIDDEN
	ostreambuf_iterator<_Ch, _Tr>
	__pad_and_output(ostreambuf_iterator<_Ch, _Tr> __s,
	const _Ch* __ob, const _Ch* __op, const _Ch* __oe,
	ios_base& __iob, _Ch __fl);
	#endif
	};

	template <class _Iter>
	class _LIBCPP_TEMPLATE_VIS move_iterator
	{
	private:
	_Iter __i;
	public:
	typedef _Iter iterator_type;
	typedef typename iterator_traits<iterator_type>::iterator_category iterator_category;
	typedef typename iterator_traits<iterator_type>::value_type value_type;
	typedef typename iterator_traits<iterator_type>::difference_type difference_type;
	typedef iterator_type pointer;
	#ifndef _LIBCPP_CXX03_LANG
	typedef typename iterator_traits<iterator_type>::reference __reference;
	typedef typename conditional<
	is_reference<__reference>::value,
	typename remove_reference<__reference>::type&&,
	__reference
	>::type reference;
	#else
	typedef typename iterator_traits<iterator_type>::reference reference;
	#endif

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	move_iterator() : __i() {}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	explicit move_iterator(_Iter __x) : __i(__x) {}
	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	move_iterator(const move_iterator<_Up>& __u) : __i(__u.base()) {}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _Iter base() const {return __i;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reference operator() const { return static_cast<reference>(__i); }
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	pointer operator->() const { return __i;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	move_iterator& operator++() {++__i; return *this;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	move_iterator operator++(int) {move_iterator __tmp(*this); ++__i; return __tmp;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	move_iterator& operator--() {--__i; return *this;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	move_iterator operator--(int) {move_iterator __tmp(*this); --__i; return __tmp;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	move_iterator operator+ (difference_type __n) const {return move_iterator(__i + __n);}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	move_iterator& operator+=(difference_type __n) {__i += __n; return *this;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	move_iterator operator- (difference_type __n) const {return move_iterator(__i - __n);}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	move_iterator& operator-=(difference_type __n) {__i -= __n; return *this;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reference operator[](difference_type __n) const { return static_cast<reference>(__i[__n]); }
	};

	template <class _Iter1, class _Iter2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	bool
	operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
	{
	return __x.base() == __y.base();
	}

	template <class _Iter1, class _Iter2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	bool
	operator<(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
	{
	return __x.base() < __y.base();
	}

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

	template <class _Iter1, class _Iter2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	bool
	operator>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
	{
	return __x.base() > __y.base();
	}

	template <class _Iter1, class _Iter2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	bool
	operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
	{
	return __x.base() >= __y.base();
	}

	template <class _Iter1, class _Iter2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	bool
	operator<=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
	{
	return __x.base() <= __y.base();
	}

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Iter1, class _Iter2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	auto
	operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
	-> decltype(__x.base() - __y.base())
	{
	return __x.base() - __y.base();
	}
	#else
	template <class _Iter1, class _Iter2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename move_iterator<_Iter1>::difference_type
	operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
	{
	return __x.base() - __y.base();
	}
	#endif

	template <class _Iter>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	move_iterator<_Iter>
	operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x)
	{
	return move_iterator<_Iter>(__x.base() + __n);
	}

	template <class _Iter>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	move_iterator<_Iter>
	make_move_iterator(_Iter __i)
	{
	return move_iterator<_Iter>(__i);
	}

	// __wrap_iter

	template <class _Iter> class __wrap_iter;

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

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

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

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

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

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

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Iter1, class _Iter2>
	-_LIBCPP_INLINE_VISIBILITY
	+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
	auto
	operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT_DEBUG
	-> decltype(__x.base() - __y.base());
	#else
	template <class _Iter1, class _Iter2>
	_LIBCPP_INLINE_VISIBILITY
	typename __wrap_iter<_Iter1>::difference_type
	operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT_DEBUG;
	#endif

	template <class _Iter>
	-_LIBCPP_INLINE_VISIBILITY
	+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
	__wrap_iter<_Iter>
	operator+(typename __wrap_iter<_Iter>::difference_type, __wrap_iter<_Iter>) _NOEXCEPT_DEBUG;

	template <class _Ip, class _Op> _Op _LIBCPP_INLINE_VISIBILITY copy(_Ip, _Ip, _Op);
	template <class _B1, class _B2> _B2 _LIBCPP_INLINE_VISIBILITY copy_backward(_B1, _B1, _B2);
	template <class _Ip, class _Op> _Op _LIBCPP_INLINE_VISIBILITY move(_Ip, _Ip, _Op);
	template <class _B1, class _B2> _B2 _LIBCPP_INLINE_VISIBILITY move_backward(_B1, _B1, _B2);

	#if _LIBCPP_DEBUG_LEVEL < 2

	template <class _Tp>
	-_LIBCPP_INLINE_VISIBILITY
	+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
	typename enable_if
	<
	is_trivially_copy_assignable<_Tp>::value,
	_Tp*
	>::type
	__unwrap_iter(__wrap_iter<_Tp*>);

	#else

	template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
	typename enable_if
	<
	is_trivially_copy_assignable<_Tp>::value,
	__wrap_iter<_Tp*>
	>::type
	__unwrap_iter(__wrap_iter<_Tp*> __i);

	#endif

	template <class _Iter>
	class __wrap_iter
	{
	public:
	typedef _Iter iterator_type;
	typedef typename iterator_traits<iterator_type>::iterator_category iterator_category;
	typedef typename iterator_traits<iterator_type>::value_type value_type;
	typedef typename iterator_traits<iterator_type>::difference_type difference_type;
	typedef typename iterator_traits<iterator_type>::pointer pointer;
	typedef typename iterator_traits<iterator_type>::reference reference;
	private:
	iterator_type __i;
	public:
	- _LIBCPP_INLINE_VISIBILITY __wrap_iter() _NOEXCEPT_DEBUG
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter() _NOEXCEPT_DEBUG
	#if _LIBCPP_STD_VER > 11
	: __i{}
	#endif
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_i(this);
	#endif
	}
	- template <class _Up> _LIBCPP_INLINE_VISIBILITY __wrap_iter(const __wrap_iter<_Up>& __u,
	- typename enable_if<is_convertible<_Up, iterator_type>::value>::type* = 0) _NOEXCEPT_DEBUG
	- : __i(__u.base())
	+ template <class _Up> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
	+ __wrap_iter(const __wrap_iter<_Up>& __u,
	+ typename enable_if<is_convertible<_Up, iterator_type>::value>::type* = 0) _NOEXCEPT_DEBUG
	+ : __i(__u.base())
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__iterator_copy(this, &__u);
	#endif
	}
	#if _LIBCPP_DEBUG_LEVEL >= 2
	- _LIBCPP_INLINE_VISIBILITY
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
	__wrap_iter(const __wrap_iter& __x)
	: __i(__x.base())
	{
	__get_db()->__iterator_copy(this, &__x);
	}
	- _LIBCPP_INLINE_VISIBILITY
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
	__wrap_iter& operator=(const __wrap_iter& __x)
	{
	if (this != &__x)
	{
	__get_db()->__iterator_copy(this, &__x);
	__i = __x.__i;
	}
	return *this;
	}
	- _LIBCPP_INLINE_VISIBILITY
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
	~__wrap_iter()
	{
	__get_db()->__erase_i(this);
	}
	#endif
	- _LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT_DEBUG
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG reference operator*() const _NOEXCEPT_DEBUG
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to dereference a non-dereferenceable iterator");
	#endif
	return *__i;
	}
	- _LIBCPP_INLINE_VISIBILITY pointer operator->() const _NOEXCEPT_DEBUG
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG pointer operator->() const _NOEXCEPT_DEBUG
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to dereference a non-dereferenceable iterator");
	#endif
	return (pointer)_VSTD::addressof(*__i);
	}
	- _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator++() _NOEXCEPT_DEBUG
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter& operator++() _NOEXCEPT_DEBUG
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to increment non-incrementable iterator");
	#endif
	++__i;
	return *this;
	}
	- _LIBCPP_INLINE_VISIBILITY __wrap_iter operator++(int) _NOEXCEPT_DEBUG
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter operator++(int) _NOEXCEPT_DEBUG
	{__wrap_iter __tmp(this); ++(this); return __tmp;}
	- _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator--() _NOEXCEPT_DEBUG
	+
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter& operator--() _NOEXCEPT_DEBUG
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__decrementable(this),
	"Attempted to decrement non-decrementable iterator");
	#endif
	--__i;
	return *this;
	}
	- _LIBCPP_INLINE_VISIBILITY __wrap_iter operator--(int) _NOEXCEPT_DEBUG
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter operator--(int) _NOEXCEPT_DEBUG
	{__wrap_iter __tmp(this); --(this); return __tmp;}
	- _LIBCPP_INLINE_VISIBILITY __wrap_iter operator+ (difference_type __n) const _NOEXCEPT_DEBUG
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter operator+ (difference_type __n) const _NOEXCEPT_DEBUG
	{__wrap_iter __w(*this); __w += __n; return __w;}
	- _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator+=(difference_type __n) _NOEXCEPT_DEBUG
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter& operator+=(difference_type __n) _NOEXCEPT_DEBUG
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__addable(this, __n),
	"Attempted to add/subtract iterator outside of valid range");
	#endif
	__i += __n;
	return *this;
	}
	- _LIBCPP_INLINE_VISIBILITY __wrap_iter operator- (difference_type __n) const _NOEXCEPT_DEBUG
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter operator- (difference_type __n) const _NOEXCEPT_DEBUG
	{return *this + (-__n);}
	- _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator-=(difference_type __n) _NOEXCEPT_DEBUG
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter& operator-=(difference_type __n) _NOEXCEPT_DEBUG
	{this += -__n; return this;}
	- _LIBCPP_INLINE_VISIBILITY reference operator[](difference_type __n) const _NOEXCEPT_DEBUG
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG reference operator[](difference_type __n) const _NOEXCEPT_DEBUG
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__subscriptable(this, __n),
	"Attempted to subscript iterator outside of valid range");
	#endif
	return __i[__n];
	}

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

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

	template <class _Up> friend class __wrap_iter;
	template <class _CharT, class _Traits, class _Alloc> friend class basic_string;
	template <class _Tp, class _Alloc> friend class _LIBCPP_TEMPLATE_VIS vector;
	+ template <class _Tp, ptrdiff_t> friend class _LIBCPP_TEMPLATE_VIS span;

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

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

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

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

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

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

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Iter1, class _Iter2>
	- friend
	+ _LIBCPP_CONSTEXPR_IF_NODEBUG friend
	auto
	operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT_DEBUG
	-> decltype(__x.base() - __y.base());
	#else
	template <class _Iter1, class _Iter2>
	- friend
	+ _LIBCPP_CONSTEXPR_IF_NODEBUG friend
	typename __wrap_iter<_Iter1>::difference_type
	operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT_DEBUG;
	#endif

	template <class _Iter1>
	- friend
	+ _LIBCPP_CONSTEXPR_IF_NODEBUG friend
	__wrap_iter<_Iter1>
	operator+(typename __wrap_iter<_Iter1>::difference_type, __wrap_iter<_Iter1>) _NOEXCEPT_DEBUG;

	template <class _Ip, class _Op> friend _Op copy(_Ip, _Ip, _Op);
	template <class _B1, class _B2> friend _B2 copy_backward(_B1, _B1, _B2);
	template <class _Ip, class _Op> friend _Op move(_Ip, _Ip, _Op);
	template <class _B1, class _B2> friend _B2 move_backward(_B1, _B1, _B2);

	#if _LIBCPP_DEBUG_LEVEL < 2
	template <class _Tp>
	- friend
	+ _LIBCPP_CONSTEXPR_IF_NODEBUG friend
	typename enable_if
	<
	is_trivially_copy_assignable<_Tp>::value,
	_Tp*
	>::type
	__unwrap_iter(__wrap_iter<_Tp*>);
	#else
	template <class _Tp>
	- inline _LIBCPP_INLINE_VISIBILITY
	+ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
	typename enable_if
	<
	is_trivially_copy_assignable<_Tp>::value,
	__wrap_iter<_Tp*>
	>::type
	__unwrap_iter(__wrap_iter<_Tp*> __i);
	#endif
	};

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

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

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

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

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

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

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

	template <class _Iter1>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
	bool
	operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT_DEBUG
	{
	return __y < __x;
	}

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

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

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

	template <class _Iter>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
	__wrap_iter<_Iter>
	operator+(typename __wrap_iter<_Iter>::difference_type __n,
	__wrap_iter<_Iter> __x) _NOEXCEPT_DEBUG
	{
	__x += __n;
	return __x;
	}

	template <class _Iter>
	struct __libcpp_is_trivial_iterator
	: public _LIBCPP_BOOL_CONSTANT(is_pointer<_Iter>::value) {};

	template <class _Iter>
	struct __libcpp_is_trivial_iterator<move_iterator<_Iter> >
	: public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value) {};

	template <class _Iter>
	struct __libcpp_is_trivial_iterator<reverse_iterator<_Iter> >
	: public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value) {};

	template <class _Iter>
	struct __libcpp_is_trivial_iterator<__wrap_iter<_Iter> >
	: public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value) {};


	template <class _Tp, size_t _Np>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_Tp*
	begin(_Tp (&__array)[_Np])
	{
	return __array;
	}

	template <class _Tp, size_t _Np>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_Tp*
	end(_Tp (&__array)[_Np])
	{
	return __array + _Np;
	}

	#if !defined(_LIBCPP_CXX03_LANG)

	template <class _Cp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	auto
	begin(_Cp& __c) -> decltype(__c.begin())
	{
	return __c.begin();
	}

	template <class _Cp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	auto
	begin(const _Cp& __c) -> decltype(__c.begin())
	{
	return __c.begin();
	}

	template <class _Cp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	auto
	end(_Cp& __c) -> decltype(__c.end())
	{
	return __c.end();
	}

	template <class _Cp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	auto
	end(const _Cp& __c) -> decltype(__c.end())
	{
	return __c.end();
	}

	#if _LIBCPP_STD_VER > 11

	template <class _Tp, size_t _Np>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator<_Tp*> rbegin(_Tp (&__array)[_Np])
	{
	return reverse_iterator<_Tp*>(__array + _Np);
	}

	template <class _Tp, size_t _Np>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator<_Tp*> rend(_Tp (&__array)[_Np])
	{
	return reverse_iterator<_Tp*>(__array);
	}

	template <class _Ep>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator<const _Ep*> rbegin(initializer_list<_Ep> __il)
	{
	return reverse_iterator<const _Ep*>(__il.end());
	}

	template <class _Ep>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	reverse_iterator<const _Ep*> rend(initializer_list<_Ep> __il)
	{
	return reverse_iterator<const _Ep*>(__il.begin());
	}

	template <class _Cp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	auto cbegin(const _Cp& __c) -> decltype(_VSTD::begin(__c))
	{
	return _VSTD::begin(__c);
	}

	template <class _Cp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	auto cend(const _Cp& __c) -> decltype(_VSTD::end(__c))
	{
	return _VSTD::end(__c);
	}

	template <class _Cp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	auto rbegin(_Cp& __c) -> decltype(__c.rbegin())
	{
	return __c.rbegin();
	}

	template <class _Cp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	auto rbegin(const _Cp& __c) -> decltype(__c.rbegin())
	{
	return __c.rbegin();
	}

	template <class _Cp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	auto rend(_Cp& __c) -> decltype(__c.rend())
	{
	return __c.rend();
	}

	template <class _Cp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	auto rend(const _Cp& __c) -> decltype(__c.rend())
	{
	return __c.rend();
	}

	template <class _Cp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	auto crbegin(const _Cp& __c) -> decltype(_VSTD::rbegin(__c))
	{
	return _VSTD::rbegin(__c);
	}

	template <class _Cp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	auto crend(const _Cp& __c) -> decltype(_VSTD::rend(__c))
	{
	return _VSTD::rend(__c);
	}

	#endif


	#else // defined(_LIBCPP_CXX03_LANG)

	template <class _Cp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename _Cp::iterator
	begin(_Cp& __c)
	{
	return __c.begin();
	}

	template <class _Cp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename _Cp::const_iterator
	begin(const _Cp& __c)
	{
	return __c.begin();
	}

	template <class _Cp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename _Cp::iterator
	end(_Cp& __c)
	{
	return __c.end();
	}

	template <class _Cp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename _Cp::const_iterator
	end(const _Cp& __c)
	{
	return __c.end();
	}

	#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>
	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>
	_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
	inline _LIBCPP_INLINE_VISIBILITY
	auto data(_Cont& __c)
	_NOEXCEPT_(noexcept(__c.data()))
	-> decltype (__c.data())
	{ return __c.data(); }

	template <class _Cont> constexpr
	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


	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_ITERATOR
	Index: projects/clang700-import/contrib/libc++/include/limits.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/limits.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/limits.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/include/limits.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/list
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/list (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/list (revision 337135)
	@@ -1,2421 +1,2456 @@
	// -- C++ --
	//===---------------------------- list ------------------------------------===//
	//
	// 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_LIST
	#define _LIBCPP_LIST

	/*
	list synopsis

	namespace std
	{

	template <class T, class Alloc = allocator<T> >
	class list
	{
	public:

	// types:
	typedef T value_type;
	typedef Alloc allocator_type;
	typedef typename allocator_type::reference reference;
	typedef typename allocator_type::const_reference const_reference;
	typedef typename allocator_type::pointer pointer;
	typedef typename allocator_type::const_pointer const_pointer;
	typedef implementation-defined iterator;
	typedef implementation-defined const_iterator;
	typedef implementation-defined size_type;
	typedef implementation-defined difference_type;
	typedef reverse_iterator<iterator> reverse_iterator;
	typedef reverse_iterator<const_iterator> const_reverse_iterator;

	list()
	noexcept(is_nothrow_default_constructible<allocator_type>::value);
	explicit list(const allocator_type& a);
	explicit list(size_type n);
	explicit list(size_type n, const allocator_type& a); // C++14
	list(size_type n, const value_type& value);
	list(size_type n, const value_type& value, const allocator_type& a);
	template <class Iter>
	list(Iter first, Iter last);
	template <class Iter>
	list(Iter first, Iter last, const allocator_type& a);
	list(const list& x);
	list(const list&, const allocator_type& a);
	list(list&& x)
	noexcept(is_nothrow_move_constructible<allocator_type>::value);
	list(list&&, const allocator_type& a);
	list(initializer_list<value_type>);
	list(initializer_list<value_type>, const allocator_type& a);

	~list();

	list& operator=(const list& x);
	list& operator=(list&& x)
	noexcept(
	allocator_type::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<allocator_type>::value);
	list& operator=(initializer_list<value_type>);
	template <class Iter>
	void assign(Iter first, Iter last);
	void assign(size_type n, const value_type& t);
	void assign(initializer_list<value_type>);

	allocator_type get_allocator() const noexcept;

	iterator begin() noexcept;
	const_iterator begin() const noexcept;
	iterator end() noexcept;
	const_iterator end() const noexcept;
	reverse_iterator rbegin() noexcept;
	const_reverse_iterator rbegin() const noexcept;
	reverse_iterator rend() noexcept;
	const_reverse_iterator rend() const noexcept;
	const_iterator cbegin() const noexcept;
	const_iterator cend() const noexcept;
	const_reverse_iterator crbegin() const noexcept;
	const_reverse_iterator crend() const noexcept;

	reference front();
	const_reference front() const;
	reference back();
	const_reference back() const;

	bool empty() const noexcept;
	size_type size() const noexcept;
	size_type max_size() const noexcept;

	template <class... Args>
	reference emplace_front(Args&&... args); // reference in C++17
	void pop_front();
	template <class... Args>
	reference emplace_back(Args&&... args); // reference in C++17
	void pop_back();
	void push_front(const value_type& x);
	void push_front(value_type&& x);
	void push_back(const value_type& x);
	void push_back(value_type&& x);
	template <class... Args>
	iterator emplace(const_iterator position, Args&&... args);
	iterator insert(const_iterator position, const value_type& x);
	iterator insert(const_iterator position, value_type&& x);
	iterator insert(const_iterator position, size_type n, const value_type& x);
	template <class Iter>
	iterator insert(const_iterator position, Iter first, Iter last);
	iterator insert(const_iterator position, initializer_list<value_type> il);

	iterator erase(const_iterator position);
	iterator erase(const_iterator position, const_iterator last);

	void resize(size_type sz);
	void resize(size_type sz, const value_type& c);

	void swap(list&)
	noexcept(allocator_traits<allocator_type>::is_always_equal::value); // C++17
	void clear() noexcept;

	void splice(const_iterator position, list& x);
	void splice(const_iterator position, list&& x);
	void splice(const_iterator position, list& x, const_iterator i);
	void splice(const_iterator position, list&& x, const_iterator i);
	void splice(const_iterator position, list& x, const_iterator first,
	const_iterator last);
	void splice(const_iterator position, list&& x, const_iterator first,
	const_iterator last);

	void remove(const value_type& value);
	template <class Pred> void remove_if(Pred pred);
	void unique();
	template <class BinaryPredicate>
	void unique(BinaryPredicate binary_pred);
	void merge(list& x);
	void merge(list&& x);
	template <class Compare>
	void merge(list& x, Compare comp);
	template <class Compare>
	void merge(list&& x, Compare comp);
	void sort();
	template <class Compare>
	void sort(Compare comp);
	void reverse() noexcept;
	};

	+
	+template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
	+ list(InputIterator, InputIterator, Allocator = Allocator())
	+ -> list<typename iterator_traits<InputIterator>::value_type, Allocator>; // C++17
	+
	template <class T, class Alloc>
	bool operator==(const list<T,Alloc>& x, const list<T,Alloc>& y);
	template <class T, class Alloc>
	bool operator< (const list<T,Alloc>& x, const list<T,Alloc>& y);
	template <class T, class Alloc>
	bool operator!=(const list<T,Alloc>& x, const list<T,Alloc>& y);
	template <class T, class Alloc>
	bool operator> (const list<T,Alloc>& x, const list<T,Alloc>& y);
	template <class T, class Alloc>
	bool operator>=(const list<T,Alloc>& x, const list<T,Alloc>& y);
	template <class T, class Alloc>
	bool operator<=(const list<T,Alloc>& x, const list<T,Alloc>& y);

	template <class T, class Alloc>
	void swap(list<T,Alloc>& x, list<T,Alloc>& y)
	noexcept(noexcept(x.swap(y)));

	} // std

	*/

	#include <__config>

	#include <memory>
	#include <limits>
	#include <initializer_list>
	#include <iterator>
	#include <algorithm>
	#include <type_traits>

	#include <__debug>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _Tp, class _VoidPtr> struct __list_node;
	template <class _Tp, class _VoidPtr> struct __list_node_base;

	template <class _Tp, class _VoidPtr>
	struct __list_node_pointer_traits {
	typedef typename __rebind_pointer<_VoidPtr, __list_node<_Tp, _VoidPtr> >::type
	__node_pointer;
	typedef typename __rebind_pointer<_VoidPtr, __list_node_base<_Tp, _VoidPtr> >::type
	__base_pointer;

	#if defined(_LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB)
	typedef __base_pointer __link_pointer;
	#else
	typedef typename conditional<
	is_pointer<_VoidPtr>::value,
	__base_pointer,
	__node_pointer
	>::type __link_pointer;
	#endif

	typedef typename conditional<
	is_same<__link_pointer, __node_pointer>::value,
	__base_pointer,
	__node_pointer
	>::type __non_link_pointer;

	static _LIBCPP_INLINE_VISIBILITY
	__link_pointer __unsafe_link_pointer_cast(__link_pointer __p) {
	return __p;
	}

	static _LIBCPP_INLINE_VISIBILITY
	__link_pointer __unsafe_link_pointer_cast(__non_link_pointer __p) {
	return static_cast<__link_pointer>(static_cast<_VoidPtr>(__p));
	}

	};

	template <class _Tp, class _VoidPtr>
	struct __list_node_base
	{
	typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits;
	typedef typename _NodeTraits::__node_pointer __node_pointer;
	typedef typename _NodeTraits::__base_pointer __base_pointer;
	typedef typename _NodeTraits::__link_pointer __link_pointer;

	__link_pointer __prev_;
	__link_pointer __next_;

	_LIBCPP_INLINE_VISIBILITY
	__list_node_base() : __prev_(_NodeTraits::__unsafe_link_pointer_cast(__self())),
	__next_(_NodeTraits::__unsafe_link_pointer_cast(__self())) {}

	_LIBCPP_INLINE_VISIBILITY
	__base_pointer __self() {
	return pointer_traits<__base_pointer>::pointer_to(*this);
	}

	_LIBCPP_INLINE_VISIBILITY
	__node_pointer __as_node() {
	return static_cast<__node_pointer>(__self());
	}
	};

	template <class _Tp, class _VoidPtr>
	struct __list_node
	: public __list_node_base<_Tp, _VoidPtr>
	{
	_Tp __value_;

	typedef __list_node_base<_Tp, _VoidPtr> __base;
	typedef typename __base::__link_pointer __link_pointer;

	_LIBCPP_INLINE_VISIBILITY
	__link_pointer __as_link() {
	return static_cast<__link_pointer>(__base::__self());
	}
	};

	template <class _Tp, class _Alloc = allocator<_Tp> > class _LIBCPP_TEMPLATE_VIS list;
	template <class _Tp, class _Alloc> class __list_imp;
	template <class _Tp, class _VoidPtr> class _LIBCPP_TEMPLATE_VIS __list_const_iterator;

	template <class _Tp, class _VoidPtr>
	class _LIBCPP_TEMPLATE_VIS __list_iterator
	{
	typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits;
	typedef typename _NodeTraits::__link_pointer __link_pointer;

	__link_pointer __ptr_;

	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_INLINE_VISIBILITY
	explicit __list_iterator(__link_pointer __p, const void* __c) _NOEXCEPT
	: __ptr_(__p)
	{
	__get_db()->__insert_ic(this, __c);
	}
	#else
	_LIBCPP_INLINE_VISIBILITY
	explicit __list_iterator(__link_pointer __p) _NOEXCEPT : __ptr_(__p) {}
	#endif



	template<class, class> friend class list;
	template<class, class> friend class __list_imp;
	template<class, class> friend class __list_const_iterator;
	public:
	typedef bidirectional_iterator_tag iterator_category;
	typedef _Tp value_type;
	typedef value_type& reference;
	typedef typename __rebind_pointer<_VoidPtr, value_type>::type pointer;
	typedef typename pointer_traits<pointer>::difference_type difference_type;

	_LIBCPP_INLINE_VISIBILITY
	__list_iterator() _NOEXCEPT : __ptr_(nullptr)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_i(this);
	#endif
	}

	#if _LIBCPP_DEBUG_LEVEL >= 2

	_LIBCPP_INLINE_VISIBILITY
	__list_iterator(const __list_iterator& __p)
	: __ptr_(__p.__ptr_)
	{
	__get_db()->__iterator_copy(this, &__p);
	}

	_LIBCPP_INLINE_VISIBILITY
	~__list_iterator()
	{
	__get_db()->__erase_i(this);
	}

	_LIBCPP_INLINE_VISIBILITY
	__list_iterator& operator=(const __list_iterator& __p)
	{
	if (this != &__p)
	{
	__get_db()->__iterator_copy(this, &__p);
	__ptr_ = __p.__ptr_;
	}
	return *this;
	}

	#endif // _LIBCPP_DEBUG_LEVEL >= 2

	_LIBCPP_INLINE_VISIBILITY
	reference operator*() const
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to dereference a non-dereferenceable list::iterator");
	#endif
	return __ptr_->__as_node()->__value_;
	}
	_LIBCPP_INLINE_VISIBILITY
	pointer operator->() const
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to dereference a non-dereferenceable list::iterator");
	#endif
	return pointer_traits<pointer>::pointer_to(__ptr_->__as_node()->__value_);
	}

	_LIBCPP_INLINE_VISIBILITY
	__list_iterator& operator++()
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to increment non-incrementable list::iterator");
	#endif
	__ptr_ = __ptr_->__next_;
	return *this;
	}
	_LIBCPP_INLINE_VISIBILITY
	__list_iterator operator++(int) {__list_iterator __t(this); ++(this); return __t;}

	_LIBCPP_INLINE_VISIBILITY
	__list_iterator& operator--()
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__decrementable(this),
	"Attempted to decrement non-decrementable list::iterator");
	#endif
	__ptr_ = __ptr_->__prev_;
	return *this;
	}
	_LIBCPP_INLINE_VISIBILITY
	__list_iterator operator--(int) {__list_iterator __t(this); --(this); return __t;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const __list_iterator& __x, const __list_iterator& __y)
	{
	return __x.__ptr_ == __y.__ptr_;
	}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const __list_iterator& __x, const __list_iterator& __y)
	{return !(__x == __y);}
	};

	template <class _Tp, class _VoidPtr>
	class _LIBCPP_TEMPLATE_VIS __list_const_iterator
	{
	typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits;
	typedef typename _NodeTraits::__link_pointer __link_pointer;

	__link_pointer __ptr_;

	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_INLINE_VISIBILITY
	explicit __list_const_iterator(__link_pointer __p, const void* __c) _NOEXCEPT
	: __ptr_(__p)
	{
	__get_db()->__insert_ic(this, __c);
	}
	#else
	_LIBCPP_INLINE_VISIBILITY
	explicit __list_const_iterator(__link_pointer __p) _NOEXCEPT : __ptr_(__p) {}
	#endif

	template<class, class> friend class list;
	template<class, class> friend class __list_imp;
	public:
	typedef bidirectional_iterator_tag iterator_category;
	typedef _Tp value_type;
	typedef const value_type& reference;
	typedef typename __rebind_pointer<_VoidPtr, const value_type>::type pointer;
	typedef typename pointer_traits<pointer>::difference_type difference_type;

	_LIBCPP_INLINE_VISIBILITY
	__list_const_iterator() _NOEXCEPT : __ptr_(nullptr)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_i(this);
	#endif
	}
	_LIBCPP_INLINE_VISIBILITY
	__list_const_iterator(const __list_iterator<_Tp, _VoidPtr>& __p) _NOEXCEPT
	: __ptr_(__p.__ptr_)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__iterator_copy(this, &__p);
	#endif
	}

	#if _LIBCPP_DEBUG_LEVEL >= 2

	_LIBCPP_INLINE_VISIBILITY
	__list_const_iterator(const __list_const_iterator& __p)
	: __ptr_(__p.__ptr_)
	{
	__get_db()->__iterator_copy(this, &__p);
	}

	_LIBCPP_INLINE_VISIBILITY
	~__list_const_iterator()
	{
	__get_db()->__erase_i(this);
	}

	_LIBCPP_INLINE_VISIBILITY
	__list_const_iterator& operator=(const __list_const_iterator& __p)
	{
	if (this != &__p)
	{
	__get_db()->__iterator_copy(this, &__p);
	__ptr_ = __p.__ptr_;
	}
	return *this;
	}

	#endif // _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_INLINE_VISIBILITY
	reference operator*() const
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to dereference a non-dereferenceable list::const_iterator");
	#endif
	return __ptr_->__as_node()->__value_;
	}
	_LIBCPP_INLINE_VISIBILITY
	pointer operator->() const
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to dereference a non-dereferenceable list::const_iterator");
	#endif
	return pointer_traits<pointer>::pointer_to(__ptr_->__as_node()->__value_);
	}

	_LIBCPP_INLINE_VISIBILITY
	__list_const_iterator& operator++()
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
	"Attempted to increment non-incrementable list::const_iterator");
	#endif
	__ptr_ = __ptr_->__next_;
	return *this;
	}
	_LIBCPP_INLINE_VISIBILITY
	__list_const_iterator operator++(int) {__list_const_iterator __t(this); ++(this); return __t;}

	_LIBCPP_INLINE_VISIBILITY
	__list_const_iterator& operator--()
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__decrementable(this),
	"Attempted to decrement non-decrementable list::const_iterator");
	#endif
	__ptr_ = __ptr_->__prev_;
	return *this;
	}
	_LIBCPP_INLINE_VISIBILITY
	__list_const_iterator operator--(int) {__list_const_iterator __t(this); --(this); return __t;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const __list_const_iterator& __x, const __list_const_iterator& __y)
	{
	return __x.__ptr_ == __y.__ptr_;
	}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const __list_const_iterator& __x, const __list_const_iterator& __y)
	{return !(__x == __y);}
	};

	template <class _Tp, class _Alloc>
	class __list_imp
	{
	__list_imp(const __list_imp&);
	__list_imp& operator=(const __list_imp&);
	-protected:
	- typedef _Tp value_type;
	+public:
	typedef _Alloc allocator_type;
	typedef allocator_traits<allocator_type> __alloc_traits;
	typedef typename __alloc_traits::size_type size_type;
	+protected:
	+ typedef _Tp value_type;
	typedef typename __alloc_traits::void_pointer __void_pointer;
	typedef __list_iterator<value_type, __void_pointer> iterator;
	typedef __list_const_iterator<value_type, __void_pointer> const_iterator;
	typedef __list_node_base<value_type, __void_pointer> __node_base;
	typedef __list_node<value_type, __void_pointer> __node;
	typedef typename __rebind_alloc_helper<__alloc_traits, __node>::type __node_allocator;
	typedef allocator_traits<__node_allocator> __node_alloc_traits;
	typedef typename __node_alloc_traits::pointer __node_pointer;
	typedef typename __node_alloc_traits::pointer __node_const_pointer;
	typedef __list_node_pointer_traits<value_type, __void_pointer> __node_pointer_traits;
	typedef typename __node_pointer_traits::__link_pointer __link_pointer;
	typedef __link_pointer __link_const_pointer;
	typedef typename __alloc_traits::pointer pointer;
	typedef typename __alloc_traits::const_pointer const_pointer;
	typedef typename __alloc_traits::difference_type difference_type;

	typedef typename __rebind_alloc_helper<__alloc_traits, __node_base>::type __node_base_allocator;
	typedef typename allocator_traits<__node_base_allocator>::pointer __node_base_pointer;
	+ static_assert((!is_same<allocator_type, __node_allocator>::value),
	+ "internal allocator type must differ from user-specified "
	+ "type; otherwise overload resolution breaks");

	__node_base __end_;
	__compressed_pair<size_type, __node_allocator> __size_alloc_;

	_LIBCPP_INLINE_VISIBILITY
	__link_pointer __end_as_link() const _NOEXCEPT {
	return __node_pointer_traits::__unsafe_link_pointer_cast(
	const_cast<__node_base&>(__end_).__self());
	}

	_LIBCPP_INLINE_VISIBILITY
	size_type& __sz() _NOEXCEPT {return __size_alloc_.first();}
	_LIBCPP_INLINE_VISIBILITY
	const size_type& __sz() const _NOEXCEPT
	{return __size_alloc_.first();}
	_LIBCPP_INLINE_VISIBILITY
	__node_allocator& __node_alloc() _NOEXCEPT
	{return __size_alloc_.second();}
	_LIBCPP_INLINE_VISIBILITY
	const __node_allocator& __node_alloc() const _NOEXCEPT
	{return __size_alloc_.second();}

	_LIBCPP_INLINE_VISIBILITY
	size_type __node_alloc_max_size() const _NOEXCEPT {
	return __node_alloc_traits::max_size(__node_alloc());
	}
	_LIBCPP_INLINE_VISIBILITY
	static void __unlink_nodes(__link_pointer __f, __link_pointer __l) _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY
	__list_imp()
	_NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value);
	_LIBCPP_INLINE_VISIBILITY
	__list_imp(const allocator_type& __a);
	+ _LIBCPP_INLINE_VISIBILITY
	+ __list_imp(const __node_allocator& __a);
	+#ifndef _LIBCPP_CXX03_LANG
	+ __list_imp(__node_allocator&& __a) _NOEXCEPT;
	+#endif
	~__list_imp();
	void clear() _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	bool empty() const _NOEXCEPT {return __sz() == 0;}

	_LIBCPP_INLINE_VISIBILITY
	iterator begin() _NOEXCEPT
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return iterator(__end_.__next_, this);
	#else
	return iterator(__end_.__next_);
	#endif
	}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator begin() const _NOEXCEPT
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return const_iterator(__end_.__next_, this);
	#else
	return const_iterator(__end_.__next_);
	#endif
	}
	_LIBCPP_INLINE_VISIBILITY
	iterator end() _NOEXCEPT
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return iterator(__end_as_link(), this);
	#else
	return iterator(__end_as_link());
	#endif
	}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator end() const _NOEXCEPT
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return const_iterator(__end_as_link(), this);
	#else
	return const_iterator(__end_as_link());
	#endif
	}

	void swap(__list_imp& __c)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT_DEBUG;
	#else
	_NOEXCEPT_DEBUG_(!__alloc_traits::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<allocator_type>::value);
	#endif

	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const __list_imp& __c)
	{__copy_assign_alloc(__c, integral_constant<bool,
	__node_alloc_traits::propagate_on_container_copy_assignment::value>());}

	_LIBCPP_INLINE_VISIBILITY
	void __move_assign_alloc(__list_imp& __c)
	_NOEXCEPT_(
	!__node_alloc_traits::propagate_on_container_move_assignment::value \|\|
	is_nothrow_move_assignable<__node_allocator>::value)
	{__move_assign_alloc(__c, integral_constant<bool,
	__node_alloc_traits::propagate_on_container_move_assignment::value>());}

	private:
	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const __list_imp& __c, true_type)
	{
	if (__node_alloc() != __c.__node_alloc())
	clear();
	__node_alloc() = __c.__node_alloc();
	}

	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const __list_imp&, false_type)
	{}

	_LIBCPP_INLINE_VISIBILITY
	void __move_assign_alloc(__list_imp& __c, true_type)
	_NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
	{
	__node_alloc() = _VSTD::move(__c.__node_alloc());
	}

	_LIBCPP_INLINE_VISIBILITY
	void __move_assign_alloc(__list_imp&, false_type)
	_NOEXCEPT
	{}

	_LIBCPP_INLINE_VISIBILITY
	void __invalidate_all_iterators() {
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__invalidate_all(this);
	#endif
	}
	};

	// Unlink nodes [__f, __l]
	template <class _Tp, class _Alloc>
	inline
	void
	__list_imp<_Tp, _Alloc>::__unlink_nodes(__link_pointer __f, __link_pointer __l)
	_NOEXCEPT
	{
	__f->__prev_->__next_ = __l->__next_;
	__l->__next_->__prev_ = __f->__prev_;
	}

	template <class _Tp, class _Alloc>
	inline
	__list_imp<_Tp, _Alloc>::__list_imp()
	_NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
	: __size_alloc_(0)
	{
	}

	template <class _Tp, class _Alloc>
	inline
	__list_imp<_Tp, _Alloc>::__list_imp(const allocator_type& __a)
	: __size_alloc_(0, __node_allocator(__a))
	{
	}

	template <class _Tp, class _Alloc>
	-__list_imp<_Tp, _Alloc>::~__list_imp()
	-{
	- clear();
	+inline __list_imp<_Tp, _Alloc>::__list_imp(const __node_allocator& __a)
	+ : __size_alloc_(0, __a) {}
	+
	+#ifndef _LIBCPP_CXX03_LANG
	+template <class _Tp, class _Alloc>
	+inline __list_imp<_Tp, _Alloc>::__list_imp(__node_allocator&& __a) _NOEXCEPT
	+ : __size_alloc_(0, std::move(__a)) {}
	+#endif
	+
	+template <class _Tp, class _Alloc>
	+__list_imp<_Tp, _Alloc>::~__list_imp() {
	+ clear();
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__erase_c(this);
	#endif
	}

	template <class _Tp, class _Alloc>
	void
	__list_imp<_Tp, _Alloc>::clear() _NOEXCEPT
	{
	if (!empty())
	{
	__node_allocator& __na = __node_alloc();
	__link_pointer __f = __end_.__next_;
	__link_pointer __l = __end_as_link();
	__unlink_nodes(__f, __l->__prev_);
	__sz() = 0;
	while (__f != __l)
	{
	__node_pointer __np = __f->__as_node();
	__f = __f->__next_;
	__node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_));
	__node_alloc_traits::deallocate(__na, __np, 1);
	}
	__invalidate_all_iterators();
	}
	}

	template <class _Tp, class _Alloc>
	void
	__list_imp<_Tp, _Alloc>::swap(__list_imp& __c)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT_DEBUG
	#else
	_NOEXCEPT_DEBUG_(!__alloc_traits::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<allocator_type>::value)
	#endif
	{
	_LIBCPP_ASSERT(__alloc_traits::propagate_on_container_swap::value \|\|
	this->__node_alloc() == __c.__node_alloc(),
	"list::swap: Either propagate_on_container_swap must be true"
	" or the allocators must compare equal");
	using _VSTD::swap;
	__swap_allocator(__node_alloc(), __c.__node_alloc());
	swap(__sz(), __c.__sz());
	swap(__end_, __c.__end_);
	if (__sz() == 0)
	__end_.__next_ = __end_.__prev_ = __end_as_link();
	else
	__end_.__prev_->__next_ = __end_.__next_->__prev_ = __end_as_link();
	if (__c.__sz() == 0)
	__c.__end_.__next_ = __c.__end_.__prev_ = __c.__end_as_link();
	else
	__c.__end_.__prev_->__next_ = __c.__end_.__next_->__prev_ = __c.__end_as_link();

	#if _LIBCPP_DEBUG_LEVEL >= 2
	__libcpp_db* __db = __get_db();
	__c_node* __cn1 = __db->__find_c_and_lock(this);
	__c_node* __cn2 = __db->__find_c(&__c);
	std::swap(__cn1->beg_, __cn2->beg_);
	std::swap(__cn1->end_, __cn2->end_);
	std::swap(__cn1->cap_, __cn2->cap_);
	for (__i_node** __p = __cn1->end_; __p != __cn1->beg_;)
	{
	--__p;
	const_iterator* __i = static_cast<const_iterator>((__p)->__i_);
	if (__i->__ptr_ == __c.__end_as_link())
	{
	__cn2->__add(*__p);
	if (--__cn1->end_ != __p)
	memmove(__p, __p+1, (__cn1->end_ - __p)sizeof(__i_node));
	}
	else
	(*__p)->__c_ = __cn1;
	}
	for (__i_node** __p = __cn2->end_; __p != __cn2->beg_;)
	{
	--__p;
	const_iterator* __i = static_cast<const_iterator>((__p)->__i_);
	if (__i->__ptr_ == __end_as_link())
	{
	__cn1->__add(*__p);
	if (--__cn2->end_ != __p)
	memmove(__p, __p+1, (__cn2->end_ - __p)sizeof(__i_node));
	}
	else
	(*__p)->__c_ = __cn2;
	}
	__db->unlock();
	#endif
	}

	template <class _Tp, class _Alloc /= allocator<_Tp>/>
	class _LIBCPP_TEMPLATE_VIS list
	: private __list_imp<_Tp, _Alloc>
	{
	typedef __list_imp<_Tp, _Alloc> base;
	typedef typename base::__node __node;
	typedef typename base::__node_allocator __node_allocator;
	typedef typename base::__node_pointer __node_pointer;
	typedef typename base::__node_alloc_traits __node_alloc_traits;
	typedef typename base::__node_base __node_base;
	typedef typename base::__node_base_pointer __node_base_pointer;
	typedef typename base::__link_pointer __link_pointer;

	public:
	typedef _Tp value_type;
	typedef _Alloc allocator_type;
	static_assert((is_same<value_type, typename allocator_type::value_type>::value),
	"Invalid allocator::value_type");
	typedef value_type& reference;
	typedef const value_type& const_reference;
	typedef typename base::pointer pointer;
	typedef typename base::const_pointer const_pointer;
	typedef typename base::size_type size_type;
	typedef typename base::difference_type difference_type;
	typedef typename base::iterator iterator;
	typedef typename base::const_iterator const_iterator;
	typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
	typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;

	_LIBCPP_INLINE_VISIBILITY
	list()
	_NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}
	_LIBCPP_INLINE_VISIBILITY
	explicit list(const allocator_type& __a) : base(__a)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}
	explicit list(size_type __n);
	#if _LIBCPP_STD_VER > 11
	explicit list(size_type __n, const allocator_type& __a);
	#endif
	list(size_type __n, const value_type& __x);
	list(size_type __n, const value_type& __x, const allocator_type& __a);
	template <class _InpIter>
	list(_InpIter __f, _InpIter __l,
	typename enable_if<__is_input_iterator<_InpIter>::value>::type* = 0);
	template <class _InpIter>
	list(_InpIter __f, _InpIter __l, const allocator_type& __a,
	typename enable_if<__is_input_iterator<_InpIter>::value>::type* = 0);

	list(const list& __c);
	list(const list& __c, const allocator_type& __a);
	_LIBCPP_INLINE_VISIBILITY
	list& operator=(const list& __c);
	#ifndef _LIBCPP_CXX03_LANG
	list(initializer_list<value_type> __il);
	list(initializer_list<value_type> __il, const allocator_type& __a);

	_LIBCPP_INLINE_VISIBILITY
	list(list&& __c)
	_NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value);
	_LIBCPP_INLINE_VISIBILITY
	list(list&& __c, const allocator_type& __a);
	_LIBCPP_INLINE_VISIBILITY
	list& operator=(list&& __c)
	_NOEXCEPT_(
	__node_alloc_traits::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<__node_allocator>::value);

	_LIBCPP_INLINE_VISIBILITY
	list& operator=(initializer_list<value_type> __il)
	{assign(__il.begin(), __il.end()); return *this;}

	_LIBCPP_INLINE_VISIBILITY
	void assign(initializer_list<value_type> __il)
	{assign(__il.begin(), __il.end());}
	#endif // _LIBCPP_CXX03_LANG

	template <class _InpIter>
	void assign(_InpIter __f, _InpIter __l,
	typename enable_if<__is_input_iterator<_InpIter>::value>::type* = 0);
	void assign(size_type __n, const value_type& __x);

	_LIBCPP_INLINE_VISIBILITY
	allocator_type get_allocator() const _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY
	size_type size() const _NOEXCEPT {return base::__sz();}
	_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
	bool empty() const _NOEXCEPT {return base::empty();}
	_LIBCPP_INLINE_VISIBILITY
	size_type max_size() const _NOEXCEPT
	{
	return std::min<size_type>(
	base::__node_alloc_max_size(),
	numeric_limits<difference_type >::max());
	}

	_LIBCPP_INLINE_VISIBILITY
	iterator begin() _NOEXCEPT {return base::begin();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator begin() const _NOEXCEPT {return base::begin();}
	_LIBCPP_INLINE_VISIBILITY
	iterator end() _NOEXCEPT {return base::end();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator end() const _NOEXCEPT {return base::end();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator cbegin() const _NOEXCEPT {return base::begin();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator cend() const _NOEXCEPT {return base::end();}

	_LIBCPP_INLINE_VISIBILITY
	reverse_iterator rbegin() _NOEXCEPT
	{return reverse_iterator(end());}
	_LIBCPP_INLINE_VISIBILITY
	const_reverse_iterator rbegin() const _NOEXCEPT
	{return const_reverse_iterator(end());}
	_LIBCPP_INLINE_VISIBILITY
	reverse_iterator rend() _NOEXCEPT
	{return reverse_iterator(begin());}
	_LIBCPP_INLINE_VISIBILITY
	const_reverse_iterator rend() const _NOEXCEPT
	{return const_reverse_iterator(begin());}
	_LIBCPP_INLINE_VISIBILITY
	const_reverse_iterator crbegin() const _NOEXCEPT
	{return const_reverse_iterator(end());}
	_LIBCPP_INLINE_VISIBILITY
	const_reverse_iterator crend() const _NOEXCEPT
	{return const_reverse_iterator(begin());}

	_LIBCPP_INLINE_VISIBILITY
	reference front()
	{
	_LIBCPP_ASSERT(!empty(), "list::front called on empty list");
	return base::__end_.__next_->__as_node()->__value_;
	}
	_LIBCPP_INLINE_VISIBILITY
	const_reference front() const
	{
	_LIBCPP_ASSERT(!empty(), "list::front called on empty list");
	return base::__end_.__next_->__as_node()->__value_;
	}
	_LIBCPP_INLINE_VISIBILITY
	reference back()
	{
	_LIBCPP_ASSERT(!empty(), "list::back called on empty list");
	return base::__end_.__prev_->__as_node()->__value_;
	}
	_LIBCPP_INLINE_VISIBILITY
	const_reference back() const
	{
	_LIBCPP_ASSERT(!empty(), "list::back called on empty list");
	return base::__end_.__prev_->__as_node()->__value_;
	}

	#ifndef _LIBCPP_CXX03_LANG
	void push_front(value_type&& __x);
	void push_back(value_type&& __x);

	template <class... _Args>
	#if _LIBCPP_STD_VER > 14
	reference emplace_front(_Args&&... __args);
	#else
	void emplace_front(_Args&&... __args);
	#endif
	template <class... _Args>
	#if _LIBCPP_STD_VER > 14
	reference emplace_back(_Args&&... __args);
	#else
	void emplace_back(_Args&&... __args);
	#endif
	template <class... _Args>
	iterator emplace(const_iterator __p, _Args&&... __args);

	iterator insert(const_iterator __p, value_type&& __x);

	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __p, initializer_list<value_type> __il)
	{return insert(__p, __il.begin(), __il.end());}
	#endif // _LIBCPP_CXX03_LANG

	void push_front(const value_type& __x);
	void push_back(const value_type& __x);

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Arg>
	_LIBCPP_INLINE_VISIBILITY
	void __emplace_back(_Arg&& __arg) { emplace_back(_VSTD::forward<_Arg>(__arg)); }
	#else
	_LIBCPP_INLINE_VISIBILITY
	void __emplace_back(value_type const& __arg) { push_back(__arg); }
	#endif

	iterator insert(const_iterator __p, const value_type& __x);
	iterator insert(const_iterator __p, size_type __n, const value_type& __x);
	template <class _InpIter>
	iterator insert(const_iterator __p, _InpIter __f, _InpIter __l,
	typename enable_if<__is_input_iterator<_InpIter>::value>::type* = 0);

	_LIBCPP_INLINE_VISIBILITY
	void swap(list& __c)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT_DEBUG
	#else
	_NOEXCEPT_DEBUG_(!__node_alloc_traits::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<__node_allocator>::value)
	#endif
	{base::swap(__c);}
	_LIBCPP_INLINE_VISIBILITY
	void clear() _NOEXCEPT {base::clear();}

	void pop_front();
	void pop_back();

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

	void resize(size_type __n);
	void resize(size_type __n, const value_type& __x);

	void splice(const_iterator __p, list& __c);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	void splice(const_iterator __p, list&& __c) {splice(__p, __c);}
	_LIBCPP_INLINE_VISIBILITY
	void splice(const_iterator __p, list&& __c, const_iterator __i)
	{splice(__p, __c, __i);}
	_LIBCPP_INLINE_VISIBILITY
	void splice(const_iterator __p, list&& __c, const_iterator __f, const_iterator __l)
	{splice(__p, __c, __f, __l);}
	#endif
	void splice(const_iterator __p, list& __c, const_iterator __i);
	void splice(const_iterator __p, list& __c, const_iterator __f, const_iterator __l);

	void remove(const value_type& __x);
	template <class _Pred> void remove_if(_Pred __pred);
	_LIBCPP_INLINE_VISIBILITY
	void unique();
	template <class _BinaryPred>
	void unique(_BinaryPred __binary_pred);
	_LIBCPP_INLINE_VISIBILITY
	void merge(list& __c);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	void merge(list&& __c) {merge(__c);}

	template <class _Comp>
	_LIBCPP_INLINE_VISIBILITY
	void merge(list&& __c, _Comp __comp) {merge(__c, __comp);}
	#endif
	template <class _Comp>
	void merge(list& __c, _Comp __comp);

	_LIBCPP_INLINE_VISIBILITY
	void sort();
	template <class _Comp>
	_LIBCPP_INLINE_VISIBILITY
	void sort(_Comp __comp);

	void reverse() _NOEXCEPT;

	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;
	bool __decrementable(const const_iterator* __i) const;
	bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
	bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;

	#endif // _LIBCPP_DEBUG_LEVEL >= 2

	private:
	_LIBCPP_INLINE_VISIBILITY
	static void __link_nodes (__link_pointer __p, __link_pointer __f, __link_pointer __l);
	_LIBCPP_INLINE_VISIBILITY
	void __link_nodes_at_front(__link_pointer __f, __link_pointer __l);
	_LIBCPP_INLINE_VISIBILITY
	void __link_nodes_at_back (__link_pointer __f, __link_pointer __l);
	iterator __iterator(size_type __n);
	template <class _Comp>
	static iterator __sort(iterator __f1, iterator __e2, size_type __n, _Comp& __comp);

	void __move_assign(list& __c, true_type)
	_NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value);
	void __move_assign(list& __c, false_type);
	};

	+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
	+template<class _InputIterator,
	+ class _Alloc = typename std::allocator<typename iterator_traits<_InputIterator>::value_type>,
	+ class = typename enable_if<__is_allocator<_Alloc>::value, void>::type
	+ >
	+list(_InputIterator, _InputIterator)
	+ -> list<typename iterator_traits<_InputIterator>::value_type, _Alloc>;
	+
	+template<class _InputIterator,
	+ class _Alloc,
	+ class = typename enable_if<__is_allocator<_Alloc>::value, void>::type
	+ >
	+list(_InputIterator, _InputIterator, _Alloc)
	+ -> list<typename iterator_traits<_InputIterator>::value_type, _Alloc>;
	+#endif
	+
	// Link in nodes [__f, __l] just prior to __p
	template <class _Tp, class _Alloc>
	inline
	void
	list<_Tp, _Alloc>::__link_nodes(__link_pointer __p, __link_pointer __f, __link_pointer __l)
	{
	__p->__prev_->__next_ = __f;
	__f->__prev_ = __p->__prev_;
	__p->__prev_ = __l;
	__l->__next_ = __p;
	}

	// Link in nodes [__f, __l] at the front of the list
	template <class _Tp, class _Alloc>
	inline
	void
	list<_Tp, _Alloc>::__link_nodes_at_front(__link_pointer __f, __link_pointer __l)
	{
	__f->__prev_ = base::__end_as_link();
	__l->__next_ = base::__end_.__next_;
	__l->__next_->__prev_ = __l;
	base::__end_.__next_ = __f;
	}

	// Link in nodes [__f, __l] at the front of the list
	template <class _Tp, class _Alloc>
	inline
	void
	list<_Tp, _Alloc>::__link_nodes_at_back(__link_pointer __f, __link_pointer __l)
	{
	__l->__next_ = base::__end_as_link();
	__f->__prev_ = base::__end_.__prev_;
	__f->__prev_->__next_ = __f;
	base::__end_.__prev_ = __l;
	}


	template <class _Tp, class _Alloc>
	inline
	typename list<_Tp, _Alloc>::iterator
	list<_Tp, _Alloc>::__iterator(size_type __n)
	{
	return __n <= base::__sz() / 2 ? _VSTD::next(begin(), __n)
	: _VSTD::prev(end(), base::__sz() - __n);
	}

	template <class _Tp, class _Alloc>
	list<_Tp, _Alloc>::list(size_type __n)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	for (; __n > 0; --__n)
	#ifndef _LIBCPP_CXX03_LANG
	emplace_back();
	#else
	push_back(value_type());
	#endif
	}

	#if _LIBCPP_STD_VER > 11
	template <class _Tp, class _Alloc>
	list<_Tp, _Alloc>::list(size_type __n, const allocator_type& __a) : base(__a)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	for (; __n > 0; --__n)
	emplace_back();
	}
	#endif

	template <class _Tp, class _Alloc>
	list<_Tp, _Alloc>::list(size_type __n, const value_type& __x)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	for (; __n > 0; --__n)
	push_back(__x);
	}

	template <class _Tp, class _Alloc>
	list<_Tp, _Alloc>::list(size_type __n, const value_type& __x, const allocator_type& __a)
	: base(__a)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	for (; __n > 0; --__n)
	push_back(__x);
	}

	template <class _Tp, class _Alloc>
	template <class _InpIter>
	list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l,
	typename enable_if<__is_input_iterator<_InpIter>::value>::type*)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	for (; __f != __l; ++__f)
	__emplace_back(*__f);
	}

	template <class _Tp, class _Alloc>
	template <class _InpIter>
	list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l, const allocator_type& __a,
	typename enable_if<__is_input_iterator<_InpIter>::value>::type*)
	: base(__a)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	for (; __f != __l; ++__f)
	__emplace_back(*__f);
	}

	template <class _Tp, class _Alloc>
	list<_Tp, _Alloc>::list(const list& __c)
	- : base(allocator_type(
	- __node_alloc_traits::select_on_container_copy_construction(
	- __c.__node_alloc())))
	-{
	+ : base(__node_alloc_traits::select_on_container_copy_construction(
	+ __c.__node_alloc())) {
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	for (const_iterator __i = __c.begin(), __e = __c.end(); __i != __e; ++__i)
	push_back(*__i);
	}

	template <class _Tp, class _Alloc>
	list<_Tp, _Alloc>::list(const list& __c, const allocator_type& __a)
	: base(__a)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	for (const_iterator __i = __c.begin(), __e = __c.end(); __i != __e; ++__i)
	push_back(*__i);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Alloc>
	list<_Tp, _Alloc>::list(initializer_list<value_type> __il, const allocator_type& __a)
	: base(__a)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	for (typename initializer_list<value_type>::const_iterator __i = __il.begin(),
	__e = __il.end(); __i != __e; ++__i)
	push_back(*__i);
	}

	template <class _Tp, class _Alloc>
	list<_Tp, _Alloc>::list(initializer_list<value_type> __il)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	for (typename initializer_list<value_type>::const_iterator __i = __il.begin(),
	__e = __il.end(); __i != __e; ++__i)
	push_back(*__i);
	}

	template <class _Tp, class _Alloc>
	-inline
	-list<_Tp, _Alloc>::list(list&& __c)
	+inline list<_Tp, _Alloc>::list(list&& __c)
	_NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value)
	- : base(allocator_type(_VSTD::move(__c.__node_alloc())))
	-{
	+ : base(_VSTD::move(__c.__node_alloc())) {
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	splice(end(), __c);
	}

	template <class _Tp, class _Alloc>
	inline
	list<_Tp, _Alloc>::list(list&& __c, const allocator_type& __a)
	: base(__a)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	if (__a == __c.get_allocator())
	splice(end(), __c);
	else
	{
	typedef move_iterator<iterator> _Ip;
	assign(_Ip(__c.begin()), _Ip(__c.end()));
	}
	}

	template <class _Tp, class _Alloc>
	inline
	list<_Tp, _Alloc>&
	list<_Tp, _Alloc>::operator=(list&& __c)
	_NOEXCEPT_(
	__node_alloc_traits::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<__node_allocator>::value)
	{
	__move_assign(__c, integral_constant<bool,
	__node_alloc_traits::propagate_on_container_move_assignment::value>());
	return *this;
	}

	template <class _Tp, class _Alloc>
	void
	list<_Tp, _Alloc>::__move_assign(list& __c, false_type)
	{
	if (base::__node_alloc() != __c.__node_alloc())
	{
	typedef move_iterator<iterator> _Ip;
	assign(_Ip(__c.begin()), _Ip(__c.end()));
	}
	else
	__move_assign(__c, true_type());
	}

	template <class _Tp, class _Alloc>
	void
	list<_Tp, _Alloc>::__move_assign(list& __c, true_type)
	_NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
	{
	clear();
	base::__move_assign_alloc(__c);
	splice(end(), __c);
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Alloc>
	inline
	list<_Tp, _Alloc>&
	list<_Tp, _Alloc>::operator=(const list& __c)
	{
	if (this != &__c)
	{
	base::__copy_assign_alloc(__c);
	assign(__c.begin(), __c.end());
	}
	return *this;
	}

	template <class _Tp, class _Alloc>
	template <class _InpIter>
	void
	list<_Tp, _Alloc>::assign(_InpIter __f, _InpIter __l,
	typename enable_if<__is_input_iterator<_InpIter>::value>::type*)
	{
	iterator __i = begin();
	iterator __e = end();
	for (; __f != __l && __i != __e; ++__f, ++__i)
	__i = __f;
	if (__i == __e)
	insert(__e, __f, __l);
	else
	erase(__i, __e);
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__invalidate_all(this);
	#endif
	}

	template <class _Tp, class _Alloc>
	void
	list<_Tp, _Alloc>::assign(size_type __n, const value_type& __x)
	{
	iterator __i = begin();
	iterator __e = end();
	for (; __n > 0 && __i != __e; --__n, ++__i)
	*__i = __x;
	if (__i == __e)
	insert(__e, __n, __x);
	else
	erase(__i, __e);
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__invalidate_all(this);
	#endif
	}

	template <class _Tp, class _Alloc>
	inline
	_Alloc
	list<_Tp, _Alloc>::get_allocator() const _NOEXCEPT
	{
	return allocator_type(base::__node_alloc());
	}

	template <class _Tp, class _Alloc>
	typename list<_Tp, _Alloc>::iterator
	list<_Tp, _Alloc>::insert(const_iterator __p, const value_type& __x)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"list::insert(iterator, x) called with an iterator not"
	" referring to this list");
	#endif
	__node_allocator& __na = base::__node_alloc();
	__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();
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return iterator(__hold.release()->__as_link(), this);
	#else
	return iterator(__hold.release()->__as_link());
	#endif
	}

	template <class _Tp, class _Alloc>
	typename list<_Tp, _Alloc>::iterator
	list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& __x)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"list::insert(iterator, n, x) called with an iterator not"
	" referring to this list");
	iterator __r(__p.__ptr_, this);
	#else
	iterator __r(__p.__ptr_);
	#endif
	if (__n > 0)
	{
	size_type __ds = 0;
	__node_allocator& __na = base::__node_alloc();
	__hold_pointer __hold = __allocate_node(__na);
	__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
	++__ds;
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__r = iterator(__hold->__as_link(), this);
	#else
	__r = iterator(__hold->__as_link());
	#endif
	__hold.release();
	iterator __e = __r;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (--__n; __n != 0; --__n, ++__e, ++__ds)
	{
	__hold.reset(__node_alloc_traits::allocate(__na, 1));
	__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
	__e.__ptr_->__next_ = __hold->__as_link();
	__hold->__prev_ = __e.__ptr_;
	__hold.release();
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	while (true)
	{
	__node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
	__link_pointer __prev = __e.__ptr_->__prev_;
	__node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1);
	if (__prev == 0)
	break;
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__e = iterator(__prev, this);
	#else
	__e = iterator(__prev);
	#endif
	}
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	__link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_);
	base::__sz() += __ds;
	}
	return __r;
	}

	template <class _Tp, class _Alloc>
	template <class _InpIter>
	typename list<_Tp, _Alloc>::iterator
	list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
	typename enable_if<__is_input_iterator<_InpIter>::value>::type*)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"list::insert(iterator, range) called with an iterator not"
	" referring to this list");
	iterator __r(__p.__ptr_, this);
	#else
	iterator __r(__p.__ptr_);
	#endif
	if (__f != __l)
	{
	size_type __ds = 0;
	__node_allocator& __na = base::__node_alloc();
	__hold_pointer __hold = __allocate_node(__na);
	__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f);
	++__ds;
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__r = iterator(__hold.get()->__as_link(), this);
	#else
	__r = iterator(__hold.get()->__as_link());
	#endif
	__hold.release();
	iterator __e = __r;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (++__f; __f != __l; ++__f, (void) ++__e, (void) ++__ds)
	{
	__hold.reset(__node_alloc_traits::allocate(__na, 1));
	__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f);
	__e.__ptr_->__next_ = __hold.get()->__as_link();
	__hold->__prev_ = __e.__ptr_;
	__hold.release();
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	while (true)
	{
	__node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
	__link_pointer __prev = __e.__ptr_->__prev_;
	__node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1);
	if (__prev == 0)
	break;
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__e = iterator(__prev, this);
	#else
	__e = iterator(__prev);
	#endif
	}
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	__link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_);
	base::__sz() += __ds;
	}
	return __r;
	}

	template <class _Tp, class _Alloc>
	void
	list<_Tp, _Alloc>::push_front(const value_type& __x)
	{
	__node_allocator& __na = base::__node_alloc();
	__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);
	++base::__sz();
	__hold.release();
	}

	template <class _Tp, class _Alloc>
	void
	list<_Tp, _Alloc>::push_back(const value_type& __x)
	{
	__node_allocator& __na = base::__node_alloc();
	__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();
	__hold.release();
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Alloc>
	void
	list<_Tp, _Alloc>::push_front(value_type&& __x)
	{
	__node_allocator& __na = base::__node_alloc();
	__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();
	__hold.release();
	}

	template <class _Tp, class _Alloc>
	void
	list<_Tp, _Alloc>::push_back(value_type&& __x)
	{
	__node_allocator& __na = base::__node_alloc();
	__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();
	__hold.release();
	}

	template <class _Tp, class _Alloc>
	template <class... _Args>
	#if _LIBCPP_STD_VER > 14
	typename list<_Tp, _Alloc>::reference
	#else
	void
	#endif
	list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
	{
	__node_allocator& __na = base::__node_alloc();
	__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();
	#if _LIBCPP_STD_VER > 14
	return __hold.release()->__value_;
	#else
	__hold.release();
	#endif
	}

	template <class _Tp, class _Alloc>
	template <class... _Args>
	#if _LIBCPP_STD_VER > 14
	typename list<_Tp, _Alloc>::reference
	#else
	void
	#endif
	list<_Tp, _Alloc>::emplace_back(_Args&&... __args)
	{
	__node_allocator& __na = base::__node_alloc();
	__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);
	++base::__sz();
	#if _LIBCPP_STD_VER > 14
	return __hold.release()->__value_;
	#else
	__hold.release();
	#endif
	}

	template <class _Tp, class _Alloc>
	template <class... _Args>
	typename list<_Tp, _Alloc>::iterator
	list<_Tp, _Alloc>::emplace(const_iterator __p, _Args&&... __args)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"list::emplace(iterator, args...) called with an iterator not"
	" referring to this list");
	#endif
	__node_allocator& __na = base::__node_alloc();
	__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);
	++base::__sz();
	__hold.release();
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return iterator(__nl, this);
	#else
	return iterator(__nl);
	#endif
	}

	template <class _Tp, class _Alloc>
	typename list<_Tp, _Alloc>::iterator
	list<_Tp, _Alloc>::insert(const_iterator __p, value_type&& __x)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"list::insert(iterator, x) called with an iterator not"
	" referring to this list");
	#endif
	__node_allocator& __na = base::__node_alloc();
	__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);
	++base::__sz();
	__hold.release();
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return iterator(__nl, this);
	#else
	return iterator(__nl);
	#endif
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Alloc>
	void
	list<_Tp, _Alloc>::pop_front()
	{
	_LIBCPP_ASSERT(!empty(), "list::pop_front() called with empty list");
	__node_allocator& __na = base::__node_alloc();
	__link_pointer __n = base::__end_.__next_;
	base::__unlink_nodes(__n, __n);
	--base::__sz();
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__c_node* __c = __get_db()->__find_c_and_lock(this);
	for (__i_node** __p = __c->end_; __p != __c->beg_; )
	{
	--__p;
	iterator* __i = static_cast<iterator>((__p)->__i_);
	if (__i->__ptr_ == __n)
	{
	(*__p)->__c_ = nullptr;
	if (--__c->end_ != __p)
	memmove(__p, __p+1, (__c->end_ - __p)sizeof(__i_node));
	}
	}
	__get_db()->unlock();
	#endif
	__node_pointer __np = __n->__as_node();
	__node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_));
	__node_alloc_traits::deallocate(__na, __np, 1);
	}

	template <class _Tp, class _Alloc>
	void
	list<_Tp, _Alloc>::pop_back()
	{
	_LIBCPP_ASSERT(!empty(), "list::pop_back() called with empty list");
	__node_allocator& __na = base::__node_alloc();
	__link_pointer __n = base::__end_.__prev_;
	base::__unlink_nodes(__n, __n);
	--base::__sz();
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__c_node* __c = __get_db()->__find_c_and_lock(this);
	for (__i_node** __p = __c->end_; __p != __c->beg_; )
	{
	--__p;
	iterator* __i = static_cast<iterator>((__p)->__i_);
	if (__i->__ptr_ == __n)
	{
	(*__p)->__c_ = nullptr;
	if (--__c->end_ != __p)
	memmove(__p, __p+1, (__c->end_ - __p)sizeof(__i_node));
	}
	}
	__get_db()->unlock();
	#endif
	__node_pointer __np = __n->__as_node();
	__node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_));
	__node_alloc_traits::deallocate(__na, __np, 1);
	}

	template <class _Tp, class _Alloc>
	typename list<_Tp, _Alloc>::iterator
	list<_Tp, _Alloc>::erase(const_iterator __p)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"list::erase(iterator) called with an iterator not"
	" referring to this list");
	#endif
	_LIBCPP_ASSERT(__p != end(),
	"list::erase(iterator) called with a non-dereferenceable iterator");
	__node_allocator& __na = base::__node_alloc();
	__link_pointer __n = __p.__ptr_;
	__link_pointer __r = __n->__next_;
	base::__unlink_nodes(__n, __n);
	--base::__sz();
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__c_node* __c = __get_db()->__find_c_and_lock(this);
	for (__i_node** __ip = __c->end_; __ip != __c->beg_; )
	{
	--__ip;
	iterator* __i = static_cast<iterator>((__ip)->__i_);
	if (__i->__ptr_ == __n)
	{
	(*__ip)->__c_ = nullptr;
	if (--__c->end_ != __ip)
	memmove(__ip, __ip+1, (__c->end_ - __ip)sizeof(__i_node));
	}
	}
	__get_db()->unlock();
	#endif
	__node_pointer __np = __n->__as_node();
	__node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_));
	__node_alloc_traits::deallocate(__na, __np, 1);
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return iterator(__r, this);
	#else
	return iterator(__r);
	#endif
	}

	template <class _Tp, class _Alloc>
	typename list<_Tp, _Alloc>::iterator
	list<_Tp, _Alloc>::erase(const_iterator __f, const_iterator __l)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__f) == this,
	"list::erase(iterator, iterator) called with an iterator not"
	" referring to this list");
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__l) == this,
	"list::erase(iterator, iterator) called with an iterator not"
	" referring to this list");
	#endif
	if (__f != __l)
	{
	__node_allocator& __na = base::__node_alloc();
	base::__unlink_nodes(__f.__ptr_, __l.__ptr_->__prev_);
	while (__f != __l)
	{
	__link_pointer __n = __f.__ptr_;
	++__f;
	--base::__sz();
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__c_node* __c = __get_db()->__find_c_and_lock(this);
	for (__i_node** __p = __c->end_; __p != __c->beg_; )
	{
	--__p;
	iterator* __i = static_cast<iterator>((__p)->__i_);
	if (__i->__ptr_ == __n)
	{
	(*__p)->__c_ = nullptr;
	if (--__c->end_ != __p)
	memmove(__p, __p+1, (__c->end_ - __p)sizeof(__i_node));
	}
	}
	__get_db()->unlock();
	#endif
	__node_pointer __np = __n->__as_node();
	__node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_));
	__node_alloc_traits::deallocate(__na, __np, 1);
	}
	}
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return iterator(__l.__ptr_, this);
	#else
	return iterator(__l.__ptr_);
	#endif
	}

	template <class _Tp, class _Alloc>
	void
	list<_Tp, _Alloc>::resize(size_type __n)
	{
	if (__n < base::__sz())
	erase(__iterator(__n), end());
	else if (__n > base::__sz())
	{
	__n -= base::__sz();
	size_type __ds = 0;
	__node_allocator& __na = base::__node_alloc();
	__hold_pointer __hold = __allocate_node(__na);
	__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_));
	++__ds;
	#if _LIBCPP_DEBUG_LEVEL >= 2
	iterator __r = iterator(__hold.release()->__as_link(), this);
	#else
	iterator __r = iterator(__hold.release()->__as_link());
	#endif
	iterator __e = __r;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (--__n; __n != 0; --__n, ++__e, ++__ds)
	{
	__hold.reset(__node_alloc_traits::allocate(__na, 1));
	__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_));
	__e.__ptr_->__next_ = __hold.get()->__as_link();
	__hold->__prev_ = __e.__ptr_;
	__hold.release();
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	while (true)
	{
	__node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
	__link_pointer __prev = __e.__ptr_->__prev_;
	__node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1);
	if (__prev == 0)
	break;
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__e = iterator(__prev, this);
	#else
	__e = iterator(__prev);
	#endif
	}
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	__link_nodes_at_back(__r.__ptr_, __e.__ptr_);
	base::__sz() += __ds;
	}
	}

	template <class _Tp, class _Alloc>
	void
	list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
	{
	if (__n < base::__sz())
	erase(__iterator(__n), end());
	else if (__n > base::__sz())
	{
	__n -= base::__sz();
	size_type __ds = 0;
	__node_allocator& __na = base::__node_alloc();
	__hold_pointer __hold = __allocate_node(__na);
	__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
	++__ds;
	__link_pointer __nl = __hold.release()->__as_link();
	#if _LIBCPP_DEBUG_LEVEL >= 2
	iterator __r = iterator(__nl, this);
	#else
	iterator __r = iterator(__nl);
	#endif
	iterator __e = __r;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (--__n; __n != 0; --__n, ++__e, ++__ds)
	{
	__hold.reset(__node_alloc_traits::allocate(__na, 1));
	__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
	__e.__ptr_->__next_ = __hold.get()->__as_link();
	__hold->__prev_ = __e.__ptr_;
	__hold.release();
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	while (true)
	{
	__node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
	__link_pointer __prev = __e.__ptr_->__prev_;
	__node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1);
	if (__prev == 0)
	break;
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__e = iterator(__prev, this);
	#else
	__e = iterator(__prev);
	#endif
	}
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	__link_nodes(base::__end_as_link(), __r.__ptr_, __e.__ptr_);
	base::__sz() += __ds;
	}
	}

	template <class _Tp, class _Alloc>
	void
	list<_Tp, _Alloc>::splice(const_iterator __p, list& __c)
	{
	_LIBCPP_ASSERT(this != &__c,
	"list::splice(iterator, list) called with this == &list");
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"list::splice(iterator, list) called with an iterator not"
	" referring to this list");
	#endif
	if (!__c.empty())
	{
	__link_pointer __f = __c.__end_.__next_;
	__link_pointer __l = __c.__end_.__prev_;
	base::__unlink_nodes(__f, __l);
	__link_nodes(__p.__ptr_, __f, __l);
	base::__sz() += __c.__sz();
	__c.__sz() = 0;
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__libcpp_db* __db = __get_db();
	__c_node* __cn1 = __db->__find_c_and_lock(this);
	__c_node* __cn2 = __db->__find_c(&__c);
	for (__i_node** __ip = __cn2->end_; __ip != __cn2->beg_;)
	{
	--__ip;
	iterator* __i = static_cast<iterator>((__ip)->__i_);
	if (__i->__ptr_ != __c.__end_as_link())
	{
	__cn1->__add(*__ip);
	(*__ip)->__c_ = __cn1;
	if (--__cn2->end_ != __ip)
	memmove(__ip, __ip+1, (__cn2->end_ - __ip)sizeof(__i_node));
	}
	}
	__db->unlock();
	#endif
	}
	}

	template <class _Tp, class _Alloc>
	void
	list<_Tp, _Alloc>::splice(const_iterator __p, list& __c, const_iterator __i)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"list::splice(iterator, list, iterator) called with first iterator not"
	" referring to this list");
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__i) == &__c,
	"list::splice(iterator, list, iterator) called with second iterator not"
	" referring to list argument");
	_LIBCPP_ASSERT(__get_const_db()->__dereferenceable(&__i),
	"list::splice(iterator, list, iterator) called with second iterator not"
	" derefereceable");
	#endif
	if (__p.__ptr_ != __i.__ptr_ && __p.__ptr_ != __i.__ptr_->__next_)
	{
	__link_pointer __f = __i.__ptr_;
	base::__unlink_nodes(__f, __f);
	__link_nodes(__p.__ptr_, __f, __f);
	--__c.__sz();
	++base::__sz();
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__libcpp_db* __db = __get_db();
	__c_node* __cn1 = __db->__find_c_and_lock(this);
	__c_node* __cn2 = __db->__find_c(&__c);
	for (__i_node** __ip = __cn2->end_; __ip != __cn2->beg_;)
	{
	--__ip;
	iterator* __j = static_cast<iterator>((__ip)->__i_);
	if (__j->__ptr_ == __f)
	{
	__cn1->__add(*__ip);
	(*__ip)->__c_ = __cn1;
	if (--__cn2->end_ != __ip)
	memmove(__ip, __ip+1, (__cn2->end_ - __ip)sizeof(__i_node));
	}
	}
	__db->unlock();
	#endif
	}
	}

	template <class _Tp, class _Alloc>
	void
	list<_Tp, _Alloc>::splice(const_iterator __p, list& __c, const_iterator __f, const_iterator __l)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"list::splice(iterator, list, iterator, iterator) called with first iterator not"
	" referring to this list");
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__f) == &__c,
	"list::splice(iterator, list, iterator, iterator) called with second iterator not"
	" referring to list argument");
	if (this == &__c)
	{
	for (const_iterator __i = __f; __i != __l; ++__i)
	_LIBCPP_ASSERT(__i != __p,
	"list::splice(iterator, list, iterator, iterator)"
	" called with the first iterator within the range"
	" of the second and third iterators");
	}
	#endif
	if (__f != __l)
	{
	__link_pointer __first = __f.__ptr_;
	--__l;
	__link_pointer __last = __l.__ptr_;
	if (this != &__c)
	{
	size_type __s = _VSTD::distance(__f, __l) + 1;
	__c.__sz() -= __s;
	base::__sz() += __s;
	}
	base::__unlink_nodes(__first, __last);
	__link_nodes(__p.__ptr_, __first, __last);
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__libcpp_db* __db = __get_db();
	__c_node* __cn1 = __db->__find_c_and_lock(this);
	__c_node* __cn2 = __db->__find_c(&__c);
	for (__i_node** __ip = __cn2->end_; __ip != __cn2->beg_;)
	{
	--__ip;
	iterator* __j = static_cast<iterator>((__ip)->__i_);
	for (__link_pointer __k = __f.__ptr_;
	__k != __l.__ptr_; __k = __k->__next_)
	{
	if (__j->__ptr_ == __k)
	{
	__cn1->__add(*__ip);
	(*__ip)->__c_ = __cn1;
	if (--__cn2->end_ != __ip)
	memmove(__ip, __ip+1, (__cn2->end_ - __ip)sizeof(__i_node));
	}
	}
	}
	__db->unlock();
	#endif
	}
	}

	template <class _Tp, class _Alloc>
	void
	list<_Tp, _Alloc>::remove(const value_type& __x)
	{
	list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
	for (const_iterator __i = begin(), __e = end(); __i != __e;)
	{
	if (*__i == __x)
	{
	const_iterator __j = _VSTD::next(__i);
	for (; __j != __e && *__j == __x; ++__j)
	;
	__deleted_nodes.splice(__deleted_nodes.end(), *this, __i, __j);
	__i = __j;
	if (__i != __e)
	++__i;
	}
	else
	++__i;
	}
	}

	template <class _Tp, class _Alloc>
	template <class _Pred>
	void
	list<_Tp, _Alloc>::remove_if(_Pred __pred)
	{
	for (iterator __i = begin(), __e = end(); __i != __e;)
	{
	if (__pred(*__i))
	{
	iterator __j = _VSTD::next(__i);
	for (; __j != __e && __pred(*__j); ++__j)
	;
	__i = erase(__i, __j);
	if (__i != __e)
	++__i;
	}
	else
	++__i;
	}
	}

	template <class _Tp, class _Alloc>
	inline
	void
	list<_Tp, _Alloc>::unique()
	{
	unique(__equal_to<value_type>());
	}

	template <class _Tp, class _Alloc>
	template <class _BinaryPred>
	void
	list<_Tp, _Alloc>::unique(_BinaryPred __binary_pred)
	{
	for (iterator __i = begin(), __e = end(); __i != __e;)
	{
	iterator __j = _VSTD::next(__i);
	for (; __j != __e && __binary_pred(__i, __j); ++__j)
	;
	if (++__i != __j)
	__i = erase(__i, __j);
	}
	}

	template <class _Tp, class _Alloc>
	inline
	void
	list<_Tp, _Alloc>::merge(list& __c)
	{
	merge(__c, __less<value_type>());
	}

	template <class _Tp, class _Alloc>
	template <class _Comp>
	void
	list<_Tp, _Alloc>::merge(list& __c, _Comp __comp)
	{
	if (this != &__c)
	{
	iterator __f1 = begin();
	iterator __e1 = end();
	iterator __f2 = __c.begin();
	iterator __e2 = __c.end();
	while (__f1 != __e1 && __f2 != __e2)
	{
	if (__comp(__f2, __f1))
	{
	size_type __ds = 1;
	iterator __m2 = _VSTD::next(__f2);
	for (; __m2 != __e2 && __comp(__m2, __f1); ++__m2, ++__ds)
	;
	base::__sz() += __ds;
	__c.__sz() -= __ds;
	__link_pointer __f = __f2.__ptr_;
	__link_pointer __l = __m2.__ptr_->__prev_;
	__f2 = __m2;
	base::__unlink_nodes(__f, __l);
	__m2 = _VSTD::next(__f1);
	__link_nodes(__f1.__ptr_, __f, __l);
	__f1 = __m2;
	}
	else
	++__f1;
	}
	splice(__e1, __c);
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__libcpp_db* __db = __get_db();
	__c_node* __cn1 = __db->__find_c_and_lock(this);
	__c_node* __cn2 = __db->__find_c(&__c);
	for (__i_node** __p = __cn2->end_; __p != __cn2->beg_;)
	{
	--__p;
	iterator* __i = static_cast<iterator>((__p)->__i_);
	if (__i->__ptr_ != __c.__end_as_link())
	{
	__cn1->__add(*__p);
	(*__p)->__c_ = __cn1;
	if (--__cn2->end_ != __p)
	memmove(__p, __p+1, (__cn2->end_ - __p)sizeof(__i_node));
	}
	}
	__db->unlock();
	#endif
	}
	}

	template <class _Tp, class _Alloc>
	inline
	void
	list<_Tp, _Alloc>::sort()
	{
	sort(__less<value_type>());
	}

	template <class _Tp, class _Alloc>
	template <class _Comp>
	inline
	void
	list<_Tp, _Alloc>::sort(_Comp __comp)
	{
	__sort(begin(), end(), base::__sz(), __comp);
	}

	template <class _Tp, class _Alloc>
	template <class _Comp>
	typename list<_Tp, _Alloc>::iterator
	list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __comp)
	{
	switch (__n)
	{
	case 0:
	case 1:
	return __f1;
	case 2:
	if (__comp(--__e2, __f1))
	{
	__link_pointer __f = __e2.__ptr_;
	base::__unlink_nodes(__f, __f);
	__link_nodes(__f1.__ptr_, __f, __f);
	return __e2;
	}
	return __f1;
	}
	size_type __n2 = __n / 2;
	iterator __e1 = _VSTD::next(__f1, __n2);
	iterator __r = __f1 = __sort(__f1, __e1, __n2, __comp);
	iterator __f2 = __e1 = __sort(__e1, __e2, __n - __n2, __comp);
	if (__comp(__f2, __f1))
	{
	iterator __m2 = _VSTD::next(__f2);
	for (; __m2 != __e2 && __comp(__m2, __f1); ++__m2)
	;
	__link_pointer __f = __f2.__ptr_;
	__link_pointer __l = __m2.__ptr_->__prev_;
	__r = __f2;
	__e1 = __f2 = __m2;
	base::__unlink_nodes(__f, __l);
	__m2 = _VSTD::next(__f1);
	__link_nodes(__f1.__ptr_, __f, __l);
	__f1 = __m2;
	}
	else
	++__f1;
	while (__f1 != __e1 && __f2 != __e2)
	{
	if (__comp(__f2, __f1))
	{
	iterator __m2 = _VSTD::next(__f2);
	for (; __m2 != __e2 && __comp(__m2, __f1); ++__m2)
	;
	__link_pointer __f = __f2.__ptr_;
	__link_pointer __l = __m2.__ptr_->__prev_;
	if (__e1 == __f2)
	__e1 = __m2;
	__f2 = __m2;
	base::__unlink_nodes(__f, __l);
	__m2 = _VSTD::next(__f1);
	__link_nodes(__f1.__ptr_, __f, __l);
	__f1 = __m2;
	}
	else
	++__f1;
	}
	return __r;
	}

	template <class _Tp, class _Alloc>
	void
	list<_Tp, _Alloc>::reverse() _NOEXCEPT
	{
	if (base::__sz() > 1)
	{
	iterator __e = end();
	for (iterator __i = begin(); __i.__ptr_ != __e.__ptr_;)
	{
	_VSTD::swap(__i.__ptr_->__prev_, __i.__ptr_->__next_);
	__i.__ptr_ = __i.__ptr_->__prev_;
	}
	_VSTD::swap(__e.__ptr_->__prev_, __e.__ptr_->__next_);
	}
	}

	template <class _Tp, class _Alloc>
	bool
	list<_Tp, _Alloc>::__invariants() const
	{
	return size() == _VSTD::distance(begin(), end());
	}

	#if _LIBCPP_DEBUG_LEVEL >= 2

	template <class _Tp, class _Alloc>
	bool
	list<_Tp, _Alloc>::__dereferenceable(const const_iterator* __i) const
	{
	return __i->__ptr_ != this->__end_as_link();
	}

	template <class _Tp, class _Alloc>
	bool
	list<_Tp, _Alloc>::__decrementable(const const_iterator* __i) const
	{
	return !empty() && __i->__ptr_ != base::__end_.__next_;
	}

	template <class _Tp, class _Alloc>
	bool
	list<_Tp, _Alloc>::__addable(const const_iterator*, ptrdiff_t) const
	{
	return false;
	}

	template <class _Tp, class _Alloc>
	bool
	list<_Tp, _Alloc>::__subscriptable(const const_iterator*, ptrdiff_t) const
	{
	return false;
	}

	#endif // _LIBCPP_DEBUG_LEVEL >= 2

	template <class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
	{
	return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
	}

	template <class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator< (const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
	{
	return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
	}

	template <class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
	{
	return !(__x == __y);
	}

	template <class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator> (const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
	{
	return __y < __x;
	}

	template <class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
	{
	return !(__x < __y);
	}

	template <class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
	{
	return !(__y < __x);
	}

	template <class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
	_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
	{
	__x.swap(__y);
	}

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_LIST
	Index: projects/clang700-import/contrib/libc++/include/locale
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/locale (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/locale (revision 337135)
	@@ -1,4335 +1,4336 @@
	// -- C++ --
	//===-------------------------- locale ------------------------------------===//
	//
	// 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_LOCALE
	#define _LIBCPP_LOCALE

	/*
	locale synopsis

	namespace std
	{

	class locale
	{
	public:
	// types:
	class facet;
	class id;

	typedef int category;
	static const category // values assigned here are for exposition only
	none = 0x000,
	collate = 0x010,
	ctype = 0x020,
	monetary = 0x040,
	numeric = 0x080,
	time = 0x100,
	messages = 0x200,
	all = collate \| ctype \| monetary \| numeric \| time \| messages;

	// construct/copy/destroy:
	locale() noexcept;
	locale(const locale& other) noexcept;
	explicit locale(const char* std_name);
	explicit locale(const string& std_name);
	locale(const locale& other, const char* std_name, category);
	locale(const locale& other, const string& std_name, category);
	template <class Facet> locale(const locale& other, Facet* f);
	locale(const locale& other, const locale& one, category);

	~locale(); // not virtual

	const locale& operator=(const locale& other) noexcept;

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

	// locale operations:
	basic_string<char> name() const;
	bool operator==(const locale& other) const;
	bool operator!=(const locale& other) const;
	template <class charT, class Traits, class Allocator>
	bool operator()(const basic_string<charT,Traits,Allocator>& s1,
	const basic_string<charT,Traits,Allocator>& s2) const;

	// global locale objects:
	static locale global(const locale&);
	static const locale& classic();
	};

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

	// 22.3.3, convenience interfaces:
	template <class charT> bool isspace (charT c, const locale& loc);
	template <class charT> bool isprint (charT c, const locale& loc);
	template <class charT> bool iscntrl (charT c, const locale& loc);
	template <class charT> bool isupper (charT c, const locale& loc);
	template <class charT> bool islower (charT c, const locale& loc);
	template <class charT> bool isalpha (charT c, const locale& loc);
	template <class charT> bool isdigit (charT c, const locale& loc);
	template <class charT> bool ispunct (charT c, const locale& loc);
	template <class charT> bool isxdigit(charT c, const locale& loc);
	template <class charT> bool isalnum (charT c, const locale& loc);
	template <class charT> bool isgraph (charT c, const locale& loc);
	template <class charT> charT toupper(charT c, const locale& loc);
	template <class charT> charT tolower(charT c, const locale& loc);

	template<class Codecvt, class Elem = wchar_t,
	class Wide_alloc = allocator<Elem>,
	class Byte_alloc = allocator<char>>
	class wstring_convert
	{
	public:
	typedef basic_string<char, char_traits<char>, Byte_alloc> byte_string;
	typedef basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
	typedef typename Codecvt::state_type state_type;
	typedef typename wide_string::traits_type::int_type int_type;

	explicit wstring_convert(Codecvt* pcvt = new Codecvt); // explicit in C++14
	wstring_convert(Codecvt* pcvt, state_type state);
	explicit wstring_convert(const byte_string& byte_err, // explicit in C++14
	const wide_string& wide_err = wide_string());
	wstring_convert(const wstring_convert&) = delete; // C++14
	wstring_convert & operator=(const wstring_convert &) = delete; // C++14
	~wstring_convert();

	wide_string from_bytes(char byte);
	wide_string from_bytes(const char* ptr);
	wide_string from_bytes(const byte_string& str);
	wide_string from_bytes(const char* first, const char* last);

	byte_string to_bytes(Elem wchar);
	byte_string to_bytes(const Elem* wptr);
	byte_string to_bytes(const wide_string& wstr);
	byte_string to_bytes(const Elem* first, const Elem* last);

	size_t converted() const; // noexcept in C++14
	state_type state() const;
	};

	template <class Codecvt, class Elem = wchar_t, class Tr = char_traits<Elem>>
	class wbuffer_convert
	: public basic_streambuf<Elem, Tr>
	{
	public:
	typedef typename Tr::state_type state_type;

	explicit wbuffer_convert(streambuf* bytebuf = 0, Codecvt* pcvt = new Codecvt,
	state_type state = state_type()); // explicit in C++14
	wbuffer_convert(const wbuffer_convert&) = delete; // C++14
	wbuffer_convert & operator=(const wbuffer_convert &) = delete; // C++14
	~wbuffer_convert(); // C++14

	streambuf* rdbuf() const;
	streambuf* rdbuf(streambuf* bytebuf);

	state_type state() const;
	};

	// 22.4.1 and 22.4.1.3, ctype:
	class ctype_base;
	template <class charT> class ctype;
	template <> class ctype<char>; // specialization
	template <class charT> class ctype_byname;
	template <> class ctype_byname<char>; // specialization

	class codecvt_base;
	template <class internT, class externT, class stateT> class codecvt;
	template <class internT, class externT, class stateT> class codecvt_byname;

	// 22.4.2 and 22.4.3, numeric:
	template <class charT, class InputIterator> class num_get;
	template <class charT, class OutputIterator> class num_put;
	template <class charT> class numpunct;
	template <class charT> class numpunct_byname;

	// 22.4.4, col lation:
	template <class charT> class collate;
	template <class charT> class collate_byname;

	// 22.4.5, date and time:
	class time_base;
	template <class charT, class InputIterator> class time_get;
	template <class charT, class InputIterator> class time_get_byname;
	template <class charT, class OutputIterator> class time_put;
	template <class charT, class OutputIterator> class time_put_byname;

	// 22.4.6, money:
	class money_base;
	template <class charT, class InputIterator> class money_get;
	template <class charT, class OutputIterator> class money_put;
	template <class charT, bool Intl> class moneypunct;
	template <class charT, bool Intl> class moneypunct_byname;

	// 22.4.7, message retrieval:
	class messages_base;
	template <class charT> class messages;
	template <class charT> class messages_byname;

	} // std

	*/

	#include <__config>
	#include <__locale>
	#include <__debug>
	#include <algorithm>
	#include <memory>
	#include <ios>
	#include <streambuf>
	#include <iterator>
	#include <limits>
	#ifndef __APPLE__
	#include <cstdarg>
	#endif
	#include <cstdlib>
	#include <ctime>
	#include <cstdio>
	#ifdef _LIBCPP_HAS_CATOPEN
	#include <nl_types.h>
	#endif

	#ifdef __APPLE__
	#include <Availability.h>
	#endif

	#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
	#include <__bsd_locale_defaults.h>
	#else
	#include <__bsd_locale_fallbacks.h>
	#endif

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_STD

	#if defined(__APPLE__) \|\| defined(__FreeBSD__)
	# define _LIBCPP_GET_C_LOCALE 0
	#elif defined(__CloudABI__) \|\| defined(__NetBSD__)
	# define _LIBCPP_GET_C_LOCALE LC_C_LOCALE
	#else
	# define _LIBCPP_GET_C_LOCALE __cloc()
	// Get the C locale object
	_LIBCPP_FUNC_VIS locale_t __cloc();
	#define __cloc_defined
	#endif

	// __scan_keyword
	// Scans [__b, __e) until a match is found in the basic_strings range
	// [__kb, __ke) or until it can be shown that there is no match in [__kb, __ke).
	// __b will be incremented (visibly), consuming CharT until a match is found
	// or proved to not exist. A keyword may be "", in which will match anything.
	// If one keyword is a prefix of another, and the next CharT in the input
	// might match another keyword, the algorithm will attempt to find the longest
	// matching keyword. If the longer matching keyword ends up not matching, then
	// no keyword match is found. If no keyword match is found, __ke is returned
	// and failbit is set in __err.
	// Else an iterator pointing to the matching keyword is found. If more than
	// one keyword matches, an iterator to the first matching keyword is returned.
	// If on exit __b == __e, eofbit is set in __err. If __case_sensitive is false,
	// __ct is used to force to lower case before comparing characters.
	// Examples:
	// Keywords: "a", "abb"
	// If the input is "a", the first keyword matches and eofbit is set.
	// If the input is "abc", no match is found and "ab" are consumed.
	template <class _InputIterator, class _ForwardIterator, class _Ctype>
	_LIBCPP_HIDDEN
	_ForwardIterator
	__scan_keyword(_InputIterator& __b, _InputIterator __e,
	_ForwardIterator __kb, _ForwardIterator __ke,
	const _Ctype& __ct, ios_base::iostate& __err,
	bool __case_sensitive = true)
	{
	typedef typename iterator_traits<_InputIterator>::value_type _CharT;
	size_t __nkw = static_cast<size_t>(_VSTD::distance(__kb, __ke));
	const unsigned char __doesnt_match = '\0';
	const unsigned char __might_match = '\1';
	const unsigned char __does_match = '\2';
	unsigned char __statbuf[100];
	unsigned char* __status = __statbuf;
	unique_ptr<unsigned char, void()(void)> __stat_hold(0, free);
	if (__nkw > sizeof(__statbuf))
	{
	__status = (unsigned char*)malloc(__nkw);
	if (__status == 0)
	__throw_bad_alloc();
	__stat_hold.reset(__status);
	}
	size_t __n_might_match = __nkw; // At this point, any keyword might match
	size_t __n_does_match = 0; // but none of them definitely do
	// Initialize all statuses to __might_match, except for "" keywords are __does_match
	unsigned char* __st = __status;
	for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void) ++__st)
	{
	if (!__ky->empty())
	*__st = __might_match;
	else
	{
	*__st = __does_match;
	--__n_might_match;
	++__n_does_match;
	}
	}
	// While there might be a match, test keywords against the next CharT
	for (size_t __indx = 0; __b != __e && __n_might_match > 0; ++__indx)
	{
	// Peek at the next CharT but don't consume it
	_CharT __c = *__b;
	if (!__case_sensitive)
	__c = __ct.toupper(__c);
	bool __consume = false;
	// For each keyword which might match, see if the __indx character is __c
	// If a match if found, consume __c
	// If a match is found, and that is the last character in the keyword,
	// then that keyword matches.
	// If the keyword doesn't match this character, then change the keyword
	// to doesn't match
	__st = __status;
	for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void) ++__st)
	{
	if (*__st == __might_match)
	{
	_CharT __kc = (*__ky)[__indx];
	if (!__case_sensitive)
	__kc = __ct.toupper(__kc);
	if (__c == __kc)
	{
	__consume = true;
	if (__ky->size() == __indx+1)
	{
	*__st = __does_match;
	--__n_might_match;
	++__n_does_match;
	}
	}
	else
	{
	*__st = __doesnt_match;
	--__n_might_match;
	}
	}
	}
	// consume if we matched a character
	if (__consume)
	{
	++__b;
	// If we consumed a character and there might be a matched keyword that
	// was marked matched on a previous iteration, then such keywords
	// which are now marked as not matching.
	if (__n_might_match + __n_does_match > 1)
	{
	__st = __status;
	for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void) ++__st)
	{
	if (*__st == __does_match && __ky->size() != __indx+1)
	{
	*__st = __doesnt_match;
	--__n_does_match;
	}
	}
	}
	}
	}
	// We've exited the loop because we hit eof and/or we have no more "might matches".
	if (__b == __e)
	__err \|= ios_base::eofbit;
	// Return the first matching result
	for (__st = __status; __kb != __ke; ++__kb, (void) ++__st)
	if (*__st == __does_match)
	break;
	if (__kb == __ke)
	__err \|= ios_base::failbit;
	return __kb;
	}

	struct _LIBCPP_TYPE_VIS __num_get_base
	{
	static const int __num_get_buf_sz = 40;

	static int __get_base(ios_base&);
	static const char __src[33];
	};

	_LIBCPP_FUNC_VIS
	void __check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end,
	ios_base::iostate& __err);

	template <class _CharT>
	struct __num_get
	: protected __num_get_base
	{
	static string __stage2_float_prep(ios_base& __iob, _CharT* __atoms, _CharT& __decimal_point,
	_CharT& __thousands_sep);

	static int __stage2_float_loop(_CharT __ct, bool& __in_units, char& __exp,
	char* __a, char*& __a_end,
	_CharT __decimal_point, _CharT __thousands_sep,
	const string& __grouping, unsigned* __g,
	unsigned& __g_end, unsigned& __dc, _CharT __atoms);
	#ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
	static string __stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep);
	static int __stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end,
	unsigned& __dc, _CharT __thousands_sep, const string& __grouping,
	unsigned* __g, unsigned& __g_end, _CharT __atoms);

	#else
	static string __stage2_int_prep(ios_base& __iob, _CharT& __thousands_sep)
	{
	locale __loc = __iob.getloc();
	const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
	__thousands_sep = __np.thousands_sep();
	return __np.grouping();
	}

	const _CharT* __do_widen(ios_base& __iob, _CharT* __atoms) const
	{
	return __do_widen_p(__iob, __atoms);
	}


	static int __stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end,
	unsigned& __dc, _CharT __thousands_sep, const string& __grouping,
	unsigned* __g, unsigned& __g_end, const _CharT __atoms);
	private:
	template<typename T>
	const T* __do_widen_p(ios_base& __iob, T* __atoms) const
	{
	locale __loc = __iob.getloc();
	use_facet<ctype<T> >(__loc).widen(__src, __src + 26, __atoms);
	return __atoms;
	}

	const char* __do_widen_p(ios_base& __iob, char* __atoms) const
	{
	(void)__iob;
	(void)__atoms;
	return __src;
	}
	#endif
	};

	#ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
	template <class _CharT>
	string
	__num_get<_CharT>::__stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep)
	{
	locale __loc = __iob.getloc();
	use_facet<ctype<_CharT> >(__loc).widen(__src, __src + 26, __atoms);
	const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
	__thousands_sep = __np.thousands_sep();
	return __np.grouping();
	}
	#endif

	template <class _CharT>
	string
	__num_get<_CharT>::__stage2_float_prep(ios_base& __iob, _CharT* __atoms, _CharT& __decimal_point,
	_CharT& __thousands_sep)
	{
	locale __loc = __iob.getloc();
	use_facet<ctype<_CharT> >(__loc).widen(__src, __src + 32, __atoms);
	const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
	__decimal_point = __np.decimal_point();
	__thousands_sep = __np.thousands_sep();
	return __np.grouping();
	}

	template <class _CharT>
	int
	#ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
	__num_get<_CharT>::__stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end,
	unsigned& __dc, _CharT __thousands_sep, const string& __grouping,
	unsigned* __g, unsigned& __g_end, _CharT __atoms)
	#else
	__num_get<_CharT>::__stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end,
	unsigned& __dc, _CharT __thousands_sep, const string& __grouping,
	unsigned* __g, unsigned& __g_end, const _CharT __atoms)

	#endif
	{
	if (__a_end == __a && (__ct == __atoms[24] \|\| __ct == __atoms[25]))
	{
	*__a_end++ = __ct == __atoms[24] ? '+' : '-';
	__dc = 0;
	return 0;
	}
	if (__grouping.size() != 0 && __ct == __thousands_sep)
	{
	if (__g_end-__g < __num_get_buf_sz)
	{
	*__g_end++ = __dc;
	__dc = 0;
	}
	return 0;
	}
	ptrdiff_t __f = find(__atoms, __atoms + 26, __ct) - __atoms;
	if (__f >= 24)
	return -1;
	switch (__base)
	{
	case 8:
	case 10:
	if (__f >= __base)
	return -1;
	break;
	case 16:
	if (__f < 22)
	break;
	if (__a_end != __a && __a_end - __a <= 2 && __a_end[-1] == '0')
	{
	__dc = 0;
	*__a_end++ = __src[__f];
	return 0;
	}
	return -1;
	}
	*__a_end++ = __src[__f];
	++__dc;
	return 0;
	}

	template <class _CharT>
	int
	__num_get<_CharT>::__stage2_float_loop(_CharT __ct, bool& __in_units, char& __exp, char* __a, char*& __a_end,
	_CharT __decimal_point, _CharT __thousands_sep, const string& __grouping,
	unsigned* __g, unsigned& __g_end, unsigned& __dc, _CharT __atoms)
	{
	if (__ct == __decimal_point)
	{
	if (!__in_units)
	return -1;
	__in_units = false;
	*__a_end++ = '.';
	if (__grouping.size() != 0 && __g_end-__g < __num_get_buf_sz)
	*__g_end++ = __dc;
	return 0;
	}
	if (__ct == __thousands_sep && __grouping.size() != 0)
	{
	if (!__in_units)
	return -1;
	if (__g_end-__g < __num_get_buf_sz)
	{
	*__g_end++ = __dc;
	__dc = 0;
	}
	return 0;
	}
	ptrdiff_t __f = find(__atoms, __atoms + 32, __ct) - __atoms;
	if (__f >= 32)
	return -1;
	char __x = __src[__f];
	if (__x == '-' \|\| __x == '+')
	{
	if (__a_end == __a \|\| (__a_end[-1] & 0x5F) == (__exp & 0x7F))
	{
	*__a_end++ = __x;
	return 0;
	}
	return -1;
	}
	if (__x == 'x' \|\| __x == 'X')
	__exp = 'P';
	else if ((__x & 0x5F) == __exp)
	{
	__exp \|= 0x80;
	if (__in_units)
	{
	__in_units = false;
	if (__grouping.size() != 0 && __g_end-__g < __num_get_buf_sz)
	*__g_end++ = __dc;
	}
	}
	*__a_end++ = __x;
	if (__f >= 22)
	return 0;
	++__dc;
	return 0;
	}

	_LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<char>)
	_LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<wchar_t>)

	template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
	class _LIBCPP_TEMPLATE_VIS num_get
	: public locale::facet,
	private __num_get<_CharT>
	{
	public:
	typedef _CharT char_type;
	typedef _InputIterator iter_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit num_get(size_t __refs = 0)
	: locale::facet(__refs) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, bool& __v) const
	{
	return do_get(__b, __e, __iob, __err, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, long& __v) const
	{
	return do_get(__b, __e, __iob, __err, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, long long& __v) const
	{
	return do_get(__b, __e, __iob, __err, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, unsigned short& __v) const
	{
	return do_get(__b, __e, __iob, __err, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, unsigned int& __v) const
	{
	return do_get(__b, __e, __iob, __err, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, unsigned long& __v) const
	{
	return do_get(__b, __e, __iob, __err, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, unsigned long long& __v) const
	{
	return do_get(__b, __e, __iob, __err, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, float& __v) const
	{
	return do_get(__b, __e, __iob, __err, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, double& __v) const
	{
	return do_get(__b, __e, __iob, __err, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, long double& __v) const
	{
	return do_get(__b, __e, __iob, __err, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, void*& __v) const
	{
	return do_get(__b, __e, __iob, __err, __v);
	}

	static locale::id id;

	protected:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	~num_get() {}

	template <class _Fp>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	iter_type __do_get_floating_point
	(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, _Fp& __v) const;

	template <class _Signed>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	iter_type __do_get_signed
	(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, _Signed& __v) const;

	template <class _Unsigned>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	iter_type __do_get_unsigned
	(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, _Unsigned& __v) const;


	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, bool& __v) const;

	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, long& __v) const
	{ return this->__do_get_signed ( __b, __e, __iob, __err, __v ); }

	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, long long& __v) const
	{ return this->__do_get_signed ( __b, __e, __iob, __err, __v ); }

	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, unsigned short& __v) const
	{ return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); }

	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, unsigned int& __v) const
	{ return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); }

	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, unsigned long& __v) const
	{ return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); }

	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, unsigned long long& __v) const
	{ return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); }

	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, float& __v) const
	{ return this->__do_get_floating_point ( __b, __e, __iob, __err, __v ); }

	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, double& __v) const
	{ return this->__do_get_floating_point ( __b, __e, __iob, __err, __v ); }

	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, long double& __v) const
	{ return this->__do_get_floating_point ( __b, __e, __iob, __err, __v ); }

	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, void*& __v) const;
	};

	template <class _CharT, class _InputIterator>
	locale::id
	num_get<_CharT, _InputIterator>::id;

	template <class _Tp>
	_Tp
	__num_get_signed_integral(const char* __a, const char* __a_end,
	ios_base::iostate& __err, int __base)
	{
	if (__a != __a_end)
	{
	typename remove_reference<decltype(errno)>::type __save_errno = errno;
	errno = 0;
	char *__p2;
	long long __ll = strtoll_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
	typename remove_reference<decltype(errno)>::type __current_errno = errno;
	if (__current_errno == 0)
	errno = __save_errno;
	if (__p2 != __a_end)
	{
	__err = ios_base::failbit;
	return 0;
	}
	else if (__current_errno == ERANGE \|\|
	__ll < numeric_limits<_Tp>::min() \|\|
	numeric_limits<_Tp>::max() < __ll)
	{
	__err = ios_base::failbit;
	if (__ll > 0)
	return numeric_limits<_Tp>::max();
	else
	return numeric_limits<_Tp>::min();
	}
	return static_cast<_Tp>(__ll);
	}
	__err = ios_base::failbit;
	return 0;
	}

	template <class _Tp>
	_Tp
	__num_get_unsigned_integral(const char* __a, const char* __a_end,
	ios_base::iostate& __err, int __base)
	{
	if (__a != __a_end)
	{
	- if (*__a == '-')
	- {
	- __err = ios_base::failbit;
	- return 0;
	+ const bool __negate = *__a == '-';
	+ if (__negate && ++__a == __a_end) {
	+ __err = ios_base::failbit;
	+ return 0;
	}
	typename remove_reference<decltype(errno)>::type __save_errno = errno;
	errno = 0;
	char *__p2;
	unsigned long long __ll = strtoull_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
	typename remove_reference<decltype(errno)>::type __current_errno = errno;
	if (__current_errno == 0)
	errno = __save_errno;
	if (__p2 != __a_end)
	{
	__err = ios_base::failbit;
	return 0;
	}
	- else if (__current_errno == ERANGE \|\|
	- numeric_limits<_Tp>::max() < __ll)
	+ else if (__current_errno == ERANGE \|\| numeric_limits<_Tp>::max() < __ll)
	{
	__err = ios_base::failbit;
	return numeric_limits<_Tp>::max();
	}
	- return static_cast<_Tp>(__ll);
	+ _Tp __res = static_cast<_Tp>(__ll);
	+ if (__negate) __res = -__res;
	+ return __res;
	}
	__err = ios_base::failbit;
	return 0;
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	_Tp __do_strtod(const char* __a, char** __p2);

	template <>
	inline _LIBCPP_INLINE_VISIBILITY
	float __do_strtod<float>(const char* __a, char** __p2) {
	return strtof_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
	}

	template <>
	inline _LIBCPP_INLINE_VISIBILITY
	double __do_strtod<double>(const char* __a, char** __p2) {
	return strtod_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
	}

	template <>
	inline _LIBCPP_INLINE_VISIBILITY
	long double __do_strtod<long double>(const char* __a, char** __p2) {
	return strtold_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
	}

	template <class _Tp>
	_LIBCPP_HIDDEN
	_Tp
	__num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err)
	{
	if (__a != __a_end)
	{
	typename remove_reference<decltype(errno)>::type __save_errno = errno;
	errno = 0;
	char *__p2;
	_Tp __ld = __do_strtod<_Tp>(__a, &__p2);
	typename remove_reference<decltype(errno)>::type __current_errno = errno;
	if (__current_errno == 0)
	errno = __save_errno;
	if (__p2 != __a_end)
	{
	__err = ios_base::failbit;
	return 0;
	}
	else if (__current_errno == ERANGE)
	__err = ios_base::failbit;
	return __ld;
	}
	__err = ios_base::failbit;
	return 0;
	}

	template <class _CharT, class _InputIterator>
	_InputIterator
	num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
	ios_base& __iob,
	ios_base::iostate& __err,
	bool& __v) const
	{
	if ((__iob.flags() & ios_base::boolalpha) == 0)
	{
	long __lv = -1;
	__b = do_get(__b, __e, __iob, __err, __lv);
	switch (__lv)
	{
	case 0:
	__v = false;
	break;
	case 1:
	__v = true;
	break;
	default:
	__v = true;
	__err = ios_base::failbit;
	break;
	}
	return __b;
	}
	const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__iob.getloc());
	const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__iob.getloc());
	typedef typename numpunct<_CharT>::string_type string_type;
	const string_type __names[2] = {__np.truename(), __np.falsename()};
	const string_type* __i = __scan_keyword(__b, __e, __names, __names+2,
	__ct, __err);
	__v = __i == __names;
	return __b;
	}

	// signed

	template <class _CharT, class _InputIterator>
	template <class _Signed>
	_InputIterator
	num_get<_CharT, _InputIterator>::__do_get_signed(iter_type __b, iter_type __e,
	ios_base& __iob,
	ios_base::iostate& __err,
	_Signed& __v) const
	{
	// Stage 1
	int __base = this->__get_base(__iob);
	// Stage 2
	char_type __thousands_sep;
	const int __atoms_size = 26;
	#ifdef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
	char_type __atoms1[__atoms_size];
	const char_type *__atoms = this->__do_widen(__iob, __atoms1);
	string __grouping = this->__stage2_int_prep(__iob, __thousands_sep);
	#else
	char_type __atoms[__atoms_size];
	string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep);
	#endif
	string __buf;
	__buf.resize(__buf.capacity());
	char* __a = &__buf[0];
	char* __a_end = __a;
	unsigned __g[__num_get_base::__num_get_buf_sz];
	unsigned* __g_end = __g;
	unsigned __dc = 0;
	for (; __b != __e; ++__b)
	{
	if (__a_end == __a + __buf.size())
	{
	size_t __tmp = __buf.size();
	__buf.resize(2*__buf.size());
	__buf.resize(__buf.capacity());
	__a = &__buf[0];
	__a_end = __a + __tmp;
	}
	if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
	__thousands_sep, __grouping, __g, __g_end,
	__atoms))
	break;
	}
	if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz)
	*__g_end++ = __dc;
	// Stage 3
	__v = __num_get_signed_integral<_Signed>(__a, __a_end, __err, __base);
	// Digit grouping checked
	__check_grouping(__grouping, __g, __g_end, __err);
	// EOF checked
	if (__b == __e)
	__err \|= ios_base::eofbit;
	return __b;
	}

	// unsigned

	template <class _CharT, class _InputIterator>
	template <class _Unsigned>
	_InputIterator
	num_get<_CharT, _InputIterator>::__do_get_unsigned(iter_type __b, iter_type __e,
	ios_base& __iob,
	ios_base::iostate& __err,
	_Unsigned& __v) const
	{
	// Stage 1
	int __base = this->__get_base(__iob);
	// Stage 2
	char_type __thousands_sep;
	const int __atoms_size = 26;
	#ifdef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
	char_type __atoms1[__atoms_size];
	const char_type *__atoms = this->__do_widen(__iob, __atoms1);
	string __grouping = this->__stage2_int_prep(__iob, __thousands_sep);
	#else
	char_type __atoms[__atoms_size];
	string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep);
	#endif
	string __buf;
	__buf.resize(__buf.capacity());
	char* __a = &__buf[0];
	char* __a_end = __a;
	unsigned __g[__num_get_base::__num_get_buf_sz];
	unsigned* __g_end = __g;
	unsigned __dc = 0;
	for (; __b != __e; ++__b)
	{
	if (__a_end == __a + __buf.size())
	{
	size_t __tmp = __buf.size();
	__buf.resize(2*__buf.size());
	__buf.resize(__buf.capacity());
	__a = &__buf[0];
	__a_end = __a + __tmp;
	}
	if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
	__thousands_sep, __grouping, __g, __g_end,
	__atoms))
	break;
	}
	if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz)
	*__g_end++ = __dc;
	// Stage 3
	__v = __num_get_unsigned_integral<_Unsigned>(__a, __a_end, __err, __base);
	// Digit grouping checked
	__check_grouping(__grouping, __g, __g_end, __err);
	// EOF checked
	if (__b == __e)
	__err \|= ios_base::eofbit;
	return __b;
	}

	// floating point

	template <class _CharT, class _InputIterator>
	template <class _Fp>
	_InputIterator
	num_get<_CharT, _InputIterator>::__do_get_floating_point(iter_type __b, iter_type __e,
	ios_base& __iob,
	ios_base::iostate& __err,
	_Fp& __v) const
	{
	// Stage 1, nothing to do
	// Stage 2
	char_type __atoms[32];
	char_type __decimal_point;
	char_type __thousands_sep;
	string __grouping = this->__stage2_float_prep(__iob, __atoms,
	__decimal_point,
	__thousands_sep);
	string __buf;
	__buf.resize(__buf.capacity());
	char* __a = &__buf[0];
	char* __a_end = __a;
	unsigned __g[__num_get_base::__num_get_buf_sz];
	unsigned* __g_end = __g;
	unsigned __dc = 0;
	bool __in_units = true;
	char __exp = 'E';
	for (; __b != __e; ++__b)
	{
	if (__a_end == __a + __buf.size())
	{
	size_t __tmp = __buf.size();
	__buf.resize(2*__buf.size());
	__buf.resize(__buf.capacity());
	__a = &__buf[0];
	__a_end = __a + __tmp;
	}
	if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end,
	__decimal_point, __thousands_sep,
	__grouping, __g, __g_end,
	__dc, __atoms))
	break;
	}
	if (__grouping.size() != 0 && __in_units && __g_end-__g < __num_get_base::__num_get_buf_sz)
	*__g_end++ = __dc;
	// Stage 3
	__v = __num_get_float<_Fp>(__a, __a_end, __err);
	// Digit grouping checked
	__check_grouping(__grouping, __g, __g_end, __err);
	// EOF checked
	if (__b == __e)
	__err \|= ios_base::eofbit;
	return __b;
	}

	template <class _CharT, class _InputIterator>
	_InputIterator
	num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
	ios_base& __iob,
	ios_base::iostate& __err,
	void*& __v) const
	{
	// Stage 1
	int __base = 16;
	// Stage 2
	char_type __atoms[26];
	char_type __thousands_sep = 0;
	string __grouping;
	use_facet<ctype<_CharT> >(__iob.getloc()).widen(__num_get_base::__src,
	__num_get_base::__src + 26, __atoms);
	string __buf;
	__buf.resize(__buf.capacity());
	char* __a = &__buf[0];
	char* __a_end = __a;
	unsigned __g[__num_get_base::__num_get_buf_sz];
	unsigned* __g_end = __g;
	unsigned __dc = 0;
	for (; __b != __e; ++__b)
	{
	if (__a_end == __a + __buf.size())
	{
	size_t __tmp = __buf.size();
	__buf.resize(2*__buf.size());
	__buf.resize(__buf.capacity());
	__a = &__buf[0];
	__a_end = __a + __tmp;
	}
	if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
	__thousands_sep, __grouping,
	__g, __g_end, __atoms))
	break;
	}
	// Stage 3
	__buf.resize(__a_end - __a);
	if (__libcpp_sscanf_l(__buf.c_str(), _LIBCPP_GET_C_LOCALE, "%p", &__v) != 1)
	__err = ios_base::failbit;
	// EOF checked
	if (__b == __e)
	__err \|= ios_base::eofbit;
	return __b;
	}

	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_get<char>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_get<wchar_t>)

	struct _LIBCPP_TYPE_VIS __num_put_base
	{
	protected:
	static void __format_int(char* __fmt, const char* __len, bool __signd,
	ios_base::fmtflags __flags);
	static bool __format_float(char* __fmt, const char* __len,
	ios_base::fmtflags __flags);
	static char* __identify_padding(char* __nb, char* __ne,
	const ios_base& __iob);
	};

	template <class _CharT>
	struct __num_put
	: protected __num_put_base
	{
	static void __widen_and_group_int(char* __nb, char* __np, char* __ne,
	_CharT* __ob, _CharT& __op, _CharT& __oe,
	const locale& __loc);
	static void __widen_and_group_float(char* __nb, char* __np, char* __ne,
	_CharT* __ob, _CharT& __op, _CharT& __oe,
	const locale& __loc);
	};

	template <class _CharT>
	void
	__num_put<_CharT>::__widen_and_group_int(char* __nb, char* __np, char* __ne,
	_CharT* __ob, _CharT& __op, _CharT& __oe,
	const locale& __loc)
	{
	const ctype<_CharT>& __ct = use_facet<ctype<_CharT> > (__loc);
	const numpunct<_CharT>& __npt = use_facet<numpunct<_CharT> >(__loc);
	string __grouping = __npt.grouping();
	if (__grouping.empty())
	{
	__ct.widen(__nb, __ne, __ob);
	__oe = __ob + (__ne - __nb);
	}
	else
	{
	__oe = __ob;
	char* __nf = __nb;
	if (__nf == '-' \|\| __nf == '+')
	__oe++ = __ct.widen(__nf++);
	if (__ne - __nf >= 2 && __nf[0] == '0' && (__nf[1] == 'x' \|\|
	__nf[1] == 'X'))
	{
	__oe++ = __ct.widen(__nf++);
	__oe++ = __ct.widen(__nf++);
	}
	reverse(__nf, __ne);
	_CharT __thousands_sep = __npt.thousands_sep();
	unsigned __dc = 0;
	unsigned __dg = 0;
	for (char* __p = __nf; __p < __ne; ++__p)
	{
	if (static_cast<unsigned>(__grouping[__dg]) > 0 &&
	__dc == static_cast<unsigned>(__grouping[__dg]))
	{
	*__oe++ = __thousands_sep;
	__dc = 0;
	if (__dg < __grouping.size()-1)
	++__dg;
	}
	__oe++ = __ct.widen(__p);
	++__dc;
	}
	reverse(__ob + (__nf - __nb), __oe);
	}
	if (__np == __ne)
	__op = __oe;
	else
	__op = __ob + (__np - __nb);
	}

	template <class _CharT>
	void
	__num_put<_CharT>::__widen_and_group_float(char* __nb, char* __np, char* __ne,
	_CharT* __ob, _CharT& __op, _CharT& __oe,
	const locale& __loc)
	{
	const ctype<_CharT>& __ct = use_facet<ctype<_CharT> > (__loc);
	const numpunct<_CharT>& __npt = use_facet<numpunct<_CharT> >(__loc);
	string __grouping = __npt.grouping();
	__oe = __ob;
	char* __nf = __nb;
	if (__nf == '-' \|\| __nf == '+')
	__oe++ = __ct.widen(__nf++);
	char* __ns;
	if (__ne - __nf >= 2 && __nf[0] == '0' && (__nf[1] == 'x' \|\|
	__nf[1] == 'X'))
	{
	__oe++ = __ct.widen(__nf++);
	__oe++ = __ct.widen(__nf++);
	for (__ns = __nf; __ns < __ne; ++__ns)
	if (!isxdigit_l(*__ns, _LIBCPP_GET_C_LOCALE))
	break;
	}
	else
	{
	for (__ns = __nf; __ns < __ne; ++__ns)
	if (!isdigit_l(*__ns, _LIBCPP_GET_C_LOCALE))
	break;
	}
	if (__grouping.empty())
	{
	__ct.widen(__nf, __ns, __oe);
	__oe += __ns - __nf;
	}
	else
	{
	reverse(__nf, __ns);
	_CharT __thousands_sep = __npt.thousands_sep();
	unsigned __dc = 0;
	unsigned __dg = 0;
	for (char* __p = __nf; __p < __ns; ++__p)
	{
	if (__grouping[__dg] > 0 && __dc == static_cast<unsigned>(__grouping[__dg]))
	{
	*__oe++ = __thousands_sep;
	__dc = 0;
	if (__dg < __grouping.size()-1)
	++__dg;
	}
	__oe++ = __ct.widen(__p);
	++__dc;
	}
	reverse(__ob + (__nf - __nb), __oe);
	}
	for (__nf = __ns; __nf < __ne; ++__nf)
	{
	if (*__nf == '.')
	{
	*__oe++ = __npt.decimal_point();
	++__nf;
	break;
	}
	else
	__oe++ = __ct.widen(__nf);
	}
	__ct.widen(__nf, __ne, __oe);
	__oe += __ne - __nf;
	if (__np == __ne)
	__op = __oe;
	else
	__op = __ob + (__np - __nb);
	}

	_LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_put<char>)
	_LIBCPP_EXTERN_TEMPLATE2(struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_put<wchar_t>)

	template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
	class _LIBCPP_TEMPLATE_VIS num_put
	: public locale::facet,
	private __num_put<_CharT>
	{
	public:
	typedef _CharT char_type;
	typedef _OutputIterator iter_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit num_put(size_t __refs = 0)
	: locale::facet(__refs) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
	bool __v) const
	{
	return do_put(__s, __iob, __fl, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
	long __v) const
	{
	return do_put(__s, __iob, __fl, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
	long long __v) const
	{
	return do_put(__s, __iob, __fl, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
	unsigned long __v) const
	{
	return do_put(__s, __iob, __fl, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
	unsigned long long __v) const
	{
	return do_put(__s, __iob, __fl, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
	double __v) const
	{
	return do_put(__s, __iob, __fl, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
	long double __v) const
	{
	return do_put(__s, __iob, __fl, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
	const void* __v) const
	{
	return do_put(__s, __iob, __fl, __v);
	}

	static locale::id id;

	protected:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	~num_put() {}

	virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
	bool __v) const;
	virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
	long __v) const;
	virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
	long long __v) const;
	virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
	unsigned long) const;
	virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
	unsigned long long) const;
	virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
	double __v) const;
	virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
	long double __v) const;
	virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
	const void* __v) const;
	};

	template <class _CharT, class _OutputIterator>
	locale::id
	num_put<_CharT, _OutputIterator>::id;

	template <class _CharT, class _OutputIterator>
	_LIBCPP_HIDDEN
	_OutputIterator
	__pad_and_output(_OutputIterator __s,
	const _CharT* __ob, const _CharT* __op, const _CharT* __oe,
	ios_base& __iob, _CharT __fl)
	{
	streamsize __sz = __oe - __ob;
	streamsize __ns = __iob.width();
	if (__ns > __sz)
	__ns -= __sz;
	else
	__ns = 0;
	for (;__ob < __op; ++__ob, ++__s)
	__s = __ob;
	for (; __ns; --__ns, ++__s)
	*__s = __fl;
	for (; __ob < __oe; ++__ob, ++__s)
	__s = __ob;
	__iob.width(0);
	return __s;
	}

	#if !defined(__APPLE__) \|\| \
	(defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED > __MAC_10_8) \|\| \
	(defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED > __IPHONE_6_0)

	template <class _CharT, class _Traits>
	_LIBCPP_HIDDEN
	ostreambuf_iterator<_CharT, _Traits>
	__pad_and_output(ostreambuf_iterator<_CharT, _Traits> __s,
	const _CharT* __ob, const _CharT* __op, const _CharT* __oe,
	ios_base& __iob, _CharT __fl)
	{
	if (__s.__sbuf_ == nullptr)
	return __s;
	streamsize __sz = __oe - __ob;
	streamsize __ns = __iob.width();
	if (__ns > __sz)
	__ns -= __sz;
	else
	__ns = 0;
	streamsize __np = __op - __ob;
	if (__np > 0)
	{
	if (__s.__sbuf_->sputn(__ob, __np) != __np)
	{
	__s.__sbuf_ = nullptr;
	return __s;
	}
	}
	if (__ns > 0)
	{
	basic_string<_CharT, _Traits> __sp(__ns, __fl);
	if (__s.__sbuf_->sputn(__sp.data(), __ns) != __ns)
	{
	__s.__sbuf_ = nullptr;
	return __s;
	}
	}
	__np = __oe - __op;
	if (__np > 0)
	{
	if (__s.__sbuf_->sputn(__op, __np) != __np)
	{
	__s.__sbuf_ = nullptr;
	return __s;
	}
	}
	__iob.width(0);
	return __s;
	}

	#endif

	template <class _CharT, class _OutputIterator>
	_OutputIterator
	num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
	char_type __fl, bool __v) const
	{
	if ((__iob.flags() & ios_base::boolalpha) == 0)
	return do_put(__s, __iob, __fl, (unsigned long)__v);
	const numpunct<char_type>& __np = use_facet<numpunct<char_type> >(__iob.getloc());
	typedef typename numpunct<char_type>::string_type string_type;
	#if _LIBCPP_DEBUG_LEVEL >= 2
	string_type __tmp(__v ? __np.truename() : __np.falsename());
	string_type __nm = _VSTD::move(__tmp);
	#else
	string_type __nm = __v ? __np.truename() : __np.falsename();
	#endif
	for (typename string_type::iterator __i = __nm.begin(); __i != __nm.end(); ++__i, ++__s)
	__s = __i;
	return __s;
	}

	template <class _CharT, class _OutputIterator>
	_OutputIterator
	num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
	char_type __fl, long __v) const
	{
	// Stage 1 - Get number in narrow char
	char __fmt[6] = {'%', 0};
	const char* __len = "l";
	this->__format_int(__fmt+1, __len, true, __iob.flags());
	const unsigned __nbuf = (numeric_limits<long>::digits / 3)
	+ ((numeric_limits<long>::digits % 3) != 0)
	+ ((__iob.flags() & ios_base::showbase) != 0)
	+ 2;
	char __nar[__nbuf];
	int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
	char* __ne = __nar + __nc;
	char* __np = this->__identify_padding(__nar, __ne, __iob);
	// Stage 2 - Widen __nar while adding thousands separators
	char_type __o[2*(__nbuf-1) - 1];
	char_type* __op; // pad here
	char_type* __oe; // end of output
	this->__widen_and_group_int(__nar, __np, __ne, __o, __op, __oe, __iob.getloc());
	// [__o, __oe) contains thousands_sep'd wide number
	// Stage 3 & 4
	return __pad_and_output(__s, __o, __op, __oe, __iob, __fl);
	}

	template <class _CharT, class _OutputIterator>
	_OutputIterator
	num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
	char_type __fl, long long __v) const
	{
	// Stage 1 - Get number in narrow char
	char __fmt[8] = {'%', 0};
	const char* __len = "ll";
	this->__format_int(__fmt+1, __len, true, __iob.flags());
	const unsigned __nbuf = (numeric_limits<long long>::digits / 3)
	+ ((numeric_limits<long long>::digits % 3) != 0)
	+ ((__iob.flags() & ios_base::showbase) != 0)
	+ 2;
	char __nar[__nbuf];
	int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
	char* __ne = __nar + __nc;
	char* __np = this->__identify_padding(__nar, __ne, __iob);
	// Stage 2 - Widen __nar while adding thousands separators
	char_type __o[2*(__nbuf-1) - 1];
	char_type* __op; // pad here
	char_type* __oe; // end of output
	this->__widen_and_group_int(__nar, __np, __ne, __o, __op, __oe, __iob.getloc());
	// [__o, __oe) contains thousands_sep'd wide number
	// Stage 3 & 4
	return __pad_and_output(__s, __o, __op, __oe, __iob, __fl);
	}

	template <class _CharT, class _OutputIterator>
	_OutputIterator
	num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
	char_type __fl, unsigned long __v) const
	{
	// Stage 1 - Get number in narrow char
	char __fmt[6] = {'%', 0};
	const char* __len = "l";
	this->__format_int(__fmt+1, __len, false, __iob.flags());
	const unsigned __nbuf = (numeric_limits<unsigned long>::digits / 3)
	+ ((numeric_limits<unsigned long>::digits % 3) != 0)
	+ ((__iob.flags() & ios_base::showbase) != 0)
	+ 1;
	char __nar[__nbuf];
	int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
	char* __ne = __nar + __nc;
	char* __np = this->__identify_padding(__nar, __ne, __iob);
	// Stage 2 - Widen __nar while adding thousands separators
	char_type __o[2*(__nbuf-1) - 1];
	char_type* __op; // pad here
	char_type* __oe; // end of output
	this->__widen_and_group_int(__nar, __np, __ne, __o, __op, __oe, __iob.getloc());
	// [__o, __oe) contains thousands_sep'd wide number
	// Stage 3 & 4
	return __pad_and_output(__s, __o, __op, __oe, __iob, __fl);
	}

	template <class _CharT, class _OutputIterator>
	_OutputIterator
	num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
	char_type __fl, unsigned long long __v) const
	{
	// Stage 1 - Get number in narrow char
	char __fmt[8] = {'%', 0};
	const char* __len = "ll";
	this->__format_int(__fmt+1, __len, false, __iob.flags());
	const unsigned __nbuf = (numeric_limits<unsigned long long>::digits / 3)
	+ ((numeric_limits<unsigned long long>::digits % 3) != 0)
	+ ((__iob.flags() & ios_base::showbase) != 0)
	+ 1;
	char __nar[__nbuf];
	int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
	char* __ne = __nar + __nc;
	char* __np = this->__identify_padding(__nar, __ne, __iob);
	// Stage 2 - Widen __nar while adding thousands separators
	char_type __o[2*(__nbuf-1) - 1];
	char_type* __op; // pad here
	char_type* __oe; // end of output
	this->__widen_and_group_int(__nar, __np, __ne, __o, __op, __oe, __iob.getloc());
	// [__o, __oe) contains thousands_sep'd wide number
	// Stage 3 & 4
	return __pad_and_output(__s, __o, __op, __oe, __iob, __fl);
	}

	template <class _CharT, class _OutputIterator>
	_OutputIterator
	num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
	char_type __fl, double __v) const
	{
	// Stage 1 - Get number in narrow char
	char __fmt[8] = {'%', 0};
	const char* __len = "";
	bool __specify_precision = this->__format_float(__fmt+1, __len, __iob.flags());
	const unsigned __nbuf = 30;
	char __nar[__nbuf];
	char* __nb = __nar;
	int __nc;
	if (__specify_precision)
	__nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
	(int)__iob.precision(), __v);
	else
	__nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
	unique_ptr<char, void()(void)> __nbh(0, free);
	if (__nc > static_cast<int>(__nbuf-1))
	{
	if (__specify_precision)
	__nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
	else
	__nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
	if (__nb == 0)
	__throw_bad_alloc();
	__nbh.reset(__nb);
	}
	char* __ne = __nb + __nc;
	char* __np = this->__identify_padding(__nb, __ne, __iob);
	// Stage 2 - Widen __nar while adding thousands separators
	char_type __o[2*(__nbuf-1) - 1];
	char_type* __ob = __o;
	unique_ptr<char_type, void()(void)> __obh(0, free);
	if (__nb != __nar)
	{
	__ob = (char_type)malloc(2static_cast<size_t>(__nc)*sizeof(char_type));
	if (__ob == 0)
	__throw_bad_alloc();
	__obh.reset(__ob);
	}
	char_type* __op; // pad here
	char_type* __oe; // end of output
	this->__widen_and_group_float(__nb, __np, __ne, __ob, __op, __oe, __iob.getloc());
	// [__o, __oe) contains thousands_sep'd wide number
	// Stage 3 & 4
	__s = __pad_and_output(__s, __ob, __op, __oe, __iob, __fl);
	return __s;
	}

	template <class _CharT, class _OutputIterator>
	_OutputIterator
	num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
	char_type __fl, long double __v) const
	{
	// Stage 1 - Get number in narrow char
	char __fmt[8] = {'%', 0};
	const char* __len = "L";
	bool __specify_precision = this->__format_float(__fmt+1, __len, __iob.flags());
	const unsigned __nbuf = 30;
	char __nar[__nbuf];
	char* __nb = __nar;
	int __nc;
	if (__specify_precision)
	__nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
	(int)__iob.precision(), __v);
	else
	__nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
	unique_ptr<char, void()(void)> __nbh(0, free);
	if (__nc > static_cast<int>(__nbuf-1))
	{
	if (__specify_precision)
	__nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
	else
	__nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
	if (__nb == 0)
	__throw_bad_alloc();
	__nbh.reset(__nb);
	}
	char* __ne = __nb + __nc;
	char* __np = this->__identify_padding(__nb, __ne, __iob);
	// Stage 2 - Widen __nar while adding thousands separators
	char_type __o[2*(__nbuf-1) - 1];
	char_type* __ob = __o;
	unique_ptr<char_type, void()(void)> __obh(0, free);
	if (__nb != __nar)
	{
	__ob = (char_type)malloc(2static_cast<size_t>(__nc)*sizeof(char_type));
	if (__ob == 0)
	__throw_bad_alloc();
	__obh.reset(__ob);
	}
	char_type* __op; // pad here
	char_type* __oe; // end of output
	this->__widen_and_group_float(__nb, __np, __ne, __ob, __op, __oe, __iob.getloc());
	// [__o, __oe) contains thousands_sep'd wide number
	// Stage 3 & 4
	__s = __pad_and_output(__s, __ob, __op, __oe, __iob, __fl);
	return __s;
	}

	template <class _CharT, class _OutputIterator>
	_OutputIterator
	num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
	char_type __fl, const void* __v) const
	{
	// Stage 1 - Get pointer in narrow char
	char __fmt[6] = "%p";
	const unsigned __nbuf = 20;
	char __nar[__nbuf];
	int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
	char* __ne = __nar + __nc;
	char* __np = this->__identify_padding(__nar, __ne, __iob);
	// Stage 2 - Widen __nar
	char_type __o[2*(__nbuf-1) - 1];
	char_type* __op; // pad here
	char_type* __oe; // end of output
	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
	__ct.widen(__nar, __ne, __o);
	__oe = __o + (__ne - __nar);
	if (__np == __ne)
	__op = __oe;
	else
	__op = __o + (__np - __nar);
	// [__o, __oe) contains wide number
	// Stage 3 & 4
	return __pad_and_output(__s, __o, __op, __oe, __iob, __fl);
	}

	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_put<char>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_put<wchar_t>)

	template <class _CharT, class _InputIterator>
	_LIBCPP_HIDDEN
	int
	__get_up_to_n_digits(_InputIterator& __b, _InputIterator __e,
	ios_base::iostate& __err, const ctype<_CharT>& __ct, int __n)
	{
	// Precondition: __n >= 1
	if (__b == __e)
	{
	__err \|= ios_base::eofbit \| ios_base::failbit;
	return 0;
	}
	// get first digit
	_CharT __c = *__b;
	if (!__ct.is(ctype_base::digit, __c))
	{
	__err \|= ios_base::failbit;
	return 0;
	}
	int __r = __ct.narrow(__c, 0) - '0';
	for (++__b, (void) --__n; __b != __e && __n > 0; ++__b, (void) --__n)
	{
	// get next digit
	__c = *__b;
	if (!__ct.is(ctype_base::digit, __c))
	return __r;
	__r = __r * 10 + __ct.narrow(__c, 0) - '0';
	}
	if (__b == __e)
	__err \|= ios_base::eofbit;
	return __r;
	}

	class _LIBCPP_TYPE_VIS time_base
	{
	public:
	enum dateorder {no_order, dmy, mdy, ymd, ydm};
	};

	template <class _CharT>
	class _LIBCPP_TEMPLATE_VIS __time_get_c_storage
	{
	protected:
	typedef basic_string<_CharT> string_type;

	virtual const string_type* __weeks() const;
	virtual const string_type* __months() const;
	virtual const string_type* __am_pm() const;
	virtual const string_type& __c() const;
	virtual const string_type& __r() const;
	virtual const string_type& __x() const;
	virtual const string_type& __X() const;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	~__time_get_c_storage() {}
	};

	template <> _LIBCPP_FUNC_VIS const string* __time_get_c_storage<char>::__weeks() const;
	template <> _LIBCPP_FUNC_VIS const string* __time_get_c_storage<char>::__months() const;
	template <> _LIBCPP_FUNC_VIS const string* __time_get_c_storage<char>::__am_pm() const;
	template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__c() const;
	template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__r() const;
	template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__x() const;
	template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__X() const;

	template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__weeks() const;
	template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__months() const;
	template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__am_pm() const;
	template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__c() const;
	template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__r() const;
	template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__x() const;
	template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__X() const;

	template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
	class _LIBCPP_TEMPLATE_VIS time_get
	: public locale::facet,
	public time_base,
	private __time_get_c_storage<_CharT>
	{
	public:
	typedef _CharT char_type;
	typedef _InputIterator iter_type;
	typedef time_base::dateorder dateorder;
	typedef basic_string<char_type> string_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit time_get(size_t __refs = 0)
	: locale::facet(__refs) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	dateorder date_order() const
	{
	return this->do_date_order();
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get_time(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, tm* __tm) const
	{
	return do_get_time(__b, __e, __iob, __err, __tm);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get_date(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, tm* __tm) const
	{
	return do_get_date(__b, __e, __iob, __err, __tm);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get_weekday(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, tm* __tm) const
	{
	return do_get_weekday(__b, __e, __iob, __err, __tm);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get_monthname(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, tm* __tm) const
	{
	return do_get_monthname(__b, __e, __iob, __err, __tm);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get_year(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, tm* __tm) const
	{
	return do_get_year(__b, __e, __iob, __err, __tm);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, tm *__tm,
	char __fmt, char __mod = 0) const
	{
	return do_get(__b, __e, __iob, __err, __tm, __fmt, __mod);
	}

	iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, tm* __tm,
	const char_type* __fmtb, const char_type* __fmte) const;

	static locale::id id;

	protected:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	~time_get() {}

	virtual dateorder do_date_order() const;
	virtual iter_type do_get_time(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, tm* __tm) const;
	virtual iter_type do_get_date(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, tm* __tm) const;
	virtual iter_type do_get_weekday(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, tm* __tm) const;
	virtual iter_type do_get_monthname(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, tm* __tm) const;
	virtual iter_type do_get_year(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, tm* __tm) const;
	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
	ios_base::iostate& __err, tm* __tm,
	char __fmt, char __mod) const;
	private:
	void __get_white_space(iter_type& __b, iter_type __e,
	ios_base::iostate& __err, const ctype<char_type>& __ct) const;
	void __get_percent(iter_type& __b, iter_type __e, ios_base::iostate& __err,
	const ctype<char_type>& __ct) const;

	void __get_weekdayname(int& __m,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const;
	void __get_monthname(int& __m,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const;
	void __get_day(int& __d,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const;
	void __get_month(int& __m,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const;
	void __get_year(int& __y,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const;
	void __get_year4(int& __y,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const;
	void __get_hour(int& __d,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const;
	void __get_12_hour(int& __h,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const;
	void __get_am_pm(int& __h,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const;
	void __get_minute(int& __m,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const;
	void __get_second(int& __s,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const;
	void __get_weekday(int& __w,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const;
	void __get_day_year_num(int& __w,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const;
	};

	template <class _CharT, class _InputIterator>
	locale::id
	time_get<_CharT, _InputIterator>::id;

	// time_get primitives

	template <class _CharT, class _InputIterator>
	void
	time_get<_CharT, _InputIterator>::__get_weekdayname(int& __w,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const
	{
	// Note: ignoring case comes from the POSIX strptime spec
	const string_type* __wk = this->__weeks();
	ptrdiff_t __i = __scan_keyword(__b, __e, __wk, __wk+14, __ct, __err, false) - __wk;
	if (__i < 14)
	__w = __i % 7;
	}

	template <class _CharT, class _InputIterator>
	void
	time_get<_CharT, _InputIterator>::__get_monthname(int& __m,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const
	{
	// Note: ignoring case comes from the POSIX strptime spec
	const string_type* __month = this->__months();
	ptrdiff_t __i = __scan_keyword(__b, __e, __month, __month+24, __ct, __err, false) - __month;
	if (__i < 24)
	__m = __i % 12;
	}

	template <class _CharT, class _InputIterator>
	void
	time_get<_CharT, _InputIterator>::__get_day(int& __d,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const
	{
	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2);
	if (!(__err & ios_base::failbit) && 1 <= __t && __t <= 31)
	__d = __t;
	else
	__err \|= ios_base::failbit;
	}

	template <class _CharT, class _InputIterator>
	void
	time_get<_CharT, _InputIterator>::__get_month(int& __m,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const
	{
	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2) - 1;
	if (!(__err & ios_base::failbit) && __t <= 11)
	__m = __t;
	else
	__err \|= ios_base::failbit;
	}

	template <class _CharT, class _InputIterator>
	void
	time_get<_CharT, _InputIterator>::__get_year(int& __y,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const
	{
	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 4);
	if (!(__err & ios_base::failbit))
	{
	if (__t < 69)
	__t += 2000;
	else if (69 <= __t && __t <= 99)
	__t += 1900;
	__y = __t - 1900;
	}
	}

	template <class _CharT, class _InputIterator>
	void
	time_get<_CharT, _InputIterator>::__get_year4(int& __y,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const
	{
	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 4);
	if (!(__err & ios_base::failbit))
	__y = __t - 1900;
	}

	template <class _CharT, class _InputIterator>
	void
	time_get<_CharT, _InputIterator>::__get_hour(int& __h,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const
	{
	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2);
	if (!(__err & ios_base::failbit) && __t <= 23)
	__h = __t;
	else
	__err \|= ios_base::failbit;
	}

	template <class _CharT, class _InputIterator>
	void
	time_get<_CharT, _InputIterator>::__get_12_hour(int& __h,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const
	{
	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2);
	if (!(__err & ios_base::failbit) && 1 <= __t && __t <= 12)
	__h = __t;
	else
	__err \|= ios_base::failbit;
	}

	template <class _CharT, class _InputIterator>
	void
	time_get<_CharT, _InputIterator>::__get_minute(int& __m,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const
	{
	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2);
	if (!(__err & ios_base::failbit) && __t <= 59)
	__m = __t;
	else
	__err \|= ios_base::failbit;
	}

	template <class _CharT, class _InputIterator>
	void
	time_get<_CharT, _InputIterator>::__get_second(int& __s,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const
	{
	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 2);
	if (!(__err & ios_base::failbit) && __t <= 60)
	__s = __t;
	else
	__err \|= ios_base::failbit;
	}

	template <class _CharT, class _InputIterator>
	void
	time_get<_CharT, _InputIterator>::__get_weekday(int& __w,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const
	{
	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 1);
	if (!(__err & ios_base::failbit) && __t <= 6)
	__w = __t;
	else
	__err \|= ios_base::failbit;
	}

	template <class _CharT, class _InputIterator>
	void
	time_get<_CharT, _InputIterator>::__get_day_year_num(int& __d,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const
	{
	int __t = __get_up_to_n_digits(__b, __e, __err, __ct, 3);
	if (!(__err & ios_base::failbit) && __t <= 365)
	__d = __t;
	else
	__err \|= ios_base::failbit;
	}

	template <class _CharT, class _InputIterator>
	void
	time_get<_CharT, _InputIterator>::__get_white_space(iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const
	{
	for (; __b != __e && __ct.is(ctype_base::space, *__b); ++__b)
	;
	if (__b == __e)
	__err \|= ios_base::eofbit;
	}

	template <class _CharT, class _InputIterator>
	void
	time_get<_CharT, _InputIterator>::__get_am_pm(int& __h,
	iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const
	{
	const string_type* __ap = this->__am_pm();
	if (__ap[0].size() + __ap[1].size() == 0)
	{
	__err \|= ios_base::failbit;
	return;
	}
	ptrdiff_t __i = __scan_keyword(__b, __e, __ap, __ap+2, __ct, __err, false) - __ap;
	if (__i == 0 && __h == 12)
	__h = 0;
	else if (__i == 1 && __h < 12)
	__h += 12;
	}

	template <class _CharT, class _InputIterator>
	void
	time_get<_CharT, _InputIterator>::__get_percent(iter_type& __b, iter_type __e,
	ios_base::iostate& __err,
	const ctype<char_type>& __ct) const
	{
	if (__b == __e)
	{
	__err \|= ios_base::eofbit \| ios_base::failbit;
	return;
	}
	if (__ct.narrow(*__b, 0) != '%')
	__err \|= ios_base::failbit;
	else if(++__b == __e)
	__err \|= ios_base::eofbit;
	}

	// time_get end primitives

	template <class _CharT, class _InputIterator>
	_InputIterator
	time_get<_CharT, _InputIterator>::get(iter_type __b, iter_type __e,
	ios_base& __iob,
	ios_base::iostate& __err, tm* __tm,
	const char_type* __fmtb, const char_type* __fmte) const
	{
	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
	__err = ios_base::goodbit;
	while (__fmtb != __fmte && __err == ios_base::goodbit)
	{
	if (__b == __e)
	{
	__err = ios_base::failbit;
	break;
	}
	if (__ct.narrow(*__fmtb, 0) == '%')
	{
	if (++__fmtb == __fmte)
	{
	__err = ios_base::failbit;
	break;
	}
	char __cmd = __ct.narrow(*__fmtb, 0);
	char __opt = '\0';
	if (__cmd == 'E' \|\| __cmd == '0')
	{
	if (++__fmtb == __fmte)
	{
	__err = ios_base::failbit;
	break;
	}
	__opt = __cmd;
	__cmd = __ct.narrow(*__fmtb, 0);
	}
	__b = do_get(__b, __e, __iob, __err, __tm, __cmd, __opt);
	++__fmtb;
	}
	else if (__ct.is(ctype_base::space, *__fmtb))
	{
	for (++__fmtb; __fmtb != __fmte && __ct.is(ctype_base::space, *__fmtb); ++__fmtb)
	;
	for ( ; __b != __e && __ct.is(ctype_base::space, *__b); ++__b)
	;
	}
	else if (__ct.toupper(__b) == __ct.toupper(__fmtb))
	{
	++__b;
	++__fmtb;
	}
	else
	__err = ios_base::failbit;
	}
	if (__b == __e)
	__err \|= ios_base::eofbit;
	return __b;
	}

	template <class _CharT, class _InputIterator>
	typename time_get<_CharT, _InputIterator>::dateorder
	time_get<_CharT, _InputIterator>::do_date_order() const
	{
	return mdy;
	}

	template <class _CharT, class _InputIterator>
	_InputIterator
	time_get<_CharT, _InputIterator>::do_get_time(iter_type __b, iter_type __e,
	ios_base& __iob,
	ios_base::iostate& __err,
	tm* __tm) const
	{
	const char_type __fmt[] = {'%', 'H', ':', '%', 'M', ':', '%', 'S'};
	return get(__b, __e, __iob, __err, __tm, __fmt, __fmt + sizeof(__fmt)/sizeof(__fmt[0]));
	}

	template <class _CharT, class _InputIterator>
	_InputIterator
	time_get<_CharT, _InputIterator>::do_get_date(iter_type __b, iter_type __e,
	ios_base& __iob,
	ios_base::iostate& __err,
	tm* __tm) const
	{
	const string_type& __fmt = this->__x();
	return get(__b, __e, __iob, __err, __tm, __fmt.data(), __fmt.data() + __fmt.size());
	}

	template <class _CharT, class _InputIterator>
	_InputIterator
	time_get<_CharT, _InputIterator>::do_get_weekday(iter_type __b, iter_type __e,
	ios_base& __iob,
	ios_base::iostate& __err,
	tm* __tm) const
	{
	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
	__get_weekdayname(__tm->tm_wday, __b, __e, __err, __ct);
	return __b;
	}

	template <class _CharT, class _InputIterator>
	_InputIterator
	time_get<_CharT, _InputIterator>::do_get_monthname(iter_type __b, iter_type __e,
	ios_base& __iob,
	ios_base::iostate& __err,
	tm* __tm) const
	{
	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
	__get_monthname(__tm->tm_mon, __b, __e, __err, __ct);
	return __b;
	}

	template <class _CharT, class _InputIterator>
	_InputIterator
	time_get<_CharT, _InputIterator>::do_get_year(iter_type __b, iter_type __e,
	ios_base& __iob,
	ios_base::iostate& __err,
	tm* __tm) const
	{
	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
	__get_year(__tm->tm_year, __b, __e, __err, __ct);
	return __b;
	}

	template <class _CharT, class _InputIterator>
	_InputIterator
	time_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
	ios_base& __iob,
	ios_base::iostate& __err, tm* __tm,
	char __fmt, char) const
	{
	__err = ios_base::goodbit;
	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
	switch (__fmt)
	{
	case 'a':
	case 'A':
	__get_weekdayname(__tm->tm_wday, __b, __e, __err, __ct);
	break;
	case 'b':
	case 'B':
	case 'h':
	__get_monthname(__tm->tm_mon, __b, __e, __err, __ct);
	break;
	case 'c':
	{
	const string_type& __fm = this->__c();
	__b = get(__b, __e, __iob, __err, __tm, __fm.data(), __fm.data() + __fm.size());
	}
	break;
	case 'd':
	case 'e':
	__get_day(__tm->tm_mday, __b, __e, __err, __ct);
	break;
	case 'D':
	{
	const char_type __fm[] = {'%', 'm', '/', '%', 'd', '/', '%', 'y'};
	__b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[0]));
	}
	break;
	case 'F':
	{
	const char_type __fm[] = {'%', 'Y', '-', '%', 'm', '-', '%', 'd'};
	__b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[0]));
	}
	break;
	case 'H':
	__get_hour(__tm->tm_hour, __b, __e, __err, __ct);
	break;
	case 'I':
	__get_12_hour(__tm->tm_hour, __b, __e, __err, __ct);
	break;
	case 'j':
	__get_day_year_num(__tm->tm_yday, __b, __e, __err, __ct);
	break;
	case 'm':
	__get_month(__tm->tm_mon, __b, __e, __err, __ct);
	break;
	case 'M':
	__get_minute(__tm->tm_min, __b, __e, __err, __ct);
	break;
	case 'n':
	case 't':
	__get_white_space(__b, __e, __err, __ct);
	break;
	case 'p':
	__get_am_pm(__tm->tm_hour, __b, __e, __err, __ct);
	break;
	case 'r':
	{
	const char_type __fm[] = {'%', 'I', ':', '%', 'M', ':', '%', 'S', ' ', '%', 'p'};
	__b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[0]));
	}
	break;
	case 'R':
	{
	const char_type __fm[] = {'%', 'H', ':', '%', 'M'};
	__b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[0]));
	}
	break;
	case 'S':
	__get_second(__tm->tm_sec, __b, __e, __err, __ct);
	break;
	case 'T':
	{
	const char_type __fm[] = {'%', 'H', ':', '%', 'M', ':', '%', 'S'};
	__b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[0]));
	}
	break;
	case 'w':
	__get_weekday(__tm->tm_wday, __b, __e, __err, __ct);
	break;
	case 'x':
	return do_get_date(__b, __e, __iob, __err, __tm);
	case 'X':
	{
	const string_type& __fm = this->__X();
	__b = get(__b, __e, __iob, __err, __tm, __fm.data(), __fm.data() + __fm.size());
	}
	break;
	case 'y':
	__get_year(__tm->tm_year, __b, __e, __err, __ct);
	break;
	case 'Y':
	__get_year4(__tm->tm_year, __b, __e, __err, __ct);
	break;
	case '%':
	__get_percent(__b, __e, __err, __ct);
	break;
	default:
	__err \|= ios_base::failbit;
	}
	return __b;
	}

	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get<char>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get<wchar_t>)

	class _LIBCPP_TYPE_VIS __time_get
	{
	protected:
	locale_t __loc_;

	__time_get(const char* __nm);
	__time_get(const string& __nm);
	~__time_get();
	};

	template <class _CharT>
	class _LIBCPP_TEMPLATE_VIS __time_get_storage
	: public __time_get
	{
	protected:
	typedef basic_string<_CharT> string_type;

	string_type __weeks_[14];
	string_type __months_[24];
	string_type __am_pm_[2];
	string_type __c_;
	string_type __r_;
	string_type __x_;
	string_type __X_;

	explicit __time_get_storage(const char* __nm);
	explicit __time_get_storage(const string& __nm);

	- _LIBCPP_ALWAYS_INLINE ~__time_get_storage() {}
	+ _LIBCPP_INLINE_VISIBILITY ~__time_get_storage() {}

	time_base::dateorder __do_date_order() const;

	private:
	void init(const ctype<_CharT>&);
	string_type __analyze(char __fmt, const ctype<_CharT>&);
	};

	template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
	class _LIBCPP_TEMPLATE_VIS time_get_byname
	: public time_get<_CharT, _InputIterator>,
	private __time_get_storage<_CharT>
	{
	public:
	typedef time_base::dateorder dateorder;
	typedef _InputIterator iter_type;
	typedef _CharT char_type;
	typedef basic_string<char_type> string_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit time_get_byname(const char* __nm, size_t __refs = 0)
	: time_get<_CharT, _InputIterator>(__refs),
	__time_get_storage<_CharT>(__nm) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit time_get_byname(const string& __nm, size_t __refs = 0)
	: time_get<_CharT, _InputIterator>(__refs),
	__time_get_storage<_CharT>(__nm) {}

	protected:
	_LIBCPP_INLINE_VISIBILITY
	~time_get_byname() {}

	_LIBCPP_INLINE_VISIBILITY
	virtual dateorder do_date_order() const {return this->__do_date_order();}
	private:
	_LIBCPP_INLINE_VISIBILITY
	virtual const string_type* __weeks() const {return this->__weeks_;}
	_LIBCPP_INLINE_VISIBILITY
	virtual const string_type* __months() const {return this->__months_;}
	_LIBCPP_INLINE_VISIBILITY
	virtual const string_type* __am_pm() const {return this->__am_pm_;}
	_LIBCPP_INLINE_VISIBILITY
	virtual const string_type& __c() const {return this->__c_;}
	_LIBCPP_INLINE_VISIBILITY
	virtual const string_type& __r() const {return this->__r_;}
	_LIBCPP_INLINE_VISIBILITY
	virtual const string_type& __x() const {return this->__x_;}
	_LIBCPP_INLINE_VISIBILITY
	virtual const string_type& __X() const {return this->__X_;}
	};

	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get_byname<char>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get_byname<wchar_t>)

	class _LIBCPP_TYPE_VIS __time_put
	{
	locale_t __loc_;
	protected:
	- _LIBCPP_ALWAYS_INLINE __time_put() : __loc_(_LIBCPP_GET_C_LOCALE) {}
	+ _LIBCPP_INLINE_VISIBILITY __time_put() : __loc_(_LIBCPP_GET_C_LOCALE) {}
	__time_put(const char* __nm);
	__time_put(const string& __nm);
	~__time_put();
	void __do_put(char* __nb, char& __ne, const tm __tm,
	char __fmt, char __mod) const;
	void __do_put(wchar_t* __wb, wchar_t& __we, const tm __tm,
	char __fmt, char __mod) const;
	};

	template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
	class _LIBCPP_TEMPLATE_VIS time_put
	: public locale::facet,
	private __time_put
	{
	public:
	typedef _CharT char_type;
	typedef _OutputIterator iter_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit time_put(size_t __refs = 0)
	: locale::facet(__refs) {}

	iter_type put(iter_type __s, ios_base& __iob, char_type __fl, const tm* __tm,
	const char_type* __pb, const char_type* __pe) const;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
	const tm* __tm, char __fmt, char __mod = 0) const
	{
	return do_put(__s, __iob, __fl, __tm, __fmt, __mod);
	}

	static locale::id id;

	protected:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	~time_put() {}
	virtual iter_type do_put(iter_type __s, ios_base&, char_type, const tm* __tm,
	char __fmt, char __mod) const;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit time_put(const char* __nm, size_t __refs)
	: locale::facet(__refs),
	__time_put(__nm) {}
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit time_put(const string& __nm, size_t __refs)
	: locale::facet(__refs),
	__time_put(__nm) {}
	};

	template <class _CharT, class _OutputIterator>
	locale::id
	time_put<_CharT, _OutputIterator>::id;

	template <class _CharT, class _OutputIterator>
	_OutputIterator
	time_put<_CharT, _OutputIterator>::put(iter_type __s, ios_base& __iob,
	char_type __fl, const tm* __tm,
	const char_type* __pb,
	const char_type* __pe) const
	{
	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__iob.getloc());
	for (; __pb != __pe; ++__pb)
	{
	if (__ct.narrow(*__pb, 0) == '%')
	{
	if (++__pb == __pe)
	{
	*__s++ = __pb[-1];
	break;
	}
	char __mod = 0;
	char __fmt = __ct.narrow(*__pb, 0);
	if (__fmt == 'E' \|\| __fmt == 'O')
	{
	if (++__pb == __pe)
	{
	*__s++ = __pb[-2];
	*__s++ = __pb[-1];
	break;
	}
	__mod = __fmt;
	__fmt = __ct.narrow(*__pb, 0);
	}
	__s = do_put(__s, __iob, __fl, __tm, __fmt, __mod);
	}
	else
	__s++ = __pb;
	}
	return __s;
	}

	template <class _CharT, class _OutputIterator>
	_OutputIterator
	time_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base&,
	char_type, const tm* __tm,
	char __fmt, char __mod) const
	{
	char_type __nar[100];
	char_type* __nb = __nar;
	char_type* __ne = __nb + 100;
	__do_put(__nb, __ne, __tm, __fmt, __mod);
	return _VSTD::copy(__nb, __ne, __s);
	}

	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put<char>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put<wchar_t>)

	template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
	class _LIBCPP_TEMPLATE_VIS time_put_byname
	: public time_put<_CharT, _OutputIterator>
	{
	public:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit time_put_byname(const char* __nm, size_t __refs = 0)
	: time_put<_CharT, _OutputIterator>(__nm, __refs) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit time_put_byname(const string& __nm, size_t __refs = 0)
	: time_put<_CharT, _OutputIterator>(__nm, __refs) {}

	protected:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	~time_put_byname() {}
	};

	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put_byname<char>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put_byname<wchar_t>)

	// money_base

	class _LIBCPP_TYPE_VIS money_base
	{
	public:
	enum part {none, space, symbol, sign, value};
	struct pattern {char field[4];};

	- _LIBCPP_ALWAYS_INLINE money_base() {}
	+ _LIBCPP_INLINE_VISIBILITY money_base() {}
	};

	// moneypunct

	template <class _CharT, bool _International = false>
	class _LIBCPP_TEMPLATE_VIS moneypunct
	: public locale::facet,
	public money_base
	{
	public:
	typedef _CharT char_type;
	typedef basic_string<char_type> string_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit moneypunct(size_t __refs = 0)
	: locale::facet(__refs) {}

	- _LIBCPP_ALWAYS_INLINE char_type decimal_point() const {return do_decimal_point();}
	- _LIBCPP_ALWAYS_INLINE char_type thousands_sep() const {return do_thousands_sep();}
	- _LIBCPP_ALWAYS_INLINE string grouping() const {return do_grouping();}
	- _LIBCPP_ALWAYS_INLINE string_type curr_symbol() const {return do_curr_symbol();}
	- _LIBCPP_ALWAYS_INLINE string_type positive_sign() const {return do_positive_sign();}
	- _LIBCPP_ALWAYS_INLINE string_type negative_sign() const {return do_negative_sign();}
	- _LIBCPP_ALWAYS_INLINE int frac_digits() const {return do_frac_digits();}
	- _LIBCPP_ALWAYS_INLINE pattern pos_format() const {return do_pos_format();}
	- _LIBCPP_ALWAYS_INLINE pattern neg_format() const {return do_neg_format();}
	+ _LIBCPP_INLINE_VISIBILITY char_type decimal_point() const {return do_decimal_point();}
	+ _LIBCPP_INLINE_VISIBILITY char_type thousands_sep() const {return do_thousands_sep();}
	+ _LIBCPP_INLINE_VISIBILITY string grouping() const {return do_grouping();}
	+ _LIBCPP_INLINE_VISIBILITY string_type curr_symbol() const {return do_curr_symbol();}
	+ _LIBCPP_INLINE_VISIBILITY string_type positive_sign() const {return do_positive_sign();}
	+ _LIBCPP_INLINE_VISIBILITY string_type negative_sign() const {return do_negative_sign();}
	+ _LIBCPP_INLINE_VISIBILITY int frac_digits() const {return do_frac_digits();}
	+ _LIBCPP_INLINE_VISIBILITY pattern pos_format() const {return do_pos_format();}
	+ _LIBCPP_INLINE_VISIBILITY pattern neg_format() const {return do_neg_format();}

	static locale::id id;
	static const bool intl = _International;

	protected:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	~moneypunct() {}

	virtual char_type do_decimal_point() const {return numeric_limits<char_type>::max();}
	virtual char_type do_thousands_sep() const {return numeric_limits<char_type>::max();}
	virtual string do_grouping() const {return string();}
	virtual string_type do_curr_symbol() const {return string_type();}
	virtual string_type do_positive_sign() const {return string_type();}
	virtual string_type do_negative_sign() const {return string_type(1, '-');}
	virtual int do_frac_digits() const {return 0;}
	virtual pattern do_pos_format() const
	{pattern __p = {{symbol, sign, none, value}}; return __p;}
	virtual pattern do_neg_format() const
	{pattern __p = {{symbol, sign, none, value}}; return __p;}
	};

	template <class _CharT, bool _International>
	locale::id
	moneypunct<_CharT, _International>::id;

	template <class _CharT, bool _International>
	const bool
	moneypunct<_CharT, _International>::intl;

	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<char, false>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<char, true>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, false>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, true>)

	// moneypunct_byname

	template <class _CharT, bool _International = false>
	class _LIBCPP_TEMPLATE_VIS moneypunct_byname
	: public moneypunct<_CharT, _International>
	{
	public:
	typedef money_base::pattern pattern;
	typedef _CharT char_type;
	typedef basic_string<char_type> string_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit moneypunct_byname(const char* __nm, size_t __refs = 0)
	: moneypunct<_CharT, _International>(__refs) {init(__nm);}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit moneypunct_byname(const string& __nm, size_t __refs = 0)
	: moneypunct<_CharT, _International>(__refs) {init(__nm.c_str());}

	protected:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	~moneypunct_byname() {}

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

	private:
	char_type __decimal_point_;
	char_type __thousands_sep_;
	string __grouping_;
	string_type __curr_symbol_;
	string_type __positive_sign_;
	string_type __negative_sign_;
	int __frac_digits_;
	pattern __pos_format_;
	pattern __neg_format_;

	void init(const char*);
	};

	template<> _LIBCPP_FUNC_VIS void moneypunct_byname<char, false>::init(const char*);
	template<> _LIBCPP_FUNC_VIS void moneypunct_byname<char, true>::init(const char*);
	template<> _LIBCPP_FUNC_VIS void moneypunct_byname<wchar_t, false>::init(const char*);
	template<> _LIBCPP_FUNC_VIS void moneypunct_byname<wchar_t, true>::init(const char*);

	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<char, false>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<char, true>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<wchar_t, false>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<wchar_t, true>)

	// money_get

	template <class _CharT>
	class __money_get
	{
	protected:
	typedef _CharT char_type;
	typedef basic_string<char_type> string_type;

	- _LIBCPP_ALWAYS_INLINE __money_get() {}
	+ _LIBCPP_INLINE_VISIBILITY __money_get() {}

	static void __gather_info(bool __intl, const locale& __loc,
	money_base::pattern& __pat, char_type& __dp,
	char_type& __ts, string& __grp,
	string_type& __sym, string_type& __psn,
	string_type& __nsn, int& __fd);
	};

	template <class _CharT>
	void
	__money_get<_CharT>::__gather_info(bool __intl, const locale& __loc,
	money_base::pattern& __pat, char_type& __dp,
	char_type& __ts, string& __grp,
	string_type& __sym, string_type& __psn,
	string_type& __nsn, int& __fd)
	{
	if (__intl)
	{
	const moneypunct<char_type, true>& __mp =
	use_facet<moneypunct<char_type, true> >(__loc);
	__pat = __mp.neg_format();
	__nsn = __mp.negative_sign();
	__psn = __mp.positive_sign();
	__dp = __mp.decimal_point();
	__ts = __mp.thousands_sep();
	__grp = __mp.grouping();
	__sym = __mp.curr_symbol();
	__fd = __mp.frac_digits();
	}
	else
	{
	const moneypunct<char_type, false>& __mp =
	use_facet<moneypunct<char_type, false> >(__loc);
	__pat = __mp.neg_format();
	__nsn = __mp.negative_sign();
	__psn = __mp.positive_sign();
	__dp = __mp.decimal_point();
	__ts = __mp.thousands_sep();
	__grp = __mp.grouping();
	__sym = __mp.curr_symbol();
	__fd = __mp.frac_digits();
	}
	}

	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<char>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<wchar_t>)

	template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
	class _LIBCPP_TEMPLATE_VIS money_get
	: public locale::facet,
	private __money_get<_CharT>
	{
	public:
	typedef _CharT char_type;
	typedef _InputIterator iter_type;
	typedef basic_string<char_type> string_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit money_get(size_t __refs = 0)
	: locale::facet(__refs) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob,
	ios_base::iostate& __err, long double& __v) const
	{
	return do_get(__b, __e, __intl, __iob, __err, __v);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob,
	ios_base::iostate& __err, string_type& __v) const
	{
	return do_get(__b, __e, __intl, __iob, __err, __v);
	}

	static locale::id id;

	protected:

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	~money_get() {}

	virtual iter_type do_get(iter_type __b, iter_type __e, bool __intl,
	ios_base& __iob, ios_base::iostate& __err,
	long double& __v) const;
	virtual iter_type do_get(iter_type __b, iter_type __e, bool __intl,
	ios_base& __iob, ios_base::iostate& __err,
	string_type& __v) const;

	private:
	static bool __do_get(iter_type& __b, iter_type __e,
	bool __intl, const locale& __loc,
	ios_base::fmtflags __flags, ios_base::iostate& __err,
	bool& __neg, const ctype<char_type>& __ct,
	unique_ptr<char_type, void()(void)>& __wb,
	char_type& __wn, char_type __we);
	};

	template <class _CharT, class _InputIterator>
	locale::id
	money_get<_CharT, _InputIterator>::id;

	_LIBCPP_FUNC_VIS void __do_nothing(void*);

	template <class _Tp>
	_LIBCPP_HIDDEN
	void
	__double_or_nothing(unique_ptr<_Tp, void()(void)>& __b, _Tp& __n, _Tp& __e)
	{
	bool __owns = __b.get_deleter() != __do_nothing;
	size_t __cur_cap = static_cast<size_t>(__e-__b.get()) * sizeof(_Tp);
	size_t __new_cap = __cur_cap < numeric_limits<size_t>::max() / 2 ?
	2 * __cur_cap : numeric_limits<size_t>::max();
	if (__new_cap == 0)
	__new_cap = sizeof(_Tp);
	size_t __n_off = static_cast<size_t>(__n - __b.get());
	_Tp* __t = (_Tp*)realloc(__owns ? __b.get() : 0, __new_cap);
	if (__t == 0)
	__throw_bad_alloc();
	if (__owns)
	__b.release();
	__b = unique_ptr<_Tp, void()(void)>(__t, free);
	__new_cap /= sizeof(_Tp);
	__n = __b.get() + __n_off;
	__e = __b.get() + __new_cap;
	}

	// true == success
	template <class _CharT, class _InputIterator>
	bool
	money_get<_CharT, _InputIterator>::__do_get(iter_type& __b, iter_type __e,
	bool __intl, const locale& __loc,
	ios_base::fmtflags __flags,
	ios_base::iostate& __err,
	bool& __neg,
	const ctype<char_type>& __ct,
	unique_ptr<char_type, void()(void)>& __wb,
	char_type& __wn, char_type __we)
	{
	const unsigned __bz = 100;
	unsigned __gbuf[__bz];
	unique_ptr<unsigned, void()(void)> __gb(__gbuf, __do_nothing);
	unsigned* __gn = __gb.get();
	unsigned* __ge = __gn + __bz;
	money_base::pattern __pat;
	char_type __dp;
	char_type __ts;
	string __grp;
	string_type __sym;
	string_type __psn;
	string_type __nsn;
	// Capture the spaces read into money_base::{space,none} so they
	// can be compared to initial spaces in __sym.
	string_type __spaces;
	int __fd;
	__money_get<_CharT>::__gather_info(__intl, __loc, __pat, __dp, __ts, __grp,
	__sym, __psn, __nsn, __fd);
	const string_type* __trailing_sign = 0;
	__wn = __wb.get();
	for (unsigned __p = 0; __p < 4 && __b != __e; ++__p)
	{
	switch (__pat.field[__p])
	{
	case money_base::space:
	if (__p != 3)
	{
	if (__ct.is(ctype_base::space, *__b))
	__spaces.push_back(*__b++);
	else
	{
	__err \|= ios_base::failbit;
	return false;
	}
	}
	_LIBCPP_FALLTHROUGH();
	case money_base::none:
	if (__p != 3)
	{
	while (__b != __e && __ct.is(ctype_base::space, *__b))
	__spaces.push_back(*__b++);
	}
	break;
	case money_base::sign:
	if (__psn.size() + __nsn.size() > 0)
	{
	if (__psn.size() == 0 \|\| __nsn.size() == 0)
	{ // sign is optional
	if (__psn.size() > 0)
	{ // __nsn.size() == 0
	if (*__b == __psn[0])
	{
	++__b;
	if (__psn.size() > 1)
	__trailing_sign = &__psn;
	}
	else
	__neg = true;
	}
	else if (*__b == __nsn[0]) // __nsn.size() > 0 && __psn.size() == 0
	{
	++__b;
	__neg = true;
	if (__nsn.size() > 1)
	__trailing_sign = &__nsn;
	}
	}
	else // sign is required
	{
	if (*__b == __psn[0])
	{
	++__b;
	if (__psn.size() > 1)
	__trailing_sign = &__psn;
	}
	else if (*__b == __nsn[0])
	{
	++__b;
	__neg = true;
	if (__nsn.size() > 1)
	__trailing_sign = &__nsn;
	}
	else
	{
	__err \|= ios_base::failbit;
	return false;
	}
	}
	}
	break;
	case money_base::symbol:
	{
	bool __more_needed = __trailing_sign \|\|
	(__p < 2) \|\|
	(__p == 2 && __pat.field[3] != static_cast<char>(money_base::none));
	bool __sb = (__flags & ios_base::showbase) != 0;
	if (__sb \|\| __more_needed)
	{
	typename string_type::const_iterator __sym_space_end = __sym.begin();
	if (__p > 0 && (__pat.field[__p - 1] == money_base::none \|\|
	__pat.field[__p - 1] == money_base::space)) {
	// Match spaces we've already read against spaces at
	// the beginning of __sym.
	while (__sym_space_end != __sym.end() &&
	__ct.is(ctype_base::space, *__sym_space_end))
	++__sym_space_end;
	const size_t __num_spaces = __sym_space_end - __sym.begin();
	if (__num_spaces > __spaces.size() \|\|
	!equal(__spaces.end() - __num_spaces, __spaces.end(),
	__sym.begin())) {
	// No match. Put __sym_space_end back at the
	// beginning of __sym, which will prevent a
	// match in the next loop.
	__sym_space_end = __sym.begin();
	}
	}
	typename string_type::const_iterator __sym_curr_char = __sym_space_end;
	while (__sym_curr_char != __sym.end() && __b != __e &&
	__b == __sym_curr_char) {
	++__b;
	++__sym_curr_char;
	}
	if (__sb && __sym_curr_char != __sym.end())
	{
	__err \|= ios_base::failbit;
	return false;
	}
	}
	}
	break;
	case money_base::value:
	{
	unsigned __ng = 0;
	for (; __b != __e; ++__b)
	{
	char_type __c = *__b;
	if (__ct.is(ctype_base::digit, __c))
	{
	if (__wn == __we)
	__double_or_nothing(__wb, __wn, __we);
	*__wn++ = __c;
	++__ng;
	}
	else if (__grp.size() > 0 && __ng > 0 && __c == __ts)
	{
	if (__gn == __ge)
	__double_or_nothing(__gb, __gn, __ge);
	*__gn++ = __ng;
	__ng = 0;
	}
	else
	break;
	}
	if (__gb.get() != __gn && __ng > 0)
	{
	if (__gn == __ge)
	__double_or_nothing(__gb, __gn, __ge);
	*__gn++ = __ng;
	}
	if (__fd > 0)
	{
	if (__b == __e \|\| *__b != __dp)
	{
	__err \|= ios_base::failbit;
	return false;
	}
	for (++__b; __fd > 0; --__fd, ++__b)
	{
	if (__b == __e \|\| !__ct.is(ctype_base::digit, *__b))
	{
	__err \|= ios_base::failbit;
	return false;
	}
	if (__wn == __we)
	__double_or_nothing(__wb, __wn, __we);
	__wn++ = __b;
	}
	}
	if (__wn == __wb.get())
	{
	__err \|= ios_base::failbit;
	return false;
	}
	}
	break;
	}
	}
	if (__trailing_sign)
	{
	for (unsigned __i = 1; __i < __trailing_sign->size(); ++__i, ++__b)
	{
	if (__b == __e \|\| __b != (__trailing_sign)[__i])
	{
	__err \|= ios_base::failbit;
	return false;
	}
	}
	}
	if (__gb.get() != __gn)
	{
	ios_base::iostate __et = ios_base::goodbit;
	__check_grouping(__grp, __gb.get(), __gn, __et);
	if (__et)
	{
	__err \|= ios_base::failbit;
	return false;
	}
	}
	return true;
	}

	template <class _CharT, class _InputIterator>
	_InputIterator
	money_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
	bool __intl, ios_base& __iob,
	ios_base::iostate& __err,
	long double& __v) const
	{
	const int __bz = 100;
	char_type __wbuf[__bz];
	unique_ptr<char_type, void()(void)> __wb(__wbuf, __do_nothing);
	char_type* __wn;
	char_type* __we = __wbuf + __bz;
	locale __loc = __iob.getloc();
	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc);
	bool __neg = false;
	if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct,
	__wb, __wn, __we))
	{
	const char __src[] = "0123456789";
	char_type __atoms[sizeof(__src)-1];
	__ct.widen(__src, __src + (sizeof(__src)-1), __atoms);
	char __nbuf[__bz];
	char* __nc = __nbuf;
	unique_ptr<char, void()(void)> __h(0, free);
	if (__wn - __wb.get() > __bz-2)
	{
	__h.reset((char*)malloc(static_cast<size_t>(__wn - __wb.get() + 2)));
	if (__h.get() == 0)
	__throw_bad_alloc();
	__nc = __h.get();
	}
	if (__neg)
	*__nc++ = '-';
	for (const char_type* __w = __wb.get(); __w < __wn; ++__w, ++__nc)
	__nc = __src[find(__atoms, _VSTD::end(__atoms), __w) - __atoms];
	*__nc = char();
	if (sscanf(__nbuf, "%Lf", &__v) != 1)
	__throw_runtime_error("money_get error");
	}
	if (__b == __e)
	__err \|= ios_base::eofbit;
	return __b;
	}

	template <class _CharT, class _InputIterator>
	_InputIterator
	money_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
	bool __intl, ios_base& __iob,
	ios_base::iostate& __err,
	string_type& __v) const
	{
	const int __bz = 100;
	char_type __wbuf[__bz];
	unique_ptr<char_type, void()(void)> __wb(__wbuf, __do_nothing);
	char_type* __wn;
	char_type* __we = __wbuf + __bz;
	locale __loc = __iob.getloc();
	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc);
	bool __neg = false;
	if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct,
	__wb, __wn, __we))
	{
	__v.clear();
	if (__neg)
	__v.push_back(__ct.widen('-'));
	char_type __z = __ct.widen('0');
	char_type* __w;
	for (__w = __wb.get(); __w < __wn-1; ++__w)
	if (*__w != __z)
	break;
	__v.append(__w, __wn);
	}
	if (__b == __e)
	__err \|= ios_base::eofbit;
	return __b;
	}

	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_get<char>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_get<wchar_t>)

	// money_put

	template <class _CharT>
	class __money_put
	{
	protected:
	typedef _CharT char_type;
	typedef basic_string<char_type> string_type;

	- _LIBCPP_ALWAYS_INLINE __money_put() {}
	+ _LIBCPP_INLINE_VISIBILITY __money_put() {}

	static void __gather_info(bool __intl, bool __neg, const locale& __loc,
	money_base::pattern& __pat, char_type& __dp,
	char_type& __ts, string& __grp,
	string_type& __sym, string_type& __sn,
	int& __fd);
	static void __format(char_type* __mb, char_type& __mi, char_type& __me,
	ios_base::fmtflags __flags,
	const char_type* __db, const char_type* __de,
	const ctype<char_type>& __ct, bool __neg,
	const money_base::pattern& __pat, char_type __dp,
	char_type __ts, const string& __grp,
	const string_type& __sym, const string_type& __sn,
	int __fd);
	};

	template <class _CharT>
	void
	__money_put<_CharT>::__gather_info(bool __intl, bool __neg, const locale& __loc,
	money_base::pattern& __pat, char_type& __dp,
	char_type& __ts, string& __grp,
	string_type& __sym, string_type& __sn,
	int& __fd)
	{
	if (__intl)
	{
	const moneypunct<char_type, true>& __mp =
	use_facet<moneypunct<char_type, true> >(__loc);
	if (__neg)
	{
	__pat = __mp.neg_format();
	__sn = __mp.negative_sign();
	}
	else
	{
	__pat = __mp.pos_format();
	__sn = __mp.positive_sign();
	}
	__dp = __mp.decimal_point();
	__ts = __mp.thousands_sep();
	__grp = __mp.grouping();
	__sym = __mp.curr_symbol();
	__fd = __mp.frac_digits();
	}
	else
	{
	const moneypunct<char_type, false>& __mp =
	use_facet<moneypunct<char_type, false> >(__loc);
	if (__neg)
	{
	__pat = __mp.neg_format();
	__sn = __mp.negative_sign();
	}
	else
	{
	__pat = __mp.pos_format();
	__sn = __mp.positive_sign();
	}
	__dp = __mp.decimal_point();
	__ts = __mp.thousands_sep();
	__grp = __mp.grouping();
	__sym = __mp.curr_symbol();
	__fd = __mp.frac_digits();
	}
	}

	template <class _CharT>
	void
	__money_put<_CharT>::__format(char_type* __mb, char_type& __mi, char_type& __me,
	ios_base::fmtflags __flags,
	const char_type* __db, const char_type* __de,
	const ctype<char_type>& __ct, bool __neg,
	const money_base::pattern& __pat, char_type __dp,
	char_type __ts, const string& __grp,
	const string_type& __sym, const string_type& __sn,
	int __fd)
	{
	__me = __mb;
	for (unsigned __p = 0; __p < 4; ++__p)
	{
	switch (__pat.field[__p])
	{
	case money_base::none:
	__mi = __me;
	break;
	case money_base::space:
	__mi = __me;
	*__me++ = __ct.widen(' ');
	break;
	case money_base::sign:
	if (!__sn.empty())
	*__me++ = __sn[0];
	break;
	case money_base::symbol:
	if (!__sym.empty() && (__flags & ios_base::showbase))
	__me = _VSTD::copy(__sym.begin(), __sym.end(), __me);
	break;
	case money_base::value:
	{
	// remember start of value so we can reverse it
	char_type* __t = __me;
	// find beginning of digits
	if (__neg)
	++__db;
	// find end of digits
	const char_type* __d;
	for (__d = __db; __d < __de; ++__d)
	if (!__ct.is(ctype_base::digit, *__d))
	break;
	// print fractional part
	if (__fd > 0)
	{
	int __f;
	for (__f = __fd; __d > __db && __f > 0; --__f)
	__me++ = --__d;
	char_type __z = __f > 0 ? __ct.widen('0') : char_type();
	for (; __f > 0; --__f)
	*__me++ = __z;
	*__me++ = __dp;
	}
	// print units part
	if (__d == __db)
	{
	*__me++ = __ct.widen('0');
	}
	else
	{
	unsigned __ng = 0;
	unsigned __ig = 0;
	unsigned __gl = __grp.empty() ? numeric_limits<unsigned>::max()
	: static_cast<unsigned>(__grp[__ig]);
	while (__d != __db)
	{
	if (__ng == __gl)
	{
	*__me++ = __ts;
	__ng = 0;
	if (++__ig < __grp.size())
	__gl = __grp[__ig] == numeric_limits<char>::max() ?
	numeric_limits<unsigned>::max() :
	static_cast<unsigned>(__grp[__ig]);
	}
	__me++ = --__d;
	++__ng;
	}
	}
	// reverse it
	reverse(__t, __me);
	}
	break;
	}
	}
	// print rest of sign, if any
	if (__sn.size() > 1)
	__me = _VSTD::copy(__sn.begin()+1, __sn.end(), __me);
	// set alignment
	if ((__flags & ios_base::adjustfield) == ios_base::left)
	__mi = __me;
	else if ((__flags & ios_base::adjustfield) != ios_base::internal)
	__mi = __mb;
	}

	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<char>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<wchar_t>)

	template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
	class _LIBCPP_TEMPLATE_VIS money_put
	: public locale::facet,
	private __money_put<_CharT>
	{
	public:
	typedef _CharT char_type;
	typedef _OutputIterator iter_type;
	typedef basic_string<char_type> string_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit money_put(size_t __refs = 0)
	: locale::facet(__refs) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl,
	long double __units) const
	{
	return do_put(__s, __intl, __iob, __fl, __units);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	iter_type put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl,
	const string_type& __digits) const
	{
	return do_put(__s, __intl, __iob, __fl, __digits);
	}

	static locale::id id;

	protected:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	~money_put() {}

	virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __iob,
	char_type __fl, long double __units) const;
	virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __iob,
	char_type __fl, const string_type& __digits) const;
	};

	template <class _CharT, class _OutputIterator>
	locale::id
	money_put<_CharT, _OutputIterator>::id;

	template <class _CharT, class _OutputIterator>
	_OutputIterator
	money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
	ios_base& __iob, char_type __fl,
	long double __units) const
	{
	// convert to char
	const size_t __bs = 100;
	char __buf[__bs];
	char* __bb = __buf;
	char_type __digits[__bs];
	char_type* __db = __digits;
	size_t __n = static_cast<size_t>(snprintf(__bb, __bs, "%.0Lf", __units));
	unique_ptr<char, void()(void)> __hn(0, free);
	unique_ptr<char_type, void()(void)> __hd(0, free);
	// secure memory for digit storage
	if (__n > __bs-1)
	{
	__n = static_cast<size_t>(__libcpp_asprintf_l(&__bb, _LIBCPP_GET_C_LOCALE, "%.0Lf", __units));
	if (__bb == 0)
	__throw_bad_alloc();
	__hn.reset(__bb);
	__hd.reset((char_type)malloc(__n sizeof(char_type)));
	if (__hd == nullptr)
	__throw_bad_alloc();
	__db = __hd.get();
	}
	// gather info
	locale __loc = __iob.getloc();
	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc);
	__ct.widen(__bb, __bb + __n, __db);
	bool __neg = __n > 0 && __bb[0] == '-';
	money_base::pattern __pat;
	char_type __dp;
	char_type __ts;
	string __grp;
	string_type __sym;
	string_type __sn;
	int __fd;
	this->__gather_info(__intl, __neg, __loc, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
	// secure memory for formatting
	char_type __mbuf[__bs];
	char_type* __mb = __mbuf;
	unique_ptr<char_type, void()(void)> __hw(0, free);
	size_t __exn = static_cast<int>(__n) > __fd ?
	(__n - static_cast<size_t>(__fd)) * 2 + __sn.size() +
	__sym.size() + static_cast<size_t>(__fd) + 1
	: __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2;
	if (__exn > __bs)
	{
	__hw.reset((char_type)malloc(__exn sizeof(char_type)));
	__mb = __hw.get();
	if (__mb == 0)
	__throw_bad_alloc();
	}
	// format
	char_type* __mi;
	char_type* __me;
	this->__format(__mb, __mi, __me, __iob.flags(),
	__db, __db + __n, __ct,
	__neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
	return __pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
	}

	template <class _CharT, class _OutputIterator>
	_OutputIterator
	money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
	ios_base& __iob, char_type __fl,
	const string_type& __digits) const
	{
	// gather info
	locale __loc = __iob.getloc();
	const ctype<char_type>& __ct = use_facet<ctype<char_type> >(__loc);
	bool __neg = __digits.size() > 0 && __digits[0] == __ct.widen('-');
	money_base::pattern __pat;
	char_type __dp;
	char_type __ts;
	string __grp;
	string_type __sym;
	string_type __sn;
	int __fd;
	this->__gather_info(__intl, __neg, __loc, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
	// secure memory for formatting
	char_type __mbuf[100];
	char_type* __mb = __mbuf;
	unique_ptr<char_type, void()(void)> __h(0, free);
	size_t __exn = static_cast<int>(__digits.size()) > __fd ?
	(__digits.size() - static_cast<size_t>(__fd)) * 2 +
	__sn.size() + __sym.size() + static_cast<size_t>(__fd) + 1
	: __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2;
	if (__exn > 100)
	{
	__h.reset((char_type)malloc(__exn sizeof(char_type)));
	__mb = __h.get();
	if (__mb == 0)
	__throw_bad_alloc();
	}
	// format
	char_type* __mi;
	char_type* __me;
	this->__format(__mb, __mi, __me, __iob.flags(),
	__digits.data(), __digits.data() + __digits.size(), __ct,
	__neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
	return __pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
	}

	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_put<char>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_put<wchar_t>)

	// messages

	class _LIBCPP_TYPE_VIS messages_base
	{
	public:
	typedef ptrdiff_t catalog;

	- _LIBCPP_ALWAYS_INLINE messages_base() {}
	+ _LIBCPP_INLINE_VISIBILITY messages_base() {}
	};

	template <class _CharT>
	class _LIBCPP_TEMPLATE_VIS messages
	: public locale::facet,
	public messages_base
	{
	public:
	typedef _CharT char_type;
	typedef basic_string<_CharT> string_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit messages(size_t __refs = 0)
	: locale::facet(__refs) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	catalog open(const basic_string<char>& __nm, const locale& __loc) const
	{
	return do_open(__nm, __loc);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	string_type get(catalog __c, int __set, int __msgid,
	const string_type& __dflt) const
	{
	return do_get(__c, __set, __msgid, __dflt);
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void close(catalog __c) const
	{
	do_close(__c);
	}

	static locale::id id;

	protected:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	~messages() {}

	virtual catalog do_open(const basic_string<char>&, const locale&) const;
	virtual string_type do_get(catalog, int __set, int __msgid,
	const string_type& __dflt) const;
	virtual void do_close(catalog) const;
	};

	template <class _CharT>
	locale::id
	messages<_CharT>::id;

	template <class _CharT>
	typename messages<_CharT>::catalog
	messages<_CharT>::do_open(const basic_string<char>& __nm, const locale&) const
	{
	#ifdef _LIBCPP_HAS_CATOPEN
	catalog __cat = (catalog)catopen(__nm.c_str(), NL_CAT_LOCALE);
	if (__cat != -1)
	__cat = static_cast<catalog>((static_cast<size_t>(__cat) >> 1));
	return __cat;
	#else // !_LIBCPP_HAS_CATOPEN
	return -1;
	#endif // _LIBCPP_HAS_CATOPEN
	}

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

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

	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages<char>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages<wchar_t>)

	template <class _CharT>
	class _LIBCPP_TEMPLATE_VIS messages_byname
	: public messages<_CharT>
	{
	public:
	typedef messages_base::catalog catalog;
	typedef basic_string<_CharT> string_type;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit messages_byname(const char*, size_t __refs = 0)
	: messages<_CharT>(__refs) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	explicit messages_byname(const string&, size_t __refs = 0)
	: messages<_CharT>(__refs) {}

	protected:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	~messages_byname() {}
	};

	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<char>)
	_LIBCPP_EXTERN_TEMPLATE2(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<wchar_t>)

	template<class _Codecvt, class _Elem = wchar_t,
	class _Wide_alloc = allocator<_Elem>,
	class _Byte_alloc = allocator<char> >
	class _LIBCPP_TEMPLATE_VIS wstring_convert
	{
	public:
	typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string;
	typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string;
	typedef typename _Codecvt::state_type state_type;
	typedef typename wide_string::traits_type::int_type int_type;

	private:
	byte_string __byte_err_string_;
	wide_string __wide_err_string_;
	_Codecvt* __cvtptr_;
	state_type __cvtstate_;
	size_t __cvtcount_;

	wstring_convert(const wstring_convert& __wc);
	wstring_convert& operator=(const wstring_convert& __wc);
	public:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_EXPLICIT_AFTER_CXX11 wstring_convert(_Codecvt* __pcvt = new _Codecvt);
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	wstring_convert(_Codecvt* __pcvt, state_type __state);
	_LIBCPP_EXPLICIT_AFTER_CXX11 wstring_convert(const byte_string& __byte_err,
	const wide_string& __wide_err = wide_string());
	#ifndef _LIBCPP_CXX03_LANG
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	wstring_convert(wstring_convert&& __wc);
	#endif
	~wstring_convert();

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	wide_string from_bytes(char __byte)
	{return from_bytes(&__byte, &__byte+1);}
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	wide_string from_bytes(const char* __ptr)
	{return from_bytes(__ptr, __ptr + char_traits<char>::length(__ptr));}
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	wide_string from_bytes(const byte_string& __str)
	{return from_bytes(__str.data(), __str.data() + __str.size());}
	wide_string from_bytes(const char* __first, const char* __last);

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	byte_string to_bytes(_Elem __wchar)
	{return to_bytes(&__wchar, &__wchar+1);}
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	byte_string to_bytes(const _Elem* __wptr)
	{return to_bytes(__wptr, __wptr + char_traits<_Elem>::length(__wptr));}
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	byte_string to_bytes(const wide_string& __wstr)
	{return to_bytes(__wstr.data(), __wstr.data() + __wstr.size());}
	byte_string to_bytes(const _Elem* __first, const _Elem* __last);

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	size_t converted() const _NOEXCEPT {return __cvtcount_;}
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	state_type state() const {return __cvtstate_;}
	};

	template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
	inline
	wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
	wstring_convert(_Codecvt* __pcvt)
	: __cvtptr_(__pcvt), __cvtstate_(), __cvtcount_(0)
	{
	}

	template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
	inline
	wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
	wstring_convert(_Codecvt* __pcvt, state_type __state)
	: __cvtptr_(__pcvt), __cvtstate_(__state), __cvtcount_(0)
	{
	}

	template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
	wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
	wstring_convert(const byte_string& __byte_err, const wide_string& __wide_err)
	: __byte_err_string_(__byte_err), __wide_err_string_(__wide_err),
	__cvtstate_(), __cvtcount_(0)
	{
	__cvtptr_ = new _Codecvt;
	}

	#ifndef _LIBCPP_CXX03_LANG

	template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
	inline
	wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
	wstring_convert(wstring_convert&& __wc)
	: __byte_err_string_(_VSTD::move(__wc.__byte_err_string_)),
	__wide_err_string_(_VSTD::move(__wc.__wide_err_string_)),
	__cvtptr_(__wc.__cvtptr_),
	__cvtstate_(__wc.__cvtstate_), __cvtcount_(__wc.__cvtcount_)
	{
	__wc.__cvtptr_ = nullptr;
	}

	#endif // _LIBCPP_CXX03_LANG

	template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
	wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::~wstring_convert()
	{
	delete __cvtptr_;
	}

	template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
	typename wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::wide_string
	wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
	from_bytes(const char* __frm, const char* __frm_end)
	{
	__cvtcount_ = 0;
	if (__cvtptr_ != nullptr)
	{
	wide_string __ws(2*(__frm_end - __frm), _Elem());
	if (__frm != __frm_end)
	__ws.resize(__ws.capacity());
	codecvt_base::result __r = codecvt_base::ok;
	state_type __st = __cvtstate_;
	if (__frm != __frm_end)
	{
	_Elem* __to = &__ws[0];
	_Elem* __to_end = __to + __ws.size();
	const char* __frm_nxt;
	do
	{
	_Elem* __to_nxt;
	__r = __cvtptr_->in(__st, __frm, __frm_end, __frm_nxt,
	__to, __to_end, __to_nxt);
	__cvtcount_ += __frm_nxt - __frm;
	if (__frm_nxt == __frm)
	{
	__r = codecvt_base::error;
	}
	else if (__r == codecvt_base::noconv)
	{
	__ws.resize(__to - &__ws[0]);
	// This only gets executed if _Elem is char
	__ws.append((const _Elem)__frm, (const _Elem)__frm_end);
	__frm = __frm_nxt;
	__r = codecvt_base::ok;
	}
	else if (__r == codecvt_base::ok)
	{
	__ws.resize(__to_nxt - &__ws[0]);
	__frm = __frm_nxt;
	}
	else if (__r == codecvt_base::partial)
	{
	ptrdiff_t __s = __to_nxt - &__ws[0];
	__ws.resize(2 * __s);
	__to = &__ws[0] + __s;
	__to_end = &__ws[0] + __ws.size();
	__frm = __frm_nxt;
	}
	} while (__r == codecvt_base::partial && __frm_nxt < __frm_end);
	}
	if (__r == codecvt_base::ok)
	return __ws;
	}

	if (__wide_err_string_.empty())
	__throw_range_error("wstring_convert: from_bytes error");

	return __wide_err_string_;
	}

	template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
	typename wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::byte_string
	wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
	to_bytes(const _Elem* __frm, const _Elem* __frm_end)
	{
	__cvtcount_ = 0;
	if (__cvtptr_ != nullptr)
	{
	byte_string __bs(2*(__frm_end - __frm), char());
	if (__frm != __frm_end)
	__bs.resize(__bs.capacity());
	codecvt_base::result __r = codecvt_base::ok;
	state_type __st = __cvtstate_;
	if (__frm != __frm_end)
	{
	char* __to = &__bs[0];
	char* __to_end = __to + __bs.size();
	const _Elem* __frm_nxt;
	do
	{
	char* __to_nxt;
	__r = __cvtptr_->out(__st, __frm, __frm_end, __frm_nxt,
	__to, __to_end, __to_nxt);
	__cvtcount_ += __frm_nxt - __frm;
	if (__frm_nxt == __frm)
	{
	__r = codecvt_base::error;
	}
	else if (__r == codecvt_base::noconv)
	{
	__bs.resize(__to - &__bs[0]);
	// This only gets executed if _Elem is char
	__bs.append((const char)__frm, (const char)__frm_end);
	__frm = __frm_nxt;
	__r = codecvt_base::ok;
	}
	else if (__r == codecvt_base::ok)
	{
	__bs.resize(__to_nxt - &__bs[0]);
	__frm = __frm_nxt;
	}
	else if (__r == codecvt_base::partial)
	{
	ptrdiff_t __s = __to_nxt - &__bs[0];
	__bs.resize(2 * __s);
	__to = &__bs[0] + __s;
	__to_end = &__bs[0] + __bs.size();
	__frm = __frm_nxt;
	}
	} while (__r == codecvt_base::partial && __frm_nxt < __frm_end);
	}
	if (__r == codecvt_base::ok)
	{
	size_t __s = __bs.size();
	__bs.resize(__bs.capacity());
	char* __to = &__bs[0] + __s;
	char* __to_end = __to + __bs.size();
	do
	{
	char* __to_nxt;
	__r = __cvtptr_->unshift(__st, __to, __to_end, __to_nxt);
	if (__r == codecvt_base::noconv)
	{
	__bs.resize(__to - &__bs[0]);
	__r = codecvt_base::ok;
	}
	else if (__r == codecvt_base::ok)
	{
	__bs.resize(__to_nxt - &__bs[0]);
	}
	else if (__r == codecvt_base::partial)
	{
	ptrdiff_t __sp = __to_nxt - &__bs[0];
	__bs.resize(2 * __sp);
	__to = &__bs[0] + __sp;
	__to_end = &__bs[0] + __bs.size();
	}
	} while (__r == codecvt_base::partial);
	if (__r == codecvt_base::ok)
	return __bs;
	}
	}

	if (__byte_err_string_.empty())
	__throw_range_error("wstring_convert: to_bytes error");

	return __byte_err_string_;
	}

	template <class _Codecvt, class _Elem = wchar_t, class _Tr = char_traits<_Elem> >
	class _LIBCPP_TEMPLATE_VIS wbuffer_convert
	: public basic_streambuf<_Elem, _Tr>
	{
	public:
	// types:
	typedef _Elem char_type;
	typedef _Tr traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;
	typedef typename _Codecvt::state_type state_type;

	private:
	char* __extbuf_;
	const char* __extbufnext_;
	const char* __extbufend_;
	char __extbuf_min_[8];
	size_t __ebs_;
	char_type* __intbuf_;
	size_t __ibs_;
	streambuf* __bufptr_;
	_Codecvt* __cv_;
	state_type __st_;
	ios_base::openmode __cm_;
	bool __owns_eb_;
	bool __owns_ib_;
	bool __always_noconv_;

	wbuffer_convert(const wbuffer_convert&);
	wbuffer_convert& operator=(const wbuffer_convert&);
	public:
	_LIBCPP_EXPLICIT_AFTER_CXX11 wbuffer_convert(streambuf* __bytebuf = 0,
	_Codecvt* __pcvt = new _Codecvt, state_type __state = state_type());
	~wbuffer_convert();

	_LIBCPP_INLINE_VISIBILITY
	streambuf* rdbuf() const {return __bufptr_;}
	_LIBCPP_INLINE_VISIBILITY
	streambuf* rdbuf(streambuf* __bytebuf)
	{
	streambuf* __r = __bufptr_;
	__bufptr_ = __bytebuf;
	return __r;
	}

	_LIBCPP_INLINE_VISIBILITY
	state_type state() const {return __st_;}

	protected:
	virtual int_type underflow();
	virtual int_type pbackfail(int_type __c = traits_type::eof());
	virtual int_type overflow (int_type __c = traits_type::eof());
	virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* __s,
	streamsize __n);
	virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
	ios_base::openmode __wch = ios_base::in \| ios_base::out);
	virtual pos_type seekpos(pos_type __sp,
	ios_base::openmode __wch = ios_base::in \| ios_base::out);
	virtual int sync();

	private:
	bool __read_mode();
	void __write_mode();
	wbuffer_convert* __close();
	};

	template <class _Codecvt, class _Elem, class _Tr>
	wbuffer_convert<_Codecvt, _Elem, _Tr>::
	wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt, state_type __state)
	: __extbuf_(0),
	__extbufnext_(0),
	__extbufend_(0),
	__ebs_(0),
	__intbuf_(0),
	__ibs_(0),
	__bufptr_(__bytebuf),
	__cv_(__pcvt),
	__st_(__state),
	__cm_(0),
	__owns_eb_(false),
	__owns_ib_(false),
	__always_noconv_(__cv_ ? __cv_->always_noconv() : false)
	{
	setbuf(0, 4096);
	}

	template <class _Codecvt, class _Elem, class _Tr>
	wbuffer_convert<_Codecvt, _Elem, _Tr>::~wbuffer_convert()
	{
	__close();
	delete __cv_;
	if (__owns_eb_)
	delete [] __extbuf_;
	if (__owns_ib_)
	delete [] __intbuf_;
	}

	template <class _Codecvt, class _Elem, class _Tr>
	typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type
	wbuffer_convert<_Codecvt, _Elem, _Tr>::underflow()
	{
	if (__cv_ == 0 \|\| __bufptr_ == 0)
	return traits_type::eof();
	bool __initial = __read_mode();
	char_type __1buf;
	if (this->gptr() == 0)
	this->setg(&__1buf, &__1buf+1, &__1buf+1);
	const size_t __unget_sz = __initial ? 0 : min<size_t>((this->egptr() - this->eback()) / 2, 4);
	int_type __c = traits_type::eof();
	if (this->gptr() == this->egptr())
	{
	memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type));
	if (__always_noconv_)
	{
	streamsize __nmemb = static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz);
	__nmemb = __bufptr_->sgetn((char*)this->eback() + __unget_sz, __nmemb);
	if (__nmemb != 0)
	{
	this->setg(this->eback(),
	this->eback() + __unget_sz,
	this->eback() + __unget_sz + __nmemb);
	__c = *this->gptr();
	}
	}
	else
	{
	_LIBCPP_ASSERT(!(__extbufnext_ == NULL && (__extbufend_ != __extbufnext_)), "underflow moving from NULL" );
	if (__extbufend_ != __extbufnext_)
	memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
	__extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
	__extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
	streamsize __nmemb = _VSTD::min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
	static_cast<streamsize>(__extbufend_ - __extbufnext_));
	codecvt_base::result __r;
	// FIXME: Do we ever need to restore the state here?
	//state_type __svs = __st_;
	streamsize __nr = __bufptr_->sgetn(const_cast<char*>(__extbufnext_), __nmemb);
	if (__nr != 0)
	{
	__extbufend_ = __extbufnext_ + __nr;
	char_type* __inext;
	__r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_,
	this->eback() + __unget_sz,
	this->egptr(), __inext);
	if (__r == codecvt_base::noconv)
	{
	this->setg((char_type)__extbuf_, (char_type)__extbuf_,
	(char_type) const_cast<char >(__extbufend_));
	__c = *this->gptr();
	}
	else if (__inext != this->eback() + __unget_sz)
	{
	this->setg(this->eback(), this->eback() + __unget_sz, __inext);
	__c = *this->gptr();
	}
	}
	}
	}
	else
	__c = *this->gptr();
	if (this->eback() == &__1buf)
	this->setg(0, 0, 0);
	return __c;
	}

	template <class _Codecvt, class _Elem, class _Tr>
	typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type
	wbuffer_convert<_Codecvt, _Elem, _Tr>::pbackfail(int_type __c)
	{
	if (__cv_ != 0 && __bufptr_ != 0 && this->eback() < this->gptr())
	{
	if (traits_type::eq_int_type(__c, traits_type::eof()))
	{
	this->gbump(-1);
	return traits_type::not_eof(__c);
	}
	if (traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1]))
	{
	this->gbump(-1);
	*this->gptr() = traits_type::to_char_type(__c);
	return __c;
	}
	}
	return traits_type::eof();
	}

	template <class _Codecvt, class _Elem, class _Tr>
	typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type
	wbuffer_convert<_Codecvt, _Elem, _Tr>::overflow(int_type __c)
	{
	if (__cv_ == 0 \|\| __bufptr_ == 0)
	return traits_type::eof();
	__write_mode();
	char_type __1buf;
	char_type* __pb_save = this->pbase();
	char_type* __epb_save = this->epptr();
	if (!traits_type::eq_int_type(__c, traits_type::eof()))
	{
	if (this->pptr() == 0)
	this->setp(&__1buf, &__1buf+1);
	*this->pptr() = traits_type::to_char_type(__c);
	this->pbump(1);
	}
	if (this->pptr() != this->pbase())
	{
	if (__always_noconv_)
	{
	streamsize __nmemb = static_cast<streamsize>(this->pptr() - this->pbase());
	if (__bufptr_->sputn((const char*)this->pbase(), __nmemb) != __nmemb)
	return traits_type::eof();
	}
	else
	{
	char* __extbe = __extbuf_;
	codecvt_base::result __r;
	do
	{
	const char_type* __e;
	__r = __cv_->out(__st_, this->pbase(), this->pptr(), __e,
	__extbuf_, __extbuf_ + __ebs_, __extbe);
	if (__e == this->pbase())
	return traits_type::eof();
	if (__r == codecvt_base::noconv)
	{
	streamsize __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
	if (__bufptr_->sputn((const char*)this->pbase(), __nmemb) != __nmemb)
	return traits_type::eof();
	}
	else if (__r == codecvt_base::ok \|\| __r == codecvt_base::partial)
	{
	streamsize __nmemb = static_cast<size_t>(__extbe - __extbuf_);
	if (__bufptr_->sputn(__extbuf_, __nmemb) != __nmemb)
	return traits_type::eof();
	if (__r == codecvt_base::partial)
	{
	this->setp(const_cast<char_type *>(__e), this->pptr());
	this->__pbump(this->epptr() - this->pbase());
	}
	}
	else
	return traits_type::eof();
	} while (__r == codecvt_base::partial);
	}
	this->setp(__pb_save, __epb_save);
	}
	return traits_type::not_eof(__c);
	}

	template <class _Codecvt, class _Elem, class _Tr>
	basic_streambuf<_Elem, _Tr>*
	wbuffer_convert<_Codecvt, _Elem, _Tr>::setbuf(char_type* __s, streamsize __n)
	{
	this->setg(0, 0, 0);
	this->setp(0, 0);
	if (__owns_eb_)
	delete [] __extbuf_;
	if (__owns_ib_)
	delete [] __intbuf_;
	__ebs_ = __n;
	if (__ebs_ > sizeof(__extbuf_min_))
	{
	if (__always_noconv_ && __s)
	{
	__extbuf_ = (char*)__s;
	__owns_eb_ = false;
	}
	else
	{
	__extbuf_ = new char[__ebs_];
	__owns_eb_ = true;
	}
	}
	else
	{
	__extbuf_ = __extbuf_min_;
	__ebs_ = sizeof(__extbuf_min_);
	__owns_eb_ = false;
	}
	if (!__always_noconv_)
	{
	__ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_));
	if (__s && __ibs_ >= sizeof(__extbuf_min_))
	{
	__intbuf_ = __s;
	__owns_ib_ = false;
	}
	else
	{
	__intbuf_ = new char_type[__ibs_];
	__owns_ib_ = true;
	}
	}
	else
	{
	__ibs_ = 0;
	__intbuf_ = 0;
	__owns_ib_ = false;
	}
	return this;
	}

	template <class _Codecvt, class _Elem, class _Tr>
	typename wbuffer_convert<_Codecvt, _Elem, _Tr>::pos_type
	wbuffer_convert<_Codecvt, _Elem, _Tr>::seekoff(off_type __off, ios_base::seekdir __way,
	ios_base::openmode __om)
	{
	int __width = __cv_->encoding();
	if (__cv_ == 0 \|\| __bufptr_ == 0 \|\| (__width <= 0 && __off != 0) \|\| sync())
	return pos_type(off_type(-1));
	// __width > 0 \|\| __off == 0, now check __way
	if (__way != ios_base::beg && __way != ios_base::cur && __way != ios_base::end)
	return pos_type(off_type(-1));
	pos_type __r = __bufptr_->pubseekoff(__width * __off, __way, __om);
	__r.state(__st_);
	return __r;
	}

	template <class _Codecvt, class _Elem, class _Tr>
	typename wbuffer_convert<_Codecvt, _Elem, _Tr>::pos_type
	wbuffer_convert<_Codecvt, _Elem, _Tr>::seekpos(pos_type __sp, ios_base::openmode __wch)
	{
	if (__cv_ == 0 \|\| __bufptr_ == 0 \|\| sync())
	return pos_type(off_type(-1));
	if (__bufptr_->pubseekpos(__sp, __wch) == pos_type(off_type(-1)))
	return pos_type(off_type(-1));
	return __sp;
	}

	template <class _Codecvt, class _Elem, class _Tr>
	int
	wbuffer_convert<_Codecvt, _Elem, _Tr>::sync()
	{
	if (__cv_ == 0 \|\| __bufptr_ == 0)
	return 0;
	if (__cm_ & ios_base::out)
	{
	if (this->pptr() != this->pbase())
	if (overflow() == traits_type::eof())
	return -1;
	codecvt_base::result __r;
	do
	{
	char* __extbe;
	__r = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe);
	streamsize __nmemb = static_cast<streamsize>(__extbe - __extbuf_);
	if (__bufptr_->sputn(__extbuf_, __nmemb) != __nmemb)
	return -1;
	} while (__r == codecvt_base::partial);
	if (__r == codecvt_base::error)
	return -1;
	if (__bufptr_->pubsync())
	return -1;
	}
	else if (__cm_ & ios_base::in)
	{
	off_type __c;
	if (__always_noconv_)
	__c = this->egptr() - this->gptr();
	else
	{
	int __width = __cv_->encoding();
	__c = __extbufend_ - __extbufnext_;
	if (__width > 0)
	__c += __width * (this->egptr() - this->gptr());
	else
	{
	if (this->gptr() != this->egptr())
	{
	reverse(this->gptr(), this->egptr());
	codecvt_base::result __r;
	const char_type* __e = this->gptr();
	char* __extbe;
	do
	{
	__r = __cv_->out(__st_, __e, this->egptr(), __e,
	__extbuf_, __extbuf_ + __ebs_, __extbe);
	switch (__r)
	{
	case codecvt_base::noconv:
	__c += this->egptr() - this->gptr();
	break;
	case codecvt_base::ok:
	case codecvt_base::partial:
	__c += __extbe - __extbuf_;
	break;
	default:
	return -1;
	}
	} while (__r == codecvt_base::partial);
	}
	}
	}
	if (__bufptr_->pubseekoff(-__c, ios_base::cur, __cm_) == pos_type(off_type(-1)))
	return -1;
	this->setg(0, 0, 0);
	__cm_ = 0;
	}
	return 0;
	}

	template <class _Codecvt, class _Elem, class _Tr>
	bool
	wbuffer_convert<_Codecvt, _Elem, _Tr>::__read_mode()
	{
	if (!(__cm_ & ios_base::in))
	{
	this->setp(0, 0);
	if (__always_noconv_)
	this->setg((char_type*)__extbuf_,
	(char_type*)__extbuf_ + __ebs_,
	(char_type*)__extbuf_ + __ebs_);
	else
	this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_);
	__cm_ = ios_base::in;
	return true;
	}
	return false;
	}

	template <class _Codecvt, class _Elem, class _Tr>
	void
	wbuffer_convert<_Codecvt, _Elem, _Tr>::__write_mode()
	{
	if (!(__cm_ & ios_base::out))
	{
	this->setg(0, 0, 0);
	if (__ebs_ > sizeof(__extbuf_min_))
	{
	if (__always_noconv_)
	this->setp((char_type*)__extbuf_,
	(char_type*)__extbuf_ + (__ebs_ - 1));
	else
	this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1));
	}
	else
	this->setp(0, 0);
	__cm_ = ios_base::out;
	}
	}

	template <class _Codecvt, class _Elem, class _Tr>
	wbuffer_convert<_Codecvt, _Elem, _Tr>*
	wbuffer_convert<_Codecvt, _Elem, _Tr>::__close()
	{
	wbuffer_convert* __rt = 0;
	if (__cv_ != 0 && __bufptr_ != 0)
	{
	__rt = this;
	if ((__cm_ & ios_base::out) && sync())
	__rt = 0;
	}
	return __rt;
	}

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_LOCALE
	Index: projects/clang700-import/contrib/libc++/include/locale.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/locale.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/locale.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/include/locale.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/map
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/map (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/map (revision 337135)
	@@ -1,1926 +1,1977 @@
	// -- C++ --
	//===----------------------------- map ------------------------------------===//
	//
	// 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_MAP
	#define _LIBCPP_MAP

	/*

	map synopsis

	namespace std
	{

	template <class Key, class T, class Compare = less<Key>,
	class Allocator = allocator<pair<const Key, T>>>
	class map
	{
	public:
	// types:
	typedef Key key_type;
	typedef T mapped_type;
	typedef pair<const key_type, mapped_type> value_type;
	typedef Compare key_compare;
	typedef Allocator allocator_type;
	typedef typename allocator_type::reference reference;
	typedef typename allocator_type::const_reference const_reference;
	typedef typename allocator_type::pointer pointer;
	typedef typename allocator_type::const_pointer const_pointer;
	typedef typename allocator_type::size_type size_type;
	typedef typename allocator_type::difference_type difference_type;

	typedef implementation-defined iterator;
	typedef implementation-defined const_iterator;
	typedef std::reverse_iterator<iterator> reverse_iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

	class value_compare
	: public binary_function<value_type, value_type, bool>
	{
	friend class map;
	protected:
	key_compare comp;

	value_compare(key_compare c);
	public:
	bool operator()(const value_type& x, const value_type& y) const;
	};

	// construct/copy/destroy:
	map()
	noexcept(
	is_nothrow_default_constructible<allocator_type>::value &&
	is_nothrow_default_constructible<key_compare>::value &&
	is_nothrow_copy_constructible<key_compare>::value);
	explicit map(const key_compare& comp);
	map(const key_compare& comp, const allocator_type& a);
	template <class InputIterator>
	map(InputIterator first, InputIterator last,
	const key_compare& comp = key_compare());
	template <class InputIterator>
	map(InputIterator first, InputIterator last,
	const key_compare& comp, const allocator_type& a);
	map(const map& m);
	map(map&& m)
	noexcept(
	is_nothrow_move_constructible<allocator_type>::value &&
	is_nothrow_move_constructible<key_compare>::value);
	explicit map(const allocator_type& a);
	map(const map& m, const allocator_type& a);
	map(map&& m, const allocator_type& a);
	map(initializer_list<value_type> il, const key_compare& comp = key_compare());
	map(initializer_list<value_type> il, const key_compare& comp, const allocator_type& a);
	template <class InputIterator>
	map(InputIterator first, InputIterator last, const allocator_type& a)
	: map(first, last, Compare(), a) {} // C++14
	map(initializer_list<value_type> il, const allocator_type& a)
	: map(il, Compare(), a) {} // C++14
	~map();

	map& operator=(const map& m);
	map& operator=(map&& m)
	noexcept(
	allocator_type::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<allocator_type>::value &&
	is_nothrow_move_assignable<key_compare>::value);
	map& operator=(initializer_list<value_type> il);

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

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

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

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

	// element access:
	mapped_type& operator[](const key_type& k);
	mapped_type& operator[](key_type&& k);

	mapped_type& at(const key_type& k);
	const mapped_type& at(const key_type& k) const;

	// modifiers:
	template <class... Args>
	pair<iterator, bool> emplace(Args&&... args);
	template <class... Args>
	iterator emplace_hint(const_iterator position, Args&&... args);
	pair<iterator, bool> insert(const value_type& v);
	pair<iterator, bool> insert( value_type&& v); // C++17
	template <class P>
	pair<iterator, bool> insert(P&& p);
	iterator insert(const_iterator position, const value_type& v);
	iterator insert(const_iterator position, value_type&& v); // C++17
	template <class P>
	iterator insert(const_iterator position, P&& p);
	template <class InputIterator>
	void insert(InputIterator first, InputIterator last);
	void insert(initializer_list<value_type> il);

	template <class... Args>
	pair<iterator, bool> try_emplace(const key_type& k, Args&&... args); // C++17
	template <class... Args>
	pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); // C++17
	template <class... Args>
	iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); // C++17
	template <class... Args>
	iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); // C++17
	template <class M>
	pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj); // C++17
	template <class M>
	pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj); // C++17
	template <class M>
	iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); // C++17
	template <class M>
	iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); // C++17

	iterator erase(const_iterator position);
	iterator erase(iterator position); // C++14
	size_type erase(const key_type& k);
	iterator erase(const_iterator first, const_iterator last);
	void clear() noexcept;

	void swap(map& m)
	noexcept(allocator_traits<allocator_type>::is_always_equal::value &&
	is_nothrow_swappable<key_compare>::value); // C++17

	// observers:
	allocator_type get_allocator() const noexcept;
	key_compare key_comp() const;
	value_compare value_comp() const;

	// map operations:
	iterator find(const key_type& k);
	const_iterator find(const key_type& k) const;
	template<typename K>
	iterator find(const K& x); // C++14
	template<typename K>
	const_iterator find(const K& x) const; // C++14
	template<typename K>
	size_type count(const K& x) const; // C++14

	size_type count(const key_type& k) const;
	iterator lower_bound(const key_type& k);
	const_iterator lower_bound(const key_type& k) const;
	template<typename K>
	iterator lower_bound(const K& x); // C++14
	template<typename K>
	const_iterator lower_bound(const K& x) const; // C++14

	iterator upper_bound(const key_type& k);
	const_iterator upper_bound(const key_type& k) const;
	template<typename K>
	iterator upper_bound(const K& x); // C++14
	template<typename K>
	const_iterator upper_bound(const K& x) const; // C++14

	pair<iterator,iterator> equal_range(const key_type& k);
	pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
	template<typename K>
	pair<iterator,iterator> equal_range(const K& x); // C++14
	template<typename K>
	pair<const_iterator,const_iterator> equal_range(const K& x) const; // C++14
	};

	template <class Key, class T, class Compare, class Allocator>
	bool
	operator==(const map<Key, T, Compare, Allocator>& x,
	const map<Key, T, Compare, Allocator>& y);

	template <class Key, class T, class Compare, class Allocator>
	bool
	operator< (const map<Key, T, Compare, Allocator>& x,
	const map<Key, T, Compare, Allocator>& y);

	template <class Key, class T, class Compare, class Allocator>
	bool
	operator!=(const map<Key, T, Compare, Allocator>& x,
	const map<Key, T, Compare, Allocator>& y);

	template <class Key, class T, class Compare, class Allocator>
	bool
	operator> (const map<Key, T, Compare, Allocator>& x,
	const map<Key, T, Compare, Allocator>& y);

	template <class Key, class T, class Compare, class Allocator>
	bool
	operator>=(const map<Key, T, Compare, Allocator>& x,
	const map<Key, T, Compare, Allocator>& y);

	template <class Key, class T, class Compare, class Allocator>
	bool
	operator<=(const map<Key, T, Compare, Allocator>& x,
	const map<Key, T, Compare, Allocator>& y);

	// specialized algorithms:
	template <class Key, class T, class Compare, class Allocator>
	void
	swap(map<Key, T, Compare, Allocator>& x, map<Key, T, Compare, Allocator>& y)
	noexcept(noexcept(x.swap(y)));

	template <class Key, class T, class Compare = less<Key>,
	class Allocator = allocator<pair<const Key, T>>>
	class multimap
	{
	public:
	// types:
	typedef Key key_type;
	typedef T mapped_type;
	typedef pair<const key_type,mapped_type> value_type;
	typedef Compare key_compare;
	typedef Allocator allocator_type;
	typedef typename allocator_type::reference reference;
	typedef typename allocator_type::const_reference const_reference;
	typedef typename allocator_type::size_type size_type;
	typedef typename allocator_type::difference_type difference_type;
	typedef typename allocator_type::pointer pointer;
	typedef typename allocator_type::const_pointer const_pointer;

	typedef implementation-defined iterator;
	typedef implementation-defined const_iterator;
	typedef std::reverse_iterator<iterator> reverse_iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

	class value_compare
	: public binary_function<value_type,value_type,bool>
	{
	friend class multimap;
	protected:
	key_compare comp;
	value_compare(key_compare c);
	public:
	bool operator()(const value_type& x, const value_type& y) const;
	};

	// construct/copy/destroy:
	multimap()
	noexcept(
	is_nothrow_default_constructible<allocator_type>::value &&
	is_nothrow_default_constructible<key_compare>::value &&
	is_nothrow_copy_constructible<key_compare>::value);
	explicit multimap(const key_compare& comp);
	multimap(const key_compare& comp, const allocator_type& a);
	template <class InputIterator>
	multimap(InputIterator first, InputIterator last, const key_compare& comp);
	template <class InputIterator>
	multimap(InputIterator first, InputIterator last, const key_compare& comp,
	const allocator_type& a);
	multimap(const multimap& m);
	multimap(multimap&& m)
	noexcept(
	is_nothrow_move_constructible<allocator_type>::value &&
	is_nothrow_move_constructible<key_compare>::value);
	explicit multimap(const allocator_type& a);
	multimap(const multimap& m, const allocator_type& a);
	multimap(multimap&& m, const allocator_type& a);
	multimap(initializer_list<value_type> il, const key_compare& comp = key_compare());
	multimap(initializer_list<value_type> il, const key_compare& comp,
	const allocator_type& a);
	template <class InputIterator>
	multimap(InputIterator first, InputIterator last, const allocator_type& a)
	: multimap(first, last, Compare(), a) {} // C++14
	multimap(initializer_list<value_type> il, const allocator_type& a)
	: multimap(il, Compare(), a) {} // C++14
	~multimap();

	multimap& operator=(const multimap& m);
	multimap& operator=(multimap&& m)
	noexcept(
	allocator_type::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<allocator_type>::value &&
	is_nothrow_move_assignable<key_compare>::value);
	multimap& operator=(initializer_list<value_type> il);

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

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

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

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

	// modifiers:
	template <class... Args>
	iterator emplace(Args&&... args);
	template <class... Args>
	iterator emplace_hint(const_iterator position, Args&&... args);
	iterator insert(const value_type& v);
	iterator insert( value_type&& v); // C++17
	template <class P>
	iterator insert(P&& p);
	iterator insert(const_iterator position, const value_type& v);
	iterator insert(const_iterator position, value_type&& v); // C++17
	template <class P>
	iterator insert(const_iterator position, P&& p);
	template <class InputIterator>
	void insert(InputIterator first, InputIterator last);
	void insert(initializer_list<value_type> il);

	iterator erase(const_iterator position);
	iterator erase(iterator position); // C++14
	size_type erase(const key_type& k);
	iterator erase(const_iterator first, const_iterator last);
	void clear() noexcept;

	void swap(multimap& m)
	noexcept(allocator_traits<allocator_type>::is_always_equal::value &&
	is_nothrow_swappable<key_compare>::value); // C++17

	// observers:
	allocator_type get_allocator() const noexcept;
	key_compare key_comp() const;
	value_compare value_comp() const;

	// map operations:
	iterator find(const key_type& k);
	const_iterator find(const key_type& k) const;
	template<typename K>
	iterator find(const K& x); // C++14
	template<typename K>
	const_iterator find(const K& x) const; // C++14
	template<typename K>
	size_type count(const K& x) const; // C++14

	size_type count(const key_type& k) const;
	iterator lower_bound(const key_type& k);
	const_iterator lower_bound(const key_type& k) const;
	template<typename K>
	iterator lower_bound(const K& x); // C++14
	template<typename K>
	const_iterator lower_bound(const K& x) const; // C++14

	iterator upper_bound(const key_type& k);
	const_iterator upper_bound(const key_type& k) const;
	template<typename K>
	iterator upper_bound(const K& x); // C++14
	template<typename K>
	const_iterator upper_bound(const K& x) const; // C++14

	pair<iterator,iterator> equal_range(const key_type& k);
	pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
	template<typename K>
	pair<iterator,iterator> equal_range(const K& x); // C++14
	template<typename K>
	pair<const_iterator,const_iterator> equal_range(const K& x) const; // C++14
	};

	template <class Key, class T, class Compare, class Allocator>
	bool
	operator==(const multimap<Key, T, Compare, Allocator>& x,
	const multimap<Key, T, Compare, Allocator>& y);

	template <class Key, class T, class Compare, class Allocator>
	bool
	operator< (const multimap<Key, T, Compare, Allocator>& x,
	const multimap<Key, T, Compare, Allocator>& y);

	template <class Key, class T, class Compare, class Allocator>
	bool
	operator!=(const multimap<Key, T, Compare, Allocator>& x,
	const multimap<Key, T, Compare, Allocator>& y);

	template <class Key, class T, class Compare, class Allocator>
	bool
	operator> (const multimap<Key, T, Compare, Allocator>& x,
	const multimap<Key, T, Compare, Allocator>& y);

	template <class Key, class T, class Compare, class Allocator>
	bool
	operator>=(const multimap<Key, T, Compare, Allocator>& x,
	const multimap<Key, T, Compare, Allocator>& y);

	template <class Key, class T, class Compare, class Allocator>
	bool
	operator<=(const multimap<Key, T, Compare, Allocator>& x,
	const multimap<Key, T, Compare, Allocator>& y);

	// specialized algorithms:
	template <class Key, class T, class Compare, class Allocator>
	void
	swap(multimap<Key, T, Compare, Allocator>& x,
	multimap<Key, T, Compare, Allocator>& y)
	noexcept(noexcept(x.swap(y)));

	} // std

	*/

	#include <__config>
	#include <__tree>
	#include <iterator>
	#include <memory>
	#include <utility>
	#include <functional>
	#include <initializer_list>
	#include <type_traits>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _Key, class _CP, class _Compare, bool _IsSmall>
	class __map_value_compare
	: private _Compare
	{
	public:
	_LIBCPP_INLINE_VISIBILITY
	__map_value_compare()
	_NOEXCEPT_(is_nothrow_default_constructible<_Compare>::value)
	: _Compare() {}
	_LIBCPP_INLINE_VISIBILITY
	__map_value_compare(_Compare c)
	_NOEXCEPT_(is_nothrow_copy_constructible<_Compare>::value)
	: _Compare(c) {}
	_LIBCPP_INLINE_VISIBILITY
	const _Compare& key_comp() const _NOEXCEPT {return *this;}
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const _CP& __x, const _CP& __y) const
	- {return static_cast<const _Compare&>(*this)(__x.__cc.first, __y.__cc.first);}
	+ {return static_cast<const _Compare&>(*this)(__x.__get_value().first, __y.__get_value().first);}
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const _CP& __x, const _Key& __y) const
	- {return static_cast<const _Compare&>(*this)(__x.__cc.first, __y);}
	+ {return static_cast<const _Compare&>(*this)(__x.__get_value().first, __y);}
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Key& __x, const _CP& __y) const
	- {return static_cast<const _Compare&>(*this)(__x, __y.__cc.first);}
	+ {return static_cast<const _Compare&>(*this)(__x, __y.__get_value().first);}
	void swap(__map_value_compare&__y)
	_NOEXCEPT_(__is_nothrow_swappable<_Compare>::value)
	{
	using _VSTD::swap;
	swap(static_cast<_Compare&>(*this), static_cast<_Compare&>(__y));
	}

	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
	operator () ( const _K2& __x, const _CP& __y ) const
	- {return static_cast<const _Compare&>(*this) (__x, __y.__cc.first);}
	+ {return static_cast<const _Compare&>(*this) (__x, __y.__get_value().first);}

	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
	operator () (const _CP& __x, const _K2& __y) const
	- {return static_cast<const _Compare&>(*this) (__x.__cc.first, __y);}
	+ {return static_cast<const _Compare&>(*this) (__x.__get_value().first, __y);}
	#endif
	};

	template <class _Key, class _CP, class _Compare>
	class __map_value_compare<_Key, _CP, _Compare, false>
	{
	_Compare comp;

	public:
	_LIBCPP_INLINE_VISIBILITY
	__map_value_compare()
	_NOEXCEPT_(is_nothrow_default_constructible<_Compare>::value)
	: comp() {}
	_LIBCPP_INLINE_VISIBILITY
	__map_value_compare(_Compare c)
	_NOEXCEPT_(is_nothrow_copy_constructible<_Compare>::value)
	: comp(c) {}
	_LIBCPP_INLINE_VISIBILITY
	const _Compare& key_comp() const _NOEXCEPT {return comp;}

	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const _CP& __x, const _CP& __y) const
	- {return comp(__x.__cc.first, __y.__cc.first);}
	+ {return comp(__x.__get_value().first, __y.__get_value().first);}
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const _CP& __x, const _Key& __y) const
	- {return comp(__x.__cc.first, __y);}
	+ {return comp(__x.__get_value().first, __y);}
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Key& __x, const _CP& __y) const
	- {return comp(__x, __y.__cc.first);}
	+ {return comp(__x, __y.__get_value().first);}
	void swap(__map_value_compare&__y)
	_NOEXCEPT_(__is_nothrow_swappable<_Compare>::value)
	{
	using _VSTD::swap;
	swap(comp, __y.comp);
	}

	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
	operator () ( const _K2& __x, const _CP& __y ) const
	- {return comp (__x, __y.__cc.first);}
	+ {return comp (__x, __y.__get_value().first);}

	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
	operator () (const _CP& __x, const _K2& __y) const
	- {return comp (__x.__cc.first, __y);}
	+ {return comp (__x.__get_value().first, __y);}
	#endif
	};

	template <class _Key, class _CP, class _Compare, bool __b>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(__map_value_compare<_Key, _CP, _Compare, __b>& __x,
	__map_value_compare<_Key, _CP, _Compare, __b>& __y)
	_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
	{
	__x.swap(__y);
	}

	template <class _Allocator>
	class __map_node_destructor
	{
	typedef _Allocator allocator_type;
	typedef allocator_traits<allocator_type> __alloc_traits;

	public:
	typedef typename __alloc_traits::pointer pointer;

	private:
	allocator_type& __na_;

	__map_node_destructor& operator=(const __map_node_destructor&);

	public:
	bool __first_constructed;
	bool __second_constructed;

	_LIBCPP_INLINE_VISIBILITY
	explicit __map_node_destructor(allocator_type& __na) _NOEXCEPT
	: __na_(__na),
	__first_constructed(false),
	__second_constructed(false)
	{}

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	__map_node_destructor(__tree_node_destructor<allocator_type>&& __x) _NOEXCEPT
	: __na_(__x.__na_),
	__first_constructed(__x.__value_constructed),
	__second_constructed(__x.__value_constructed)
	{
	__x.__value_constructed = false;
	}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	void operator()(pointer __p) _NOEXCEPT
	{
	if (__second_constructed)
	- __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__cc.second));
	+ __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().second));
	if (__first_constructed)
	- __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__cc.first));
	+ __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().first));
	if (__p)
	__alloc_traits::deallocate(__na_, __p, 1);
	}
	};

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	class map;
	template <class _Key, class _Tp, class _Compare, class _Allocator>
	class multimap;
	template <class _TreeIterator> class __map_const_iterator;

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Key, class _Tp>
	-union __value_type
	+struct __value_type
	{
	typedef _Key key_type;
	typedef _Tp mapped_type;
	typedef pair<const key_type, mapped_type> value_type;
	- typedef pair<key_type, mapped_type> __nc_value_type;
	+ typedef pair<key_type&, mapped_type&> __nc_ref_pair_type;
	+ typedef pair<key_type&&, mapped_type&&> __nc_rref_pair_type;

	+private:
	value_type __cc;
	- __nc_value_type __nc;

	+public:
	_LIBCPP_INLINE_VISIBILITY
	+ value_type& __get_value()
	+ {
	+#if _LIBCPP_STD_VER > 14
	+ return *_VSTD::launder(_VSTD::addressof(__cc));
	+#else
	+ return __cc;
	+#endif
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ const value_type& __get_value() const
	+ {
	+#if _LIBCPP_STD_VER > 14
	+ return *_VSTD::launder(_VSTD::addressof(__cc));
	+#else
	+ return __cc;
	+#endif
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ __nc_ref_pair_type __ref()
	+ {
	+ value_type& __v = __get_value();
	+ return __nc_ref_pair_type(const_cast<key_type&>(__v.first), __v.second);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ __nc_rref_pair_type __move()
	+ {
	+ value_type& __v = __get_value();
	+ return __nc_rref_pair_type(
	+ _VSTD::move(const_cast<key_type&>(__v.first)),
	+ _VSTD::move(__v.second));
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	__value_type& operator=(const __value_type& __v)
	- {__nc = __v.__cc; return *this;}
	+ {
	+ __ref() = __v.__get_value();
	+ return *this;
	+ }

	_LIBCPP_INLINE_VISIBILITY
	__value_type& operator=(__value_type&& __v)
	- {__nc = _VSTD::move(__v.__nc); return *this;}
	+ {
	+ __ref() = __v.__move();
	+ return *this;
	+ }

	template <class _ValueTp,
	class = typename enable_if<
	__is_same_uncvref<_ValueTp, value_type>::value
	>::type
	>
	_LIBCPP_INLINE_VISIBILITY
	- __value_type& operator=(_ValueTp&& __v) {
	- __nc = _VSTD::forward<_ValueTp>(__v); return *this;
	+ __value_type& operator=(_ValueTp&& __v)
	+ {
	+ __ref() = _VSTD::forward<_ValueTp>(__v);
	+ return *this;
	}

	private:
	__value_type() _LIBCPP_EQUAL_DELETE;
	~__value_type() _LIBCPP_EQUAL_DELETE;
	__value_type(const __value_type& __v) _LIBCPP_EQUAL_DELETE;
	__value_type(__value_type&& __v) _LIBCPP_EQUAL_DELETE;
	};

	#else

	template <class _Key, class _Tp>
	struct __value_type
	{
	typedef _Key key_type;
	typedef _Tp mapped_type;
	typedef pair<const key_type, mapped_type> value_type;

	+private:
	value_type __cc;

	+public:
	+ _LIBCPP_INLINE_VISIBILITY
	+ value_type& __get_value() { return __cc; }
	+ _LIBCPP_INLINE_VISIBILITY
	+ const value_type& __get_value() const { return __cc; }
	+
	private:
	__value_type();
	__value_type(__value_type const&);
	__value_type& operator=(__value_type const&);
	~__value_type();
	};

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp>
	struct __extract_key_value_types;

	template <class _Key, class _Tp>
	struct __extract_key_value_types<__value_type<_Key, _Tp> >
	{
	typedef _Key const __key_type;
	typedef _Tp __mapped_type;
	};

	template <class _TreeIterator>
	class _LIBCPP_TEMPLATE_VIS __map_iterator
	{
	typedef typename _TreeIterator::_NodeTypes _NodeTypes;
	typedef typename _TreeIterator::__pointer_traits __pointer_traits;

	_TreeIterator __i_;

	public:
	typedef bidirectional_iterator_tag iterator_category;
	typedef typename _NodeTypes::__map_value_type value_type;
	typedef typename _TreeIterator::difference_type difference_type;
	typedef value_type& reference;
	typedef typename _NodeTypes::__map_value_type_pointer pointer;

	_LIBCPP_INLINE_VISIBILITY
	__map_iterator() _NOEXCEPT {}

	_LIBCPP_INLINE_VISIBILITY
	__map_iterator(_TreeIterator __i) _NOEXCEPT : __i_(__i) {}

	_LIBCPP_INLINE_VISIBILITY
	- reference operator*() const {return __i_->__cc;}
	+ reference operator*() const {return __i_->__get_value();}
	_LIBCPP_INLINE_VISIBILITY
	- pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__cc);}
	+ pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__get_value());}

	_LIBCPP_INLINE_VISIBILITY
	__map_iterator& operator++() {++__i_; return *this;}
	_LIBCPP_INLINE_VISIBILITY
	__map_iterator operator++(int)
	{
	__map_iterator __t(*this);
	++(*this);
	return __t;
	}

	_LIBCPP_INLINE_VISIBILITY
	__map_iterator& operator--() {--__i_; return *this;}
	_LIBCPP_INLINE_VISIBILITY
	__map_iterator operator--(int)
	{
	__map_iterator __t(*this);
	--(*this);
	return __t;
	}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const __map_iterator& __x, const __map_iterator& __y)
	{return __x.__i_ == __y.__i_;}
	friend
	_LIBCPP_INLINE_VISIBILITY
	bool operator!=(const __map_iterator& __x, const __map_iterator& __y)
	{return __x.__i_ != __y.__i_;}

	template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
	template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
	template <class> friend class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
	};

	template <class _TreeIterator>
	class _LIBCPP_TEMPLATE_VIS __map_const_iterator
	{
	typedef typename _TreeIterator::_NodeTypes _NodeTypes;
	typedef typename _TreeIterator::__pointer_traits __pointer_traits;

	_TreeIterator __i_;

	public:
	typedef bidirectional_iterator_tag iterator_category;
	typedef typename _NodeTypes::__map_value_type value_type;
	typedef typename _TreeIterator::difference_type difference_type;
	typedef const value_type& reference;
	typedef typename _NodeTypes::__const_map_value_type_pointer pointer;

	_LIBCPP_INLINE_VISIBILITY
	__map_const_iterator() _NOEXCEPT {}

	_LIBCPP_INLINE_VISIBILITY
	__map_const_iterator(_TreeIterator __i) _NOEXCEPT : __i_(__i) {}
	_LIBCPP_INLINE_VISIBILITY
	__map_const_iterator(__map_iterator<
	typename _TreeIterator::__non_const_iterator> __i) _NOEXCEPT
	: __i_(__i.__i_) {}

	_LIBCPP_INLINE_VISIBILITY
	- reference operator*() const {return __i_->__cc;}
	+ reference operator*() const {return __i_->__get_value();}
	_LIBCPP_INLINE_VISIBILITY
	- pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__cc);}
	+ pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__get_value());}

	_LIBCPP_INLINE_VISIBILITY
	__map_const_iterator& operator++() {++__i_; return *this;}
	_LIBCPP_INLINE_VISIBILITY
	__map_const_iterator operator++(int)
	{
	__map_const_iterator __t(*this);
	++(*this);
	return __t;
	}

	_LIBCPP_INLINE_VISIBILITY
	__map_const_iterator& operator--() {--__i_; return *this;}
	_LIBCPP_INLINE_VISIBILITY
	__map_const_iterator operator--(int)
	{
	__map_const_iterator __t(*this);
	--(*this);
	return __t;
	}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const __map_const_iterator& __x, const __map_const_iterator& __y)
	{return __x.__i_ == __y.__i_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const __map_const_iterator& __x, const __map_const_iterator& __y)
	{return __x.__i_ != __y.__i_;}

	template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
	template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
	template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;
	};

	template <class _Key, class _Tp, class _Compare = less<_Key>,
	class _Allocator = allocator<pair<const _Key, _Tp> > >
	class _LIBCPP_TEMPLATE_VIS map
	{
	public:
	// types:
	typedef _Key key_type;
	typedef _Tp mapped_type;
	typedef pair<const key_type, mapped_type> value_type;
	- typedef pair<key_type, mapped_type> __nc_value_type;
	typedef _Compare key_compare;
	typedef _Allocator allocator_type;
	typedef value_type& reference;
	typedef const value_type& const_reference;

	static_assert((is_same<typename allocator_type::value_type, value_type>::value),
	"Allocator::value_type must be same type as value_type");

	class _LIBCPP_TEMPLATE_VIS value_compare
	: public binary_function<value_type, value_type, bool>
	{
	friend class map;
	protected:
	key_compare comp;

	_LIBCPP_INLINE_VISIBILITY value_compare(key_compare c) : comp(c) {}
	public:
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const value_type& __x, const value_type& __y) const
	{return comp(__x.first, __y.first);}
	};

	private:

	typedef _VSTD::__value_type<key_type, mapped_type> __value_type;
	typedef __map_value_compare<key_type, __value_type, key_compare> __vc;
	typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>,
	__value_type>::type __allocator_type;
	typedef __tree<__value_type, __vc, __allocator_type> __base;
	typedef typename __base::__node_traits __node_traits;
	typedef allocator_traits<allocator_type> __alloc_traits;

	__base __tree_;

	public:
	typedef typename __alloc_traits::pointer pointer;
	typedef typename __alloc_traits::const_pointer const_pointer;
	typedef typename __alloc_traits::size_type size_type;
	typedef typename __alloc_traits::difference_type difference_type;
	typedef __map_iterator<typename __base::iterator> iterator;
	typedef __map_const_iterator<typename __base::const_iterator> const_iterator;
	typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
	typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;

	_LIBCPP_INLINE_VISIBILITY
	map()
	_NOEXCEPT_(
	is_nothrow_default_constructible<allocator_type>::value &&
	is_nothrow_default_constructible<key_compare>::value &&
	is_nothrow_copy_constructible<key_compare>::value)
	: __tree_(__vc(key_compare())) {}

	_LIBCPP_INLINE_VISIBILITY
	explicit map(const key_compare& __comp)
	_NOEXCEPT_(
	is_nothrow_default_constructible<allocator_type>::value &&
	is_nothrow_copy_constructible<key_compare>::value)
	: __tree_(__vc(__comp)) {}

	_LIBCPP_INLINE_VISIBILITY
	explicit map(const key_compare& __comp, const allocator_type& __a)
	: __tree_(__vc(__comp), typename __base::allocator_type(__a)) {}

	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	map(_InputIterator __f, _InputIterator __l,
	const key_compare& __comp = key_compare())
	: __tree_(__vc(__comp))
	{
	insert(__f, __l);
	}

	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	map(_InputIterator __f, _InputIterator __l,
	const key_compare& __comp, const allocator_type& __a)
	: __tree_(__vc(__comp), typename __base::allocator_type(__a))
	{
	insert(__f, __l);
	}

	#if _LIBCPP_STD_VER > 11
	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	map(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
	: map(__f, __l, key_compare(), __a) {}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	map(const map& __m)
	: __tree_(__m.__tree_)
	{
	insert(__m.begin(), __m.end());
	}

	_LIBCPP_INLINE_VISIBILITY
	map& operator=(const map& __m)
	{
	#ifndef _LIBCPP_CXX03_LANG
	__tree_ = __m.__tree_;
	#else
	if (this != &__m) {
	__tree_.clear();
	__tree_.value_comp() = __m.__tree_.value_comp();
	__tree_.__copy_assign_alloc(__m.__tree_);
	insert(__m.begin(), __m.end());
	}
	#endif
	return *this;
	}

	#ifndef _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	map(map&& __m)
	_NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
	: __tree_(_VSTD::move(__m.__tree_))
	{
	}

	map(map&& __m, const allocator_type& __a);

	_LIBCPP_INLINE_VISIBILITY
	map& operator=(map&& __m)
	_NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
	{
	__tree_ = _VSTD::move(__m.__tree_);
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	map(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
	: __tree_(__vc(__comp))
	{
	insert(__il.begin(), __il.end());
	}

	_LIBCPP_INLINE_VISIBILITY
	map(initializer_list<value_type> __il, const key_compare& __comp, const allocator_type& __a)
	: __tree_(__vc(__comp), typename __base::allocator_type(__a))
	{
	insert(__il.begin(), __il.end());
	}

	#if _LIBCPP_STD_VER > 11
	_LIBCPP_INLINE_VISIBILITY
	map(initializer_list<value_type> __il, const allocator_type& __a)
	: map(__il, key_compare(), __a) {}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	map& operator=(initializer_list<value_type> __il)
	{
	__tree_.__assign_unique(__il.begin(), __il.end());
	return *this;
	}

	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	explicit map(const allocator_type& __a)
	: __tree_(typename __base::allocator_type(__a))
	{
	}

	_LIBCPP_INLINE_VISIBILITY
	map(const map& __m, const allocator_type& __a)
	: __tree_(__m.__tree_.value_comp(), typename __base::allocator_type(__a))
	{
	insert(__m.begin(), __m.end());
	}

	_LIBCPP_INLINE_VISIBILITY
	iterator begin() _NOEXCEPT {return __tree_.begin();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator begin() const _NOEXCEPT {return __tree_.begin();}
	_LIBCPP_INLINE_VISIBILITY
	iterator end() _NOEXCEPT {return __tree_.end();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator end() const _NOEXCEPT {return __tree_.end();}

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

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

	_LIBCPP_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();}
	_LIBCPP_INLINE_VISIBILITY
	size_type max_size() const _NOEXCEPT {return __tree_.max_size();}

	mapped_type& operator[](const key_type& __k);
	#ifndef _LIBCPP_CXX03_LANG
	mapped_type& operator[](key_type&& __k);
	#endif

	mapped_type& at(const key_type& __k);
	const mapped_type& at(const key_type& __k) const;

	_LIBCPP_INLINE_VISIBILITY
	allocator_type get_allocator() const _NOEXCEPT {return allocator_type(__tree_.__alloc());}
	_LIBCPP_INLINE_VISIBILITY
	key_compare key_comp() const {return __tree_.value_comp().key_comp();}
	_LIBCPP_INLINE_VISIBILITY
	value_compare value_comp() const {return value_compare(__tree_.value_comp().key_comp());}

	#ifndef _LIBCPP_CXX03_LANG
	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> emplace(_Args&& ...__args) {
	return __tree_.__emplace_unique(_VSTD::forward<_Args>(__args)...);
	}

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY
	iterator emplace_hint(const_iterator __p, _Args&& ...__args) {
	return __tree_.__emplace_hint_unique(__p.__i_, _VSTD::forward<_Args>(__args)...);
	}

	template <class _Pp,
	class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> insert(_Pp&& __p)
	{return __tree_.__insert_unique(_VSTD::forward<_Pp>(__p));}

	template <class _Pp,
	class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __pos, _Pp&& __p)
	{return __tree_.__insert_unique(__pos.__i_, _VSTD::forward<_Pp>(__p));}

	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool>
	insert(const value_type& __v) {return __tree_.__insert_unique(__v);}

	_LIBCPP_INLINE_VISIBILITY
	iterator
	insert(const_iterator __p, const value_type& __v)
	{return __tree_.__insert_unique(__p.__i_, __v);}

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool>
	insert(value_type&& __v) {return __tree_.__insert_unique(_VSTD::move(__v));}

	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __p, value_type&& __v)
	{return __tree_.__insert_unique(__p.__i_, _VSTD::move(__v));}

	_LIBCPP_INLINE_VISIBILITY
	void insert(initializer_list<value_type> __il)
	{insert(__il.begin(), __il.end());}
	#endif

	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	void insert(_InputIterator __f, _InputIterator __l)
	{
	for (const_iterator __e = cend(); __f != __l; ++__f)
	insert(__e.__i_, *__f);
	}

	#if _LIBCPP_STD_VER > 14

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args)
	{
	return __tree_.__emplace_unique_key_args(__k,
	_VSTD::piecewise_construct,
	_VSTD::forward_as_tuple(__k),
	_VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
	}

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> try_emplace(key_type&& __k, _Args&&... __args)
	{
	return __tree_.__emplace_unique_key_args(__k,
	_VSTD::piecewise_construct,
	_VSTD::forward_as_tuple(_VSTD::move(__k)),
	_VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
	}

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	iterator try_emplace(const_iterator __h, const key_type& __k, _Args&&... __args)
	{
	return __tree_.__emplace_hint_unique_key_args(__h.__i_, __k,
	_VSTD::piecewise_construct,
	_VSTD::forward_as_tuple(__k),
	_VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
	}

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	iterator try_emplace(const_iterator __h, key_type&& __k, _Args&&... __args)
	{
	return __tree_.__emplace_hint_unique_key_args(__h.__i_, __k,
	_VSTD::piecewise_construct,
	_VSTD::forward_as_tuple(_VSTD::move(__k)),
	_VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
	}

	template <class _Vp>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> insert_or_assign(const key_type& __k, _Vp&& __v)
	{
	iterator __p = lower_bound(__k);
	if ( __p != end() && !key_comp()(__k, __p->first))
	{
	__p->second = _VSTD::forward<_Vp>(__v);
	return _VSTD::make_pair(__p, false);
	}
	return _VSTD::make_pair(emplace_hint(__p, __k, _VSTD::forward<_Vp>(__v)), true);
	}

	template <class _Vp>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> insert_or_assign(key_type&& __k, _Vp&& __v)
	{
	iterator __p = lower_bound(__k);
	if ( __p != end() && !key_comp()(__k, __p->first))
	{
	__p->second = _VSTD::forward<_Vp>(__v);
	return _VSTD::make_pair(__p, false);
	}
	return _VSTD::make_pair(emplace_hint(__p, _VSTD::move(__k), _VSTD::forward<_Vp>(__v)), true);
	}

	template <class _Vp>
	_LIBCPP_INLINE_VISIBILITY
	iterator insert_or_assign(const_iterator __h, const key_type& __k, _Vp&& __v)
	{
	iterator __p = lower_bound(__k);
	if ( __p != end() && !key_comp()(__k, __p->first))
	{
	__p->second = _VSTD::forward<_Vp>(__v);
	return __p;
	}
	return emplace_hint(__h, __k, _VSTD::forward<_Vp>(__v));
	}

	template <class _Vp>
	_LIBCPP_INLINE_VISIBILITY
	iterator insert_or_assign(const_iterator __h, key_type&& __k, _Vp&& __v)
	{
	iterator __p = lower_bound(__k);
	if ( __p != end() && !key_comp()(__k, __p->first))
	{
	__p->second = _VSTD::forward<_Vp>(__v);
	return __p;
	}
	return emplace_hint(__h, _VSTD::move(__k), _VSTD::forward<_Vp>(__v));
	}

	#endif // _LIBCPP_STD_VER > 14

	_LIBCPP_INLINE_VISIBILITY
	iterator erase(const_iterator __p) {return __tree_.erase(__p.__i_);}
	_LIBCPP_INLINE_VISIBILITY
	iterator erase(iterator __p) {return __tree_.erase(__p.__i_);}
	_LIBCPP_INLINE_VISIBILITY
	size_type erase(const key_type& __k)
	{return __tree_.__erase_unique(__k);}
	_LIBCPP_INLINE_VISIBILITY
	iterator erase(const_iterator __f, const_iterator __l)
	{return __tree_.erase(__f.__i_, __l.__i_);}
	_LIBCPP_INLINE_VISIBILITY
	void clear() _NOEXCEPT {__tree_.clear();}

	_LIBCPP_INLINE_VISIBILITY
	void swap(map& __m)
	_NOEXCEPT_(__is_nothrow_swappable<__base>::value)
	{__tree_.swap(__m.__tree_);}

	_LIBCPP_INLINE_VISIBILITY
	iterator find(const key_type& __k) {return __tree_.find(__k);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
	find(const _K2& __k) {return __tree_.find(__k);}
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
	find(const _K2& __k) const {return __tree_.find(__k);}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	size_type count(const key_type& __k) const
	{return __tree_.__count_unique(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
	- count(const _K2& __k) const {return __tree_.__count_unique(__k);}
	+ count(const _K2& __k) const {return __tree_.__count_multi(__k);}
	#endif
	_LIBCPP_INLINE_VISIBILITY
	iterator lower_bound(const key_type& __k)
	{return __tree_.lower_bound(__k);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator lower_bound(const key_type& __k) const
	{return __tree_.lower_bound(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
	lower_bound(const _K2& __k) {return __tree_.lower_bound(__k);}

	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
	lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	iterator upper_bound(const key_type& __k)
	{return __tree_.upper_bound(__k);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator upper_bound(const key_type& __k) const
	{return __tree_.upper_bound(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
	upper_bound(const _K2& __k) {return __tree_.upper_bound(__k);}
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
	upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	pair<iterator,iterator> equal_range(const key_type& __k)
	{return __tree_.__equal_range_unique(__k);}
	_LIBCPP_INLINE_VISIBILITY
	pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
	{return __tree_.__equal_range_unique(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
	- equal_range(const _K2& __k) {return __tree_.__equal_range_unique(__k);}
	+ equal_range(const _K2& __k) {return __tree_.__equal_range_multi(__k);}
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
	- equal_range(const _K2& __k) const {return __tree_.__equal_range_unique(__k);}
	+ equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
	#endif

	private:
	typedef typename __base::__node __node;
	typedef typename __base::__node_allocator __node_allocator;
	typedef typename __base::__node_pointer __node_pointer;
	typedef typename __base::__node_base_pointer __node_base_pointer;
	typedef typename __base::__parent_pointer __parent_pointer;

	typedef __map_node_destructor<__node_allocator> _Dp;
	typedef unique_ptr<__node, _Dp> __node_holder;

	#ifdef _LIBCPP_CXX03_LANG
	__node_holder __construct_node_with_key(const key_type& __k);
	#endif
	};


	#ifndef _LIBCPP_CXX03_LANG
	template <class _Key, class _Tp, class _Compare, class _Allocator>
	map<_Key, _Tp, _Compare, _Allocator>::map(map&& __m, const allocator_type& __a)
	: __tree_(_VSTD::move(__m.__tree_), typename __base::allocator_type(__a))
	{
	if (__a != __m.get_allocator())
	{
	const_iterator __e = cend();
	while (!__m.empty())
	__tree_.__insert_unique(__e.__i_,
	- _VSTD::move(__m.__tree_.remove(__m.begin().__i_)->__value_.__nc));
	+ __m.__tree_.remove(__m.begin().__i_)->__value_.__move());
	}
	}

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	_Tp&
	map<_Key, _Tp, _Compare, _Allocator>::operator[](const key_type& __k)
	{
	return __tree_.__emplace_unique_key_args(__k,
	_VSTD::piecewise_construct,
	_VSTD::forward_as_tuple(__k),
	- _VSTD::forward_as_tuple()).first->__cc.second;
	+ _VSTD::forward_as_tuple()).first->__get_value().second;
	}

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	_Tp&
	map<_Key, _Tp, _Compare, _Allocator>::operator[](key_type&& __k)
	{
	return __tree_.__emplace_unique_key_args(__k,
	_VSTD::piecewise_construct,
	_VSTD::forward_as_tuple(_VSTD::move(__k)),
	- _VSTD::forward_as_tuple()).first->__cc.second;
	+ _VSTD::forward_as_tuple()).first->__get_value().second;
	}

	#else // _LIBCPP_CXX03_LANG

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder
	map<_Key, _Tp, _Compare, _Allocator>::__construct_node_with_key(const key_type& __k)
	{
	__node_allocator& __na = __tree_.__node_alloc();
	__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
	- __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.first), __k);
	+ __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().first), __k);
	__h.get_deleter().__first_constructed = true;
	- __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.second));
	+ __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().second));
	__h.get_deleter().__second_constructed = true;
	return _LIBCPP_EXPLICIT_MOVE(__h); // explicitly moved for C++03
	}

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	_Tp&
	map<_Key, _Tp, _Compare, _Allocator>::operator[](const key_type& __k)
	{
	__parent_pointer __parent;
	__node_base_pointer& __child = __tree_.__find_equal(__parent, __k);
	__node_pointer __r = static_cast<__node_pointer>(__child);
	if (__child == nullptr)
	{
	__node_holder __h = __construct_node_with_key(__k);
	__tree_.__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
	__r = __h.release();
	}
	- return __r->__value_.__cc.second;
	+ return __r->__value_.__get_value().second;
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	_Tp&
	map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k)
	{
	__parent_pointer __parent;
	__node_base_pointer& __child = __tree_.__find_equal(__parent, __k);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	if (__child == nullptr)
	throw out_of_range("map::at: key not found");
	#endif // _LIBCPP_NO_EXCEPTIONS
	- return static_cast<__node_pointer>(__child)->__value_.__cc.second;
	+ return static_cast<__node_pointer>(__child)->__value_.__get_value().second;
	}

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	const _Tp&
	map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k) const
	{
	__parent_pointer __parent;
	__node_base_pointer __child = __tree_.__find_equal(__parent, __k);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	if (__child == nullptr)
	throw out_of_range("map::at: key not found");
	#endif // _LIBCPP_NO_EXCEPTIONS
	- return static_cast<__node_pointer>(__child)->__value_.__cc.second;
	+ return static_cast<__node_pointer>(__child)->__value_.__get_value().second;
	}


	template <class _Key, class _Tp, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const map<_Key, _Tp, _Compare, _Allocator>& __x,
	const map<_Key, _Tp, _Compare, _Allocator>& __y)
	{
	return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
	}

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator< (const map<_Key, _Tp, _Compare, _Allocator>& __x,
	const map<_Key, _Tp, _Compare, _Allocator>& __y)
	{
	return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
	}

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const map<_Key, _Tp, _Compare, _Allocator>& __x,
	const map<_Key, _Tp, _Compare, _Allocator>& __y)
	{
	return !(__x == __y);
	}

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator> (const map<_Key, _Tp, _Compare, _Allocator>& __x,
	const map<_Key, _Tp, _Compare, _Allocator>& __y)
	{
	return __y < __x;
	}

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const map<_Key, _Tp, _Compare, _Allocator>& __x,
	const map<_Key, _Tp, _Compare, _Allocator>& __y)
	{
	return !(__x < __y);
	}

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const map<_Key, _Tp, _Compare, _Allocator>& __x,
	const map<_Key, _Tp, _Compare, _Allocator>& __y)
	{
	return !(__y < __x);
	}

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

	template <class _Key, class _Tp, class _Compare = less<_Key>,
	class _Allocator = allocator<pair<const _Key, _Tp> > >
	class _LIBCPP_TEMPLATE_VIS multimap
	{
	public:
	// types:
	typedef _Key key_type;
	typedef _Tp mapped_type;
	typedef pair<const key_type, mapped_type> value_type;
	- typedef pair<key_type, mapped_type> __nc_value_type;
	typedef _Compare key_compare;
	typedef _Allocator allocator_type;
	typedef value_type& reference;
	typedef const value_type& const_reference;

	static_assert((is_same<typename allocator_type::value_type, value_type>::value),
	"Allocator::value_type must be same type as value_type");

	class _LIBCPP_TEMPLATE_VIS value_compare
	: public binary_function<value_type, value_type, bool>
	{
	friend class multimap;
	protected:
	key_compare comp;

	_LIBCPP_INLINE_VISIBILITY
	value_compare(key_compare c) : comp(c) {}
	public:
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const value_type& __x, const value_type& __y) const
	{return comp(__x.first, __y.first);}
	};

	private:

	typedef _VSTD::__value_type<key_type, mapped_type> __value_type;
	typedef __map_value_compare<key_type, __value_type, key_compare> __vc;
	typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>,
	__value_type>::type __allocator_type;
	typedef __tree<__value_type, __vc, __allocator_type> __base;
	typedef typename __base::__node_traits __node_traits;
	typedef allocator_traits<allocator_type> __alloc_traits;

	__base __tree_;

	public:
	typedef typename __alloc_traits::pointer pointer;
	typedef typename __alloc_traits::const_pointer const_pointer;
	typedef typename __alloc_traits::size_type size_type;
	typedef typename __alloc_traits::difference_type difference_type;
	typedef __map_iterator<typename __base::iterator> iterator;
	typedef __map_const_iterator<typename __base::const_iterator> const_iterator;
	typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
	typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;

	_LIBCPP_INLINE_VISIBILITY
	multimap()
	_NOEXCEPT_(
	is_nothrow_default_constructible<allocator_type>::value &&
	is_nothrow_default_constructible<key_compare>::value &&
	is_nothrow_copy_constructible<key_compare>::value)
	: __tree_(__vc(key_compare())) {}

	_LIBCPP_INLINE_VISIBILITY
	explicit multimap(const key_compare& __comp)
	_NOEXCEPT_(
	is_nothrow_default_constructible<allocator_type>::value &&
	is_nothrow_copy_constructible<key_compare>::value)
	: __tree_(__vc(__comp)) {}

	_LIBCPP_INLINE_VISIBILITY
	explicit multimap(const key_compare& __comp, const allocator_type& __a)
	: __tree_(__vc(__comp), typename __base::allocator_type(__a)) {}

	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	multimap(_InputIterator __f, _InputIterator __l,
	const key_compare& __comp = key_compare())
	: __tree_(__vc(__comp))
	{
	insert(__f, __l);
	}

	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	multimap(_InputIterator __f, _InputIterator __l,
	const key_compare& __comp, const allocator_type& __a)
	: __tree_(__vc(__comp), typename __base::allocator_type(__a))
	{
	insert(__f, __l);
	}

	#if _LIBCPP_STD_VER > 11
	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	multimap(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
	: multimap(__f, __l, key_compare(), __a) {}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	multimap(const multimap& __m)
	: __tree_(__m.__tree_.value_comp(),
	__alloc_traits::select_on_container_copy_construction(__m.__tree_.__alloc()))
	{
	insert(__m.begin(), __m.end());
	}

	_LIBCPP_INLINE_VISIBILITY
	multimap& operator=(const multimap& __m)
	{
	#ifndef _LIBCPP_CXX03_LANG
	__tree_ = __m.__tree_;
	#else
	if (this != &__m) {
	__tree_.clear();
	__tree_.value_comp() = __m.__tree_.value_comp();
	__tree_.__copy_assign_alloc(__m.__tree_);
	insert(__m.begin(), __m.end());
	}
	#endif
	return *this;
	}

	#ifndef _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	multimap(multimap&& __m)
	_NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
	: __tree_(_VSTD::move(__m.__tree_))
	{
	}

	multimap(multimap&& __m, const allocator_type& __a);

	_LIBCPP_INLINE_VISIBILITY
	multimap& operator=(multimap&& __m)
	_NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
	{
	__tree_ = _VSTD::move(__m.__tree_);
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	multimap(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
	: __tree_(__vc(__comp))
	{
	insert(__il.begin(), __il.end());
	}

	_LIBCPP_INLINE_VISIBILITY
	multimap(initializer_list<value_type> __il, const key_compare& __comp, const allocator_type& __a)
	: __tree_(__vc(__comp), typename __base::allocator_type(__a))
	{
	insert(__il.begin(), __il.end());
	}

	#if _LIBCPP_STD_VER > 11
	_LIBCPP_INLINE_VISIBILITY
	multimap(initializer_list<value_type> __il, const allocator_type& __a)
	: multimap(__il, key_compare(), __a) {}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	multimap& operator=(initializer_list<value_type> __il)
	{
	__tree_.__assign_multi(__il.begin(), __il.end());
	return *this;
	}

	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	explicit multimap(const allocator_type& __a)
	: __tree_(typename __base::allocator_type(__a))
	{
	}

	_LIBCPP_INLINE_VISIBILITY
	multimap(const multimap& __m, const allocator_type& __a)
	: __tree_(__m.__tree_.value_comp(), typename __base::allocator_type(__a))
	{
	insert(__m.begin(), __m.end());
	}

	_LIBCPP_INLINE_VISIBILITY
	iterator begin() _NOEXCEPT {return __tree_.begin();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator begin() const _NOEXCEPT {return __tree_.begin();}
	_LIBCPP_INLINE_VISIBILITY
	iterator end() _NOEXCEPT {return __tree_.end();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator end() const _NOEXCEPT {return __tree_.end();}

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

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

	_LIBCPP_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();}
	_LIBCPP_INLINE_VISIBILITY
	size_type max_size() const _NOEXCEPT {return __tree_.max_size();}

	_LIBCPP_INLINE_VISIBILITY
	allocator_type get_allocator() const _NOEXCEPT {return allocator_type(__tree_.__alloc());}
	_LIBCPP_INLINE_VISIBILITY
	key_compare key_comp() const {return __tree_.value_comp().key_comp();}
	_LIBCPP_INLINE_VISIBILITY
	value_compare value_comp() const
	{return value_compare(__tree_.value_comp().key_comp());}

	#ifndef _LIBCPP_CXX03_LANG

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY
	iterator emplace(_Args&& ...__args) {
	return __tree_.__emplace_multi(_VSTD::forward<_Args>(__args)...);
	}

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY
	iterator emplace_hint(const_iterator __p, _Args&& ...__args) {
	return __tree_.__emplace_hint_multi(__p.__i_, _VSTD::forward<_Args>(__args)...);
	}

	template <class _Pp,
	class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
	_LIBCPP_INLINE_VISIBILITY
	iterator insert(_Pp&& __p)
	{return __tree_.__insert_multi(_VSTD::forward<_Pp>(__p));}

	template <class _Pp,
	class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __pos, _Pp&& __p)
	{return __tree_.__insert_multi(__pos.__i_, _VSTD::forward<_Pp>(__p));}

	_LIBCPP_INLINE_VISIBILITY
	iterator insert(value_type&& __v)
	{return __tree_.__insert_multi(_VSTD::move(__v));}

	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __p, value_type&& __v)
	{return __tree_.__insert_multi(__p.__i_, _VSTD::move(__v));}


	_LIBCPP_INLINE_VISIBILITY
	void insert(initializer_list<value_type> __il)
	{insert(__il.begin(), __il.end());}

	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const value_type& __v) {return __tree_.__insert_multi(__v);}

	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __p, const value_type& __v)
	{return __tree_.__insert_multi(__p.__i_, __v);}

	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	void insert(_InputIterator __f, _InputIterator __l)
	{
	for (const_iterator __e = cend(); __f != __l; ++__f)
	__tree_.__insert_multi(__e.__i_, *__f);
	}

	_LIBCPP_INLINE_VISIBILITY
	iterator erase(const_iterator __p) {return __tree_.erase(__p.__i_);}
	_LIBCPP_INLINE_VISIBILITY
	iterator erase(iterator __p) {return __tree_.erase(__p.__i_);}
	_LIBCPP_INLINE_VISIBILITY
	size_type erase(const key_type& __k) {return __tree_.__erase_multi(__k);}
	_LIBCPP_INLINE_VISIBILITY
	iterator erase(const_iterator __f, const_iterator __l)
	{return __tree_.erase(__f.__i_, __l.__i_);}
	_LIBCPP_INLINE_VISIBILITY
	void clear() {__tree_.clear();}

	_LIBCPP_INLINE_VISIBILITY
	void swap(multimap& __m)
	_NOEXCEPT_(__is_nothrow_swappable<__base>::value)
	{__tree_.swap(__m.__tree_);}

	_LIBCPP_INLINE_VISIBILITY
	iterator find(const key_type& __k) {return __tree_.find(__k);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
	find(const _K2& __k) {return __tree_.find(__k);}
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
	find(const _K2& __k) const {return __tree_.find(__k);}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	size_type count(const key_type& __k) const
	{return __tree_.__count_multi(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
	count(const _K2& __k) const {return __tree_.__count_multi(__k);}
	#endif
	_LIBCPP_INLINE_VISIBILITY
	iterator lower_bound(const key_type& __k)
	{return __tree_.lower_bound(__k);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator lower_bound(const key_type& __k) const
	{return __tree_.lower_bound(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
	lower_bound(const _K2& __k) {return __tree_.lower_bound(__k);}

	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
	lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	iterator upper_bound(const key_type& __k)
	{return __tree_.upper_bound(__k);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator upper_bound(const key_type& __k) const
	{return __tree_.upper_bound(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
	upper_bound(const _K2& __k) {return __tree_.upper_bound(__k);}
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
	upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	pair<iterator,iterator> equal_range(const key_type& __k)
	{return __tree_.__equal_range_multi(__k);}
	_LIBCPP_INLINE_VISIBILITY
	pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
	{return __tree_.__equal_range_multi(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
	equal_range(const _K2& __k) {return __tree_.__equal_range_multi(__k);}
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
	equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
	#endif

	private:
	typedef typename __base::__node __node;
	typedef typename __base::__node_allocator __node_allocator;
	typedef typename __base::__node_pointer __node_pointer;

	typedef __map_node_destructor<__node_allocator> _Dp;
	typedef unique_ptr<__node, _Dp> __node_holder;
	};

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Key, class _Tp, class _Compare, class _Allocator>
	multimap<_Key, _Tp, _Compare, _Allocator>::multimap(multimap&& __m, const allocator_type& __a)
	: __tree_(_VSTD::move(__m.__tree_), typename __base::allocator_type(__a))
	{
	if (__a != __m.get_allocator())
	{
	const_iterator __e = cend();
	while (!__m.empty())
	__tree_.__insert_multi(__e.__i_,
	- _VSTD::move(__m.__tree_.remove(__m.begin().__i_)->__value_.__nc));
	+ _VSTD::move(__m.__tree_.remove(__m.begin().__i_)->__value_.__move()));
	}
	}
	#endif

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
	const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
	{
	return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
	}

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator< (const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
	const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
	{
	return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
	}

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
	const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
	{
	return !(__x == __y);
	}

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator> (const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
	const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
	{
	return __y < __x;
	}

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
	const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
	{
	return !(__x < __y);
	}

	template <class _Key, class _Tp, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
	const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
	{
	return !(__y < __x);
	}

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

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_MAP
	Index: projects/clang700-import/contrib/libc++/include/math.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/math.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/math.h (revision 337135)
	@@ -1,1489 +1,1531 @@
	// -- C++ --
	//===---------------------------- math.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_MATH_H
	#define _LIBCPP_MATH_H

	/*
	math.h synopsis

	Macros:

	HUGE_VAL
	HUGE_VALF // C99
	HUGE_VALL // C99
	INFINITY // C99
	NAN // C99
	FP_INFINITE // C99
	FP_NAN // C99
	FP_NORMAL // C99
	FP_SUBNORMAL // C99
	FP_ZERO // C99
	FP_FAST_FMA // C99
	FP_FAST_FMAF // C99
	FP_FAST_FMAL // C99
	FP_ILOGB0 // C99
	FP_ILOGBNAN // C99
	MATH_ERRNO // C99
	MATH_ERREXCEPT // C99
	math_errhandling // C99

	Types:

	float_t // C99
	double_t // C99

	// C90

	floating_point abs(floating_point x);

	floating_point acos (arithmetic x);
	float acosf(float x);
	long double acosl(long double x);

	floating_point asin (arithmetic x);
	float asinf(float x);
	long double asinl(long double x);

	floating_point atan (arithmetic x);
	float atanf(float x);
	long double atanl(long double x);

	floating_point atan2 (arithmetic y, arithmetic x);
	float atan2f(float y, float x);
	long double atan2l(long double y, long double x);

	floating_point ceil (arithmetic x);
	float ceilf(float x);
	long double ceill(long double x);

	floating_point cos (arithmetic x);
	float cosf(float x);
	long double cosl(long double x);

	floating_point cosh (arithmetic x);
	float coshf(float x);
	long double coshl(long double x);

	floating_point exp (arithmetic x);
	float expf(float x);
	long double expl(long double x);

	floating_point fabs (arithmetic x);
	float fabsf(float x);
	long double fabsl(long double x);

	floating_point floor (arithmetic x);
	float floorf(float x);
	long double floorl(long double x);

	floating_point fmod (arithmetic x, arithmetic y);
	float fmodf(float x, float y);
	long double fmodl(long double x, long double y);

	floating_point frexp (arithmetic value, int* exp);
	float frexpf(float value, int* exp);
	long double frexpl(long double value, int* exp);

	floating_point ldexp (arithmetic value, int exp);
	float ldexpf(float value, int exp);
	long double ldexpl(long double value, int exp);

	floating_point log (arithmetic x);
	float logf(float x);
	long double logl(long double x);

	floating_point log10 (arithmetic x);
	float log10f(float x);
	long double log10l(long double x);

	floating_point modf (floating_point value, floating_point* iptr);
	float modff(float value, float* iptr);
	long double modfl(long double value, long double* iptr);

	floating_point pow (arithmetic x, arithmetic y);
	float powf(float x, float y);
	long double powl(long double x, long double y);

	floating_point sin (arithmetic x);
	float sinf(float x);
	long double sinl(long double x);

	floating_point sinh (arithmetic x);
	float sinhf(float x);
	long double sinhl(long double x);

	floating_point sqrt (arithmetic x);
	float sqrtf(float x);
	long double sqrtl(long double x);

	floating_point tan (arithmetic x);
	float tanf(float x);
	long double tanl(long double x);

	floating_point tanh (arithmetic x);
	float tanhf(float x);
	long double tanhl(long double x);

	// C99

	bool signbit(arithmetic x);

	int fpclassify(arithmetic x);

	bool isfinite(arithmetic x);
	bool isinf(arithmetic x);
	bool isnan(arithmetic x);
	bool isnormal(arithmetic x);

	bool isgreater(arithmetic x, arithmetic y);
	bool isgreaterequal(arithmetic x, arithmetic y);
	bool isless(arithmetic x, arithmetic y);
	bool islessequal(arithmetic x, arithmetic y);
	bool islessgreater(arithmetic x, arithmetic y);
	bool isunordered(arithmetic x, arithmetic y);

	floating_point acosh (arithmetic x);
	float acoshf(float x);
	long double acoshl(long double x);

	floating_point asinh (arithmetic x);
	float asinhf(float x);
	long double asinhl(long double x);

	floating_point atanh (arithmetic x);
	float atanhf(float x);
	long double atanhl(long double x);

	floating_point cbrt (arithmetic x);
	float cbrtf(float x);
	long double cbrtl(long double x);

	floating_point copysign (arithmetic x, arithmetic y);
	float copysignf(float x, float y);
	long double copysignl(long double x, long double y);

	floating_point erf (arithmetic x);
	float erff(float x);
	long double erfl(long double x);

	floating_point erfc (arithmetic x);
	float erfcf(float x);
	long double erfcl(long double x);

	floating_point exp2 (arithmetic x);
	float exp2f(float x);
	long double exp2l(long double x);

	floating_point expm1 (arithmetic x);
	float expm1f(float x);
	long double expm1l(long double x);

	floating_point fdim (arithmetic x, arithmetic y);
	float fdimf(float x, float y);
	long double fdiml(long double x, long double y);

	floating_point fma (arithmetic x, arithmetic y, arithmetic z);
	float fmaf(float x, float y, float z);
	long double fmal(long double x, long double y, long double z);

	floating_point fmax (arithmetic x, arithmetic y);
	float fmaxf(float x, float y);
	long double fmaxl(long double x, long double y);

	floating_point fmin (arithmetic x, arithmetic y);
	float fminf(float x, float y);
	long double fminl(long double x, long double y);

	floating_point hypot (arithmetic x, arithmetic y);
	float hypotf(float x, float y);
	long double hypotl(long double x, long double y);

	int ilogb (arithmetic x);
	int ilogbf(float x);
	int ilogbl(long double x);

	floating_point lgamma (arithmetic x);
	float lgammaf(float x);
	long double lgammal(long double x);

	long long llrint (arithmetic x);
	long long llrintf(float x);
	long long llrintl(long double x);

	long long llround (arithmetic x);
	long long llroundf(float x);
	long long llroundl(long double x);

	floating_point log1p (arithmetic x);
	float log1pf(float x);
	long double log1pl(long double x);

	floating_point log2 (arithmetic x);
	float log2f(float x);
	long double log2l(long double x);

	floating_point logb (arithmetic x);
	float logbf(float x);
	long double logbl(long double x);

	long lrint (arithmetic x);
	long lrintf(float x);
	long lrintl(long double x);

	long lround (arithmetic x);
	long lroundf(float x);
	long lroundl(long double x);

	double nan (const char* str);
	float nanf(const char* str);
	long double nanl(const char* str);

	floating_point nearbyint (arithmetic x);
	float nearbyintf(float x);
	long double nearbyintl(long double x);

	floating_point nextafter (arithmetic x, arithmetic y);
	float nextafterf(float x, float y);
	long double nextafterl(long double x, long double y);

	floating_point nexttoward (arithmetic x, long double y);
	float nexttowardf(float x, long double y);
	long double nexttowardl(long double x, long double y);

	floating_point remainder (arithmetic x, arithmetic y);
	float remainderf(float x, float y);
	long double remainderl(long double x, long double y);

	floating_point remquo (arithmetic x, arithmetic y, int* pquo);
	float remquof(float x, float y, int* pquo);
	long double remquol(long double x, long double y, int* pquo);

	floating_point rint (arithmetic x);
	float rintf(float x);
	long double rintl(long double x);

	floating_point round (arithmetic x);
	float roundf(float x);
	long double roundl(long double x);

	floating_point scalbln (arithmetic x, long ex);
	float scalblnf(float x, long ex);
	long double scalblnl(long double x, long ex);

	floating_point scalbn (arithmetic x, int ex);
	float scalbnf(float x, int ex);
	long double scalbnl(long double x, int ex);

	floating_point tgamma (arithmetic x);
	float tgammaf(float x);
	long double tgammal(long double x);

	floating_point trunc (arithmetic x);
	float truncf(float x);
	long double truncl(long double x);

	*/

	#include <__config>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	#include_next <math.h>

	#ifdef __cplusplus

	// We support including .h headers inside 'extern "C"' contexts, so switch
	// back to C++ linkage before including these C++ headers.
	extern "C++" {

	#include <type_traits>
	#include <limits>

	// signbit

	#ifdef signbit

	template <class _A1>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	bool
	__libcpp_signbit(_A1 __lcpp_x) _NOEXCEPT
	{
	return signbit(__lcpp_x);
	}

	#undef signbit

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
	signbit(_A1 __lcpp_x) _NOEXCEPT
	{
	return __libcpp_signbit((typename std::__promote<_A1>::type)__lcpp_x);
	}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<
	std::is_integral<_A1>::value && std::is_signed<_A1>::value, bool>::type
	signbit(_A1 __lcpp_x) _NOEXCEPT
	{ return __lcpp_x < 0; }

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<
	std::is_integral<_A1>::value && !std::is_signed<_A1>::value, bool>::type
	signbit(_A1) _NOEXCEPT
	{ return false; }

	#elif defined(_LIBCPP_MSVCRT)

	template <typename _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
	signbit(_A1 __lcpp_x) _NOEXCEPT
	{
	return ::signbit(static_cast<typename std::__promote<_A1>::type>(__lcpp_x));
	}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<
	std::is_integral<_A1>::value && std::is_signed<_A1>::value, bool>::type
	signbit(_A1 __lcpp_x) _NOEXCEPT
	{ return __lcpp_x < 0; }

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<
	std::is_integral<_A1>::value && !std::is_signed<_A1>::value, bool>::type
	signbit(_A1) _NOEXCEPT
	{ return false; }

	#endif // signbit

	// fpclassify

	#ifdef fpclassify

	template <class _A1>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	int
	__libcpp_fpclassify(_A1 __lcpp_x) _NOEXCEPT
	{
	return fpclassify(__lcpp_x);
	}

	#undef fpclassify

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_floating_point<_A1>::value, int>::type
	fpclassify(_A1 __lcpp_x) _NOEXCEPT
	{
	return __libcpp_fpclassify((typename std::__promote<_A1>::type)__lcpp_x);
	}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, int>::type
	fpclassify(_A1 __lcpp_x) _NOEXCEPT
	{ return __lcpp_x == 0 ? FP_ZERO : FP_NORMAL; }

	#elif defined(_LIBCPP_MSVCRT)

	template <typename _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
	fpclassify(_A1 __lcpp_x) _NOEXCEPT
	{
	return ::fpclassify(static_cast<typename std::__promote<_A1>::type>(__lcpp_x));
	}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, int>::type
	fpclassify(_A1 __lcpp_x) _NOEXCEPT
	{ return __lcpp_x == 0 ? FP_ZERO : FP_NORMAL; }

	#endif // fpclassify

	// isfinite

	#ifdef isfinite

	template <class _A1>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	bool
	__libcpp_isfinite(_A1 __lcpp_x) _NOEXCEPT
	{
	return isfinite(__lcpp_x);
	}

	#undef isfinite

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<
	std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity,
	bool>::type
	isfinite(_A1 __lcpp_x) _NOEXCEPT
	{
	return __libcpp_isfinite((typename std::__promote<_A1>::type)__lcpp_x);
	}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<
	std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity,
	bool>::type
	isfinite(_A1) _NOEXCEPT
	{ return true; }

	#endif // isfinite

	// isinf

	#ifdef isinf

	template <class _A1>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	bool
	__libcpp_isinf(_A1 __lcpp_x) _NOEXCEPT
	{
	return isinf(__lcpp_x);
	}

	#undef isinf

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<
	std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity,
	bool>::type
	isinf(_A1 __lcpp_x) _NOEXCEPT
	{
	return __libcpp_isinf((typename std::__promote<_A1>::type)__lcpp_x);
	}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<
	std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity,
	bool>::type
	isinf(_A1) _NOEXCEPT
	{ return false; }

	+#ifdef _LIBCPP_PREFERRED_OVERLOAD
	+inline _LIBCPP_INLINE_VISIBILITY
	+bool
	+isinf(float __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); }
	+
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
	+bool
	+isinf(double __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); }
	+
	+inline _LIBCPP_INLINE_VISIBILITY
	+bool
	+isinf(long double __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); }
	+#endif
	+
	#endif // isinf

	// isnan

	#ifdef isnan

	template <class _A1>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	bool
	__libcpp_isnan(_A1 __lcpp_x) _NOEXCEPT
	{
	return isnan(__lcpp_x);
	}

	#undef isnan

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
	isnan(_A1 __lcpp_x) _NOEXCEPT
	{
	return __libcpp_isnan((typename std::__promote<_A1>::type)__lcpp_x);
	}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, bool>::type
	isnan(_A1) _NOEXCEPT
	{ return false; }

	+#ifdef _LIBCPP_PREFERRED_OVERLOAD
	+inline _LIBCPP_INLINE_VISIBILITY
	+bool
	+isnan(float __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); }
	+
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
	+bool
	+isnan(double __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); }
	+
	+inline _LIBCPP_INLINE_VISIBILITY
	+bool
	+isnan(long double __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); }
	+#endif
	+
	#endif // isnan

	// isnormal

	#ifdef isnormal

	template <class _A1>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	bool
	__libcpp_isnormal(_A1 __lcpp_x) _NOEXCEPT
	{
	return isnormal(__lcpp_x);
	}

	#undef isnormal

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
	isnormal(_A1 __lcpp_x) _NOEXCEPT
	{
	return __libcpp_isnormal((typename std::__promote<_A1>::type)__lcpp_x);
	}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, bool>::type
	isnormal(_A1 __lcpp_x) _NOEXCEPT
	{ return __lcpp_x != 0; }

	#endif // isnormal

	// isgreater

	#ifdef isgreater

	template <class _A1, class _A2>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	bool
	__libcpp_isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	return isgreater(__lcpp_x, __lcpp_y);
	}

	#undef isgreater

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	bool
	>::type
	isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type type;
	return __libcpp_isgreater((type)__lcpp_x, (type)__lcpp_y);
	}

	#endif // isgreater

	// isgreaterequal

	#ifdef isgreaterequal

	template <class _A1, class _A2>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	bool
	__libcpp_isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	return isgreaterequal(__lcpp_x, __lcpp_y);
	}

	#undef isgreaterequal

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	bool
	>::type
	isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type type;
	return __libcpp_isgreaterequal((type)__lcpp_x, (type)__lcpp_y);
	}

	#endif // isgreaterequal

	// isless

	#ifdef isless

	template <class _A1, class _A2>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	bool
	__libcpp_isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	return isless(__lcpp_x, __lcpp_y);
	}

	#undef isless

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	bool
	>::type
	isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type type;
	return __libcpp_isless((type)__lcpp_x, (type)__lcpp_y);
	}

	#endif // isless

	// islessequal

	#ifdef islessequal

	template <class _A1, class _A2>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	bool
	__libcpp_islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	return islessequal(__lcpp_x, __lcpp_y);
	}

	#undef islessequal

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	bool
	>::type
	islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type type;
	return __libcpp_islessequal((type)__lcpp_x, (type)__lcpp_y);
	}

	#endif // islessequal

	// islessgreater

	#ifdef islessgreater

	template <class _A1, class _A2>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	bool
	__libcpp_islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	return islessgreater(__lcpp_x, __lcpp_y);
	}

	#undef islessgreater

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	bool
	>::type
	islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type type;
	return __libcpp_islessgreater((type)__lcpp_x, (type)__lcpp_y);
	}

	#endif // islessgreater

	// isunordered

	#ifdef isunordered

	template <class _A1, class _A2>
	-_LIBCPP_ALWAYS_INLINE
	+_LIBCPP_INLINE_VISIBILITY
	bool
	__libcpp_isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	return isunordered(__lcpp_x, __lcpp_y);
	}

	#undef isunordered

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	bool
	>::type
	isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type type;
	return __libcpp_isunordered((type)__lcpp_x, (type)__lcpp_y);
	}

	#endif // isunordered

	// abs

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY
	float
	abs(float __lcpp_x) _NOEXCEPT {return ::fabsf(__lcpp_x);}

	inline _LIBCPP_INLINE_VISIBILITY
	double
	abs(double __lcpp_x) _NOEXCEPT {return ::fabs(__lcpp_x);}

	inline _LIBCPP_INLINE_VISIBILITY
	long double
	abs(long double __lcpp_x) _NOEXCEPT {return ::fabsl(__lcpp_x);}
	#endif // !(defined(_AIX) \|\| defined(__sun__))

	// acos

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float acos(float __lcpp_x) _NOEXCEPT {return ::acosf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __lcpp_x) _NOEXCEPT {return ::acosl(__lcpp_x);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	acos(_A1 __lcpp_x) _NOEXCEPT {return ::acos((double)__lcpp_x);}

	// asin

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float asin(float __lcpp_x) _NOEXCEPT {return ::asinf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double asin(long double __lcpp_x) _NOEXCEPT {return ::asinl(__lcpp_x);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	asin(_A1 __lcpp_x) _NOEXCEPT {return ::asin((double)__lcpp_x);}

	// atan

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float atan(float __lcpp_x) _NOEXCEPT {return ::atanf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double atan(long double __lcpp_x) _NOEXCEPT {return ::atanl(__lcpp_x);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	atan(_A1 __lcpp_x) _NOEXCEPT {return ::atan((double)__lcpp_x);}

	// atan2

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float atan2(float __lcpp_y, float __lcpp_x) _NOEXCEPT {return ::atan2f(__lcpp_y, __lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double atan2(long double __lcpp_y, long double __lcpp_x) _NOEXCEPT {return ::atan2l(__lcpp_y, __lcpp_x);}
	#endif

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::__lazy_enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	std::__promote<_A1, _A2>
	>::type
	atan2(_A1 __lcpp_y, _A2 __lcpp_x) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type __result_type;
	static_assert((!(std::is_same<_A1, __result_type>::value &&
	std::is_same<_A2, __result_type>::value)), "");
	return ::atan2((__result_type)__lcpp_y, (__result_type)__lcpp_x);
	}

	// ceil

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float ceil(float __lcpp_x) _NOEXCEPT {return ::ceilf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double ceil(long double __lcpp_x) _NOEXCEPT {return ::ceill(__lcpp_x);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	ceil(_A1 __lcpp_x) _NOEXCEPT {return ::ceil((double)__lcpp_x);}

	// cos

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float cos(float __lcpp_x) _NOEXCEPT {return ::cosf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double cos(long double __lcpp_x) _NOEXCEPT {return ::cosl(__lcpp_x);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	cos(_A1 __lcpp_x) _NOEXCEPT {return ::cos((double)__lcpp_x);}

	// cosh

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float cosh(float __lcpp_x) _NOEXCEPT {return ::coshf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double cosh(long double __lcpp_x) _NOEXCEPT {return ::coshl(__lcpp_x);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	cosh(_A1 __lcpp_x) _NOEXCEPT {return ::cosh((double)__lcpp_x);}

	// exp

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float exp(float __lcpp_x) _NOEXCEPT {return ::expf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double exp(long double __lcpp_x) _NOEXCEPT {return ::expl(__lcpp_x);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	exp(_A1 __lcpp_x) _NOEXCEPT {return ::exp((double)__lcpp_x);}

	// fabs

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float fabs(float __lcpp_x) _NOEXCEPT {return ::fabsf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double fabs(long double __lcpp_x) _NOEXCEPT {return ::fabsl(__lcpp_x);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	fabs(_A1 __lcpp_x) _NOEXCEPT {return ::fabs((double)__lcpp_x);}

	// floor

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float floor(float __lcpp_x) _NOEXCEPT {return ::floorf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double floor(long double __lcpp_x) _NOEXCEPT {return ::floorl(__lcpp_x);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	floor(_A1 __lcpp_x) _NOEXCEPT {return ::floor((double)__lcpp_x);}

	// fmod

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float fmod(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fmodf(__lcpp_x, __lcpp_y);}
	inline _LIBCPP_INLINE_VISIBILITY long double fmod(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fmodl(__lcpp_x, __lcpp_y);}
	#endif

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::__lazy_enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	std::__promote<_A1, _A2>
	>::type
	fmod(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type __result_type;
	static_assert((!(std::is_same<_A1, __result_type>::value &&
	std::is_same<_A2, __result_type>::value)), "");
	return ::fmod((__result_type)__lcpp_x, (__result_type)__lcpp_y);
	}

	// frexp

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float frexp(float __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexpf(__lcpp_x, __lcpp_e);}
	inline _LIBCPP_INLINE_VISIBILITY long double frexp(long double __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexpl(__lcpp_x, __lcpp_e);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	frexp(_A1 __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexp((double)__lcpp_x, __lcpp_e);}

	// ldexp

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float ldexp(float __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexpf(__lcpp_x, __lcpp_e);}
	inline _LIBCPP_INLINE_VISIBILITY long double ldexp(long double __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexpl(__lcpp_x, __lcpp_e);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	ldexp(_A1 __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexp((double)__lcpp_x, __lcpp_e);}

	// log

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float log(float __lcpp_x) _NOEXCEPT {return ::logf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double log(long double __lcpp_x) _NOEXCEPT {return ::logl(__lcpp_x);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	log(_A1 __lcpp_x) _NOEXCEPT {return ::log((double)__lcpp_x);}

	// log10

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float log10(float __lcpp_x) _NOEXCEPT {return ::log10f(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double log10(long double __lcpp_x) _NOEXCEPT {return ::log10l(__lcpp_x);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	log10(_A1 __lcpp_x) _NOEXCEPT {return ::log10((double)__lcpp_x);}

	// modf

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float modf(float __lcpp_x, float* __lcpp_y) _NOEXCEPT {return ::modff(__lcpp_x, __lcpp_y);}
	inline _LIBCPP_INLINE_VISIBILITY long double modf(long double __lcpp_x, long double* __lcpp_y) _NOEXCEPT {return ::modfl(__lcpp_x, __lcpp_y);}
	#endif

	// pow

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float pow(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::powf(__lcpp_x, __lcpp_y);}
	inline _LIBCPP_INLINE_VISIBILITY long double pow(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::powl(__lcpp_x, __lcpp_y);}
	#endif

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::__lazy_enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	std::__promote<_A1, _A2>
	>::type
	pow(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type __result_type;
	static_assert((!(std::is_same<_A1, __result_type>::value &&
	std::is_same<_A2, __result_type>::value)), "");
	return ::pow((__result_type)__lcpp_x, (__result_type)__lcpp_y);
	}

	// sin

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float sin(float __lcpp_x) _NOEXCEPT {return ::sinf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double sin(long double __lcpp_x) _NOEXCEPT {return ::sinl(__lcpp_x);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	sin(_A1 __lcpp_x) _NOEXCEPT {return ::sin((double)__lcpp_x);}

	// sinh

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float sinh(float __lcpp_x) _NOEXCEPT {return ::sinhf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double sinh(long double __lcpp_x) _NOEXCEPT {return ::sinhl(__lcpp_x);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	sinh(_A1 __lcpp_x) _NOEXCEPT {return ::sinh((double)__lcpp_x);}

	// sqrt

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float sqrt(float __lcpp_x) _NOEXCEPT {return ::sqrtf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double sqrt(long double __lcpp_x) _NOEXCEPT {return ::sqrtl(__lcpp_x);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	sqrt(_A1 __lcpp_x) _NOEXCEPT {return ::sqrt((double)__lcpp_x);}

	// tan

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float tan(float __lcpp_x) _NOEXCEPT {return ::tanf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double tan(long double __lcpp_x) _NOEXCEPT {return ::tanl(__lcpp_x);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	tan(_A1 __lcpp_x) _NOEXCEPT {return ::tan((double)__lcpp_x);}

	// tanh

	#if !(defined(_AIX) \|\| defined(__sun__))
	inline _LIBCPP_INLINE_VISIBILITY float tanh(float __lcpp_x) _NOEXCEPT {return ::tanhf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double tanh(long double __lcpp_x) _NOEXCEPT {return ::tanhl(__lcpp_x);}
	#endif

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	tanh(_A1 __lcpp_x) _NOEXCEPT {return ::tanh((double)__lcpp_x);}

	// acosh

	inline _LIBCPP_INLINE_VISIBILITY float acosh(float __lcpp_x) _NOEXCEPT {return ::acoshf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double acosh(long double __lcpp_x) _NOEXCEPT {return ::acoshl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	acosh(_A1 __lcpp_x) _NOEXCEPT {return ::acosh((double)__lcpp_x);}

	// asinh

	inline _LIBCPP_INLINE_VISIBILITY float asinh(float __lcpp_x) _NOEXCEPT {return ::asinhf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double asinh(long double __lcpp_x) _NOEXCEPT {return ::asinhl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	asinh(_A1 __lcpp_x) _NOEXCEPT {return ::asinh((double)__lcpp_x);}

	// atanh

	inline _LIBCPP_INLINE_VISIBILITY float atanh(float __lcpp_x) _NOEXCEPT {return ::atanhf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double atanh(long double __lcpp_x) _NOEXCEPT {return ::atanhl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	atanh(_A1 __lcpp_x) _NOEXCEPT {return ::atanh((double)__lcpp_x);}

	// cbrt

	inline _LIBCPP_INLINE_VISIBILITY float cbrt(float __lcpp_x) _NOEXCEPT {return ::cbrtf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double cbrt(long double __lcpp_x) _NOEXCEPT {return ::cbrtl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	cbrt(_A1 __lcpp_x) _NOEXCEPT {return ::cbrt((double)__lcpp_x);}

	// copysign

	inline _LIBCPP_INLINE_VISIBILITY float copysign(float __lcpp_x,
	float __lcpp_y) _NOEXCEPT {
	return ::copysignf(__lcpp_x, __lcpp_y);
	}
	inline _LIBCPP_INLINE_VISIBILITY long double
	copysign(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {
	return ::copysignl(__lcpp_x, __lcpp_y);
	}

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::__lazy_enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	std::__promote<_A1, _A2>
	>::type
	copysign(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type __result_type;
	static_assert((!(std::is_same<_A1, __result_type>::value &&
	std::is_same<_A2, __result_type>::value)), "");
	return ::copysign((__result_type)__lcpp_x, (__result_type)__lcpp_y);
	}

	// erf

	inline _LIBCPP_INLINE_VISIBILITY float erf(float __lcpp_x) _NOEXCEPT {return ::erff(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double erf(long double __lcpp_x) _NOEXCEPT {return ::erfl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	erf(_A1 __lcpp_x) _NOEXCEPT {return ::erf((double)__lcpp_x);}

	// erfc

	inline _LIBCPP_INLINE_VISIBILITY float erfc(float __lcpp_x) _NOEXCEPT {return ::erfcf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double erfc(long double __lcpp_x) _NOEXCEPT {return ::erfcl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	erfc(_A1 __lcpp_x) _NOEXCEPT {return ::erfc((double)__lcpp_x);}

	// exp2

	inline _LIBCPP_INLINE_VISIBILITY float exp2(float __lcpp_x) _NOEXCEPT {return ::exp2f(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double exp2(long double __lcpp_x) _NOEXCEPT {return ::exp2l(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	exp2(_A1 __lcpp_x) _NOEXCEPT {return ::exp2((double)__lcpp_x);}

	// expm1

	inline _LIBCPP_INLINE_VISIBILITY float expm1(float __lcpp_x) _NOEXCEPT {return ::expm1f(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double expm1(long double __lcpp_x) _NOEXCEPT {return ::expm1l(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	expm1(_A1 __lcpp_x) _NOEXCEPT {return ::expm1((double)__lcpp_x);}

	// fdim

	inline _LIBCPP_INLINE_VISIBILITY float fdim(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fdimf(__lcpp_x, __lcpp_y);}
	inline _LIBCPP_INLINE_VISIBILITY long double fdim(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fdiml(__lcpp_x, __lcpp_y);}

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::__lazy_enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	std::__promote<_A1, _A2>
	>::type
	fdim(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type __result_type;
	static_assert((!(std::is_same<_A1, __result_type>::value &&
	std::is_same<_A2, __result_type>::value)), "");
	return ::fdim((__result_type)__lcpp_x, (__result_type)__lcpp_y);
	}

	// fma

	inline _LIBCPP_INLINE_VISIBILITY float fma(float __lcpp_x, float __lcpp_y, float __lcpp_z) _NOEXCEPT {return ::fmaf(__lcpp_x, __lcpp_y, __lcpp_z);}
	inline _LIBCPP_INLINE_VISIBILITY long double fma(long double __lcpp_x, long double __lcpp_y, long double __lcpp_z) _NOEXCEPT {return ::fmal(__lcpp_x, __lcpp_y, __lcpp_z);}

	template <class _A1, class _A2, class _A3>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::__lazy_enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value &&
	std::is_arithmetic<_A3>::value,
	std::__promote<_A1, _A2, _A3>
	>::type
	fma(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2, _A3>::type __result_type;
	static_assert((!(std::is_same<_A1, __result_type>::value &&
	std::is_same<_A2, __result_type>::value &&
	std::is_same<_A3, __result_type>::value)), "");
	return ::fma((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z);
	}

	// fmax

	inline _LIBCPP_INLINE_VISIBILITY float fmax(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fmaxf(__lcpp_x, __lcpp_y);}
	inline _LIBCPP_INLINE_VISIBILITY long double fmax(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fmaxl(__lcpp_x, __lcpp_y);}

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::__lazy_enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	std::__promote<_A1, _A2>
	>::type
	fmax(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type __result_type;
	static_assert((!(std::is_same<_A1, __result_type>::value &&
	std::is_same<_A2, __result_type>::value)), "");
	return ::fmax((__result_type)__lcpp_x, (__result_type)__lcpp_y);
	}

	// fmin

	inline _LIBCPP_INLINE_VISIBILITY float fmin(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fminf(__lcpp_x, __lcpp_y);}
	inline _LIBCPP_INLINE_VISIBILITY long double fmin(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fminl(__lcpp_x, __lcpp_y);}

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::__lazy_enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	std::__promote<_A1, _A2>
	>::type
	fmin(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type __result_type;
	static_assert((!(std::is_same<_A1, __result_type>::value &&
	std::is_same<_A2, __result_type>::value)), "");
	return ::fmin((__result_type)__lcpp_x, (__result_type)__lcpp_y);
	}

	// hypot

	inline _LIBCPP_INLINE_VISIBILITY float hypot(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::hypotf(__lcpp_x, __lcpp_y);}
	inline _LIBCPP_INLINE_VISIBILITY long double hypot(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::hypotl(__lcpp_x, __lcpp_y);}

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::__lazy_enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	std::__promote<_A1, _A2>
	>::type
	hypot(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type __result_type;
	static_assert((!(std::is_same<_A1, __result_type>::value &&
	std::is_same<_A2, __result_type>::value)), "");
	return ::hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y);
	}

	// ilogb

	inline _LIBCPP_INLINE_VISIBILITY int ilogb(float __lcpp_x) _NOEXCEPT {return ::ilogbf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY int ilogb(long double __lcpp_x) _NOEXCEPT {return ::ilogbl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, int>::type
	ilogb(_A1 __lcpp_x) _NOEXCEPT {return ::ilogb((double)__lcpp_x);}

	// lgamma

	inline _LIBCPP_INLINE_VISIBILITY float lgamma(float __lcpp_x) _NOEXCEPT {return ::lgammaf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double lgamma(long double __lcpp_x) _NOEXCEPT {return ::lgammal(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	lgamma(_A1 __lcpp_x) _NOEXCEPT {return ::lgamma((double)__lcpp_x);}

	// llrint

	inline _LIBCPP_INLINE_VISIBILITY long long llrint(float __lcpp_x) _NOEXCEPT {return ::llrintf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long long llrint(long double __lcpp_x) _NOEXCEPT {return ::llrintl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, long long>::type
	llrint(_A1 __lcpp_x) _NOEXCEPT {return ::llrint((double)__lcpp_x);}

	// llround

	inline _LIBCPP_INLINE_VISIBILITY long long llround(float __lcpp_x) _NOEXCEPT {return ::llroundf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long long llround(long double __lcpp_x) _NOEXCEPT {return ::llroundl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, long long>::type
	llround(_A1 __lcpp_x) _NOEXCEPT {return ::llround((double)__lcpp_x);}

	// log1p

	inline _LIBCPP_INLINE_VISIBILITY float log1p(float __lcpp_x) _NOEXCEPT {return ::log1pf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double log1p(long double __lcpp_x) _NOEXCEPT {return ::log1pl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	log1p(_A1 __lcpp_x) _NOEXCEPT {return ::log1p((double)__lcpp_x);}

	// log2

	inline _LIBCPP_INLINE_VISIBILITY float log2(float __lcpp_x) _NOEXCEPT {return ::log2f(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double log2(long double __lcpp_x) _NOEXCEPT {return ::log2l(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	log2(_A1 __lcpp_x) _NOEXCEPT {return ::log2((double)__lcpp_x);}

	// logb

	inline _LIBCPP_INLINE_VISIBILITY float logb(float __lcpp_x) _NOEXCEPT {return ::logbf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double logb(long double __lcpp_x) _NOEXCEPT {return ::logbl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	logb(_A1 __lcpp_x) _NOEXCEPT {return ::logb((double)__lcpp_x);}

	// lrint

	inline _LIBCPP_INLINE_VISIBILITY long lrint(float __lcpp_x) _NOEXCEPT {return ::lrintf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long lrint(long double __lcpp_x) _NOEXCEPT {return ::lrintl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, long>::type
	lrint(_A1 __lcpp_x) _NOEXCEPT {return ::lrint((double)__lcpp_x);}

	// lround

	inline _LIBCPP_INLINE_VISIBILITY long lround(float __lcpp_x) _NOEXCEPT {return ::lroundf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long lround(long double __lcpp_x) _NOEXCEPT {return ::lroundl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, long>::type
	lround(_A1 __lcpp_x) _NOEXCEPT {return ::lround((double)__lcpp_x);}

	// nan

	// nearbyint

	inline _LIBCPP_INLINE_VISIBILITY float nearbyint(float __lcpp_x) _NOEXCEPT {return ::nearbyintf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double nearbyint(long double __lcpp_x) _NOEXCEPT {return ::nearbyintl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	nearbyint(_A1 __lcpp_x) _NOEXCEPT {return ::nearbyint((double)__lcpp_x);}

	// nextafter

	inline _LIBCPP_INLINE_VISIBILITY float nextafter(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::nextafterf(__lcpp_x, __lcpp_y);}
	inline _LIBCPP_INLINE_VISIBILITY long double nextafter(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nextafterl(__lcpp_x, __lcpp_y);}

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::__lazy_enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	std::__promote<_A1, _A2>
	>::type
	nextafter(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type __result_type;
	static_assert((!(std::is_same<_A1, __result_type>::value &&
	std::is_same<_A2, __result_type>::value)), "");
	return ::nextafter((__result_type)__lcpp_x, (__result_type)__lcpp_y);
	}

	// nexttoward

	inline _LIBCPP_INLINE_VISIBILITY float nexttoward(float __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttowardf(__lcpp_x, __lcpp_y);}
	inline _LIBCPP_INLINE_VISIBILITY long double nexttoward(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttowardl(__lcpp_x, __lcpp_y);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	nexttoward(_A1 __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttoward((double)__lcpp_x, __lcpp_y);}

	// remainder

	inline _LIBCPP_INLINE_VISIBILITY float remainder(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::remainderf(__lcpp_x, __lcpp_y);}
	inline _LIBCPP_INLINE_VISIBILITY long double remainder(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::remainderl(__lcpp_x, __lcpp_y);}

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::__lazy_enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	std::__promote<_A1, _A2>
	>::type
	remainder(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type __result_type;
	static_assert((!(std::is_same<_A1, __result_type>::value &&
	std::is_same<_A2, __result_type>::value)), "");
	return ::remainder((__result_type)__lcpp_x, (__result_type)__lcpp_y);
	}

	// remquo

	inline _LIBCPP_INLINE_VISIBILITY float remquo(float __lcpp_x, float __lcpp_y, int* __lcpp_z) _NOEXCEPT {return ::remquof(__lcpp_x, __lcpp_y, __lcpp_z);}
	inline _LIBCPP_INLINE_VISIBILITY long double remquo(long double __lcpp_x, long double __lcpp_y, int* __lcpp_z) _NOEXCEPT {return ::remquol(__lcpp_x, __lcpp_y, __lcpp_z);}

	template <class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::__lazy_enable_if
	<
	std::is_arithmetic<_A1>::value &&
	std::is_arithmetic<_A2>::value,
	std::__promote<_A1, _A2>
	>::type
	remquo(_A1 __lcpp_x, _A2 __lcpp_y, int* __lcpp_z) _NOEXCEPT
	{
	typedef typename std::__promote<_A1, _A2>::type __result_type;
	static_assert((!(std::is_same<_A1, __result_type>::value &&
	std::is_same<_A2, __result_type>::value)), "");
	return ::remquo((__result_type)__lcpp_x, (__result_type)__lcpp_y, __lcpp_z);
	}

	// rint

	inline _LIBCPP_INLINE_VISIBILITY float rint(float __lcpp_x) _NOEXCEPT {return ::rintf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double rint(long double __lcpp_x) _NOEXCEPT {return ::rintl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	rint(_A1 __lcpp_x) _NOEXCEPT {return ::rint((double)__lcpp_x);}

	// round

	inline _LIBCPP_INLINE_VISIBILITY float round(float __lcpp_x) _NOEXCEPT {return ::roundf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double round(long double __lcpp_x) _NOEXCEPT {return ::roundl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	round(_A1 __lcpp_x) _NOEXCEPT {return ::round((double)__lcpp_x);}

	// scalbln

	inline _LIBCPP_INLINE_VISIBILITY float scalbln(float __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalblnf(__lcpp_x, __lcpp_y);}
	inline _LIBCPP_INLINE_VISIBILITY long double scalbln(long double __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalblnl(__lcpp_x, __lcpp_y);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	scalbln(_A1 __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalbln((double)__lcpp_x, __lcpp_y);}

	// scalbn

	inline _LIBCPP_INLINE_VISIBILITY float scalbn(float __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbnf(__lcpp_x, __lcpp_y);}
	inline _LIBCPP_INLINE_VISIBILITY long double scalbn(long double __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbnl(__lcpp_x, __lcpp_y);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	scalbn(_A1 __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbn((double)__lcpp_x, __lcpp_y);}

	// tgamma

	inline _LIBCPP_INLINE_VISIBILITY float tgamma(float __lcpp_x) _NOEXCEPT {return ::tgammaf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double tgamma(long double __lcpp_x) _NOEXCEPT {return ::tgammal(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	tgamma(_A1 __lcpp_x) _NOEXCEPT {return ::tgamma((double)__lcpp_x);}

	// trunc

	inline _LIBCPP_INLINE_VISIBILITY float trunc(float __lcpp_x) _NOEXCEPT {return ::truncf(__lcpp_x);}
	inline _LIBCPP_INLINE_VISIBILITY long double trunc(long double __lcpp_x) _NOEXCEPT {return ::truncl(__lcpp_x);}

	template <class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	typename std::enable_if<std::is_integral<_A1>::value, double>::type
	trunc(_A1 __lcpp_x) _NOEXCEPT {return ::trunc((double)__lcpp_x);}

	} // extern "C++"

	#endif // __cplusplus
	+
	+#else // _LIBCPP_MATH_H
	+
	+// This include lives outside the header guard in order to support an MSVC
	+// extension which allows users to do:
	+//
	+// #define _USE_MATH_DEFINES
	+// #include <math.h>
	+//
	+// and receive the definitions of mathematical constants, even if <math.h>
	+// has previously been included.
	+#if defined(_LIBCPP_MSVCRT) && defined(_USE_MATH_DEFINES)
	+#include_next <math.h>
	+#endif

	#endif // _LIBCPP_MATH_H

	Property changes on: projects/clang700-import/contrib/libc++/include/math.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/memory
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/memory (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/memory (revision 337135)
	@@ -1,5604 +1,5655 @@
	// -- C++ --
	//===-------------------------- memory ------------------------------------===//
	//
	// 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_MEMORY
	#define _LIBCPP_MEMORY

	/*
	memory synopsis

	namespace std
	{

	struct allocator_arg_t { };
	inline constexpr allocator_arg_t allocator_arg = allocator_arg_t();

	template <class T, class Alloc> struct uses_allocator;

	template <class Ptr>
	struct pointer_traits
	{
	typedef Ptr pointer;
	typedef <details> element_type;
	typedef <details> difference_type;

	template <class U> using rebind = <details>;

	static pointer pointer_to(<details>);
	};

	template <class T>
	struct pointer_traits<T*>
	{
	typedef T* pointer;
	typedef T element_type;
	typedef ptrdiff_t difference_type;

	template <class U> using rebind = U*;

	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
	{
	typedef Alloc allocator_type;
	typedef typename allocator_type::value_type
	value_type;

	typedef Alloc::pointer \| value_type* pointer;
	typedef Alloc::const_pointer
	\| pointer_traits<pointer>::rebind<const value_type>
	const_pointer;
	typedef Alloc::void_pointer
	\| pointer_traits<pointer>::rebind<void>
	void_pointer;
	typedef Alloc::const_void_pointer
	\| pointer_traits<pointer>::rebind<const void>
	const_void_pointer;
	typedef Alloc::difference_type
	\| pointer_traits<pointer>::difference_type
	difference_type;
	typedef Alloc::size_type
	\| make_unsigned<difference_type>::type
	size_type;
	typedef Alloc::propagate_on_container_copy_assignment
	\| false_type propagate_on_container_copy_assignment;
	typedef Alloc::propagate_on_container_move_assignment
	\| false_type propagate_on_container_move_assignment;
	typedef Alloc::propagate_on_container_swap
	\| false_type propagate_on_container_swap;
	typedef Alloc::is_always_equal
	\| is_empty is_always_equal;

	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); // [[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;

	template <class T, class... Args>
	static void construct(allocator_type& a, T* p, Args&&... args);

	template <class T>
	static void destroy(allocator_type& a, T* p);

	static size_type max_size(const allocator_type& a); // noexcept in C++14

	static allocator_type
	select_on_container_copy_construction(const allocator_type& a);
	};

	template <>
	class allocator<void>
	{
	public:
	typedef void* pointer;
	typedef const void* const_pointer;
	typedef void value_type;

	template <class _Up> struct rebind {typedef allocator<_Up> other;};
	};

	template <class T>
	class allocator
	{
	public:
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;
	typedef T* pointer;
	typedef const T* const_pointer;
	typedef typename add_lvalue_reference<T>::type reference;
	typedef typename add_lvalue_reference<const T>::type const_reference;
	typedef T value_type;

	template <class U> struct rebind {typedef allocator<U> other;};

	- allocator() noexcept;
	- allocator(const allocator&) noexcept;
	- template <class U> allocator(const allocator<U>&) noexcept;
	+ constexpr allocator() noexcept; // constexpr in C++20
	+ constexpr allocator(const allocator&) noexcept; // constexpr in C++20
	+ template <class U>
	+ constexpr allocator(const allocator<U>&) noexcept; // constexpr in C++20
	~allocator();
	pointer address(reference x) const noexcept;
	const_pointer address(const_reference x) const noexcept;
	pointer allocate(size_type, allocator<void>::const_pointer hint = 0);
	void deallocate(pointer p, size_type n) noexcept;
	size_type max_size() const noexcept;
	template<class U, class... Args>
	void construct(U* p, Args&&... args);
	template <class U>
	void destroy(U* p);
	};

	template <class T, class U>
	bool operator==(const allocator<T>&, const allocator<U>&) noexcept;

	template <class T, class U>
	bool operator!=(const allocator<T>&, const allocator<U>&) noexcept;

	template <class OutputIterator, class T>
	class raw_storage_iterator
	: public iterator<output_iterator_tag,
	T, // purposefully not C++03
	ptrdiff_t, // purposefully not C++03
	T*, // purposefully not C++03
	raw_storage_iterator&> // purposefully not C++03
	{
	public:
	explicit raw_storage_iterator(OutputIterator x);
	raw_storage_iterator& operator*();
	raw_storage_iterator& operator=(const T& element);
	raw_storage_iterator& operator++();
	raw_storage_iterator operator++(int);
	};

	template <class T> pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n) noexcept;
	template <class T> void return_temporary_buffer(T* p) noexcept;

	template <class T> T* addressof(T& r) noexcept;
	template <class T> T* addressof(const T&& r) noexcept = delete;

	template <class InputIterator, class ForwardIterator>
	ForwardIterator
	uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result);

	template <class InputIterator, class Size, class ForwardIterator>
	ForwardIterator
	uninitialized_copy_n(InputIterator first, Size n, ForwardIterator result);

	template <class ForwardIterator, class T>
	void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x);

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

	template <class T>
	void destroy_at(T* location);

	template <class ForwardIterator>
	void destroy(ForwardIterator first, ForwardIterator last);

	template <class ForwardIterator, class Size>
	ForwardIterator destroy_n(ForwardIterator first, Size n);

	template <class InputIterator, class ForwardIterator>
	ForwardIterator uninitialized_move(InputIterator first, InputIterator last, ForwardIterator result);

	template <class InputIterator, class Size, class ForwardIterator>
	pair<InputIterator,ForwardIterator> uninitialized_move_n(InputIterator first, Size n, ForwardIterator result);

	template <class ForwardIterator>
	void uninitialized_value_construct(ForwardIterator first, ForwardIterator last);

	template <class ForwardIterator, class Size>
	ForwardIterator uninitialized_value_construct_n(ForwardIterator first, Size n);

	template <class ForwardIterator>
	void uninitialized_default_construct(ForwardIterator first, ForwardIterator last);

	template <class ForwardIterator, class Size>
	ForwardIterator uninitialized_default_construct_n(ForwardIterator first, Size n);

	template <class Y> struct auto_ptr_ref {}; // removed in C++17

	template<class X>
	class auto_ptr // removed in C++17
	{
	public:
	typedef X element_type;

	explicit auto_ptr(X* p =0) throw();
	auto_ptr(auto_ptr&) throw();
	template<class Y> auto_ptr(auto_ptr<Y>&) throw();
	auto_ptr& operator=(auto_ptr&) throw();
	template<class Y> auto_ptr& operator=(auto_ptr<Y>&) throw();
	auto_ptr& operator=(auto_ptr_ref<X> r) throw();
	~auto_ptr() throw();

	typename add_lvalue_reference<X>::type operator*() const throw();
	X* operator->() const throw();
	X* get() const throw();
	X* release() throw();
	void reset(X* p =0) throw();

	auto_ptr(auto_ptr_ref<X>) throw();
	template<class Y> operator auto_ptr_ref<Y>() throw();
	template<class Y> operator auto_ptr<Y>() throw();
	};

	template <class T>
	struct default_delete
	{
	constexpr default_delete() noexcept = default;
	template <class U> default_delete(const default_delete<U>&) noexcept;

	void operator()(T*) const noexcept;
	};

	template <class T>
	struct default_delete<T[]>
	{
	constexpr default_delete() noexcept = default;
	void operator()(T*) const noexcept;
	template <class U> void operator()(U*) const = delete;
	};

	template <class T, class D = default_delete<T>>
	class unique_ptr
	{
	public:
	typedef see below pointer;
	typedef T element_type;
	typedef D deleter_type;

	// constructors
	constexpr unique_ptr() noexcept;
	explicit unique_ptr(pointer p) noexcept;
	unique_ptr(pointer p, see below d1) noexcept;
	unique_ptr(pointer p, see below d2) noexcept;
	unique_ptr(unique_ptr&& u) noexcept;
	unique_ptr(nullptr_t) noexcept : unique_ptr() { }
	template <class U, class E>
	unique_ptr(unique_ptr<U, E>&& u) noexcept;
	template <class U>
	unique_ptr(auto_ptr<U>&& u) noexcept; // removed in C++17

	// destructor
	~unique_ptr();

	// assignment
	unique_ptr& operator=(unique_ptr&& u) noexcept;
	template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
	unique_ptr& operator=(nullptr_t) noexcept;

	// observers
	typename add_lvalue_reference<T>::type operator*() const;
	pointer operator->() const noexcept;
	pointer get() const noexcept;
	deleter_type& get_deleter() noexcept;
	const deleter_type& get_deleter() const noexcept;
	explicit operator bool() const noexcept;

	// modifiers
	pointer release() noexcept;
	void reset(pointer p = pointer()) noexcept;
	void swap(unique_ptr& u) noexcept;
	};

	template <class T, class D>
	class unique_ptr<T[], D>
	{
	public:
	typedef implementation-defined pointer;
	typedef T element_type;
	typedef D deleter_type;

	// constructors
	constexpr unique_ptr() noexcept;
	explicit unique_ptr(pointer p) noexcept;
	unique_ptr(pointer p, see below d) noexcept;
	unique_ptr(pointer p, see below d) noexcept;
	unique_ptr(unique_ptr&& u) noexcept;
	unique_ptr(nullptr_t) noexcept : unique_ptr() { }

	// destructor
	~unique_ptr();

	// assignment
	unique_ptr& operator=(unique_ptr&& u) noexcept;
	unique_ptr& operator=(nullptr_t) noexcept;

	// observers
	T& operator[](size_t i) const;
	pointer get() const noexcept;
	deleter_type& get_deleter() noexcept;
	const deleter_type& get_deleter() const noexcept;
	explicit operator bool() const noexcept;

	// modifiers
	pointer release() noexcept;
	void reset(pointer p = pointer()) noexcept;
	void reset(nullptr_t) noexcept;
	template <class U> void reset(U) = delete;
	void swap(unique_ptr& u) noexcept;
	};

	template <class T, class D>
	void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;

	template <class T1, class D1, class T2, class D2>
	bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
	template <class T1, class D1, class T2, class D2>
	bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
	template <class T1, class D1, class T2, class D2>
	bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
	template <class T1, class D1, class T2, class D2>
	bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
	template <class T1, class D1, class T2, class D2>
	bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
	template <class T1, class D1, class T2, class D2>
	bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);

	template <class T, class D>
	bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;
	template <class T, class D>
	bool operator==(nullptr_t, const unique_ptr<T, D>& y) noexcept;
	template <class T, class D>
	bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept;
	template <class T, class D>
	bool operator!=(nullptr_t, const unique_ptr<T, D>& y) noexcept;

	template <class T, class D>
	bool operator<(const unique_ptr<T, D>& x, nullptr_t);
	template <class T, class D>
	bool operator<(nullptr_t, const unique_ptr<T, D>& y);
	template <class T, class D>
	bool operator<=(const unique_ptr<T, D>& x, nullptr_t);
	template <class T, class D>
	bool operator<=(nullptr_t, const unique_ptr<T, D>& y);
	template <class T, class D>
	bool operator>(const unique_ptr<T, D>& x, nullptr_t);
	template <class T, class D>
	bool operator>(nullptr_t, const unique_ptr<T, D>& y);
	template <class T, class D>
	bool operator>=(const unique_ptr<T, D>& x, nullptr_t);
	template <class T, class D>
	bool operator>=(nullptr_t, const unique_ptr<T, D>& y);

	class bad_weak_ptr
	: public std::exception
	{
	bad_weak_ptr() noexcept;
	};

	template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args); // C++14
	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
	{
	public:
	typedef T element_type;
	typedef weak_ptr<T> weak_type; // C++17

	// constructors:
	constexpr shared_ptr() noexcept;
	template<class Y> explicit shared_ptr(Y* p);
	template<class Y, class D> shared_ptr(Y* p, D d);
	template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
	template <class D> shared_ptr(nullptr_t p, D d);
	template <class D, class A> shared_ptr(nullptr_t p, D d, A a);
	template<class Y> shared_ptr(const shared_ptr<Y>& r, T *p) noexcept;
	shared_ptr(const shared_ptr& r) noexcept;
	template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
	shared_ptr(shared_ptr&& r) noexcept;
	template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
	template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
	template<class Y> shared_ptr(auto_ptr<Y>&& r); // removed in C++17
	template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
	shared_ptr(nullptr_t) : shared_ptr() { }

	// destructor:
	~shared_ptr();

	// assignment:
	shared_ptr& operator=(const shared_ptr& r) noexcept;
	template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
	shared_ptr& operator=(shared_ptr&& r) noexcept;
	template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r);
	template<class Y> shared_ptr& operator=(auto_ptr<Y>&& r); // removed in C++17
	template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);

	// modifiers:
	void swap(shared_ptr& r) noexcept;
	void reset() noexcept;
	template<class Y> void reset(Y* p);
	template<class Y, class D> void reset(Y* p, D d);
	template<class Y, class D, class A> void reset(Y* p, D d, A a);

	// observers:
	T* get() const noexcept;
	T& operator*() const noexcept;
	T* operator->() const noexcept;
	long use_count() const noexcept;
	bool unique() const noexcept;
	explicit operator bool() const noexcept;
	template<class U> bool owner_before(shared_ptr<U> const& b) const noexcept;
	template<class U> bool owner_before(weak_ptr<U> const& b) const noexcept;
	};

	// shared_ptr comparisons:
	template<class T, class U>
	bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
	template<class T, class U>
	bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
	template<class T, class U>
	bool operator<(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
	template<class T, class U>
	bool operator>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
	template<class T, class U>
	bool operator<=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
	template<class T, class U>
	bool operator>=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;

	template <class T>
	bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept;
	template <class T>
	bool operator==(nullptr_t, const shared_ptr<T>& y) noexcept;
	template <class T>
	bool operator!=(const shared_ptr<T>& x, nullptr_t) noexcept;
	template <class T>
	bool operator!=(nullptr_t, const shared_ptr<T>& y) noexcept;
	template <class T>
	bool operator<(const shared_ptr<T>& x, nullptr_t) noexcept;
	template <class T>
	bool operator<(nullptr_t, const shared_ptr<T>& y) noexcept;
	template <class T>
	bool operator<=(const shared_ptr<T>& x, nullptr_t) noexcept;
	template <class T>
	bool operator<=(nullptr_t, const shared_ptr<T>& y) noexcept;
	template <class T>
	bool operator>(const shared_ptr<T>& x, nullptr_t) noexcept;
	template <class T>
	bool operator>(nullptr_t, const shared_ptr<T>& y) noexcept;
	template <class T>
	bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept;
	template <class T>
	bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept;

	// shared_ptr specialized algorithms:
	template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;

	// shared_ptr casts:
	template<class T, class U>
	shared_ptr<T> static_pointer_cast(shared_ptr<U> const& r) noexcept;
	template<class T, class U>
	shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const& r) noexcept;
	template<class T, class U>
	shared_ptr<T> const_pointer_cast(shared_ptr<U> const& r) noexcept;

	// shared_ptr I/O:
	template<class E, class T, class Y>
	basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, shared_ptr<Y> const& p);

	// shared_ptr get_deleter:
	template<class D, class T> D* get_deleter(shared_ptr<T> const& p) noexcept;

	template<class T, class... Args>
	shared_ptr<T> make_shared(Args&&... args);
	template<class T, class A, class... Args>
	shared_ptr<T> allocate_shared(const A& a, Args&&... args);

	template<class T>
	class weak_ptr
	{
	public:
	typedef T element_type;

	// constructors
	constexpr weak_ptr() noexcept;
	template<class Y> weak_ptr(shared_ptr<Y> const& r) noexcept;
	weak_ptr(weak_ptr const& r) noexcept;
	template<class Y> weak_ptr(weak_ptr<Y> const& r) noexcept;
	weak_ptr(weak_ptr&& r) noexcept; // C++14
	template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept; // C++14

	// destructor
	~weak_ptr();

	// assignment
	weak_ptr& operator=(weak_ptr const& r) noexcept;
	template<class Y> weak_ptr& operator=(weak_ptr<Y> const& r) noexcept;
	template<class Y> weak_ptr& operator=(shared_ptr<Y> const& r) noexcept;
	weak_ptr& operator=(weak_ptr&& r) noexcept; // C++14
	template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r) noexcept; // C++14

	// modifiers
	void swap(weak_ptr& r) noexcept;
	void reset() noexcept;

	// observers
	long use_count() const noexcept;
	bool expired() const noexcept;
	shared_ptr<T> lock() const noexcept;
	template<class U> bool owner_before(shared_ptr<U> const& b) const noexcept;
	template<class U> bool owner_before(weak_ptr<U> const& b) const noexcept;
	};

	// weak_ptr specialized algorithms:
	template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;

	// class owner_less:
	template<class T> struct owner_less;

	template<class T>
	struct owner_less<shared_ptr<T>>
	: binary_function<shared_ptr<T>, shared_ptr<T>, bool>
	{
	typedef bool result_type;
	bool operator()(shared_ptr<T> const&, shared_ptr<T> const&) const noexcept;
	bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const noexcept;
	bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const noexcept;
	};

	template<class T>
	struct owner_less<weak_ptr<T>>
	: binary_function<weak_ptr<T>, weak_ptr<T>, bool>
	{
	typedef bool result_type;
	bool operator()(weak_ptr<T> const&, weak_ptr<T> const&) const noexcept;
	bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const noexcept;
	bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const noexcept;
	};

	template <> // Added in C++14
	struct owner_less<void>
	{
	template <class _Tp, class _Up>
	bool operator()( shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const noexcept;
	template <class _Tp, class _Up>
	bool operator()( shared_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const noexcept;
	template <class _Tp, class _Up>
	bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const noexcept;
	template <class _Tp, class _Up>
	bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const noexcept;

	typedef void is_transparent;
	};

	template<class T>
	class enable_shared_from_this
	{
	protected:
	constexpr enable_shared_from_this() noexcept;
	enable_shared_from_this(enable_shared_from_this const&) noexcept;
	enable_shared_from_this& operator=(enable_shared_from_this const&) noexcept;
	~enable_shared_from_this();
	public:
	shared_ptr<T> shared_from_this();
	shared_ptr<T const> shared_from_this() const;
	};

	template<class T>
	bool atomic_is_lock_free(const shared_ptr<T>* p);
	template<class T>
	shared_ptr<T> atomic_load(const shared_ptr<T>* p);
	template<class T>
	shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo);
	template<class T>
	void atomic_store(shared_ptr<T>* p, shared_ptr<T> r);
	template<class T>
	void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
	template<class T>
	shared_ptr<T> atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r);
	template<class T>
	shared_ptr<T>
	atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
	template<class T>
	bool
	atomic_compare_exchange_weak(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
	template<class T>
	bool
	atomic_compare_exchange_strong( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
	template<class T>
	bool
	atomic_compare_exchange_weak_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
	shared_ptr<T> w, memory_order success,
	memory_order failure);
	template<class T>
	bool
	atomic_compare_exchange_strong_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
	shared_ptr<T> w, memory_order success,
	memory_order failure);
	// Hash support
	template <class T> struct hash;
	template <class T, class D> struct hash<unique_ptr<T, D> >;
	template <class T> struct hash<shared_ptr<T> >;

	template <class T, class Alloc>
	inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;

	// Pointer safety
	enum class pointer_safety { relaxed, preferred, strict };
	void declare_reachable(void *p);
	template <class T> T undeclare_reachable(T p);
	void declare_no_pointers(char *p, size_t n);
	void undeclare_no_pointers(char *p, size_t n);
	pointer_safety get_pointer_safety() noexcept;

	void* align(size_t alignment, size_t size, void*& ptr, size_t& space);

	} // std

	*/

	#include <__config>
	#include <type_traits>
	#include <typeinfo>
	#include <cstddef>
	#include <cstdint>
	#include <new>
	#include <utility>
	#include <limits>
	#include <iterator>
	#include <__functional_base>
	#include <iosfwd>
	#include <tuple>
	#include <stdexcept>
	#include <cstring>
	#include <cassert>
	#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
	# include <atomic>
	#endif

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _ValueType>
	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	_ValueType __libcpp_relaxed_load(_ValueType const* __value) {
	#if !defined(_LIBCPP_HAS_NO_THREADS) && \
	defined(__ATOMIC_RELAXED) && \
	(__has_builtin(__atomic_load_n) \|\| _GNUC_VER >= 407)
	return __atomic_load_n(__value, __ATOMIC_RELAXED);
	#else
	return *__value;
	#endif
	}

	template <class _ValueType>
	-inline _LIBCPP_ALWAYS_INLINE
	+inline _LIBCPP_INLINE_VISIBILITY
	_ValueType __libcpp_acquire_load(_ValueType const* __value) {
	#if !defined(_LIBCPP_HAS_NO_THREADS) && \
	defined(__ATOMIC_ACQUIRE) && \
	(__has_builtin(__atomic_load_n) \|\| _GNUC_VER >= 407)
	return __atomic_load_n(__value, __ATOMIC_ACQUIRE);
	#else
	return *__value;
	#endif
	}

	// addressof moved to <type_traits>

	template <class _Tp> class allocator;

	template <>
	class _LIBCPP_TEMPLATE_VIS allocator<void>
	{
	public:
	typedef void* pointer;
	typedef const void* const_pointer;
	typedef void value_type;

	template <class _Up> struct rebind {typedef allocator<_Up> other;};
	};

	template <>
	class _LIBCPP_TEMPLATE_VIS allocator<const void>
	{
	public:
	typedef const void* pointer;
	typedef const void* const_pointer;
	typedef const void value_type;

	template <class _Up> struct rebind {typedef allocator<_Up> other;};
	};

	// pointer_traits

	template <class _Tp, class = void>
	struct __has_element_type : false_type {};

	template <class _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>
	struct __pointer_traits_element_type;

	template <class _Ptr>
	struct __pointer_traits_element_type<_Ptr, true>
	{
	typedef typename _Ptr::element_type type;
	};

	#ifndef _LIBCPP_HAS_NO_VARIADICS

	template <template <class, class...> class _Sp, class _Tp, class ..._Args>
	struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, true>
	{
	typedef typename _Sp<_Tp, _Args...>::element_type type;
	};

	template <template <class, class...> class _Sp, class _Tp, class ..._Args>
	struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, false>
	{
	typedef _Tp type;
	};

	#else // _LIBCPP_HAS_NO_VARIADICS

	template <template <class> class _Sp, class _Tp>
	struct __pointer_traits_element_type<_Sp<_Tp>, true>
	{
	typedef typename _Sp<_Tp>::element_type type;
	};

	template <template <class> class _Sp, class _Tp>
	struct __pointer_traits_element_type<_Sp<_Tp>, false>
	{
	typedef _Tp type;
	};

	template <template <class, class> class _Sp, class _Tp, class _A0>
	struct __pointer_traits_element_type<_Sp<_Tp, _A0>, true>
	{
	typedef typename _Sp<_Tp, _A0>::element_type type;
	};

	template <template <class, class> class _Sp, class _Tp, class _A0>
	struct __pointer_traits_element_type<_Sp<_Tp, _A0>, false>
	{
	typedef _Tp type;
	};

	template <template <class, class, class> class _Sp, class _Tp, class _A0, class _A1>
	struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1>, true>
	{
	typedef typename _Sp<_Tp, _A0, _A1>::element_type type;
	};

	template <template <class, class, class> class _Sp, class _Tp, class _A0, class _A1>
	struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1>, false>
	{
	typedef _Tp type;
	};

	template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
	class _A1, class _A2>
	struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1, _A2>, true>
	{
	typedef typename _Sp<_Tp, _A0, _A1, _A2>::element_type type;
	};

	template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
	class _A1, class _A2>
	struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1, _A2>, false>
	{
	typedef _Tp type;
	};

	#endif // _LIBCPP_HAS_NO_VARIADICS

	template <class _Tp, class = void>
	struct __has_difference_type : false_type {};

	template <class _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>
	struct __pointer_traits_difference_type
	{
	typedef ptrdiff_t type;
	};

	template <class _Ptr>
	struct __pointer_traits_difference_type<_Ptr, true>
	{
	typedef typename _Ptr::difference_type type;
	};

	template <class _Tp, class _Up>
	struct __has_rebind
	{
	private:
	struct __two {char __lx; char __lxx;};
	template <class _Xp> static __two __test(...);
	template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0);
	public:
	static const bool value = sizeof(__test<_Tp>(0)) == 1;
	};

	template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
	struct __pointer_traits_rebind
	{
	#ifndef _LIBCPP_CXX03_LANG
	typedef typename _Tp::template rebind<_Up> type;
	#else
	typedef typename _Tp::template rebind<_Up>::other type;
	#endif
	};

	#ifndef _LIBCPP_HAS_NO_VARIADICS

	template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up>
	struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, true>
	{
	#ifndef _LIBCPP_CXX03_LANG
	typedef typename _Sp<_Tp, _Args...>::template rebind<_Up> type;
	#else
	typedef typename _Sp<_Tp, _Args...>::template rebind<_Up>::other type;
	#endif
	};

	template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up>
	struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, false>
	{
	typedef _Sp<_Up, _Args...> type;
	};

	#else // _LIBCPP_HAS_NO_VARIADICS

	template <template <class> class _Sp, class _Tp, class _Up>
	struct __pointer_traits_rebind<_Sp<_Tp>, _Up, true>
	{
	#ifndef _LIBCPP_CXX03_LANG
	typedef typename _Sp<_Tp>::template rebind<_Up> type;
	#else
	typedef typename _Sp<_Tp>::template rebind<_Up>::other type;
	#endif
	};

	template <template <class> class _Sp, class _Tp, class _Up>
	struct __pointer_traits_rebind<_Sp<_Tp>, _Up, false>
	{
	typedef _Sp<_Up> type;
	};

	template <template <class, class> class _Sp, class _Tp, class _A0, class _Up>
	struct __pointer_traits_rebind<_Sp<_Tp, _A0>, _Up, true>
	{
	#ifndef _LIBCPP_CXX03_LANG
	typedef typename _Sp<_Tp, _A0>::template rebind<_Up> type;
	#else
	typedef typename _Sp<_Tp, _A0>::template rebind<_Up>::other type;
	#endif
	};

	template <template <class, class> class _Sp, class _Tp, class _A0, class _Up>
	struct __pointer_traits_rebind<_Sp<_Tp, _A0>, _Up, false>
	{
	typedef _Sp<_Up, _A0> type;
	};

	template <template <class, class, class> class _Sp, class _Tp, class _A0,
	class _A1, class _Up>
	struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1>, _Up, true>
	{
	#ifndef _LIBCPP_CXX03_LANG
	typedef typename _Sp<_Tp, _A0, _A1>::template rebind<_Up> type;
	#else
	typedef typename _Sp<_Tp, _A0, _A1>::template rebind<_Up>::other type;
	#endif
	};

	template <template <class, class, class> class _Sp, class _Tp, class _A0,
	class _A1, class _Up>
	struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1>, _Up, false>
	{
	typedef _Sp<_Up, _A0, _A1> type;
	};

	template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
	class _A1, class _A2, class _Up>
	struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, true>
	{
	#ifndef _LIBCPP_CXX03_LANG
	typedef typename _Sp<_Tp, _A0, _A1, _A2>::template rebind<_Up> type;
	#else
	typedef typename _Sp<_Tp, _A0, _A1, _A2>::template rebind<_Up>::other type;
	#endif
	};

	template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
	class _A1, class _A2, class _Up>
	struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, false>
	{
	typedef _Sp<_Up, _A0, _A1, _A2> type;
	};

	#endif // _LIBCPP_HAS_NO_VARIADICS

	template <class _Ptr>
	struct _LIBCPP_TEMPLATE_VIS pointer_traits
	{
	typedef _Ptr pointer;
	typedef typename __pointer_traits_element_type<pointer>::type element_type;
	typedef typename __pointer_traits_difference_type<pointer>::type difference_type;

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Up> using rebind = typename __pointer_traits_rebind<pointer, _Up>::type;
	#else
	template <class _Up> struct rebind
	{typedef typename __pointer_traits_rebind<pointer, _Up>::type other;};
	#endif // _LIBCPP_CXX03_LANG

	private:
	struct __nat {};
	public:
	_LIBCPP_INLINE_VISIBILITY
	static pointer pointer_to(typename conditional<is_void<element_type>::value,
	__nat, element_type>::type& __r)
	{return pointer::pointer_to(__r);}
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS pointer_traits<_Tp*>
	{
	typedef _Tp* pointer;
	typedef _Tp element_type;
	typedef ptrdiff_t difference_type;

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Up> using rebind = _Up*;
	#else
	template <class _Up> struct rebind {typedef _Up* other;};
	#endif

	private:
	struct __nat {};
	public:
	_LIBCPP_INLINE_VISIBILITY
	static pointer pointer_to(typename conditional<is_void<element_type>::value,
	__nat, element_type>::type& __r) _NOEXCEPT
	{return _VSTD::addressof(__r);}
	};

	template <class _From, class _To>
	struct __rebind_pointer {
	#ifndef _LIBCPP_CXX03_LANG
	typedef typename pointer_traits<_From>::template rebind<_To> type;
	#else
	typedef typename pointer_traits<_From>::template rebind<_To>::other type;
	#endif
	};

	// allocator_traits

	template <class _Tp, class = void>
	struct __has_pointer_type : false_type {};

	template <class _Tp>
	struct __has_pointer_type<_Tp,
	typename __void_t<typename _Tp::pointer>::type> : true_type {};

	namespace __pointer_type_imp
	{

	template <class _Tp, class _Dp, bool = __has_pointer_type<_Dp>::value>
	struct __pointer_type
	{
	typedef typename _Dp::pointer type;
	};

	template <class _Tp, class _Dp>
	struct __pointer_type<_Tp, _Dp, false>
	{
	typedef _Tp* type;
	};

	} // __pointer_type_imp

	template <class _Tp, class _Dp>
	struct __pointer_type
	{
	typedef typename __pointer_type_imp::__pointer_type<_Tp, typename remove_reference<_Dp>::type>::type type;
	};

	template <class _Tp, class = void>
	struct __has_const_pointer : false_type {};

	template <class _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>
	struct __const_pointer
	{
	typedef typename _Alloc::const_pointer type;
	};

	template <class _Tp, class _Ptr, class _Alloc>
	struct __const_pointer<_Tp, _Ptr, _Alloc, false>
	{
	#ifndef _LIBCPP_CXX03_LANG
	typedef typename pointer_traits<_Ptr>::template rebind<const _Tp> type;
	#else
	typedef typename pointer_traits<_Ptr>::template rebind<const _Tp>::other type;
	#endif
	};

	template <class _Tp, class = void>
	struct __has_void_pointer : false_type {};

	template <class _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>
	struct __void_pointer
	{
	typedef typename _Alloc::void_pointer type;
	};

	template <class _Ptr, class _Alloc>
	struct __void_pointer<_Ptr, _Alloc, false>
	{
	#ifndef _LIBCPP_CXX03_LANG
	typedef typename pointer_traits<_Ptr>::template rebind<void> type;
	#else
	typedef typename pointer_traits<_Ptr>::template rebind<void>::other type;
	#endif
	};

	template <class _Tp, class = void>
	struct __has_const_void_pointer : false_type {};

	template <class _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>
	struct __const_void_pointer
	{
	typedef typename _Alloc::const_void_pointer type;
	};

	template <class _Ptr, class _Alloc>
	struct __const_void_pointer<_Ptr, _Alloc, false>
	{
	#ifndef _LIBCPP_CXX03_LANG
	typedef typename pointer_traits<_Ptr>::template rebind<const void> type;
	#else
	typedef typename pointer_traits<_Ptr>::template rebind<const void>::other type;
	#endif
	};

	template <class _Tp>
	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*
	__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 {};

	template <class _Tp>
	struct __has_size_type<_Tp,
	typename __void_t<typename _Tp::size_type>::type> : true_type {};

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

	template <class _Alloc, class _DiffType>
	struct __size_type<_Alloc, _DiffType, true>
	{
	typedef typename _Alloc::size_type type;
	};

	template <class _Tp, class = void>
	struct __has_propagate_on_container_copy_assignment : false_type {};

	template <class _Tp>
	struct __has_propagate_on_container_copy_assignment<_Tp,
	typename __void_t<typename _Tp::propagate_on_container_copy_assignment>::type>
	: true_type {};

	template <class _Alloc, bool = __has_propagate_on_container_copy_assignment<_Alloc>::value>
	struct __propagate_on_container_copy_assignment
	{
	typedef false_type type;
	};

	template <class _Alloc>
	struct __propagate_on_container_copy_assignment<_Alloc, true>
	{
	typedef typename _Alloc::propagate_on_container_copy_assignment type;
	};

	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,
	typename __void_t<typename _Tp::propagate_on_container_move_assignment>::type>
	: true_type {};

	template <class _Alloc, bool = __has_propagate_on_container_move_assignment<_Alloc>::value>
	struct __propagate_on_container_move_assignment
	{
	typedef false_type type;
	};

	template <class _Alloc>
	struct __propagate_on_container_move_assignment<_Alloc, true>
	{
	typedef typename _Alloc::propagate_on_container_move_assignment type;
	};

	template <class _Tp, class = void>
	struct __has_propagate_on_container_swap : false_type {};

	template <class _Tp>
	struct __has_propagate_on_container_swap<_Tp,
	typename __void_t<typename _Tp::propagate_on_container_swap>::type>
	: true_type {};

	template <class _Alloc, bool = __has_propagate_on_container_swap<_Alloc>::value>
	struct __propagate_on_container_swap
	{
	typedef false_type type;
	};

	template <class _Alloc>
	struct __propagate_on_container_swap<_Alloc, true>
	{
	typedef typename _Alloc::propagate_on_container_swap type;
	};

	template <class _Tp, class = void>
	struct __has_is_always_equal : false_type {};

	template <class _Tp>
	struct __has_is_always_equal<_Tp,
	typename __void_t<typename _Tp::is_always_equal>::type>
	: true_type {};

	template <class _Alloc, bool = __has_is_always_equal<_Alloc>::value>
	struct __is_always_equal
	{
	typedef typename _VSTD::is_empty<_Alloc>::type type;
	};

	template <class _Alloc>
	struct __is_always_equal<_Alloc, true>
	{
	typedef typename _Alloc::is_always_equal type;
	};

	template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
	struct __has_rebind_other
	{
	private:
	struct __two {char __lx; char __lxx;};
	template <class _Xp> static __two __test(...);
	template <class _Xp> static char __test(typename _Xp::template rebind<_Up>::other* = 0);
	public:
	static const bool value = sizeof(__test<_Tp>(0)) == 1;
	};

	template <class _Tp, class _Up>
	struct __has_rebind_other<_Tp, _Up, false>
	{
	static const bool value = false;
	};

	template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value>
	struct __allocator_traits_rebind
	{
	typedef typename _Tp::template rebind<_Up>::other type;
	};

	#ifndef _LIBCPP_HAS_NO_VARIADICS

	template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
	struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true>
	{
	typedef typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other type;
	};

	template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
	struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false>
	{
	typedef _Alloc<_Up, _Args...> type;
	};

	#else // _LIBCPP_HAS_NO_VARIADICS

	template <template <class> class _Alloc, class _Tp, class _Up>
	struct __allocator_traits_rebind<_Alloc<_Tp>, _Up, true>
	{
	typedef typename _Alloc<_Tp>::template rebind<_Up>::other type;
	};

	template <template <class> class _Alloc, class _Tp, class _Up>
	struct __allocator_traits_rebind<_Alloc<_Tp>, _Up, false>
	{
	typedef _Alloc<_Up> type;
	};

	template <template <class, class> class _Alloc, class _Tp, class _A0, class _Up>
	struct __allocator_traits_rebind<_Alloc<_Tp, _A0>, _Up, true>
	{
	typedef typename _Alloc<_Tp, _A0>::template rebind<_Up>::other type;
	};

	template <template <class, class> class _Alloc, class _Tp, class _A0, class _Up>
	struct __allocator_traits_rebind<_Alloc<_Tp, _A0>, _Up, false>
	{
	typedef _Alloc<_Up, _A0> type;
	};

	template <template <class, class, class> class _Alloc, class _Tp, class _A0,
	class _A1, class _Up>
	struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1>, _Up, true>
	{
	typedef typename _Alloc<_Tp, _A0, _A1>::template rebind<_Up>::other type;
	};

	template <template <class, class, class> class _Alloc, class _Tp, class _A0,
	class _A1, class _Up>
	struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1>, _Up, false>
	{
	typedef _Alloc<_Up, _A0, _A1> type;
	};

	template <template <class, class, class, class> class _Alloc, class _Tp, class _A0,
	class _A1, class _A2, class _Up>
	struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1, _A2>, _Up, true>
	{
	typedef typename _Alloc<_Tp, _A0, _A1, _A2>::template rebind<_Up>::other type;
	};

	template <template <class, class, class, class> class _Alloc, class _Tp, class _A0,
	class _A1, class _A2, class _Up>
	struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1, _A2>, _Up, false>
	{
	typedef _Alloc<_Up, _A0, _A1, _A2> type;
	};

	#endif // _LIBCPP_HAS_NO_VARIADICS

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Alloc, class _SizeType, class _ConstVoidPtr>
	auto
	__has_allocate_hint_test(_Alloc&& __a, _SizeType&& __sz, _ConstVoidPtr&& __p)
	-> decltype((void)__a.allocate(__sz, __p), true_type());

	template <class _Alloc, class _SizeType, class _ConstVoidPtr>
	auto
	__has_allocate_hint_test(const _Alloc& __a, _SizeType&& __sz, _ConstVoidPtr&& __p)
	-> false_type;

	template <class _Alloc, class _SizeType, class _ConstVoidPtr>
	struct __has_allocate_hint
	: integral_constant<bool,
	is_same<
	decltype(_VSTD::__has_allocate_hint_test(declval<_Alloc>(),
	declval<_SizeType>(),
	declval<_ConstVoidPtr>())),
	true_type>::value>
	{
	};

	#else // _LIBCPP_CXX03_LANG

	template <class _Alloc, class _SizeType, class _ConstVoidPtr>
	struct __has_allocate_hint
	: true_type
	{
	};

	#endif // _LIBCPP_CXX03_LANG

	#if !defined(_LIBCPP_CXX03_LANG)

	template <class _Alloc, class _Tp, class ..._Args>
	decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Tp*>(),
	_VSTD::declval<_Args>()...),
	true_type())
	__has_construct_test(_Alloc&& __a, _Tp* __p, _Args&& ...__args);

	template <class _Alloc, class _Pointer, class ..._Args>
	false_type
	__has_construct_test(const _Alloc& __a, _Pointer&& __p, _Args&& ...__args);

	template <class _Alloc, class _Pointer, class ..._Args>
	struct __has_construct
	: integral_constant<bool,
	is_same<
	decltype(_VSTD::__has_construct_test(declval<_Alloc>(),
	declval<_Pointer>(),
	declval<_Args>()...)),
	true_type>::value>
	{
	};

	template <class _Alloc, class _Pointer>
	auto
	__has_destroy_test(_Alloc&& __a, _Pointer&& __p)
	-> decltype(__a.destroy(__p), true_type());

	template <class _Alloc, class _Pointer>
	auto
	__has_destroy_test(const _Alloc& __a, _Pointer&& __p)
	-> false_type;

	template <class _Alloc, class _Pointer>
	struct __has_destroy
	: integral_constant<bool,
	is_same<
	decltype(_VSTD::__has_destroy_test(declval<_Alloc>(),
	declval<_Pointer>())),
	true_type>::value>
	{
	};

	template <class _Alloc>
	auto
	__has_max_size_test(_Alloc&& __a)
	-> decltype(__a.max_size(), true_type());

	template <class _Alloc>
	auto
	__has_max_size_test(const volatile _Alloc& __a)
	-> false_type;

	template <class _Alloc>
	struct __has_max_size
	: integral_constant<bool,
	is_same<
	decltype(_VSTD::__has_max_size_test(declval<_Alloc&>())),
	true_type>::value>
	{
	};

	template <class _Alloc>
	auto
	__has_select_on_container_copy_construction_test(_Alloc&& __a)
	-> decltype(__a.select_on_container_copy_construction(), true_type());

	template <class _Alloc>
	auto
	__has_select_on_container_copy_construction_test(const volatile _Alloc& __a)
	-> false_type;

	template <class _Alloc>
	struct __has_select_on_container_copy_construction
	: integral_constant<bool,
	is_same<
	decltype(_VSTD::__has_select_on_container_copy_construction_test(declval<_Alloc&>())),
	true_type>::value>
	{
	};

	#else // _LIBCPP_CXX03_LANG

	#ifndef _LIBCPP_HAS_NO_VARIADICS

	template <class _Alloc, class _Pointer, class ..._Args>
	struct __has_construct
	: false_type
	{
	};

	#else // _LIBCPP_HAS_NO_VARIADICS

	template <class _Alloc, class _Pointer, class _Args>
	struct __has_construct
	: false_type
	{
	};

	#endif // _LIBCPP_HAS_NO_VARIADICS

	template <class _Alloc, class _Pointer>
	struct __has_destroy
	: false_type
	{
	};

	template <class _Alloc>
	struct __has_max_size
	: true_type
	{
	};

	template <class _Alloc>
	struct __has_select_on_container_copy_construction
	: false_type
	{
	};

	#endif // _LIBCPP_CXX03_LANG

	template <class _Alloc, class _Ptr, bool = __has_difference_type<_Alloc>::value>
	struct __alloc_traits_difference_type
	{
	typedef typename pointer_traits<_Ptr>::difference_type type;
	};

	template <class _Alloc, class _Ptr>
	struct __alloc_traits_difference_type<_Alloc, _Ptr, true>
	{
	typedef typename _Alloc::difference_type type;
	};

	template <class _Alloc>
	struct _LIBCPP_TEMPLATE_VIS allocator_traits
	{
	typedef _Alloc allocator_type;
	typedef typename allocator_type::value_type value_type;

	typedef typename __pointer_type<value_type, allocator_type>::type pointer;
	typedef typename __const_pointer<value_type, pointer, allocator_type>::type const_pointer;
	typedef typename __void_pointer<pointer, allocator_type>::type void_pointer;
	typedef typename __const_void_pointer<pointer, allocator_type>::type const_void_pointer;

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

	typedef typename __propagate_on_container_copy_assignment<allocator_type>::type
	propagate_on_container_copy_assignment;
	typedef typename __propagate_on_container_move_assignment<allocator_type>::type
	propagate_on_container_move_assignment;
	typedef typename __propagate_on_container_swap<allocator_type>::type
	propagate_on_container_swap;
	typedef typename __is_always_equal<allocator_type>::type
	is_always_equal;

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Tp> using rebind_alloc =
	typename __allocator_traits_rebind<allocator_type, _Tp>::type;
	template <class _Tp> using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
	#else // _LIBCPP_CXX03_LANG
	template <class _Tp> struct rebind_alloc
	{typedef typename __allocator_traits_rebind<allocator_type, _Tp>::type other;};
	template <class _Tp> struct rebind_traits
	{typedef allocator_traits<typename rebind_alloc<_Tp>::other> other;};
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
	static pointer allocate(allocator_type& __a, size_type __n)
	{return __a.allocate(__n);}
	_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>());}

	_LIBCPP_INLINE_VISIBILITY
	static void deallocate(allocator_type& __a, pointer __p, size_type __n) _NOEXCEPT
	{__a.deallocate(__p, __n);}

	#ifndef _LIBCPP_HAS_NO_VARIADICS
	template <class _Tp, class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args)
	{__construct(__has_construct<allocator_type, _Tp*, _Args...>(),
	__a, __p, _VSTD::forward<_Args>(__args)...);}
	#else // _LIBCPP_HAS_NO_VARIADICS
	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	static void construct(allocator_type&, _Tp* __p)
	{
	::new ((void*)__p) _Tp();
	}
	template <class _Tp, class _A0>
	_LIBCPP_INLINE_VISIBILITY
	static void construct(allocator_type&, _Tp* __p, const _A0& __a0)
	{
	::new ((void*)__p) _Tp(__a0);
	}
	template <class _Tp, class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	static void construct(allocator_type&, _Tp* __p, const _A0& __a0,
	const _A1& __a1)
	{
	::new ((void*)__p) _Tp(__a0, __a1);
	}
	template <class _Tp, class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	static void construct(allocator_type&, _Tp* __p, const _A0& __a0,
	const _A1& __a1, const _A2& __a2)
	{
	::new ((void*)__p) _Tp(__a0, __a1, __a2);
	}
	#endif // _LIBCPP_HAS_NO_VARIADICS

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	static void destroy(allocator_type& __a, _Tp* __p)
	{__destroy(__has_destroy<allocator_type, _Tp*>(), __a, __p);}

	_LIBCPP_INLINE_VISIBILITY
	static size_type max_size(const allocator_type& __a) _NOEXCEPT
	{return __max_size(__has_max_size<const allocator_type>(), __a);}

	_LIBCPP_INLINE_VISIBILITY
	static allocator_type
	select_on_container_copy_construction(const allocator_type& __a)
	{return __select_on_container_copy_construction(
	__has_select_on_container_copy_construction<const allocator_type>(),
	__a);}

	template <class _Ptr>
	_LIBCPP_INLINE_VISIBILITY
	static
	void
	__construct_forward(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __begin2)
	{
	for (; __begin1 != __end1; ++__begin1, ++__begin2)
	construct(__a, _VSTD::__to_raw_pointer(__begin2), _VSTD::move_if_noexcept(*__begin1));
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	static
	typename enable_if
	<
	(is_same<allocator_type, allocator<_Tp> >::value
	\|\| !__has_construct<allocator_type, _Tp*, _Tp>::value) &&
	is_trivially_move_constructible<_Tp>::value,
	void
	>::type
	__construct_forward(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2)
	{
	ptrdiff_t _Np = __end1 - __begin1;
	if (_Np > 0)
	{
	_VSTD::memcpy(__begin2, __begin1, _Np * sizeof(_Tp));
	__begin2 += _Np;
	}
	}

	template <class _Iter, class _Ptr>
	_LIBCPP_INLINE_VISIBILITY
	static
	void
	__construct_range_forward(allocator_type& __a, _Iter __begin1, _Iter __end1, _Ptr& __begin2)
	{
	for (; __begin1 != __end1; ++__begin1, (void) ++__begin2)
	construct(__a, _VSTD::__to_raw_pointer(__begin2), *__begin1);
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	static
	typename enable_if
	<
	(is_same<allocator_type, allocator<_Tp> >::value
	\|\| !__has_construct<allocator_type, _Tp*, _Tp>::value) &&
	is_trivially_move_constructible<_Tp>::value,
	void
	>::type
	__construct_range_forward(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2)
	{
	typedef typename remove_const<_Tp>::type _Vp;
	ptrdiff_t _Np = __end1 - __begin1;
	if (_Np > 0)
	{
	_VSTD::memcpy(const_cast<_Vp>(__begin2), __begin1, _Np sizeof(_Tp));
	__begin2 += _Np;
	}
	}

	template <class _Ptr>
	_LIBCPP_INLINE_VISIBILITY
	static
	void
	__construct_backward(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __end2)
	{
	while (__end1 != __begin1)
	{
	construct(__a, _VSTD::__to_raw_pointer(__end2-1), _VSTD::move_if_noexcept(*--__end1));
	--__end2;
	}
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	static
	typename enable_if
	<
	(is_same<allocator_type, allocator<_Tp> >::value
	\|\| !__has_construct<allocator_type, _Tp*, _Tp>::value) &&
	is_trivially_move_constructible<_Tp>::value,
	void
	>::type
	__construct_backward(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __end2)
	{
	ptrdiff_t _Np = __end1 - __begin1;
	__end2 -= _Np;
	if (_Np > 0)
	_VSTD::memcpy(__end2, __begin1, _Np * sizeof(_Tp));
	}

	private:

	_LIBCPP_INLINE_VISIBILITY
	static pointer __allocate(allocator_type& __a, size_type __n,
	const_void_pointer __hint, true_type)
	{return __a.allocate(__n, __hint);}
	_LIBCPP_INLINE_VISIBILITY
	static pointer __allocate(allocator_type& __a, size_type __n,
	const_void_pointer, false_type)
	{return __a.allocate(__n);}

	#ifndef _LIBCPP_HAS_NO_VARIADICS
	template <class _Tp, class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	static void __construct(true_type, allocator_type& __a, _Tp* __p, _Args&&... __args)
	{__a.construct(__p, _VSTD::forward<_Args>(__args)...);}
	template <class _Tp, class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	static void __construct(false_type, allocator_type&, _Tp* __p, _Args&&... __args)
	{
	::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...);
	}
	#endif // _LIBCPP_HAS_NO_VARIADICS

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	static void __destroy(true_type, allocator_type& __a, _Tp* __p)
	{__a.destroy(__p);}
	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	static void __destroy(false_type, allocator_type&, _Tp* __p)
	{
	__p->~_Tp();
	}

	_LIBCPP_INLINE_VISIBILITY
	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&) _NOEXCEPT
	{return numeric_limits<size_type>::max() / sizeof(value_type);}

	_LIBCPP_INLINE_VISIBILITY
	static allocator_type
	__select_on_container_copy_construction(true_type, const allocator_type& __a)
	{return __a.select_on_container_copy_construction();}
	_LIBCPP_INLINE_VISIBILITY
	static allocator_type
	__select_on_container_copy_construction(false_type, const allocator_type& __a)
	{return __a;}
	};

	template <class _Traits, class _Tp>
	struct __rebind_alloc_helper
	{
	#ifndef _LIBCPP_CXX03_LANG
	typedef typename _Traits::template rebind_alloc<_Tp> type;
	#else
	typedef typename _Traits::template rebind_alloc<_Tp>::other type;
	#endif
	};

	// allocator

	template <class _Tp>
	class _LIBCPP_TEMPLATE_VIS allocator
	{
	public:
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;
	typedef _Tp* pointer;
	typedef const _Tp* const_pointer;
	typedef _Tp& reference;
	typedef const _Tp& const_reference;
	typedef _Tp value_type;

	typedef true_type propagate_on_container_move_assignment;
	typedef true_type is_always_equal;

	template <class _Up> struct rebind {typedef allocator<_Up> other;};

	- _LIBCPP_INLINE_VISIBILITY allocator() _NOEXCEPT {}
	- template <class _Up> _LIBCPP_INLINE_VISIBILITY allocator(const allocator<_Up>&) _NOEXCEPT {}
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	+ allocator() _NOEXCEPT {}
	+
	+ template <class _Up>
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	+ allocator(const allocator<_Up>&) _NOEXCEPT {}
	+
	_LIBCPP_INLINE_VISIBILITY pointer address(reference __x) const _NOEXCEPT
	{return _VSTD::addressof(__x);}
	_LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT
	{return _VSTD::addressof(__x);}
	_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)"
	" 'n' exceeds maximum supported size");
	- return static_cast<pointer>(_VSTD::__allocate(__n * sizeof(_Tp)));
	+ return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp)));
	}
	_LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT
	- {_VSTD::__libcpp_deallocate((void*)__p);}
	+ {_VSTD::__libcpp_deallocate((void*)__p, __alignof(_Tp));}
	_LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
	{return size_type(~0) / sizeof(_Tp);}
	#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
	template <class _Up, class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	void
	construct(_Up* __p, _Args&&... __args)
	{
	::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);
	}
	#else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
	_LIBCPP_INLINE_VISIBILITY
	void
	construct(pointer __p)
	{
	::new((void*)__p) _Tp();
	}
	# if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)

	template <class _A0>
	_LIBCPP_INLINE_VISIBILITY
	void
	construct(pointer __p, _A0& __a0)
	{
	::new((void*)__p) _Tp(__a0);
	}
	template <class _A0>
	_LIBCPP_INLINE_VISIBILITY
	void
	construct(pointer __p, const _A0& __a0)
	{
	::new((void*)__p) _Tp(__a0);
	}
	# endif // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	void
	construct(pointer __p, _A0& __a0, _A1& __a1)
	{
	::new((void*)__p) _Tp(__a0, __a1);
	}
	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	void
	construct(pointer __p, const _A0& __a0, _A1& __a1)
	{
	::new((void*)__p) _Tp(__a0, __a1);
	}
	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	void
	construct(pointer __p, _A0& __a0, const _A1& __a1)
	{
	::new((void*)__p) _Tp(__a0, __a1);
	}
	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	void
	construct(pointer __p, const _A0& __a0, const _A1& __a1)
	{
	::new((void*)__p) _Tp(__a0, __a1);
	}
	#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
	_LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();}
	};

	template <class _Tp>
	class _LIBCPP_TEMPLATE_VIS allocator<const _Tp>
	{
	public:
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;
	typedef const _Tp* pointer;
	typedef const _Tp* const_pointer;
	typedef const _Tp& reference;
	typedef const _Tp& const_reference;
	typedef const _Tp value_type;

	typedef true_type propagate_on_container_move_assignment;
	typedef true_type is_always_equal;

	template <class _Up> struct rebind {typedef allocator<_Up> other;};

	- _LIBCPP_INLINE_VISIBILITY allocator() _NOEXCEPT {}
	- template <class _Up> _LIBCPP_INLINE_VISIBILITY allocator(const allocator<_Up>&) _NOEXCEPT {}
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	+ allocator() _NOEXCEPT {}
	+
	+ template <class _Up>
	+ _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	+ allocator(const allocator<_Up>&) _NOEXCEPT {}
	+
	_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)
	{
	if (__n > max_size())
	__throw_length_error("allocator<const T>::allocate(size_t n)"
	" 'n' exceeds maximum supported size");
	- return static_cast<pointer>(_VSTD::__allocate(__n * sizeof(_Tp)));
	+ return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp)));
	}
	_LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT
	- {_VSTD::__libcpp_deallocate((void) const_cast<_Tp >(__p));}
	+ {_VSTD::__libcpp_deallocate((void) const_cast<_Tp >(__p), __alignof(_Tp));}
	_LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
	{return size_type(~0) / sizeof(_Tp);}
	#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
	template <class _Up, class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	void
	construct(_Up* __p, _Args&&... __args)
	{
	::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);
	}
	#else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
	_LIBCPP_INLINE_VISIBILITY
	void
	construct(pointer __p)
	{
	::new((void) const_cast<_Tp >(__p)) _Tp();
	}
	# if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)

	template <class _A0>
	_LIBCPP_INLINE_VISIBILITY
	void
	construct(pointer __p, _A0& __a0)
	{
	::new((void) const_cast<_Tp >(__p)) _Tp(__a0);
	}
	template <class _A0>
	_LIBCPP_INLINE_VISIBILITY
	void
	construct(pointer __p, const _A0& __a0)
	{
	::new((void) const_cast<_Tp >(__p)) _Tp(__a0);
	}
	# endif // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	void
	construct(pointer __p, _A0& __a0, _A1& __a1)
	{
	::new((void) const_cast<_Tp >(__p)) _Tp(__a0, __a1);
	}
	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	void
	construct(pointer __p, const _A0& __a0, _A1& __a1)
	{
	::new((void) const_cast<_Tp >(__p)) _Tp(__a0, __a1);
	}
	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	void
	construct(pointer __p, _A0& __a0, const _A1& __a1)
	{
	::new((void) const_cast<_Tp >(__p)) _Tp(__a0, __a1);
	}
	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	void
	construct(pointer __p, const _A0& __a0, const _A1& __a1)
	{
	::new((void) const_cast<_Tp >(__p)) _Tp(__a0, __a1);
	}
	#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
	_LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();}
	};

	template <class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	bool operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return true;}

	template <class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return false;}

	template <class _OutputIterator, class _Tp>
	class _LIBCPP_TEMPLATE_VIS raw_storage_iterator
	: public iterator<output_iterator_tag,
	_Tp, // purposefully not C++03
	ptrdiff_t, // purposefully not C++03
	_Tp*, // purposefully not C++03
	raw_storage_iterator<_OutputIterator, _Tp>&> // purposefully not C++03
	{
	private:
	_OutputIterator __x_;
	public:
	_LIBCPP_INLINE_VISIBILITY explicit raw_storage_iterator(_OutputIterator __x) : __x_(__x) {}
	_LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator() {return this;}
	_LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(const _Tp& __element)
	{::new(&__x_) _Tp(__element); return this;}
	#if _LIBCPP_STD_VER >= 14
	_LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(_Tp&& __element)
	{::new(&__x_) _Tp(_VSTD::move(__element)); return this;}
	#endif
	_LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator++() {++__x_; return *this;}
	_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_; }
	#endif
	};

	template <class _Tp>
	+_LIBCPP_NO_CFI
	pair<_Tp*, ptrdiff_t>
	get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT
	{
	pair<_Tp*, ptrdiff_t> __r(0, 0);
	const ptrdiff_t __m = (~ptrdiff_t(0) ^
	ptrdiff_t(ptrdiff_t(1) << (sizeof(ptrdiff_t) * __CHAR_BIT__ - 1)))
	/ sizeof(_Tp);
	if (__n > __m)
	__n = __m;
	while (__n > 0)
	{
	+#if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
	+ if (__is_overaligned_for_new(__alignof(_Tp)))
	+ {
	+ std::align_val_t __al =
	+ std::align_val_t(std::alignment_of<_Tp>::value);
	+ __r.first = static_cast<_Tp*>(::operator new(
	+ __n * sizeof(_Tp), __al, nothrow));
	+ } else {
	+ __r.first = static_cast<_Tp*>(::operator new(
	+ __n * sizeof(_Tp), nothrow));
	+ }
	+#else
	+ if (__is_overaligned_for_new(__alignof(_Tp)))
	+ {
	+ // Since aligned operator new is unavailable, return an empty
	+ // buffer rather than one with invalid alignment.
	+ return __r;
	+ }
	+
	__r.first = static_cast<_Tp>(::operator new(__n sizeof(_Tp), nothrow));
	+#endif
	+
	if (__r.first)
	{
	__r.second = __n;
	break;
	}
	__n /= 2;
	}
	return __r;
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	-void return_temporary_buffer(_Tp* __p) _NOEXCEPT {::operator delete(__p);}
	+void return_temporary_buffer(_Tp* __p) _NOEXCEPT
	+{
	+ _VSTD::__libcpp_deallocate((void*)__p, __alignof(_Tp));
	+}

	#if _LIBCPP_STD_VER <= 14 \|\| defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
	template <class _Tp>
	struct auto_ptr_ref
	{
	_Tp* __ptr_;
	};

	template<class _Tp>
	class _LIBCPP_TEMPLATE_VIS auto_ptr
	{
	private:
	_Tp* __ptr_;
	public:
	typedef _Tp element_type;

	_LIBCPP_INLINE_VISIBILITY explicit auto_ptr(_Tp* __p = 0) throw() : __ptr_(__p) {}
	_LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr& __p) throw() : __ptr_(__p.release()) {}
	template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr<_Up>& __p) throw()
	: __ptr_(__p.release()) {}
	_LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr& __p) throw()
	{reset(__p.release()); return *this;}
	template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr<_Up>& __p) throw()
	{reset(__p.release()); return *this;}
	_LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr_ref<_Tp> __p) throw()
	{reset(__p.__ptr_); return *this;}
	_LIBCPP_INLINE_VISIBILITY ~auto_ptr() throw() {delete __ptr_;}

	_LIBCPP_INLINE_VISIBILITY _Tp& operator*() const throw()
	{return *__ptr_;}
	_LIBCPP_INLINE_VISIBILITY _Tp* operator->() const throw() {return __ptr_;}
	_LIBCPP_INLINE_VISIBILITY _Tp* get() const throw() {return __ptr_;}
	_LIBCPP_INLINE_VISIBILITY _Tp* release() throw()
	{
	_Tp* __t = __ptr_;
	__ptr_ = 0;
	return __t;
	}
	_LIBCPP_INLINE_VISIBILITY void reset(_Tp* __p = 0) throw()
	{
	if (__ptr_ != __p)
	delete __ptr_;
	__ptr_ = __p;
	}

	_LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr_ref<_Tp> __p) throw() : __ptr_(__p.__ptr_) {}
	template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr_ref<_Up>() throw()
	{auto_ptr_ref<_Up> __t; __t.__ptr_ = release(); return __t;}
	template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr<_Up>() throw()
	{return auto_ptr<_Up>(release());}
	};

	template <>
	class _LIBCPP_TEMPLATE_VIS auto_ptr<void>
	{
	public:
	typedef void element_type;
	};
	#endif

	template <class _Tp, int _Idx,
	bool _CanBeEmptyBase =
	is_empty<_Tp>::value && !__libcpp_is_final<_Tp>::value>
	struct __compressed_pair_elem {
	typedef _Tp _ParamT;
	typedef _Tp& reference;
	typedef const _Tp& const_reference;

	#ifndef _LIBCPP_CXX03_LANG
	_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)){};

	template <class... _Args, size_t... _Indexes>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	__compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args,
	__tuple_indices<_Indexes...>)
	: __value_(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {}
	#else
	_LIBCPP_INLINE_VISIBILITY __compressed_pair_elem() : __value_() {}
	_LIBCPP_INLINE_VISIBILITY
	__compressed_pair_elem(_ParamT __p) : __value_(std::forward<_ParamT>(__p)) {}
	#endif

	_LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return __value_; }
	_LIBCPP_INLINE_VISIBILITY
	const_reference __get() const _NOEXCEPT { return __value_; }

	private:
	_Tp __value_;
	};

	template <class _Tp, int _Idx>
	struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp {
	typedef _Tp _ParamT;
	typedef _Tp& reference;
	typedef const _Tp& const_reference;
	typedef _Tp __value_type;

	#ifndef _LIBCPP_CXX03_LANG
	_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)){};

	template <class... _Args, size_t... _Indexes>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	__compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args,
	__tuple_indices<_Indexes...>)
	: __value_type(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {}
	#else
	_LIBCPP_INLINE_VISIBILITY __compressed_pair_elem() : __value_type() {}
	_LIBCPP_INLINE_VISIBILITY
	__compressed_pair_elem(_ParamT __p)
	: __value_type(std::forward<_ParamT>(__p)) {}
	#endif

	_LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return *this; }
	_LIBCPP_INLINE_VISIBILITY
	const_reference __get() const _NOEXCEPT { return *this; }
	};

	// Tag used to construct the second element of the compressed pair.
	struct __second_tag {};

	template <class _T1, class _T2>
	class __compressed_pair : private __compressed_pair_elem<_T1, 0>,
	private __compressed_pair_elem<_T2, 1> {
	typedef __compressed_pair_elem<_T1, 0> _Base1;
	typedef __compressed_pair_elem<_T2, 1> _Base2;

	// NOTE: This static assert should never fire because __compressed_pair
	// is almost never used in a scenario where it's possible for T1 == T2.
	// (The exception is std::function where it is possible that the function
	// object and the allocator have the same type).
	static_assert((!is_same<_T1, _T2>::value),
	"__compressed_pair cannot be instantated when T1 and T2 are the same type; "
	"The current implementation is NOT ABI-compatible with the previous "
	"implementation for this configuration");

	public:
	#ifndef _LIBCPP_CXX03_LANG
	template <bool _Dummy = true,
	class = typename enable_if<
	__dependent_type<is_default_constructible<_T1>, _Dummy>::value &&
	__dependent_type<is_default_constructible<_T2>, _Dummy>::value
	>::type
	>
	_LIBCPP_INLINE_VISIBILITY
	constexpr __compressed_pair() {}

	template <class _Tp, typename enable_if<!is_same<typename decay<_Tp>::type,
	__compressed_pair>::value,
	bool>::type = true>
	_LIBCPP_INLINE_VISIBILITY constexpr explicit
	__compressed_pair(_Tp&& __t)
	: _Base1(std::forward<_Tp>(__t)), _Base2() {}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY constexpr
	__compressed_pair(__second_tag, _Tp&& __t)
	: _Base1(), _Base2(std::forward<_Tp>(__t)) {}

	template <class _U1, class _U2>
	_LIBCPP_INLINE_VISIBILITY constexpr
	__compressed_pair(_U1&& __t1, _U2&& __t2)
	: _Base1(std::forward<_U1>(__t1)), _Base2(std::forward<_U2>(__t2)) {}

	template <class... _Args1, class... _Args2>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
	__compressed_pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,
	tuple<_Args2...> __second_args)
	: _Base1(__pc, _VSTD::move(__first_args),
	typename __make_tuple_indices<sizeof...(_Args1)>::type()),
	_Base2(__pc, _VSTD::move(__second_args),
	typename __make_tuple_indices<sizeof...(_Args2)>::type()) {}

	#else
	_LIBCPP_INLINE_VISIBILITY
	__compressed_pair() {}

	_LIBCPP_INLINE_VISIBILITY explicit
	__compressed_pair(_T1 __t1) : _Base1(_VSTD::forward<_T1>(__t1)) {}

	_LIBCPP_INLINE_VISIBILITY
	__compressed_pair(__second_tag, _T2 __t2)
	: _Base1(), _Base2(_VSTD::forward<_T2>(__t2)) {}

	_LIBCPP_INLINE_VISIBILITY
	__compressed_pair(_T1 __t1, _T2 __t2)
	: _Base1(_VSTD::forward<_T1>(__t1)), _Base2(_VSTD::forward<_T2>(__t2)) {}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	typename _Base1::reference first() _NOEXCEPT {
	return static_cast<_Base1&>(*this).__get();
	}

	_LIBCPP_INLINE_VISIBILITY
	typename _Base1::const_reference first() const _NOEXCEPT {
	return static_cast<_Base1 const&>(*this).__get();
	}

	_LIBCPP_INLINE_VISIBILITY
	typename _Base2::reference second() _NOEXCEPT {
	return static_cast<_Base2&>(*this).__get();
	}

	_LIBCPP_INLINE_VISIBILITY
	typename _Base2::const_reference second() const _NOEXCEPT {
	return static_cast<_Base2 const&>(*this).__get();
	}

	_LIBCPP_INLINE_VISIBILITY
	void swap(__compressed_pair& __x)
	_NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
	__is_nothrow_swappable<_T2>::value)
	{
	using std::swap;
	swap(first(), __x.first());
	swap(second(), __x.second());
	}
	};

	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY
	void swap(__compressed_pair<_T1, _T2>& __x, __compressed_pair<_T1, _T2>& __y)
	_NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
	__is_nothrow_swappable<_T2>::value) {
	__x.swap(__y);
	}

	// default_delete

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS default_delete {
	static_assert(!is_function<_Tp>::value,
	"default_delete cannot be instantiated for function types");
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY constexpr default_delete() noexcept = default;
	#else
	_LIBCPP_INLINE_VISIBILITY default_delete() {}
	#endif
	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY
	default_delete(const default_delete<_Up>&,
	typename enable_if<is_convertible<_Up, _Tp>::value>::type* =
	0) _NOEXCEPT {}

	_LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __ptr) const _NOEXCEPT {
	static_assert(sizeof(_Tp) > 0,
	"default_delete can not delete incomplete type");
	static_assert(!is_void<_Tp>::value,
	"default_delete can not delete incomplete type");
	delete __ptr;
	}
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS default_delete<_Tp[]> {
	private:
	template <class _Up>
	struct _EnableIfConvertible
	: enable_if<is_convertible<_Up()[], _Tp()[]>::value> {};

	public:
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY constexpr default_delete() noexcept = default;
	#else
	_LIBCPP_INLINE_VISIBILITY default_delete() {}
	#endif

	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY
	default_delete(const default_delete<_Up[]>&,
	typename _EnableIfConvertible<_Up>::type* = 0) _NOEXCEPT {}

	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY
	typename _EnableIfConvertible<_Up>::type
	operator()(_Up* __ptr) const _NOEXCEPT {
	static_assert(sizeof(_Tp) > 0,
	"default_delete can not delete incomplete type");
	static_assert(!is_void<_Tp>::value,
	"default_delete can not delete void type");
	delete[] __ptr;
	}
	};



	#ifndef _LIBCPP_CXX03_LANG
	template <class _Deleter>
	struct __unique_ptr_deleter_sfinae {
	static_assert(!is_reference<_Deleter>::value, "incorrect specialization");
	typedef const _Deleter& __lval_ref_type;
	typedef _Deleter&& __good_rval_ref_type;
	typedef true_type __enable_rval_overload;
	};

	template <class _Deleter>
	struct __unique_ptr_deleter_sfinae<_Deleter const&> {
	typedef const _Deleter& __lval_ref_type;
	typedef const _Deleter&& __bad_rval_ref_type;
	typedef false_type __enable_rval_overload;
	};

	template <class _Deleter>
	struct __unique_ptr_deleter_sfinae<_Deleter&> {
	typedef _Deleter& __lval_ref_type;
	typedef _Deleter&& __bad_rval_ref_type;
	typedef false_type __enable_rval_overload;
	};
	#endif // !defined(_LIBCPP_CXX03_LANG)

	template <class _Tp, class _Dp = default_delete<_Tp> >
	class _LIBCPP_TEMPLATE_VIS unique_ptr {
	public:
	typedef _Tp element_type;
	typedef _Dp deleter_type;
	typedef typename __pointer_type<_Tp, deleter_type>::type pointer;

	static_assert(!is_rvalue_reference<deleter_type>::value,
	"the specified deleter type cannot be an rvalue reference");

	private:
	__compressed_pair<pointer, deleter_type> __ptr_;

	struct __nat { int __for_bool_; };

	#ifndef _LIBCPP_CXX03_LANG
	typedef __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE;

	template <bool _Dummy>
	using _LValRefType =
	typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type;

	template <bool _Dummy>
	using _GoodRValRefType =
	typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type;

	template <bool _Dummy>
	using _BadRValRefType =
	typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type;

	template <bool _Dummy, class _Deleter = typename __dependent_type<
	__identity<deleter_type>, _Dummy>::type>
	using _EnableIfDeleterDefaultConstructible =
	typename enable_if<is_default_constructible<_Deleter>::value &&
	!is_pointer<_Deleter>::value>::type;

	template <class _ArgType>
	using _EnableIfDeleterConstructible =
	typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type;

	template <class _UPtr, class _Up>
	using _EnableIfMoveConvertible = typename enable_if<
	is_convertible<typename _UPtr::pointer, pointer>::value &&
	!is_array<_Up>::value
	>::type;

	template <class _UDel>
	using _EnableIfDeleterConvertible = typename enable_if<
	(is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) \|\|
	(!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value)
	>::type;

	template <class _UDel>
	using _EnableIfDeleterAssignable = typename enable_if<
	is_assignable<_Dp&, _UDel&&>::value
	>::type;

	public:
	template <bool _Dummy = true,
	class = _EnableIfDeleterDefaultConstructible<_Dummy>>
	_LIBCPP_INLINE_VISIBILITY
	constexpr unique_ptr() noexcept : __ptr_(pointer()) {}

	template <bool _Dummy = true,
	class = _EnableIfDeleterDefaultConstructible<_Dummy>>
	_LIBCPP_INLINE_VISIBILITY
	constexpr unique_ptr(nullptr_t) noexcept : __ptr_(pointer()) {}

	template <bool _Dummy = true,
	class = _EnableIfDeleterDefaultConstructible<_Dummy>>
	_LIBCPP_INLINE_VISIBILITY
	explicit unique_ptr(pointer __p) noexcept : __ptr_(__p) {}

	template <bool _Dummy = true,
	class = _EnableIfDeleterConstructible<_LValRefType<_Dummy>>>
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(pointer __p, _LValRefType<_Dummy> __d) noexcept
	: __ptr_(__p, __d) {}

	template <bool _Dummy = true,
	class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy>>>
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(pointer __p, _GoodRValRefType<_Dummy> __d) noexcept
	: __ptr_(__p, _VSTD::move(__d)) {
	static_assert(!is_reference<deleter_type>::value,
	"rvalue deleter bound to reference");
	}

	template <bool _Dummy = true,
	class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy>>>
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(pointer __p, _BadRValRefType<_Dummy> __d) = delete;

	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(unique_ptr&& __u) noexcept
	: __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {
	}

	template <class _Up, class _Ep,
	class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
	class = _EnableIfDeleterConvertible<_Ep>
	>
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
	: __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {}

	#if _LIBCPP_STD_VER <= 14 \|\| defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(auto_ptr<_Up>&& __p,
	typename enable_if<is_convertible<_Up, _Tp>::value &&
	is_same<_Dp, default_delete<_Tp>>::value,
	__nat>::type = __nat()) _NOEXCEPT
	: __ptr_(__p.release()) {}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
	reset(__u.release());
	__ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
	return *this;
	}

	template <class _Up, class _Ep,
	class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
	class = _EnableIfDeleterAssignable<_Ep>
	>
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
	reset(__u.release());
	__ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
	return *this;
	}

	#else // _LIBCPP_CXX03_LANG
	private:
	unique_ptr(unique_ptr&);
	template <class _Up, class _Ep> unique_ptr(unique_ptr<_Up, _Ep>&);

	unique_ptr& operator=(unique_ptr&);
	template <class _Up, class _Ep> unique_ptr& operator=(unique_ptr<_Up, _Ep>&);

	public:
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr() : __ptr_(pointer())
	{
	static_assert(!is_pointer<deleter_type>::value,
	"unique_ptr constructed with null function pointer deleter");
	static_assert(is_default_constructible<deleter_type>::value,
	"unique_ptr::deleter_type is not default constructible");
	}
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(nullptr_t) : __ptr_(pointer())
	{
	static_assert(!is_pointer<deleter_type>::value,
	"unique_ptr constructed with null function pointer deleter");
	}
	_LIBCPP_INLINE_VISIBILITY
	explicit unique_ptr(pointer __p)
	: __ptr_(_VSTD::move(__p)) {
	static_assert(!is_pointer<deleter_type>::value,
	"unique_ptr constructed with null function pointer deleter");
	}

	_LIBCPP_INLINE_VISIBILITY
	operator __rv<unique_ptr>() {
	return __rv<unique_ptr>(*this);
	}

	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(__rv<unique_ptr> __u)
	: __ptr_(__u->release(),
	_VSTD::forward<deleter_type>(__u->get_deleter())) {}

	template <class _Up, class _Ep>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<
	!is_array<_Up>::value &&
	is_convertible<typename unique_ptr<_Up, _Ep>::pointer,
	pointer>::value &&
	is_assignable<deleter_type&, _Ep&>::value,
	unique_ptr&>::type
	operator=(unique_ptr<_Up, _Ep> __u) {
	reset(__u.release());
	__ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(pointer __p, deleter_type __d)
	: __ptr_(_VSTD::move(__p), _VSTD::move(__d)) {}
	#endif // _LIBCPP_CXX03_LANG

	#if _LIBCPP_STD_VER <= 14 \|\| defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<is_convertible<_Up, _Tp>::value &&
	is_same<_Dp, default_delete<_Tp> >::value,
	unique_ptr&>::type
	operator=(auto_ptr<_Up> __p) {
	reset(__p.release());
	return *this;
	}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	~unique_ptr() { reset(); }

	_LIBCPP_INLINE_VISIBILITY
	unique_ptr& operator=(nullptr_t) _NOEXCEPT {
	reset();
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	typename add_lvalue_reference<_Tp>::type
	operator*() const {
	return *__ptr_.first();
	}
	_LIBCPP_INLINE_VISIBILITY
	pointer operator->() const _NOEXCEPT {
	return __ptr_.first();
	}
	_LIBCPP_INLINE_VISIBILITY
	pointer get() const _NOEXCEPT {
	return __ptr_.first();
	}
	_LIBCPP_INLINE_VISIBILITY
	deleter_type& get_deleter() _NOEXCEPT {
	return __ptr_.second();
	}
	_LIBCPP_INLINE_VISIBILITY
	const deleter_type& get_deleter() const _NOEXCEPT {
	return __ptr_.second();
	}
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {
	return __ptr_.first() != nullptr;
	}

	_LIBCPP_INLINE_VISIBILITY
	pointer release() _NOEXCEPT {
	pointer __t = __ptr_.first();
	__ptr_.first() = pointer();
	return __t;
	}

	_LIBCPP_INLINE_VISIBILITY
	void reset(pointer __p = pointer()) _NOEXCEPT {
	pointer __tmp = __ptr_.first();
	__ptr_.first() = __p;
	if (__tmp)
	__ptr_.second()(__tmp);
	}

	_LIBCPP_INLINE_VISIBILITY
	void swap(unique_ptr& __u) _NOEXCEPT {
	__ptr_.swap(__u.__ptr_);
	}
	};


	template <class _Tp, class _Dp>
	class _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp> {
	public:
	typedef _Tp element_type;
	typedef _Dp deleter_type;
	typedef typename __pointer_type<_Tp, deleter_type>::type pointer;

	private:
	__compressed_pair<pointer, deleter_type> __ptr_;

	template <class _From>
	struct _CheckArrayPointerConversion : is_same<_From, pointer> {};

	template <class _FromElem>
	struct _CheckArrayPointerConversion<_FromElem*>
	: integral_constant<bool,
	is_same<_FromElem*, pointer>::value \|\|
	(is_same<pointer, element_type*>::value &&
	is_convertible<_FromElem()[], element_type()[]>::value)
	>
	{};

	#ifndef _LIBCPP_CXX03_LANG
	typedef __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE;

	template <bool _Dummy>
	using _LValRefType =
	typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type;

	template <bool _Dummy>
	using _GoodRValRefType =
	typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type;

	template <bool _Dummy>
	using _BadRValRefType =
	typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type;

	template <bool _Dummy, class _Deleter = typename __dependent_type<
	__identity<deleter_type>, _Dummy>::type>
	using _EnableIfDeleterDefaultConstructible =
	typename enable_if<is_default_constructible<_Deleter>::value &&
	!is_pointer<_Deleter>::value>::type;

	template <class _ArgType>
	using _EnableIfDeleterConstructible =
	typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type;

	template <class _Pp>
	using _EnableIfPointerConvertible = typename enable_if<
	_CheckArrayPointerConversion<_Pp>::value
	>::type;

	template <class _UPtr, class _Up,
	class _ElemT = typename _UPtr::element_type>
	using _EnableIfMoveConvertible = typename enable_if<
	is_array<_Up>::value &&
	is_same<pointer, element_type*>::value &&
	is_same<typename _UPtr::pointer, _ElemT*>::value &&
	is_convertible<_ElemT()[], element_type()[]>::value
	>::type;

	template <class _UDel>
	using _EnableIfDeleterConvertible = typename enable_if<
	(is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) \|\|
	(!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value)
	>::type;

	template <class _UDel>
	using _EnableIfDeleterAssignable = typename enable_if<
	is_assignable<_Dp&, _UDel&&>::value
	>::type;

	public:
	template <bool _Dummy = true,
	class = _EnableIfDeleterDefaultConstructible<_Dummy>>
	_LIBCPP_INLINE_VISIBILITY
	constexpr unique_ptr() noexcept : __ptr_(pointer()) {}

	template <bool _Dummy = true,
	class = _EnableIfDeleterDefaultConstructible<_Dummy>>
	_LIBCPP_INLINE_VISIBILITY
	constexpr unique_ptr(nullptr_t) noexcept : __ptr_(pointer()) {}

	template <class _Pp, bool _Dummy = true,
	class = _EnableIfDeleterDefaultConstructible<_Dummy>,
	class = _EnableIfPointerConvertible<_Pp>>
	_LIBCPP_INLINE_VISIBILITY
	explicit unique_ptr(_Pp __p) noexcept
	: __ptr_(__p) {}

	template <class _Pp, bool _Dummy = true,
	class = _EnableIfDeleterConstructible<_LValRefType<_Dummy>>,
	class = _EnableIfPointerConvertible<_Pp>>
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(_Pp __p, _LValRefType<_Dummy> __d) noexcept
	: __ptr_(__p, __d) {}

	template <bool _Dummy = true,
	class = _EnableIfDeleterConstructible<_LValRefType<_Dummy>>>
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(nullptr_t, _LValRefType<_Dummy> __d) noexcept
	: __ptr_(nullptr, __d) {}

	template <class _Pp, bool _Dummy = true,
	class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy>>,
	class = _EnableIfPointerConvertible<_Pp>>
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(_Pp __p, _GoodRValRefType<_Dummy> __d) noexcept
	: __ptr_(__p, _VSTD::move(__d)) {
	static_assert(!is_reference<deleter_type>::value,
	"rvalue deleter bound to reference");
	}

	template <bool _Dummy = true,
	class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy>>>
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(nullptr_t, _GoodRValRefType<_Dummy> __d) noexcept
	: __ptr_(nullptr, _VSTD::move(__d)) {
	static_assert(!is_reference<deleter_type>::value,
	"rvalue deleter bound to reference");
	}

	template <class _Pp, bool _Dummy = true,
	class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy>>,
	class = _EnableIfPointerConvertible<_Pp>>
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(_Pp __p, _BadRValRefType<_Dummy> __d) = delete;

	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(unique_ptr&& __u) noexcept
	: __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {
	}

	_LIBCPP_INLINE_VISIBILITY
	unique_ptr& operator=(unique_ptr&& __u) noexcept {
	reset(__u.release());
	__ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
	return *this;
	}

	template <class _Up, class _Ep,
	class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
	class = _EnableIfDeleterConvertible<_Ep>
	>
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
	: __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {
	}

	template <class _Up, class _Ep,
	class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
	class = _EnableIfDeleterAssignable<_Ep>
	>
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr&
	operator=(unique_ptr<_Up, _Ep>&& __u) noexcept {
	reset(__u.release());
	__ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
	return *this;
	}

	#else // _LIBCPP_CXX03_LANG
	private:
	template <class _Up> explicit unique_ptr(_Up);

	unique_ptr(unique_ptr&);
	template <class _Up> unique_ptr(unique_ptr<_Up>&);

	unique_ptr& operator=(unique_ptr&);
	template <class _Up> unique_ptr& operator=(unique_ptr<_Up>&);

	template <class _Up>
	unique_ptr(_Up __u,
	typename conditional<
	is_reference<deleter_type>::value, deleter_type,
	typename add_lvalue_reference<const deleter_type>::type>::type,
	typename enable_if<is_convertible<_Up, pointer>::value,
	__nat>::type = __nat());
	public:
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr() : __ptr_(pointer()) {
	static_assert(!is_pointer<deleter_type>::value,
	"unique_ptr constructed with null function pointer deleter");
	}
	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(nullptr_t) : __ptr_(pointer()) {
	static_assert(!is_pointer<deleter_type>::value,
	"unique_ptr constructed with null function pointer deleter");
	}

	_LIBCPP_INLINE_VISIBILITY
	explicit unique_ptr(pointer __p) : __ptr_(__p) {
	static_assert(!is_pointer<deleter_type>::value,
	"unique_ptr constructed with null function pointer deleter");
	}

	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(pointer __p, deleter_type __d)
	: __ptr_(__p, _VSTD::forward<deleter_type>(__d)) {}

	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(nullptr_t, deleter_type __d)
	: __ptr_(pointer(), _VSTD::forward<deleter_type>(__d)) {}

	_LIBCPP_INLINE_VISIBILITY
	operator __rv<unique_ptr>() {
	return __rv<unique_ptr>(*this);
	}

	_LIBCPP_INLINE_VISIBILITY
	unique_ptr(__rv<unique_ptr> __u)
	: __ptr_(__u->release(),
	_VSTD::forward<deleter_type>(__u->get_deleter())) {}

	_LIBCPP_INLINE_VISIBILITY
	unique_ptr& operator=(__rv<unique_ptr> __u) {
	reset(__u->release());
	__ptr_.second() = _VSTD::forward<deleter_type>(__u->get_deleter());
	return *this;
	}

	#endif // _LIBCPP_CXX03_LANG

	public:
	_LIBCPP_INLINE_VISIBILITY
	~unique_ptr() { reset(); }

	_LIBCPP_INLINE_VISIBILITY
	unique_ptr& operator=(nullptr_t) _NOEXCEPT {
	reset();
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	typename add_lvalue_reference<_Tp>::type
	operator[](size_t __i) const {
	return __ptr_.first()[__i];
	}
	_LIBCPP_INLINE_VISIBILITY
	pointer get() const _NOEXCEPT {
	return __ptr_.first();
	}

	_LIBCPP_INLINE_VISIBILITY
	deleter_type& get_deleter() _NOEXCEPT {
	return __ptr_.second();
	}

	_LIBCPP_INLINE_VISIBILITY
	const deleter_type& get_deleter() const _NOEXCEPT {
	return __ptr_.second();
	}
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {
	return __ptr_.first() != nullptr;
	}

	_LIBCPP_INLINE_VISIBILITY
	pointer release() _NOEXCEPT {
	pointer __t = __ptr_.first();
	__ptr_.first() = pointer();
	return __t;
	}

	template <class _Pp>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<
	_CheckArrayPointerConversion<_Pp>::value
	>::type
	reset(_Pp __p) _NOEXCEPT {
	pointer __tmp = __ptr_.first();
	__ptr_.first() = __p;
	if (__tmp)
	__ptr_.second()(__tmp);
	}

	_LIBCPP_INLINE_VISIBILITY
	void reset(nullptr_t = nullptr) _NOEXCEPT {
	pointer __tmp = __ptr_.first();
	__ptr_.first() = nullptr;
	if (__tmp)
	__ptr_.second()(__tmp);
	}

	_LIBCPP_INLINE_VISIBILITY
	void swap(unique_ptr& __u) _NOEXCEPT {
	__ptr_.swap(__u.__ptr_);
	}

	};

	template <class _Tp, class _Dp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if<
	__is_swappable<_Dp>::value,
	void
	>::type
	swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) _NOEXCEPT {__x.swap(__y);}

	template <class _T1, class _D1, class _T2, class _D2>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __x.get() == __y.get();}

	template <class _T1, class _D1, class _T2, class _D2>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x == __y);}

	template <class _T1, class _D1, class _T2, class _D2>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator< (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y)
	{
	typedef typename unique_ptr<_T1, _D1>::pointer _P1;
	typedef typename unique_ptr<_T2, _D2>::pointer _P2;
	typedef typename common_type<_P1, _P2>::type _Vp;
	return less<_Vp>()(__x.get(), __y.get());
	}

	template <class _T1, class _D1, class _T2, class _D2>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator> (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __y < __x;}

	template <class _T1, class _D1, class _T2, class _D2>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__y < __x);}

	template <class _T1, class _D1, class _T2, class _D2>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x < __y);}

	template <class _T1, class _D1>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT
	{
	return !__x;
	}

	template <class _T1, class _D1>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT
	{
	return !__x;
	}

	template <class _T1, class _D1>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT
	{
	return static_cast<bool>(__x);
	}

	template <class _T1, class _D1>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT
	{
	return static_cast<bool>(__x);
	}

	template <class _T1, class _D1>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<(const unique_ptr<_T1, _D1>& __x, nullptr_t)
	{
	typedef typename unique_ptr<_T1, _D1>::pointer _P1;
	return less<_P1>()(__x.get(), nullptr);
	}

	template <class _T1, class _D1>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<(nullptr_t, const unique_ptr<_T1, _D1>& __x)
	{
	typedef typename unique_ptr<_T1, _D1>::pointer _P1;
	return less<_P1>()(nullptr, __x.get());
	}

	template <class _T1, class _D1>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>(const unique_ptr<_T1, _D1>& __x, nullptr_t)
	{
	return nullptr < __x;
	}

	template <class _T1, class _D1>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>(nullptr_t, const unique_ptr<_T1, _D1>& __x)
	{
	return __x < nullptr;
	}

	template <class _T1, class _D1>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const unique_ptr<_T1, _D1>& __x, nullptr_t)
	{
	return !(nullptr < __x);
	}

	template <class _T1, class _D1>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(nullptr_t, const unique_ptr<_T1, _D1>& __x)
	{
	return !(__x < nullptr);
	}

	template <class _T1, class _D1>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const unique_ptr<_T1, _D1>& __x, nullptr_t)
	{
	return !(__x < nullptr);
	}

	template <class _T1, class _D1>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __x)
	{
	return !(nullptr < __x);
	}

	#ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Tp, class _Dp>
	inline _LIBCPP_INLINE_VISIBILITY
	unique_ptr<_Tp, _Dp>
	move(unique_ptr<_Tp, _Dp>& __t)
	{
	return unique_ptr<_Tp, _Dp>(__rv<unique_ptr<_Tp, _Dp> >(__t));
	}

	#endif

	#if _LIBCPP_STD_VER > 11

	template<class _Tp>
	struct __unique_if
	{
	typedef unique_ptr<_Tp> __unique_single;
	};

	template<class _Tp>
	struct __unique_if<_Tp[]>
	{
	typedef unique_ptr<_Tp[]> __unique_array_unknown_bound;
	};

	template<class _Tp, size_t _Np>
	struct __unique_if<_Tp[_Np]>
	{
	typedef void __unique_array_known_bound;
	};

	template<class _Tp, class... _Args>
	inline _LIBCPP_INLINE_VISIBILITY
	typename __unique_if<_Tp>::__unique_single
	make_unique(_Args&&... __args)
	{
	return unique_ptr<_Tp>(new _Tp(_VSTD::forward<_Args>(__args)...));
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename __unique_if<_Tp>::__unique_array_unknown_bound
	make_unique(size_t __n)
	{
	typedef typename remove_extent<_Tp>::type _Up;
	return unique_ptr<_Tp>(new _Up[__n]());
	}

	template<class _Tp, class... _Args>
	typename __unique_if<_Tp>::__unique_array_known_bound
	make_unique(_Args&&...) = delete;

	#endif // _LIBCPP_STD_VER > 11

	template <class _Tp, class _Dp>
	#ifdef _LIBCPP_CXX03_LANG
	struct _LIBCPP_TEMPLATE_VIS hash<unique_ptr<_Tp, _Dp> >
	#else
	struct _LIBCPP_TEMPLATE_VIS hash<__enable_hash_helper<
	unique_ptr<_Tp, _Dp>, typename unique_ptr<_Tp, _Dp>::pointer>>
	#endif
	{
	typedef unique_ptr<_Tp, _Dp> argument_type;
	typedef size_t result_type;
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(const argument_type& __ptr) const
	{
	typedef typename argument_type::pointer pointer;
	return hash<pointer>()(__ptr.get());
	}
	};

	struct __destruct_n
	{
	private:
	size_t __size_;

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY void __process(_Tp* __p, false_type) _NOEXCEPT
	{for (size_t __i = 0; __i < __size_; ++__i, ++__p) __p->~_Tp();}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY void __process(_Tp*, true_type) _NOEXCEPT
	{}

	_LIBCPP_INLINE_VISIBILITY void __incr(false_type) _NOEXCEPT
	{++__size_;}
	_LIBCPP_INLINE_VISIBILITY void __incr(true_type) _NOEXCEPT
	{}

	_LIBCPP_INLINE_VISIBILITY void __set(size_t __s, false_type) _NOEXCEPT
	{__size_ = __s;}
	_LIBCPP_INLINE_VISIBILITY void __set(size_t, true_type) _NOEXCEPT
	{}
	public:
	_LIBCPP_INLINE_VISIBILITY explicit __destruct_n(size_t __s) _NOEXCEPT
	: __size_(__s) {}

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

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

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

	template <class _Alloc>
	class __allocator_destructor
	{
	typedef allocator_traits<_Alloc> __alloc_traits;
	public:
	typedef typename __alloc_traits::pointer pointer;
	typedef typename __alloc_traits::size_type size_type;
	private:
	_Alloc& __alloc_;
	size_type __s_;
	public:
	_LIBCPP_INLINE_VISIBILITY __allocator_destructor(_Alloc& __a, size_type __s)
	_NOEXCEPT
	: __alloc_(__a), __s_(__s) {}
	_LIBCPP_INLINE_VISIBILITY
	void operator()(pointer __p) _NOEXCEPT
	{__alloc_traits::deallocate(__alloc_, __p, __s_);}
	};

	template <class _InputIterator, class _ForwardIterator>
	_ForwardIterator
	uninitialized_copy(_InputIterator __f, _InputIterator __l, _ForwardIterator __r)
	{
	typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	_ForwardIterator __s = __r;
	try
	{
	#endif
	for (; __f != __l; ++__f, (void) ++__r)
	::new (static_cast<void>(_VSTD::addressof(__r))) value_type(*__f);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	for (; __s != __r; ++__s)
	__s->~value_type();
	throw;
	}
	#endif
	return __r;
	}

	template <class _InputIterator, class _Size, class _ForwardIterator>
	_ForwardIterator
	uninitialized_copy_n(_InputIterator __f, _Size __n, _ForwardIterator __r)
	{
	typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	_ForwardIterator __s = __r;
	try
	{
	#endif
	for (; __n > 0; ++__f, (void) ++__r, (void) --__n)
	::new (static_cast<void>(_VSTD::addressof(__r))) value_type(*__f);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	for (; __s != __r; ++__s)
	__s->~value_type();
	throw;
	}
	#endif
	return __r;
	}

	template <class _ForwardIterator, class _Tp>
	void
	uninitialized_fill(_ForwardIterator __f, _ForwardIterator __l, const _Tp& __x)
	{
	typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	_ForwardIterator __s = __f;
	try
	{
	#endif
	for (; __f != __l; ++__f)
	::new (static_cast<void>(_VSTD::addressof(__f))) value_type(__x);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	for (; __s != __f; ++__s)
	__s->~value_type();
	throw;
	}
	#endif
	}

	template <class _ForwardIterator, class _Size, class _Tp>
	_ForwardIterator
	uninitialized_fill_n(_ForwardIterator __f, _Size __n, const _Tp& __x)
	{
	typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	_ForwardIterator __s = __f;
	try
	{
	#endif
	for (; __n > 0; ++__f, (void) --__n)
	::new (static_cast<void>(_VSTD::addressof(__f))) value_type(__x);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	for (; __s != __f; ++__s)
	__s->~value_type();
	throw;
	}
	#endif
	return __f;
	}

	#if _LIBCPP_STD_VER > 14

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	void destroy_at(_Tp* __loc) {
	_LIBCPP_ASSERT(__loc, "null pointer given to destroy_at");
	__loc->~_Tp();
	}

	template <class _ForwardIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	void destroy(_ForwardIterator __first, _ForwardIterator __last) {
	for (; __first != __last; ++__first)
	_VSTD::destroy_at(_VSTD::addressof(*__first));
	}

	template <class _ForwardIterator, class _Size>
	inline _LIBCPP_INLINE_VISIBILITY
	_ForwardIterator destroy_n(_ForwardIterator __first, _Size __n) {
	for (; __n > 0; (void)++__first, --__n)
	_VSTD::destroy_at(_VSTD::addressof(*__first));
	return __first;
	}

	template <class _ForwardIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	void uninitialized_default_construct(_ForwardIterator __first, _ForwardIterator __last) {
	using _Vt = typename iterator_traits<_ForwardIterator>::value_type;
	auto __idx = __first;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try {
	#endif
	for (; __idx != __last; ++__idx)
	::new((void)_VSTD::addressof(__idx)) _Vt;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	} catch (...) {
	_VSTD::destroy(__first, __idx);
	throw;
	}
	#endif
	}

	template <class _ForwardIterator, class _Size>
	inline _LIBCPP_INLINE_VISIBILITY
	_ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) {
	using _Vt = typename iterator_traits<_ForwardIterator>::value_type;
	auto __idx = __first;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try {
	#endif
	for (; __n > 0; (void)++__idx, --__n)
	::new((void)_VSTD::addressof(__idx)) _Vt;
	return __idx;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	} catch (...) {
	_VSTD::destroy(__first, __idx);
	throw;
	}
	#endif
	}


	template <class _ForwardIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	void uninitialized_value_construct(_ForwardIterator __first, _ForwardIterator __last) {
	using _Vt = typename iterator_traits<_ForwardIterator>::value_type;
	auto __idx = __first;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try {
	#endif
	for (; __idx != __last; ++__idx)
	::new((void)_VSTD::addressof(__idx)) _Vt();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	} catch (...) {
	_VSTD::destroy(__first, __idx);
	throw;
	}
	#endif
	}

	template <class _ForwardIterator, class _Size>
	inline _LIBCPP_INLINE_VISIBILITY
	_ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) {
	using _Vt = typename iterator_traits<_ForwardIterator>::value_type;
	auto __idx = __first;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try {
	#endif
	for (; __n > 0; (void)++__idx, --__n)
	::new((void)_VSTD::addressof(__idx)) _Vt();
	return __idx;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	} catch (...) {
	_VSTD::destroy(__first, __idx);
	throw;
	}
	#endif
	}


	template <class _InputIt, class _ForwardIt>
	inline _LIBCPP_INLINE_VISIBILITY
	_ForwardIt uninitialized_move(_InputIt __first, _InputIt __last, _ForwardIt __first_res) {
	using _Vt = typename iterator_traits<_ForwardIt>::value_type;
	auto __idx = __first_res;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try {
	#endif
	for (; __first != __last; (void)++__idx, ++__first)
	::new((void)_VSTD::addressof(__idx)) _Vt(std::move(*__first));
	return __idx;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	} catch (...) {
	_VSTD::destroy(__first_res, __idx);
	throw;
	}
	#endif
	}

	template <class _InputIt, class _Size, class _ForwardIt>
	inline _LIBCPP_INLINE_VISIBILITY
	pair<_InputIt, _ForwardIt>
	uninitialized_move_n(_InputIt __first, _Size __n, _ForwardIt __first_res) {
	using _Vt = typename iterator_traits<_ForwardIt>::value_type;
	auto __idx = __first_res;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try {
	#endif
	for (; __n > 0; ++__idx, (void)++__first, --__n)
	::new((void)_VSTD::addressof(__idx)) _Vt(std::move(*__first));
	return {__first, __idx};
	#ifndef _LIBCPP_NO_EXCEPTIONS
	} catch (...) {
	_VSTD::destroy(__first_res, __idx);
	throw;
	}
	#endif
	}


	#endif // _LIBCPP_STD_VER > 14

	// NOTE: Relaxed and acq/rel atomics (for increment and decrement respectively)
	// should be sufficient for thread safety.
	// See https://bugs.llvm.org/show_bug.cgi?id=22803
	#if defined(__clang__) && __has_builtin(__atomic_add_fetch) \
	&& defined(__ATOMIC_RELAXED) \
	&& defined(__ATOMIC_ACQ_REL)
	# define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT
	#elif !defined(__clang__) && defined(_GNUC_VER) && _GNUC_VER >= 407
	# define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT
	#endif

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _Tp
	__libcpp_atomic_refcount_increment(_Tp& __t) _NOEXCEPT
	{
	#if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS)
	return __atomic_add_fetch(&__t, 1, __ATOMIC_RELAXED);
	#else
	return __t += 1;
	#endif
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _Tp
	__libcpp_atomic_refcount_decrement(_Tp& __t) _NOEXCEPT
	{
	#if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS)
	return __atomic_add_fetch(&__t, -1, __ATOMIC_ACQ_REL);
	#else
	return __t -= 1;
	#endif
	}

	class _LIBCPP_EXCEPTION_ABI bad_weak_ptr
	: public std::exception
	{
	public:
	virtual ~bad_weak_ptr() _NOEXCEPT;
	virtual const char* what() const _NOEXCEPT;
	};

	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
	void __throw_bad_weak_ptr()
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw bad_weak_ptr();
	#else
	_VSTD::abort();
	#endif
	}

	template<class _Tp> class _LIBCPP_TEMPLATE_VIS weak_ptr;

	class _LIBCPP_TYPE_VIS __shared_count
	{
	__shared_count(const __shared_count&);
	__shared_count& operator=(const __shared_count&);

	protected:
	long __shared_owners_;
	virtual ~__shared_count();
	private:
	virtual void __on_zero_shared() _NOEXCEPT = 0;

	public:
	_LIBCPP_INLINE_VISIBILITY
	explicit __shared_count(long __refs = 0) _NOEXCEPT
	: __shared_owners_(__refs) {}

	#if defined(_LIBCPP_BUILDING_MEMORY) && \
	defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
	void __add_shared() _NOEXCEPT;
	bool __release_shared() _NOEXCEPT;
	#else
	_LIBCPP_INLINE_VISIBILITY
	void __add_shared() _NOEXCEPT {
	__libcpp_atomic_refcount_increment(__shared_owners_);
	}
	_LIBCPP_INLINE_VISIBILITY
	bool __release_shared() _NOEXCEPT {
	if (__libcpp_atomic_refcount_decrement(__shared_owners_) == -1) {
	__on_zero_shared();
	return true;
	}
	return false;
	}
	#endif
	_LIBCPP_INLINE_VISIBILITY
	long use_count() const _NOEXCEPT {
	return __libcpp_relaxed_load(&__shared_owners_) + 1;
	}
	};

	class _LIBCPP_TYPE_VIS __shared_weak_count
	: private __shared_count
	{
	long __shared_weak_owners_;

	public:
	_LIBCPP_INLINE_VISIBILITY
	explicit __shared_weak_count(long __refs = 0) _NOEXCEPT
	: __shared_count(__refs),
	__shared_weak_owners_(__refs) {}
	protected:
	virtual ~__shared_weak_count();

	public:
	#if defined(_LIBCPP_BUILDING_MEMORY) && \
	defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
	void __add_shared() _NOEXCEPT;
	void __add_weak() _NOEXCEPT;
	void __release_shared() _NOEXCEPT;
	#else
	_LIBCPP_INLINE_VISIBILITY
	void __add_shared() _NOEXCEPT {
	__shared_count::__add_shared();
	}
	_LIBCPP_INLINE_VISIBILITY
	void __add_weak() _NOEXCEPT {
	__libcpp_atomic_refcount_increment(__shared_weak_owners_);
	}
	_LIBCPP_INLINE_VISIBILITY
	void __release_shared() _NOEXCEPT {
	if (__shared_count::__release_shared())
	__release_weak();
	}
	#endif
	void __release_weak() _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	long use_count() const _NOEXCEPT {return __shared_count::use_count();}
	__shared_weak_count* lock() _NOEXCEPT;

	// Define the function out only if we build static libc++ without RTTI.
	// Otherwise we may break clients who need to compile their projects with
	// -fno-rtti and yet link against a libc++.dylib compiled
	// without -fno-rtti.
	#if !defined(_LIBCPP_NO_RTTI) \|\| !defined(_LIBCPP_BUILD_STATIC)
	virtual const void* __get_deleter(const type_info&) const _NOEXCEPT;
	#endif
	private:
	virtual void __on_zero_shared_weak() _NOEXCEPT = 0;
	};

	template <class _Tp, class _Dp, class _Alloc>
	class __shared_ptr_pointer
	: public __shared_weak_count
	{
	__compressed_pair<__compressed_pair<_Tp, _Dp>, _Alloc> __data_;
	public:
	_LIBCPP_INLINE_VISIBILITY
	__shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a)
	: __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTD::move(__d)), _VSTD::move(__a)) {}

	#ifndef _LIBCPP_NO_RTTI
	virtual const void* __get_deleter(const type_info&) const _NOEXCEPT;
	#endif

	private:
	virtual void __on_zero_shared() _NOEXCEPT;
	virtual void __on_zero_shared_weak() _NOEXCEPT;
	};

	#ifndef _LIBCPP_NO_RTTI

	template <class _Tp, class _Dp, class _Alloc>
	const void*
	__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const _NOEXCEPT
	{
	return __t == typeid(_Dp) ? _VSTD::addressof(__data_.first().second()) : nullptr;
	}

	#endif // _LIBCPP_NO_RTTI

	template <class _Tp, class _Dp, class _Alloc>
	void
	__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPT
	{
	__data_.first().second()(__data_.first().first());
	__data_.first().second().~_Dp();
	}

	template <class _Tp, class _Dp, class _Alloc>
	void
	__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT
	{
	typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_pointer>::type _Al;
	typedef allocator_traits<_Al> _ATraits;
	typedef pointer_traits<typename _ATraits::pointer> _PTraits;

	_Al __a(__data_.second());
	__data_.second().~_Alloc();
	__a.deallocate(_PTraits::pointer_to(*this), 1);
	}

	template <class _Tp, class _Alloc>
	class __shared_ptr_emplace
	: public __shared_weak_count
	{
	__compressed_pair<_Alloc, _Tp> __data_;
	public:
	#ifndef _LIBCPP_HAS_NO_VARIADICS

	_LIBCPP_INLINE_VISIBILITY
	__shared_ptr_emplace(_Alloc __a)
	: __data_(_VSTD::move(__a)) {}

	template <class ..._Args>
	_LIBCPP_INLINE_VISIBILITY
	__shared_ptr_emplace(_Alloc __a, _Args&& ...__args)
	: __data_(piecewise_construct, _VSTD::forward_as_tuple(__a),
	_VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)) {}

	#else // _LIBCPP_HAS_NO_VARIADICS

	_LIBCPP_INLINE_VISIBILITY
	__shared_ptr_emplace(_Alloc __a)
	: __data_(__a) {}

	template <class _A0>
	_LIBCPP_INLINE_VISIBILITY
	__shared_ptr_emplace(_Alloc __a, _A0& __a0)
	: __data_(__a, _Tp(__a0)) {}

	template <class _A0, class _A1>
	_LIBCPP_INLINE_VISIBILITY
	__shared_ptr_emplace(_Alloc __a, _A0& __a0, _A1& __a1)
	: __data_(__a, _Tp(__a0, __a1)) {}

	template <class _A0, class _A1, class _A2>
	_LIBCPP_INLINE_VISIBILITY
	__shared_ptr_emplace(_Alloc __a, _A0& __a0, _A1& __a1, _A2& __a2)
	: __data_(__a, _Tp(__a0, __a1, __a2)) {}

	#endif // _LIBCPP_HAS_NO_VARIADICS

	private:
	virtual void __on_zero_shared() _NOEXCEPT;
	virtual void __on_zero_shared_weak() _NOEXCEPT;
	public:
	_LIBCPP_INLINE_VISIBILITY
	_Tp* get() _NOEXCEPT {return &__data_.second();}
	};

	template <class _Tp, class _Alloc>
	void
	__shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared() _NOEXCEPT
	{
	__data_.second().~_Tp();
	}

	template <class _Tp, class _Alloc>
	void
	__shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT
	{
	typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_emplace>::type _Al;
	typedef allocator_traits<_Al> _ATraits;
	typedef pointer_traits<typename _ATraits::pointer> _PTraits;
	_Al __a(__data_.first());
	__data_.first().~_Alloc();
	__a.deallocate(_PTraits::pointer_to(*this), 1);
	}

	struct __shared_ptr_dummy_rebind_allocator_type;
	template <>
	class _LIBCPP_TEMPLATE_VIS allocator<__shared_ptr_dummy_rebind_allocator_type>
	{
	public:
	template <class _Other>
	struct rebind
	{
	typedef allocator<_Other> other;
	};
	};

	template<class _Tp> class _LIBCPP_TEMPLATE_VIS enable_shared_from_this;

	template<class _Tp>
	class _LIBCPP_TEMPLATE_VIS shared_ptr
	{
	public:
	typedef _Tp element_type;

	#if _LIBCPP_STD_VER > 14
	typedef weak_ptr<_Tp> weak_type;
	#endif
	private:
	element_type* __ptr_;
	__shared_weak_count* __cntrl_;

	struct __nat {int __for_bool_;};
	public:
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR shared_ptr() _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR shared_ptr(nullptr_t) _NOEXCEPT;
	template<class _Yp>
	explicit shared_ptr(_Yp* __p,
	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type = __nat());
	template<class _Yp, class _Dp>
	shared_ptr(_Yp* __p, _Dp __d,
	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type = __nat());
	template<class _Yp, class _Dp, class _Alloc>
	shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,
	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type = __nat());
	template <class _Dp> shared_ptr(nullptr_t __p, _Dp __d);
	template <class _Dp, class _Alloc> shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a);
	template<class _Yp> _LIBCPP_INLINE_VISIBILITY shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	shared_ptr(const shared_ptr& __r) _NOEXCEPT;
	template<class _Yp>
	_LIBCPP_INLINE_VISIBILITY
	shared_ptr(const shared_ptr<_Yp>& __r,
	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type = __nat())
	_NOEXCEPT;
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	shared_ptr(shared_ptr&& __r) _NOEXCEPT;
	template<class _Yp> _LIBCPP_INLINE_VISIBILITY shared_ptr(shared_ptr<_Yp>&& __r,
	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type = __nat())
	_NOEXCEPT;
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	template<class _Yp> explicit shared_ptr(const weak_ptr<_Yp>& __r,
	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type= __nat());
	#if _LIBCPP_STD_VER <= 14 \|\| defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	template<class _Yp>
	shared_ptr(auto_ptr<_Yp>&& __r,
	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type = __nat());
	#else
	template<class _Yp>
	shared_ptr(auto_ptr<_Yp> __r,
	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type = __nat());
	#endif
	#endif
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	template <class _Yp, class _Dp>
	shared_ptr(unique_ptr<_Yp, _Dp>&&,
	typename enable_if
	<
	!is_lvalue_reference<_Dp>::value &&
	!is_array<_Yp>::value &&
	is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
	__nat
	>::type = __nat());
	template <class _Yp, class _Dp>
	shared_ptr(unique_ptr<_Yp, _Dp>&&,
	typename enable_if
	<
	is_lvalue_reference<_Dp>::value &&
	!is_array<_Yp>::value &&
	is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
	__nat
	>::type = __nat());
	#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	template <class _Yp, class _Dp>
	shared_ptr(unique_ptr<_Yp, _Dp>,
	typename enable_if
	<
	!is_lvalue_reference<_Dp>::value &&
	!is_array<_Yp>::value &&
	is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
	__nat
	>::type = __nat());
	template <class _Yp, class _Dp>
	shared_ptr(unique_ptr<_Yp, _Dp>,
	typename enable_if
	<
	is_lvalue_reference<_Dp>::value &&
	!is_array<_Yp>::value &&
	is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
	__nat
	>::type = __nat());
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	~shared_ptr();

	_LIBCPP_INLINE_VISIBILITY
	shared_ptr& operator=(const shared_ptr& __r) _NOEXCEPT;
	template<class _Yp>
	typename enable_if
	<
	is_convertible<_Yp, element_type>::value,
	shared_ptr&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT;
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	shared_ptr& operator=(shared_ptr&& __r) _NOEXCEPT;
	template<class _Yp>
	typename enable_if
	<
	is_convertible<_Yp, element_type>::value,
	shared_ptr<_Tp>&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator=(shared_ptr<_Yp>&& __r);
	#if _LIBCPP_STD_VER <= 14 \|\| defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
	template<class _Yp>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	!is_array<_Yp>::value &&
	is_convertible<_Yp, element_type>::value,
	shared_ptr
	>::type&
	operator=(auto_ptr<_Yp>&& __r);
	#endif
	#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	#if _LIBCPP_STD_VER <= 14 \|\| defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
	template<class _Yp>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	!is_array<_Yp>::value &&
	is_convertible<_Yp, element_type>::value,
	shared_ptr&
	>::type
	operator=(auto_ptr<_Yp> __r);
	#endif
	#endif
	template <class _Yp, class _Dp>
	typename enable_if
	<
	!is_array<_Yp>::value &&
	is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
	shared_ptr&
	>::type
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	operator=(unique_ptr<_Yp, _Dp>&& __r);
	#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	operator=(unique_ptr<_Yp, _Dp> __r);
	#endif

	_LIBCPP_INLINE_VISIBILITY
	void swap(shared_ptr& __r) _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	void reset() _NOEXCEPT;
	template<class _Yp>
	typename enable_if
	<
	is_convertible<_Yp, element_type>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	reset(_Yp* __p);
	template<class _Yp, class _Dp>
	typename enable_if
	<
	is_convertible<_Yp, element_type>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	reset(_Yp* __p, _Dp __d);
	template<class _Yp, class _Dp, class _Alloc>
	typename enable_if
	<
	is_convertible<_Yp, element_type>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	reset(_Yp* __p, _Dp __d, _Alloc __a);

	_LIBCPP_INLINE_VISIBILITY
	element_type* get() const _NOEXCEPT {return __ptr_;}
	_LIBCPP_INLINE_VISIBILITY
	typename add_lvalue_reference<element_type>::type operator*() const _NOEXCEPT
	{return *__ptr_;}
	_LIBCPP_INLINE_VISIBILITY
	element_type* operator->() const _NOEXCEPT {return __ptr_;}
	_LIBCPP_INLINE_VISIBILITY
	long use_count() const _NOEXCEPT {return __cntrl_ ? __cntrl_->use_count() : 0;}
	_LIBCPP_INLINE_VISIBILITY
	bool unique() const _NOEXCEPT {return use_count() == 1;}
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return get() != 0;}
	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY
	bool owner_before(shared_ptr<_Up> const& __p) const _NOEXCEPT
	{return __cntrl_ < __p.__cntrl_;}
	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY
	bool owner_before(weak_ptr<_Up> const& __p) const _NOEXCEPT
	{return __cntrl_ < __p.__cntrl_;}
	_LIBCPP_INLINE_VISIBILITY
	bool
	__owner_equivalent(const shared_ptr& __p) const
	{return __cntrl_ == __p.__cntrl_;}

	#ifndef _LIBCPP_NO_RTTI
	template <class _Dp>
	_LIBCPP_INLINE_VISIBILITY
	_Dp* __get_deleter() const _NOEXCEPT
	{return static_cast<_Dp*>(__cntrl_
	? const_cast<void *>(__cntrl_->__get_deleter(typeid(_Dp)))
	: nullptr);}
	#endif // _LIBCPP_NO_RTTI

	#ifndef _LIBCPP_HAS_NO_VARIADICS

	template<class ..._Args>
	static
	shared_ptr<_Tp>
	make_shared(_Args&& ...__args);

	template<class _Alloc, class ..._Args>
	static
	shared_ptr<_Tp>
	allocate_shared(const _Alloc& __a, _Args&& ...__args);

	#else // _LIBCPP_HAS_NO_VARIADICS

	static shared_ptr<_Tp> make_shared();

	template<class _A0>
	static shared_ptr<_Tp> make_shared(_A0&);

	template<class _A0, class _A1>
	static shared_ptr<_Tp> make_shared(_A0&, _A1&);

	template<class _A0, class _A1, class _A2>
	static shared_ptr<_Tp> make_shared(_A0&, _A1&, _A2&);

	template<class _Alloc>
	static shared_ptr<_Tp>
	allocate_shared(const _Alloc& __a);

	template<class _Alloc, class _A0>
	static shared_ptr<_Tp>
	allocate_shared(const _Alloc& __a, _A0& __a0);

	template<class _Alloc, class _A0, class _A1>
	static shared_ptr<_Tp>
	allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1);

	template<class _Alloc, class _A0, class _A1, class _A2>
	static shared_ptr<_Tp>
	allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2);

	#endif // _LIBCPP_HAS_NO_VARIADICS

	private:
	template <class _Yp, bool = is_function<_Yp>::value>
	struct __shared_ptr_default_allocator
	{
	typedef allocator<_Yp> type;
	};

	template <class _Yp>
	struct __shared_ptr_default_allocator<_Yp, true>
	{
	typedef allocator<__shared_ptr_dummy_rebind_allocator_type> type;
	};

	template <class _Yp, class _OrigPtr>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<is_convertible<_OrigPtr*,
	const enable_shared_from_this<_Yp>*
	>::value,
	void>::type
	__enable_weak_this(const enable_shared_from_this<_Yp>* __e,
	_OrigPtr* __ptr) _NOEXCEPT
	{
	typedef typename remove_cv<_Yp>::type _RawYp;
	if (__e && __e->__weak_this_.expired())
	{
	__e->__weak_this_ = shared_ptr<_RawYp>(*this,
	const_cast<_RawYp>(static_cast<const _Yp>(__ptr)));
	}
	}

	_LIBCPP_INLINE_VISIBILITY void __enable_weak_this(...) _NOEXCEPT {}

	template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
	template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
	};


	template<class _Tp>
	inline
	_LIBCPP_CONSTEXPR
	shared_ptr<_Tp>::shared_ptr() _NOEXCEPT
	: __ptr_(0),
	__cntrl_(0)
	{
	}

	template<class _Tp>
	inline
	_LIBCPP_CONSTEXPR
	shared_ptr<_Tp>::shared_ptr(nullptr_t) _NOEXCEPT
	: __ptr_(0),
	__cntrl_(0)
	{
	}

	template<class _Tp>
	template<class _Yp>
	shared_ptr<_Tp>::shared_ptr(_Yp* __p,
	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type)
	: __ptr_(__p)
	{
	unique_ptr<_Yp> __hold(__p);
	typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
	typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, _AllocT > _CntrlBlk;
	__cntrl_ = new _CntrlBlk(__p, default_delete<_Yp>(), _AllocT());
	__hold.release();
	__enable_weak_this(__p, __p);
	}

	template<class _Tp>
	template<class _Yp, class _Dp>
	shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d,
	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type)
	: __ptr_(__p)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
	typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT > _CntrlBlk;
	__cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
	__enable_weak_this(__p, __p);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__d(__p);
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	template<class _Tp>
	template<class _Dp>
	shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d)
	: __ptr_(0)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typedef typename __shared_ptr_default_allocator<_Tp>::type _AllocT;
	typedef __shared_ptr_pointer<nullptr_t, _Dp, _AllocT > _CntrlBlk;
	__cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__d(__p);
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	template<class _Tp>
	template<class _Yp, class _Dp, class _Alloc>
	shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,
	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type)
	: __ptr_(__p)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk;
	typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
	typedef __allocator_destructor<_A2> _D2;
	_A2 __a2(__a);
	unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
	::new(static_cast<void>(_VSTD::addressof(__hold2.get())))
	_CntrlBlk(__p, __d, __a);
	__cntrl_ = _VSTD::addressof(*__hold2.release());
	__enable_weak_this(__p, __p);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__d(__p);
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	template<class _Tp>
	template<class _Dp, class _Alloc>
	shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a)
	: __ptr_(0)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk;
	typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
	typedef __allocator_destructor<_A2> _D2;
	_A2 __a2(__a);
	unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
	::new(static_cast<void>(_VSTD::addressof(__hold2.get())))
	_CntrlBlk(__p, __d, __a);
	__cntrl_ = _VSTD::addressof(*__hold2.release());
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__d(__p);
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	template<class _Tp>
	template<class _Yp>
	inline
	shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r, element_type *__p) _NOEXCEPT
	: __ptr_(__p),
	__cntrl_(__r.__cntrl_)
	{
	if (__cntrl_)
	__cntrl_->__add_shared();
	}

	template<class _Tp>
	inline
	shared_ptr<_Tp>::shared_ptr(const shared_ptr& __r) _NOEXCEPT
	: __ptr_(__r.__ptr_),
	__cntrl_(__r.__cntrl_)
	{
	if (__cntrl_)
	__cntrl_->__add_shared();
	}

	template<class _Tp>
	template<class _Yp>
	inline
	shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r,
	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type)
	_NOEXCEPT
	: __ptr_(__r.__ptr_),
	__cntrl_(__r.__cntrl_)
	{
	if (__cntrl_)
	__cntrl_->__add_shared();
	}

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template<class _Tp>
	inline
	shared_ptr<_Tp>::shared_ptr(shared_ptr&& __r) _NOEXCEPT
	: __ptr_(__r.__ptr_),
	__cntrl_(__r.__cntrl_)
	{
	__r.__ptr_ = 0;
	__r.__cntrl_ = 0;
	}

	template<class _Tp>
	template<class _Yp>
	inline
	shared_ptr<_Tp>::shared_ptr(shared_ptr<_Yp>&& __r,
	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type)
	_NOEXCEPT
	: __ptr_(__r.__ptr_),
	__cntrl_(__r.__cntrl_)
	{
	__r.__ptr_ = 0;
	__r.__cntrl_ = 0;
	}

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	#if _LIBCPP_STD_VER <= 14 \|\| defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
	template<class _Tp>
	template<class _Yp>
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp>&& __r,
	#else
	shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp> __r,
	#endif
	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type)
	: __ptr_(__r.get())
	{
	typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk;
	__cntrl_ = new _CntrlBlk(__r.get(), default_delete<_Yp>(), allocator<_Yp>());
	__enable_weak_this(__r.get(), __r.get());
	__r.release();
	}
	#endif

	template<class _Tp>
	template <class _Yp, class _Dp>
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r,
	#else
	shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r,
	#endif
	typename enable_if
	<
	!is_lvalue_reference<_Dp>::value &&
	!is_array<_Yp>::value &&
	is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
	__nat
	>::type)
	: __ptr_(__r.get())
	{
	#if _LIBCPP_STD_VER > 11
	if (__ptr_ == nullptr)
	__cntrl_ = nullptr;
	else
	#endif
	{
	typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
	typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT > _CntrlBlk;
	__cntrl_ = new _CntrlBlk(__r.get(), __r.get_deleter(), _AllocT());
	__enable_weak_this(__r.get(), __r.get());
	}
	__r.release();
	}

	template<class _Tp>
	template <class _Yp, class _Dp>
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r,
	#else
	shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r,
	#endif
	typename enable_if
	<
	is_lvalue_reference<_Dp>::value &&
	!is_array<_Yp>::value &&
	is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
	__nat
	>::type)
	: __ptr_(__r.get())
	{
	#if _LIBCPP_STD_VER > 11
	if (__ptr_ == nullptr)
	__cntrl_ = nullptr;
	else
	#endif
	{
	typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
	typedef __shared_ptr_pointer<_Yp*,
	reference_wrapper<typename remove_reference<_Dp>::type>,
	_AllocT > _CntrlBlk;
	__cntrl_ = new _CntrlBlk(__r.get(), ref(__r.get_deleter()), _AllocT());
	__enable_weak_this(__r.get(), __r.get());
	}
	__r.release();
	}

	#ifndef _LIBCPP_HAS_NO_VARIADICS

	template<class _Tp>
	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;
	_A2 __a2;
	unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
	::new(__hold2.get()) _CntrlBlk(__a2, _VSTD::forward<_Args>(__args)...);
	shared_ptr<_Tp> __r;
	__r.__ptr_ = __hold2.get()->get();
	__r.__cntrl_ = __hold2.release();
	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
	return __r;
	}

	template<class _Tp>
	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;
	_A2 __a2(__a);
	unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
	::new(static_cast<void>(_VSTD::addressof(__hold2.get())))
	_CntrlBlk(__a, _VSTD::forward<_Args>(__args)...);
	shared_ptr<_Tp> __r;
	__r.__ptr_ = __hold2.get()->get();
	__r.__cntrl_ = _VSTD::addressof(*__hold2.release());
	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
	return __r;
	}

	#else // _LIBCPP_HAS_NO_VARIADICS

	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;
	_Alloc2 __alloc2;
	unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1));
	::new(__hold2.get()) _CntrlBlk(__alloc2);
	shared_ptr<_Tp> __r;
	__r.__ptr_ = __hold2.get()->get();
	__r.__cntrl_ = __hold2.release();
	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
	return __r;
	}

	template<class _Tp>
	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;
	_Alloc2 __alloc2;
	unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1));
	::new(__hold2.get()) _CntrlBlk(__alloc2, __a0);
	shared_ptr<_Tp> __r;
	__r.__ptr_ = __hold2.get()->get();
	__r.__cntrl_ = __hold2.release();
	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
	return __r;
	}

	template<class _Tp>
	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;
	_Alloc2 __alloc2;
	unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1));
	::new(__hold2.get()) _CntrlBlk(__alloc2, __a0, __a1);
	shared_ptr<_Tp> __r;
	__r.__ptr_ = __hold2.get()->get();
	__r.__cntrl_ = __hold2.release();
	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
	return __r;
	}

	template<class _Tp>
	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;
	_Alloc2 __alloc2;
	unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1));
	::new(__hold2.get()) _CntrlBlk(__alloc2, __a0, __a1, __a2);
	shared_ptr<_Tp> __r;
	__r.__ptr_ = __hold2.get()->get();
	__r.__cntrl_ = __hold2.release();
	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
	return __r;
	}

	template<class _Tp>
	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;
	_Alloc2 __alloc2(__a);
	unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1));
	::new(static_cast<void>(_VSTD::addressof(__hold2.get())))
	_CntrlBlk(__a);
	shared_ptr<_Tp> __r;
	__r.__ptr_ = __hold2.get()->get();
	__r.__cntrl_ = _VSTD::addressof(*__hold2.release());
	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
	return __r;
	}

	template<class _Tp>
	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;
	_Alloc2 __alloc2(__a);
	unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1));
	::new(static_cast<void>(_VSTD::addressof(__hold2.get())))
	_CntrlBlk(__a, __a0);
	shared_ptr<_Tp> __r;
	__r.__ptr_ = __hold2.get()->get();
	__r.__cntrl_ = _VSTD::addressof(*__hold2.release());
	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
	return __r;
	}

	template<class _Tp>
	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;
	_Alloc2 __alloc2(__a);
	unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1));
	::new(static_cast<void>(_VSTD::addressof(__hold2.get())))
	_CntrlBlk(__a, __a0, __a1);
	shared_ptr<_Tp> __r;
	__r.__ptr_ = __hold2.get()->get();
	__r.__cntrl_ = _VSTD::addressof(*__hold2.release());
	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
	return __r;
	}

	template<class _Tp>
	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;
	_Alloc2 __alloc2(__a);
	unique_ptr<_CntrlBlk, _D2> __hold2(__alloc2.allocate(1), _D2(__alloc2, 1));
	::new(static_cast<void>(_VSTD::addressof(__hold2.get())))
	_CntrlBlk(__a, __a0, __a1, __a2);
	shared_ptr<_Tp> __r;
	__r.__ptr_ = __hold2.get()->get();
	__r.__cntrl_ = _VSTD::addressof(*__hold2.release());
	__r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
	return __r;
	}

	#endif // _LIBCPP_HAS_NO_VARIADICS

	template<class _Tp>
	shared_ptr<_Tp>::~shared_ptr()
	{
	if (__cntrl_)
	__cntrl_->__release_shared();
	}

	template<class _Tp>
	inline
	shared_ptr<_Tp>&
	shared_ptr<_Tp>::operator=(const shared_ptr& __r) _NOEXCEPT
	{
	shared_ptr(__r).swap(*this);
	return *this;
	}

	template<class _Tp>
	template<class _Yp>
	inline
	typename enable_if
	<
	is_convertible<_Yp, typename shared_ptr<_Tp>::element_type>::value,
	shared_ptr<_Tp>&
	>::type
	shared_ptr<_Tp>::operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT
	{
	shared_ptr(__r).swap(*this);
	return *this;
	}

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template<class _Tp>
	inline
	shared_ptr<_Tp>&
	shared_ptr<_Tp>::operator=(shared_ptr&& __r) _NOEXCEPT
	{
	shared_ptr(_VSTD::move(__r)).swap(*this);
	return *this;
	}

	template<class _Tp>
	template<class _Yp>
	inline
	typename enable_if
	<
	is_convertible<_Yp, typename shared_ptr<_Tp>::element_type>::value,
	shared_ptr<_Tp>&
	>::type
	shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r)
	{
	shared_ptr(_VSTD::move(__r)).swap(*this);
	return *this;
	}

	#if _LIBCPP_STD_VER <= 14 \|\| defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
	template<class _Tp>
	template<class _Yp>
	inline
	typename enable_if
	<
	!is_array<_Yp>::value &&
	is_convertible<_Yp, typename shared_ptr<_Tp>::element_type>::value,
	shared_ptr<_Tp>
	>::type&
	shared_ptr<_Tp>::operator=(auto_ptr<_Yp>&& __r)
	{
	shared_ptr(_VSTD::move(__r)).swap(*this);
	return *this;
	}
	#endif

	template<class _Tp>
	template <class _Yp, class _Dp>
	inline
	typename enable_if
	<
	!is_array<_Yp>::value &&
	is_convertible<typename unique_ptr<_Yp, _Dp>::pointer,
	typename shared_ptr<_Tp>::element_type*>::value,
	shared_ptr<_Tp>&
	>::type
	shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp>&& __r)
	{
	shared_ptr(_VSTD::move(__r)).swap(*this);
	return *this;
	}

	#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	#if _LIBCPP_STD_VER <= 14 \|\| defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
	template<class _Tp>
	template<class _Yp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	!is_array<_Yp>::value &&
	is_convertible<_Yp, typename shared_ptr<_Tp>::element_type>::value,
	shared_ptr<_Tp>&
	>::type
	shared_ptr<_Tp>::operator=(auto_ptr<_Yp> __r)
	{
	shared_ptr(__r).swap(*this);
	return *this;
	}
	#endif

	template<class _Tp>
	template <class _Yp, class _Dp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	!is_array<_Yp>::value &&
	is_convertible<typename unique_ptr<_Yp, _Dp>::pointer,
	typename shared_ptr<_Tp>::element_type*>::value,
	shared_ptr<_Tp>&
	>::type
	shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp> __r)
	{
	shared_ptr(_VSTD::move(__r)).swap(*this);
	return *this;
	}

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template<class _Tp>
	inline
	void
	shared_ptr<_Tp>::swap(shared_ptr& __r) _NOEXCEPT
	{
	_VSTD::swap(__ptr_, __r.__ptr_);
	_VSTD::swap(__cntrl_, __r.__cntrl_);
	}

	template<class _Tp>
	inline
	void
	shared_ptr<_Tp>::reset() _NOEXCEPT
	{
	shared_ptr().swap(*this);
	}

	template<class _Tp>
	template<class _Yp>
	inline
	typename enable_if
	<
	is_convertible<_Yp, typename shared_ptr<_Tp>::element_type>::value,
	void
	>::type
	shared_ptr<_Tp>::reset(_Yp* __p)
	{
	shared_ptr(__p).swap(*this);
	}

	template<class _Tp>
	template<class _Yp, class _Dp>
	inline
	typename enable_if
	<
	is_convertible<_Yp, typename shared_ptr<_Tp>::element_type>::value,
	void
	>::type
	shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d)
	{
	shared_ptr(__p, __d).swap(*this);
	}

	template<class _Tp>
	template<class _Yp, class _Dp, class _Alloc>
	inline
	typename enable_if
	<
	is_convertible<_Yp, typename shared_ptr<_Tp>::element_type>::value,
	void
	>::type
	shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d, _Alloc __a)
	{
	shared_ptr(__p, __d, __a).swap(*this);
	}

	#ifndef _LIBCPP_HAS_NO_VARIADICS

	template<class _Tp, class ..._Args>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	!is_array<_Tp>::value,
	shared_ptr<_Tp>
	>::type
	make_shared(_Args&& ...__args)
	{
	return shared_ptr<_Tp>::make_shared(_VSTD::forward<_Args>(__args)...);
	}

	template<class _Tp, class _Alloc, class ..._Args>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	!is_array<_Tp>::value,
	shared_ptr<_Tp>
	>::type
	allocate_shared(const _Alloc& __a, _Args&& ...__args)
	{
	return shared_ptr<_Tp>::allocate_shared(__a, _VSTD::forward<_Args>(__args)...);
	}

	#else // _LIBCPP_HAS_NO_VARIADICS

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	shared_ptr<_Tp>
	make_shared()
	{
	return shared_ptr<_Tp>::make_shared();
	}

	template<class _Tp, class _A0>
	inline _LIBCPP_INLINE_VISIBILITY
	shared_ptr<_Tp>
	make_shared(_A0& __a0)
	{
	return shared_ptr<_Tp>::make_shared(__a0);
	}

	template<class _Tp, class _A0, class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	shared_ptr<_Tp>
	make_shared(_A0& __a0, _A1& __a1)
	{
	return shared_ptr<_Tp>::make_shared(__a0, __a1);
	}

	template<class _Tp, class _A0, class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	shared_ptr<_Tp>
	make_shared(_A0& __a0, _A1& __a1, _A2& __a2)
	{
	return shared_ptr<_Tp>::make_shared(__a0, __a1, __a2);
	}

	template<class _Tp, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	shared_ptr<_Tp>
	allocate_shared(const _Alloc& __a)
	{
	return shared_ptr<_Tp>::allocate_shared(__a);
	}

	template<class _Tp, class _Alloc, class _A0>
	inline _LIBCPP_INLINE_VISIBILITY
	shared_ptr<_Tp>
	allocate_shared(const _Alloc& __a, _A0& __a0)
	{
	return shared_ptr<_Tp>::allocate_shared(__a, __a0);
	}

	template<class _Tp, class _Alloc, class _A0, class _A1>
	inline _LIBCPP_INLINE_VISIBILITY
	shared_ptr<_Tp>
	allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1)
	{
	return shared_ptr<_Tp>::allocate_shared(__a, __a0, __a1);
	}

	template<class _Tp, class _Alloc, class _A0, class _A1, class _A2>
	inline _LIBCPP_INLINE_VISIBILITY
	shared_ptr<_Tp>
	allocate_shared(const _Alloc& __a, _A0& __a0, _A1& __a1, _A2& __a2)
	{
	return shared_ptr<_Tp>::allocate_shared(__a, __a0, __a1, __a2);
	}

	#endif // _LIBCPP_HAS_NO_VARIADICS

	template<class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
	{
	return __x.get() == __y.get();
	}

	template<class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
	{
	return !(__x == __y);
	}

	template<class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
	{
	+#if _LIBCPP_STD_VER <= 11
	typedef typename common_type<_Tp, _Up>::type _Vp;
	return less<_Vp>()(__x.get(), __y.get());
	+#else
	+ return less<>()(__x.get(), __y.get());
	+#endif
	+
	}

	template<class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
	{
	return __y < __x;
	}

	template<class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
	{
	return !(__y < __x);
	}

	template<class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
	{
	return !(__x < __y);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
	{
	return !__x;
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
	{
	return !__x;
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
	{
	return static_cast<bool>(__x);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
	{
	return static_cast<bool>(__x);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
	{
	return less<_Tp*>()(__x.get(), nullptr);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
	{
	return less<_Tp*>()(nullptr, __x.get());
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
	{
	return nullptr < __x;
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
	{
	return __x < nullptr;
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
	{
	return !(nullptr < __x);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
	{
	return !(__x < nullptr);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
	{
	return !(__x < nullptr);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
	{
	return !(nullptr < __x);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) _NOEXCEPT
	{
	__x.swap(__y);
	}

	template<class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	!is_array<_Tp>::value && !is_array<_Up>::value,
	shared_ptr<_Tp>
	>::type
	static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT
	{
	return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get()));
	}

	template<class _Tp, class _Up>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	!is_array<_Tp>::value && !is_array<_Up>::value,
	shared_ptr<_Tp>
	>::type
	dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT
	{
	_Tp* __p = dynamic_cast<_Tp*>(__r.get());
	return __p ? shared_ptr<_Tp>(__r, __p) : shared_ptr<_Tp>();
	}

	template<class _Tp, class _Up>
	typename enable_if
	<
	is_array<_Tp>::value == is_array<_Up>::value,
	shared_ptr<_Tp>
	>::type
	const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT
	{
	typedef typename remove_extent<_Tp>::type _RTp;
	return shared_ptr<_Tp>(__r, const_cast<_RTp*>(__r.get()));
	}

	#ifndef _LIBCPP_NO_RTTI

	template<class _Dp, class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Dp*
	get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT
	{
	return __p.template __get_deleter<_Dp>();
	}

	#endif // _LIBCPP_NO_RTTI

	template<class _Tp>
	class _LIBCPP_TEMPLATE_VIS weak_ptr
	{
	public:
	typedef _Tp element_type;
	private:
	element_type* __ptr_;
	__shared_weak_count* __cntrl_;

	public:
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR weak_ptr() _NOEXCEPT;
	template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(shared_ptr<_Yp> const& __r,
	typename enable_if<is_convertible<_Yp, _Tp>::value, __nat*>::type = 0)
	_NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	weak_ptr(weak_ptr const& __r) _NOEXCEPT;
	template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp> const& __r,
	typename enable_if<is_convertible<_Yp, _Tp>::value, __nat*>::type = 0)
	_NOEXCEPT;

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	_LIBCPP_INLINE_VISIBILITY
	weak_ptr(weak_ptr&& __r) _NOEXCEPT;
	template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp>&& __r,
	typename enable_if<is_convertible<_Yp, _Tp>::value, __nat*>::type = 0)
	_NOEXCEPT;
	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
	~weak_ptr();

	_LIBCPP_INLINE_VISIBILITY
	weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT;
	template<class _Yp>
	typename enable_if
	<
	is_convertible<_Yp, element_type>::value,
	weak_ptr&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT;

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	_LIBCPP_INLINE_VISIBILITY
	weak_ptr& operator=(weak_ptr&& __r) _NOEXCEPT;
	template<class _Yp>
	typename enable_if
	<
	is_convertible<_Yp, element_type>::value,
	weak_ptr&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT;

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template<class _Yp>
	typename enable_if
	<
	is_convertible<_Yp, element_type>::value,
	weak_ptr&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY
	void swap(weak_ptr& __r) _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	void reset() _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY
	long use_count() const _NOEXCEPT
	{return __cntrl_ ? __cntrl_->use_count() : 0;}
	_LIBCPP_INLINE_VISIBILITY
	bool expired() const _NOEXCEPT
	{return __cntrl_ == 0 \|\| __cntrl_->use_count() == 0;}
	shared_ptr<_Tp> lock() const _NOEXCEPT;
	template<class _Up>
	_LIBCPP_INLINE_VISIBILITY
	bool owner_before(const shared_ptr<_Up>& __r) const _NOEXCEPT
	{return __cntrl_ < __r.__cntrl_;}
	template<class _Up>
	_LIBCPP_INLINE_VISIBILITY
	bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPT
	{return __cntrl_ < __r.__cntrl_;}

	template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
	template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
	};

	template<class _Tp>
	inline
	_LIBCPP_CONSTEXPR
	weak_ptr<_Tp>::weak_ptr() _NOEXCEPT
	: __ptr_(0),
	__cntrl_(0)
	{
	}

	template<class _Tp>
	inline
	weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) _NOEXCEPT
	: __ptr_(__r.__ptr_),
	__cntrl_(__r.__cntrl_)
	{
	if (__cntrl_)
	__cntrl_->__add_weak();
	}

	template<class _Tp>
	template<class _Yp>
	inline
	weak_ptr<_Tp>::weak_ptr(shared_ptr<_Yp> const& __r,
	typename enable_if<is_convertible<_Yp, _Tp>::value, __nat*>::type)
	_NOEXCEPT
	: __ptr_(__r.__ptr_),
	__cntrl_(__r.__cntrl_)
	{
	if (__cntrl_)
	__cntrl_->__add_weak();
	}

	template<class _Tp>
	template<class _Yp>
	inline
	weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp> const& __r,
	typename enable_if<is_convertible<_Yp, _Tp>::value, __nat*>::type)
	_NOEXCEPT
	: __ptr_(__r.__ptr_),
	__cntrl_(__r.__cntrl_)
	{
	if (__cntrl_)
	__cntrl_->__add_weak();
	}

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template<class _Tp>
	inline
	weak_ptr<_Tp>::weak_ptr(weak_ptr&& __r) _NOEXCEPT
	: __ptr_(__r.__ptr_),
	__cntrl_(__r.__cntrl_)
	{
	__r.__ptr_ = 0;
	__r.__cntrl_ = 0;
	}

	template<class _Tp>
	template<class _Yp>
	inline
	weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp>&& __r,
	typename enable_if<is_convertible<_Yp, _Tp>::value, __nat*>::type)
	_NOEXCEPT
	: __ptr_(__r.__ptr_),
	__cntrl_(__r.__cntrl_)
	{
	__r.__ptr_ = 0;
	__r.__cntrl_ = 0;
	}

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template<class _Tp>
	weak_ptr<_Tp>::~weak_ptr()
	{
	if (__cntrl_)
	__cntrl_->__release_weak();
	}

	template<class _Tp>
	inline
	weak_ptr<_Tp>&
	weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPT
	{
	weak_ptr(__r).swap(*this);
	return *this;
	}

	template<class _Tp>
	template<class _Yp>
	inline
	typename enable_if
	<
	is_convertible<_Yp, _Tp>::value,
	weak_ptr<_Tp>&
	>::type
	weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT
	{
	weak_ptr(__r).swap(*this);
	return *this;
	}

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template<class _Tp>
	inline
	weak_ptr<_Tp>&
	weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPT
	{
	weak_ptr(_VSTD::move(__r)).swap(*this);
	return *this;
	}

	template<class _Tp>
	template<class _Yp>
	inline
	typename enable_if
	<
	is_convertible<_Yp, _Tp>::value,
	weak_ptr<_Tp>&
	>::type
	weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT
	{
	weak_ptr(_VSTD::move(__r)).swap(*this);
	return *this;
	}

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template<class _Tp>
	template<class _Yp>
	inline
	typename enable_if
	<
	is_convertible<_Yp, _Tp>::value,
	weak_ptr<_Tp>&
	>::type
	weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT
	{
	weak_ptr(__r).swap(*this);
	return *this;
	}

	template<class _Tp>
	inline
	void
	weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPT
	{
	_VSTD::swap(__ptr_, __r.__ptr_);
	_VSTD::swap(__cntrl_, __r.__cntrl_);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(weak_ptr<_Tp>& __x, weak_ptr<_Tp>& __y) _NOEXCEPT
	{
	__x.swap(__y);
	}

	template<class _Tp>
	inline
	void
	weak_ptr<_Tp>::reset() _NOEXCEPT
	{
	weak_ptr().swap(*this);
	}

	template<class _Tp>
	template<class _Yp>
	shared_ptr<_Tp>::shared_ptr(const weak_ptr<_Yp>& __r,
	typename enable_if<is_convertible<_Yp, element_type>::value, __nat>::type)
	: __ptr_(__r.__ptr_),
	__cntrl_(__r.__cntrl_ ? __r.__cntrl_->lock() : __r.__cntrl_)
	{
	if (__cntrl_ == 0)
	__throw_bad_weak_ptr();
	}

	template<class _Tp>
	shared_ptr<_Tp>
	weak_ptr<_Tp>::lock() const _NOEXCEPT
	{
	shared_ptr<_Tp> __r;
	__r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_;
	if (__r.__cntrl_)
	__r.__ptr_ = __ptr_;
	return __r;
	}

	#if _LIBCPP_STD_VER > 14
	template <class _Tp = void> struct owner_less;
	#else
	template <class _Tp> struct owner_less;
	#endif

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS owner_less<shared_ptr<_Tp> >
	: binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool>
	{
	typedef bool result_type;
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT
	{return __x.owner_before(__y);}
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT
	{return __x.owner_before(__y);}
	_LIBCPP_INLINE_VISIBILITY
	bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT
	{return __x.owner_before(__y);}
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS owner_less<weak_ptr<_Tp> >
	: binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool>
	{
	typedef bool result_type;
	_LIBCPP_INLINE_VISIBILITY
	bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT
	{return __x.owner_before(__y);}
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT
	{return __x.owner_before(__y);}
	_LIBCPP_INLINE_VISIBILITY
	bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT
	{return __x.owner_before(__y);}
	};

	#if _LIBCPP_STD_VER > 14
	template <>
	struct _LIBCPP_TEMPLATE_VIS owner_less<void>
	{
	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	bool operator()( shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT
	{return __x.owner_before(__y);}
	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	bool operator()( shared_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const _NOEXCEPT
	{return __x.owner_before(__y);}
	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT
	{return __x.owner_before(__y);}
	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const _NOEXCEPT
	{return __x.owner_before(__y);}
	typedef void is_transparent;
	};
	#endif

	template<class _Tp>
	class _LIBCPP_TEMPLATE_VIS enable_shared_from_this
	{
	mutable weak_ptr<_Tp> __weak_this_;
	protected:
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	enable_shared_from_this() _NOEXCEPT {}
	_LIBCPP_INLINE_VISIBILITY
	enable_shared_from_this(enable_shared_from_this const&) _NOEXCEPT {}
	_LIBCPP_INLINE_VISIBILITY
	enable_shared_from_this& operator=(enable_shared_from_this const&) _NOEXCEPT
	{return *this;}
	_LIBCPP_INLINE_VISIBILITY
	~enable_shared_from_this() {}
	public:
	_LIBCPP_INLINE_VISIBILITY
	shared_ptr<_Tp> shared_from_this()
	{return shared_ptr<_Tp>(__weak_this_);}
	_LIBCPP_INLINE_VISIBILITY
	shared_ptr<_Tp const> shared_from_this() const
	{return shared_ptr<const _Tp>(__weak_this_);}

	#if _LIBCPP_STD_VER > 14
	_LIBCPP_INLINE_VISIBILITY
	weak_ptr<_Tp> weak_from_this() _NOEXCEPT
	{ return __weak_this_; }

	_LIBCPP_INLINE_VISIBILITY
	weak_ptr<const _Tp> weak_from_this() const _NOEXCEPT
	{ return __weak_this_; }
	#endif // _LIBCPP_STD_VER > 14

	template <class _Up> friend class shared_ptr;
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS hash<shared_ptr<_Tp> >
	{
	typedef shared_ptr<_Tp> argument_type;
	typedef size_t result_type;

	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(const argument_type& __ptr) const _NOEXCEPT
	{
	return hash<_Tp*>()(__ptr.get());
	}
	};

	template<class _CharT, class _Traits, class _Yp>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p);


	#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)

	class _LIBCPP_TYPE_VIS __sp_mut
	{
	void* __lx;
	public:
	void lock() _NOEXCEPT;
	void unlock() _NOEXCEPT;

	private:
	_LIBCPP_CONSTEXPR __sp_mut(void*) _NOEXCEPT;
	__sp_mut(const __sp_mut&);
	__sp_mut& operator=(const __sp_mut&);

	friend _LIBCPP_FUNC_VIS __sp_mut& __get_sp_mut(const void*);
	};

	_LIBCPP_FUNC_VIS _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
	__sp_mut& __get_sp_mut(const void*);

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	atomic_is_lock_free(const shared_ptr<_Tp>*)
	{
	return false;
	}

	template <class _Tp>
	_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
	shared_ptr<_Tp>
	atomic_load(const shared_ptr<_Tp>* __p)
	{
	__sp_mut& __m = __get_sp_mut(__p);
	__m.lock();
	shared_ptr<_Tp> __q = *__p;
	__m.unlock();
	return __q;
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
	shared_ptr<_Tp>
	atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
	{
	return atomic_load(__p);
	}

	template <class _Tp>
	_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
	void
	atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
	{
	__sp_mut& __m = __get_sp_mut(__p);
	__m.lock();
	__p->swap(__r);
	__m.unlock();
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
	void
	atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order)
	{
	atomic_store(__p, __r);
	}

	template <class _Tp>
	_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
	shared_ptr<_Tp>
	atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
	{
	__sp_mut& __m = __get_sp_mut(__p);
	__m.lock();
	__p->swap(__r);
	__m.unlock();
	return __r;
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
	shared_ptr<_Tp>
	atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order)
	{
	return atomic_exchange(__p, __r);
	}

	template <class _Tp>
	_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
	bool
	atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w)
	{
	shared_ptr<_Tp> __temp;
	__sp_mut& __m = __get_sp_mut(__p);
	__m.lock();
	if (__p->__owner_equivalent(*__v))
	{
	_VSTD::swap(__temp, *__p);
	*__p = __w;
	__m.unlock();
	return true;
	}
	_VSTD::swap(__temp, *__v);
	__v = __p;
	__m.unlock();
	return false;
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
	bool
	atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w)
	{
	return atomic_compare_exchange_strong(__p, __v, __w);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
	bool
	atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
	shared_ptr<_Tp> __w, memory_order, memory_order)
	{
	return atomic_compare_exchange_strong(__p, __v, __w);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
	bool
	atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
	shared_ptr<_Tp> __w, memory_order, memory_order)
	{
	return atomic_compare_exchange_weak(__p, __v, __w);
	}

	#endif // !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)

	//enum class
	#if defined(_LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE)
	# ifndef _LIBCPP_CXX03_LANG
	enum class pointer_safety : unsigned char {
	relaxed,
	preferred,
	strict
	};
	# endif
	#else
	struct _LIBCPP_TYPE_VIS pointer_safety
	{
	enum __lx
	{
	relaxed,
	preferred,
	strict
	};

	__lx __v_;

	_LIBCPP_INLINE_VISIBILITY
	pointer_safety() : __v_() {}

	_LIBCPP_INLINE_VISIBILITY
	pointer_safety(__lx __v) : __v_(__v) {}
	_LIBCPP_INLINE_VISIBILITY
	operator int() const {return __v_;}
	};
	#endif

	#if !defined(_LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE) && \
	defined(_LIBCPP_BUILDING_MEMORY)
	_LIBCPP_FUNC_VIS pointer_safety get_pointer_safety() _NOEXCEPT;
	#else
	// This function is only offered in C++03 under ABI v1.
	# if !defined(_LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE) \|\| !defined(_LIBCPP_CXX03_LANG)
	inline _LIBCPP_INLINE_VISIBILITY
	pointer_safety get_pointer_safety() _NOEXCEPT {
	return pointer_safety::relaxed;
	}
	# endif
	#endif


	_LIBCPP_FUNC_VIS void declare_reachable(void* __p);
	_LIBCPP_FUNC_VIS void declare_no_pointers(char* __p, size_t __n);
	_LIBCPP_FUNC_VIS void undeclare_no_pointers(char* __p, size_t __n);
	_LIBCPP_FUNC_VIS void* __undeclare_reachable(void* __p);

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp*
	undeclare_reachable(_Tp* __p)
	{
	return static_cast<_Tp*>(__undeclare_reachable(__p));
	}

	_LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);

	// --- Helper for container swap --
	template <typename _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	void __swap_allocator(_Alloc & __a1, _Alloc & __a2)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT
	#else
	_NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
	#endif
	{
	__swap_allocator(__a1, __a2,
	integral_constant<bool, _VSTD::allocator_traits<_Alloc>::propagate_on_container_swap::value>());
	}

	template <typename _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	void __swap_allocator(_Alloc & __a1, _Alloc & __a2, true_type)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT
	#else
	_NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
	#endif
	{
	using _VSTD::swap;
	swap(__a1, __a2);
	}

	template <typename _Alloc>
	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,
	_Traits::propagate_on_container_move_assignment::value
	#if _LIBCPP_STD_VER > 14
	\|\| _Traits::is_always_equal::value
	#else
	&& is_nothrow_move_assignable<_Alloc>::value
	#endif
	> {};


	#ifndef _LIBCPP_HAS_NO_VARIADICS
	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
	+
	+template<typename _Alloc, typename = void, typename = void>
	+struct __is_allocator : false_type {};
	+
	+template<typename _Alloc>
	+struct __is_allocator<_Alloc,
	+ typename __void_t<typename _Alloc::value_type>::type,
	+ typename __void_t<decltype(_VSTD::declval<_Alloc&>().allocate(size_t(0)))>::type
	+ >
	+ : true_type {};

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_MEMORY
	Index: projects/clang700-import/contrib/libc++/include/module.modulemap
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/module.modulemap (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/module.modulemap (revision 337135)
	@@ -1,611 +1,600 @@
	// define the module for __config outside of the top level 'std' module
	// since __config may be included from C headers which may create an
	// include cycle.
	module std_config [system] [extern_c] {
	header "__config"
	}

	module std [system] {
	export std_config
	// FIXME: The standard does not require that each of these submodules
	// re-exports its imported modules. We should provide an alternative form of
	// export that issues a warning if a name from the submodule is used, and
	// use that to provide a 'strict mode' for libc++.

	// Deprecated C-compatibility headers. These can all be included from within
	// an 'extern "C"' context.
	module depr [extern_c] {
	// <assert.h> provided by C library.
	module ctype_h {
	header "ctype.h"
	export *
	}
	module errno_h {
	header "errno.h"
	export *
	}
	// <fenv.h> provided by C library.
	// <float.h> provided by compiler or C library.
	module inttypes_h {
	header "inttypes.h"
	export stdint_h
	export *
	}
	// <iso646.h> provided by compiler.
	// <limits.h> provided by compiler or C library.
	module locale_h {
	header "locale.h"
	export *
	}
	module math_h {
	header "math.h"
	export *
	}
	module setjmp_h {
	header "setjmp.h"
	export *
	}
	// FIXME: <stdalign.h> is missing.
	// <signal.h> provided by C library.
	// <stdarg.h> provided by compiler.
	// <stdbool.h> provided by compiler.
	module stddef_h {
	// <stddef.h>'s __need_* macros require textual inclusion.
	textual header "stddef.h"
	}
	module stdint_h {
	header "stdint.h"
	export *
	// FIXME: This module only exists on OS X and for some reason the
	// wildcard above doesn't export it.
	export Darwin.C.stdint
	}
	module stdio_h {
	// <stdio.h>'s __need_* macros require textual inclusion.
	textual header "stdio.h"
	export *
	export Darwin.C.stdio
	}
	module stdlib_h {
	// <stdlib.h>'s __need_* macros require textual inclusion.
	textual header "stdlib.h"
	export *
	}
	module string_h {
	header "string.h"
	export *
	}
	// FIXME: <uchar.h> is missing.
	// <time.h> provided by C library.
	module wchar_h {
	// <wchar.h>'s __need_* macros require textual inclusion.
	textual header "wchar.h"
	export *
	}
	module wctype_h {
	header "wctype.h"
	export *
	}
	}

	// <complex.h> and <tgmath.h> are not C headers in any real sense, do not
	// allow their use in extern "C" contexts.
	module complex_h {
	header "complex.h"
	export ccomplex
	export *
	}
	module tgmath_h {
	header "tgmath.h"
	export ccomplex
	export cmath
	export *
	}

	// C compatibility headers.
	module compat {
	module cassert {
	// <cassert>'s use of NDEBUG requires textual inclusion.
	textual header "cassert"
	}
	module ccomplex {
	header "ccomplex"
	export complex
	export *
	}
	module cctype {
	header "cctype"
	export *
	}
	module cerrno {
	header "cerrno"
	export *
	}
	module cfenv {
	header "cfenv"
	export *
	}
	module cfloat {
	header "cfloat"
	export *
	}
	module cinttypes {
	header "cinttypes"
	export cstdint
	export *
	}
	module ciso646 {
	header "ciso646"
	export *
	}
	module climits {
	header "climits"
	export *
	}
	module clocale {
	header "clocale"
	export *
	}
	module cmath {
	header "cmath"
	export *
	}
	module csetjmp {
	header "csetjmp"
	export *
	}
	module csignal {
	header "csignal"
	export *
	}
	// FIXME: <cstdalign> is missing.
	module cstdarg {
	header "cstdarg"
	export *
	}
	module cstdbool {
	header "cstdbool"
	export *
	}
	module cstddef {
	header "cstddef"
	export *
	}
	module cstdint {
	header "cstdint"
	export depr.stdint_h
	export *
	}
	module cstdio {
	header "cstdio"
	export *
	}
	module cstdlib {
	header "cstdlib"
	export *
	}
	module cstring {
	header "cstring"
	export *
	}
	module ctgmath {
	header "ctgmath"
	export ccomplex
	export cmath
	export *
	}
	module ctime {
	header "ctime"
	export *
	}
	// FIXME: <cuchar> is missing.
	module cwchar {
	header "cwchar"
	export depr.stdio_h
	export *
	}
	module cwctype {
	header "cwctype"
	export *
	}
	}

	module algorithm {
	header "algorithm"
	export initializer_list
	export *
	}
	module any {
	header "any"
	export *
	}
	module array {
	header "array"
	export initializer_list
	export *
	}
	module atomic {
	header "atomic"
	export *
	}
	module bitset {
	header "bitset"
	export string
	export iosfwd
	export *
	}
	// No submodule for cassert. It fundamentally needs repeated, textual inclusion.
	module chrono {
	header "chrono"
	export *
	}
	module codecvt {
	header "codecvt"
	export *
	}
	+ module compare {
	+ header "compare"
	+ export *
	+ }
	module complex {
	header "complex"
	export *
	}
	module condition_variable {
	header "condition_variable"
	export *
	}
	module deque {
	header "deque"
	export initializer_list
	export *
	}
	module exception {
	header "exception"
	export *
	}
	+ module filesystem {
	+ header "filesystem"
	+ export *
	+ }
	module forward_list {
	header "forward_list"
	export initializer_list
	export *
	}
	module fstream {
	header "fstream"
	export *
	}
	module functional {
	header "functional"
	export *
	}
	module future {
	header "future"
	export *
	}
	module initializer_list {
	header "initializer_list"
	export *
	}
	module iomanip {
	header "iomanip"
	export *
	}
	module ios {
	header "ios"
	export iosfwd
	export *
	}
	module iosfwd {
	header "iosfwd"
	export *
	}
	module iostream {
	header "iostream"
	export ios
	export streambuf
	export istream
	export ostream
	export *
	}
	module istream {
	header "istream"
	// FIXME: should re-export ios, streambuf?
	export *
	}
	module iterator {
	header "iterator"
	export *
	}
	module limits {
	header "limits"
	export *
	}
	module list {
	header "list"
	export initializer_list
	export *
	}
	module locale {
	header "locale"
	export *
	}
	module map {
	header "map"
	export initializer_list
	export *
	}
	module memory {
	header "memory"
	export *
	}
	module mutex {
	header "mutex"
	export *
	}
	module new {
	header "new"
	export *
	}
	module numeric {
	header "numeric"
	export *
	}
	module optional {
	header "optional"
	export *
	}
	module ostream {
	header "ostream"
	// FIXME: should re-export ios, streambuf?
	export *
	}
	module queue {
	header "queue"
	export initializer_list
	export *
	}
	module random {
	header "random"
	export initializer_list
	export *
	}
	module ratio {
	header "ratio"
	export *
	}
	module regex {
	header "regex"
	export initializer_list
	export *
	}
	module scoped_allocator {
	header "scoped_allocator"
	export *
	}
	module set {
	header "set"
	export initializer_list
	export *
	}
	module sstream {
	header "sstream"
	// FIXME: should re-export istream, ostream, ios, streambuf, string?
	export *
	}
	module stack {
	header "stack"
	export initializer_list
	export *
	}
	module stdexcept {
	header "stdexcept"
	export *
	}
	module streambuf {
	header "streambuf"
	export *
	}
	module string {
	header "string"
	export initializer_list
	export string_view
	export __string
	export *
	}
	module string_view {
	header "string_view"
	export initializer_list
	export __string
	export *
	}
	module strstream {
	header "strstream"
	export *
	}
	module system_error {
	header "system_error"
	export *
	}
	module thread {
	header "thread"
	export *
	}
	module tuple {
	header "tuple"
	export *
	}
	module type_traits {
	header "type_traits"
	export *
	}
	module typeindex {
	header "typeindex"
	export *
	}
	module typeinfo {
	header "typeinfo"
	export *
	}
	module unordered_map {
	header "unordered_map"
	export initializer_list
	export *
	}
	module unordered_set {
	header "unordered_set"
	export initializer_list
	export *
	}
	module utility {
	header "utility"
	export initializer_list
	export *
	}
	module valarray {
	header "valarray"
	export initializer_list
	export *
	}
	module variant {
	header "variant"
	export *
	}
	module vector {
	header "vector"
	export initializer_list
	export *
	}
	+ module version {
	+ header "version"
	+ export *
	+ }

	// FIXME: These should be private.
	module __bit_reference { header "__bit_reference" export * }
	module __debug { header "__debug" export * }
	+ module __errc { header "__errc" export * }
	module __functional_base { header "__functional_base" export * }
	module __hash_table { header "__hash_table" export * }
	module __locale { header "__locale" export * }
	module __mutex_base { header "__mutex_base" export * }
	module __split_buffer { header "__split_buffer" export * }
	module __sso_allocator { header "__sso_allocator" export * }
	module __std_stream { header "__std_stream" export * }
	module __string { header "__string" export * }
	module __tree { header "__tree" export * }
	module __tuple { header "__tuple" export * }
	module __undef_macros { header "__undef_macros" export * }

	module experimental {
	requires cplusplus11

	module algorithm {
	header "experimental/algorithm"
	export *
	}
	- module any {
	- header "experimental/any"
	- export *
	- }
	- module chrono {
	- header "experimental/chrono"
	- export *
	- }
	module coroutine {
	requires coroutines
	header "experimental/coroutine"
	export *
	}
	module deque {
	header "experimental/deque"
	export *
	}
	module dynarray {
	header "experimental/dynarray"
	export *
	}
	module filesystem {
	header "experimental/filesystem"
	export *
	}
	module forward_list {
	header "experimental/forward_list"
	export *
	}
	module functional {
	header "experimental/functional"
	export *
	}
	module iterator {
	header "experimental/iterator"
	export *
	}
	module list {
	header "experimental/list"
	export *
	}
	module map {
	header "experimental/map"
	export *
	}
	module memory_resource {
	header "experimental/memory_resource"
	export *
	}
	- module numeric {
	- header "experimental/numeric"
	- export *
	- }
	- module optional {
	- header "experimental/optional"
	- export *
	- }
	module propagate_const {
	header "experimental/propagate_const"
	export *
	}
	- module ratio {
	- header "experimental/ratio"
	- export *
	- }
	module regex {
	header "experimental/regex"
	export *
	}
	+ module simd {
	+ header "experimental/simd"
	+ export *
	+ }
	module set {
	header "experimental/set"
	export *
	}
	- module string {
	- header "experimental/string"
	+ module span {
	+ header "span"
	export *
	}
	- module string_view {
	- header "experimental/string_view"
	- export *
	- }
	- module system_error {
	- header "experimental/system_error"
	- export *
	- }
	- module tuple {
	- header "experimental/tuple"
	+ module string {
	+ header "experimental/string"
	export *
	}
	module type_traits {
	header "experimental/type_traits"
	export *
	}
	module unordered_map {
	header "experimental/unordered_map"
	export *
	}
	module unordered_set {
	header "experimental/unordered_set"
	export *
	}
	module utility {
	header "experimental/utility"
	export *
	}
	module vector {
	header "experimental/vector"
	export *
	}
	// FIXME these should be private
	module __memory {
	header "experimental/__memory"
	export *
	}
	} // end experimental
	}
	Index: projects/clang700-import/contrib/libc++/include/new
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/new (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/new (revision 337135)
	@@ -1,280 +1,323 @@
	// -- C++ --
	//===----------------------------- new ------------------------------------===//
	//
	// 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_NEW
	#define _LIBCPP_NEW

	/*
	new synopsis

	namespace std
	{

	class bad_alloc
	: public exception
	{
	public:
	bad_alloc() noexcept;
	bad_alloc(const bad_alloc&) noexcept;
	bad_alloc& operator=(const bad_alloc&) noexcept;
	virtual const char* what() const noexcept;
	};

	class bad_array_length : public bad_alloc // FIXME: Not part of C++
	{
	public:
	bad_array_length() noexcept;
	};

	class bad_array_new_length : public bad_alloc // C++14
	{
	public:
	bad_array_new_length() noexcept;
	};

	enum class align_val_t : size_t {}; // C++17
	struct nothrow_t {};
	extern const nothrow_t nothrow;
	typedef void (*new_handler)();
	new_handler set_new_handler(new_handler new_p) noexcept;
	new_handler get_new_handler() noexcept;

	// 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, 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, 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
	void operator delete(void* ptr, std::size_t size,
	std::align_val_t alignment) noexcept; // replaceable, C++17
	void operator delete(void* ptr, const std::nothrow_t&) noexcept; // replaceable
	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, nodiscard in C++2a
	void* operator new[](std::size_t size,
	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, 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
	void operator delete[](void* ptr, std::size_t size,
	std::align_val_t alignment) noexcept; // replaceable, C++17
	void operator delete[](void* ptr, const std::nothrow_t&) noexcept; // replaceable
	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; // 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;

	*/

	#include <__config>
	#include <exception>
	+#include <type_traits>
	#include <cstddef>
	#ifdef _LIBCPP_NO_EXCEPTIONS
	#include <cstdlib>
	#endif

	#if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_NO_VCRUNTIME)
	#include <new.h>
	#endif

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	#if !(defined(_LIBCPP_BUILDING_NEW) \|\| _LIBCPP_STD_VER >= 14 \|\| \
	(defined(__cpp_sized_deallocation) && __cpp_sized_deallocation >= 201309))
	# define _LIBCPP_HAS_NO_SIZED_DEALLOCATION
	#endif

	#if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) && \
	(!(defined(_LIBCPP_BUILDING_NEW) \|\| _LIBCPP_STD_VER > 14 \|\| \
	(defined(__cpp_aligned_new) && __cpp_aligned_new >= 201606)))
	# define _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
	#endif

	+
	+#if !__has_builtin(__builtin_operator_new) \|\| \
	+ __has_builtin(__builtin_operator_new) < 201802L \|\| \
	+ defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) \|\| \
	+ !defined(__cpp_aligned_new) \|\| __cpp_aligned_new < 201606
	+#define _LIBCPP_HAS_NO_BUILTIN_ALIGNED_OPERATOR_NEW_DELETE
	+#endif
	+
	namespace std // purposefully not using versioning namespace
	{

	#if !defined(_LIBCPP_ABI_MICROSOFT) \|\| defined(_LIBCPP_NO_VCRUNTIME)
	struct _LIBCPP_TYPE_VIS nothrow_t {};
	extern _LIBCPP_FUNC_VIS const nothrow_t nothrow;

	class _LIBCPP_EXCEPTION_ABI bad_alloc
	: public exception
	{
	public:
	bad_alloc() _NOEXCEPT;
	virtual ~bad_alloc() _NOEXCEPT;
	virtual const char* what() const _NOEXCEPT;
	};

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

	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 \|\| _LIBCPP_NO_VCRUNTIME

	_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_bad_alloc(); // not in C++ spec

	#if defined(_LIBCPP_BUILDING_LIBRARY) \|\| (_LIBCPP_STD_VER > 11)

	class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ARRAY_LENGTH
	bad_array_length : public bad_alloc {
	public:
	bad_array_length() _NOEXCEPT;
	virtual ~bad_array_length() _NOEXCEPT;
	virtual const char* what() const _NOEXCEPT;
	};

	#define _LIBCPP_BAD_ARRAY_LENGTH_DEFINED

	#endif // defined(_LIBCPP_BUILDING_NEW) \|\| (_LIBCPP_STD_VER > 11)

	+#if !defined(_LIBCPP_ABI_MICROSOFT) \|\| defined(_LIBCPP_NO_VCRUNTIME)
	#if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) \|\| _LIBCPP_STD_VER > 14
	#ifndef _LIBCPP_CXX03_LANG
	enum class _LIBCPP_ENUM_VIS align_val_t : size_t { };
	#else
	enum align_val_t { __zero = 0, __max = (size_t)-1 };
	#endif
	#endif
	+#endif

	} // std

	#if defined(_LIBCPP_CXX03_LANG)
	#define _THROW_BAD_ALLOC throw(std::bad_alloc)
	#else
	#define _THROW_BAD_ALLOC
	#endif

	#if !defined(_LIBCPP_ABI_MICROSOFT) \|\| defined(_LIBCPP_NO_VCRUNTIME)

	_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_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

	#ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
	_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_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
	#endif

	_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 \|\| _LIBCPP_NO_VCRUNTIME

	_LIBCPP_BEGIN_NAMESPACE_STD

	-inline _LIBCPP_INLINE_VISIBILITY void *__allocate(size_t __size) {
	+_LIBCPP_CONSTEXPR inline _LIBCPP_INLINE_VISIBILITY bool __is_overaligned_for_new(size_t __align) _NOEXCEPT {
	+#ifdef __STDCPP_DEFAULT_NEW_ALIGNMENT__
	+ return __align > __STDCPP_DEFAULT_NEW_ALIGNMENT__;
	+#else
	+ return __align > alignment_of<max_align_t>::value;
	+#endif
	+}
	+
	+inline _LIBCPP_INLINE_VISIBILITY void *__libcpp_allocate(size_t __size, size_t __align) {
	+#ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
	+ if (__is_overaligned_for_new(__align)) {
	+ const align_val_t __align_val = static_cast<align_val_t>(__align);
	+# ifdef _LIBCPP_HAS_NO_BUILTIN_ALIGNED_OPERATOR_NEW_DELETE
	+ return ::operator new(__size, __align_val);
	+# else
	+ return __builtin_operator_new(__size, __align_val);
	+# endif
	+ }
	+#else
	+ ((void)__align);
	+#endif
	#ifdef _LIBCPP_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE
	return ::operator new(__size);
	#else
	return __builtin_operator_new(__size);
	#endif
	}

	-inline _LIBCPP_INLINE_VISIBILITY void __libcpp_deallocate(void *__ptr) {
	+inline _LIBCPP_INLINE_VISIBILITY void __libcpp_deallocate(void* __ptr, size_t __align) {
	+#ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
	+ if (__is_overaligned_for_new(__align)) {
	+ const align_val_t __align_val = static_cast<align_val_t>(__align);
	+# ifdef _LIBCPP_HAS_NO_BUILTIN_ALIGNED_OPERATOR_NEW_DELETE
	+ return ::operator delete(__ptr, __align_val);
	+# else
	+ return __builtin_operator_delete(__ptr, __align_val);
	+# endif
	+ }
	+#else
	+ ((void)__align);
	+#endif
	#ifdef _LIBCPP_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE
	- ::operator delete(__ptr);
	+ return ::operator delete(__ptr);
	#else
	- __builtin_operator_delete(__ptr);
	+ return __builtin_operator_delete(__ptr);
	#endif
	}

	#ifdef _LIBCPP_BAD_ARRAY_LENGTH_DEFINED
	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
	#ifndef _LIBCPP_NO_EXCEPTIONS
	_LIBCPP_AVAILABILITY_BAD_ARRAY_LENGTH
	#endif
	void __throw_bad_array_length()
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw bad_array_length();
	#else
	_VSTD::abort();
	#endif
	}
	#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
	Index: projects/clang700-import/contrib/libc++/include/numeric
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/numeric (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/numeric (revision 337135)
	@@ -1,526 +1,526 @@
	// -- C++ --
	//===---------------------------- numeric ---------------------------------===//
	//
	// 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_NUMERIC
	#define _LIBCPP_NUMERIC

	/*
	numeric synopsis

	namespace std
	{

	template <class InputIterator, class T>
	T
	accumulate(InputIterator first, InputIterator last, T init);

	template <class InputIterator, class T, class BinaryOperation>
	T
	accumulate(InputIterator first, InputIterator last, T init, BinaryOperation binary_op);

	template<class InputIterator>
	typename iterator_traits<InputIterator>::value_type
	reduce(InputIterator first, InputIterator last); // C++17

	template<class InputIterator, class T>
	T
	reduce(InputIterator first, InputIterator last, T init); // C++17

	template<class InputIterator, class T, class BinaryOperation>
	T
	reduce(InputIterator first, InputIterator last, T init, BinaryOperation binary_op); // C++17

	template <class InputIterator1, class InputIterator2, class T>
	T
	inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init);

	template <class InputIterator1, class InputIterator2, class T, class BinaryOperation1, class BinaryOperation2>
	T
	inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
	T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2);


	template<class InputIterator1, class InputIterator2, class T>
	T
	transform_reduce(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, T init); // C++17
	-
	+
	template<class InputIterator1, class InputIterator2, class T, class BinaryOperation1, class BinaryOperation2>
	T
	transform_reduce(InputIterator1 first1, InputIterator1 last1,
	InputIterator2 first2, T init,
	BinaryOperation1 binary_op1, BinaryOperation2 binary_op2); // C++17

	template<class InputIterator, class T, class BinaryOperation, class UnaryOperation>
	T
	transform_reduce(InputIterator first, InputIterator last, T init,
	BinaryOperation binary_op, UnaryOperation unary_op); // C++17

	template <class InputIterator, class OutputIterator>
	OutputIterator
	partial_sum(InputIterator first, InputIterator last, OutputIterator result);

	template <class InputIterator, class OutputIterator, class BinaryOperation>
	OutputIterator
	partial_sum(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op);

	template<class InputIterator, class OutputIterator, class T>
	OutputIterator
	exclusive_scan(InputIterator first, InputIterator last,
	OutputIterator result, T init); // C++17
	-
	+
	template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
	OutputIterator
	- exclusive_scan(InputIterator first, InputIterator last,
	+ exclusive_scan(InputIterator first, InputIterator last,
	OutputIterator result, T init, BinaryOperation binary_op); // C++17

	template<class InputIterator, class OutputIterator>
	OutputIterator
	inclusive_scan(InputIterator first, InputIterator last, OutputIterator result); // C++17

	template<class InputIterator, class OutputIterator, class BinaryOperation>
	OutputIterator
	inclusive_scan(InputIterator first, InputIterator last,
	OutputIterator result, BinaryOperation binary_op); // C++17

	template<class InputIterator, class OutputIterator, class BinaryOperation, class T>
	OutputIterator
	inclusive_scan(InputIterator first, InputIterator last,
	OutputIterator result, BinaryOperation binary_op, T init); // C++17

	template<class InputIterator, class OutputIterator, class T,
	class BinaryOperation, class UnaryOperation>
	OutputIterator
	transform_exclusive_scan(InputIterator first, InputIterator last,
	OutputIterator result, T init,
	BinaryOperation binary_op, UnaryOperation unary_op); // C++17

	template<class InputIterator, class OutputIterator,
	class BinaryOperation, class UnaryOperation>
	OutputIterator
	transform_inclusive_scan(InputIterator first, InputIterator last,
	OutputIterator result,
	BinaryOperation binary_op, UnaryOperation unary_op); // C++17
	-
	+
	template<class InputIterator, class OutputIterator,
	class BinaryOperation, class UnaryOperation, class T>
	OutputIterator
	transform_inclusive_scan(InputIterator first, InputIterator last,
	OutputIterator result,
	BinaryOperation binary_op, UnaryOperation unary_op,
	T init); // C++17

	template <class InputIterator, class OutputIterator>
	OutputIterator
	adjacent_difference(InputIterator first, InputIterator last, OutputIterator result);

	template <class InputIterator, class OutputIterator, class BinaryOperation>
	OutputIterator
	adjacent_difference(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op);

	template <class ForwardIterator, class T>
	void iota(ForwardIterator first, ForwardIterator last, T value);

	template <class M, class N>
	constexpr common_type_t<M,N> gcd(M m, N n); // C++17

	template <class M, class N>
	constexpr common_type_t<M,N> lcm(M m, N n); // C++17

	} // std

	*/

	#include <__config>
	#include <iterator>
	#include <limits> // for numeric_limits
	#include <functional>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>

	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _InputIterator, class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
	{
	for (; __first != __last; ++__first)
	__init = __init + *__first;
	return __init;
	}

	template <class _InputIterator, class _Tp, class _BinaryOperation>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	accumulate(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOperation __binary_op)
	{
	for (; __first != __last; ++__first)
	__init = __binary_op(__init, *__first);
	return __init;
	}

	#if _LIBCPP_STD_VER > 14
	template <class _InputIterator, class _Tp, class _BinaryOp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	reduce(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOp __b)
	{
	for (; __first != __last; ++__first)
	__init = __b(__init, *__first);
	return __init;
	}

	template <class _InputIterator, class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	reduce(_InputIterator __first, _InputIterator __last, _Tp __init)
	{
	return _VSTD::reduce(__first, __last, __init, _VSTD::plus<>());
	}

	template <class _InputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename iterator_traits<_InputIterator>::value_type
	reduce(_InputIterator __first, _InputIterator __last)
	{
	- return _VSTD::reduce(__first, __last,
	+ return _VSTD::reduce(__first, __last,
	typename iterator_traits<_InputIterator>::value_type{});
	}
	#endif

	template <class _InputIterator1, class _InputIterator2, class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init)
	{
	for (; __first1 != __last1; ++__first1, (void) ++__first2)
	__init = __init + __first1 *__first2;
	return __init;
	}

	template <class _InputIterator1, class _InputIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2,
	_Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2)
	{
	for (; __first1 != __last1; ++__first1, (void) ++__first2)
	__init = __binary_op1(__init, __binary_op2(__first1, __first2));
	return __init;
	}

	#if _LIBCPP_STD_VER > 14
	template <class _InputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	-transform_reduce(_InputIterator __first, _InputIterator __last,
	+transform_reduce(_InputIterator __first, _InputIterator __last,
	_Tp __init, _BinaryOp __b, _UnaryOp __u)
	{
	for (; __first != __last; ++__first)
	__init = __b(__init, __u(*__first));
	return __init;
	}

	-template <class _InputIterator1, class _InputIterator2,
	+template <class _InputIterator1, class _InputIterator2,
	class _Tp, class _BinaryOp1, class _BinaryOp2>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _Tp __init, _BinaryOp1 __b1, _BinaryOp2 __b2)
	{
	for (; __first1 != __last1; ++__first1, (void) ++__first2)
	__init = __b1(__init, __b2(__first1, __first2));
	return __init;
	}

	template <class _InputIterator1, class _InputIterator2, class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp
	-transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1,
	+transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1,
	_InputIterator2 __first2, _Tp __init)
	{
	- return _VSTD::transform_reduce(__first1, __last1, __first2, __init,
	+ return _VSTD::transform_reduce(__first1, __last1, __first2, _VSTD::move(__init),
	_VSTD::plus<>(), _VSTD::multiplies<>());
	}
	#endif

	template <class _InputIterator, class _OutputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
	{
	if (__first != __last)
	{
	typename iterator_traits<_InputIterator>::value_type __t(*__first);
	*__result = __t;
	for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
	{
	__t = __t + *__first;
	*__result = __t;
	}
	}
	return __result;
	}

	template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
	_BinaryOperation __binary_op)
	{
	if (__first != __last)
	{
	typename iterator_traits<_InputIterator>::value_type __t(*__first);
	*__result = __t;
	for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
	{
	__t = __binary_op(__t, *__first);
	*__result = __t;
	}
	}
	return __result;
	}

	#if _LIBCPP_STD_VER > 14
	template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	-exclusive_scan(_InputIterator __first, _InputIterator __last,
	+exclusive_scan(_InputIterator __first, _InputIterator __last,
	_OutputIterator __result, _Tp __init, _BinaryOp __b)
	{
	if (__first != __last)
	{
	_Tp __saved = __init;
	do
	{
	__init = __b(__init, *__first);
	*__result = __saved;
	__saved = __init;
	++__result;
	} while (++__first != __last);
	}
	return __result;
	}

	template <class _InputIterator, class _OutputIterator, class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	-exclusive_scan(_InputIterator __first, _InputIterator __last,
	+exclusive_scan(_InputIterator __first, _InputIterator __last,
	_OutputIterator __result, _Tp __init)
	{
	return _VSTD::exclusive_scan(__first, __last, __result, __init, _VSTD::plus<>());
	}

	template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
	-_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
	+_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
	_OutputIterator __result, _BinaryOp __b, _Tp __init)
	{
	for (; __first != __last; ++__first, (void) ++__result) {
	__init = __b(__init, *__first);
	*__result = __init;
	}
	return __result;
	}

	template <class _InputIterator, class _OutputIterator, class _BinaryOp>
	-_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
	+_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
	_OutputIterator __result, _BinaryOp __b)
	{
	if (__first != __last) {
	typename std::iterator_traits<_InputIterator>::value_type __init = *__first;
	*__result++ = __init;
	if (++__first != __last)
	return _VSTD::inclusive_scan(__first, __last, __result, __b, __init);
	}

	return __result;
	}

	template <class _InputIterator, class _OutputIterator>
	-_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
	+_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
	_OutputIterator __result)
	{
	return _VSTD::inclusive_scan(__first, __last, __result, std::plus<>());
	}

	-template <class _InputIterator, class _OutputIterator, class _Tp,
	+template <class _InputIterator, class _OutputIterator, class _Tp,
	class _BinaryOp, class _UnaryOp>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	-transform_exclusive_scan(_InputIterator __first, _InputIterator __last,
	+transform_exclusive_scan(_InputIterator __first, _InputIterator __last,
	_OutputIterator __result, _Tp __init,
	_BinaryOp __b, _UnaryOp __u)
	{
	if (__first != __last)
	{
	_Tp __saved = __init;
	do
	{
	__init = __b(__init, __u(*__first));
	*__result = __saved;
	__saved = __init;
	++__result;
	} while (++__first != __last);
	}
	return __result;
	}

	template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
	-_OutputIterator transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
	+_OutputIterator transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
	_OutputIterator __result, _BinaryOp __b, _UnaryOp __u, _Tp __init)
	{
	for (; __first != __last; ++__first, (void) ++__result) {
	__init = __b(__init, __u(*__first));
	*__result = __init;
	}

	return __result;
	}

	template <class _InputIterator, class _OutputIterator, class _BinaryOp, class _UnaryOp>
	-_OutputIterator transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
	+_OutputIterator transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
	_OutputIterator __result, _BinaryOp __b, _UnaryOp __u)
	{
	if (__first != __last) {
	typename std::iterator_traits<_InputIterator>::value_type __init = __u(*__first);
	*__result++ = __init;
	if (++__first != __last)
	return _VSTD::transform_inclusive_scan(__first, __last, __result, __b, __u, __init);
	}
	-
	+
	return __result;
	}
	#endif

	template <class _InputIterator, class _OutputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
	{
	if (__first != __last)
	{
	typename iterator_traits<_InputIterator>::value_type __t1(*__first);
	*__result = __t1;
	for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
	{
	typename iterator_traits<_InputIterator>::value_type __t2(*__first);
	*__result = __t2 - __t1;
	__t1 = _VSTD::move(__t2);
	}
	}
	return __result;
	}

	template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
	inline _LIBCPP_INLINE_VISIBILITY
	_OutputIterator
	adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
	_BinaryOperation __binary_op)
	{
	if (__first != __last)
	{
	typename iterator_traits<_InputIterator>::value_type __t1(*__first);
	*__result = __t1;
	for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
	{
	typename iterator_traits<_InputIterator>::value_type __t2(*__first);
	*__result = __binary_op(__t2, __t1);
	__t1 = _VSTD::move(__t2);
	}
	}
	return __result;
	}

	template <class _ForwardIterator, class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value_)
	{
	for (; __first != __last; ++__first, (void) ++__value_)
	*__first = __value_;
	}


	#if _LIBCPP_STD_VER > 14
	template <typename _Result, typename _Source, bool _IsSigned = is_signed<_Source>::value> struct __abs;

	template <typename _Result, typename _Source>
	struct __abs<_Result, _Source, true> {
	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
	_Result operator()(_Source __t) const noexcept
	{
	if (__t >= 0) return __t;
	if (__t == numeric_limits<_Source>::min()) return -static_cast<_Result>(__t);
	return -__t;
	}
	};

	template <typename _Result, typename _Source>
	struct __abs<_Result, _Source, false> {
	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
	_Result operator()(_Source __t) const noexcept { return __t; }
	};


	template<class _Tp>
	_LIBCPP_CONSTEXPR _LIBCPP_HIDDEN
	_Tp __gcd(_Tp __m, _Tp __n)
	{
	static_assert((!is_signed<_Tp>::value), "");
	return __n == 0 ? __m : _VSTD::__gcd<_Tp>(__n, __m % __n);
	}


	template<class _Tp, class _Up>
	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
	common_type_t<_Tp,_Up>
	gcd(_Tp __m, _Up __n)
	{
	static_assert((is_integral<_Tp>::value && is_integral<_Up>::value), "Arguments to gcd must be integer types");
	static_assert((!is_same<typename remove_cv<_Tp>::type, bool>::value), "First argument to gcd cannot be bool" );
	static_assert((!is_same<typename remove_cv<_Up>::type, bool>::value), "Second argument to gcd cannot be bool" );
	using _Rp = common_type_t<_Tp,_Up>;
	using _Wp = make_unsigned_t<_Rp>;
	return static_cast<_Rp>(_VSTD::__gcd(
	static_cast<_Wp>(__abs<_Rp, _Tp>()(__m)),
	static_cast<_Wp>(__abs<_Rp, _Up>()(__n))));
	}

	template<class _Tp, class _Up>
	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
	common_type_t<_Tp,_Up>
	lcm(_Tp __m, _Up __n)
	{
	static_assert((is_integral<_Tp>::value && is_integral<_Up>::value), "Arguments to lcm must be integer types");
	static_assert((!is_same<typename remove_cv<_Tp>::type, bool>::value), "First argument to lcm cannot be bool" );
	static_assert((!is_same<typename remove_cv<_Up>::type, bool>::value), "Second argument to lcm cannot be bool" );
	if (__m == 0 \|\| __n == 0)
	return 0;

	using _Rp = common_type_t<_Tp,_Up>;
	_Rp __val1 = __abs<_Rp, _Tp>()(__m) / _VSTD::gcd(__m, __n);
	_Rp __val2 = __abs<_Rp, _Up>()(__n);
	_LIBCPP_ASSERT((numeric_limits<_Rp>::max() / __val1 > __val2), "Overflow in lcm");
	return __val1 * __val2;
	}

	#endif /* _LIBCPP_STD_VER > 14 */

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_NUMERIC
	Index: projects/clang700-import/contrib/libc++/include/optional
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/optional (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/optional (revision 337135)
	@@ -1,1399 +1,1408 @@
	// -- C++ --
	//===-------------------------- optional ----------------------------------===//
	//
	// 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_OPTIONAL
	#define _LIBCPP_OPTIONAL

	/*
	optional synopsis

	// C++1z

	namespace std {
	// 23.6.3, optional for object types
	template <class T> class optional;

	// 23.6.4, no-value state indicator
	struct nullopt_t{see below };
	inline constexpr nullopt_t nullopt(unspecified );

	// 23.6.5, class bad_optional_access
	class bad_optional_access;

	// 23.6.6, relational operators
	template <class T, class U>
	constexpr bool operator==(const optional<T>&, const optional<U>&);
	template <class T, class U>
	constexpr bool operator!=(const optional<T>&, const optional<U>&);
	template <class T, class U>
	constexpr bool operator<(const optional<T>&, const optional<U>&);
	template <class T, class U>
	constexpr bool operator>(const optional<T>&, const optional<U>&);
	template <class T, class U>
	constexpr bool operator<=(const optional<T>&, const optional<U>&);
	template <class T, class U>
	constexpr bool operator>=(const optional<T>&, const optional<U>&);

	// 23.6.7 comparison with nullopt
	template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
	template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept;
	template <class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept;
	template <class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept;
	template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept;
	template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept;
	template <class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept;
	template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept;
	template <class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept;
	template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept;
	template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept;
	template <class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept;

	// 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 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 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 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 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 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 T&, const optional<U>&);

	// 23.6.9, specialized algorithms
	template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below );
	template <class T> constexpr optional<see below > make_optional(T&&);
	template <class T, class... Args>
	constexpr optional<T> make_optional(Args&&... args);
	template <class T, class U, class... Args>
	constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args);

	// 23.6.10, hash support
	template <class T> struct hash;
	template <class T> struct hash<optional<T>>;

	template <class T> class optional {
	public:
	using value_type = T;

	// 23.6.3.1, constructors
	constexpr optional() noexcept;
	constexpr optional(nullopt_t) noexcept;
	optional(const optional &);
	optional(optional &&) noexcept(see below);
	template <class... Args> constexpr explicit optional(in_place_t, Args &&...);
	template <class U, class... Args>
	constexpr explicit optional(in_place_t, initializer_list<U>, Args &&...);
	template <class U = T>
	constexpr EXPLICIT optional(U &&);
	template <class U>
	constexpr EXPLICIT optional(const optional<U> &);
	template <class U>
	constexpr EXPLICIT optional(optional<U> &&);

	// 23.6.3.2, destructor
	~optional();

	// 23.6.3.3, assignment
	optional &operator=(nullopt_t) noexcept;
	optional &operator=(const optional &);
	optional &operator=(optional &&) noexcept(see below );
	template <class U = T> optional &operator=(U &&);
	template <class U> optional &operator=(const optional<U> &);
	template <class U> optional &operator=(optional<U> &&);
	template <class... Args> T& emplace(Args &&...);
	template <class U, class... Args>
	T& emplace(initializer_list<U>, Args &&...);

	// 23.6.3.4, swap
	void swap(optional &) noexcept(see below );

	// 23.6.3.5, observers
	constexpr T const *operator->() const;
	constexpr T *operator->();
	constexpr T const &operator*() const &;
	constexpr T &operator*() &;
	constexpr T &&operator*() &&;
	constexpr const T &&operator*() const &&;
	constexpr explicit operator bool() const noexcept;
	constexpr bool has_value() const noexcept;
	constexpr T const &value() const &;
	constexpr T &value() &;
	constexpr T &&value() &&;
	constexpr const T &&value() const &&;
	template <class U> constexpr T value_or(U &&) const &;
	template <class U> constexpr T value_or(U &&) &&;

	// 23.6.3.6, modifiers
	void reset() noexcept;

	private:
	T *val; // exposition only
	};
	+
	+template<class T>
	+ optional(T) -> optional<T>;
	+
	} // namespace std

	*/

	#include <__config>
	#include <__debug>
	#include <__functional_base>
	#include <functional>
	#include <initializer_list>
	#include <new>
	#include <stdexcept>
	#include <type_traits>
	#include <utility>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	namespace std // purposefully not using versioning namespace
	{

	class _LIBCPP_EXCEPTION_ABI bad_optional_access
	: public exception
	{
	public:
	// Get the key function ~bad_optional_access() into the dylib
	virtual ~bad_optional_access() _NOEXCEPT;
	virtual const char* what() const _NOEXCEPT;
	};

	} // std

	#if _LIBCPP_STD_VER > 14

	_LIBCPP_BEGIN_NAMESPACE_STD

	_LIBCPP_NORETURN
	inline _LIBCPP_INLINE_VISIBILITY
	void __throw_bad_optional_access() {
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw bad_optional_access();
	#else
	_VSTD::abort();
	#endif
	}

	struct nullopt_t
	{
	struct __secret_tag { _LIBCPP_INLINE_VISIBILITY explicit __secret_tag() = default; };
	_LIBCPP_INLINE_VISIBILITY constexpr explicit nullopt_t(__secret_tag, __secret_tag) noexcept {}
	};

	_LIBCPP_INLINE_VAR constexpr nullopt_t nullopt{nullopt_t::__secret_tag{}, nullopt_t::__secret_tag{}};

	template <class _Tp, bool = is_trivially_destructible<_Tp>::value>
	struct __optional_destruct_base;

	template <class _Tp>
	struct __optional_destruct_base<_Tp, false>
	{
	typedef _Tp value_type;
	static_assert(is_object_v<value_type>,
	"instantiation of optional with a non-object type is undefined behavior");
	union
	{
	char __null_state_;
	value_type __val_;
	};
	bool __engaged_;

	_LIBCPP_INLINE_VISIBILITY
	~__optional_destruct_base()
	{
	if (__engaged_)
	__val_.~value_type();
	}

	_LIBCPP_INLINE_VISIBILITY
	constexpr __optional_destruct_base() noexcept
	: __null_state_(),
	__engaged_(false) {}

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
	: __val_(_VSTD::forward<_Args>(__args)...),
	__engaged_(true) {}

	_LIBCPP_INLINE_VISIBILITY
	void reset() noexcept
	{
	if (__engaged_)
	{
	__val_.~value_type();
	__engaged_ = false;
	}
	}
	};

	template <class _Tp>
	struct __optional_destruct_base<_Tp, true>
	{
	typedef _Tp value_type;
	static_assert(is_object_v<value_type>,
	"instantiation of optional with a non-object type is undefined behavior");
	union
	{
	char __null_state_;
	value_type __val_;
	};
	bool __engaged_;

	_LIBCPP_INLINE_VISIBILITY
	constexpr __optional_destruct_base() noexcept
	: __null_state_(),
	__engaged_(false) {}

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
	: __val_(_VSTD::forward<_Args>(__args)...),
	__engaged_(true) {}

	_LIBCPP_INLINE_VISIBILITY
	void reset() noexcept
	{
	if (__engaged_)
	{
	__engaged_ = false;
	}
	}
	};

	template <class _Tp, bool = is_reference<_Tp>::value>
	struct __optional_storage_base : __optional_destruct_base<_Tp>
	{
	using __base = __optional_destruct_base<_Tp>;
	using value_type = _Tp;
	using __base::__base;

	_LIBCPP_INLINE_VISIBILITY
	constexpr bool has_value() const noexcept
	{
	return this->__engaged_;
	}

	_LIBCPP_INLINE_VISIBILITY
	constexpr value_type& __get() & noexcept
	{
	return this->__val_;
	}
	_LIBCPP_INLINE_VISIBILITY
	constexpr const value_type& __get() const& noexcept
	{
	return this->__val_;
	}
	_LIBCPP_INLINE_VISIBILITY
	constexpr value_type&& __get() && noexcept
	{
	return _VSTD::move(this->__val_);
	}
	_LIBCPP_INLINE_VISIBILITY
	constexpr const value_type&& __get() const&& noexcept
	{
	return _VSTD::move(this->__val_);
	}

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	void __construct(_Args&&... __args)
	{
	_LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage");
	::new((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...);
	this->__engaged_ = true;
	}

	template <class _That>
	_LIBCPP_INLINE_VISIBILITY
	void __construct_from(_That&& __opt)
	{
	if (__opt.has_value())
	__construct(_VSTD::forward<_That>(__opt).__get());
	}

	template <class _That>
	_LIBCPP_INLINE_VISIBILITY
	void __assign_from(_That&& __opt)
	{
	if (this->__engaged_ == __opt.has_value())
	{
	if (this->__engaged_)
	this->__val_ = _VSTD::forward<_That>(__opt).__get();
	}
	else
	{
	if (this->__engaged_)
	this->reset();
	else
	__construct(_VSTD::forward<_That>(__opt).__get());
	}
	}
	};

	// optional<T&> is currently required ill-formed, however it may to be in the
	// future. For this reason it has already been implemented to ensure we can
	// make the change in an ABI compatible manner.
	template <class _Tp>
	struct __optional_storage_base<_Tp, true>
	{
	using value_type = _Tp;
	using __raw_type = remove_reference_t<_Tp>;
	__raw_type* __value_;

	template <class _Up>
	static constexpr bool __can_bind_reference() {
	using _RawUp = typename remove_reference<_Up>::type;
	using _UpPtr = _RawUp*;
	using _RawTp = typename remove_reference<_Tp>::type;
	using _TpPtr = _RawTp*;
	using _CheckLValueArg = integral_constant<bool,
	(is_lvalue_reference<_Up>::value && is_convertible<_UpPtr, _TpPtr>::value)
	\|\| is_same<_RawUp, reference_wrapper<_RawTp>>::value
	\|\| is_same<_RawUp, reference_wrapper<typename remove_const<_RawTp>::type>>::value
	>;
	return (is_lvalue_reference<_Tp>::value && _CheckLValueArg::value)
	\|\| (is_rvalue_reference<_Tp>::value && !is_lvalue_reference<_Up>::value &&
	is_convertible<_UpPtr, _TpPtr>::value);
	}

	_LIBCPP_INLINE_VISIBILITY
	constexpr __optional_storage_base() noexcept
	: __value_(nullptr) {}

	template <class _UArg>
	_LIBCPP_INLINE_VISIBILITY
	constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg)
	: __value_(_VSTD::addressof(__uarg))
	{
	static_assert(__can_bind_reference<_UArg>(),
	"Attempted to construct a reference element in tuple from a "
	"possible temporary");
	}

	_LIBCPP_INLINE_VISIBILITY
	void reset() noexcept { __value_ = nullptr; }

	_LIBCPP_INLINE_VISIBILITY
	constexpr bool has_value() const noexcept
	{ return __value_ != nullptr; }

	_LIBCPP_INLINE_VISIBILITY
	constexpr value_type& __get() const& noexcept
	{ return *__value_; }

	_LIBCPP_INLINE_VISIBILITY
	constexpr value_type&& __get() const&& noexcept
	{ return _VSTD::forward<value_type>(*__value_); }

	template <class _UArg>
	_LIBCPP_INLINE_VISIBILITY
	void __construct(_UArg&& __val)
	{
	_LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage");
	static_assert(__can_bind_reference<_UArg>(),
	"Attempted to construct a reference element in tuple from a "
	"possible temporary");
	__value_ = _VSTD::addressof(__val);
	}

	template <class _That>
	_LIBCPP_INLINE_VISIBILITY
	void __construct_from(_That&& __opt)
	{
	if (__opt.has_value())
	__construct(_VSTD::forward<_That>(__opt).__get());
	}

	template <class _That>
	_LIBCPP_INLINE_VISIBILITY
	void __assign_from(_That&& __opt)
	{
	if (has_value() == __opt.has_value())
	{
	if (has_value())
	*__value_ = _VSTD::forward<_That>(__opt).__get();
	}
	else
	{
	if (has_value())
	reset();
	else
	__construct(_VSTD::forward<_That>(__opt).__get());
	}
	}
	};

	template <class _Tp, bool = is_trivially_copy_constructible<_Tp>::value>
	struct __optional_copy_base : __optional_storage_base<_Tp>
	{
	using __optional_storage_base<_Tp>::__optional_storage_base;
	};

	template <class _Tp>
	struct __optional_copy_base<_Tp, false> : __optional_storage_base<_Tp>
	{
	using __optional_storage_base<_Tp>::__optional_storage_base;

	_LIBCPP_INLINE_VISIBILITY
	__optional_copy_base() = default;

	_LIBCPP_INLINE_VISIBILITY
	__optional_copy_base(const __optional_copy_base& __opt)
	{
	this->__construct_from(__opt);
	}

	_LIBCPP_INLINE_VISIBILITY
	__optional_copy_base(__optional_copy_base&&) = default;
	_LIBCPP_INLINE_VISIBILITY
	__optional_copy_base& operator=(const __optional_copy_base&) = default;
	_LIBCPP_INLINE_VISIBILITY
	__optional_copy_base& operator=(__optional_copy_base&&) = default;
	};

	template <class _Tp, bool = is_trivially_move_constructible<_Tp>::value>
	struct __optional_move_base : __optional_copy_base<_Tp>
	{
	using __optional_copy_base<_Tp>::__optional_copy_base;
	};

	template <class _Tp>
	struct __optional_move_base<_Tp, false> : __optional_copy_base<_Tp>
	{
	using value_type = _Tp;
	using __optional_copy_base<_Tp>::__optional_copy_base;

	_LIBCPP_INLINE_VISIBILITY
	__optional_move_base() = default;
	_LIBCPP_INLINE_VISIBILITY
	__optional_move_base(const __optional_move_base&) = default;

	_LIBCPP_INLINE_VISIBILITY
	__optional_move_base(__optional_move_base&& __opt)
	noexcept(is_nothrow_move_constructible_v<value_type>)
	{
	this->__construct_from(_VSTD::move(__opt));
	}

	_LIBCPP_INLINE_VISIBILITY
	__optional_move_base& operator=(const __optional_move_base&) = default;
	_LIBCPP_INLINE_VISIBILITY
	__optional_move_base& operator=(__optional_move_base&&) = default;
	};

	template <class _Tp, bool =
	is_trivially_destructible<_Tp>::value &&
	is_trivially_copy_constructible<_Tp>::value &&
	is_trivially_copy_assignable<_Tp>::value>
	struct __optional_copy_assign_base : __optional_move_base<_Tp>
	{
	using __optional_move_base<_Tp>::__optional_move_base;
	};

	template <class _Tp>
	struct __optional_copy_assign_base<_Tp, false> : __optional_move_base<_Tp>
	{
	using __optional_move_base<_Tp>::__optional_move_base;

	_LIBCPP_INLINE_VISIBILITY
	__optional_copy_assign_base() = default;
	_LIBCPP_INLINE_VISIBILITY
	__optional_copy_assign_base(const __optional_copy_assign_base&) = default;
	_LIBCPP_INLINE_VISIBILITY
	__optional_copy_assign_base(__optional_copy_assign_base&&) = default;

	_LIBCPP_INLINE_VISIBILITY
	__optional_copy_assign_base& operator=(const __optional_copy_assign_base& __opt)
	{
	this->__assign_from(__opt);
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	__optional_copy_assign_base& operator=(__optional_copy_assign_base&&) = default;
	};

	template <class _Tp, bool =
	is_trivially_destructible<_Tp>::value &&
	is_trivially_move_constructible<_Tp>::value &&
	is_trivially_move_assignable<_Tp>::value>
	struct __optional_move_assign_base : __optional_copy_assign_base<_Tp>
	{
	using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
	};

	template <class _Tp>
	struct __optional_move_assign_base<_Tp, false> : __optional_copy_assign_base<_Tp>
	{
	using value_type = _Tp;
	using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;

	_LIBCPP_INLINE_VISIBILITY
	__optional_move_assign_base() = default;
	_LIBCPP_INLINE_VISIBILITY
	__optional_move_assign_base(const __optional_move_assign_base& __opt) = default;
	_LIBCPP_INLINE_VISIBILITY
	__optional_move_assign_base(__optional_move_assign_base&&) = default;
	_LIBCPP_INLINE_VISIBILITY
	__optional_move_assign_base& operator=(const __optional_move_assign_base&) = default;

	_LIBCPP_INLINE_VISIBILITY
	__optional_move_assign_base& operator=(__optional_move_assign_base&& __opt)
	noexcept(is_nothrow_move_assignable_v<value_type> &&
	is_nothrow_move_constructible_v<value_type>)
	{
	this->__assign_from(_VSTD::move(__opt));
	return *this;
	}
	};

	template <class _Tp>
	using __optional_sfinae_ctor_base_t = __sfinae_ctor_base<
	is_copy_constructible<_Tp>::value,
	is_move_constructible<_Tp>::value
	>;

	template <class _Tp>
	using __optional_sfinae_assign_base_t = __sfinae_assign_base<
	(is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value),
	(is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value)
	>;

	template <class _Tp>
	class optional
	: private __optional_move_assign_base<_Tp>
	, private __optional_sfinae_ctor_base_t<_Tp>
	, private __optional_sfinae_assign_base_t<_Tp>
	{
	using __base = __optional_move_assign_base<_Tp>;
	public:
	using value_type = _Tp;

	private:
	// Disable the reference extension using this static assert.
	static_assert(!is_same_v<value_type, in_place_t>,
	"instantiation of optional with in_place_t is ill-formed");
	static_assert(!is_same_v<__uncvref_t<value_type>, nullopt_t>,
	"instantiation of optional with nullopt_t is ill-formed");
	static_assert(!is_reference_v<value_type>,
	"instantiation of optional with a reference type is ill-formed");
	static_assert(is_destructible_v<value_type>,
	"instantiation of optional with a non-destructible type is ill-formed");

	// LWG2756: conditionally explicit conversion from _Up
	struct _CheckOptionalArgsConstructor {
	template <class _Up>
	static constexpr bool __enable_implicit() {
	return is_constructible_v<_Tp, _Up&&> &&
	is_convertible_v<_Up&&, _Tp>;
	}

	template <class _Up>
	static constexpr bool __enable_explicit() {
	return is_constructible_v<_Tp, _Up&&> &&
	!is_convertible_v<_Up&&, _Tp>;
	}
	};
	template <class _Up>
	using _CheckOptionalArgsCtor = conditional_t<
	- !is_same_v<decay_t<_Up>, in_place_t> &&
	- !is_same_v<decay_t<_Up>, optional>,
	+ !is_same_v<__uncvref_t<_Up>, in_place_t> &&
	+ !is_same_v<__uncvref_t<_Up>, optional>,
	_CheckOptionalArgsConstructor,
	__check_tuple_constructor_fail
	>;
	template <class _QualUp>
	struct _CheckOptionalLikeConstructor {
	template <class _Up, class _Opt = optional<_Up>>
	using __check_constructible_from_opt = __lazy_or<
	is_constructible<_Tp, _Opt&>,
	is_constructible<_Tp, _Opt const&>,
	is_constructible<_Tp, _Opt&&>,
	is_constructible<_Tp, _Opt const&&>,
	is_convertible<_Opt&, _Tp>,
	is_convertible<_Opt const&, _Tp>,
	is_convertible<_Opt&&, _Tp>,
	is_convertible<_Opt const&&, _Tp>
	>;
	template <class _Up, class _Opt = optional<_Up>>
	using __check_assignable_from_opt = __lazy_or<
	is_assignable<_Tp&, _Opt&>,
	is_assignable<_Tp&, _Opt const&>,
	is_assignable<_Tp&, _Opt&&>,
	is_assignable<_Tp&, _Opt const&&>
	>;
	template <class _Up, class _QUp = _QualUp>
	static constexpr bool __enable_implicit() {
	return is_convertible<_QUp, _Tp>::value &&
	!__check_constructible_from_opt<_Up>::value;
	}
	template <class _Up, class _QUp = _QualUp>
	static constexpr bool __enable_explicit() {
	return !is_convertible<_QUp, _Tp>::value &&
	!__check_constructible_from_opt<_Up>::value;
	}
	template <class _Up, class _QUp = _QualUp>
	static constexpr bool __enable_assign() {
	// Construction and assignability of _Qup to _Tp has already been
	// checked.
	return !__check_constructible_from_opt<_Up>::value &&
	!__check_assignable_from_opt<_Up>::value;
	}
	};

	template <class _Up, class _QualUp>
	using _CheckOptionalLikeCtor = conditional_t<
	__lazy_and<
	__lazy_not<is_same<_Up, _Tp>>,
	is_constructible<_Tp, _QualUp>
	>::value,
	_CheckOptionalLikeConstructor<_QualUp>,
	__check_tuple_constructor_fail
	>;
	template <class _Up, class _QualUp>
	using _CheckOptionalLikeAssign = conditional_t<
	__lazy_and<
	__lazy_not<is_same<_Up, _Tp>>,
	is_constructible<_Tp, _QualUp>,
	is_assignable<_Tp&, _QualUp>
	>::value,
	_CheckOptionalLikeConstructor<_QualUp>,
	__check_tuple_constructor_fail
	>;
	public:

	_LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {}
	_LIBCPP_INLINE_VISIBILITY constexpr optional(const optional&) = default;
	_LIBCPP_INLINE_VISIBILITY constexpr optional(optional&&) = default;
	_LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {}

	template <class... _Args, class = enable_if_t<
	is_constructible_v<value_type, _Args...>>
	>
	_LIBCPP_INLINE_VISIBILITY
	constexpr explicit optional(in_place_t, _Args&&... __args)
	: __base(in_place, _VSTD::forward<_Args>(__args)...) {}

	template <class _Up, class... _Args, class = enable_if_t<
	is_constructible_v<value_type, initializer_list<_Up>&, _Args...>>
	>
	_LIBCPP_INLINE_VISIBILITY
	constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
	: __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {}

	template <class _Up = value_type, enable_if_t<
	_CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>()
	, int> = 0>
	_LIBCPP_INLINE_VISIBILITY
	constexpr optional(_Up&& __v)
	: __base(in_place, _VSTD::forward<_Up>(__v)) {}

	template <class _Up, enable_if_t<
	_CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>()
	, int> = 0>
	_LIBCPP_INLINE_VISIBILITY
	constexpr explicit optional(_Up&& __v)
	: __base(in_place, _VSTD::forward<_Up>(__v)) {}

	// LWG2756: conditionally explicit conversion from const optional<_Up>&
	template <class _Up, enable_if_t<
	_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>()
	, int> = 0>
	_LIBCPP_INLINE_VISIBILITY
	optional(const optional<_Up>& __v)
	{
	this->__construct_from(__v);
	}
	template <class _Up, enable_if_t<
	_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>()
	, int> = 0>
	_LIBCPP_INLINE_VISIBILITY
	explicit optional(const optional<_Up>& __v)
	{
	this->__construct_from(__v);
	}

	// LWG2756: conditionally explicit conversion from optional<_Up>&&
	template <class _Up, enable_if_t<
	_CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_implicit<_Up>()
	, int> = 0>
	_LIBCPP_INLINE_VISIBILITY
	optional(optional<_Up>&& __v)
	{
	this->__construct_from(_VSTD::move(__v));
	}
	template <class _Up, enable_if_t<
	_CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_explicit<_Up>()
	, int> = 0>
	_LIBCPP_INLINE_VISIBILITY
	explicit optional(optional<_Up>&& __v)
	{
	this->__construct_from(_VSTD::move(__v));
	}

	_LIBCPP_INLINE_VISIBILITY
	optional& operator=(nullopt_t) noexcept
	{
	reset();
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY optional& operator=(const optional&) = default;
	_LIBCPP_INLINE_VISIBILITY optional& operator=(optional&&) = default;

	// LWG2756
	template <class _Up = value_type,
	class = enable_if_t
	<__lazy_and<
	integral_constant<bool,
	- !is_same_v<decay_t<_Up>, optional> &&
	+ !is_same_v<__uncvref_t<_Up>, optional> &&
	!(is_same_v<_Up, value_type> && is_scalar_v<value_type>)
	>,
	is_constructible<value_type, _Up>,
	is_assignable<value_type&, _Up>
	>::value>
	>
	_LIBCPP_INLINE_VISIBILITY
	optional&
	operator=(_Up&& __v)
	{
	if (this->has_value())
	this->__get() = _VSTD::forward<_Up>(__v);
	else
	this->__construct(_VSTD::forward<_Up>(__v));
	return *this;
	}

	// LWG2756
	template <class _Up, enable_if_t<
	_CheckOptionalLikeAssign<_Up, _Up const&>::template __enable_assign<_Up>()
	, int> = 0>
	_LIBCPP_INLINE_VISIBILITY
	optional&
	operator=(const optional<_Up>& __v)
	{
	this->__assign_from(__v);
	return *this;
	}

	// LWG2756
	template <class _Up, enable_if_t<
	_CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_assign<_Up>()
	, int> = 0>
	_LIBCPP_INLINE_VISIBILITY
	optional&
	operator=(optional<_Up>&& __v)
	{
	this->__assign_from(_VSTD::move(__v));
	return *this;
	}

	template <class... _Args,
	class = enable_if_t
	<
	is_constructible_v<value_type, _Args...>
	>
	>
	_LIBCPP_INLINE_VISIBILITY
	_Tp &
	emplace(_Args&&... __args)
	{
	reset();
	this->__construct(_VSTD::forward<_Args>(__args)...);
	return this->__get();
	}

	template <class _Up, class... _Args,
	class = enable_if_t
	<
	is_constructible_v<value_type, initializer_list<_Up>&, _Args...>
	>
	>
	_LIBCPP_INLINE_VISIBILITY
	_Tp &
	emplace(initializer_list<_Up> __il, _Args&&... __args)
	{
	reset();
	this->__construct(__il, _VSTD::forward<_Args>(__args)...);
	return this->__get();
	}

	_LIBCPP_INLINE_VISIBILITY
	void swap(optional& __opt)
	noexcept(is_nothrow_move_constructible_v<value_type> &&
	is_nothrow_swappable_v<value_type>)
	{
	if (this->has_value() == __opt.has_value())
	{
	using _VSTD::swap;
	if (this->has_value())
	swap(this->__get(), __opt.__get());
	}
	else
	{
	if (this->has_value())
	{
	__opt.__construct(_VSTD::move(this->__get()));
	reset();
	}
	else
	{
	this->__construct(_VSTD::move(__opt.__get()));
	__opt.reset();
	}
	}
	}

	_LIBCPP_INLINE_VISIBILITY
	constexpr
	add_pointer_t<value_type const>
	operator->() const
	{
	_LIBCPP_ASSERT(this->has_value(), "optional operator-> called for disengaged value");
	#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
	return _VSTD::addressof(this->__get());
	#else
	return __operator_arrow(__has_operator_addressof<value_type>{}, this->__get());
	#endif
	}

	_LIBCPP_INLINE_VISIBILITY
	constexpr
	add_pointer_t<value_type>
	operator->()
	{
	_LIBCPP_ASSERT(this->has_value(), "optional operator-> called for disengaged value");
	#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
	return _VSTD::addressof(this->__get());
	#else
	return __operator_arrow(__has_operator_addressof<value_type>{}, this->__get());
	#endif
	}

	_LIBCPP_INLINE_VISIBILITY
	constexpr
	const value_type&
	operator*() const&
	{
	_LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value");
	return this->__get();
	}

	_LIBCPP_INLINE_VISIBILITY
	constexpr
	value_type&
	operator*() &
	{
	_LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value");
	return this->__get();
	}

	_LIBCPP_INLINE_VISIBILITY
	constexpr
	value_type&&
	operator*() &&
	{
	_LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value");
	return _VSTD::move(this->__get());
	}

	_LIBCPP_INLINE_VISIBILITY
	constexpr
	const value_type&&
	operator*() const&&
	{
	_LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value");
	return _VSTD::move(this->__get());
	}

	_LIBCPP_INLINE_VISIBILITY
	constexpr explicit operator bool() const noexcept { return has_value(); }

	using __base::has_value;
	using __base::__get;

	_LIBCPP_INLINE_VISIBILITY
	constexpr value_type const& value() const&
	{
	if (!this->has_value())
	__throw_bad_optional_access();
	return this->__get();
	}

	_LIBCPP_INLINE_VISIBILITY
	constexpr value_type& value() &
	{
	if (!this->has_value())
	__throw_bad_optional_access();
	return this->__get();
	}

	_LIBCPP_INLINE_VISIBILITY
	constexpr value_type&& value() &&
	{
	if (!this->has_value())
	__throw_bad_optional_access();
	return _VSTD::move(this->__get());
	}

	_LIBCPP_INLINE_VISIBILITY
	constexpr value_type const&& value() const&&
	{
	if (!this->has_value())
	__throw_bad_optional_access();
	return _VSTD::move(this->__get());
	}

	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY
	constexpr value_type value_or(_Up&& __v) const&
	{
	static_assert(is_copy_constructible_v<value_type>,
	"optional<T>::value_or: T must be copy constructible");
	static_assert(is_convertible_v<_Up, value_type>,
	"optional<T>::value_or: U must be convertible to T");
	return this->has_value() ? this->__get() :
	static_cast<value_type>(_VSTD::forward<_Up>(__v));
	}

	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY
	constexpr value_type value_or(_Up&& __v) &&
	{
	static_assert(is_move_constructible_v<value_type>,
	"optional<T>::value_or: T must be move constructible");
	static_assert(is_convertible_v<_Up, value_type>,
	"optional<T>::value_or: U must be convertible to T");
	return this->has_value() ? _VSTD::move(this->__get()) :
	static_cast<value_type>(_VSTD::forward<_Up>(__v));
	}

	using __base::reset;

	private:
	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY
	static _Up*
	__operator_arrow(true_type, _Up& __x)
	{
	return _VSTD::addressof(__x);
	}

	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY
	static constexpr _Up*
	__operator_arrow(false_type, _Up& __x)
	{
	return &__x;
	}
	};
	+
	+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
	+template<class T>
	+ optional(T) -> optional<T>;
	+#endif

	// Comparisons between optionals
	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() ==
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator==(const optional<_Tp>& __x, const optional<_Up>& __y)
	{
	if (static_cast<bool>(__x) != static_cast<bool>(__y))
	return false;
	if (!static_cast<bool>(__x))
	return true;
	return __x == __y;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() !=
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator!=(const optional<_Tp>& __x, const optional<_Up>& __y)
	{
	if (static_cast<bool>(__x) != static_cast<bool>(__y))
	return true;
	if (!static_cast<bool>(__x))
	return false;
	return __x != __y;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator<(const optional<_Tp>& __x, const optional<_Up>& __y)
	{
	if (!static_cast<bool>(__y))
	return false;
	if (!static_cast<bool>(__x))
	return true;
	return __x < __y;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator>(const optional<_Tp>& __x, const optional<_Up>& __y)
	{
	if (!static_cast<bool>(__x))
	return false;
	if (!static_cast<bool>(__y))
	return true;
	return __x > __y;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <=
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator<=(const optional<_Tp>& __x, const optional<_Up>& __y)
	{
	if (!static_cast<bool>(__x))
	return true;
	if (!static_cast<bool>(__y))
	return false;
	return __x <= __y;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >=
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator>=(const optional<_Tp>& __x, const optional<_Up>& __y)
	{
	if (!static_cast<bool>(__y))
	return true;
	if (!static_cast<bool>(__x))
	return false;
	return __x >= __y;
	}

	// Comparisons with nullopt
	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY constexpr
	bool
	operator==(const optional<_Tp>& __x, nullopt_t) noexcept
	{
	return !static_cast<bool>(__x);
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY constexpr
	bool
	operator==(nullopt_t, const optional<_Tp>& __x) noexcept
	{
	return !static_cast<bool>(__x);
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY constexpr
	bool
	operator!=(const optional<_Tp>& __x, nullopt_t) noexcept
	{
	return static_cast<bool>(__x);
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY constexpr
	bool
	operator!=(nullopt_t, const optional<_Tp>& __x) noexcept
	{
	return static_cast<bool>(__x);
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY constexpr
	bool
	operator<(const optional<_Tp>&, nullopt_t) noexcept
	{
	return false;
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY constexpr
	bool
	operator<(nullopt_t, const optional<_Tp>& __x) noexcept
	{
	return static_cast<bool>(__x);
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY constexpr
	bool
	operator<=(const optional<_Tp>& __x, nullopt_t) noexcept
	{
	return !static_cast<bool>(__x);
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY constexpr
	bool
	operator<=(nullopt_t, const optional<_Tp>&) noexcept
	{
	return true;
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY constexpr
	bool
	operator>(const optional<_Tp>& __x, nullopt_t) noexcept
	{
	return static_cast<bool>(__x);
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY constexpr
	bool
	operator>(nullopt_t, const optional<_Tp>&) noexcept
	{
	return false;
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY constexpr
	bool
	operator>=(const optional<_Tp>&, nullopt_t) noexcept
	{
	return true;
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY constexpr
	bool
	operator>=(nullopt_t, const optional<_Tp>& __x) noexcept
	{
	return !static_cast<bool>(__x);
	}

	// Comparisons with T
	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() ==
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator==(const optional<_Tp>& __x, const _Up& __v)
	{
	return static_cast<bool>(__x) ? *__x == __v : false;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() ==
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator==(const _Tp& __v, const optional<_Up>& __x)
	{
	return static_cast<bool>(__x) ? __v == *__x : false;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() !=
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator!=(const optional<_Tp>& __x, const _Up& __v)
	{
	return static_cast<bool>(__x) ? *__x != __v : true;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() !=
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator!=(const _Tp& __v, const optional<_Up>& __x)
	{
	return static_cast<bool>(__x) ? __v != *__x : true;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator<(const optional<_Tp>& __x, const _Up& __v)
	{
	return static_cast<bool>(__x) ? *__x < __v : true;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator<(const _Tp& __v, const optional<_Up>& __x)
	{
	return static_cast<bool>(__x) ? __v < *__x : false;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <=
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator<=(const optional<_Tp>& __x, const _Up& __v)
	{
	return static_cast<bool>(__x) ? *__x <= __v : true;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <=
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator<=(const _Tp& __v, const optional<_Up>& __x)
	{
	return static_cast<bool>(__x) ? __v <= *__x : false;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator>(const optional<_Tp>& __x, const _Up& __v)
	{
	return static_cast<bool>(__x) ? *__x > __v : false;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator>(const _Tp& __v, const optional<_Up>& __x)
	{
	return static_cast<bool>(__x) ? __v > *__x : true;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >=
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator>=(const optional<_Tp>& __x, const _Up& __v)
	{
	return static_cast<bool>(__x) ? *__x >= __v : false;
	}

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY constexpr
	enable_if_t<
	is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >=
	_VSTD::declval<const _Up&>()), bool>,
	bool
	>
	operator>=(const _Tp& __v, const optional<_Up>& __x)
	{
	return static_cast<bool>(__x) ? __v >= *__x : true;
	}


	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	enable_if_t<
	is_move_constructible_v<_Tp> && is_swappable_v<_Tp>,
	void
	>
	swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
	{
	__x.swap(__y);
	}

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY constexpr
	optional<decay_t<_Tp>> make_optional(_Tp&& __v)
	{
	return optional<decay_t<_Tp>>(_VSTD::forward<_Tp>(__v));
	}

	template <class _Tp, class... _Args>
	_LIBCPP_INLINE_VISIBILITY constexpr
	optional<_Tp> make_optional(_Args&&... __args)
	{
	return optional<_Tp>(in_place, _VSTD::forward<_Args>(__args)...);
	}

	template <class _Tp, class _Up, class... _Args>
	_LIBCPP_INLINE_VISIBILITY constexpr
	optional<_Tp> make_optional(initializer_list<_Up> __il, _Args&&... __args)
	{
	return optional<_Tp>(in_place, __il, _VSTD::forward<_Args>(__args)...);
	}

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS hash<
	__enable_hash_helper<optional<_Tp>, remove_const_t<_Tp>>
	>
	{
	typedef optional<_Tp> argument_type;
	typedef size_t result_type;

	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(const argument_type& __opt) const
	{
	return static_cast<bool>(__opt) ? hash<remove_const_t<_Tp>>()(*__opt) : 0;
	}
	};

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_STD_VER > 14

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_OPTIONAL
	Index: projects/clang700-import/contrib/libc++/include/ostream
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/ostream (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/ostream (revision 337135)
	@@ -1,1104 +1,1102 @@
	// -- C++ --
	//===-------------------------- ostream -----------------------------------===//
	//
	// 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_OSTREAM
	#define _LIBCPP_OSTREAM

	/*
	ostream synopsis

	template <class charT, class traits = char_traits<charT> >
	class basic_ostream
	: virtual public basic_ios<charT,traits>
	{
	public:
	// types (inherited from basic_ios (27.5.4)):
	typedef charT char_type;
	typedef traits traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;

	// 27.7.2.2 Constructor/destructor:
	explicit basic_ostream(basic_streambuf<char_type,traits>* sb);
	basic_ostream(basic_ostream&& rhs);
	virtual ~basic_ostream();

	// 27.7.2.3 Assign/swap
	basic_ostream& operator=(const basic_ostream& rhs) = delete; // C++14
	basic_ostream& operator=(basic_ostream&& rhs);
	void swap(basic_ostream& rhs);

	// 27.7.2.4 Prefix/suffix:
	class sentry;

	// 27.7.2.6 Formatted output:
	basic_ostream& operator<<(basic_ostream& (*pf)(basic_ostream&));
	basic_ostream& operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT,traits>&));
	basic_ostream& operator<<(ios_base& (*pf)(ios_base&));
	basic_ostream& operator<<(bool n);
	basic_ostream& operator<<(short n);
	basic_ostream& operator<<(unsigned short n);
	basic_ostream& operator<<(int n);
	basic_ostream& operator<<(unsigned int n);
	basic_ostream& operator<<(long n);
	basic_ostream& operator<<(unsigned long n);
	basic_ostream& operator<<(long long n);
	basic_ostream& operator<<(unsigned long long n);
	basic_ostream& operator<<(float f);
	basic_ostream& operator<<(double f);
	basic_ostream& operator<<(long double f);
	basic_ostream& operator<<(const void* p);
	basic_ostream& operator<<(basic_streambuf<char_type,traits>* sb);

	// 27.7.2.7 Unformatted output:
	basic_ostream& put(char_type c);
	basic_ostream& write(const char_type* s, streamsize n);
	basic_ostream& flush();

	// 27.7.2.5 seeks:
	pos_type tellp();
	basic_ostream& seekp(pos_type);
	basic_ostream& seekp(off_type, ios_base::seekdir);
	protected:
	basic_ostream(const basic_ostream& rhs) = delete;
	basic_ostream(basic_ostream&& rhs);
	// 27.7.3.3 Assign/swap
	basic_ostream& operator=(basic_ostream& rhs) = delete;
	basic_ostream& operator=(const basic_ostream&& rhs);
	void swap(basic_ostream& rhs);
	};

	// 27.7.2.6.4 character inserters

	template<class charT, class traits>
	basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, charT);

	template<class charT, class traits>
	basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, char);

	template<class traits>
	basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, char);

	// signed and unsigned

	template<class traits>
	basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, signed char);

	template<class traits>
	basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, unsigned char);

	// NTBS
	template<class charT, class traits>
	basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const charT*);

	template<class charT, class traits>
	basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const char*);

	template<class traits>
	basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const char*);

	// signed and unsigned
	template<class traits>
	basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const signed char*);

	template<class traits>
	basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const unsigned char*);

	// swap:
	template <class charT, class traits>
	void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y);

	template <class charT, class traits>
	basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);

	template <class charT, class traits>
	basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);

	template <class charT, class traits>
	basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);

	// rvalue stream insertion
	template <class charT, class traits, class T>
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>&& os, const T& x);

	} // std

	*/

	#include <__config>
	#include <ios>
	#include <streambuf>
	#include <locale>
	#include <iterator>
	#include <bitset>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _CharT, class _Traits>
	class _LIBCPP_TEMPLATE_VIS basic_ostream
	: virtual public basic_ios<_CharT, _Traits>
	{
	public:
	// types (inherited from basic_ios (27.5.4)):
	typedef _CharT char_type;
	typedef _Traits traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;

	// 27.7.2.2 Constructor/destructor:
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb)
	{ this->init(__sb); }
	virtual ~basic_ostream();
	protected:
	#ifndef _LIBCPP_CXX03_LANG
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ostream(basic_ostream&& __rhs);

	// 27.7.2.3 Assign/swap
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ostream& operator=(basic_ostream&& __rhs);
	#endif
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	void swap(basic_ostream& __rhs)
	{ basic_ios<char_type, traits_type>::swap(__rhs); }

	#ifndef _LIBCPP_CXX03_LANG
	basic_ostream (const basic_ostream& __rhs) = delete;
	basic_ostream& operator=(const basic_ostream& __rhs) = delete;
	#else
	basic_ostream (const basic_ostream& __rhs); // not defined
	basic_ostream& operator=(const basic_ostream& __rhs); // not defined
	#endif
	public:

	// 27.7.2.4 Prefix/suffix:
	class _LIBCPP_TEMPLATE_VIS sentry;

	// 27.7.2.6 Formatted output:
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&))
	{ return __pf(*this); }

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	basic_ostream& operator<<(basic_ios<char_type, traits_type>&
	(*__pf)(basic_ios<char_type,traits_type>&))
	{ __pf(this); return this; }

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	basic_ostream& operator<<(ios_base& (*__pf)(ios_base&))
	{ __pf(this); return this; }

	basic_ostream& operator<<(bool __n);
	basic_ostream& operator<<(short __n);
	basic_ostream& operator<<(unsigned short __n);
	basic_ostream& operator<<(int __n);
	basic_ostream& operator<<(unsigned int __n);
	basic_ostream& operator<<(long __n);
	basic_ostream& operator<<(unsigned long __n);
	basic_ostream& operator<<(long long __n);
	basic_ostream& operator<<(unsigned long long __n);
	basic_ostream& operator<<(float __f);
	basic_ostream& operator<<(double __f);
	basic_ostream& operator<<(long double __f);
	basic_ostream& operator<<(const void* __p);
	basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb);

	// 27.7.2.7 Unformatted output:
	basic_ostream& put(char_type __c);
	basic_ostream& write(const char_type* __s, streamsize __n);
	basic_ostream& flush();

	// 27.7.2.5 seeks:
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	pos_type tellp();
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	basic_ostream& seekp(pos_type __pos);
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	basic_ostream& seekp(off_type __off, ios_base::seekdir __dir);

	protected:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	basic_ostream() {} // extension, intentially does not initialize
	};

	template <class _CharT, class _Traits>
	class _LIBCPP_TEMPLATE_VIS basic_ostream<_CharT, _Traits>::sentry
	{
	bool __ok_;
	basic_ostream<_CharT, _Traits>& __os_;

	sentry(const sentry&); // = delete;
	sentry& operator=(const sentry&); // = delete;

	public:
	explicit sentry(basic_ostream<_CharT, _Traits>& __os);
	~sentry();

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_EXPLICIT
	operator bool() const {return __ok_;}
	};

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>::sentry::sentry(basic_ostream<_CharT, _Traits>& __os)
	: __ok_(false),
	__os_(__os)
	{
	if (__os.good())
	{
	if (__os.tie())
	__os.tie()->flush();
	__ok_ = true;
	}
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>::sentry::~sentry()
	{
	if (__os_.rdbuf() && __os_.good() && (__os_.flags() & ios_base::unitbuf)
	&& !uncaught_exception())
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	if (__os_.rdbuf()->pubsync() == -1)
	__os_.setstate(ios_base::badbit);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs)
	{
	this->move(__rhs);
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs)
	{
	swap(__rhs);
	return *this;
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>::~basic_ostream()
	{
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this);
	if (__s)
	{
	if (__sb)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typedef istreambuf_iterator<_CharT, _Traits> _Ip;
	typedef ostreambuf_iterator<_CharT, _Traits> _Op;
	_Ip __i(__sb);
	_Ip __eof;
	_Op __o(*this);
	size_t __c = 0;
	for (; __i != __eof; ++__i, ++__o, ++__c)
	{
	__o = __i;
	if (__o.failed())
	break;
	}
	if (__c == 0)
	this->setstate(ios_base::failbit);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_failbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}
	else
	this->setstate(ios_base::badbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::operator<<(bool __n)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this);
	if (__s)
	{
	typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
	const _Fp& __f = use_facet<_Fp>(this->getloc());
	if (__f.put(this, this, this->fill(), __n).failed())
	this->setstate(ios_base::badbit \| ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::operator<<(short __n)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this);
	if (__s)
	{
	ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
	typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
	const _Fp& __f = use_facet<_Fp>(this->getloc());
	if (__f.put(this, this, this->fill(),
	__flags == ios_base::oct \|\| __flags == ios_base::hex ?
	static_cast<long>(static_cast<unsigned short>(__n)) :
	static_cast<long>(__n)).failed())
	this->setstate(ios_base::badbit \| ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this);
	if (__s)
	{
	typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
	const _Fp& __f = use_facet<_Fp>(this->getloc());
	if (__f.put(this, this, this->fill(), static_cast<unsigned long>(__n)).failed())
	this->setstate(ios_base::badbit \| ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::operator<<(int __n)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this);
	if (__s)
	{
	ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
	typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
	const _Fp& __f = use_facet<_Fp>(this->getloc());
	if (__f.put(this, this, this->fill(),
	__flags == ios_base::oct \|\| __flags == ios_base::hex ?
	static_cast<long>(static_cast<unsigned int>(__n)) :
	static_cast<long>(__n)).failed())
	this->setstate(ios_base::badbit \| ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this);
	if (__s)
	{
	typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
	const _Fp& __f = use_facet<_Fp>(this->getloc());
	if (__f.put(this, this, this->fill(), static_cast<unsigned long>(__n)).failed())
	this->setstate(ios_base::badbit \| ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::operator<<(long __n)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this);
	if (__s)
	{
	typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
	const _Fp& __f = use_facet<_Fp>(this->getloc());
	if (__f.put(this, this, this->fill(), __n).failed())
	this->setstate(ios_base::badbit \| ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this);
	if (__s)
	{
	typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
	const _Fp& __f = use_facet<_Fp>(this->getloc());
	if (__f.put(this, this, this->fill(), __n).failed())
	this->setstate(ios_base::badbit \| ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::operator<<(long long __n)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this);
	if (__s)
	{
	typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
	const _Fp& __f = use_facet<_Fp>(this->getloc());
	if (__f.put(this, this, this->fill(), __n).failed())
	this->setstate(ios_base::badbit \| ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this);
	if (__s)
	{
	typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
	const _Fp& __f = use_facet<_Fp>(this->getloc());
	if (__f.put(this, this, this->fill(), __n).failed())
	this->setstate(ios_base::badbit \| ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::operator<<(float __n)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this);
	if (__s)
	{
	typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
	const _Fp& __f = use_facet<_Fp>(this->getloc());
	if (__f.put(this, this, this->fill(), static_cast<double>(__n)).failed())
	this->setstate(ios_base::badbit \| ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::operator<<(double __n)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this);
	if (__s)
	{
	typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
	const _Fp& __f = use_facet<_Fp>(this->getloc());
	if (__f.put(this, this, this->fill(), __n).failed())
	this->setstate(ios_base::badbit \| ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::operator<<(long double __n)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this);
	if (__s)
	{
	typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
	const _Fp& __f = use_facet<_Fp>(this->getloc());
	if (__f.put(this, this, this->fill(), __n).failed())
	this->setstate(ios_base::badbit \| ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::operator<<(const void* __n)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this);
	if (__s)
	{
	typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
	const _Fp& __f = use_facet<_Fp>(this->getloc());
	if (__f.put(this, this, this->fill(), __n).failed())
	this->setstate(ios_base::badbit \| ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template<class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	__put_character_sequence(basic_ostream<_CharT, _Traits>& __os,
	const _CharT* __str, size_t __len)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
	if (__s)
	{
	typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
	if (__pad_and_output(_Ip(__os),
	__str,
	(__os.flags() & ios_base::adjustfield) == ios_base::left ?
	__str + __len :
	__str,
	__str + __len,
	__os,
	__os.fill()).failed())
	__os.setstate(ios_base::badbit \| ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__os.__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return __os;
	}


	template<class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c)
	{
	return _VSTD::__put_character_sequence(__os, &__c, 1);
	}

	template<class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
	if (__s)
	{
	_CharT __c = __os.widen(__cn);
	typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
	if (__pad_and_output(_Ip(__os),
	&__c,
	(__os.flags() & ios_base::adjustfield) == ios_base::left ?
	&__c + 1 :
	&__c,
	&__c + 1,
	__os,
	__os.fill()).failed())
	__os.setstate(ios_base::badbit \| ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__os.__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return __os;
	}

	template<class _Traits>
	basic_ostream<char, _Traits>&
	operator<<(basic_ostream<char, _Traits>& __os, char __c)
	{
	return _VSTD::__put_character_sequence(__os, &__c, 1);
	}

	template<class _Traits>
	basic_ostream<char, _Traits>&
	operator<<(basic_ostream<char, _Traits>& __os, signed char __c)
	{
	return _VSTD::__put_character_sequence(__os, (char *) &__c, 1);
	}

	template<class _Traits>
	basic_ostream<char, _Traits>&
	operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c)
	{
	return _VSTD::__put_character_sequence(__os, (char *) &__c, 1);
	}

	template<class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str)
	{
	return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str));
	}

	template<class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
	if (__s)
	{
	typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
	size_t __len = char_traits<char>::length(__strn);
	const int __bs = 100;
	_CharT __wbb[__bs];
	_CharT* __wb = __wbb;
	unique_ptr<_CharT, void()(void)> __h(0, free);
	if (__len > __bs)
	{
	__wb = (_CharT)malloc(__lensizeof(_CharT));
	if (__wb == 0)
	__throw_bad_alloc();
	__h.reset(__wb);
	}
	for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p)
	__p = __os.widen(__strn);
	if (__pad_and_output(_Ip(__os),
	__wb,
	(__os.flags() & ios_base::adjustfield) == ios_base::left ?
	__wb + __len :
	__wb,
	__wb + __len,
	__os,
	__os.fill()).failed())
	__os.setstate(ios_base::badbit \| ios_base::failbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	__os.__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return __os;
	}

	template<class _Traits>
	basic_ostream<char, _Traits>&
	operator<<(basic_ostream<char, _Traits>& __os, const char* __str)
	{
	return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str));
	}

	template<class _Traits>
	basic_ostream<char, _Traits>&
	operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str)
	{
	const char __s = (const char ) __str;
	return _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s));
	}

	template<class _Traits>
	basic_ostream<char, _Traits>&
	operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str)
	{
	const char __s = (const char ) __str;
	return _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s));
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::put(char_type __c)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __s(*this);
	if (__s)
	{
	typedef ostreambuf_iterator<_CharT, _Traits> _Op;
	_Op __o(*this);
	*__o = __c;
	if (__o.failed())
	this->setstate(ios_base::badbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	sentry __sen(*this);
	if (__sen && __n)
	{
	if (this->rdbuf()->sputn(__s, __n) != __n)
	this->setstate(ios_base::badbit);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::flush()
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	if (this->rdbuf())
	{
	sentry __s(*this);
	if (__s)
	{
	if (this->rdbuf()->pubsync() == -1)
	this->setstate(ios_base::badbit);
	}
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	this->__set_badbit_and_consider_rethrow();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	return *this;
	}

	template <class _CharT, class _Traits>
	typename basic_ostream<_CharT, _Traits>::pos_type
	basic_ostream<_CharT, _Traits>::tellp()
	{
	if (this->fail())
	return pos_type(-1);
	return this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::seekp(pos_type __pos)
	{
	sentry __s(*this);
	if (!this->fail())
	{
	if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1))
	this->setstate(ios_base::failbit);
	}
	return *this;
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir)
	{
	sentry __s(*this);
	if (!this->fail())
	{
	if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::out) == pos_type(-1))
	this->setstate(ios_base::failbit);
	}
	return *this;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ostream<_CharT, _Traits>&
	endl(basic_ostream<_CharT, _Traits>& __os)
	{
	__os.put(__os.widen('\n'));
	__os.flush();
	return __os;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ostream<_CharT, _Traits>&
	ends(basic_ostream<_CharT, _Traits>& __os)
	{
	__os.put(_CharT());
	return __os;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ostream<_CharT, _Traits>&
	flush(basic_ostream<_CharT, _Traits>& __os)
	{
	__os.flush();
	return __os;
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Stream, class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	!is_lvalue_reference<_Stream>::value &&
	is_base_of<ios_base, _Stream>::value,
	_Stream&&
	>::type
	operator<<(_Stream&& __os, const _Tp& __x)
	{
	__os << __x;
	return _VSTD::move(__os);
	}

	#endif // _LIBCPP_CXX03_LANG

	template<class _CharT, class _Traits, class _Allocator>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const basic_string<_CharT, _Traits, _Allocator>& __str)
	{
	return _VSTD::__put_character_sequence(__os, __str.data(), __str.size());
	}

	template<class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const basic_string_view<_CharT, _Traits> __sv)
	{
	return _VSTD::__put_character_sequence(__os, __sv.data(), __sv.size());
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __ec)
	{
	return __os << __ec.category().name() << ':' << __ec.value();
	}

	template<class _CharT, class _Traits, class _Yp>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ostream<_CharT, _Traits>&
	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,
	+ is_same<void, typename __void_t<decltype((declval<basic_ostream<_CharT, _Traits>&>() << declval<typename unique_ptr<_Yp, _Dp>::pointer>()))>::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)
	{
	return __os << __x.template to_string<_CharT, _Traits>
	(use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),
	use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
	}

	#ifndef _LIBCPP_AVAILABILITY_NO_STREAMS_EXTERN_TEMPLATE
	_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<char>)
	_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>)
	#endif

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_OSTREAM
	Index: projects/clang700-import/contrib/libc++/include/queue
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/queue (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/queue (revision 337135)
	@@ -1,738 +1,804 @@
	// -- C++ --
	//===--------------------------- queue ------------------------------------===//
	//
	// 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_QUEUE
	#define _LIBCPP_QUEUE

	/*
	queue synopsis

	namespace std
	{

	template <class T, class Container = deque<T>>
	class queue
	{
	public:
	typedef Container container_type;
	typedef typename container_type::value_type value_type;
	typedef typename container_type::reference reference;
	typedef typename container_type::const_reference const_reference;
	typedef typename container_type::size_type size_type;

	protected:
	container_type c;

	public:
	queue() = default;
	~queue() = default;

	queue(const queue& q) = default;
	queue(queue&& q) = default;

	queue& operator=(const queue& q) = default;
	queue& operator=(queue&& q) = default;

	explicit queue(const container_type& c);
	explicit queue(container_type&& c)
	template <class Alloc>
	explicit queue(const Alloc& a);
	template <class Alloc>
	queue(const container_type& c, const Alloc& a);
	template <class Alloc>
	queue(container_type&& c, const Alloc& a);
	template <class Alloc>
	queue(const queue& q, const Alloc& a);
	template <class Alloc>
	queue(queue&& q, const Alloc& a);

	bool empty() const;
	size_type size() const;

	reference front();
	const_reference front() const;
	reference back();
	const_reference back() const;

	void push(const value_type& v);
	void push(value_type&& v);
	template <class... Args> reference emplace(Args&&... args); // reference in C++17
	void pop();

	void swap(queue& q) noexcept(is_nothrow_swappable_v<Container>)
	};

	+template<class Container>
	+ queue(Container) -> queue<typename Container::value_type, Container>; // C++17
	+
	+template<class Container, class Allocator>
	+ queue(Container, Allocator) -> queue<typename Container::value_type, Container>; // C++17
	+
	template <class T, class Container>
	bool operator==(const queue<T, Container>& x,const queue<T, Container>& y);

	template <class T, class Container>
	bool operator< (const queue<T, Container>& x,const queue<T, Container>& y);

	template <class T, class Container>
	bool operator!=(const queue<T, Container>& x,const queue<T, Container>& y);

	template <class T, class Container>
	bool operator> (const queue<T, Container>& x,const queue<T, Container>& y);

	template <class T, class Container>
	bool operator>=(const queue<T, Container>& x,const queue<T, Container>& y);

	template <class T, class Container>
	bool operator<=(const queue<T, Container>& x,const queue<T, Container>& y);

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

	template <class T, class Container = vector<T>,
	class Compare = less<typename Container::value_type>>
	class priority_queue
	{
	public:
	typedef Container container_type;
	typedef typename container_type::value_type value_type;
	typedef typename container_type::reference reference;
	typedef typename container_type::const_reference const_reference;
	typedef typename container_type::size_type size_type;

	protected:
	container_type c;
	Compare comp;

	public:
	priority_queue() = default;
	~priority_queue() = default;

	priority_queue(const priority_queue& q) = default;
	priority_queue(priority_queue&& q) = default;

	priority_queue& operator=(const priority_queue& q) = default;
	priority_queue& operator=(priority_queue&& q) = default;

	explicit priority_queue(const Compare& comp);
	priority_queue(const Compare& comp, const container_type& c);
	explicit priority_queue(const Compare& comp, container_type&& c);
	template <class InputIterator>
	priority_queue(InputIterator first, InputIterator last,
	const Compare& comp = Compare());
	template <class InputIterator>
	priority_queue(InputIterator first, InputIterator last,
	const Compare& comp, const container_type& c);
	template <class InputIterator>
	priority_queue(InputIterator first, InputIterator last,
	const Compare& comp, container_type&& c);
	template <class Alloc>
	explicit priority_queue(const Alloc& a);
	template <class Alloc>
	priority_queue(const Compare& comp, const Alloc& a);
	template <class Alloc>
	priority_queue(const Compare& comp, const container_type& c,
	const Alloc& a);
	template <class Alloc>
	priority_queue(const Compare& comp, container_type&& c,
	const Alloc& a);
	template <class Alloc>
	priority_queue(const priority_queue& q, const Alloc& a);
	template <class Alloc>
	priority_queue(priority_queue&& q, const Alloc& a);

	bool empty() const;
	size_type size() const;
	const_reference top() const;

	void push(const value_type& v);
	void push(value_type&& v);
	template <class... Args> void emplace(Args&&... args);
	void pop();

	void swap(priority_queue& q)
	noexcept(is_nothrow_swappable_v<Container> &&
	is_nothrow_swappable_v<Comp>)
	};

	+template <class Compare, class Container>
	+priority_queue(Compare, Container)
	+ -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
	+
	+template<class InputIterator,
	+ class Compare = less<typename iterator_traits<InputIterator>::value_type>,
	+ class Container = vector<typename iterator_traits<InputIterator>::value_type>>
	+priority_queue(InputIterator, InputIterator, Compare = Compare(), Container = Container())
	+ -> priority_queue<typename iterator_traits<InputIterator>::value_type, Container, Compare>; // C++17
	+
	+template<class Compare, class Container, class Allocator>
	+priority_queue(Compare, Container, Allocator)
	+ -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
	+
	template <class T, class Container, class Compare>
	void swap(priority_queue<T, Container, Compare>& x,
	priority_queue<T, Container, Compare>& y)
	noexcept(noexcept(x.swap(y)));

	} // std

	*/

	#include <__config>
	#include <deque>
	#include <vector>
	#include <functional>
	#include <algorithm>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _Tp, class _Container = deque<_Tp> > class _LIBCPP_TEMPLATE_VIS queue;

	template <class _Tp, class _Container>
	_LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y);

	template <class _Tp, class _Container>
	_LIBCPP_INLINE_VISIBILITY
	bool
	operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y);

	template <class _Tp, class _Container /= deque<_Tp>/>
	class _LIBCPP_TEMPLATE_VIS queue
	{
	public:
	typedef _Container container_type;
	typedef typename container_type::value_type value_type;
	typedef typename container_type::reference reference;
	typedef typename container_type::const_reference const_reference;
	typedef typename container_type::size_type size_type;
	static_assert((is_same<_Tp, value_type>::value), "" );

	protected:
	container_type c;

	public:
	_LIBCPP_INLINE_VISIBILITY
	queue()
	_NOEXCEPT_(is_nothrow_default_constructible<container_type>::value)
	: c() {}

	_LIBCPP_INLINE_VISIBILITY
	queue(const queue& __q) : c(__q.c) {}

	_LIBCPP_INLINE_VISIBILITY
	queue& operator=(const queue& __q) {c = __q.c; return *this;}

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	queue(queue&& __q)
	_NOEXCEPT_(is_nothrow_move_constructible<container_type>::value)
	: c(_VSTD::move(__q.c)) {}

	_LIBCPP_INLINE_VISIBILITY
	queue& operator=(queue&& __q)
	_NOEXCEPT_(is_nothrow_move_assignable<container_type>::value)
	{c = _VSTD::move(__q.c); return *this;}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	explicit queue(const container_type& __c) : c(__c) {}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	explicit queue(container_type&& __c) : c(_VSTD::move(__c)) {}
	#endif // _LIBCPP_CXX03_LANG
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	explicit queue(const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type* = 0)
	: c(__a) {}
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	queue(const queue& __q, const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type* = 0)
	: c(__q.c, __a) {}
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	queue(const container_type& __c, const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type* = 0)
	: c(__c, __a) {}
	#ifndef _LIBCPP_CXX03_LANG
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	queue(container_type&& __c, const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type* = 0)
	: c(_VSTD::move(__c), __a) {}
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	queue(queue&& __q, const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type* = 0)
	: c(_VSTD::move(__q.c), __a) {}

	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
	bool empty() const {return c.empty();}
	_LIBCPP_INLINE_VISIBILITY
	size_type size() const {return c.size();}

	_LIBCPP_INLINE_VISIBILITY
	reference front() {return c.front();}
	_LIBCPP_INLINE_VISIBILITY
	const_reference front() const {return c.front();}
	_LIBCPP_INLINE_VISIBILITY
	reference back() {return c.back();}
	_LIBCPP_INLINE_VISIBILITY
	const_reference back() const {return c.back();}

	_LIBCPP_INLINE_VISIBILITY
	void push(const value_type& __v) {c.push_back(__v);}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	void push(value_type&& __v) {c.push_back(_VSTD::move(__v));}
	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	#if _LIBCPP_STD_VER > 14
	- reference emplace(_Args&&... __args)
	+ decltype(auto) emplace(_Args&&... __args)
	{ return c.emplace_back(_VSTD::forward<_Args>(__args)...);}
	#else
	void emplace(_Args&&... __args)
	{ c.emplace_back(_VSTD::forward<_Args>(__args)...);}
	#endif
	#endif // _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	void pop() {c.pop_front();}

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

	template <class _T1, class _C1>
	friend
	_LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const queue<_T1, _C1>& __x,const queue<_T1, _C1>& __y);

	template <class _T1, class _C1>
	friend
	_LIBCPP_INLINE_VISIBILITY
	bool
	operator< (const queue<_T1, _C1>& __x,const queue<_T1, _C1>& __y);
	};

	+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
	+template<class _Container,
	+ class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type
	+>
	+queue(_Container)
	+ -> queue<typename _Container::value_type, _Container>;
	+
	+template<class _Container,
	+ class _Alloc,
	+ class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type,
	+ class = typename enable_if< __is_allocator<_Alloc>::value, nullptr_t>::type
	+>
	+queue(_Container, _Alloc)
	+ -> queue<typename _Container::value_type, _Container>;
	+#endif
	+
	template <class _Tp, class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
	{
	return __x.c == __y.c;
	}

	template <class _Tp, class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
	{
	return __x.c < __y.c;
	}

	template <class _Tp, class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
	{
	return !(__x == __y);
	}

	template <class _Tp, class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator> (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
	{
	return __y < __x;
	}

	template <class _Tp, class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
	{
	return !(__x < __y);
	}

	template <class _Tp, class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
	{
	return !(__y < __x);
	}

	template <class _Tp, class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if<
	__is_swappable<_Container>::value,
	void
	>::type
	swap(queue<_Tp, _Container>& __x, queue<_Tp, _Container>& __y)
	_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
	{
	__x.swap(__y);
	}

	template <class _Tp, class _Container, class _Alloc>
	struct _LIBCPP_TEMPLATE_VIS uses_allocator<queue<_Tp, _Container>, _Alloc>
	: public uses_allocator<_Container, _Alloc>
	{
	};

	template <class _Tp, class _Container = vector<_Tp>,
	class _Compare = less<typename _Container::value_type> >
	class _LIBCPP_TEMPLATE_VIS priority_queue
	{
	public:
	typedef _Container container_type;
	typedef _Compare value_compare;
	typedef typename container_type::value_type value_type;
	typedef typename container_type::reference reference;
	typedef typename container_type::const_reference const_reference;
	typedef typename container_type::size_type size_type;
	static_assert((is_same<_Tp, value_type>::value), "" );

	protected:
	container_type c;
	value_compare comp;

	public:
	_LIBCPP_INLINE_VISIBILITY
	priority_queue()
	_NOEXCEPT_(is_nothrow_default_constructible<container_type>::value &&
	is_nothrow_default_constructible<value_compare>::value)
	: c(), comp() {}

	_LIBCPP_INLINE_VISIBILITY
	priority_queue(const priority_queue& __q) : c(__q.c), comp(__q.comp) {}

	_LIBCPP_INLINE_VISIBILITY
	priority_queue& operator=(const priority_queue& __q)
	{c = __q.c; comp = __q.comp; return *this;}

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	priority_queue(priority_queue&& __q)
	_NOEXCEPT_(is_nothrow_move_constructible<container_type>::value &&
	is_nothrow_move_constructible<value_compare>::value)
	: c(_VSTD::move(__q.c)), comp(_VSTD::move(__q.comp)) {}

	_LIBCPP_INLINE_VISIBILITY
	priority_queue& operator=(priority_queue&& __q)
	_NOEXCEPT_(is_nothrow_move_assignable<container_type>::value &&
	is_nothrow_move_assignable<value_compare>::value)
	{c = _VSTD::move(__q.c); comp = _VSTD::move(__q.comp); return *this;}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	explicit priority_queue(const value_compare& __comp)
	: c(), comp(__comp) {}
	_LIBCPP_INLINE_VISIBILITY
	priority_queue(const value_compare& __comp, const container_type& __c);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	explicit priority_queue(const value_compare& __comp, container_type&& __c);
	#endif
	template <class _InputIter>
	_LIBCPP_INLINE_VISIBILITY
	priority_queue(_InputIter __f, _InputIter __l,
	const value_compare& __comp = value_compare());
	template <class _InputIter>
	_LIBCPP_INLINE_VISIBILITY
	priority_queue(_InputIter __f, _InputIter __l,
	const value_compare& __comp, const container_type& __c);
	#ifndef _LIBCPP_CXX03_LANG
	template <class _InputIter>
	_LIBCPP_INLINE_VISIBILITY
	priority_queue(_InputIter __f, _InputIter __l,
	const value_compare& __comp, container_type&& __c);
	#endif // _LIBCPP_CXX03_LANG
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	explicit priority_queue(const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type* = 0);
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	priority_queue(const value_compare& __comp, const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type* = 0);
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	priority_queue(const value_compare& __comp, const container_type& __c,
	const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type* = 0);
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	priority_queue(const priority_queue& __q, const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type* = 0);
	#ifndef _LIBCPP_CXX03_LANG
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	priority_queue(const value_compare& __comp, container_type&& __c,
	const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type* = 0);
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	priority_queue(priority_queue&& __q, const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type* = 0);
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
	bool empty() const {return c.empty();}
	_LIBCPP_INLINE_VISIBILITY
	size_type size() const {return c.size();}
	_LIBCPP_INLINE_VISIBILITY
	const_reference top() const {return c.front();}

	_LIBCPP_INLINE_VISIBILITY
	void push(const value_type& __v);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	void push(value_type&& __v);
	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	void emplace(_Args&&... __args);
	#endif // _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	void pop();

	_LIBCPP_INLINE_VISIBILITY
	void swap(priority_queue& __q)
	_NOEXCEPT_(__is_nothrow_swappable<container_type>::value &&
	__is_nothrow_swappable<value_compare>::value);
	};
	+
	+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
	+template <class _Compare,
	+ class _Container,
	+ class = typename enable_if<!__is_allocator<_Compare>::value, nullptr_t>::type,
	+ class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type
	+>
	+priority_queue(_Compare, _Container)
	+ -> priority_queue<typename _Container::value_type, _Container, _Compare>;
	+
	+template<class _InputIterator,
	+ class _Compare = less<typename iterator_traits<_InputIterator>::value_type>,
	+ class _Container = vector<typename iterator_traits<_InputIterator>::value_type>,
	+ class = typename enable_if< __is_input_iterator<_InputIterator>::value, nullptr_t>::type,
	+ class = typename enable_if<!__is_allocator<_Compare>::value, nullptr_t>::type,
	+ class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type
	+>
	+priority_queue(_InputIterator, _InputIterator, _Compare = _Compare(), _Container = _Container())
	+ -> priority_queue<typename iterator_traits<_InputIterator>::value_type, _Container, _Compare>;
	+
	+template<class _Compare,
	+ class _Container,
	+ class _Alloc,
	+ class = typename enable_if<!__is_allocator<_Compare>::value, nullptr_t>::type,
	+ class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type,
	+ class = typename enable_if< __is_allocator<_Alloc>::value, nullptr_t>::type
	+>
	+priority_queue(_Compare, _Container, _Alloc)
	+ -> priority_queue<typename _Container::value_type, _Container, _Compare>;
	+#endif

	template <class _Tp, class _Container, class _Compare>
	inline
	priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Compare& __comp,
	const container_type& __c)
	: c(__c),
	comp(__comp)
	{
	_VSTD::make_heap(c.begin(), c.end(), comp);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Container, class _Compare>
	inline
	priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
	container_type&& __c)
	: c(_VSTD::move(__c)),
	comp(__comp)
	{
	_VSTD::make_heap(c.begin(), c.end(), comp);
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Container, class _Compare>
	template <class _InputIter>
	inline
	priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
	const value_compare& __comp)
	: c(__f, __l),
	comp(__comp)
	{
	_VSTD::make_heap(c.begin(), c.end(), comp);
	}

	template <class _Tp, class _Container, class _Compare>
	template <class _InputIter>
	inline
	priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
	const value_compare& __comp,
	const container_type& __c)
	: c(__c),
	comp(__comp)
	{
	c.insert(c.end(), __f, __l);
	_VSTD::make_heap(c.begin(), c.end(), comp);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Container, class _Compare>
	template <class _InputIter>
	inline
	priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
	const value_compare& __comp,
	container_type&& __c)
	: c(_VSTD::move(__c)),
	comp(__comp)
	{
	c.insert(c.end(), __f, __l);
	_VSTD::make_heap(c.begin(), c.end(), comp);
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Container, class _Compare>
	template <class _Alloc>
	inline
	priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type*)
	: c(__a)
	{
	}

	template <class _Tp, class _Container, class _Compare>
	template <class _Alloc>
	inline
	priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
	const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type*)
	: c(__a),
	comp(__comp)
	{
	}

	template <class _Tp, class _Container, class _Compare>
	template <class _Alloc>
	inline
	priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
	const container_type& __c,
	const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type*)
	: c(__c, __a),
	comp(__comp)
	{
	_VSTD::make_heap(c.begin(), c.end(), comp);
	}

	template <class _Tp, class _Container, class _Compare>
	template <class _Alloc>
	inline
	priority_queue<_Tp, _Container, _Compare>::priority_queue(const priority_queue& __q,
	const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type*)
	: c(__q.c, __a),
	comp(__q.comp)
	{
	_VSTD::make_heap(c.begin(), c.end(), comp);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Container, class _Compare>
	template <class _Alloc>
	inline
	priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
	container_type&& __c,
	const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type*)
	: c(_VSTD::move(__c), __a),
	comp(__comp)
	{
	_VSTD::make_heap(c.begin(), c.end(), comp);
	}

	template <class _Tp, class _Container, class _Compare>
	template <class _Alloc>
	inline
	priority_queue<_Tp, _Container, _Compare>::priority_queue(priority_queue&& __q,
	const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type*)
	: c(_VSTD::move(__q.c), __a),
	comp(_VSTD::move(__q.comp))
	{
	_VSTD::make_heap(c.begin(), c.end(), comp);
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Container, class _Compare>
	inline
	void
	priority_queue<_Tp, _Container, _Compare>::push(const value_type& __v)
	{
	c.push_back(__v);
	_VSTD::push_heap(c.begin(), c.end(), comp);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Container, class _Compare>
	inline
	void
	priority_queue<_Tp, _Container, _Compare>::push(value_type&& __v)
	{
	c.push_back(_VSTD::move(__v));
	_VSTD::push_heap(c.begin(), c.end(), comp);
	}

	template <class _Tp, class _Container, class _Compare>
	template <class... _Args>
	inline
	void
	priority_queue<_Tp, _Container, _Compare>::emplace(_Args&&... __args)
	{
	c.emplace_back(_VSTD::forward<_Args>(__args)...);
	_VSTD::push_heap(c.begin(), c.end(), comp);
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp, class _Container, class _Compare>
	inline
	void
	priority_queue<_Tp, _Container, _Compare>::pop()
	{
	_VSTD::pop_heap(c.begin(), c.end(), comp);
	c.pop_back();
	}

	template <class _Tp, class _Container, class _Compare>
	inline
	void
	priority_queue<_Tp, _Container, _Compare>::swap(priority_queue& __q)
	_NOEXCEPT_(__is_nothrow_swappable<container_type>::value &&
	__is_nothrow_swappable<value_compare>::value)
	{
	using _VSTD::swap;
	swap(c, __q.c);
	swap(comp, __q.comp);
	}

	template <class _Tp, class _Container, class _Compare>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if<
	__is_swappable<_Container>::value
	&& __is_swappable<_Compare>::value,
	void
	>::type
	swap(priority_queue<_Tp, _Container, _Compare>& __x,
	priority_queue<_Tp, _Container, _Compare>& __y)
	_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
	{
	__x.swap(__y);
	}

	template <class _Tp, class _Container, class _Compare, class _Alloc>
	struct _LIBCPP_TEMPLATE_VIS uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc>
	: public uses_allocator<_Container, _Alloc>
	{
	};

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_QUEUE
	Index: projects/clang700-import/contrib/libc++/include/random
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/random (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/random (revision 337135)
	@@ -1,6744 +1,6744 @@
	// -- C++ --
	//===--------------------------- random -----------------------------------===//
	//
	// 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_RANDOM
	#define _LIBCPP_RANDOM

	/*
	random synopsis

	#include <initializer_list>

	namespace std
	{

	// Engines

	template <class UIntType, UIntType a, UIntType c, UIntType m>
	class linear_congruential_engine
	{
	public:
	// types
	typedef UIntType result_type;

	// engine characteristics
	static constexpr result_type multiplier = a;
	static constexpr result_type increment = c;
	static constexpr result_type modulus = m;
	static constexpr result_type min() { return c == 0u ? 1u: 0u;}
	static constexpr result_type max() { return m - 1u;}
	static constexpr result_type default_seed = 1u;

	// constructors and seeding functions
	explicit linear_congruential_engine(result_type s = default_seed);
	template<class Sseq> explicit linear_congruential_engine(Sseq& q);
	void seed(result_type s = default_seed);
	template<class Sseq> void seed(Sseq& q);

	// generating functions
	result_type operator()();
	void discard(unsigned long long z);
	};

	template <class UIntType, UIntType a, UIntType c, UIntType m>
	bool
	operator==(const linear_congruential_engine<UIntType, a, c, m>& x,
	const linear_congruential_engine<UIntType, a, c, m>& y);

	template <class UIntType, UIntType a, UIntType c, UIntType m>
	bool
	operator!=(const linear_congruential_engine<UIntType, a, c, m>& x,
	const linear_congruential_engine<UIntType, a, c, m>& y);

	template <class charT, class traits,
	class UIntType, UIntType a, UIntType c, UIntType m>
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const linear_congruential_engine<UIntType, a, c, m>& x);

	template <class charT, class traits,
	class UIntType, UIntType a, UIntType c, UIntType m>
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	linear_congruential_engine<UIntType, a, c, m>& x);

	template <class UIntType, size_t w, size_t n, size_t m, size_t r,
	UIntType a, size_t u, UIntType d, size_t s,
	UIntType b, size_t t, UIntType c, size_t l, UIntType f>
	class mersenne_twister_engine
	{
	public:
	// types
	typedef UIntType result_type;

	// engine characteristics
	static constexpr size_t word_size = w;
	static constexpr size_t state_size = n;
	static constexpr size_t shift_size = m;
	static constexpr size_t mask_bits = r;
	static constexpr result_type xor_mask = a;
	static constexpr size_t tempering_u = u;
	static constexpr result_type tempering_d = d;
	static constexpr size_t tempering_s = s;
	static constexpr result_type tempering_b = b;
	static constexpr size_t tempering_t = t;
	static constexpr result_type tempering_c = c;
	static constexpr size_t tempering_l = l;
	static constexpr result_type initialization_multiplier = f;
	static constexpr result_type min () { return 0; }
	static constexpr result_type max() { return 2^w - 1; }
	static constexpr result_type default_seed = 5489u;

	// constructors and seeding functions
	explicit mersenne_twister_engine(result_type value = default_seed);
	template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
	void seed(result_type value = default_seed);
	template<class Sseq> void seed(Sseq& q);

	// generating functions
	result_type operator()();
	void discard(unsigned long long z);
	};

	template <class UIntType, size_t w, size_t n, size_t m, size_t r,
	UIntType a, size_t u, UIntType d, size_t s,
	UIntType b, size_t t, UIntType c, size_t l, UIntType f>
	bool
	operator==(
	const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x,
	const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& y);

	template <class UIntType, size_t w, size_t n, size_t m, size_t r,
	UIntType a, size_t u, UIntType d, size_t s,
	UIntType b, size_t t, UIntType c, size_t l, UIntType f>
	bool
	operator!=(
	const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x,
	const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& y);

	template <class charT, class traits,
	class UIntType, size_t w, size_t n, size_t m, size_t r,
	UIntType a, size_t u, UIntType d, size_t s,
	UIntType b, size_t t, UIntType c, size_t l, UIntType f>
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x);

	template <class charT, class traits,
	class UIntType, size_t w, size_t n, size_t m, size_t r,
	UIntType a, size_t u, UIntType d, size_t s,
	UIntType b, size_t t, UIntType c, size_t l, UIntType f>
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x);

	template<class UIntType, size_t w, size_t s, size_t r>
	class subtract_with_carry_engine
	{
	public:
	// types
	typedef UIntType result_type;

	// engine characteristics
	static constexpr size_t word_size = w;
	static constexpr size_t short_lag = s;
	static constexpr size_t long_lag = r;
	static constexpr result_type min() { return 0; }
	static constexpr result_type max() { return m-1; }
	static constexpr result_type default_seed = 19780503u;

	// constructors and seeding functions
	explicit subtract_with_carry_engine(result_type value = default_seed);
	template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
	void seed(result_type value = default_seed);
	template<class Sseq> void seed(Sseq& q);

	// generating functions
	result_type operator()();
	void discard(unsigned long long z);
	};

	template<class UIntType, size_t w, size_t s, size_t r>
	bool
	operator==(
	const subtract_with_carry_engine<UIntType, w, s, r>& x,
	const subtract_with_carry_engine<UIntType, w, s, r>& y);

	template<class UIntType, size_t w, size_t s, size_t r>
	bool
	operator!=(
	const subtract_with_carry_engine<UIntType, w, s, r>& x,
	const subtract_with_carry_engine<UIntType, w, s, r>& y);

	template <class charT, class traits,
	class UIntType, size_t w, size_t s, size_t r>
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const subtract_with_carry_engine<UIntType, w, s, r>& x);

	template <class charT, class traits,
	class UIntType, size_t w, size_t s, size_t r>
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	subtract_with_carry_engine<UIntType, w, s, r>& x);

	template<class Engine, size_t p, size_t r>
	class discard_block_engine
	{
	public:
	// types
	typedef typename Engine::result_type result_type;

	// engine characteristics
	static constexpr size_t block_size = p;
	static constexpr size_t used_block = r;
	static constexpr result_type min() { return Engine::min(); }
	static constexpr result_type max() { return Engine::max(); }

	// constructors and seeding functions
	discard_block_engine();
	explicit discard_block_engine(const Engine& e);
	explicit discard_block_engine(Engine&& e);
	explicit discard_block_engine(result_type s);
	template<class Sseq> explicit discard_block_engine(Sseq& q);
	void seed();
	void seed(result_type s);
	template<class Sseq> void seed(Sseq& q);

	// generating functions
	result_type operator()();
	void discard(unsigned long long z);

	// property functions
	const Engine& base() const noexcept;
	};

	template<class Engine, size_t p, size_t r>
	bool
	operator==(
	const discard_block_engine<Engine, p, r>& x,
	const discard_block_engine<Engine, p, r>& y);

	template<class Engine, size_t p, size_t r>
	bool
	operator!=(
	const discard_block_engine<Engine, p, r>& x,
	const discard_block_engine<Engine, p, r>& y);

	template <class charT, class traits,
	class Engine, size_t p, size_t r>
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const discard_block_engine<Engine, p, r>& x);

	template <class charT, class traits,
	class Engine, size_t p, size_t r>
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	discard_block_engine<Engine, p, r>& x);

	template<class Engine, size_t w, class UIntType>
	class independent_bits_engine
	{
	public:
	// types
	typedef UIntType result_type;

	// engine characteristics
	static constexpr result_type min() { return 0; }
	static constexpr result_type max() { return 2^w - 1; }

	// constructors and seeding functions
	independent_bits_engine();
	explicit independent_bits_engine(const Engine& e);
	explicit independent_bits_engine(Engine&& e);
	explicit independent_bits_engine(result_type s);
	template<class Sseq> explicit independent_bits_engine(Sseq& q);
	void seed();
	void seed(result_type s);
	template<class Sseq> void seed(Sseq& q);

	// generating functions
	result_type operator()(); void discard(unsigned long long z);

	// property functions
	const Engine& base() const noexcept;
	};

	template<class Engine, size_t w, class UIntType>
	bool
	operator==(
	const independent_bits_engine<Engine, w, UIntType>& x,
	const independent_bits_engine<Engine, w, UIntType>& y);

	template<class Engine, size_t w, class UIntType>
	bool
	operator!=(
	const independent_bits_engine<Engine, w, UIntType>& x,
	const independent_bits_engine<Engine, w, UIntType>& y);

	template <class charT, class traits,
	class Engine, size_t w, class UIntType>
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const independent_bits_engine<Engine, w, UIntType>& x);

	template <class charT, class traits,
	class Engine, size_t w, class UIntType>
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	independent_bits_engine<Engine, w, UIntType>& x);

	template<class Engine, size_t k>
	class shuffle_order_engine
	{
	public:
	// types
	typedef typename Engine::result_type result_type;

	// engine characteristics
	static constexpr size_t table_size = k;
	static constexpr result_type min() { return Engine::min; }
	static constexpr result_type max() { return Engine::max; }

	// constructors and seeding functions
	shuffle_order_engine();
	explicit shuffle_order_engine(const Engine& e);
	explicit shuffle_order_engine(Engine&& e);
	explicit shuffle_order_engine(result_type s);
	template<class Sseq> explicit shuffle_order_engine(Sseq& q);
	void seed();
	void seed(result_type s);
	template<class Sseq> void seed(Sseq& q);

	// generating functions
	result_type operator()();
	void discard(unsigned long long z);

	// property functions
	const Engine& base() const noexcept;
	};

	template<class Engine, size_t k>
	bool
	operator==(
	const shuffle_order_engine<Engine, k>& x,
	const shuffle_order_engine<Engine, k>& y);

	template<class Engine, size_t k>
	bool
	operator!=(
	const shuffle_order_engine<Engine, k>& x,
	const shuffle_order_engine<Engine, k>& y);

	template <class charT, class traits,
	class Engine, size_t k>
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const shuffle_order_engine<Engine, k>& x);

	template <class charT, class traits,
	class Engine, size_t k>
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	shuffle_order_engine<Engine, k>& x);

	typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>
	minstd_rand0;
	typedef linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>
	minstd_rand;
	typedef mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31,
	0x9908b0df,
	11, 0xffffffff,
	7, 0x9d2c5680,
	15, 0xefc60000,
	18, 1812433253> mt19937;
	typedef mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
	0xb5026f5aa96619e9,
	29, 0x5555555555555555,
	17, 0x71d67fffeda60000,
	37, 0xfff7eee000000000,
	43, 6364136223846793005> mt19937_64;
	typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24> ranlux24_base;
	typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12> ranlux48_base;
	typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
	typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
	typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
	typedef minstd_rand default_random_engine;

	// Generators

	class random_device
	{
	public:
	// types
	typedef unsigned int result_type;

	// generator characteristics
	static constexpr result_type min() { return numeric_limits<result_type>::min(); }
	static constexpr result_type max() { return numeric_limits<result_type>::max(); }

	// constructors
	explicit random_device(const string& token = "/dev/urandom");

	// generating functions
	result_type operator()();

	// property functions
	double entropy() const noexcept;

	// no copy functions
	random_device(const random_device& ) = delete;
	void operator=(const random_device& ) = delete;
	};

	// Utilities

	class seed_seq
	{
	public:
	// types
	typedef uint_least32_t result_type;

	// constructors
	seed_seq();
	template<class T>
	seed_seq(initializer_list<T> il);
	template<class InputIterator>
	seed_seq(InputIterator begin, InputIterator end);

	// generating functions
	template<class RandomAccessIterator>
	void generate(RandomAccessIterator begin, RandomAccessIterator end);

	// property functions
	size_t size() const;
	template<class OutputIterator>
	void param(OutputIterator dest) const;

	// no copy functions
	seed_seq(const seed_seq&) = delete;
	void operator=(const seed_seq& ) = delete;
	};

	template<class RealType, size_t bits, class URNG>
	RealType generate_canonical(URNG& g);

	// Distributions

	template<class IntType = int>
	class uniform_int_distribution
	{
	public:
	// types
	typedef IntType result_type;

	class param_type
	{
	public:
	typedef uniform_int_distribution distribution_type;

	explicit param_type(IntType a = 0,
	IntType b = numeric_limits<IntType>::max());

	result_type a() const;
	result_type b() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructors and reset functions
	explicit uniform_int_distribution(IntType a = 0,
	IntType b = numeric_limits<IntType>::max());
	explicit uniform_int_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	result_type a() const;
	result_type b() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const uniform_int_distribution& x,
	const uniform_int_distribution& y);
	friend bool operator!=(const uniform_int_distribution& x,
	const uniform_int_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const uniform_int_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	uniform_int_distribution& x);
	};

	template<class RealType = double>
	class uniform_real_distribution
	{
	public:
	// types
	typedef RealType result_type;

	class param_type
	{
	public:
	typedef uniform_real_distribution distribution_type;

	explicit param_type(RealType a = 0,
	RealType b = 1);

	result_type a() const;
	result_type b() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructors and reset functions
	explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0);
	explicit uniform_real_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	result_type a() const;
	result_type b() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const uniform_real_distribution& x,
	const uniform_real_distribution& y);
	friend bool operator!=(const uniform_real_distribution& x,
	const uniform_real_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const uniform_real_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	uniform_real_distribution& x);
	};

	class bernoulli_distribution
	{
	public:
	// types
	typedef bool result_type;

	class param_type
	{
	public:
	typedef bernoulli_distribution distribution_type;

	explicit param_type(double p = 0.5);

	double p() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructors and reset functions
	explicit bernoulli_distribution(double p = 0.5);
	explicit bernoulli_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	double p() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const bernoulli_distribution& x,
	const bernoulli_distribution& y);
	friend bool operator!=(const bernoulli_distribution& x,
	const bernoulli_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const bernoulli_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	bernoulli_distribution& x);
	};

	template<class IntType = int>
	class binomial_distribution
	{
	public:
	// types
	typedef IntType result_type;

	class param_type
	{
	public:
	typedef binomial_distribution distribution_type;

	explicit param_type(IntType t = 1, double p = 0.5);

	IntType t() const;
	double p() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructors and reset functions
	explicit binomial_distribution(IntType t = 1, double p = 0.5);
	explicit binomial_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	IntType t() const;
	double p() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const binomial_distribution& x,
	const binomial_distribution& y);
	friend bool operator!=(const binomial_distribution& x,
	const binomial_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const binomial_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	binomial_distribution& x);
	};

	template<class IntType = int>
	class geometric_distribution
	{
	public:
	// types
	typedef IntType result_type;

	class param_type
	{
	public:
	typedef geometric_distribution distribution_type;

	explicit param_type(double p = 0.5);

	double p() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructors and reset functions
	explicit geometric_distribution(double p = 0.5);
	explicit geometric_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	double p() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const geometric_distribution& x,
	const geometric_distribution& y);
	friend bool operator!=(const geometric_distribution& x,
	const geometric_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const geometric_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	geometric_distribution& x);
	};

	template<class IntType = int>
	class negative_binomial_distribution
	{
	public:
	// types
	typedef IntType result_type;

	class param_type
	{
	public:
	typedef negative_binomial_distribution distribution_type;

	explicit param_type(result_type k = 1, double p = 0.5);

	result_type k() const;
	double p() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructor and reset functions
	explicit negative_binomial_distribution(result_type k = 1, double p = 0.5);
	explicit negative_binomial_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	result_type k() const;
	double p() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const negative_binomial_distribution& x,
	const negative_binomial_distribution& y);
	friend bool operator!=(const negative_binomial_distribution& x,
	const negative_binomial_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const negative_binomial_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	negative_binomial_distribution& x);
	};

	template<class IntType = int>
	class poisson_distribution
	{
	public:
	// types
	typedef IntType result_type;

	class param_type
	{
	public:
	typedef poisson_distribution distribution_type;

	explicit param_type(double mean = 1.0);

	double mean() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructors and reset functions
	explicit poisson_distribution(double mean = 1.0);
	explicit poisson_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	double mean() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const poisson_distribution& x,
	const poisson_distribution& y);
	friend bool operator!=(const poisson_distribution& x,
	const poisson_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const poisson_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	poisson_distribution& x);
	};

	template<class RealType = double>
	class exponential_distribution
	{
	public:
	// types
	typedef RealType result_type;

	class param_type
	{
	public:
	typedef exponential_distribution distribution_type;

	explicit param_type(result_type lambda = 1.0);

	result_type lambda() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructors and reset functions
	explicit exponential_distribution(result_type lambda = 1.0);
	explicit exponential_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	result_type lambda() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const exponential_distribution& x,
	const exponential_distribution& y);
	friend bool operator!=(const exponential_distribution& x,
	const exponential_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const exponential_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	exponential_distribution& x);
	};

	template<class RealType = double>
	class gamma_distribution
	{
	public:
	// types
	typedef RealType result_type;

	class param_type
	{
	public:
	typedef gamma_distribution distribution_type;

	explicit param_type(result_type alpha = 1, result_type beta = 1);

	result_type alpha() const;
	result_type beta() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructors and reset functions
	explicit gamma_distribution(result_type alpha = 1, result_type beta = 1);
	explicit gamma_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	result_type alpha() const;
	result_type beta() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const gamma_distribution& x,
	const gamma_distribution& y);
	friend bool operator!=(const gamma_distribution& x,
	const gamma_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const gamma_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	gamma_distribution& x);
	};

	template<class RealType = double>
	class weibull_distribution
	{
	public:
	// types
	typedef RealType result_type;

	class param_type
	{
	public:
	typedef weibull_distribution distribution_type;

	explicit param_type(result_type alpha = 1, result_type beta = 1);

	result_type a() const;
	result_type b() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructor and reset functions
	explicit weibull_distribution(result_type a = 1, result_type b = 1);
	explicit weibull_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	result_type a() const;
	result_type b() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const weibull_distribution& x,
	const weibull_distribution& y);
	friend bool operator!=(const weibull_distribution& x,
	const weibull_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const weibull_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	weibull_distribution& x);
	};

	template<class RealType = double>
	class extreme_value_distribution
	{
	public:
	// types
	typedef RealType result_type;

	class param_type
	{
	public:
	typedef extreme_value_distribution distribution_type;

	explicit param_type(result_type a = 0, result_type b = 1);

	result_type a() const;
	result_type b() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructor and reset functions
	explicit extreme_value_distribution(result_type a = 0, result_type b = 1);
	explicit extreme_value_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	result_type a() const;
	result_type b() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const extreme_value_distribution& x,
	const extreme_value_distribution& y);
	friend bool operator!=(const extreme_value_distribution& x,
	const extreme_value_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const extreme_value_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	extreme_value_distribution& x);
	};

	template<class RealType = double>
	class normal_distribution
	{
	public:
	// types
	typedef RealType result_type;

	class param_type
	{
	public:
	typedef normal_distribution distribution_type;

	explicit param_type(result_type mean = 0, result_type stddev = 1);

	result_type mean() const;
	result_type stddev() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructors and reset functions
	explicit normal_distribution(result_type mean = 0, result_type stddev = 1);
	explicit normal_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	result_type mean() const;
	result_type stddev() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const normal_distribution& x,
	const normal_distribution& y);
	friend bool operator!=(const normal_distribution& x,
	const normal_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const normal_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	normal_distribution& x);
	};

	template<class RealType = double>
	class lognormal_distribution
	{
	public:
	// types
	typedef RealType result_type;

	class param_type
	{
	public:
	typedef lognormal_distribution distribution_type;

	explicit param_type(result_type m = 0, result_type s = 1);

	result_type m() const;
	result_type s() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructor and reset functions
	explicit lognormal_distribution(result_type m = 0, result_type s = 1);
	explicit lognormal_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	result_type m() const;
	result_type s() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const lognormal_distribution& x,
	const lognormal_distribution& y);
	friend bool operator!=(const lognormal_distribution& x,
	const lognormal_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const lognormal_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	lognormal_distribution& x);
	};

	template<class RealType = double>
	class chi_squared_distribution
	{
	public:
	// types
	typedef RealType result_type;

	class param_type
	{
	public:
	typedef chi_squared_distribution distribution_type;

	explicit param_type(result_type n = 1);

	result_type n() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructor and reset functions
	explicit chi_squared_distribution(result_type n = 1);
	explicit chi_squared_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	result_type n() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const chi_squared_distribution& x,
	const chi_squared_distribution& y);
	friend bool operator!=(const chi_squared_distribution& x,
	const chi_squared_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const chi_squared_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	chi_squared_distribution& x);
	};

	template<class RealType = double>
	class cauchy_distribution
	{
	public:
	// types
	typedef RealType result_type;

	class param_type
	{
	public:
	typedef cauchy_distribution distribution_type;

	explicit param_type(result_type a = 0, result_type b = 1);

	result_type a() const;
	result_type b() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructor and reset functions
	explicit cauchy_distribution(result_type a = 0, result_type b = 1);
	explicit cauchy_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	result_type a() const;
	result_type b() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const cauchy_distribution& x,
	const cauchy_distribution& y);
	friend bool operator!=(const cauchy_distribution& x,
	const cauchy_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const cauchy_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	cauchy_distribution& x);
	};

	template<class RealType = double>
	class fisher_f_distribution
	{
	public:
	// types
	typedef RealType result_type;

	class param_type
	{
	public:
	typedef fisher_f_distribution distribution_type;

	explicit param_type(result_type m = 1, result_type n = 1);

	result_type m() const;
	result_type n() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructor and reset functions
	explicit fisher_f_distribution(result_type m = 1, result_type n = 1);
	explicit fisher_f_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	result_type m() const;
	result_type n() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const fisher_f_distribution& x,
	const fisher_f_distribution& y);
	friend bool operator!=(const fisher_f_distribution& x,
	const fisher_f_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const fisher_f_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	fisher_f_distribution& x);
	};

	template<class RealType = double>
	class student_t_distribution
	{
	public:
	// types
	typedef RealType result_type;

	class param_type
	{
	public:
	typedef student_t_distribution distribution_type;

	explicit param_type(result_type n = 1);

	result_type n() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructor and reset functions
	explicit student_t_distribution(result_type n = 1);
	explicit student_t_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	result_type n() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const student_t_distribution& x,
	const student_t_distribution& y);
	friend bool operator!=(const student_t_distribution& x,
	const student_t_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const student_t_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	student_t_distribution& x);
	};

	template<class IntType = int>
	class discrete_distribution
	{
	public:
	// types
	typedef IntType result_type;

	class param_type
	{
	public:
	typedef discrete_distribution distribution_type;

	param_type();
	template<class InputIterator>
	param_type(InputIterator firstW, InputIterator lastW);
	param_type(initializer_list<double> wl);
	template<class UnaryOperation>
	param_type(size_t nw, double xmin, double xmax, UnaryOperation fw);

	vector<double> probabilities() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructor and reset functions
	discrete_distribution();
	template<class InputIterator>
	discrete_distribution(InputIterator firstW, InputIterator lastW);
	discrete_distribution(initializer_list<double> wl);
	template<class UnaryOperation>
	discrete_distribution(size_t nw, double xmin, double xmax,
	UnaryOperation fw);
	explicit discrete_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

	// property functions
	vector<double> probabilities() const;

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const discrete_distribution& x,
	const discrete_distribution& y);
	friend bool operator!=(const discrete_distribution& x,
	const discrete_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const discrete_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	discrete_distribution& x);
	};

	template<class RealType = double>
	class piecewise_constant_distribution
	{
	// types
	typedef RealType result_type;

	class param_type
	{
	public:
	typedef piecewise_constant_distribution distribution_type;

	param_type();
	template<class InputIteratorB, class InputIteratorW>
	param_type(InputIteratorB firstB, InputIteratorB lastB,
	InputIteratorW firstW);
	template<class UnaryOperation>
	param_type(initializer_list<result_type> bl, UnaryOperation fw);
	template<class UnaryOperation>
	param_type(size_t nw, result_type xmin, result_type xmax,
	UnaryOperation fw);

	vector<result_type> intervals() const;
	vector<result_type> densities() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructor and reset functions
	piecewise_constant_distribution();
	template<class InputIteratorB, class InputIteratorW>
	piecewise_constant_distribution(InputIteratorB firstB,
	InputIteratorB lastB,
	InputIteratorW firstW);
	template<class UnaryOperation>
	piecewise_constant_distribution(initializer_list<result_type> bl,
	UnaryOperation fw);
	template<class UnaryOperation>
	piecewise_constant_distribution(size_t nw, result_type xmin,
	result_type xmax, UnaryOperation fw);
	explicit piecewise_constant_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

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

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const piecewise_constant_distribution& x,
	const piecewise_constant_distribution& y);
	friend bool operator!=(const piecewise_constant_distribution& x,
	const piecewise_constant_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const piecewise_constant_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	piecewise_constant_distribution& x);
	};

	template<class RealType = double>
	class piecewise_linear_distribution
	{
	// types
	typedef RealType result_type;

	class param_type
	{
	public:
	typedef piecewise_linear_distribution distribution_type;

	param_type();
	template<class InputIteratorB, class InputIteratorW>
	param_type(InputIteratorB firstB, InputIteratorB lastB,
	InputIteratorW firstW);
	template<class UnaryOperation>
	param_type(initializer_list<result_type> bl, UnaryOperation fw);
	template<class UnaryOperation>
	param_type(size_t nw, result_type xmin, result_type xmax,
	UnaryOperation fw);

	vector<result_type> intervals() const;
	vector<result_type> densities() const;

	friend bool operator==(const param_type& x, const param_type& y);
	friend bool operator!=(const param_type& x, const param_type& y);
	};

	// constructor and reset functions
	piecewise_linear_distribution();
	template<class InputIteratorB, class InputIteratorW>
	piecewise_linear_distribution(InputIteratorB firstB,
	InputIteratorB lastB,
	InputIteratorW firstW);

	template<class UnaryOperation>
	piecewise_linear_distribution(initializer_list<result_type> bl,
	UnaryOperation fw);

	template<class UnaryOperation>
	piecewise_linear_distribution(size_t nw, result_type xmin,
	result_type xmax, UnaryOperation fw);

	explicit piecewise_linear_distribution(const param_type& parm);
	void reset();

	// generating functions
	template<class URNG> result_type operator()(URNG& g);
	template<class URNG> result_type operator()(URNG& g, const param_type& parm);

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

	param_type param() const;
	void param(const param_type& parm);

	result_type min() const;
	result_type max() const;

	friend bool operator==(const piecewise_linear_distribution& x,
	const piecewise_linear_distribution& y);
	friend bool operator!=(const piecewise_linear_distribution& x,
	const piecewise_linear_distribution& y);

	template <class charT, class traits>
	friend
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	const piecewise_linear_distribution& x);

	template <class charT, class traits>
	friend
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is,
	piecewise_linear_distribution& x);
	};

	} // std
	*/

	#include <__config>
	#include <cstddef>
	#include <cstdint>
	#include <cmath>
	#include <type_traits>
	#include <initializer_list>
	#include <limits>
	#include <algorithm>
	#include <numeric>
	#include <vector>
	#include <string>
	#include <istream>
	#include <ostream>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_STD

	// __is_seed_sequence

	template <class _Sseq, class _Engine>
	struct __is_seed_sequence
	{
	static _LIBCPP_CONSTEXPR const bool value =
	!is_convertible<_Sseq, typename _Engine::result_type>::value &&
	!is_same<typename remove_cv<_Sseq>::type, _Engine>::value;
	};

	// linear_congruential_engine

	template <unsigned long long __a, unsigned long long __c,
	unsigned long long __m, unsigned long long _Mp,
	bool _MightOverflow = (__a != 0 && __m != 0 && __m-1 > (_Mp-__c)/__a)>
	struct __lce_ta;

	// 64

	template <unsigned long long __a, unsigned long long __c, unsigned long long __m>
	struct __lce_ta<__a, __c, __m, (unsigned long long)(~0), true>
	{
	typedef unsigned long long result_type;
	_LIBCPP_INLINE_VISIBILITY
	static result_type next(result_type __x)
	{
	// Schrage's algorithm
	const result_type __q = __m / __a;
	const result_type __r = __m % __a;
	const result_type __t0 = __a * (__x % __q);
	const result_type __t1 = __r * (__x / __q);
	__x = __t0 + (__t0 < __t1) * __m - __t1;
	__x += __c - (__x >= __m - __c) * __m;
	return __x;
	}
	};

	template <unsigned long long __a, unsigned long long __m>
	struct __lce_ta<__a, 0, __m, (unsigned long long)(~0), true>
	{
	typedef unsigned long long result_type;
	_LIBCPP_INLINE_VISIBILITY
	static result_type next(result_type __x)
	{
	// Schrage's algorithm
	const result_type __q = __m / __a;
	const result_type __r = __m % __a;
	const result_type __t0 = __a * (__x % __q);
	const result_type __t1 = __r * (__x / __q);
	__x = __t0 + (__t0 < __t1) * __m - __t1;
	return __x;
	}
	};

	template <unsigned long long __a, unsigned long long __c, unsigned long long __m>
	struct __lce_ta<__a, __c, __m, (unsigned long long)(~0), false>
	{
	typedef unsigned long long result_type;
	_LIBCPP_INLINE_VISIBILITY
	static result_type next(result_type __x)
	{
	return (__a * __x + __c) % __m;
	}
	};

	template <unsigned long long __a, unsigned long long __c>
	struct __lce_ta<__a, __c, 0, (unsigned long long)(~0), false>
	{
	typedef unsigned long long result_type;
	_LIBCPP_INLINE_VISIBILITY
	static result_type next(result_type __x)
	{
	return __a * __x + __c;
	}
	};

	// 32

	template <unsigned long long _Ap, unsigned long long _Cp, unsigned long long _Mp>
	struct __lce_ta<_Ap, _Cp, _Mp, unsigned(~0), true>
	{
	typedef unsigned result_type;
	_LIBCPP_INLINE_VISIBILITY
	static result_type next(result_type __x)
	{
	const result_type __a = static_cast<result_type>(_Ap);
	const result_type __c = static_cast<result_type>(_Cp);
	const result_type __m = static_cast<result_type>(_Mp);
	// Schrage's algorithm
	const result_type __q = __m / __a;
	const result_type __r = __m % __a;
	const result_type __t0 = __a * (__x % __q);
	const result_type __t1 = __r * (__x / __q);
	__x = __t0 + (__t0 < __t1) * __m - __t1;
	__x += __c - (__x >= __m - __c) * __m;
	return __x;
	}
	};

	template <unsigned long long _Ap, unsigned long long _Mp>
	struct __lce_ta<_Ap, 0, _Mp, unsigned(~0), true>
	{
	typedef unsigned result_type;
	_LIBCPP_INLINE_VISIBILITY
	static result_type next(result_type __x)
	{
	const result_type __a = static_cast<result_type>(_Ap);
	const result_type __m = static_cast<result_type>(_Mp);
	// Schrage's algorithm
	const result_type __q = __m / __a;
	const result_type __r = __m % __a;
	const result_type __t0 = __a * (__x % __q);
	const result_type __t1 = __r * (__x / __q);
	__x = __t0 + (__t0 < __t1) * __m - __t1;
	return __x;
	}
	};

	template <unsigned long long _Ap, unsigned long long _Cp, unsigned long long _Mp>
	struct __lce_ta<_Ap, _Cp, _Mp, unsigned(~0), false>
	{
	typedef unsigned result_type;
	_LIBCPP_INLINE_VISIBILITY
	static result_type next(result_type __x)
	{
	const result_type __a = static_cast<result_type>(_Ap);
	const result_type __c = static_cast<result_type>(_Cp);
	const result_type __m = static_cast<result_type>(_Mp);
	return (__a * __x + __c) % __m;
	}
	};

	template <unsigned long long _Ap, unsigned long long _Cp>
	struct __lce_ta<_Ap, _Cp, 0, unsigned(~0), false>
	{
	typedef unsigned result_type;
	_LIBCPP_INLINE_VISIBILITY
	static result_type next(result_type __x)
	{
	const result_type __a = static_cast<result_type>(_Ap);
	const result_type __c = static_cast<result_type>(_Cp);
	return __a * __x + __c;
	}
	};

	// 16

	template <unsigned long long __a, unsigned long long __c, unsigned long long __m, bool __b>
	struct __lce_ta<__a, __c, __m, (unsigned short)(~0), __b>
	{
	typedef unsigned short result_type;
	_LIBCPP_INLINE_VISIBILITY
	static result_type next(result_type __x)
	{
	return static_cast<result_type>(__lce_ta<__a, __c, __m, unsigned(~0)>::next(__x));
	}
	};

	template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
	class _LIBCPP_TEMPLATE_VIS linear_congruential_engine;

	template <class _CharT, class _Traits,
	class _Up, _Up _Ap, _Up _Cp, _Up _Np>
	_LIBCPP_INLINE_VISIBILITY
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&);

	template <class _CharT, class _Traits,
	class _Up, _Up _Ap, _Up _Cp, _Up _Np>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);

	template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
	class _LIBCPP_TEMPLATE_VIS linear_congruential_engine
	{
	public:
	// types
	typedef _UIntType result_type;

	private:
	result_type __x_;

	static _LIBCPP_CONSTEXPR const result_type _Mp = result_type(~0);

	static_assert(__m == 0 \|\| __a < __m, "linear_congruential_engine invalid parameters");
	static_assert(__m == 0 \|\| __c < __m, "linear_congruential_engine invalid parameters");
	public:
	static _LIBCPP_CONSTEXPR const result_type _Min = __c == 0u ? 1u: 0u;
	static _LIBCPP_CONSTEXPR const result_type _Max = __m - 1u;
	static_assert(_Min < _Max, "linear_congruential_engine invalid parameters");

	// engine characteristics
	static _LIBCPP_CONSTEXPR const result_type multiplier = __a;
	static _LIBCPP_CONSTEXPR const result_type increment = __c;
	static _LIBCPP_CONSTEXPR const result_type modulus = __m;
	_LIBCPP_INLINE_VISIBILITY
	static _LIBCPP_CONSTEXPR result_type min() {return _Min;}
	_LIBCPP_INLINE_VISIBILITY
	static _LIBCPP_CONSTEXPR result_type max() {return _Max;}
	static _LIBCPP_CONSTEXPR const result_type default_seed = 1u;

	// constructors and seeding functions
	_LIBCPP_INLINE_VISIBILITY
	explicit linear_congruential_engine(result_type __s = default_seed)
	{seed(__s);}
	template<class _Sseq>
	_LIBCPP_INLINE_VISIBILITY
	explicit linear_congruential_engine(_Sseq& __q,
	typename enable_if<__is_seed_sequence<_Sseq, linear_congruential_engine>::value>::type* = 0)
	{seed(__q);}
	_LIBCPP_INLINE_VISIBILITY
	void seed(result_type __s = default_seed)
	{seed(integral_constant<bool, __m == 0>(),
	integral_constant<bool, __c == 0>(), __s);}
	template<class _Sseq>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_seed_sequence<_Sseq, linear_congruential_engine>::value,
	void
	>::type
	seed(_Sseq& __q)
	{__seed(__q, integral_constant<unsigned,
	1 + (__m == 0 ? (sizeof(result_type) * __CHAR_BIT__ - 1)/32
	: (__m > 0x100000000ull))>());}

	// generating functions
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()()
	{return __x_ = static_cast<result_type>(__lce_ta<__a, __c, __m, _Mp>::next(__x_));}
	_LIBCPP_INLINE_VISIBILITY
	void discard(unsigned long long __z) {for (; __z; --__z) operator()();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const linear_congruential_engine& __x,
	const linear_congruential_engine& __y)
	{return __x.__x_ == __y.__x_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const linear_congruential_engine& __x,
	const linear_congruential_engine& __y)
	{return !(__x == __y);}

	private:

	_LIBCPP_INLINE_VISIBILITY
	void seed(true_type, true_type, result_type __s) {__x_ = __s == 0 ? 1 : __s;}
	_LIBCPP_INLINE_VISIBILITY
	void seed(true_type, false_type, result_type __s) {__x_ = __s;}
	_LIBCPP_INLINE_VISIBILITY
	void seed(false_type, true_type, result_type __s) {__x_ = __s % __m == 0 ?
	1 : __s % __m;}
	_LIBCPP_INLINE_VISIBILITY
	void seed(false_type, false_type, result_type __s) {__x_ = __s % __m;}

	template<class _Sseq>
	void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
	template<class _Sseq>
	void __seed(_Sseq& __q, integral_constant<unsigned, 2>);

	template <class _CharT, class _Traits,
	class _Up, _Up _Ap, _Up _Cp, _Up _Np>
	friend
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&);

	template <class _CharT, class _Traits,
	class _Up, _Up _Ap, _Up _Cp, _Up _Np>
	friend
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
	};

	template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
	_LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
	linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier;

	template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
	_LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
	linear_congruential_engine<_UIntType, __a, __c, __m>::increment;

	template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
	_LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
	linear_congruential_engine<_UIntType, __a, __c, __m>::modulus;

	template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
	_LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
	linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed;

	template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
	template<class _Sseq>
	void
	linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q,
	integral_constant<unsigned, 1>)
	{
	const unsigned __k = 1;
	uint32_t __ar[__k+3];
	__q.generate(__ar, __ar + __k + 3);
	result_type __s = static_cast<result_type>(__ar[3] % __m);
	__x_ = __c == 0 && __s == 0 ? result_type(1) : __s;
	}

	template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
	template<class _Sseq>
	void
	linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q,
	integral_constant<unsigned, 2>)
	{
	const unsigned __k = 2;
	uint32_t __ar[__k+3];
	__q.generate(__ar, __ar + __k + 3);
	result_type __s = static_cast<result_type>((__ar[3] +
	((uint64_t)__ar[4] << 32)) % __m);
	__x_ = __c == 0 && __s == 0 ? result_type(1) : __s;
	}

	template <class _CharT, class _Traits,
	class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const linear_congruential_engine<_UIntType, __a, __c, __m>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left);
	__os.fill(__os.widen(' '));
	return __os << __x.__x_;
	}

	template <class _CharT, class _Traits,
	class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	linear_congruential_engine<_UIntType, __a, __c, __m>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	_UIntType __t;
	__is >> __t;
	if (!__is.fail())
	__x.__x_ = __t;
	return __is;
	}

	typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>
	minstd_rand0;
	typedef linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>
	minstd_rand;
	typedef minstd_rand default_random_engine;
	// mersenne_twister_engine

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine;

	template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
	_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
	_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
	bool
	operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __x,
	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __y);

	template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
	_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
	_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
	_LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __x,
	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __y);

	template <class _CharT, class _Traits,
	class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
	_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
	_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __x);

	template <class _CharT, class _Traits,
	class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
	_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
	_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __x);

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine
	{
	public:
	// types
	typedef _UIntType result_type;

	private:
	result_type __x_[__n];
	size_t __i_;

	static_assert( 0 < __m, "mersenne_twister_engine invalid parameters");
	static_assert(__m <= __n, "mersenne_twister_engine invalid parameters");
	static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
	static_assert(__w <= _Dt, "mersenne_twister_engine invalid parameters");
	static_assert( 2 <= __w, "mersenne_twister_engine invalid parameters");
	static_assert(__r <= __w, "mersenne_twister_engine invalid parameters");
	static_assert(__u <= __w, "mersenne_twister_engine invalid parameters");
	static_assert(__s <= __w, "mersenne_twister_engine invalid parameters");
	static_assert(__t <= __w, "mersenne_twister_engine invalid parameters");
	static_assert(__l <= __w, "mersenne_twister_engine invalid parameters");
	public:
	static _LIBCPP_CONSTEXPR const result_type _Min = 0;
	static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
	(result_type(1) << __w) - result_type(1);
	static_assert(_Min < _Max, "mersenne_twister_engine invalid parameters");
	static_assert(__a <= _Max, "mersenne_twister_engine invalid parameters");
	static_assert(__b <= _Max, "mersenne_twister_engine invalid parameters");
	static_assert(__c <= _Max, "mersenne_twister_engine invalid parameters");
	static_assert(__d <= _Max, "mersenne_twister_engine invalid parameters");
	static_assert(__f <= _Max, "mersenne_twister_engine invalid parameters");

	// engine characteristics
	static _LIBCPP_CONSTEXPR const size_t word_size = __w;
	static _LIBCPP_CONSTEXPR const size_t state_size = __n;
	static _LIBCPP_CONSTEXPR const size_t shift_size = __m;
	static _LIBCPP_CONSTEXPR const size_t mask_bits = __r;
	static _LIBCPP_CONSTEXPR const result_type xor_mask = __a;
	static _LIBCPP_CONSTEXPR const size_t tempering_u = __u;
	static _LIBCPP_CONSTEXPR const result_type tempering_d = __d;
	static _LIBCPP_CONSTEXPR const size_t tempering_s = __s;
	static _LIBCPP_CONSTEXPR const result_type tempering_b = __b;
	static _LIBCPP_CONSTEXPR const size_t tempering_t = __t;
	static _LIBCPP_CONSTEXPR const result_type tempering_c = __c;
	static _LIBCPP_CONSTEXPR const size_t tempering_l = __l;
	static _LIBCPP_CONSTEXPR const result_type initialization_multiplier = __f;
	_LIBCPP_INLINE_VISIBILITY
	static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
	_LIBCPP_INLINE_VISIBILITY
	static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
	static _LIBCPP_CONSTEXPR const result_type default_seed = 5489u;

	// constructors and seeding functions
	_LIBCPP_INLINE_VISIBILITY
	explicit mersenne_twister_engine(result_type __sd = default_seed)
	{seed(__sd);}
	template<class _Sseq>
	_LIBCPP_INLINE_VISIBILITY
	explicit mersenne_twister_engine(_Sseq& __q,
	typename enable_if<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* = 0)
	{seed(__q);}
	void seed(result_type __sd = default_seed);
	template<class _Sseq>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_seed_sequence<_Sseq, mersenne_twister_engine>::value,
	void
	>::type
	seed(_Sseq& __q)
	{__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());}

	// generating functions
	result_type operator()();
	_LIBCPP_INLINE_VISIBILITY
	void discard(unsigned long long __z) {for (; __z; --__z) operator()();}

	template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
	_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
	_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
	friend
	bool
	operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __x,
	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __y);

	template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
	_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
	_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
	friend
	bool
	operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __x,
	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __y);

	template <class _CharT, class _Traits,
	class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
	_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
	_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
	friend
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __x);

	template <class _CharT, class _Traits,
	class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
	_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
	_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
	friend
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __x);
	private:

	template<class _Sseq>
	void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
	template<class _Sseq>
	void __seed(_Sseq& __q, integral_constant<unsigned, 2>);

	template <size_t __count>
	_LIBCPP_INLINE_VISIBILITY
	static
	typename enable_if
	<
	__count < __w,
	result_type
	>::type
	__lshift(result_type __x) {return (__x << __count) & _Max;}

	template <size_t __count>
	_LIBCPP_INLINE_VISIBILITY
	static
	typename enable_if
	<
	(__count >= __w),
	result_type
	>::type
	__lshift(result_type) {return result_type(0);}

	template <size_t __count>
	_LIBCPP_INLINE_VISIBILITY
	static
	typename enable_if
	<
	__count < _Dt,
	result_type
	>::type
	__rshift(result_type __x) {return __x >> __count;}

	template <size_t __count>
	_LIBCPP_INLINE_VISIBILITY
	static
	typename enable_if
	<
	(__count >= _Dt),
	result_type
	>::type
	__rshift(result_type) {return result_type(0);}
	};

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	_LIBCPP_CONSTEXPR const size_t
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::word_size;

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	_LIBCPP_CONSTEXPR const size_t
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::state_size;

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	_LIBCPP_CONSTEXPR const size_t
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::shift_size;

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	_LIBCPP_CONSTEXPR const size_t
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::mask_bits;

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::xor_mask;

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	_LIBCPP_CONSTEXPR const size_t
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_u;

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_d;

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	_LIBCPP_CONSTEXPR const size_t
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_s;

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_b;

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	_LIBCPP_CONSTEXPR const size_t
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_t;

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_c;

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	_LIBCPP_CONSTEXPR const size_t
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_l;

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::initialization_multiplier;

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::default_seed;

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	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)
	__x_[__i] = (__f * (__x_[__i-1] ^ __rshift<__w - 2>(__x_[__i-1])) + __i) & _Max;
	__i_ = 0;
	}

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	template<class _Sseq>
	void
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
	__t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant<unsigned, 1>)
	{
	const unsigned __k = 1;
	uint32_t __ar[__n * __k];
	__q.generate(__ar, __ar + __n * __k);
	for (size_t __i = 0; __i < __n; ++__i)
	__x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
	const result_type __mask = __r == _Dt ? result_type(~0) :
	(result_type(1) << __r) - result_type(1);
	__i_ = 0;
	if ((__x_[0] & ~__mask) == 0)
	{
	for (size_t __i = 1; __i < __n; ++__i)
	if (__x_[__i] != 0)
	return;
	__x_[0] = _Max;
	}
	}

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	template<class _Sseq>
	void
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
	__t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant<unsigned, 2>)
	{
	const unsigned __k = 2;
	uint32_t __ar[__n * __k];
	__q.generate(__ar, __ar + __n * __k);
	for (size_t __i = 0; __i < __n; ++__i)
	__x_[__i] = static_cast<result_type>(
	(__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
	const result_type __mask = __r == _Dt ? result_type(~0) :
	(result_type(1) << __r) - result_type(1);
	__i_ = 0;
	if ((__x_[0] & ~__mask) == 0)
	{
	for (size_t __i = 1; __i < __n; ++__i)
	if (__x_[__i] != 0)
	return;
	__x_[0] = _Max;
	}
	}

	template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
	_UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
	_UIntType
	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
	__t, __c, __l, __f>::operator()()
	{
	const size_t __j = (__i_ + 1) % __n;
	const result_type __mask = __r == _Dt ? result_type(~0) :
	(result_type(1) << __r) - result_type(1);
	const result_type _Yp = (__x_[__i_] & ~__mask) \| (__x_[__j] & __mask);
	const size_t __k = (__i_ + __m) % __n;
	__x_[__i_] = __x_[__k] ^ __rshift<1>(_Yp) ^ (__a * (_Yp & 1));
	result_type __z = __x_[__i_] ^ (__rshift<__u>(__x_[__i_]) & __d);
	__i_ = __j;
	__z ^= __lshift<__s>(__z) & __b;
	__z ^= __lshift<__t>(__z) & __c;
	return __z ^ __rshift<__l>(__z);
	}

	template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
	_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
	_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
	bool
	operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __x,
	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __y)
	{
	if (__x.__i_ == __y.__i_)
	return _VSTD::equal(__x.__x_, __x.__x_ + _Np, __y.__x_);
	if (__x.__i_ == 0 \|\| __y.__i_ == 0)
	{
	size_t __j = _VSTD::min(_Np - __x.__i_, _Np - __y.__i_);
	if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
	__y.__x_ + __y.__i_))
	return false;
	if (__x.__i_ == 0)
	return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Np, __y.__x_);
	return _VSTD::equal(__x.__x_, __x.__x_ + (_Np - __j), __y.__x_ + __j);
	}
	if (__x.__i_ < __y.__i_)
	{
	size_t __j = _Np - __y.__i_;
	if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
	__y.__x_ + __y.__i_))
	return false;
	if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Np,
	__y.__x_))
	return false;
	return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
	__y.__x_ + (_Np - (__x.__i_ + __j)));
	}
	size_t __j = _Np - __x.__i_;
	if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
	__x.__x_ + __x.__i_))
	return false;
	if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Np,
	__x.__x_))
	return false;
	return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
	__x.__x_ + (_Np - (__y.__i_ + __j)));
	}

	template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
	_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
	_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __x,
	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __y)
	{
	return !(__x == __y);
	}

	template <class _CharT, class _Traits,
	class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
	_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
	_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	__os << __x.__x_[__x.__i_];
	for (size_t __j = __x.__i_ + 1; __j < _Np; ++__j)
	__os << __sp << __x.__x_[__j];
	for (size_t __j = 0; __j < __x.__i_; ++__j)
	__os << __sp << __x.__x_[__j];
	return __os;
	}

	template <class _CharT, class _Traits,
	class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
	_UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
	_UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
	_Bp, _Tp, _Cp, _Lp, _Fp>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	_UInt __t[_Np];
	for (size_t __i = 0; __i < _Np; ++__i)
	__is >> __t[__i];
	if (!__is.fail())
	{
	for (size_t __i = 0; __i < _Np; ++__i)
	__x.__x_[__i] = __t[__i];
	__x.__i_ = 0;
	}
	return __is;
	}

	typedef mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31,
	0x9908b0df, 11, 0xffffffff,
	7, 0x9d2c5680,
	15, 0xefc60000,
	18, 1812433253> mt19937;
	typedef mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
	0xb5026f5aa96619e9ULL, 29, 0x5555555555555555ULL,
	17, 0x71d67fffeda60000ULL,
	37, 0xfff7eee000000000ULL,
	43, 6364136223846793005ULL> mt19937_64;

	// subtract_with_carry_engine

	template<class _UIntType, size_t __w, size_t __s, size_t __r>
	class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine;

	template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
	bool
	operator==(
	const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
	const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);

	template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
	_LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(
	const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
	const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);

	template <class _CharT, class _Traits,
	class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);

	template <class _CharT, class _Traits,
	class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);

	template<class _UIntType, size_t __w, size_t __s, size_t __r>
	class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine
	{
	public:
	// types
	typedef _UIntType result_type;

	private:
	result_type __x_[__r];
	result_type __c_;
	size_t __i_;

	static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
	static_assert( 0 < __w, "subtract_with_carry_engine invalid parameters");
	static_assert(__w <= _Dt, "subtract_with_carry_engine invalid parameters");
	static_assert( 0 < __s, "subtract_with_carry_engine invalid parameters");
	static_assert(__s < __r, "subtract_with_carry_engine invalid parameters");
	public:
	static _LIBCPP_CONSTEXPR const result_type _Min = 0;
	static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
	(result_type(1) << __w) - result_type(1);
	static_assert(_Min < _Max, "subtract_with_carry_engine invalid parameters");

	// engine characteristics
	static _LIBCPP_CONSTEXPR const size_t word_size = __w;
	static _LIBCPP_CONSTEXPR const size_t short_lag = __s;
	static _LIBCPP_CONSTEXPR const size_t long_lag = __r;
	_LIBCPP_INLINE_VISIBILITY
	static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
	_LIBCPP_INLINE_VISIBILITY
	static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
	static _LIBCPP_CONSTEXPR const result_type default_seed = 19780503u;

	// constructors and seeding functions
	_LIBCPP_INLINE_VISIBILITY
	explicit subtract_with_carry_engine(result_type __sd = default_seed)
	{seed(__sd);}
	template<class _Sseq>
	_LIBCPP_INLINE_VISIBILITY
	explicit subtract_with_carry_engine(_Sseq& __q,
	typename enable_if<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value>::type* = 0)
	{seed(__q);}
	_LIBCPP_INLINE_VISIBILITY
	void seed(result_type __sd = default_seed)
	{seed(__sd, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
	template<class _Sseq>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value,
	void
	>::type
	seed(_Sseq& __q)
	{__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());}

	// generating functions
	result_type operator()();
	_LIBCPP_INLINE_VISIBILITY
	void discard(unsigned long long __z) {for (; __z; --__z) operator()();}

	template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
	friend
	bool
	operator==(
	const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
	const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);

	template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
	friend
	bool
	operator!=(
	const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
	const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);

	template <class _CharT, class _Traits,
	class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
	friend
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);

	template <class _CharT, class _Traits,
	class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
	friend
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);

	private:

	void seed(result_type __sd, integral_constant<unsigned, 1>);
	void seed(result_type __sd, integral_constant<unsigned, 2>);
	template<class _Sseq>
	void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
	template<class _Sseq>
	void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
	};

	template<class _UIntType, size_t __w, size_t __s, size_t __r>
	_LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;

	template<class _UIntType, size_t __w, size_t __s, size_t __r>
	_LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;

	template<class _UIntType, size_t __w, size_t __s, size_t __r>
	_LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;

	template<class _UIntType, size_t __w, size_t __s, size_t __r>
	_LIBCPP_CONSTEXPR const typename subtract_with_carry_engine<_UIntType, __w, __s, __r>::result_type
	subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed;

	template<class _UIntType, size_t __w, size_t __s, size_t __r>
	void
	subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
	integral_constant<unsigned, 1>)
	{
	linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
	__e(__sd == 0u ? default_seed : __sd);
	for (size_t __i = 0; __i < __r; ++__i)
	__x_[__i] = static_cast<result_type>(__e() & _Max);
	__c_ = __x_[__r-1] == 0;
	__i_ = 0;
	}

	template<class _UIntType, size_t __w, size_t __s, size_t __r>
	void
	subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
	integral_constant<unsigned, 2>)
	{
	linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
	__e(__sd == 0u ? default_seed : __sd);
	for (size_t __i = 0; __i < __r; ++__i)
	{
	result_type __e0 = __e();
	__x_[__i] = static_cast<result_type>(
	(__e0 + ((uint64_t)__e() << 32)) & _Max);
	}
	__c_ = __x_[__r-1] == 0;
	__i_ = 0;
	}

	template<class _UIntType, size_t __w, size_t __s, size_t __r>
	template<class _Sseq>
	void
	subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q,
	integral_constant<unsigned, 1>)
	{
	const unsigned __k = 1;
	uint32_t __ar[__r * __k];
	__q.generate(__ar, __ar + __r * __k);
	for (size_t __i = 0; __i < __r; ++__i)
	__x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
	__c_ = __x_[__r-1] == 0;
	__i_ = 0;
	}

	template<class _UIntType, size_t __w, size_t __s, size_t __r>
	template<class _Sseq>
	void
	subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q,
	integral_constant<unsigned, 2>)
	{
	const unsigned __k = 2;
	uint32_t __ar[__r * __k];
	__q.generate(__ar, __ar + __r * __k);
	for (size_t __i = 0; __i < __r; ++__i)
	__x_[__i] = static_cast<result_type>(
	(__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
	__c_ = __x_[__r-1] == 0;
	__i_ = 0;
	}

	template<class _UIntType, size_t __w, size_t __s, size_t __r>
	_UIntType
	subtract_with_carry_engine<_UIntType, __w, __s, __r>::operator()()
	{
	const result_type& __xs = __x_[(__i_ + (__r - __s)) % __r];
	result_type& __xr = __x_[__i_];
	result_type __new_c = __c_ == 0 ? __xs < __xr : __xs != 0 ? __xs <= __xr : 1;
	__xr = (__xs - __xr - __c_) & _Max;
	__c_ = __new_c;
	__i_ = (__i_ + 1) % __r;
	return __xr;
	}

	template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
	bool
	operator==(
	const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
	const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y)
	{
	if (__x.__c_ != __y.__c_)
	return false;
	if (__x.__i_ == __y.__i_)
	return _VSTD::equal(__x.__x_, __x.__x_ + _Rp, __y.__x_);
	if (__x.__i_ == 0 \|\| __y.__i_ == 0)
	{
	size_t __j = _VSTD::min(_Rp - __x.__i_, _Rp - __y.__i_);
	if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
	__y.__x_ + __y.__i_))
	return false;
	if (__x.__i_ == 0)
	return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Rp, __y.__x_);
	return _VSTD::equal(__x.__x_, __x.__x_ + (_Rp - __j), __y.__x_ + __j);
	}
	if (__x.__i_ < __y.__i_)
	{
	size_t __j = _Rp - __y.__i_;
	if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
	__y.__x_ + __y.__i_))
	return false;
	if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Rp,
	__y.__x_))
	return false;
	return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
	__y.__x_ + (_Rp - (__x.__i_ + __j)));
	}
	size_t __j = _Rp - __x.__i_;
	if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
	__x.__x_ + __x.__i_))
	return false;
	if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Rp,
	__x.__x_))
	return false;
	return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
	__x.__x_ + (_Rp - (__y.__i_ + __j)));
	}

	template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(
	const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
	const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y)
	{
	return !(__x == __y);
	}

	template <class _CharT, class _Traits,
	class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	__os << __x.__x_[__x.__i_];
	for (size_t __j = __x.__i_ + 1; __j < _Rp; ++__j)
	__os << __sp << __x.__x_[__j];
	for (size_t __j = 0; __j < __x.__i_; ++__j)
	__os << __sp << __x.__x_[__j];
	__os << __sp << __x.__c_;
	return __os;
	}

	template <class _CharT, class _Traits,
	class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	_UInt __t[_Rp+1];
	for (size_t __i = 0; __i < _Rp+1; ++__i)
	__is >> __t[__i];
	if (!__is.fail())
	{
	for (size_t __i = 0; __i < _Rp; ++__i)
	__x.__x_[__i] = __t[__i];
	__x.__c_ = __t[_Rp];
	__x.__i_ = 0;
	}
	return __is;
	}

	typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24> ranlux24_base;
	typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12> ranlux48_base;

	// discard_block_engine

	template<class _Engine, size_t __p, size_t __r>
	class _LIBCPP_TEMPLATE_VIS discard_block_engine
	{
	_Engine __e_;
	int __n_;

	static_assert( 0 < __r, "discard_block_engine invalid parameters");
	static_assert(__r <= __p, "discard_block_engine invalid parameters");
	static_assert(__r <= INT_MAX, "discard_block_engine invalid parameters");
	public:
	// types
	typedef typename _Engine::result_type result_type;

	// engine characteristics
	static _LIBCPP_CONSTEXPR const size_t block_size = __p;
	static _LIBCPP_CONSTEXPR const size_t used_block = __r;

	#ifdef _LIBCPP_CXX03_LANG
	static const result_type _Min = _Engine::_Min;
	static const result_type _Max = _Engine::_Max;
	#else
	static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
	static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
	#endif

	_LIBCPP_INLINE_VISIBILITY
	static _LIBCPP_CONSTEXPR result_type min() { return _Engine::min(); }
	_LIBCPP_INLINE_VISIBILITY
	static _LIBCPP_CONSTEXPR result_type max() { return _Engine::max(); }

	// constructors and seeding functions
	_LIBCPP_INLINE_VISIBILITY
	discard_block_engine() : __n_(0) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit discard_block_engine(const _Engine& __e)
	: __e_(__e), __n_(0) {}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	explicit discard_block_engine(_Engine&& __e)
	: __e_(_VSTD::move(__e)), __n_(0) {}
	#endif // _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {}
	template<class _Sseq>
	_LIBCPP_INLINE_VISIBILITY
	explicit discard_block_engine(_Sseq& __q,
	typename enable_if<__is_seed_sequence<_Sseq, discard_block_engine>::value &&
	!is_convertible<_Sseq, _Engine>::value>::type* = 0)
	: __e_(__q), __n_(0) {}
	_LIBCPP_INLINE_VISIBILITY
	void seed() {__e_.seed(); __n_ = 0;}
	_LIBCPP_INLINE_VISIBILITY
	void seed(result_type __sd) {__e_.seed(__sd); __n_ = 0;}
	template<class _Sseq>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_seed_sequence<_Sseq, discard_block_engine>::value,
	void
	>::type
	seed(_Sseq& __q) {__e_.seed(__q); __n_ = 0;}

	// generating functions
	result_type operator()();
	_LIBCPP_INLINE_VISIBILITY
	void discard(unsigned long long __z) {for (; __z; --__z) operator()();}

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	const _Engine& base() const _NOEXCEPT {return __e_;}

	template<class _Eng, size_t _Pp, size_t _Rp>
	friend
	bool
	operator==(
	const discard_block_engine<_Eng, _Pp, _Rp>& __x,
	const discard_block_engine<_Eng, _Pp, _Rp>& __y);

	template<class _Eng, size_t _Pp, size_t _Rp>
	friend
	bool
	operator!=(
	const discard_block_engine<_Eng, _Pp, _Rp>& __x,
	const discard_block_engine<_Eng, _Pp, _Rp>& __y);

	template <class _CharT, class _Traits,
	class _Eng, size_t _Pp, size_t _Rp>
	friend
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const discard_block_engine<_Eng, _Pp, _Rp>& __x);

	template <class _CharT, class _Traits,
	class _Eng, size_t _Pp, size_t _Rp>
	friend
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	discard_block_engine<_Eng, _Pp, _Rp>& __x);
	};

	template<class _Engine, size_t __p, size_t __r>
	_LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::block_size;

	template<class _Engine, size_t __p, size_t __r>
	_LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::used_block;

	template<class _Engine, size_t __p, size_t __r>
	typename discard_block_engine<_Engine, __p, __r>::result_type
	discard_block_engine<_Engine, __p, __r>::operator()()
	{
	if (__n_ >= static_cast<int>(__r))
	{
	__e_.discard(__p - __r);
	__n_ = 0;
	}
	++__n_;
	return __e_();
	}

	template<class _Eng, size_t _Pp, size_t _Rp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const discard_block_engine<_Eng, _Pp, _Rp>& __x,
	const discard_block_engine<_Eng, _Pp, _Rp>& __y)
	{
	return __x.__n_ == __y.__n_ && __x.__e_ == __y.__e_;
	}

	template<class _Eng, size_t _Pp, size_t _Rp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const discard_block_engine<_Eng, _Pp, _Rp>& __x,
	const discard_block_engine<_Eng, _Pp, _Rp>& __y)
	{
	return !(__x == __y);
	}

	template <class _CharT, class _Traits,
	class _Eng, size_t _Pp, size_t _Rp>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const discard_block_engine<_Eng, _Pp, _Rp>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	return __os << __x.__e_ << __sp << __x.__n_;
	}

	template <class _CharT, class _Traits,
	class _Eng, size_t _Pp, size_t _Rp>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	discard_block_engine<_Eng, _Pp, _Rp>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	_Eng __e;
	int __n;
	__is >> __e >> __n;
	if (!__is.fail())
	{
	__x.__e_ = __e;
	__x.__n_ = __n;
	}
	return __is;
	}

	typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
	typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;

	// independent_bits_engine

	template<class _Engine, size_t __w, class _UIntType>
	class _LIBCPP_TEMPLATE_VIS independent_bits_engine
	{
	template <class _UInt, _UInt _R0, size_t _Wp, size_t _Mp>
	class __get_n
	{
	static _LIBCPP_CONSTEXPR const size_t _Dt = numeric_limits<_UInt>::digits;
	static _LIBCPP_CONSTEXPR const size_t _Np = _Wp / _Mp + (_Wp % _Mp != 0);
	static _LIBCPP_CONSTEXPR const size_t _W0 = _Wp / _Np;
	static _LIBCPP_CONSTEXPR const _UInt _Y0 = _W0 >= _Dt ? 0 : (_R0 >> _W0) << _W0;
	public:
	static _LIBCPP_CONSTEXPR const size_t value = _R0 - _Y0 > _Y0 / _Np ? _Np + 1 : _Np;
	};
	public:
	// types
	typedef _UIntType result_type;

	private:
	_Engine __e_;

	static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
	static_assert( 0 < __w, "independent_bits_engine invalid parameters");
	static_assert(__w <= _Dt, "independent_bits_engine invalid parameters");

	typedef typename _Engine::result_type _Engine_result_type;
	typedef typename conditional
	<
	sizeof(_Engine_result_type) <= sizeof(result_type),
	result_type,
	_Engine_result_type
	>::type _Working_result_type;
	#ifdef _LIBCPP_CXX03_LANG
	static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min
	+ _Working_result_type(1);
	#else
	static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min()
	+ _Working_result_type(1);
	#endif
	static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value;
	static _LIBCPP_CONSTEXPR const size_t __n = __get_n<_Working_result_type, _Rp, __w, __m>::value;
	static _LIBCPP_CONSTEXPR const size_t __w0 = __w / __n;
	static _LIBCPP_CONSTEXPR const size_t __n0 = __n - __w % __n;
	static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits;
	static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits;
	static _LIBCPP_CONSTEXPR const _Working_result_type __y0 = __w0 >= _WDt ? 0 :
	(_Rp >> __w0) << __w0;
	static _LIBCPP_CONSTEXPR const _Working_result_type __y1 = __w0 >= _WDt - 1 ? 0 :
	(_Rp >> (__w0+1)) << (__w0+1);
	static _LIBCPP_CONSTEXPR const _Engine_result_type __mask0 = __w0 > 0 ?
	_Engine_result_type(~0) >> (_EDt - __w0) :
	_Engine_result_type(0);
	static _LIBCPP_CONSTEXPR const _Engine_result_type __mask1 = __w0 < _EDt - 1 ?
	_Engine_result_type(~0) >> (_EDt - (__w0 + 1)) :
	_Engine_result_type(~0);
	public:
	static _LIBCPP_CONSTEXPR const result_type _Min = 0;
	static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
	(result_type(1) << __w) - result_type(1);
	static_assert(_Min < _Max, "independent_bits_engine invalid parameters");

	// engine characteristics
	_LIBCPP_INLINE_VISIBILITY
	static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
	_LIBCPP_INLINE_VISIBILITY
	static _LIBCPP_CONSTEXPR result_type max() { return _Max; }

	// constructors and seeding functions
	_LIBCPP_INLINE_VISIBILITY
	independent_bits_engine() {}
	_LIBCPP_INLINE_VISIBILITY
	explicit independent_bits_engine(const _Engine& __e)
	: __e_(__e) {}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	explicit independent_bits_engine(_Engine&& __e)
	: __e_(_VSTD::move(__e)) {}
	#endif // _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	explicit independent_bits_engine(result_type __sd) : __e_(__sd) {}
	template<class _Sseq>
	_LIBCPP_INLINE_VISIBILITY
	explicit independent_bits_engine(_Sseq& __q,
	typename enable_if<__is_seed_sequence<_Sseq, independent_bits_engine>::value &&
	!is_convertible<_Sseq, _Engine>::value>::type* = 0)
	: __e_(__q) {}
	_LIBCPP_INLINE_VISIBILITY
	void seed() {__e_.seed();}
	_LIBCPP_INLINE_VISIBILITY
	void seed(result_type __sd) {__e_.seed(__sd);}
	template<class _Sseq>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_seed_sequence<_Sseq, independent_bits_engine>::value,
	void
	>::type
	seed(_Sseq& __q) {__e_.seed(__q);}

	// generating functions
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
	_LIBCPP_INLINE_VISIBILITY
	void discard(unsigned long long __z) {for (; __z; --__z) operator()();}

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	const _Engine& base() const _NOEXCEPT {return __e_;}

	template<class _Eng, size_t _Wp, class _UInt>
	friend
	bool
	operator==(
	const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
	const independent_bits_engine<_Eng, _Wp, _UInt>& __y);

	template<class _Eng, size_t _Wp, class _UInt>
	friend
	bool
	operator!=(
	const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
	const independent_bits_engine<_Eng, _Wp, _UInt>& __y);

	template <class _CharT, class _Traits,
	class _Eng, size_t _Wp, class _UInt>
	friend
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const independent_bits_engine<_Eng, _Wp, _UInt>& __x);

	template <class _CharT, class _Traits,
	class _Eng, size_t _Wp, class _UInt>
	friend
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	independent_bits_engine<_Eng, _Wp, _UInt>& __x);

	private:
	_LIBCPP_INLINE_VISIBILITY
	result_type __eval(false_type);
	result_type __eval(true_type);

	template <size_t __count>
	_LIBCPP_INLINE_VISIBILITY
	static
	typename enable_if
	<
	__count < _Dt,
	result_type
	>::type
	__lshift(result_type __x) {return __x << __count;}

	template <size_t __count>
	_LIBCPP_INLINE_VISIBILITY
	static
	typename enable_if
	<
	(__count >= _Dt),
	result_type
	>::type
	__lshift(result_type) {return result_type(0);}
	};

	template<class _Engine, size_t __w, class _UIntType>
	inline
	_UIntType
	independent_bits_engine<_Engine, __w, _UIntType>::__eval(false_type)
	{
	return static_cast<result_type>(__e_() & __mask0);
	}

	template<class _Engine, size_t __w, class _UIntType>
	_UIntType
	independent_bits_engine<_Engine, __w, _UIntType>::__eval(true_type)
	{
	result_type _Sp = 0;
	for (size_t __k = 0; __k < __n0; ++__k)
	{
	_Engine_result_type __u;
	do
	{
	__u = __e_() - _Engine::min();
	} while (__u >= __y0);
	_Sp = static_cast<result_type>(__lshift<__w0>(_Sp) + (__u & __mask0));
	}
	for (size_t __k = __n0; __k < __n; ++__k)
	{
	_Engine_result_type __u;
	do
	{
	__u = __e_() - _Engine::min();
	} while (__u >= __y1);
	_Sp = static_cast<result_type>(__lshift<__w0+1>(_Sp) + (__u & __mask1));
	}
	return _Sp;
	}

	template<class _Eng, size_t _Wp, class _UInt>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(
	const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
	const independent_bits_engine<_Eng, _Wp, _UInt>& __y)
	{
	return __x.base() == __y.base();
	}

	template<class _Eng, size_t _Wp, class _UInt>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(
	const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
	const independent_bits_engine<_Eng, _Wp, _UInt>& __y)
	{
	return !(__x == __y);
	}

	template <class _CharT, class _Traits,
	class _Eng, size_t _Wp, class _UInt>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const independent_bits_engine<_Eng, _Wp, _UInt>& __x)
	{
	return __os << __x.base();
	}

	template <class _CharT, class _Traits,
	class _Eng, size_t _Wp, class _UInt>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	independent_bits_engine<_Eng, _Wp, _UInt>& __x)
	{
	_Eng __e;
	__is >> __e;
	if (!__is.fail())
	__x.__e_ = __e;
	return __is;
	}

	// shuffle_order_engine

	template <uint64_t _Xp, uint64_t _Yp>
	struct __ugcd
	{
	static _LIBCPP_CONSTEXPR const uint64_t value = __ugcd<_Yp, _Xp % _Yp>::value;
	};

	template <uint64_t _Xp>
	struct __ugcd<_Xp, 0>
	{
	static _LIBCPP_CONSTEXPR const uint64_t value = _Xp;
	};

	template <uint64_t _Np, uint64_t _Dp>
	class __uratio
	{
	static_assert(_Dp != 0, "__uratio divide by 0");
	static _LIBCPP_CONSTEXPR const uint64_t __gcd = __ugcd<_Np, _Dp>::value;
	public:
	static _LIBCPP_CONSTEXPR const uint64_t num = _Np / __gcd;
	static _LIBCPP_CONSTEXPR const uint64_t den = _Dp / __gcd;

	typedef __uratio<num, den> type;
	};

	template<class _Engine, size_t __k>
	class _LIBCPP_TEMPLATE_VIS shuffle_order_engine
	{
	static_assert(0 < __k, "shuffle_order_engine invalid parameters");
	public:
	// types
	typedef typename _Engine::result_type result_type;

	private:
	_Engine __e_;
	result_type _V_[__k];
	result_type _Y_;

	public:
	// engine characteristics
	static _LIBCPP_CONSTEXPR const size_t table_size = __k;

	#ifdef _LIBCPP_CXX03_LANG
	static const result_type _Min = _Engine::_Min;
	static const result_type _Max = _Engine::_Max;
	#else
	static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
	static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
	#endif
	static_assert(_Min < _Max, "shuffle_order_engine invalid parameters");
	_LIBCPP_INLINE_VISIBILITY
	static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
	_LIBCPP_INLINE_VISIBILITY
	static _LIBCPP_CONSTEXPR result_type max() { return _Max; }

	static _LIBCPP_CONSTEXPR const unsigned long long _Rp = _Max - _Min + 1ull;

	// constructors and seeding functions
	_LIBCPP_INLINE_VISIBILITY
	shuffle_order_engine() {__init();}
	_LIBCPP_INLINE_VISIBILITY
	explicit shuffle_order_engine(const _Engine& __e)
	: __e_(__e) {__init();}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	explicit shuffle_order_engine(_Engine&& __e)
	: __e_(_VSTD::move(__e)) {__init();}
	#endif // _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();}
	template<class _Sseq>
	_LIBCPP_INLINE_VISIBILITY
	explicit shuffle_order_engine(_Sseq& __q,
	typename enable_if<__is_seed_sequence<_Sseq, shuffle_order_engine>::value &&
	!is_convertible<_Sseq, _Engine>::value>::type* = 0)
	: __e_(__q) {__init();}
	_LIBCPP_INLINE_VISIBILITY
	void seed() {__e_.seed(); __init();}
	_LIBCPP_INLINE_VISIBILITY
	void seed(result_type __sd) {__e_.seed(__sd); __init();}
	template<class _Sseq>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_seed_sequence<_Sseq, shuffle_order_engine>::value,
	void
	>::type
	seed(_Sseq& __q) {__e_.seed(__q); __init();}

	// generating functions
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
	_LIBCPP_INLINE_VISIBILITY
	void discard(unsigned long long __z) {for (; __z; --__z) operator()();}

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	const _Engine& base() const _NOEXCEPT {return __e_;}

	private:
	template<class _Eng, size_t _Kp>
	friend
	bool
	operator==(
	const shuffle_order_engine<_Eng, _Kp>& __x,
	const shuffle_order_engine<_Eng, _Kp>& __y);

	template<class _Eng, size_t _Kp>
	friend
	bool
	operator!=(
	const shuffle_order_engine<_Eng, _Kp>& __x,
	const shuffle_order_engine<_Eng, _Kp>& __y);

	template <class _CharT, class _Traits,
	class _Eng, size_t _Kp>
	friend
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const shuffle_order_engine<_Eng, _Kp>& __x);

	template <class _CharT, class _Traits,
	class _Eng, size_t _Kp>
	friend
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	shuffle_order_engine<_Eng, _Kp>& __x);

	_LIBCPP_INLINE_VISIBILITY
	void __init()
	{
	for (size_t __i = 0; __i < __k; ++__i)
	_V_[__i] = __e_();
	_Y_ = __e_();
	}

	_LIBCPP_INLINE_VISIBILITY
	result_type __eval(false_type) {return __eval2(integral_constant<bool, __k & 1>());}
	_LIBCPP_INLINE_VISIBILITY
	result_type __eval(true_type) {return __eval(__uratio<__k, _Rp>());}

	_LIBCPP_INLINE_VISIBILITY
	result_type __eval2(false_type) {return __eval(__uratio<__k/2, 0x8000000000000000ull>());}
	_LIBCPP_INLINE_VISIBILITY
	result_type __eval2(true_type) {return __evalf<__k, 0>();}

	template <uint64_t _Np, uint64_t _Dp>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	(__uratio<_Np, _Dp>::num > 0xFFFFFFFFFFFFFFFFull / (_Max - _Min)),
	result_type
	>::type
	__eval(__uratio<_Np, _Dp>)
	{return __evalf<__uratio<_Np, _Dp>::num, __uratio<_Np, _Dp>::den>();}

	template <uint64_t _Np, uint64_t _Dp>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__uratio<_Np, _Dp>::num <= 0xFFFFFFFFFFFFFFFFull / (_Max - _Min),
	result_type
	>::type
	__eval(__uratio<_Np, _Dp>)
	{
	const size_t __j = static_cast<size_t>(__uratio<_Np, _Dp>::num * (_Y_ - _Min)
	/ __uratio<_Np, _Dp>::den);
	_Y_ = _V_[__j];
	_V_[__j] = __e_();
	return _Y_;
	}

	template <uint64_t __n, uint64_t __d>
	_LIBCPP_INLINE_VISIBILITY
	result_type __evalf()
	{
	const double _Fp = __d == 0 ?
	__n / (2. * 0x8000000000000000ull) :
	__n / (double)__d;
	const size_t __j = static_cast<size_t>(_Fp * (_Y_ - _Min));
	_Y_ = _V_[__j];
	_V_[__j] = __e_();
	return _Y_;
	}
	};

	template<class _Engine, size_t __k>
	_LIBCPP_CONSTEXPR const size_t shuffle_order_engine<_Engine, __k>::table_size;

	template<class _Eng, size_t _Kp>
	bool
	operator==(
	const shuffle_order_engine<_Eng, _Kp>& __x,
	const shuffle_order_engine<_Eng, _Kp>& __y)
	{
	return __x._Y_ == __y._Y_ && _VSTD::equal(__x._V_, __x._V_ + _Kp, __y._V_) &&
	__x.__e_ == __y.__e_;
	}

	template<class _Eng, size_t _Kp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(
	const shuffle_order_engine<_Eng, _Kp>& __x,
	const shuffle_order_engine<_Eng, _Kp>& __y)
	{
	return !(__x == __y);
	}

	template <class _CharT, class _Traits,
	class _Eng, size_t _Kp>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const shuffle_order_engine<_Eng, _Kp>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	__os << __x.__e_ << __sp << __x._V_[0];
	for (size_t __i = 1; __i < _Kp; ++__i)
	__os << __sp << __x._V_[__i];
	return __os << __sp << __x._Y_;
	}

	template <class _CharT, class _Traits,
	class _Eng, size_t _Kp>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	shuffle_order_engine<_Eng, _Kp>& __x)
	{
	typedef typename shuffle_order_engine<_Eng, _Kp>::result_type result_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	_Eng __e;
	result_type _Vp[_Kp+1];
	__is >> __e;
	for (size_t __i = 0; __i < _Kp+1; ++__i)
	__is >> _Vp[__i];
	if (!__is.fail())
	{
	__x.__e_ = __e;
	for (size_t __i = 0; __i < _Kp; ++__i)
	__x._V_[__i] = _Vp[__i];
	__x._Y_ = _Vp[_Kp];
	}
	return __is;
	}

	typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;

	// random_device

	class _LIBCPP_TYPE_VIS random_device
	{
	#ifdef _LIBCPP_USING_DEV_RANDOM
	int __f_;
	#endif // defined(_LIBCPP_USING_DEV_RANDOM)
	public:
	// types
	typedef unsigned result_type;

	// generator characteristics
	static _LIBCPP_CONSTEXPR const result_type _Min = 0;
	static _LIBCPP_CONSTEXPR const result_type _Max = 0xFFFFFFFFu;

	_LIBCPP_INLINE_VISIBILITY
	static _LIBCPP_CONSTEXPR result_type min() { return _Min;}
	_LIBCPP_INLINE_VISIBILITY
	static _LIBCPP_CONSTEXPR result_type max() { return _Max;}

	// constructors
	explicit random_device(const string& __token = "/dev/urandom");
	~random_device();

	// generating functions
	result_type operator()();

	// property functions
	double entropy() const _NOEXCEPT;

	private:
	// no copy functions
	random_device(const random_device&); // = delete;
	random_device& operator=(const random_device&); // = delete;
	};

	// seed_seq

	class _LIBCPP_TEMPLATE_VIS seed_seq
	{
	public:
	// types
	typedef uint32_t result_type;

	private:
	vector<result_type> __v_;

	template<class _InputIterator>
	void init(_InputIterator __first, _InputIterator __last);
	public:
	// constructors
	_LIBCPP_INLINE_VISIBILITY
	seed_seq() _NOEXCEPT {}
	#ifndef _LIBCPP_CXX03_LANG
	template<class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	seed_seq(initializer_list<_Tp> __il) {init(__il.begin(), __il.end());}
	#endif // _LIBCPP_CXX03_LANG

	template<class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	seed_seq(_InputIterator __first, _InputIterator __last)
	{init(__first, __last);}

	// generating functions
	template<class _RandomAccessIterator>
	void generate(_RandomAccessIterator __first, _RandomAccessIterator __last);

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	size_t size() const _NOEXCEPT {return __v_.size();}
	template<class _OutputIterator>
	_LIBCPP_INLINE_VISIBILITY
	void param(_OutputIterator __dest) const
	{_VSTD::copy(__v_.begin(), __v_.end(), __dest);}

	private:
	// no copy functions
	seed_seq(const seed_seq&); // = delete;
	void operator=(const seed_seq&); // = delete;

	_LIBCPP_INLINE_VISIBILITY
	static result_type _Tp(result_type __x) {return __x ^ (__x >> 27);}
	};

	template<class _InputIterator>
	void
	seed_seq::init(_InputIterator __first, _InputIterator __last)
	{
	for (_InputIterator __s = __first; __s != __last; ++__s)
	__v_.push_back(*__s & 0xFFFFFFFF);
	}

	template<class _RandomAccessIterator>
	void
	seed_seq::generate(_RandomAccessIterator __first, _RandomAccessIterator __last)
	{
	if (__first != __last)
	{
	_VSTD::fill(__first, __last, 0x8b8b8b8b);
	const size_t __n = static_cast<size_t>(__last - __first);
	const size_t __s = __v_.size();
	const size_t __t = (__n >= 623) ? 11
	: (__n >= 68) ? 7
	: (__n >= 39) ? 5
	: (__n >= 7) ? 3
	: (__n - 1) / 2;
	const size_t __p = (__n - __t) / 2;
	const size_t __q = __p + __t;
	const size_t __m = _VSTD::max(__s + 1, __n);
	// __k = 0;
	{
	result_type __r = 1664525 * _Tp(__first[0] ^ __first[__p]
	^ __first[__n - 1]);
	__first[__p] += __r;
	__r += __s;
	__first[__q] += __r;
	__first[0] = __r;
	}
	for (size_t __k = 1; __k <= __s; ++__k)
	{
	const size_t __kmodn = __k % __n;
	const size_t __kpmodn = (__k + __p) % __n;
	result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn]
	^ __first[(__k - 1) % __n]);
	__first[__kpmodn] += __r;
	__r += __kmodn + __v_[__k-1];
	__first[(__k + __q) % __n] += __r;
	__first[__kmodn] = __r;
	}
	for (size_t __k = __s + 1; __k < __m; ++__k)
	{
	const size_t __kmodn = __k % __n;
	const size_t __kpmodn = (__k + __p) % __n;
	result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn]
	^ __first[(__k - 1) % __n]);
	__first[__kpmodn] += __r;
	__r += __kmodn;
	__first[(__k + __q) % __n] += __r;
	__first[__kmodn] = __r;
	}
	for (size_t __k = __m; __k < __m + __n; ++__k)
	{
	const size_t __kmodn = __k % __n;
	const size_t __kpmodn = (__k + __p) % __n;
	result_type __r = 1566083941 * _Tp(__first[__kmodn] +
	__first[__kpmodn] +
	__first[(__k - 1) % __n]);
	__first[__kpmodn] ^= __r;
	__r -= __kmodn;
	__first[(__k + __q) % __n] ^= __r;
	__first[__kmodn] = __r;
	}
	}
	}

	// generate_canonical

	template<class _RealType, size_t __bits, class _URNG>
	_RealType
	generate_canonical(_URNG& __g)
	{
	const size_t _Dt = numeric_limits<_RealType>::digits;
	const size_t __b = _Dt < __bits ? _Dt : __bits;
	#ifdef _LIBCPP_CXX03_LANG
	const size_t __logR = __log2<uint64_t, _URNG::_Max - _URNG::_Min + uint64_t(1)>::value;
	#else
	const size_t __logR = __log2<uint64_t, _URNG::max() - _URNG::min() + uint64_t(1)>::value;
	#endif
	const size_t __k = __b / __logR + (__b % __logR != 0) + (__b == 0);
	const _RealType _Rp = _URNG::max() - _URNG::min() + _RealType(1);
	_RealType __base = _Rp;
	_RealType _Sp = __g() - _URNG::min();
	for (size_t __i = 1; __i < __k; ++__i, __base *= _Rp)
	_Sp += (__g() - _URNG::min()) * __base;
	return _Sp / __base;
	}

	// uniform_int_distribution

	// in <algorithm>

	template <class _CharT, class _Traits, class _IT>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const uniform_int_distribution<_IT>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	return __os << __x.a() << __sp << __x.b();
	}

	template <class _CharT, class _Traits, class _IT>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	uniform_int_distribution<_IT>& __x)
	{
	typedef uniform_int_distribution<_IT> _Eng;
	typedef typename _Eng::result_type result_type;
	typedef typename _Eng::param_type param_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	result_type __a;
	result_type __b;
	__is >> __a >> __b;
	if (!__is.fail())
	__x.param(param_type(__a, __b));
	return __is;
	}

	// uniform_real_distribution

	template<class _RealType = double>
	class _LIBCPP_TEMPLATE_VIS uniform_real_distribution
	{
	public:
	// types
	typedef _RealType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	result_type __a_;
	result_type __b_;
	public:
	typedef uniform_real_distribution distribution_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit param_type(result_type __a = 0,
	result_type __b = 1)
	: __a_(__a), __b_(__b) {}

	_LIBCPP_INLINE_VISIBILITY
	result_type a() const {return __a_;}
	_LIBCPP_INLINE_VISIBILITY
	result_type b() const {return __b_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}
	};

	private:
	param_type __p_;

	public:
	// constructors and reset functions
	_LIBCPP_INLINE_VISIBILITY
	explicit uniform_real_distribution(result_type __a = 0, result_type __b = 1)
	: __p_(param_type(__a, __b)) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit uniform_real_distribution(const param_type& __p) : __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	result_type a() const {return __p_.a();}
	_LIBCPP_INLINE_VISIBILITY
	result_type b() const {return __p_.b();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return a();}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return b();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const uniform_real_distribution& __x,
	const uniform_real_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const uniform_real_distribution& __x,
	const uniform_real_distribution& __y)
	{return !(__x == __y);}
	};

	template<class _RealType>
	template<class _URNG>
	inline
	typename uniform_real_distribution<_RealType>::result_type
	uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
	{
	return (__p.b() - __p.a())
	* _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
	+ __p.a();
	}

	template <class _CharT, class _Traits, class _RT>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const uniform_real_distribution<_RT>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	return __os << __x.a() << __sp << __x.b();
	}

	template <class _CharT, class _Traits, class _RT>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	uniform_real_distribution<_RT>& __x)
	{
	typedef uniform_real_distribution<_RT> _Eng;
	typedef typename _Eng::result_type result_type;
	typedef typename _Eng::param_type param_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	result_type __a;
	result_type __b;
	__is >> __a >> __b;
	if (!__is.fail())
	__x.param(param_type(__a, __b));
	return __is;
	}

	// bernoulli_distribution

	class _LIBCPP_TEMPLATE_VIS bernoulli_distribution
	{
	public:
	// types
	typedef bool result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	double __p_;
	public:
	typedef bernoulli_distribution distribution_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit param_type(double __p = 0.5) : __p_(__p) {}

	_LIBCPP_INLINE_VISIBILITY
	double p() const {return __p_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}
	};

	private:
	param_type __p_;

	public:
	// constructors and reset functions
	_LIBCPP_INLINE_VISIBILITY
	explicit bernoulli_distribution(double __p = 0.5)
	: __p_(param_type(__p)) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit bernoulli_distribution(const param_type& __p) : __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	double p() const {return __p_.p();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return false;}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return true;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const bernoulli_distribution& __x,
	const bernoulli_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const bernoulli_distribution& __x,
	const bernoulli_distribution& __y)
	{return !(__x == __y);}
	};

	template<class _URNG>
	inline
	bernoulli_distribution::result_type
	bernoulli_distribution::operator()(_URNG& __g, const param_type& __p)
	{
	uniform_real_distribution<double> __gen;
	return __gen(__g) < __p.p();
	}

	template <class _CharT, class _Traits>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os, const bernoulli_distribution& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	return __os << __x.p();
	}

	template <class _CharT, class _Traits>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is, bernoulli_distribution& __x)
	{
	typedef bernoulli_distribution _Eng;
	typedef typename _Eng::param_type param_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	double __p;
	__is >> __p;
	if (!__is.fail())
	__x.param(param_type(__p));
	return __is;
	}

	// binomial_distribution

	template<class _IntType = int>
	class _LIBCPP_TEMPLATE_VIS binomial_distribution
	{
	public:
	// types
	typedef _IntType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	result_type __t_;
	double __p_;
	double __pr_;
	double __odds_ratio_;
	result_type __r0_;
	public:
	typedef binomial_distribution distribution_type;

	explicit param_type(result_type __t = 1, double __p = 0.5);

	_LIBCPP_INLINE_VISIBILITY
	result_type t() const {return __t_;}
	_LIBCPP_INLINE_VISIBILITY
	double p() const {return __p_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__t_ == __y.__t_ && __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}

	friend class binomial_distribution;
	};

	private:
	param_type __p_;

	public:
	// constructors and reset functions
	_LIBCPP_INLINE_VISIBILITY
	explicit binomial_distribution(result_type __t = 1, double __p = 0.5)
	: __p_(param_type(__t, __p)) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit binomial_distribution(const param_type& __p) : __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	result_type t() const {return __p_.t();}
	_LIBCPP_INLINE_VISIBILITY
	double p() const {return __p_.p();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return 0;}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return t();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const binomial_distribution& __x,
	const binomial_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const binomial_distribution& __x,
	const binomial_distribution& __y)
	{return !(__x == __y);}
	};

	#ifndef _LIBCPP_MSVCRT
	extern "C" double lgamma_r(double, int *);
	#endif

	inline _LIBCPP_INLINE_VISIBILITY double __libcpp_lgamma(double __d) {
	#if defined(_LIBCPP_MSVCRT)
	return lgamma(__d);
	#else
	int __sign;
	return lgamma_r(__d, &__sign);
	#endif
	}

	template<class _IntType>
	binomial_distribution<_IntType>::param_type::param_type(const result_type __t, const double __p)
	: __t_(__t), __p_(__p)
	{
	if (0 < __p_ && __p_ < 1)
	{
	__r0_ = static_cast<result_type>((__t_ + 1) * __p_);
	__pr_ = _VSTD::exp(__libcpp_lgamma(__t_ + 1.) -
	__libcpp_lgamma(__r0_ + 1.) -
	__libcpp_lgamma(__t_ - __r0_ + 1.) + __r0_ * _VSTD::log(__p_) +
	(__t_ - __r0_) * _VSTD::log(1 - __p_));
	__odds_ratio_ = __p_ / (1 - __p_);
	}
	}

	// Reference: Kemp, C.D. (1986). `A modal method for generating binomial
	// variables', Commun. Statist. - Theor. Meth. 15(3), 805-813.
	template<class _IntType>
	template<class _URNG>
	_IntType
	binomial_distribution<_IntType>::operator()(_URNG& __g, const param_type& __pr)
	{
	if (__pr.__t_ == 0 \|\| __pr.__p_ == 0)
	return 0;
	if (__pr.__p_ == 1)
	return __pr.__t_;
	uniform_real_distribution<double> __gen;
	double __u = __gen(__g) - __pr.__pr_;
	if (__u < 0)
	return __pr.__r0_;
	double __pu = __pr.__pr_;
	double __pd = __pu;
	result_type __ru = __pr.__r0_;
	result_type __rd = __ru;
	while (true)
	{
	if (__rd >= 1)
	{
	__pd = __rd / (__pr.__odds_ratio_ (__pr.__t_ - __rd + 1));
	__u -= __pd;
	if (__u < 0)
	return __rd - 1;
	}
	if ( __rd != 0 )
	--__rd;
	++__ru;
	if (__ru <= __pr.__t_)
	{
	__pu = (__pr.__t_ - __ru + 1) __pr.__odds_ratio_ / __ru;
	__u -= __pu;
	if (__u < 0)
	return __ru;
	}
	}
	}

	template <class _CharT, class _Traits, class _IntType>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const binomial_distribution<_IntType>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	return __os << __x.t() << __sp << __x.p();
	}

	template <class _CharT, class _Traits, class _IntType>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	binomial_distribution<_IntType>& __x)
	{
	typedef binomial_distribution<_IntType> _Eng;
	typedef typename _Eng::result_type result_type;
	typedef typename _Eng::param_type param_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	result_type __t;
	double __p;
	__is >> __t >> __p;
	if (!__is.fail())
	__x.param(param_type(__t, __p));
	return __is;
	}

	// exponential_distribution

	template<class _RealType = double>
	class _LIBCPP_TEMPLATE_VIS exponential_distribution
	{
	public:
	// types
	typedef _RealType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	result_type __lambda_;
	public:
	typedef exponential_distribution distribution_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit param_type(result_type __lambda = 1) : __lambda_(__lambda) {}

	_LIBCPP_INLINE_VISIBILITY
	result_type lambda() const {return __lambda_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__lambda_ == __y.__lambda_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}
	};

	private:
	param_type __p_;

	public:
	// constructors and reset functions
	_LIBCPP_INLINE_VISIBILITY
	explicit exponential_distribution(result_type __lambda = 1)
	: __p_(param_type(__lambda)) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit exponential_distribution(const param_type& __p) : __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	result_type lambda() const {return __p_.lambda();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return 0;}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return numeric_limits<result_type>::infinity();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const exponential_distribution& __x,
	const exponential_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const exponential_distribution& __x,
	const exponential_distribution& __y)
	{return !(__x == __y);}
	};

	template <class _RealType>
	template<class _URNG>
	_RealType
	exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
	{
	return -_VSTD::log
	(
	result_type(1) -
	_VSTD::generate_canonical<result_type,
	numeric_limits<result_type>::digits>(__g)
	)
	/ __p.lambda();
	}

	template <class _CharT, class _Traits, class _RealType>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const exponential_distribution<_RealType>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	return __os << __x.lambda();
	}

	template <class _CharT, class _Traits, class _RealType>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	exponential_distribution<_RealType>& __x)
	{
	typedef exponential_distribution<_RealType> _Eng;
	typedef typename _Eng::result_type result_type;
	typedef typename _Eng::param_type param_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	result_type __lambda;
	__is >> __lambda;
	if (!__is.fail())
	__x.param(param_type(__lambda));
	return __is;
	}

	// normal_distribution

	template<class _RealType = double>
	class _LIBCPP_TEMPLATE_VIS normal_distribution
	{
	public:
	// types
	typedef _RealType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	result_type __mean_;
	result_type __stddev_;
	public:
	typedef normal_distribution distribution_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit param_type(result_type __mean = 0, result_type __stddev = 1)
	: __mean_(__mean), __stddev_(__stddev) {}

	_LIBCPP_INLINE_VISIBILITY
	result_type mean() const {return __mean_;}
	_LIBCPP_INLINE_VISIBILITY
	result_type stddev() const {return __stddev_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__mean_ == __y.__mean_ && __x.__stddev_ == __y.__stddev_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}
	};

	private:
	param_type __p_;
	result_type _V_;
	bool _V_hot_;

	public:
	// constructors and reset functions
	_LIBCPP_INLINE_VISIBILITY
	explicit normal_distribution(result_type __mean = 0, result_type __stddev = 1)
	: __p_(param_type(__mean, __stddev)), _V_hot_(false) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit normal_distribution(const param_type& __p)
	: __p_(__p), _V_hot_(false) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {_V_hot_ = false;}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	result_type mean() const {return __p_.mean();}
	_LIBCPP_INLINE_VISIBILITY
	result_type stddev() const {return __p_.stddev();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return -numeric_limits<result_type>::infinity();}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return numeric_limits<result_type>::infinity();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const normal_distribution& __x,
	const normal_distribution& __y)
	{return __x.__p_ == __y.__p_ && __x._V_hot_ == __y._V_hot_ &&
	(!__x._V_hot_ \|\| __x._V_ == __y._V_);}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const normal_distribution& __x,
	const normal_distribution& __y)
	{return !(__x == __y);}

	template <class _CharT, class _Traits, class _RT>
	friend
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const normal_distribution<_RT>& __x);

	template <class _CharT, class _Traits, class _RT>
	friend
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	normal_distribution<_RT>& __x);
	};

	template <class _RealType>
	template<class _URNG>
	_RealType
	normal_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
	{
	result_type _Up;
	if (_V_hot_)
	{
	_V_hot_ = false;
	_Up = _V_;
	}
	else
	{
	uniform_real_distribution<result_type> _Uni(-1, 1);
	result_type __u;
	result_type __v;
	result_type __s;
	do
	{
	__u = _Uni(__g);
	__v = _Uni(__g);
	__s = __u * __u + __v * __v;
	} while (__s > 1 \|\| __s == 0);
	result_type _Fp = _VSTD::sqrt(-2 * _VSTD::log(__s) / __s);
	_V_ = __v * _Fp;
	_V_hot_ = true;
	_Up = __u * _Fp;
	}
	return _Up * __p.stddev() + __p.mean();
	}

	template <class _CharT, class _Traits, class _RT>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const normal_distribution<_RT>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	__os << __x.mean() << __sp << __x.stddev() << __sp << __x._V_hot_;
	if (__x._V_hot_)
	__os << __sp << __x._V_;
	return __os;
	}

	template <class _CharT, class _Traits, class _RT>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	normal_distribution<_RT>& __x)
	{
	typedef normal_distribution<_RT> _Eng;
	typedef typename _Eng::result_type result_type;
	typedef typename _Eng::param_type param_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	result_type __mean;
	result_type __stddev;
	result_type _Vp = 0;
	bool _V_hot = false;
	__is >> __mean >> __stddev >> _V_hot;
	if (_V_hot)
	__is >> _Vp;
	if (!__is.fail())
	{
	__x.param(param_type(__mean, __stddev));
	__x._V_hot_ = _V_hot;
	__x._V_ = _Vp;
	}
	return __is;
	}

	// lognormal_distribution

	template<class _RealType = double>
	class _LIBCPP_TEMPLATE_VIS lognormal_distribution
	{
	public:
	// types
	typedef _RealType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	normal_distribution<result_type> __nd_;
	public:
	typedef lognormal_distribution distribution_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit param_type(result_type __m = 0, result_type __s = 1)
	: __nd_(__m, __s) {}

	_LIBCPP_INLINE_VISIBILITY
	result_type m() const {return __nd_.mean();}
	_LIBCPP_INLINE_VISIBILITY
	result_type s() const {return __nd_.stddev();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__nd_ == __y.__nd_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}
	friend class lognormal_distribution;

	template <class _CharT, class _Traits, class _RT>
	friend
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const lognormal_distribution<_RT>& __x);

	template <class _CharT, class _Traits, class _RT>
	friend
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	lognormal_distribution<_RT>& __x);
	};

	private:
	param_type __p_;

	public:
	// constructor and reset functions
	_LIBCPP_INLINE_VISIBILITY
	explicit lognormal_distribution(result_type __m = 0, result_type __s = 1)
	: __p_(param_type(__m, __s)) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit lognormal_distribution(const param_type& __p)
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {__p_.__nd_.reset();}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g, const param_type& __p)
	{return _VSTD::exp(const_cast<normal_distribution<result_type>&>(__p.__nd_)(__g));}

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	result_type m() const {return __p_.m();}
	_LIBCPP_INLINE_VISIBILITY
	result_type s() const {return __p_.s();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return 0;}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return numeric_limits<result_type>::infinity();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const lognormal_distribution& __x,
	const lognormal_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const lognormal_distribution& __x,
	const lognormal_distribution& __y)
	{return !(__x == __y);}

	template <class _CharT, class _Traits, class _RT>
	friend
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const lognormal_distribution<_RT>& __x);

	template <class _CharT, class _Traits, class _RT>
	friend
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	lognormal_distribution<_RT>& __x);
	};

	template <class _CharT, class _Traits, class _RT>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const lognormal_distribution<_RT>& __x)
	{
	return __os << __x.__p_.__nd_;
	}

	template <class _CharT, class _Traits, class _RT>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	lognormal_distribution<_RT>& __x)
	{
	return __is >> __x.__p_.__nd_;
	}

	// poisson_distribution

	template<class _IntType = int>
	class _LIBCPP_TEMPLATE_VIS poisson_distribution
	{
	public:
	// types
	typedef _IntType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	double __mean_;
	double __s_;
	double __d_;
	double __l_;
	double __omega_;
	double __c0_;
	double __c1_;
	double __c2_;
	double __c3_;
	double __c_;

	public:
	typedef poisson_distribution distribution_type;

	explicit param_type(double __mean = 1.0);

	_LIBCPP_INLINE_VISIBILITY
	double mean() const {return __mean_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__mean_ == __y.__mean_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}

	friend class poisson_distribution;
	};

	private:
	param_type __p_;

	public:
	// constructors and reset functions
	_LIBCPP_INLINE_VISIBILITY
	explicit poisson_distribution(double __mean = 1.0) : __p_(__mean) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit poisson_distribution(const param_type& __p) : __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	double mean() const {return __p_.mean();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return 0;}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return numeric_limits<result_type>::max();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const poisson_distribution& __x,
	const poisson_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const poisson_distribution& __x,
	const poisson_distribution& __y)
	{return !(__x == __y);}
	};

	template<class _IntType>
	poisson_distribution<_IntType>::param_type::param_type(double __mean)
	: __mean_(__mean)
	{
	if (__mean_ < 10)
	{
	__s_ = 0;
	__d_ = 0;
	__l_ = _VSTD::exp(-__mean_);
	__omega_ = 0;
	__c3_ = 0;
	__c2_ = 0;
	__c1_ = 0;
	__c0_ = 0;
	__c_ = 0;
	}
	else
	{
	__s_ = _VSTD::sqrt(__mean_);
	__d_ = 6 * __mean_ * __mean_;
	__l_ = static_cast<result_type>(__mean_ - 1.1484);
	__omega_ = .3989423 / __s_;
	double __b1_ = .4166667E-1 / __mean_;
	double __b2_ = .3 * __b1_ * __b1_;
	__c3_ = .1428571 * __b1_ * __b2_;
	__c2_ = __b2_ - 15. * __c3_;
	__c1_ = __b1_ - 6. * __b2_ + 45. * __c3_;
	__c0_ = 1. - __b1_ + 3. * __b2_ - 15. * __c3_;
	__c_ = .1069 / __mean_;
	}
	}

	template <class _IntType>
	template<class _URNG>
	_IntType
	poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
	{
	result_type __x;
	uniform_real_distribution<double> __urd;
	if (__pr.__mean_ < 10)
	{
	__x = 0;
	for (double __p = __urd(__urng); __p > __pr.__l_; ++__x)
	__p *= __urd(__urng);
	}
	else
	{
	double __difmuk;
	double __g = __pr.__mean_ + __pr.__s_ * normal_distribution<double>()(__urng);
	double __u;
	if (__g > 0)
	{
	__x = static_cast<result_type>(__g);
	if (__x >= __pr.__l_)
	return __x;
	__difmuk = __pr.__mean_ - __x;
	__u = __urd(__urng);
	if (__pr.__d_ * __u >= __difmuk * __difmuk * __difmuk)
	return __x;
	}
	exponential_distribution<double> __edist;
	for (bool __using_exp_dist = false; true; __using_exp_dist = true)
	{
	double __e;
	if (__using_exp_dist \|\| __g < 0)
	{
	double __t;
	do
	{
	__e = __edist(__urng);
	__u = __urd(__urng);
	__u += __u - 1;
	__t = 1.8 + (__u < 0 ? -__e : __e);
	} while (__t <= -.6744);
	__x = __pr.__mean_ + __pr.__s_ * __t;
	__difmuk = __pr.__mean_ - __x;
	__using_exp_dist = true;
	}
	double __px;
	double __py;
	if (__x < 10)
	{
	- const result_type __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040,
	+ const double __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040,
	40320, 362880};
	__px = -__pr.__mean_;
	__py = _VSTD::pow(__pr.__mean_, (double)__x) / __fac[__x];
	}
	else
	{
	double __del = .8333333E-1 / __x;
	__del -= 4.8 * __del * __del * __del;
	double __v = __difmuk / __x;
	if (_VSTD::abs(__v) > 0.25)
	__px = __x * _VSTD::log(1 + __v) - __difmuk - __del;
	else
	__px = __x * __v * __v * (((((((.1250060 * __v + -.1384794) *
	__v + .1421878) * __v + -.1661269) * __v + .2000118) *
	__v + -.2500068) * __v + .3333333) * __v + -.5) - __del;
	__py = .3989423 / _VSTD::sqrt(__x);
	}
	double __r = (0.5 - __difmuk) / __pr.__s_;
	double __r2 = __r * __r;
	double __fx = -0.5 * __r2;
	double __fy = __pr.__omega_ * (((__pr.__c3_ * __r2 + __pr.__c2_) *
	__r2 + __pr.__c1_) * __r2 + __pr.__c0_);
	if (__using_exp_dist)
	{
	if (__pr.__c_ * _VSTD::abs(__u) <= __py * _VSTD::exp(__px + __e) -
	__fy * _VSTD::exp(__fx + __e))
	break;
	}
	else
	{
	if (__fy - __u * __fy <= __py * _VSTD::exp(__px - __fx))
	break;
	}
	}
	}
	return __x;
	}

	template <class _CharT, class _Traits, class _IntType>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const poisson_distribution<_IntType>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	return __os << __x.mean();
	}

	template <class _CharT, class _Traits, class _IntType>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	poisson_distribution<_IntType>& __x)
	{
	typedef poisson_distribution<_IntType> _Eng;
	typedef typename _Eng::param_type param_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	double __mean;
	__is >> __mean;
	if (!__is.fail())
	__x.param(param_type(__mean));
	return __is;
	}

	// weibull_distribution

	template<class _RealType = double>
	class _LIBCPP_TEMPLATE_VIS weibull_distribution
	{
	public:
	// types
	typedef _RealType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	result_type __a_;
	result_type __b_;
	public:
	typedef weibull_distribution distribution_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit param_type(result_type __a = 1, result_type __b = 1)
	: __a_(__a), __b_(__b) {}

	_LIBCPP_INLINE_VISIBILITY
	result_type a() const {return __a_;}
	_LIBCPP_INLINE_VISIBILITY
	result_type b() const {return __b_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}
	};

	private:
	param_type __p_;

	public:
	// constructor and reset functions
	_LIBCPP_INLINE_VISIBILITY
	explicit weibull_distribution(result_type __a = 1, result_type __b = 1)
	: __p_(param_type(__a, __b)) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit weibull_distribution(const param_type& __p)
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g, const param_type& __p)
	{return __p.b() *
	_VSTD::pow(exponential_distribution<result_type>()(__g), 1/__p.a());}

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	result_type a() const {return __p_.a();}
	_LIBCPP_INLINE_VISIBILITY
	result_type b() const {return __p_.b();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return 0;}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return numeric_limits<result_type>::infinity();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const weibull_distribution& __x,
	const weibull_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const weibull_distribution& __x,
	const weibull_distribution& __y)
	{return !(__x == __y);}
	};

	template <class _CharT, class _Traits, class _RT>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const weibull_distribution<_RT>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	__os << __x.a() << __sp << __x.b();
	return __os;
	}

	template <class _CharT, class _Traits, class _RT>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	weibull_distribution<_RT>& __x)
	{
	typedef weibull_distribution<_RT> _Eng;
	typedef typename _Eng::result_type result_type;
	typedef typename _Eng::param_type param_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	result_type __a;
	result_type __b;
	__is >> __a >> __b;
	if (!__is.fail())
	__x.param(param_type(__a, __b));
	return __is;
	}

	template<class _RealType = double>
	class _LIBCPP_TEMPLATE_VIS extreme_value_distribution
	{
	public:
	// types
	typedef _RealType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	result_type __a_;
	result_type __b_;
	public:
	typedef extreme_value_distribution distribution_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit param_type(result_type __a = 0, result_type __b = 1)
	: __a_(__a), __b_(__b) {}

	_LIBCPP_INLINE_VISIBILITY
	result_type a() const {return __a_;}
	_LIBCPP_INLINE_VISIBILITY
	result_type b() const {return __b_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}
	};

	private:
	param_type __p_;

	public:
	// constructor and reset functions
	_LIBCPP_INLINE_VISIBILITY
	explicit extreme_value_distribution(result_type __a = 0, result_type __b = 1)
	: __p_(param_type(__a, __b)) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit extreme_value_distribution(const param_type& __p)
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	result_type a() const {return __p_.a();}
	_LIBCPP_INLINE_VISIBILITY
	result_type b() const {return __p_.b();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return -numeric_limits<result_type>::infinity();}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return numeric_limits<result_type>::infinity();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const extreme_value_distribution& __x,
	const extreme_value_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const extreme_value_distribution& __x,
	const extreme_value_distribution& __y)
	{return !(__x == __y);}
	};

	template<class _RealType>
	template<class _URNG>
	_RealType
	extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
	{
	return __p.a() - __p.b() *
	_VSTD::log(-_VSTD::log(1-uniform_real_distribution<result_type>()(__g)));
	}

	template <class _CharT, class _Traits, class _RT>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const extreme_value_distribution<_RT>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	__os << __x.a() << __sp << __x.b();
	return __os;
	}

	template <class _CharT, class _Traits, class _RT>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	extreme_value_distribution<_RT>& __x)
	{
	typedef extreme_value_distribution<_RT> _Eng;
	typedef typename _Eng::result_type result_type;
	typedef typename _Eng::param_type param_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	result_type __a;
	result_type __b;
	__is >> __a >> __b;
	if (!__is.fail())
	__x.param(param_type(__a, __b));
	return __is;
	}

	// gamma_distribution

	template<class _RealType = double>
	class _LIBCPP_TEMPLATE_VIS gamma_distribution
	{
	public:
	// types
	typedef _RealType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	result_type __alpha_;
	result_type __beta_;
	public:
	typedef gamma_distribution distribution_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit param_type(result_type __alpha = 1, result_type __beta = 1)
	: __alpha_(__alpha), __beta_(__beta) {}

	_LIBCPP_INLINE_VISIBILITY
	result_type alpha() const {return __alpha_;}
	_LIBCPP_INLINE_VISIBILITY
	result_type beta() const {return __beta_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__alpha_ == __y.__alpha_ && __x.__beta_ == __y.__beta_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}
	};

	private:
	param_type __p_;

	public:
	// constructors and reset functions
	_LIBCPP_INLINE_VISIBILITY
	explicit gamma_distribution(result_type __alpha = 1, result_type __beta = 1)
	: __p_(param_type(__alpha, __beta)) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit gamma_distribution(const param_type& __p)
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	result_type alpha() const {return __p_.alpha();}
	_LIBCPP_INLINE_VISIBILITY
	result_type beta() const {return __p_.beta();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return 0;}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return numeric_limits<result_type>::infinity();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const gamma_distribution& __x,
	const gamma_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const gamma_distribution& __x,
	const gamma_distribution& __y)
	{return !(__x == __y);}
	};

	template <class _RealType>
	template<class _URNG>
	_RealType
	gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
	{
	result_type __a = __p.alpha();
	uniform_real_distribution<result_type> __gen(0, 1);
	exponential_distribution<result_type> __egen;
	result_type __x;
	if (__a == 1)
	__x = __egen(__g);
	else if (__a > 1)
	{
	const result_type __b = __a - 1;
	const result_type __c = 3 * __a - result_type(0.75);
	while (true)
	{
	const result_type __u = __gen(__g);
	const result_type __v = __gen(__g);
	const result_type __w = __u * (1 - __u);
	if (__w != 0)
	{
	const result_type __y = _VSTD::sqrt(__c / __w) *
	(__u - result_type(0.5));
	__x = __b + __y;
	if (__x >= 0)
	{
	const result_type __z = 64 * __w * __w * __w * __v * __v;
	if (__z <= 1 - 2 * __y * __y / __x)
	break;
	if (_VSTD::log(__z) <= 2 * (__b * _VSTD::log(__x / __b) - __y))
	break;
	}
	}
	}
	}
	else // __a < 1
	{
	while (true)
	{
	const result_type __u = __gen(__g);
	const result_type __es = __egen(__g);
	if (__u <= 1 - __a)
	{
	__x = _VSTD::pow(__u, 1 / __a);
	if (__x <= __es)
	break;
	}
	else
	{
	const result_type __e = -_VSTD::log((1-__u)/__a);
	__x = _VSTD::pow(1 - __a + __a * __e, 1 / __a);
	if (__x <= __e + __es)
	break;
	}
	}
	}
	return __x * __p.beta();
	}

	template <class _CharT, class _Traits, class _RT>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const gamma_distribution<_RT>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	__os << __x.alpha() << __sp << __x.beta();
	return __os;
	}

	template <class _CharT, class _Traits, class _RT>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	gamma_distribution<_RT>& __x)
	{
	typedef gamma_distribution<_RT> _Eng;
	typedef typename _Eng::result_type result_type;
	typedef typename _Eng::param_type param_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	result_type __alpha;
	result_type __beta;
	__is >> __alpha >> __beta;
	if (!__is.fail())
	__x.param(param_type(__alpha, __beta));
	return __is;
	}

	// negative_binomial_distribution

	template<class _IntType = int>
	class _LIBCPP_TEMPLATE_VIS negative_binomial_distribution
	{
	public:
	// types
	typedef _IntType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	result_type __k_;
	double __p_;
	public:
	typedef negative_binomial_distribution distribution_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit param_type(result_type __k = 1, double __p = 0.5)
	: __k_(__k), __p_(__p) {}

	_LIBCPP_INLINE_VISIBILITY
	result_type k() const {return __k_;}
	_LIBCPP_INLINE_VISIBILITY
	double p() const {return __p_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__k_ == __y.__k_ && __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}
	};

	private:
	param_type __p_;

	public:
	// constructor and reset functions
	_LIBCPP_INLINE_VISIBILITY
	explicit negative_binomial_distribution(result_type __k = 1, double __p = 0.5)
	: __p_(__k, __p) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit negative_binomial_distribution(const param_type& __p) : __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	result_type k() const {return __p_.k();}
	_LIBCPP_INLINE_VISIBILITY
	double p() const {return __p_.p();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return 0;}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return numeric_limits<result_type>::max();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const negative_binomial_distribution& __x,
	const negative_binomial_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const negative_binomial_distribution& __x,
	const negative_binomial_distribution& __y)
	{return !(__x == __y);}
	};

	template <class _IntType>
	template<class _URNG>
	_IntType
	negative_binomial_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
	{
	result_type __k = __pr.k();
	double __p = __pr.p();
	if (__k <= 21 * __p)
	{
	bernoulli_distribution __gen(__p);
	result_type __f = 0;
	result_type __s = 0;
	while (__s < __k)
	{
	if (__gen(__urng))
	++__s;
	else
	++__f;
	}
	return __f;
	}
	return poisson_distribution<result_type>(gamma_distribution<double>
	(__k, (1-__p)/__p)(__urng))(__urng);
	}

	template <class _CharT, class _Traits, class _IntType>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const negative_binomial_distribution<_IntType>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	return __os << __x.k() << __sp << __x.p();
	}

	template <class _CharT, class _Traits, class _IntType>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	negative_binomial_distribution<_IntType>& __x)
	{
	typedef negative_binomial_distribution<_IntType> _Eng;
	typedef typename _Eng::result_type result_type;
	typedef typename _Eng::param_type param_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	result_type __k;
	double __p;
	__is >> __k >> __p;
	if (!__is.fail())
	__x.param(param_type(__k, __p));
	return __is;
	}

	// geometric_distribution

	template<class _IntType = int>
	class _LIBCPP_TEMPLATE_VIS geometric_distribution
	{
	public:
	// types
	typedef _IntType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	double __p_;
	public:
	typedef geometric_distribution distribution_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit param_type(double __p = 0.5) : __p_(__p) {}

	_LIBCPP_INLINE_VISIBILITY
	double p() const {return __p_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}
	};

	private:
	param_type __p_;

	public:
	// constructors and reset functions
	_LIBCPP_INLINE_VISIBILITY
	explicit geometric_distribution(double __p = 0.5) : __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit geometric_distribution(const param_type& __p) : __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g, const param_type& __p)
	{return negative_binomial_distribution<result_type>(1, __p.p())(__g);}

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	double p() const {return __p_.p();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return 0;}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return numeric_limits<result_type>::max();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const geometric_distribution& __x,
	const geometric_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const geometric_distribution& __x,
	const geometric_distribution& __y)
	{return !(__x == __y);}
	};

	template <class _CharT, class _Traits, class _IntType>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const geometric_distribution<_IntType>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	return __os << __x.p();
	}

	template <class _CharT, class _Traits, class _IntType>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	geometric_distribution<_IntType>& __x)
	{
	typedef geometric_distribution<_IntType> _Eng;
	typedef typename _Eng::param_type param_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	double __p;
	__is >> __p;
	if (!__is.fail())
	__x.param(param_type(__p));
	return __is;
	}

	// chi_squared_distribution

	template<class _RealType = double>
	class _LIBCPP_TEMPLATE_VIS chi_squared_distribution
	{
	public:
	// types
	typedef _RealType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	result_type __n_;
	public:
	typedef chi_squared_distribution distribution_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit param_type(result_type __n = 1) : __n_(__n) {}

	_LIBCPP_INLINE_VISIBILITY
	result_type n() const {return __n_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__n_ == __y.__n_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}
	};

	private:
	param_type __p_;

	public:
	// constructor and reset functions
	_LIBCPP_INLINE_VISIBILITY
	explicit chi_squared_distribution(result_type __n = 1)
	: __p_(param_type(__n)) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit chi_squared_distribution(const param_type& __p)
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g, const param_type& __p)
	{return gamma_distribution<result_type>(__p.n() / 2, 2)(__g);}

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	result_type n() const {return __p_.n();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return 0;}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return numeric_limits<result_type>::infinity();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const chi_squared_distribution& __x,
	const chi_squared_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const chi_squared_distribution& __x,
	const chi_squared_distribution& __y)
	{return !(__x == __y);}
	};

	template <class _CharT, class _Traits, class _RT>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const chi_squared_distribution<_RT>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	__os << __x.n();
	return __os;
	}

	template <class _CharT, class _Traits, class _RT>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	chi_squared_distribution<_RT>& __x)
	{
	typedef chi_squared_distribution<_RT> _Eng;
	typedef typename _Eng::result_type result_type;
	typedef typename _Eng::param_type param_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	result_type __n;
	__is >> __n;
	if (!__is.fail())
	__x.param(param_type(__n));
	return __is;
	}

	// cauchy_distribution

	template<class _RealType = double>
	class _LIBCPP_TEMPLATE_VIS cauchy_distribution
	{
	public:
	// types
	typedef _RealType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	result_type __a_;
	result_type __b_;
	public:
	typedef cauchy_distribution distribution_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit param_type(result_type __a = 0, result_type __b = 1)
	: __a_(__a), __b_(__b) {}

	_LIBCPP_INLINE_VISIBILITY
	result_type a() const {return __a_;}
	_LIBCPP_INLINE_VISIBILITY
	result_type b() const {return __b_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}
	};

	private:
	param_type __p_;

	public:
	// constructor and reset functions
	_LIBCPP_INLINE_VISIBILITY
	explicit cauchy_distribution(result_type __a = 0, result_type __b = 1)
	: __p_(param_type(__a, __b)) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit cauchy_distribution(const param_type& __p)
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	result_type a() const {return __p_.a();}
	_LIBCPP_INLINE_VISIBILITY
	result_type b() const {return __p_.b();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return -numeric_limits<result_type>::infinity();}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return numeric_limits<result_type>::infinity();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const cauchy_distribution& __x,
	const cauchy_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const cauchy_distribution& __x,
	const cauchy_distribution& __y)
	{return !(__x == __y);}
	};

	template <class _RealType>
	template<class _URNG>
	inline
	_RealType
	cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
	{
	uniform_real_distribution<result_type> __gen;
	// purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite
	return __p.a() + __p.b() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g));
	}

	template <class _CharT, class _Traits, class _RT>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const cauchy_distribution<_RT>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	__os << __x.a() << __sp << __x.b();
	return __os;
	}

	template <class _CharT, class _Traits, class _RT>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	cauchy_distribution<_RT>& __x)
	{
	typedef cauchy_distribution<_RT> _Eng;
	typedef typename _Eng::result_type result_type;
	typedef typename _Eng::param_type param_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	result_type __a;
	result_type __b;
	__is >> __a >> __b;
	if (!__is.fail())
	__x.param(param_type(__a, __b));
	return __is;
	}

	// fisher_f_distribution

	template<class _RealType = double>
	class _LIBCPP_TEMPLATE_VIS fisher_f_distribution
	{
	public:
	// types
	typedef _RealType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	result_type __m_;
	result_type __n_;
	public:
	typedef fisher_f_distribution distribution_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit param_type(result_type __m = 1, result_type __n = 1)
	: __m_(__m), __n_(__n) {}

	_LIBCPP_INLINE_VISIBILITY
	result_type m() const {return __m_;}
	_LIBCPP_INLINE_VISIBILITY
	result_type n() const {return __n_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__m_ == __y.__m_ && __x.__n_ == __y.__n_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}
	};

	private:
	param_type __p_;

	public:
	// constructor and reset functions
	_LIBCPP_INLINE_VISIBILITY
	explicit fisher_f_distribution(result_type __m = 1, result_type __n = 1)
	: __p_(param_type(__m, __n)) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit fisher_f_distribution(const param_type& __p)
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	result_type m() const {return __p_.m();}
	_LIBCPP_INLINE_VISIBILITY
	result_type n() const {return __p_.n();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return 0;}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return numeric_limits<result_type>::infinity();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const fisher_f_distribution& __x,
	const fisher_f_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const fisher_f_distribution& __x,
	const fisher_f_distribution& __y)
	{return !(__x == __y);}
	};

	template <class _RealType>
	template<class _URNG>
	_RealType
	fisher_f_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
	{
	gamma_distribution<result_type> __gdm(__p.m() * result_type(.5));
	gamma_distribution<result_type> __gdn(__p.n() * result_type(.5));
	return __p.n() * __gdm(__g) / (__p.m() * __gdn(__g));
	}

	template <class _CharT, class _Traits, class _RT>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const fisher_f_distribution<_RT>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	__os << __x.m() << __sp << __x.n();
	return __os;
	}

	template <class _CharT, class _Traits, class _RT>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	fisher_f_distribution<_RT>& __x)
	{
	typedef fisher_f_distribution<_RT> _Eng;
	typedef typename _Eng::result_type result_type;
	typedef typename _Eng::param_type param_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	result_type __m;
	result_type __n;
	__is >> __m >> __n;
	if (!__is.fail())
	__x.param(param_type(__m, __n));
	return __is;
	}

	// student_t_distribution

	template<class _RealType = double>
	class _LIBCPP_TEMPLATE_VIS student_t_distribution
	{
	public:
	// types
	typedef _RealType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	result_type __n_;
	public:
	typedef student_t_distribution distribution_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit param_type(result_type __n = 1) : __n_(__n) {}

	_LIBCPP_INLINE_VISIBILITY
	result_type n() const {return __n_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__n_ == __y.__n_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}
	};

	private:
	param_type __p_;
	normal_distribution<result_type> __nd_;

	public:
	// constructor and reset functions
	_LIBCPP_INLINE_VISIBILITY
	explicit student_t_distribution(result_type __n = 1)
	: __p_(param_type(__n)) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit student_t_distribution(const param_type& __p)
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {__nd_.reset();}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	result_type n() const {return __p_.n();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return -numeric_limits<result_type>::infinity();}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return numeric_limits<result_type>::infinity();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const student_t_distribution& __x,
	const student_t_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const student_t_distribution& __x,
	const student_t_distribution& __y)
	{return !(__x == __y);}
	};

	template <class _RealType>
	template<class _URNG>
	_RealType
	student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
	{
	gamma_distribution<result_type> __gd(__p.n() * .5, 2);
	return __nd_(__g) * _VSTD::sqrt(__p.n()/__gd(__g));
	}

	template <class _CharT, class _Traits, class _RT>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const student_t_distribution<_RT>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	__os << __x.n();
	return __os;
	}

	template <class _CharT, class _Traits, class _RT>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	student_t_distribution<_RT>& __x)
	{
	typedef student_t_distribution<_RT> _Eng;
	typedef typename _Eng::result_type result_type;
	typedef typename _Eng::param_type param_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	result_type __n;
	__is >> __n;
	if (!__is.fail())
	__x.param(param_type(__n));
	return __is;
	}

	// discrete_distribution

	template<class _IntType = int>
	class _LIBCPP_TEMPLATE_VIS discrete_distribution
	{
	public:
	// types
	typedef _IntType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	vector<double> __p_;
	public:
	typedef discrete_distribution distribution_type;

	_LIBCPP_INLINE_VISIBILITY
	param_type() {}
	template<class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	param_type(_InputIterator __f, _InputIterator __l)
	: __p_(__f, __l) {__init();}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	param_type(initializer_list<double> __wl)
	: __p_(__wl.begin(), __wl.end()) {__init();}
	#endif // _LIBCPP_CXX03_LANG
	template<class _UnaryOperation>
	param_type(size_t __nw, double __xmin, double __xmax,
	_UnaryOperation __fw);

	vector<double> probabilities() const;

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}

	private:
	void __init();

	friend class discrete_distribution;

	template <class _CharT, class _Traits, class _IT>
	friend
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const discrete_distribution<_IT>& __x);

	template <class _CharT, class _Traits, class _IT>
	friend
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	discrete_distribution<_IT>& __x);
	};

	private:
	param_type __p_;

	public:
	// constructor and reset functions
	_LIBCPP_INLINE_VISIBILITY
	discrete_distribution() {}
	template<class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	discrete_distribution(_InputIterator __f, _InputIterator __l)
	: __p_(__f, __l) {}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	discrete_distribution(initializer_list<double> __wl)
	: __p_(__wl) {}
	#endif // _LIBCPP_CXX03_LANG
	template<class _UnaryOperation>
	_LIBCPP_INLINE_VISIBILITY
	discrete_distribution(size_t __nw, double __xmin, double __xmax,
	_UnaryOperation __fw)
	: __p_(__nw, __xmin, __xmax, __fw) {}
	_LIBCPP_INLINE_VISIBILITY
	explicit discrete_distribution(const param_type& __p)
	: __p_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	void reset() {}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	vector<double> probabilities() const {return __p_.probabilities();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return 0;}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return __p_.__p_.size();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const discrete_distribution& __x,
	const discrete_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const discrete_distribution& __x,
	const discrete_distribution& __y)
	{return !(__x == __y);}

	template <class _CharT, class _Traits, class _IT>
	friend
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const discrete_distribution<_IT>& __x);

	template <class _CharT, class _Traits, class _IT>
	friend
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	discrete_distribution<_IT>& __x);
	};

	template<class _IntType>
	template<class _UnaryOperation>
	discrete_distribution<_IntType>::param_type::param_type(size_t __nw,
	double __xmin,
	double __xmax,
	_UnaryOperation __fw)
	{
	if (__nw > 1)
	{
	__p_.reserve(__nw - 1);
	double __d = (__xmax - __xmin) / __nw;
	double __d2 = __d / 2;
	for (size_t __k = 0; __k < __nw; ++__k)
	__p_.push_back(__fw(__xmin + __k * __d + __d2));
	__init();
	}
	}

	template<class _IntType>
	void
	discrete_distribution<_IntType>::param_type::__init()
	{
	if (!__p_.empty())
	{
	if (__p_.size() > 1)
	{
	double __s = _VSTD::accumulate(__p_.begin(), __p_.end(), 0.0);
	for (_VSTD::vector<double>::iterator __i = __p_.begin(), __e = __p_.end();
	__i < __e; ++__i)
	*__i /= __s;
	vector<double> __t(__p_.size() - 1);
	_VSTD::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin());
	swap(__p_, __t);
	}
	else
	{
	__p_.clear();
	__p_.shrink_to_fit();
	}
	}
	}

	template<class _IntType>
	vector<double>
	discrete_distribution<_IntType>::param_type::probabilities() const
	{
	size_t __n = __p_.size();
	_VSTD::vector<double> __p(__n+1);
	_VSTD::adjacent_difference(__p_.begin(), __p_.end(), __p.begin());
	if (__n > 0)
	__p[__n] = 1 - __p_[__n-1];
	else
	__p[0] = 1;
	return __p;
	}

	template<class _IntType>
	template<class _URNG>
	_IntType
	discrete_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
	{
	uniform_real_distribution<double> __gen;
	return static_cast<_IntType>(
	_VSTD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) -
	__p.__p_.begin());
	}

	template <class _CharT, class _Traits, class _IT>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const discrete_distribution<_IT>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	size_t __n = __x.__p_.__p_.size();
	__os << __n;
	for (size_t __i = 0; __i < __n; ++__i)
	__os << __sp << __x.__p_.__p_[__i];
	return __os;
	}

	template <class _CharT, class _Traits, class _IT>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	discrete_distribution<_IT>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	size_t __n;
	__is >> __n;
	vector<double> __p(__n);
	for (size_t __i = 0; __i < __n; ++__i)
	__is >> __p[__i];
	if (!__is.fail())
	swap(__x.__p_.__p_, __p);
	return __is;
	}

	// piecewise_constant_distribution

	template<class _RealType = double>
	class _LIBCPP_TEMPLATE_VIS piecewise_constant_distribution
	{
	public:
	// types
	typedef _RealType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	vector<result_type> __b_;
	vector<result_type> __densities_;
	vector<result_type> __areas_;
	public:
	typedef piecewise_constant_distribution distribution_type;

	param_type();
	template<class _InputIteratorB, class _InputIteratorW>
	param_type(_InputIteratorB __fB, _InputIteratorB __lB,
	_InputIteratorW __fW);
	#ifndef _LIBCPP_CXX03_LANG
	template<class _UnaryOperation>
	param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
	#endif // _LIBCPP_CXX03_LANG
	template<class _UnaryOperation>
	param_type(size_t __nw, result_type __xmin, result_type __xmax,
	_UnaryOperation __fw);
	param_type & operator=(const param_type& __rhs);

	_LIBCPP_INLINE_VISIBILITY
	vector<result_type> intervals() const {return __b_;}
	_LIBCPP_INLINE_VISIBILITY
	vector<result_type> densities() const {return __densities_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}

	private:
	void __init();

	friend class piecewise_constant_distribution;

	template <class _CharT, class _Traits, class _RT>
	friend
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const piecewise_constant_distribution<_RT>& __x);

	template <class _CharT, class _Traits, class _RT>
	friend
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	piecewise_constant_distribution<_RT>& __x);
	};

	private:
	param_type __p_;

	public:
	// constructor and reset functions
	_LIBCPP_INLINE_VISIBILITY
	piecewise_constant_distribution() {}
	template<class _InputIteratorB, class _InputIteratorW>
	_LIBCPP_INLINE_VISIBILITY
	piecewise_constant_distribution(_InputIteratorB __fB,
	_InputIteratorB __lB,
	_InputIteratorW __fW)
	: __p_(__fB, __lB, __fW) {}

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

	template<class _UnaryOperation>
	_LIBCPP_INLINE_VISIBILITY
	piecewise_constant_distribution(size_t __nw, result_type __xmin,
	result_type __xmax, _UnaryOperation __fw)
	: __p_(__nw, __xmin, __xmax, __fw) {}

	_LIBCPP_INLINE_VISIBILITY
	explicit piecewise_constant_distribution(const param_type& __p)
	: __p_(__p) {}

	_LIBCPP_INLINE_VISIBILITY
	void reset() {}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	vector<result_type> intervals() const {return __p_.intervals();}
	_LIBCPP_INLINE_VISIBILITY
	vector<result_type> densities() const {return __p_.densities();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return __p_.__b_.front();}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return __p_.__b_.back();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const piecewise_constant_distribution& __x,
	const piecewise_constant_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const piecewise_constant_distribution& __x,
	const piecewise_constant_distribution& __y)
	{return !(__x == __y);}

	template <class _CharT, class _Traits, class _RT>
	friend
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const piecewise_constant_distribution<_RT>& __x);

	template <class _CharT, class _Traits, class _RT>
	friend
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	piecewise_constant_distribution<_RT>& __x);
	};

	template<class _RealType>
	typename piecewise_constant_distribution<_RealType>::param_type &
	piecewise_constant_distribution<_RealType>::param_type::operator=
	(const param_type& __rhs)
	{
	// These can throw
	__b_.reserve (__rhs.__b_.size ());
	__densities_.reserve(__rhs.__densities_.size());
	__areas_.reserve (__rhs.__areas_.size());

	// These can not throw
	__b_ = __rhs.__b_;
	__densities_ = __rhs.__densities_;
	__areas_ = __rhs.__areas_;
	return *this;
	}

	template<class _RealType>
	void
	piecewise_constant_distribution<_RealType>::param_type::__init()
	{
	// __densities_ contains non-normalized areas
	result_type __total_area = _VSTD::accumulate(__densities_.begin(),
	__densities_.end(),
	result_type());
	for (size_t __i = 0; __i < __densities_.size(); ++__i)
	__densities_[__i] /= __total_area;
	// __densities_ contains normalized areas
	__areas_.assign(__densities_.size(), result_type());
	_VSTD::partial_sum(__densities_.begin(), __densities_.end() - 1,
	__areas_.begin() + 1);
	// __areas_ contains partial sums of normalized areas: [0, __densities_ - 1]
	__densities_.back() = 1 - __areas_.back(); // correct round off error
	for (size_t __i = 0; __i < __densities_.size(); ++__i)
	__densities_[__i] /= (__b_[__i+1] - __b_[__i]);
	// __densities_ now contains __densities_
	}

	template<class _RealType>
	piecewise_constant_distribution<_RealType>::param_type::param_type()
	: __b_(2),
	__densities_(1, 1.0),
	__areas_(1, 0.0)
	{
	__b_[1] = 1;
	}

	template<class _RealType>
	template<class _InputIteratorB, class _InputIteratorW>
	piecewise_constant_distribution<_RealType>::param_type::param_type(
	_InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW)
	: __b_(__fB, __lB)
	{
	if (__b_.size() < 2)
	{
	__b_.resize(2);
	__b_[0] = 0;
	__b_[1] = 1;
	__densities_.assign(1, 1.0);
	__areas_.assign(1, 0.0);
	}
	else
	{
	__densities_.reserve(__b_.size() - 1);
	for (size_t __i = 0; __i < __b_.size() - 1; ++__i, ++__fW)
	__densities_.push_back(*__fW);
	__init();
	}
	}

	#ifndef _LIBCPP_CXX03_LANG

	template<class _RealType>
	template<class _UnaryOperation>
	piecewise_constant_distribution<_RealType>::param_type::param_type(
	initializer_list<result_type> __bl, _UnaryOperation __fw)
	: __b_(__bl.begin(), __bl.end())
	{
	if (__b_.size() < 2)
	{
	__b_.resize(2);
	__b_[0] = 0;
	__b_[1] = 1;
	__densities_.assign(1, 1.0);
	__areas_.assign(1, 0.0);
	}
	else
	{
	__densities_.reserve(__b_.size() - 1);
	for (size_t __i = 0; __i < __b_.size() - 1; ++__i)
	__densities_.push_back(__fw((__b_[__i+1] + __b_[__i])*.5));
	__init();
	}
	}

	#endif // _LIBCPP_CXX03_LANG

	template<class _RealType>
	template<class _UnaryOperation>
	piecewise_constant_distribution<_RealType>::param_type::param_type(
	size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
	: __b_(__nw == 0 ? 2 : __nw + 1)
	{
	size_t __n = __b_.size() - 1;
	result_type __d = (__xmax - __xmin) / __n;
	__densities_.reserve(__n);
	for (size_t __i = 0; __i < __n; ++__i)
	{
	__b_[__i] = __xmin + __i * __d;
	__densities_.push_back(__fw(__b_[__i] + __d*.5));
	}
	__b_[__n] = __xmax;
	__init();
	}

	template<class _RealType>
	template<class _URNG>
	_RealType
	piecewise_constant_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
	{
	typedef uniform_real_distribution<result_type> _Gen;
	result_type __u = _Gen()(__g);
	ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
	__u) - __p.__areas_.begin() - 1;
	return (__u - __p.__areas_[__k]) / __p.__densities_[__k] + __p.__b_[__k];
	}

	template <class _CharT, class _Traits, class _RT>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const piecewise_constant_distribution<_RT>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	size_t __n = __x.__p_.__b_.size();
	__os << __n;
	for (size_t __i = 0; __i < __n; ++__i)
	__os << __sp << __x.__p_.__b_[__i];
	__n = __x.__p_.__densities_.size();
	__os << __sp << __n;
	for (size_t __i = 0; __i < __n; ++__i)
	__os << __sp << __x.__p_.__densities_[__i];
	__n = __x.__p_.__areas_.size();
	__os << __sp << __n;
	for (size_t __i = 0; __i < __n; ++__i)
	__os << __sp << __x.__p_.__areas_[__i];
	return __os;
	}

	template <class _CharT, class _Traits, class _RT>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	piecewise_constant_distribution<_RT>& __x)
	{
	typedef piecewise_constant_distribution<_RT> _Eng;
	typedef typename _Eng::result_type result_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	size_t __n;
	__is >> __n;
	vector<result_type> __b(__n);
	for (size_t __i = 0; __i < __n; ++__i)
	__is >> __b[__i];
	__is >> __n;
	vector<result_type> __densities(__n);
	for (size_t __i = 0; __i < __n; ++__i)
	__is >> __densities[__i];
	__is >> __n;
	vector<result_type> __areas(__n);
	for (size_t __i = 0; __i < __n; ++__i)
	__is >> __areas[__i];
	if (!__is.fail())
	{
	swap(__x.__p_.__b_, __b);
	swap(__x.__p_.__densities_, __densities);
	swap(__x.__p_.__areas_, __areas);
	}
	return __is;
	}

	// piecewise_linear_distribution

	template<class _RealType = double>
	class _LIBCPP_TEMPLATE_VIS piecewise_linear_distribution
	{
	public:
	// types
	typedef _RealType result_type;

	class _LIBCPP_TEMPLATE_VIS param_type
	{
	vector<result_type> __b_;
	vector<result_type> __densities_;
	vector<result_type> __areas_;
	public:
	typedef piecewise_linear_distribution distribution_type;

	param_type();
	template<class _InputIteratorB, class _InputIteratorW>
	param_type(_InputIteratorB __fB, _InputIteratorB __lB,
	_InputIteratorW __fW);
	#ifndef _LIBCPP_CXX03_LANG
	template<class _UnaryOperation>
	param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
	#endif // _LIBCPP_CXX03_LANG
	template<class _UnaryOperation>
	param_type(size_t __nw, result_type __xmin, result_type __xmax,
	_UnaryOperation __fw);
	param_type & operator=(const param_type& __rhs);

	_LIBCPP_INLINE_VISIBILITY
	vector<result_type> intervals() const {return __b_;}
	_LIBCPP_INLINE_VISIBILITY
	vector<result_type> densities() const {return __densities_;}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const param_type& __x, const param_type& __y)
	{return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const param_type& __x, const param_type& __y)
	{return !(__x == __y);}

	private:
	void __init();

	friend class piecewise_linear_distribution;

	template <class _CharT, class _Traits, class _RT>
	friend
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const piecewise_linear_distribution<_RT>& __x);

	template <class _CharT, class _Traits, class _RT>
	friend
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	piecewise_linear_distribution<_RT>& __x);
	};

	private:
	param_type __p_;

	public:
	// constructor and reset functions
	_LIBCPP_INLINE_VISIBILITY
	piecewise_linear_distribution() {}
	template<class _InputIteratorB, class _InputIteratorW>
	_LIBCPP_INLINE_VISIBILITY
	piecewise_linear_distribution(_InputIteratorB __fB,
	_InputIteratorB __lB,
	_InputIteratorW __fW)
	: __p_(__fB, __lB, __fW) {}

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

	template<class _UnaryOperation>
	_LIBCPP_INLINE_VISIBILITY
	piecewise_linear_distribution(size_t __nw, result_type __xmin,
	result_type __xmax, _UnaryOperation __fw)
	: __p_(__nw, __xmin, __xmax, __fw) {}

	_LIBCPP_INLINE_VISIBILITY
	explicit piecewise_linear_distribution(const param_type& __p)
	: __p_(__p) {}

	_LIBCPP_INLINE_VISIBILITY
	void reset() {}

	// generating functions
	template<class _URNG>
	_LIBCPP_INLINE_VISIBILITY
	result_type operator()(_URNG& __g)
	{return (*this)(__g, __p_);}
	template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);

	// property functions
	_LIBCPP_INLINE_VISIBILITY
	vector<result_type> intervals() const {return __p_.intervals();}
	_LIBCPP_INLINE_VISIBILITY
	vector<result_type> densities() const {return __p_.densities();}

	_LIBCPP_INLINE_VISIBILITY
	param_type param() const {return __p_;}
	_LIBCPP_INLINE_VISIBILITY
	void param(const param_type& __p) {__p_ = __p;}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const {return __p_.__b_.front();}
	_LIBCPP_INLINE_VISIBILITY
	result_type max() const {return __p_.__b_.back();}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const piecewise_linear_distribution& __x,
	const piecewise_linear_distribution& __y)
	{return __x.__p_ == __y.__p_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const piecewise_linear_distribution& __x,
	const piecewise_linear_distribution& __y)
	{return !(__x == __y);}

	template <class _CharT, class _Traits, class _RT>
	friend
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const piecewise_linear_distribution<_RT>& __x);

	template <class _CharT, class _Traits, class _RT>
	friend
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	piecewise_linear_distribution<_RT>& __x);
	};

	template<class _RealType>
	typename piecewise_linear_distribution<_RealType>::param_type &
	piecewise_linear_distribution<_RealType>::param_type::operator=
	(const param_type& __rhs)
	{
	// These can throw
	__b_.reserve (__rhs.__b_.size ());
	__densities_.reserve(__rhs.__densities_.size());
	__areas_.reserve (__rhs.__areas_.size());

	// These can not throw
	__b_ = __rhs.__b_;
	__densities_ = __rhs.__densities_;
	__areas_ = __rhs.__areas_;
	return *this;
	}


	template<class _RealType>
	void
	piecewise_linear_distribution<_RealType>::param_type::__init()
	{
	__areas_.assign(__densities_.size() - 1, result_type());
	result_type _Sp = 0;
	for (size_t __i = 0; __i < __areas_.size(); ++__i)
	{
	__areas_[__i] = (__densities_[__i+1] + __densities_[__i]) *
	(__b_[__i+1] - __b_[__i]) * .5;
	_Sp += __areas_[__i];
	}
	for (size_t __i = __areas_.size(); __i > 1;)
	{
	--__i;
	__areas_[__i] = __areas_[__i-1] / _Sp;
	}
	__areas_[0] = 0;
	for (size_t __i = 1; __i < __areas_.size(); ++__i)
	__areas_[__i] += __areas_[__i-1];
	for (size_t __i = 0; __i < __densities_.size(); ++__i)
	__densities_[__i] /= _Sp;
	}

	template<class _RealType>
	piecewise_linear_distribution<_RealType>::param_type::param_type()
	: __b_(2),
	__densities_(2, 1.0),
	__areas_(1, 0.0)
	{
	__b_[1] = 1;
	}

	template<class _RealType>
	template<class _InputIteratorB, class _InputIteratorW>
	piecewise_linear_distribution<_RealType>::param_type::param_type(
	_InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW)
	: __b_(__fB, __lB)
	{
	if (__b_.size() < 2)
	{
	__b_.resize(2);
	__b_[0] = 0;
	__b_[1] = 1;
	__densities_.assign(2, 1.0);
	__areas_.assign(1, 0.0);
	}
	else
	{
	__densities_.reserve(__b_.size());
	for (size_t __i = 0; __i < __b_.size(); ++__i, ++__fW)
	__densities_.push_back(*__fW);
	__init();
	}
	}

	#ifndef _LIBCPP_CXX03_LANG

	template<class _RealType>
	template<class _UnaryOperation>
	piecewise_linear_distribution<_RealType>::param_type::param_type(
	initializer_list<result_type> __bl, _UnaryOperation __fw)
	: __b_(__bl.begin(), __bl.end())
	{
	if (__b_.size() < 2)
	{
	__b_.resize(2);
	__b_[0] = 0;
	__b_[1] = 1;
	__densities_.assign(2, 1.0);
	__areas_.assign(1, 0.0);
	}
	else
	{
	__densities_.reserve(__b_.size());
	for (size_t __i = 0; __i < __b_.size(); ++__i)
	__densities_.push_back(__fw(__b_[__i]));
	__init();
	}
	}

	#endif // _LIBCPP_CXX03_LANG

	template<class _RealType>
	template<class _UnaryOperation>
	piecewise_linear_distribution<_RealType>::param_type::param_type(
	size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
	: __b_(__nw == 0 ? 2 : __nw + 1)
	{
	size_t __n = __b_.size() - 1;
	result_type __d = (__xmax - __xmin) / __n;
	__densities_.reserve(__b_.size());
	for (size_t __i = 0; __i < __n; ++__i)
	{
	__b_[__i] = __xmin + __i * __d;
	__densities_.push_back(__fw(__b_[__i]));
	}
	__b_[__n] = __xmax;
	__densities_.push_back(__fw(__b_[__n]));
	__init();
	}

	template<class _RealType>
	template<class _URNG>
	_RealType
	piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
	{
	typedef uniform_real_distribution<result_type> _Gen;
	result_type __u = _Gen()(__g);
	ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
	__u) - __p.__areas_.begin() - 1;
	__u -= __p.__areas_[__k];
	const result_type __dk = __p.__densities_[__k];
	const result_type __dk1 = __p.__densities_[__k+1];
	const result_type __deltad = __dk1 - __dk;
	const result_type __bk = __p.__b_[__k];
	if (__deltad == 0)
	return __u / __dk + __bk;
	const result_type __bk1 = __p.__b_[__k+1];
	const result_type __deltab = __bk1 - __bk;
	return (__bk * __dk1 - __bk1 * __dk +
	_VSTD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) /
	__deltad;
	}

	template <class _CharT, class _Traits, class _RT>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const piecewise_linear_distribution<_RT>& __x)
	{
	__save_flags<_CharT, _Traits> __lx(__os);
	__os.flags(ios_base::dec \| ios_base::left \| ios_base::fixed \|
	ios_base::scientific);
	_CharT __sp = __os.widen(' ');
	__os.fill(__sp);
	size_t __n = __x.__p_.__b_.size();
	__os << __n;
	for (size_t __i = 0; __i < __n; ++__i)
	__os << __sp << __x.__p_.__b_[__i];
	__n = __x.__p_.__densities_.size();
	__os << __sp << __n;
	for (size_t __i = 0; __i < __n; ++__i)
	__os << __sp << __x.__p_.__densities_[__i];
	__n = __x.__p_.__areas_.size();
	__os << __sp << __n;
	for (size_t __i = 0; __i < __n; ++__i)
	__os << __sp << __x.__p_.__areas_[__i];
	return __os;
	}

	template <class _CharT, class _Traits, class _RT>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	piecewise_linear_distribution<_RT>& __x)
	{
	typedef piecewise_linear_distribution<_RT> _Eng;
	typedef typename _Eng::result_type result_type;
	__save_flags<_CharT, _Traits> __lx(__is);
	__is.flags(ios_base::dec \| ios_base::skipws);
	size_t __n;
	__is >> __n;
	vector<result_type> __b(__n);
	for (size_t __i = 0; __i < __n; ++__i)
	__is >> __b[__i];
	__is >> __n;
	vector<result_type> __densities(__n);
	for (size_t __i = 0; __i < __n; ++__i)
	__is >> __densities[__i];
	__is >> __n;
	vector<result_type> __areas(__n);
	for (size_t __i = 0; __i < __n; ++__i)
	__is >> __areas[__i];
	if (!__is.fail())
	{
	swap(__x.__p_.__b_, __b);
	swap(__x.__p_.__densities_, __densities);
	swap(__x.__p_.__areas_, __areas);
	}
	return __is;
	}

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_RANDOM
	Index: projects/clang700-import/contrib/libc++/include/regex
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/regex (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/regex (revision 337135)
	@@ -1,6603 +1,6617 @@
	// -- C++ --
	//===--------------------------- regex ------------------------------------===//
	//
	// 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_REGEX
	#define _LIBCPP_REGEX

	/*
	regex synopsis

	#include <initializer_list>

	namespace std
	{

	namespace regex_constants
	{

	emum syntax_option_type
	{
	icase = unspecified,
	nosubs = unspecified,
	optimize = unspecified,
	collate = unspecified,
	ECMAScript = unspecified,
	basic = unspecified,
	extended = unspecified,
	awk = unspecified,
	grep = unspecified,
	egrep = unspecified
	};

	constexpr syntax_option_type operator~(syntax_option_type f);
	constexpr syntax_option_type operator&(syntax_option_type lhs, syntax_option_type rhs);
	constexpr syntax_option_type operator\|(syntax_option_type lhs, syntax_option_type rhs);

	enum match_flag_type
	{
	match_default = 0,
	match_not_bol = unspecified,
	match_not_eol = unspecified,
	match_not_bow = unspecified,
	match_not_eow = unspecified,
	match_any = unspecified,
	match_not_null = unspecified,
	match_continuous = unspecified,
	match_prev_avail = unspecified,
	format_default = 0,
	format_sed = unspecified,
	format_no_copy = unspecified,
	format_first_only = unspecified
	};

	constexpr match_flag_type operator~(match_flag_type f);
	constexpr match_flag_type operator&(match_flag_type lhs, match_flag_type rhs);
	constexpr match_flag_type operator\|(match_flag_type lhs, match_flag_type rhs);

	enum error_type
	{
	error_collate = unspecified,
	error_ctype = unspecified,
	error_escape = unspecified,
	error_backref = unspecified,
	error_brack = unspecified,
	error_paren = unspecified,
	error_brace = unspecified,
	error_badbrace = unspecified,
	error_range = unspecified,
	error_space = unspecified,
	error_badrepeat = unspecified,
	error_complexity = unspecified,
	error_stack = unspecified
	};

	} // regex_constants

	class regex_error
	: public runtime_error
	{
	public:
	explicit regex_error(regex_constants::error_type ecode);
	regex_constants::error_type code() const;
	};

	template <class charT>
	struct regex_traits
	{
	public:
	typedef charT char_type;
	typedef basic_string<char_type> string_type;
	typedef locale locale_type;
	typedef /bitmask_type/ char_class_type;

	regex_traits();

	static size_t length(const char_type* p);
	charT translate(charT c) const;
	charT translate_nocase(charT c) const;
	template <class ForwardIterator>
	string_type
	transform(ForwardIterator first, ForwardIterator last) const;
	template <class ForwardIterator>
	string_type
	transform_primary( ForwardIterator first, ForwardIterator last) const;
	template <class ForwardIterator>
	string_type
	lookup_collatename(ForwardIterator first, ForwardIterator last) const;
	template <class ForwardIterator>
	char_class_type
	lookup_classname(ForwardIterator first, ForwardIterator last,
	bool icase = false) const;
	bool isctype(charT c, char_class_type f) const;
	int value(charT ch, int radix) const;
	locale_type imbue(locale_type l);
	locale_type getloc()const;
	};

	template <class charT, class traits = regex_traits<charT>>
	class basic_regex
	{
	public:
	// types:
	typedef charT value_type;
	typedef traits traits_type;
	typedef typename traits::string_type string_type;
	typedef regex_constants::syntax_option_type flag_type;
	typedef typename traits::locale_type locale_type;

	// constants:
	static constexpr regex_constants::syntax_option_type icase = regex_constants::icase;
	static constexpr regex_constants::syntax_option_type nosubs = regex_constants::nosubs;
	static constexpr regex_constants::syntax_option_type optimize = regex_constants::optimize;
	static constexpr regex_constants::syntax_option_type collate = regex_constants::collate;
	static constexpr regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
	static constexpr regex_constants::syntax_option_type basic = regex_constants::basic;
	static constexpr regex_constants::syntax_option_type extended = regex_constants::extended;
	static constexpr regex_constants::syntax_option_type awk = regex_constants::awk;
	static constexpr regex_constants::syntax_option_type grep = regex_constants::grep;
	static constexpr regex_constants::syntax_option_type egrep = regex_constants::egrep;

	// construct/copy/destroy:
	basic_regex();
	explicit basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript);
	basic_regex(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript);
	basic_regex(const basic_regex&);
	basic_regex(basic_regex&&) noexcept;
	template <class ST, class SA>
	explicit basic_regex(const basic_string<charT, ST, SA>& p,
	flag_type f = regex_constants::ECMAScript);
	template <class ForwardIterator>
	basic_regex(ForwardIterator first, ForwardIterator last,
	flag_type f = regex_constants::ECMAScript);
	basic_regex(initializer_list<charT>, flag_type = regex_constants::ECMAScript);

	~basic_regex();

	basic_regex& operator=(const basic_regex&);
	basic_regex& operator=(basic_regex&&) noexcept;
	basic_regex& operator=(const charT* ptr);
	basic_regex& operator=(initializer_list<charT> il);
	template <class ST, class SA>
	basic_regex& operator=(const basic_string<charT, ST, SA>& p);

	// assign:
	basic_regex& assign(const basic_regex& that);
	basic_regex& assign(basic_regex&& that) noexcept;
	basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript);
	basic_regex& assign(const charT* p, size_t len, flag_type f);
	template <class string_traits, class A>
	basic_regex& assign(const basic_string<charT, string_traits, A>& s,
	flag_type f = regex_constants::ECMAScript);
	template <class InputIterator>
	basic_regex& assign(InputIterator first, InputIterator last,
	flag_type f = regex_constants::ECMAScript);
	basic_regex& assign(initializer_list<charT>, flag_type = regex_constants::ECMAScript);

	// const operations:
	unsigned mark_count() const;
	flag_type flags() const;

	// locale:
	locale_type imbue(locale_type loc);
	locale_type getloc() const;

	// swap:
	void swap(basic_regex&);
	};

	+template<class ForwardIterator>
	+basic_regex(ForwardIterator, ForwardIterator,
	+ regex_constants::syntax_option_type = regex_constants::ECMAScript)
	+ -> basic_regex<typename iterator_traits<ForwardIterator>::value_type>; // C++17
	+
	typedef basic_regex<char> regex;
	typedef basic_regex<wchar_t> wregex;

	template <class charT, class traits>
	void swap(basic_regex<charT, traits>& e1, basic_regex<charT, traits>& e2);

	template <class BidirectionalIterator>
	class sub_match
	: public pair<BidirectionalIterator, BidirectionalIterator>
	{
	public:
	typedef typename iterator_traits<BidirectionalIterator>::value_type value_type;
	typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
	typedef BidirectionalIterator iterator;
	typedef basic_string<value_type> string_type;

	bool matched;

	constexpr sub_match();

	difference_type length() const;
	operator string_type() const;
	string_type str() const;

	int compare(const sub_match& s) const;
	int compare(const string_type& s) const;
	int compare(const value_type* s) const;
	};

	typedef sub_match<const char*> csub_match;
	typedef sub_match<const wchar_t*> wcsub_match;
	typedef sub_match<string::const_iterator> ssub_match;
	typedef sub_match<wstring::const_iterator> wssub_match;

	template <class BiIter>
	bool
	operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator<(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator<=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator>=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);

	template <class BiIter, class ST, class SA>
	bool
	operator==(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter, class ST, class SA>
	bool
	operator!=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter, class ST, class SA>
	bool
	operator<(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter, class ST, class SA>
	bool
	operator>(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter, class ST, class SA>
	bool operator>=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter, class ST, class SA>
	bool
	operator<=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter, class ST, class SA>
	bool
	operator==(const sub_match<BiIter>& lhs,
	const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

	template <class BiIter, class ST, class SA>
	bool
	operator!=(const sub_match<BiIter>& lhs,
	const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

	template <class BiIter, class ST, class SA>
	bool
	operator<(const sub_match<BiIter>& lhs,
	const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

	template <class BiIter, class ST, class SA>
	bool operator>(const sub_match<BiIter>& lhs,
	const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

	template <class BiIter, class ST, class SA>
	bool
	operator>=(const sub_match<BiIter>& lhs,
	const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

	template <class BiIter, class ST, class SA>
	bool
	operator<=(const sub_match<BiIter>& lhs,
	const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

	template <class BiIter>
	bool
	operator==(typename iterator_traits<BiIter>::value_type const* lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator!=(typename iterator_traits<BiIter>::value_type const* lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator<(typename iterator_traits<BiIter>::value_type const* lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator>(typename iterator_traits<BiIter>::value_type const* lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator>=(typename iterator_traits<BiIter>::value_type const* lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator<=(typename iterator_traits<BiIter>::value_type const* lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator==(const sub_match<BiIter>& lhs,
	typename iterator_traits<BiIter>::value_type const* rhs);

	template <class BiIter>
	bool
	operator!=(const sub_match<BiIter>& lhs,
	typename iterator_traits<BiIter>::value_type const* rhs);

	template <class BiIter>
	bool
	operator<(const sub_match<BiIter>& lhs,
	typename iterator_traits<BiIter>::value_type const* rhs);

	template <class BiIter>
	bool
	operator>(const sub_match<BiIter>& lhs,
	typename iterator_traits<BiIter>::value_type const* rhs);

	template <class BiIter>
	bool
	operator>=(const sub_match<BiIter>& lhs,
	typename iterator_traits<BiIter>::value_type const* rhs);

	template <class BiIter>
	bool
	operator<=(const sub_match<BiIter>& lhs,
	typename iterator_traits<BiIter>::value_type const* rhs);

	template <class BiIter>
	bool
	operator==(typename iterator_traits<BiIter>::value_type const& lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator!=(typename iterator_traits<BiIter>::value_type const& lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator<(typename iterator_traits<BiIter>::value_type const& lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator>(typename iterator_traits<BiIter>::value_type const& lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator>=(typename iterator_traits<BiIter>::value_type const& lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator<=(typename iterator_traits<BiIter>::value_type const& lhs,
	const sub_match<BiIter>& rhs);

	template <class BiIter>
	bool
	operator==(const sub_match<BiIter>& lhs,
	typename iterator_traits<BiIter>::value_type const& rhs);

	template <class BiIter>
	bool
	operator!=(const sub_match<BiIter>& lhs,
	typename iterator_traits<BiIter>::value_type const& rhs);

	template <class BiIter>
	bool
	operator<(const sub_match<BiIter>& lhs,
	typename iterator_traits<BiIter>::value_type const& rhs);

	template <class BiIter>
	bool
	operator>(const sub_match<BiIter>& lhs,
	typename iterator_traits<BiIter>::value_type const& rhs);

	template <class BiIter>
	bool
	operator>=(const sub_match<BiIter>& lhs,
	typename iterator_traits<BiIter>::value_type const& rhs);

	template <class BiIter>
	bool
	operator<=(const sub_match<BiIter>& lhs,
	typename iterator_traits<BiIter>::value_type const& rhs);

	template <class charT, class ST, class BiIter>
	basic_ostream<charT, ST>&
	operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);

	template <class BidirectionalIterator,
	class Allocator = allocator<sub_match<BidirectionalIterator>>>
	class match_results
	{
	public:
	typedef sub_match<BidirectionalIterator> value_type;
	typedef const value_type& const_reference;
	typedef value_type& reference;
	typedef /implementation-defined/ const_iterator;
	typedef const_iterator iterator;
	typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
	typedef typename allocator_traits<Allocator>::size_type size_type;
	typedef Allocator allocator_type;
	typedef typename iterator_traits<BidirectionalIterator>::value_type char_type;
	typedef basic_string<char_type> string_type;

	// construct/copy/destroy:
	explicit match_results(const Allocator& a = Allocator());
	match_results(const match_results& m);
	match_results(match_results&& m) noexcept;
	match_results& operator=(const match_results& m);
	match_results& operator=(match_results&& m);
	~match_results();

	bool ready() const;

	// size:
	size_type size() const;
	size_type max_size() const;
	bool empty() const;

	// element access:
	difference_type length(size_type sub = 0) const;
	difference_type position(size_type sub = 0) const;
	string_type str(size_type sub = 0) const;
	const_reference operator[](size_type n) const;

	const_reference prefix() const;
	const_reference suffix() const;

	const_iterator begin() const;
	const_iterator end() const;
	const_iterator cbegin() const;
	const_iterator cend() const;

	// format:
	template <class OutputIter>
	OutputIter
	format(OutputIter out, 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>
	OutputIter
	format(OutputIter out, const basic_string<char_type, ST, SA>& fmt,
	regex_constants::match_flag_type flags = regex_constants::format_default) const;
	template <class ST, class SA>
	basic_string<char_type, ST, SA>
	format(const basic_string<char_type, ST, SA>& fmt,
	regex_constants::match_flag_type flags = regex_constants::format_default) const;
	string_type
	format(const char_type* fmt,
	regex_constants::match_flag_type flags = regex_constants::format_default) const;

	// allocator:
	allocator_type get_allocator() const;

	// swap:
	void swap(match_results& that);
	};

	typedef match_results<const char*> cmatch;
	typedef match_results<const wchar_t*> wcmatch;
	typedef match_results<string::const_iterator> smatch;
	typedef match_results<wstring::const_iterator> wsmatch;

	template <class BidirectionalIterator, class Allocator>
	bool
	operator==(const match_results<BidirectionalIterator, Allocator>& m1,
	const match_results<BidirectionalIterator, Allocator>& m2);

	template <class BidirectionalIterator, class Allocator>
	bool
	operator!=(const match_results<BidirectionalIterator, Allocator>& m1,
	const match_results<BidirectionalIterator, Allocator>& m2);

	template <class BidirectionalIterator, class Allocator>
	void
	swap(match_results<BidirectionalIterator, Allocator>& m1,
	match_results<BidirectionalIterator, Allocator>& m2);

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

	template <class BidirectionalIterator, class charT, class traits>
	bool
	regex_match(BidirectionalIterator first, BidirectionalIterator last,
	const basic_regex<charT, traits>& e,
	regex_constants::match_flag_type flags = regex_constants::match_default);

	template <class charT, class Allocator, class traits>
	bool
	regex_match(const charT* str, match_results<const charT*, Allocator>& m,
	const basic_regex<charT, traits>& e,
	regex_constants::match_flag_type flags = regex_constants::match_default);

	template <class ST, class SA, class Allocator, class charT, class traits>
	bool
	regex_match(const basic_string<charT, ST, SA>& s,
	match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
	const basic_regex<charT, traits>& e,
	regex_constants::match_flag_type flags = regex_constants::match_default);

	template <class ST, class SA, class Allocator, class charT, class traits>
	bool
	regex_match(const basic_string<charT, ST, SA>&& s,
	match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
	const basic_regex<charT, traits>& e,
	regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // C++14

	template <class charT, class traits>
	bool
	regex_match(const charT* str, const basic_regex<charT, traits>& e,
	regex_constants::match_flag_type flags = regex_constants::match_default);

	template <class ST, class SA, class charT, class traits>
	bool
	regex_match(const basic_string<charT, ST, SA>& s,
	const basic_regex<charT, traits>& e,
	regex_constants::match_flag_type flags = regex_constants::match_default);

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

	template <class BidirectionalIterator, class charT, class traits>
	bool
	regex_search(BidirectionalIterator first, BidirectionalIterator last,
	const basic_regex<charT, traits>& e,
	regex_constants::match_flag_type flags = regex_constants::match_default);

	template <class charT, class Allocator, class traits>
	bool
	regex_search(const charT* str, match_results<const charT*, Allocator>& m,
	const basic_regex<charT, traits>& e,
	regex_constants::match_flag_type flags = regex_constants::match_default);

	template <class charT, class traits>
	bool
	regex_search(const charT* str, const basic_regex<charT, traits>& e,
	regex_constants::match_flag_type flags = regex_constants::match_default);

	template <class ST, class SA, class charT, class traits>
	bool
	regex_search(const basic_string<charT, ST, SA>& s,
	const basic_regex<charT, traits>& e,
	regex_constants::match_flag_type flags = regex_constants::match_default);

	template <class ST, class SA, class Allocator, class charT, class traits>
	bool
	regex_search(const basic_string<charT, ST, SA>& s,
	match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
	const basic_regex<charT, traits>& e,
	regex_constants::match_flag_type flags = regex_constants::match_default);

	template <class ST, class SA, class Allocator, class charT, class traits>
	bool
	regex_search(const basic_string<charT, ST, SA>&& s,
	match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
	const basic_regex<charT, traits>& e,
	regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // C++14

	template <class OutputIterator, class BidirectionalIterator,
	class traits, class charT, class ST, class SA>
	OutputIterator
	regex_replace(OutputIterator out,
	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);

	template <class OutputIterator, class BidirectionalIterator,
	class traits, class charT>
	OutputIterator
	regex_replace(OutputIterator out,
	BidirectionalIterator first, BidirectionalIterator last,
	const basic_regex<charT, traits>& e, const charT* fmt,
	regex_constants::match_flag_type flags = regex_constants::match_default);

	template <class traits, class charT, class ST, class SA, class FST, class FSA>>
	basic_string<charT, ST, SA>
	regex_replace(const basic_string<charT, ST, SA>& s,
	const basic_regex<charT, traits>& e,
	const basic_string<charT, FST, FSA>& fmt,
	regex_constants::match_flag_type flags = regex_constants::match_default);

	template <class traits, class charT, class ST, class SA>
	basic_string<charT, ST, SA>
	regex_replace(const basic_string<charT, ST, SA>& s,
	const basic_regex<charT, traits>& e, const charT* fmt,
	regex_constants::match_flag_type flags = regex_constants::match_default);

	template <class traits, class charT, class ST, class SA>
	basic_string<charT>
	regex_replace(const charT* s,
	const basic_regex<charT, traits>& e,
	const basic_string<charT, ST, SA>& fmt,
	regex_constants::match_flag_type flags = regex_constants::match_default);

	template <class traits, class charT>
	basic_string<charT>
	regex_replace(const charT* s,
	const basic_regex<charT, traits>& e,
	const charT* fmt,
	regex_constants::match_flag_type flags = regex_constants::match_default);

	template <class BidirectionalIterator,
	class charT = typename iterator_traits< BidirectionalIterator>::value_type,
	class traits = regex_traits<charT>>
	class regex_iterator
	{
	public:
	typedef basic_regex<charT, traits> regex_type;
	typedef match_results<BidirectionalIterator> value_type;
	typedef ptrdiff_t difference_type;
	typedef const value_type* pointer;
	typedef const value_type& reference;
	typedef forward_iterator_tag iterator_category;

	regex_iterator();
	regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
	const regex_type& re,
	regex_constants::match_flag_type m = regex_constants::match_default);
	regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
	const regex_type&& __re,
	regex_constants::match_flag_type __m
	= regex_constants::match_default) = delete; // C++14
	regex_iterator(const regex_iterator&);
	regex_iterator& operator=(const regex_iterator&);

	bool operator==(const regex_iterator&) const;
	bool operator!=(const regex_iterator&) const;

	const value_type& operator*() const;
	const value_type* operator->() const;

	regex_iterator& operator++();
	regex_iterator operator++(int);
	};

	typedef regex_iterator<const char*> cregex_iterator;
	typedef regex_iterator<const wchar_t*> wcregex_iterator;
	typedef regex_iterator<string::const_iterator> sregex_iterator;
	typedef regex_iterator<wstring::const_iterator> wsregex_iterator;

	template <class BidirectionalIterator,
	class charT = typename iterator_traits< BidirectionalIterator>::value_type,
	class traits = regex_traits<charT>>
	class regex_token_iterator
	{
	public:
	typedef basic_regex<charT, traits> regex_type;
	typedef sub_match<BidirectionalIterator> value_type;
	typedef ptrdiff_t difference_type;
	typedef const value_type* pointer;
	typedef const value_type& reference;
	typedef forward_iterator_tag iterator_category;

	regex_token_iterator();
	regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
	const regex_type& re, int submatch = 0,
	regex_constants::match_flag_type m = regex_constants::match_default);
	regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
	const regex_type&& re, int submatch = 0,
	regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
	regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
	const regex_type& re, const vector<int>& submatches,
	regex_constants::match_flag_type m = regex_constants::match_default);
	regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
	const regex_type&& re, const vector<int>& submatches,
	regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
	regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
	const regex_type& re, initializer_list<int> submatches,
	regex_constants::match_flag_type m = regex_constants::match_default);
	regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
	const regex_type&& re, initializer_list<int> submatches,
	regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
	template <size_t N>
	regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
	const regex_type& re, const int (&submatches)[N],
	regex_constants::match_flag_type m = regex_constants::match_default);
	template <size_t N>
	regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
	const regex_type& re, const int (&submatches)[N],
	regex_constants::match_flag_type m = regex_constants::match_default) = delete // C++14;
	regex_token_iterator(const regex_token_iterator&);
	regex_token_iterator& operator=(const regex_token_iterator&);

	bool operator==(const regex_token_iterator&) const;
	bool operator!=(const regex_token_iterator&) const;

	const value_type& operator*() const;
	const value_type* operator->() const;

	regex_token_iterator& operator++();
	regex_token_iterator operator++(int);
	};

	typedef regex_token_iterator<const char*> cregex_token_iterator;
	typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
	typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
	typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;

	} // std
	*/

	#include <__config>
	#include <stdexcept>
	#include <__locale>
	#include <initializer_list>
	#include <utility>
	#include <iterator>
	#include <string>
	#include <memory>
	#include <vector>
	#include <deque>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	#define _LIBCPP_REGEX_COMPLEXITY_FACTOR 4096

	_LIBCPP_BEGIN_NAMESPACE_STD

	namespace regex_constants
	{

	// syntax_option_type

	enum syntax_option_type
	{
	icase = 1 << 0,
	nosubs = 1 << 1,
	optimize = 1 << 2,
	collate = 1 << 3,
	ECMAScript = 0,
	basic = 1 << 4,
	extended = 1 << 5,
	awk = 1 << 6,
	grep = 1 << 7,
	egrep = 1 << 8
	};

	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	syntax_option_type
	operator~(syntax_option_type __x)
	{
	return syntax_option_type(~int(__x) & 0x1FF);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	syntax_option_type
	operator&(syntax_option_type __x, syntax_option_type __y)
	{
	return syntax_option_type(int(__x) & int(__y));
	}

	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	syntax_option_type
	operator\|(syntax_option_type __x, syntax_option_type __y)
	{
	return syntax_option_type(int(__x) \| int(__y));
	}

	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	syntax_option_type
	operator^(syntax_option_type __x, syntax_option_type __y)
	{
	return syntax_option_type(int(__x) ^ int(__y));
	}

	inline _LIBCPP_INLINE_VISIBILITY
	syntax_option_type&
	operator&=(syntax_option_type& __x, syntax_option_type __y)
	{
	__x = __x & __y;
	return __x;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	syntax_option_type&
	operator\|=(syntax_option_type& __x, syntax_option_type __y)
	{
	__x = __x \| __y;
	return __x;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	syntax_option_type&
	operator^=(syntax_option_type& __x, syntax_option_type __y)
	{
	__x = __x ^ __y;
	return __x;
	}

	// match_flag_type

	enum match_flag_type
	{
	match_default = 0,
	match_not_bol = 1 << 0,
	match_not_eol = 1 << 1,
	match_not_bow = 1 << 2,
	match_not_eow = 1 << 3,
	match_any = 1 << 4,
	match_not_null = 1 << 5,
	match_continuous = 1 << 6,
	match_prev_avail = 1 << 7,
	format_default = 0,
	format_sed = 1 << 8,
	format_no_copy = 1 << 9,
	format_first_only = 1 << 10,
	__no_update_pos = 1 << 11,
	__full_match = 1 << 12
	};

	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	match_flag_type
	operator~(match_flag_type __x)
	{
	return match_flag_type(~int(__x) & 0x0FFF);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	match_flag_type
	operator&(match_flag_type __x, match_flag_type __y)
	{
	return match_flag_type(int(__x) & int(__y));
	}

	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	match_flag_type
	operator\|(match_flag_type __x, match_flag_type __y)
	{
	return match_flag_type(int(__x) \| int(__y));
	}

	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR
	match_flag_type
	operator^(match_flag_type __x, match_flag_type __y)
	{
	return match_flag_type(int(__x) ^ int(__y));
	}

	inline _LIBCPP_INLINE_VISIBILITY
	match_flag_type&
	operator&=(match_flag_type& __x, match_flag_type __y)
	{
	__x = __x & __y;
	return __x;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	match_flag_type&
	operator\|=(match_flag_type& __x, match_flag_type __y)
	{
	__x = __x \| __y;
	return __x;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	match_flag_type&
	operator^=(match_flag_type& __x, match_flag_type __y)
	{
	__x = __x ^ __y;
	return __x;
	}

	enum error_type
	{
	error_collate = 1,
	error_ctype,
	error_escape,
	error_backref,
	error_brack,
	error_paren,
	error_brace,
	error_badbrace,
	error_range,
	error_space,
	error_badrepeat,
	error_complexity,
	error_stack,
	__re_err_grammar,
	__re_err_empty,
	__re_err_unknown
	};

	} // regex_constants

	class _LIBCPP_EXCEPTION_ABI regex_error
	: public runtime_error
	{
	regex_constants::error_type __code_;
	public:
	explicit regex_error(regex_constants::error_type __ecode);
	virtual ~regex_error() throw();
	_LIBCPP_INLINE_VISIBILITY
	regex_constants::error_type code() const {return __code_;}
	};

	template <regex_constants::error_type _Ev>
	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
	void __throw_regex_error()
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw regex_error(_Ev);
	#else
	_VSTD::abort();
	#endif
	}

	template <class _CharT>
	struct _LIBCPP_TEMPLATE_VIS regex_traits
	{
	public:
	typedef _CharT char_type;
	typedef basic_string<char_type> string_type;
	typedef locale locale_type;
	typedef ctype_base::mask char_class_type;

	#if defined(__mips__) && defined(__GLIBC__)
	static const char_class_type __regex_word = static_cast<char_class_type>(_ISbit(15));
	#else
	static const char_class_type __regex_word = 0x80;
	#endif

	private:
	locale __loc_;
	const ctype<char_type>* __ct_;
	const collate<char_type>* __col_;

	public:
	regex_traits();

	_LIBCPP_INLINE_VISIBILITY
	static size_t length(const char_type* __p)
	{return char_traits<char_type>::length(__p);}
	_LIBCPP_INLINE_VISIBILITY
	char_type translate(char_type __c) const {return __c;}
	char_type translate_nocase(char_type __c) const;
	template <class _ForwardIterator>
	string_type
	transform(_ForwardIterator __f, _ForwardIterator __l) const;
	template <class _ForwardIterator>
	_LIBCPP_INLINE_VISIBILITY
	string_type
	transform_primary( _ForwardIterator __f, _ForwardIterator __l) const
	{return __transform_primary(__f, __l, char_type());}
	template <class _ForwardIterator>
	_LIBCPP_INLINE_VISIBILITY
	string_type
	lookup_collatename(_ForwardIterator __f, _ForwardIterator __l) const
	{return __lookup_collatename(__f, __l, char_type());}
	template <class _ForwardIterator>
	_LIBCPP_INLINE_VISIBILITY
	char_class_type
	lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
	bool __icase = false) const
	{return __lookup_classname(__f, __l, __icase, char_type());}
	bool isctype(char_type __c, char_class_type __m) const;
	_LIBCPP_INLINE_VISIBILITY
	int value(char_type __ch, int __radix) const
	{return __regex_traits_value(__ch, __radix);}
	locale_type imbue(locale_type __l);
	_LIBCPP_INLINE_VISIBILITY
	locale_type getloc()const {return __loc_;}

	private:
	void __init();

	template <class _ForwardIterator>
	string_type
	__transform_primary(_ForwardIterator __f, _ForwardIterator __l, char) const;
	template <class _ForwardIterator>
	string_type
	__transform_primary(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;

	template <class _ForwardIterator>
	string_type
	__lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, char) const;
	template <class _ForwardIterator>
	string_type
	__lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;

	template <class _ForwardIterator>
	char_class_type
	__lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
	bool __icase, char) const;
	template <class _ForwardIterator>
	char_class_type
	__lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
	bool __icase, wchar_t) const;

	static int __regex_traits_value(unsigned char __ch, int __radix);
	_LIBCPP_INLINE_VISIBILITY
	int __regex_traits_value(char __ch, int __radix) const
	{return __regex_traits_value(static_cast<unsigned char>(__ch), __radix);}
	_LIBCPP_INLINE_VISIBILITY
	int __regex_traits_value(wchar_t __ch, int __radix) const;
	};

	template <class _CharT>
	const typename regex_traits<_CharT>::char_class_type
	regex_traits<_CharT>::__regex_word;

	template <class _CharT>
	regex_traits<_CharT>::regex_traits()
	{
	__init();
	}

	template <class _CharT>
	typename regex_traits<_CharT>::char_type
	regex_traits<_CharT>::translate_nocase(char_type __c) const
	{
	return __ct_->tolower(__c);
	}

	template <class _CharT>
	template <class _ForwardIterator>
	typename regex_traits<_CharT>::string_type
	regex_traits<_CharT>::transform(_ForwardIterator __f, _ForwardIterator __l) const
	{
	string_type __s(__f, __l);
	return __col_->transform(__s.data(), __s.data() + __s.size());
	}

	template <class _CharT>
	void
	regex_traits<_CharT>::__init()
	{
	__ct_ = &use_facet<ctype<char_type> >(__loc_);
	__col_ = &use_facet<collate<char_type> >(__loc_);
	}

	template <class _CharT>
	typename regex_traits<_CharT>::locale_type
	regex_traits<_CharT>::imbue(locale_type __l)
	{
	locale __r = __loc_;
	__loc_ = __l;
	__init();
	return __r;
	}

	// transform_primary is very FreeBSD-specific

	template <class _CharT>
	template <class _ForwardIterator>
	typename regex_traits<_CharT>::string_type
	regex_traits<_CharT>::__transform_primary(_ForwardIterator __f,
	_ForwardIterator __l, char) const
	{
	const string_type __s(__f, __l);
	string_type __d = __col_->transform(__s.data(), __s.data() + __s.size());
	switch (__d.size())
	{
	case 1:
	break;
	case 12:
	__d[11] = __d[3];
	break;
	default:
	__d.clear();
	break;
	}
	return __d;
	}

	template <class _CharT>
	template <class _ForwardIterator>
	typename regex_traits<_CharT>::string_type
	regex_traits<_CharT>::__transform_primary(_ForwardIterator __f,
	_ForwardIterator __l, wchar_t) const
	{
	const string_type __s(__f, __l);
	string_type __d = __col_->transform(__s.data(), __s.data() + __s.size());
	switch (__d.size())
	{
	case 1:
	break;
	case 3:
	__d[2] = __d[0];
	break;
	default:
	__d.clear();
	break;
	}
	return __d;
	}

	// lookup_collatename is very FreeBSD-specific

	_LIBCPP_FUNC_VIS string __get_collation_name(const char* __s);

	template <class _CharT>
	template <class _ForwardIterator>
	typename regex_traits<_CharT>::string_type
	regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f,
	_ForwardIterator __l, char) const
	{
	string_type __s(__f, __l);
	string_type __r;
	if (!__s.empty())
	{
	__r = __get_collation_name(__s.c_str());
	if (__r.empty() && __s.size() <= 2)
	{
	__r = __col_->transform(__s.data(), __s.data() + __s.size());
	if (__r.size() == 1 \|\| __r.size() == 12)
	__r = __s;
	else
	__r.clear();
	}
	}
	return __r;
	}

	template <class _CharT>
	template <class _ForwardIterator>
	typename regex_traits<_CharT>::string_type
	regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f,
	_ForwardIterator __l, wchar_t) const
	{
	string_type __s(__f, __l);
	string __n;
	__n.reserve(__s.size());
	for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end();
	__i != __e; ++__i)
	{
	if (static_cast<unsigned>(*__i) >= 127)
	return string_type();
	__n.push_back(char(*__i));
	}
	string_type __r;
	if (!__s.empty())
	{
	__n = __get_collation_name(__n.c_str());
	if (!__n.empty())
	__r.assign(__n.begin(), __n.end());
	else if (__s.size() <= 2)
	{
	__r = __col_->transform(__s.data(), __s.data() + __s.size());
	if (__r.size() == 1 \|\| __r.size() == 3)
	__r = __s;
	else
	__r.clear();
	}
	}
	return __r;
	}

	// lookup_classname

	regex_traits<char>::char_class_type _LIBCPP_FUNC_VIS
	__get_classname(const char* __s, bool __icase);

	template <class _CharT>
	template <class _ForwardIterator>
	typename regex_traits<_CharT>::char_class_type
	regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f,
	_ForwardIterator __l,
	bool __icase, char) const
	{
	string_type __s(__f, __l);
	__ct_->tolower(&__s[0], &__s[0] + __s.size());
	return __get_classname(__s.c_str(), __icase);
	}

	template <class _CharT>
	template <class _ForwardIterator>
	typename regex_traits<_CharT>::char_class_type
	regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f,
	_ForwardIterator __l,
	bool __icase, wchar_t) const
	{
	string_type __s(__f, __l);
	__ct_->tolower(&__s[0], &__s[0] + __s.size());
	string __n;
	__n.reserve(__s.size());
	for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end();
	__i != __e; ++__i)
	{
	if (static_cast<unsigned>(*__i) >= 127)
	return char_class_type();
	__n.push_back(char(*__i));
	}
	return __get_classname(__n.c_str(), __icase);
	}

	template <class _CharT>
	bool
	regex_traits<_CharT>::isctype(char_type __c, char_class_type __m) const
	{
	if (__ct_->is(__m, __c))
	return true;
	return (__c == '_' && (__m & __regex_word));
	}

	template <class _CharT>
	int
	regex_traits<_CharT>::__regex_traits_value(unsigned char __ch, int __radix)
	{
	if ((__ch & 0xF8u) == 0x30) // '0' <= __ch && __ch <= '7'
	return __ch - '0';
	if (__radix != 8)
	{
	if ((__ch & 0xFEu) == 0x38) // '8' <= __ch && __ch <= '9'
	return __ch - '0';
	if (__radix == 16)
	{
	__ch \|= 0x20; // tolower
	if ('a' <= __ch && __ch <= 'f')
	return __ch - ('a' - 10);
	}
	}
	return -1;
	}

	template <class _CharT>
	inline
	int
	regex_traits<_CharT>::__regex_traits_value(wchar_t __ch, int __radix) const
	{
	return __regex_traits_value(static_cast<unsigned char>(__ct_->narrow(__ch, char_type())), __radix);
	}

	template <class _CharT> class __node;

	template <class _BidirectionalIterator> class _LIBCPP_TEMPLATE_VIS sub_match;

	template <class _BidirectionalIterator,
	class _Allocator = allocator<sub_match<_BidirectionalIterator> > >
	class _LIBCPP_TEMPLATE_VIS match_results;

	template <class _CharT>
	struct __state
	{
	enum
	{
	__end_state = -1000,
	__consume_input, // -999
	__begin_marked_expr, // -998
	__end_marked_expr, // -997
	__pop_state, // -996
	__accept_and_consume, // -995
	__accept_but_not_consume, // -994
	__reject, // -993
	__split,
	__repeat
	};

	int __do_;
	const _CharT* __first_;
	const _CharT* __current_;
	const _CharT* __last_;
	vector<sub_match<const _CharT*> > __sub_matches_;
	vector<pair<size_t, const _CharT*> > __loop_data_;
	const __node<_CharT>* __node_;
	regex_constants::match_flag_type __flags_;
	bool __at_first_;

	_LIBCPP_INLINE_VISIBILITY
	__state()
	: __do_(0), __first_(nullptr), __current_(nullptr), __last_(nullptr),
	__node_(nullptr), __flags_() {}
	};

	// __node

	template <class _CharT>
	class __node
	{
	__node(const __node&);
	__node& operator=(const __node&);
	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	__node() {}
	_LIBCPP_INLINE_VISIBILITY
	virtual ~__node() {}

	_LIBCPP_INLINE_VISIBILITY
	virtual void __exec(__state&) const {};
	_LIBCPP_INLINE_VISIBILITY
	virtual void __exec_split(bool, __state&) const {};
	};

	// __end_state

	template <class _CharT>
	class __end_state
	: public __node<_CharT>
	{
	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	__end_state() {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT>
	void
	__end_state<_CharT>::__exec(__state& __s) const
	{
	__s.__do_ = __state::__end_state;
	}

	// __has_one_state

	template <class _CharT>
	class __has_one_state
	: public __node<_CharT>
	{
	__node<_CharT>* __first_;

	public:
	_LIBCPP_INLINE_VISIBILITY
	explicit __has_one_state(__node<_CharT>* __s)
	: __first_(__s) {}

	_LIBCPP_INLINE_VISIBILITY
	__node<_CharT>* first() const {return __first_;}
	_LIBCPP_INLINE_VISIBILITY
	__node<_CharT>*& first() {return __first_;}
	};

	// __owns_one_state

	template <class _CharT>
	class __owns_one_state
	: public __has_one_state<_CharT>
	{
	typedef __has_one_state<_CharT> base;

	public:
	_LIBCPP_INLINE_VISIBILITY
	explicit __owns_one_state(__node<_CharT>* __s)
	: base(__s) {}

	virtual ~__owns_one_state();
	};

	template <class _CharT>
	__owns_one_state<_CharT>::~__owns_one_state()
	{
	delete this->first();
	}

	// __empty_state

	template <class _CharT>
	class __empty_state
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;

	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	explicit __empty_state(__node<_CharT>* __s)
	: base(__s) {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT>
	void
	__empty_state<_CharT>::__exec(__state& __s) const
	{
	__s.__do_ = __state::__accept_but_not_consume;
	__s.__node_ = this->first();
	}

	// __empty_non_own_state

	template <class _CharT>
	class __empty_non_own_state
	: public __has_one_state<_CharT>
	{
	typedef __has_one_state<_CharT> base;

	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	explicit __empty_non_own_state(__node<_CharT>* __s)
	: base(__s) {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT>
	void
	__empty_non_own_state<_CharT>::__exec(__state& __s) const
	{
	__s.__do_ = __state::__accept_but_not_consume;
	__s.__node_ = this->first();
	}

	// __repeat_one_loop

	template <class _CharT>
	class __repeat_one_loop
	: public __has_one_state<_CharT>
	{
	typedef __has_one_state<_CharT> base;

	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	explicit __repeat_one_loop(__node<_CharT>* __s)
	: base(__s) {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT>
	void
	__repeat_one_loop<_CharT>::__exec(__state& __s) const
	{
	__s.__do_ = __state::__repeat;
	__s.__node_ = this->first();
	}

	// __owns_two_states

	template <class _CharT>
	class __owns_two_states
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;

	base* __second_;

	public:
	_LIBCPP_INLINE_VISIBILITY
	explicit __owns_two_states(__node<_CharT>* __s1, base* __s2)
	: base(__s1), __second_(__s2) {}

	virtual ~__owns_two_states();

	_LIBCPP_INLINE_VISIBILITY
	base* second() const {return __second_;}
	_LIBCPP_INLINE_VISIBILITY
	base*& second() {return __second_;}
	};

	template <class _CharT>
	__owns_two_states<_CharT>::~__owns_two_states()
	{
	delete __second_;
	}

	// __loop

	template <class _CharT>
	class __loop
	: public __owns_two_states<_CharT>
	{
	typedef __owns_two_states<_CharT> base;

	size_t __min_;
	size_t __max_;
	unsigned __loop_id_;
	unsigned __mexp_begin_;
	unsigned __mexp_end_;
	bool __greedy_;

	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	explicit __loop(unsigned __loop_id,
	__node<_CharT>* __s1, __owns_one_state<_CharT>* __s2,
	unsigned __mexp_begin, unsigned __mexp_end,
	bool __greedy = true,
	size_t __min = 0,
	size_t __max = numeric_limits<size_t>::max())
	: base(__s1, __s2), __min_(__min), __max_(__max), __loop_id_(__loop_id),
	__mexp_begin_(__mexp_begin), __mexp_end_(__mexp_end),
	__greedy_(__greedy) {}

	virtual void __exec(__state& __s) const;
	virtual void __exec_split(bool __second, __state& __s) const;

	private:
	_LIBCPP_INLINE_VISIBILITY
	void __init_repeat(__state& __s) const
	{
	__s.__loop_data_[__loop_id_].second = __s.__current_;
	for (size_t __i = __mexp_begin_-1; __i != __mexp_end_-1; ++__i)
	{
	__s.__sub_matches_[__i].first = __s.__last_;
	__s.__sub_matches_[__i].second = __s.__last_;
	__s.__sub_matches_[__i].matched = false;
	}
	}
	};

	template <class _CharT>
	void
	__loop<_CharT>::__exec(__state& __s) const
	{
	if (__s.__do_ == __state::__repeat)
	{
	bool __do_repeat = ++__s.__loop_data_[__loop_id_].first < __max_;
	bool __do_alt = __s.__loop_data_[__loop_id_].first >= __min_;
	if (__do_repeat && __do_alt &&
	__s.__loop_data_[__loop_id_].second == __s.__current_)
	__do_repeat = false;
	if (__do_repeat && __do_alt)
	__s.__do_ = __state::__split;
	else if (__do_repeat)
	{
	__s.__do_ = __state::__accept_but_not_consume;
	__s.__node_ = this->first();
	__init_repeat(__s);
	}
	else
	{
	__s.__do_ = __state::__accept_but_not_consume;
	__s.__node_ = this->second();
	}
	}
	else
	{
	__s.__loop_data_[__loop_id_].first = 0;
	bool __do_repeat = 0 < __max_;
	bool __do_alt = 0 >= __min_;
	if (__do_repeat && __do_alt)
	__s.__do_ = __state::__split;
	else if (__do_repeat)
	{
	__s.__do_ = __state::__accept_but_not_consume;
	__s.__node_ = this->first();
	__init_repeat(__s);
	}
	else
	{
	__s.__do_ = __state::__accept_but_not_consume;
	__s.__node_ = this->second();
	}
	}
	}

	template <class _CharT>
	void
	__loop<_CharT>::__exec_split(bool __second, __state& __s) const
	{
	__s.__do_ = __state::__accept_but_not_consume;
	if (__greedy_ != __second)
	{
	__s.__node_ = this->first();
	__init_repeat(__s);
	}
	else
	__s.__node_ = this->second();
	}

	// __alternate

	template <class _CharT>
	class __alternate
	: public __owns_two_states<_CharT>
	{
	typedef __owns_two_states<_CharT> base;

	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	explicit __alternate(__owns_one_state<_CharT>* __s1,
	__owns_one_state<_CharT>* __s2)
	: base(__s1, __s2) {}

	virtual void __exec(__state& __s) const;
	virtual void __exec_split(bool __second, __state& __s) const;
	};

	template <class _CharT>
	void
	__alternate<_CharT>::__exec(__state& __s) const
	{
	__s.__do_ = __state::__split;
	}

	template <class _CharT>
	void
	__alternate<_CharT>::__exec_split(bool __second, __state& __s) const
	{
	__s.__do_ = __state::__accept_but_not_consume;
	if (__second)
	__s.__node_ = this->second();
	else
	__s.__node_ = this->first();
	}

	// __begin_marked_subexpression

	template <class _CharT>
	class __begin_marked_subexpression
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;

	unsigned __mexp_;
	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	explicit __begin_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
	: base(__s), __mexp_(__mexp) {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT>
	void
	__begin_marked_subexpression<_CharT>::__exec(__state& __s) const
	{
	__s.__do_ = __state::__accept_but_not_consume;
	__s.__sub_matches_[__mexp_-1].first = __s.__current_;
	__s.__node_ = this->first();
	}

	// __end_marked_subexpression

	template <class _CharT>
	class __end_marked_subexpression
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;

	unsigned __mexp_;
	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	explicit __end_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
	: base(__s), __mexp_(__mexp) {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT>
	void
	__end_marked_subexpression<_CharT>::__exec(__state& __s) const
	{
	__s.__do_ = __state::__accept_but_not_consume;
	__s.__sub_matches_[__mexp_-1].second = __s.__current_;
	__s.__sub_matches_[__mexp_-1].matched = true;
	__s.__node_ = this->first();
	}

	// __back_ref

	template <class _CharT>
	class __back_ref
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;

	unsigned __mexp_;
	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	explicit __back_ref(unsigned __mexp, __node<_CharT>* __s)
	: base(__s), __mexp_(__mexp) {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT>
	void
	__back_ref<_CharT>::__exec(__state& __s) const
	{
	if (__mexp_ > __s.__sub_matches_.size())
	__throw_regex_error<regex_constants::error_backref>();
	sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1];
	if (__sm.matched)
	{
	ptrdiff_t __len = __sm.second - __sm.first;
	if (__s.__last_ - __s.__current_ >= __len &&
	_VSTD::equal(__sm.first, __sm.second, __s.__current_))
	{
	__s.__do_ = __state::__accept_but_not_consume;
	__s.__current_ += __len;
	__s.__node_ = this->first();
	}
	else
	{
	__s.__do_ = __state::__reject;
	__s.__node_ = nullptr;
	}
	}
	else
	{
	__s.__do_ = __state::__reject;
	__s.__node_ = nullptr;
	}
	}

	// __back_ref_icase

	template <class _CharT, class _Traits>
	class __back_ref_icase
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;

	_Traits __traits_;
	unsigned __mexp_;
	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	explicit __back_ref_icase(const _Traits& __traits, unsigned __mexp,
	__node<_CharT>* __s)
	: base(__s), __traits_(__traits), __mexp_(__mexp) {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT, class _Traits>
	void
	__back_ref_icase<_CharT, _Traits>::__exec(__state& __s) const
	{
	sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1];
	if (__sm.matched)
	{
	ptrdiff_t __len = __sm.second - __sm.first;
	if (__s.__last_ - __s.__current_ >= __len)
	{
	for (ptrdiff_t __i = 0; __i < __len; ++__i)
	{
	if (__traits_.translate_nocase(__sm.first[__i]) !=
	__traits_.translate_nocase(__s.__current_[__i]))
	goto __not_equal;
	}
	__s.__do_ = __state::__accept_but_not_consume;
	__s.__current_ += __len;
	__s.__node_ = this->first();
	}
	else
	{
	__s.__do_ = __state::__reject;
	__s.__node_ = nullptr;
	}
	}
	else
	{
	__not_equal:
	__s.__do_ = __state::__reject;
	__s.__node_ = nullptr;
	}
	}

	// __back_ref_collate

	template <class _CharT, class _Traits>
	class __back_ref_collate
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;

	_Traits __traits_;
	unsigned __mexp_;
	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	explicit __back_ref_collate(const _Traits& __traits, unsigned __mexp,
	__node<_CharT>* __s)
	: base(__s), __traits_(__traits), __mexp_(__mexp) {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT, class _Traits>
	void
	__back_ref_collate<_CharT, _Traits>::__exec(__state& __s) const
	{
	sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1];
	if (__sm.matched)
	{
	ptrdiff_t __len = __sm.second - __sm.first;
	if (__s.__last_ - __s.__current_ >= __len)
	{
	for (ptrdiff_t __i = 0; __i < __len; ++__i)
	{
	if (__traits_.translate(__sm.first[__i]) !=
	__traits_.translate(__s.__current_[__i]))
	goto __not_equal;
	}
	__s.__do_ = __state::__accept_but_not_consume;
	__s.__current_ += __len;
	__s.__node_ = this->first();
	}
	else
	{
	__s.__do_ = __state::__reject;
	__s.__node_ = nullptr;
	}
	}
	else
	{
	__not_equal:
	__s.__do_ = __state::__reject;
	__s.__node_ = nullptr;
	}
	}

	// __word_boundary

	template <class _CharT, class _Traits>
	class __word_boundary
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;

	_Traits __traits_;
	bool __invert_;
	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	explicit __word_boundary(const _Traits& __traits, bool __invert,
	__node<_CharT>* __s)
	: base(__s), __traits_(__traits), __invert_(__invert) {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT, class _Traits>
	void
	__word_boundary<_CharT, _Traits>::__exec(__state& __s) const
	{
	bool __is_word_b = false;
	if (__s.__first_ != __s.__last_)
	{
	if (__s.__current_ == __s.__last_)
	{
	if (!(__s.__flags_ & regex_constants::match_not_eow))
	{
	_CharT __c = __s.__current_[-1];
	__is_word_b = __c == '_' \|\|
	__traits_.isctype(__c, ctype_base::alnum);
	}
	}
	else if (__s.__current_ == __s.__first_ &&
	!(__s.__flags_ & regex_constants::match_prev_avail))
	{
	if (!(__s.__flags_ & regex_constants::match_not_bow))
	{
	_CharT __c = *__s.__current_;
	__is_word_b = __c == '_' \|\|
	__traits_.isctype(__c, ctype_base::alnum);
	}
	}
	else
	{
	_CharT __c1 = __s.__current_[-1];
	_CharT __c2 = *__s.__current_;
	bool __is_c1_b = __c1 == '_' \|\|
	__traits_.isctype(__c1, ctype_base::alnum);
	bool __is_c2_b = __c2 == '_' \|\|
	__traits_.isctype(__c2, ctype_base::alnum);
	__is_word_b = __is_c1_b != __is_c2_b;
	}
	}
	if (__is_word_b != __invert_)
	{
	__s.__do_ = __state::__accept_but_not_consume;
	__s.__node_ = this->first();
	}
	else
	{
	__s.__do_ = __state::__reject;
	__s.__node_ = nullptr;
	}
	}

	// __l_anchor

	template <class _CharT>
	class __l_anchor
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;

	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	__l_anchor(__node<_CharT>* __s)
	: base(__s) {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT>
	void
	__l_anchor<_CharT>::__exec(__state& __s) const
	{
	if (__s.__at_first_ && __s.__current_ == __s.__first_ &&
	!(__s.__flags_ & regex_constants::match_not_bol))
	{
	__s.__do_ = __state::__accept_but_not_consume;
	__s.__node_ = this->first();
	}
	else
	{
	__s.__do_ = __state::__reject;
	__s.__node_ = nullptr;
	}
	}

	// __r_anchor

	template <class _CharT>
	class __r_anchor
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;

	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	__r_anchor(__node<_CharT>* __s)
	: base(__s) {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT>
	void
	__r_anchor<_CharT>::__exec(__state& __s) const
	{
	if (__s.__current_ == __s.__last_ &&
	!(__s.__flags_ & regex_constants::match_not_eol))
	{
	__s.__do_ = __state::__accept_but_not_consume;
	__s.__node_ = this->first();
	}
	else
	{
	__s.__do_ = __state::__reject;
	__s.__node_ = nullptr;
	}
	}

	// __match_any

	template <class _CharT>
	class __match_any
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;

	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	__match_any(__node<_CharT>* __s)
	: base(__s) {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT>
	void
	__match_any<_CharT>::__exec(__state& __s) const
	{
	if (__s.__current_ != __s.__last_ && *__s.__current_ != 0)
	{
	__s.__do_ = __state::__accept_and_consume;
	++__s.__current_;
	__s.__node_ = this->first();
	}
	else
	{
	__s.__do_ = __state::__reject;
	__s.__node_ = nullptr;
	}
	}

	// __match_any_but_newline

	template <class _CharT>
	class __match_any_but_newline
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;

	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	__match_any_but_newline(__node<_CharT>* __s)
	: base(__s) {}

	virtual void __exec(__state&) const;
	};

	template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<char>::__exec(__state&) const;
	template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<wchar_t>::__exec(__state&) const;

	// __match_char

	template <class _CharT>
	class __match_char
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;

	_CharT __c_;

	__match_char(const __match_char&);
	__match_char& operator=(const __match_char&);
	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	__match_char(_CharT __c, __node<_CharT>* __s)
	: base(__s), __c_(__c) {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT>
	void
	__match_char<_CharT>::__exec(__state& __s) const
	{
	if (__s.__current_ != __s.__last_ && *__s.__current_ == __c_)
	{
	__s.__do_ = __state::__accept_and_consume;
	++__s.__current_;
	__s.__node_ = this->first();
	}
	else
	{
	__s.__do_ = __state::__reject;
	__s.__node_ = nullptr;
	}
	}

	// __match_char_icase

	template <class _CharT, class _Traits>
	class __match_char_icase
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;

	_Traits __traits_;
	_CharT __c_;

	__match_char_icase(const __match_char_icase&);
	__match_char_icase& operator=(const __match_char_icase&);
	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	__match_char_icase(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
	: base(__s), __traits_(__traits), __c_(__traits.translate_nocase(__c)) {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT, class _Traits>
	void
	__match_char_icase<_CharT, _Traits>::__exec(__state& __s) const
	{
	if (__s.__current_ != __s.__last_ &&
	__traits_.translate_nocase(*__s.__current_) == __c_)
	{
	__s.__do_ = __state::__accept_and_consume;
	++__s.__current_;
	__s.__node_ = this->first();
	}
	else
	{
	__s.__do_ = __state::__reject;
	__s.__node_ = nullptr;
	}
	}

	// __match_char_collate

	template <class _CharT, class _Traits>
	class __match_char_collate
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;

	_Traits __traits_;
	_CharT __c_;

	__match_char_collate(const __match_char_collate&);
	__match_char_collate& operator=(const __match_char_collate&);
	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	__match_char_collate(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
	: base(__s), __traits_(__traits), __c_(__traits.translate(__c)) {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT, class _Traits>
	void
	__match_char_collate<_CharT, _Traits>::__exec(__state& __s) const
	{
	if (__s.__current_ != __s.__last_ &&
	__traits_.translate(*__s.__current_) == __c_)
	{
	__s.__do_ = __state::__accept_and_consume;
	++__s.__current_;
	__s.__node_ = this->first();
	}
	else
	{
	__s.__do_ = __state::__reject;
	__s.__node_ = nullptr;
	}
	}

	// __bracket_expression

	template <class _CharT, class _Traits>
	class __bracket_expression
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;
	typedef typename _Traits::string_type string_type;

	_Traits __traits_;
	vector<_CharT> __chars_;
	vector<_CharT> __neg_chars_;
	vector<pair<string_type, string_type> > __ranges_;
	vector<pair<_CharT, _CharT> > __digraphs_;
	vector<string_type> __equivalences_;
	typename regex_traits<_CharT>::char_class_type __mask_;
	typename regex_traits<_CharT>::char_class_type __neg_mask_;
	bool __negate_;
	bool __icase_;
	bool __collate_;
	bool __might_have_digraph_;

	__bracket_expression(const __bracket_expression&);
	__bracket_expression& operator=(const __bracket_expression&);
	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	__bracket_expression(const _Traits& __traits, __node<_CharT>* __s,
	bool __negate, bool __icase, bool __collate)
	: base(__s), __traits_(__traits), __mask_(), __neg_mask_(),
	__negate_(__negate), __icase_(__icase), __collate_(__collate),
	__might_have_digraph_(__traits_.getloc().name() != "C") {}

	virtual void __exec(__state&) const;

	_LIBCPP_INLINE_VISIBILITY
	bool __negated() const {return __negate_;}

	_LIBCPP_INLINE_VISIBILITY
	void __add_char(_CharT __c)
	{
	if (__icase_)
	__chars_.push_back(__traits_.translate_nocase(__c));
	else if (__collate_)
	__chars_.push_back(__traits_.translate(__c));
	else
	__chars_.push_back(__c);
	}
	_LIBCPP_INLINE_VISIBILITY
	void __add_neg_char(_CharT __c)
	{
	if (__icase_)
	__neg_chars_.push_back(__traits_.translate_nocase(__c));
	else if (__collate_)
	__neg_chars_.push_back(__traits_.translate(__c));
	else
	__neg_chars_.push_back(__c);
	}
	_LIBCPP_INLINE_VISIBILITY
	void __add_range(string_type __b, string_type __e)
	{
	if (__collate_)
	{
	if (__icase_)
	{
	for (size_t __i = 0; __i < __b.size(); ++__i)
	__b[__i] = __traits_.translate_nocase(__b[__i]);
	for (size_t __i = 0; __i < __e.size(); ++__i)
	__e[__i] = __traits_.translate_nocase(__e[__i]);
	}
	else
	{
	for (size_t __i = 0; __i < __b.size(); ++__i)
	__b[__i] = __traits_.translate(__b[__i]);
	for (size_t __i = 0; __i < __e.size(); ++__i)
	__e[__i] = __traits_.translate(__e[__i]);
	}
	__ranges_.push_back(make_pair(
	__traits_.transform(__b.begin(), __b.end()),
	__traits_.transform(__e.begin(), __e.end())));
	}
	else
	{
	if (__b.size() != 1 \|\| __e.size() != 1)
	__throw_regex_error<regex_constants::error_collate>();
	if (__icase_)
	{
	__b[0] = __traits_.translate_nocase(__b[0]);
	__e[0] = __traits_.translate_nocase(__e[0]);
	}
	__ranges_.push_back(make_pair(_VSTD::move(__b), _VSTD::move(__e)));
	}
	}
	_LIBCPP_INLINE_VISIBILITY
	void __add_digraph(_CharT __c1, _CharT __c2)
	{
	if (__icase_)
	__digraphs_.push_back(make_pair(__traits_.translate_nocase(__c1),
	__traits_.translate_nocase(__c2)));
	else if (__collate_)
	__digraphs_.push_back(make_pair(__traits_.translate(__c1),
	__traits_.translate(__c2)));
	else
	__digraphs_.push_back(make_pair(__c1, __c2));
	}
	_LIBCPP_INLINE_VISIBILITY
	void __add_equivalence(const string_type& __s)
	{__equivalences_.push_back(__s);}
	_LIBCPP_INLINE_VISIBILITY
	void __add_class(typename regex_traits<_CharT>::char_class_type __mask)
	{__mask_ \|= __mask;}
	_LIBCPP_INLINE_VISIBILITY
	void __add_neg_class(typename regex_traits<_CharT>::char_class_type __mask)
	{__neg_mask_ \|= __mask;}
	};

	template <class _CharT, class _Traits>
	void
	__bracket_expression<_CharT, _Traits>::__exec(__state& __s) const
	{
	bool __found = false;
	unsigned __consumed = 0;
	if (__s.__current_ != __s.__last_)
	{
	++__consumed;
	if (__might_have_digraph_)
	{
	const _CharT* __next = _VSTD::next(__s.__current_);
	if (__next != __s.__last_)
	{
	pair<_CharT, _CharT> __ch2(__s.__current_, __next);
	if (__icase_)
	{
	__ch2.first = __traits_.translate_nocase(__ch2.first);
	__ch2.second = __traits_.translate_nocase(__ch2.second);
	}
	else if (__collate_)
	{
	__ch2.first = __traits_.translate(__ch2.first);
	__ch2.second = __traits_.translate(__ch2.second);
	}
	if (!__traits_.lookup_collatename(&__ch2.first, &__ch2.first+2).empty())
	{
	// __ch2 is a digraph in this locale
	++__consumed;
	for (size_t __i = 0; __i < __digraphs_.size(); ++__i)
	{
	if (__ch2 == __digraphs_[__i])
	{
	__found = true;
	goto __exit;
	}
	}
	if (__collate_ && !__ranges_.empty())
	{
	string_type __s2 = __traits_.transform(&__ch2.first,
	&__ch2.first + 2);
	for (size_t __i = 0; __i < __ranges_.size(); ++__i)
	{
	if (__ranges_[__i].first <= __s2 &&
	__s2 <= __ranges_[__i].second)
	{
	__found = true;
	goto __exit;
	}
	}
	}
	if (!__equivalences_.empty())
	{
	string_type __s2 = __traits_.transform_primary(&__ch2.first,
	&__ch2.first + 2);
	for (size_t __i = 0; __i < __equivalences_.size(); ++__i)
	{
	if (__s2 == __equivalences_[__i])
	{
	__found = true;
	goto __exit;
	}
	}
	}
	if (__traits_.isctype(__ch2.first, __mask_) &&
	__traits_.isctype(__ch2.second, __mask_))
	{
	__found = true;
	goto __exit;
	}
	if (!__traits_.isctype(__ch2.first, __neg_mask_) &&
	!__traits_.isctype(__ch2.second, __neg_mask_))
	{
	__found = true;
	goto __exit;
	}
	goto __exit;
	}
	}
	}
	// test *__s.__current_ as not a digraph
	_CharT __ch = *__s.__current_;
	if (__icase_)
	__ch = __traits_.translate_nocase(__ch);
	else if (__collate_)
	__ch = __traits_.translate(__ch);
	for (size_t __i = 0; __i < __chars_.size(); ++__i)
	{
	if (__ch == __chars_[__i])
	{
	__found = true;
	goto __exit;
	}
	}
	// 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.
	{
	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;
	}
	}
	if (!__ranges_.empty())
	{
	string_type __s2 = __collate_ ?
	__traits_.transform(&__ch, &__ch + 1) :
	string_type(1, __ch);
	for (size_t __i = 0; __i < __ranges_.size(); ++__i)
	{
	if (__ranges_[__i].first <= __s2 && __s2 <= __ranges_[__i].second)
	{
	__found = true;
	goto __exit;
	}
	}
	}
	if (!__equivalences_.empty())
	{
	string_type __s2 = __traits_.transform_primary(&__ch, &__ch + 1);
	for (size_t __i = 0; __i < __equivalences_.size(); ++__i)
	{
	if (__s2 == __equivalences_[__i])
	{
	__found = true;
	goto __exit;
	}
	}
	}
	if (__traits_.isctype(__ch, __mask_))
	{
	__found = true;
	goto __exit;
	}
	}
	else
	__found = __negate_; // force reject
	__exit:
	if (__found != __negate_)
	{
	__s.__do_ = __state::__accept_and_consume;
	__s.__current_ += __consumed;
	__s.__node_ = this->first();
	}
	else
	{
	__s.__do_ = __state::__reject;
	__s.__node_ = nullptr;
	}
	}

	template <class _CharT, class _Traits> class __lookahead;

	template <class _CharT, class _Traits = regex_traits<_CharT> >
	class _LIBCPP_TEMPLATE_VIS basic_regex
	{
	public:
	// types:
	typedef _CharT value_type;
	typedef _Traits traits_type;
	typedef typename _Traits::string_type string_type;
	typedef regex_constants::syntax_option_type flag_type;
	typedef typename _Traits::locale_type locale_type;

	private:
	_Traits __traits_;
	flag_type __flags_;
	unsigned __marked_count_;
	unsigned __loop_count_;
	int __open_count_;
	shared_ptr<__empty_state<_CharT> > __start_;
	__owns_one_state<_CharT>* __end_;

	typedef _VSTD::__state<_CharT> __state;
	typedef _VSTD::__node<_CharT> __node;

	public:
	// constants:
	static const regex_constants::syntax_option_type icase = regex_constants::icase;
	static const regex_constants::syntax_option_type nosubs = regex_constants::nosubs;
	static const regex_constants::syntax_option_type optimize = regex_constants::optimize;
	static const regex_constants::syntax_option_type collate = regex_constants::collate;
	static const regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
	static const regex_constants::syntax_option_type basic = regex_constants::basic;
	static const regex_constants::syntax_option_type extended = regex_constants::extended;
	static const regex_constants::syntax_option_type awk = regex_constants::awk;
	static const regex_constants::syntax_option_type grep = regex_constants::grep;
	static const regex_constants::syntax_option_type egrep = regex_constants::egrep;

	// construct/copy/destroy:
	_LIBCPP_INLINE_VISIBILITY
	basic_regex()
	: __flags_(), __marked_count_(0), __loop_count_(0), __open_count_(0),
	__end_(0)
	{}
	_LIBCPP_INLINE_VISIBILITY
	explicit basic_regex(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
	: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
	__end_(0)
	{__parse(__p, __p + __traits_.length(__p));}
	_LIBCPP_INLINE_VISIBILITY
	basic_regex(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript)
	: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
	__end_(0)
	{__parse(__p, __p + __len);}
	// basic_regex(const basic_regex&) = default;
	// basic_regex(basic_regex&&) = default;
	template <class _ST, class _SA>
	_LIBCPP_INLINE_VISIBILITY
	explicit basic_regex(const basic_string<value_type, _ST, _SA>& __p,
	flag_type __f = regex_constants::ECMAScript)
	: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
	__end_(0)
	{__parse(__p.begin(), __p.end());}
	template <class _ForwardIterator>
	_LIBCPP_INLINE_VISIBILITY
	basic_regex(_ForwardIterator __first, _ForwardIterator __last,
	flag_type __f = regex_constants::ECMAScript)
	: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
	__end_(0)
	{__parse(__first, __last);}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	basic_regex(initializer_list<value_type> __il,
	flag_type __f = regex_constants::ECMAScript)
	: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
	__end_(0)
	{__parse(__il.begin(), __il.end());}
	#endif // _LIBCPP_CXX03_LANG

	// ~basic_regex() = default;

	// basic_regex& operator=(const basic_regex&) = default;
	// basic_regex& operator=(basic_regex&&) = default;
	_LIBCPP_INLINE_VISIBILITY
	basic_regex& operator=(const value_type* __p)
	{return assign(__p);}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	basic_regex& operator=(initializer_list<value_type> __il)
	{return assign(__il);}
	#endif // _LIBCPP_CXX03_LANG
	template <class _ST, class _SA>
	_LIBCPP_INLINE_VISIBILITY
	basic_regex& operator=(const basic_string<value_type, _ST, _SA>& __p)
	{return assign(__p);}

	// assign:
	_LIBCPP_INLINE_VISIBILITY
	basic_regex& assign(const basic_regex& __that)
	{return *this = __that;}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	basic_regex& assign(basic_regex&& __that) _NOEXCEPT
	{return *this = _VSTD::move(__that);}
	#endif
	_LIBCPP_INLINE_VISIBILITY
	basic_regex& assign(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
	{return assign(__p, __p + __traits_.length(__p), __f);}
	_LIBCPP_INLINE_VISIBILITY
	basic_regex& assign(const value_type* __p, size_t __len, flag_type __f)
	{return assign(__p, __p + __len, __f);}
	template <class _ST, class _SA>
	_LIBCPP_INLINE_VISIBILITY
	basic_regex& assign(const basic_string<value_type, _ST, _SA>& __s,
	flag_type __f = regex_constants::ECMAScript)
	{return assign(__s.begin(), __s.end(), __f);}

	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_input_iterator <_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value,
	basic_regex&
	>::type
	assign(_InputIterator __first, _InputIterator __last,
	flag_type __f = regex_constants::ECMAScript)
	{
	basic_string<_CharT> __t(__first, __last);
	return assign(__t.begin(), __t.end(), __f);
	}

	private:
	_LIBCPP_INLINE_VISIBILITY
	void __member_init(flag_type __f)
	{
	__flags_ = __f;
	__marked_count_ = 0;
	__loop_count_ = 0;
	__open_count_ = 0;
	__end_ = nullptr;
	}
	public:

	template <class _ForwardIterator>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value,
	basic_regex&
	>::type
	assign(_ForwardIterator __first, _ForwardIterator __last,
	flag_type __f = regex_constants::ECMAScript)
	{
	return assign(basic_regex(__first, __last, __f));
	}

	#ifndef _LIBCPP_CXX03_LANG

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

	#endif // _LIBCPP_CXX03_LANG

	// const operations:
	_LIBCPP_INLINE_VISIBILITY
	unsigned mark_count() const {return __marked_count_;}
	_LIBCPP_INLINE_VISIBILITY
	flag_type flags() const {return __flags_;}

	// locale:
	_LIBCPP_INLINE_VISIBILITY
	locale_type imbue(locale_type __loc)
	{
	__member_init(ECMAScript);
	__start_.reset();
	return __traits_.imbue(__loc);
	}
	_LIBCPP_INLINE_VISIBILITY
	locale_type getloc() const {return __traits_.getloc();}

	// swap:
	void swap(basic_regex& __r);

	private:
	_LIBCPP_INLINE_VISIBILITY
	unsigned __loop_count() const {return __loop_count_;}

	template <class _ForwardIterator>
	_ForwardIterator
	__parse(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_basic_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_RE_expression(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_simple_RE(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_nondupl_RE(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_one_char_or_coll_elem_RE(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_Back_open_paren(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_Back_close_paren(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_Back_open_brace(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_Back_close_brace(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_BACKREF(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_ORD_CHAR(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_QUOTED_CHAR(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_RE_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last,
	__owns_one_state<_CharT>* __s,
	unsigned __mexp_begin, unsigned __mexp_end);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_ERE_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last,
	__owns_one_state<_CharT>* __s,
	unsigned __mexp_begin, unsigned __mexp_end);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_bracket_expression(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_follow_list(_ForwardIterator __first, _ForwardIterator __last,
	__bracket_expression<_CharT, _Traits>* __ml);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_expression_term(_ForwardIterator __first, _ForwardIterator __last,
	__bracket_expression<_CharT, _Traits>* __ml);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_equivalence_class(_ForwardIterator __first, _ForwardIterator __last,
	__bracket_expression<_CharT, _Traits>* __ml);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_character_class(_ForwardIterator __first, _ForwardIterator __last,
	__bracket_expression<_CharT, _Traits>* __ml);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_collating_symbol(_ForwardIterator __first, _ForwardIterator __last,
	basic_string<_CharT>& __col_sym);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_DUP_COUNT(_ForwardIterator __first, _ForwardIterator __last, int& __c);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_extended_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_ERE_branch(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_ERE_expression(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_one_char_or_coll_elem_ERE(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_ORD_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_QUOTED_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_ecma_exp(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_alternative(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_term(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_assertion(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_atom(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_atom_escape(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_decimal_escape(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_character_class_escape(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_character_escape(_ForwardIterator __first, _ForwardIterator __last,
	basic_string<_CharT>* __str = nullptr);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_pattern_character(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_grep(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_egrep(_ForwardIterator __first, _ForwardIterator __last);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_class_escape(_ForwardIterator __first, _ForwardIterator __last,
	basic_string<_CharT>& __str,
	__bracket_expression<_CharT, _Traits>* __ml);
	template <class _ForwardIterator>
	_ForwardIterator
	__parse_awk_escape(_ForwardIterator __first, _ForwardIterator __last,
	basic_string<_CharT>* __str = nullptr);

	_LIBCPP_INLINE_VISIBILITY
	void __push_l_anchor();
	void __push_r_anchor();
	void __push_match_any();
	void __push_match_any_but_newline();
	_LIBCPP_INLINE_VISIBILITY
	void __push_greedy_inf_repeat(size_t __min, __owns_one_state<_CharT>* __s,
	unsigned __mexp_begin = 0, unsigned __mexp_end = 0)
	{__push_loop(__min, numeric_limits<size_t>::max(), __s,
	__mexp_begin, __mexp_end);}
	_LIBCPP_INLINE_VISIBILITY
	void __push_nongreedy_inf_repeat(size_t __min, __owns_one_state<_CharT>* __s,
	unsigned __mexp_begin = 0, unsigned __mexp_end = 0)
	{__push_loop(__min, numeric_limits<size_t>::max(), __s,
	__mexp_begin, __mexp_end, false);}
	void __push_loop(size_t __min, size_t __max, __owns_one_state<_CharT>* __s,
	size_t __mexp_begin = 0, size_t __mexp_end = 0,
	bool __greedy = true);
	__bracket_expression<_CharT, _Traits>* __start_matching_list(bool __negate);
	void __push_char(value_type __c);
	void __push_back_ref(int __i);
	void __push_alternation(__owns_one_state<_CharT>* __sa,
	__owns_one_state<_CharT>* __sb);
	void __push_begin_marked_subexpression();
	void __push_end_marked_subexpression(unsigned);
	void __push_empty();
	void __push_word_boundary(bool);
	void __push_lookahead(const basic_regex&, bool, unsigned);

	template <class _Allocator>
	bool
	__search(const _CharT* __first, const _CharT* __last,
	match_results<const _CharT*, _Allocator>& __m,
	regex_constants::match_flag_type __flags) const;

	template <class _Allocator>
	bool
	__match_at_start(const _CharT* __first, const _CharT* __last,
	match_results<const _CharT*, _Allocator>& __m,
	regex_constants::match_flag_type __flags, bool) const;
	template <class _Allocator>
	bool
	__match_at_start_ecma(const _CharT* __first, const _CharT* __last,
	match_results<const _CharT*, _Allocator>& __m,
	regex_constants::match_flag_type __flags, bool) const;
	template <class _Allocator>
	bool
	__match_at_start_posix_nosubs(const _CharT* __first, const _CharT* __last,
	match_results<const _CharT*, _Allocator>& __m,
	regex_constants::match_flag_type __flags, bool) const;
	template <class _Allocator>
	bool
	__match_at_start_posix_subs(const _CharT* __first, const _CharT* __last,
	match_results<const _CharT*, _Allocator>& __m,
	regex_constants::match_flag_type __flags, bool) const;

	template <class _Bp, class _Ap, class _Cp, class _Tp>
	friend
	bool
	regex_search(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&,
	regex_constants::match_flag_type);

	template <class _Ap, class _Cp, class _Tp>
	friend
	bool
	regex_search(const _Cp, const _Cp, match_results<const _Cp*, _Ap>&,
	const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);

	template <class _Bp, class _Cp, class _Tp>
	friend
	bool
	regex_search(_Bp, _Bp, const basic_regex<_Cp, _Tp>&,
	regex_constants::match_flag_type);

	template <class _Cp, class _Tp>
	friend
	bool
	regex_search(const _Cp, const _Cp,
	const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);

	template <class _Cp, class _Ap, class _Tp>
	friend
	bool
	regex_search(const _Cp, match_results<const _Cp, _Ap>&, const basic_regex<_Cp, _Tp>&,
	regex_constants::match_flag_type);

	template <class _ST, class _SA, class _Cp, class _Tp>
	friend
	bool
	regex_search(const basic_string<_Cp, _ST, _SA>& __s,
	const basic_regex<_Cp, _Tp>& __e,
	regex_constants::match_flag_type __flags);

	template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
	friend
	bool
	regex_search(const basic_string<_Cp, _ST, _SA>& __s,
	match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
	const basic_regex<_Cp, _Tp>& __e,
	regex_constants::match_flag_type __flags);

	template <class _Iter, class _Ap, class _Cp, class _Tp>
	friend
	bool
	regex_search(__wrap_iter<_Iter> __first,
	__wrap_iter<_Iter> __last,
	match_results<__wrap_iter<_Iter>, _Ap>& __m,
	const basic_regex<_Cp, _Tp>& __e,
	regex_constants::match_flag_type __flags);

	template <class, class> friend class __lookahead;
	};

	+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
	+template <class _ForwardIterator,
	+ class = typename enable_if<__is_forward_iterator<_ForwardIterator>::value, nullptr_t>::type
	+>
	+basic_regex(_ForwardIterator, _ForwardIterator,
	+ regex_constants::syntax_option_type = regex_constants::ECMAScript)
	+ -> basic_regex<typename iterator_traits<_ForwardIterator>::value_type>;
	+#endif
	+
	template <class _CharT, class _Traits>
	const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::icase;
	template <class _CharT, class _Traits>
	const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::nosubs;
	template <class _CharT, class _Traits>
	const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::optimize;
	template <class _CharT, class _Traits>
	const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::collate;
	template <class _CharT, class _Traits>
	const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::ECMAScript;
	template <class _CharT, class _Traits>
	const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::basic;
	template <class _CharT, class _Traits>
	const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::extended;
	template <class _CharT, class _Traits>
	const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::awk;
	template <class _CharT, class _Traits>
	const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::grep;
	template <class _CharT, class _Traits>
	const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::egrep;

	template <class _CharT, class _Traits>
	void
	basic_regex<_CharT, _Traits>::swap(basic_regex& __r)
	{
	using _VSTD::swap;
	swap(__traits_, __r.__traits_);
	swap(__flags_, __r.__flags_);
	swap(__marked_count_, __r.__marked_count_);
	swap(__loop_count_, __r.__loop_count_);
	swap(__open_count_, __r.__open_count_);
	swap(__start_, __r.__start_);
	swap(__end_, __r.__end_);
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(basic_regex<_CharT, _Traits>& __x, basic_regex<_CharT, _Traits>& __y)
	{
	return __x.swap(__y);
	}

	// __lookahead

	template <class _CharT, class _Traits>
	class __lookahead
	: public __owns_one_state<_CharT>
	{
	typedef __owns_one_state<_CharT> base;

	basic_regex<_CharT, _Traits> __exp_;
	unsigned __mexp_;
	bool __invert_;

	__lookahead(const __lookahead&);
	__lookahead& operator=(const __lookahead&);
	public:
	typedef _VSTD::__state<_CharT> __state;

	_LIBCPP_INLINE_VISIBILITY
	__lookahead(const basic_regex<_CharT, _Traits>& __exp, bool __invert, __node<_CharT>* __s, unsigned __mexp)
	: base(__s), __exp_(__exp), __mexp_(__mexp), __invert_(__invert) {}

	virtual void __exec(__state&) const;
	};

	template <class _CharT, class _Traits>
	void
	__lookahead<_CharT, _Traits>::__exec(__state& __s) const
	{
	match_results<const _CharT*> __m;
	__m.__init(1 + __exp_.mark_count(), __s.__current_, __s.__last_);
	bool __matched = __exp_.__match_at_start_ecma(
	__s.__current_, __s.__last_,
	__m,
	(__s.__flags_ \| regex_constants::match_continuous) &
	~regex_constants::__full_match,
	__s.__at_first_ && __s.__current_ == __s.__first_);
	if (__matched != __invert_)
	{
	__s.__do_ = __state::__accept_but_not_consume;
	__s.__node_ = this->first();
	for (unsigned __i = 1; __i < __m.size(); ++__i) {
	__s.__sub_matches_[__mexp_ + __i - 1] = __m.__matches_[__i];
	}
	}
	else
	{
	__s.__do_ = __state::__reject;
	__s.__node_ = nullptr;
	}
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	{
	unique_ptr<__node> __h(new __end_state<_CharT>);
	__start_.reset(new __empty_state<_CharT>(__h.get()));
	__h.release();
	__end_ = __start_.get();
	}
	switch (__flags_ & 0x1F0)
	{
	case ECMAScript:
	__first = __parse_ecma_exp(__first, __last);
	break;
	case basic:
	__first = __parse_basic_reg_exp(__first, __last);
	break;
	case extended:
	case awk:
	__first = __parse_extended_reg_exp(__first, __last);
	break;
	case grep:
	__first = __parse_grep(__first, __last);
	break;
	case egrep:
	__first = __parse_egrep(__first, __last);
	break;
	default:
	__throw_regex_error<regex_constants::__re_err_grammar>();
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_basic_reg_exp(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last)
	{
	if (*__first == '^')
	{
	__push_l_anchor();
	++__first;
	}
	if (__first != __last)
	{
	__first = __parse_RE_expression(__first, __last);
	if (__first != __last)
	{
	_ForwardIterator __temp = _VSTD::next(__first);
	if (__temp == __last && *__first == '$')
	{
	__push_r_anchor();
	++__first;
	}
	}
	}
	if (__first != __last)
	__throw_regex_error<regex_constants::__re_err_empty>();
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_extended_reg_exp(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	__owns_one_state<_CharT>* __sa = __end_;
	_ForwardIterator __temp = __parse_ERE_branch(__first, __last);
	if (__temp == __first)
	__throw_regex_error<regex_constants::__re_err_empty>();
	__first = __temp;
	while (__first != __last && *__first == '\|')
	{
	__owns_one_state<_CharT>* __sb = __end_;
	__temp = __parse_ERE_branch(++__first, __last);
	if (__temp == __first)
	__throw_regex_error<regex_constants::__re_err_empty>();
	__push_alternation(__sa, __sb);
	__first = __temp;
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_ERE_branch(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	_ForwardIterator __temp = __parse_ERE_expression(__first, __last);
	if (__temp == __first)
	__throw_regex_error<regex_constants::__re_err_empty>();
	do
	{
	__first = __temp;
	__temp = __parse_ERE_expression(__first, __last);
	} while (__temp != __first);
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_ERE_expression(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	__owns_one_state<_CharT>* __e = __end_;
	unsigned __mexp_begin = __marked_count_;
	_ForwardIterator __temp = __parse_one_char_or_coll_elem_ERE(__first, __last);
	if (__temp == __first && __temp != __last)
	{
	switch (*__temp)
	{
	case '^':
	__push_l_anchor();
	++__temp;
	break;
	case '$':
	__push_r_anchor();
	++__temp;
	break;
	case '(':
	__push_begin_marked_subexpression();
	unsigned __temp_count = __marked_count_;
	++__open_count_;
	__temp = __parse_extended_reg_exp(++__temp, __last);
	if (__temp == __last \|\| *__temp != ')')
	__throw_regex_error<regex_constants::error_paren>();
	__push_end_marked_subexpression(__temp_count);
	--__open_count_;
	++__temp;
	break;
	}
	}
	if (__temp != __first)
	__temp = __parse_ERE_dupl_symbol(__temp, __last, __e, __mexp_begin+1,
	__marked_count_+1);
	__first = __temp;
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_RE_expression(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	while (true)
	{
	_ForwardIterator __temp = __parse_simple_RE(__first, __last);
	if (__temp == __first)
	break;
	__first = __temp;
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_simple_RE(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last)
	{
	__owns_one_state<_CharT>* __e = __end_;
	unsigned __mexp_begin = __marked_count_;
	_ForwardIterator __temp = __parse_nondupl_RE(__first, __last);
	if (__temp != __first)
	__first = __parse_RE_dupl_symbol(__temp, __last, __e,
	__mexp_begin+1, __marked_count_+1);
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_nondupl_RE(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	_ForwardIterator __temp = __first;
	__first = __parse_one_char_or_coll_elem_RE(__first, __last);
	if (__temp == __first)
	{
	__temp = __parse_Back_open_paren(__first, __last);
	if (__temp != __first)
	{
	__push_begin_marked_subexpression();
	unsigned __temp_count = __marked_count_;
	__first = __parse_RE_expression(__temp, __last);
	__temp = __parse_Back_close_paren(__first, __last);
	if (__temp == __first)
	__throw_regex_error<regex_constants::error_paren>();
	__push_end_marked_subexpression(__temp_count);
	__first = __temp;
	}
	else
	__first = __parse_BACKREF(__first, __last);
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_RE(
	_ForwardIterator __first,
	_ForwardIterator __last)
	{
	_ForwardIterator __temp = __parse_ORD_CHAR(__first, __last);
	if (__temp == __first)
	{
	__temp = __parse_QUOTED_CHAR(__first, __last);
	if (__temp == __first)
	{
	if (__temp != __last && *__temp == '.')
	{
	__push_match_any();
	++__temp;
	}
	else
	__temp = __parse_bracket_expression(__first, __last);
	}
	}
	__first = __temp;
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_ERE(
	_ForwardIterator __first,
	_ForwardIterator __last)
	{
	_ForwardIterator __temp = __parse_ORD_CHAR_ERE(__first, __last);
	if (__temp == __first)
	{
	__temp = __parse_QUOTED_CHAR_ERE(__first, __last);
	if (__temp == __first)
	{
	if (__temp != __last && *__temp == '.')
	{
	__push_match_any();
	++__temp;
	}
	else
	__temp = __parse_bracket_expression(__first, __last);
	}
	}
	__first = __temp;
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_Back_open_paren(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last)
	{
	_ForwardIterator __temp = _VSTD::next(__first);
	if (__temp != __last)
	{
	if (__first == '\\' && __temp == '(')
	__first = ++__temp;
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_Back_close_paren(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last)
	{
	_ForwardIterator __temp = _VSTD::next(__first);
	if (__temp != __last)
	{
	if (__first == '\\' && __temp == ')')
	__first = ++__temp;
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_Back_open_brace(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last)
	{
	_ForwardIterator __temp = _VSTD::next(__first);
	if (__temp != __last)
	{
	if (__first == '\\' && __temp == '{')
	__first = ++__temp;
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_Back_close_brace(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last)
	{
	_ForwardIterator __temp = _VSTD::next(__first);
	if (__temp != __last)
	{
	if (__first == '\\' && __temp == '}')
	__first = ++__temp;
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last)
	{
	_ForwardIterator __temp = _VSTD::next(__first);
	if (__temp != __last)
	{
	if (*__first == '\\')
	{
	int __val = __traits_.value(*__temp, 10);
	if (__val >= 1 && __val <= 9)
	{
	__push_back_ref(__val);
	__first = ++__temp;
	}
	}
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_ORD_CHAR(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last)
	{
	_ForwardIterator __temp = _VSTD::next(__first);
	if (__temp == __last && *__first == '$')
	return __first;
	// Not called inside a bracket
	if (__first == '.' \|\| __first == '\\' \|\| *__first == '[')
	return __first;
	__push_char(*__first);
	++__first;
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_ORD_CHAR_ERE(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last)
	{
	switch (*__first)
	{
	case '^':
	case '.':
	case '[':
	case '$':
	case '(':
	case '\|':
	case '*':
	case '+':
	case '?':
	case '{':
	case '\\':
	break;
	case ')':
	if (__open_count_ == 0)
	{
	__push_char(*__first);
	++__first;
	}
	break;
	default:
	__push_char(*__first);
	++__first;
	break;
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last)
	{
	_ForwardIterator __temp = _VSTD::next(__first);
	if (__temp != __last)
	{
	if (*__first == '\\')
	{
	switch (*__temp)
	{
	case '^':
	case '.':
	case '*':
	case '[':
	case '$':
	case '\\':
	__push_char(*__temp);
	__first = ++__temp;
	break;
	}
	}
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last)
	{
	_ForwardIterator __temp = _VSTD::next(__first);
	if (__temp != __last)
	{
	if (*__first == '\\')
	{
	switch (*__temp)
	{
	case '^':
	case '.':
	case '*':
	case '[':
	case '$':
	case '\\':
	case '(':
	case ')':
	case '\|':
	case '+':
	case '?':
	case '{':
	case '}':
	__push_char(*__temp);
	__first = ++__temp;
	break;
	default:
	if ((__flags_ & 0x1F0) == awk)
	__first = __parse_awk_escape(++__first, __last);
	break;
	}
	}
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_RE_dupl_symbol(_ForwardIterator __first,
	_ForwardIterator __last,
	__owns_one_state<_CharT>* __s,
	unsigned __mexp_begin,
	unsigned __mexp_end)
	{
	if (__first != __last)
	{
	if (__first == '')
	{
	__push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
	++__first;
	}
	else
	{
	_ForwardIterator __temp = __parse_Back_open_brace(__first, __last);
	if (__temp != __first)
	{
	int __min = 0;
	__first = __temp;
	__temp = __parse_DUP_COUNT(__first, __last, __min);
	if (__temp == __first)
	__throw_regex_error<regex_constants::error_badbrace>();
	__first = __temp;
	if (__first == __last)
	__throw_regex_error<regex_constants::error_brace>();
	if (*__first != ',')
	{
	__temp = __parse_Back_close_brace(__first, __last);
	if (__temp == __first)
	__throw_regex_error<regex_constants::error_brace>();
	__push_loop(__min, __min, __s, __mexp_begin, __mexp_end,
	true);
	__first = __temp;
	}
	else
	{
	++__first; // consume ','
	int __max = -1;
	__first = __parse_DUP_COUNT(__first, __last, __max);
	__temp = __parse_Back_close_brace(__first, __last);
	if (__temp == __first)
	__throw_regex_error<regex_constants::error_brace>();
	if (__max == -1)
	__push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
	else
	{
	if (__max < __min)
	__throw_regex_error<regex_constants::error_badbrace>();
	__push_loop(__min, __max, __s, __mexp_begin, __mexp_end,
	true);
	}
	__first = __temp;
	}
	}
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_ERE_dupl_symbol(_ForwardIterator __first,
	_ForwardIterator __last,
	__owns_one_state<_CharT>* __s,
	unsigned __mexp_begin,
	unsigned __mexp_end)
	{
	if (__first != __last)
	{
	unsigned __grammar = __flags_ & 0x1F0;
	switch (*__first)
	{
	case '*':
	++__first;
	if (__grammar == ECMAScript && __first != __last && *__first == '?')
	{
	++__first;
	__push_nongreedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
	}
	else
	__push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
	break;
	case '+':
	++__first;
	if (__grammar == ECMAScript && __first != __last && *__first == '?')
	{
	++__first;
	__push_nongreedy_inf_repeat(1, __s, __mexp_begin, __mexp_end);
	}
	else
	__push_greedy_inf_repeat(1, __s, __mexp_begin, __mexp_end);
	break;
	case '?':
	++__first;
	if (__grammar == ECMAScript && __first != __last && *__first == '?')
	{
	++__first;
	__push_loop(0, 1, __s, __mexp_begin, __mexp_end, false);
	}
	else
	__push_loop(0, 1, __s, __mexp_begin, __mexp_end);
	break;
	case '{':
	{
	int __min;
	_ForwardIterator __temp = __parse_DUP_COUNT(++__first, __last, __min);
	if (__temp == __first)
	__throw_regex_error<regex_constants::error_badbrace>();
	__first = __temp;
	if (__first == __last)
	__throw_regex_error<regex_constants::error_brace>();
	switch (*__first)
	{
	case '}':
	++__first;
	if (__grammar == ECMAScript && __first != __last && *__first == '?')
	{
	++__first;
	__push_loop(__min, __min, __s, __mexp_begin, __mexp_end, false);
	}
	else
	__push_loop(__min, __min, __s, __mexp_begin, __mexp_end);
	break;
	case ',':
	++__first;
	if (__first == __last)
	__throw_regex_error<regex_constants::error_badbrace>();
	if (*__first == '}')
	{
	++__first;
	if (__grammar == ECMAScript && __first != __last && *__first == '?')
	{
	++__first;
	__push_nongreedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
	}
	else
	__push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
	}
	else
	{
	int __max = -1;
	__temp = __parse_DUP_COUNT(__first, __last, __max);
	if (__temp == __first)
	__throw_regex_error<regex_constants::error_brace>();
	__first = __temp;
	if (__first == __last \|\| *__first != '}')
	__throw_regex_error<regex_constants::error_brace>();
	++__first;
	if (__max < __min)
	__throw_regex_error<regex_constants::error_badbrace>();
	if (__grammar == ECMAScript && __first != __last && *__first == '?')
	{
	++__first;
	__push_loop(__min, __max, __s, __mexp_begin, __mexp_end, false);
	}
	else
	__push_loop(__min, __max, __s, __mexp_begin, __mexp_end);
	}
	break;
	default:
	__throw_regex_error<regex_constants::error_badbrace>();
	}
	}
	break;
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_bracket_expression(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last && *__first == '[')
	{
	++__first;
	if (__first == __last)
	__throw_regex_error<regex_constants::error_brack>();
	bool __negate = false;
	if (*__first == '^')
	{
	++__first;
	__negate = true;
	}
	__bracket_expression<_CharT, _Traits>* __ml = __start_matching_list(__negate);
	// __ml owned by *this
	if (__first == __last)
	__throw_regex_error<regex_constants::error_brack>();
	if ((__flags_ & 0x1F0) != ECMAScript && *__first == ']')
	{
	__ml->__add_char(']');
	++__first;
	}
	__first = __parse_follow_list(__first, __last, __ml);
	if (__first == __last)
	__throw_regex_error<regex_constants::error_brack>();
	if (*__first == '-')
	{
	__ml->__add_char('-');
	++__first;
	}
	if (__first == __last \|\| *__first != ']')
	__throw_regex_error<regex_constants::error_brack>();
	++__first;
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_follow_list(_ForwardIterator __first,
	_ForwardIterator __last,
	__bracket_expression<_CharT, _Traits>* __ml)
	{
	if (__first != __last)
	{
	while (true)
	{
	_ForwardIterator __temp = __parse_expression_term(__first, __last,
	__ml);
	if (__temp == __first)
	break;
	__first = __temp;
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
	_ForwardIterator __last,
	__bracket_expression<_CharT, _Traits>* __ml)
	{
	if (__first != __last && *__first != ']')
	{
	_ForwardIterator __temp = _VSTD::next(__first);
	basic_string<_CharT> __start_range;
	if (__temp != __last && *__first == '[')
	{
	if (*__temp == '=')
	return __parse_equivalence_class(++__temp, __last, __ml);
	else if (*__temp == ':')
	return __parse_character_class(++__temp, __last, __ml);
	else if (*__temp == '.')
	__first = __parse_collating_symbol(++__temp, __last, __start_range);
	}
	unsigned __grammar = __flags_ & 0x1F0;
	if (__start_range.empty())
	{
	if ((__grammar == ECMAScript \|\| __grammar == awk) && *__first == '\\')
	{
	if (__grammar == ECMAScript)
	__first = __parse_class_escape(++__first, __last, __start_range, __ml);
	else
	__first = __parse_awk_escape(++__first, __last, &__start_range);
	}
	else
	{
	__start_range = *__first;
	++__first;
	}
	}
	if (__first != __last && *__first != ']')
	{
	__temp = _VSTD::next(__first);
	if (__temp != __last && __first == '-' && __temp != ']')
	{
	// parse a range
	basic_string<_CharT> __end_range;
	__first = __temp;
	++__temp;
	if (__temp != __last && __first == '[' && __temp == '.')
	__first = __parse_collating_symbol(++__temp, __last, __end_range);
	else
	{
	if ((__grammar == ECMAScript \|\| __grammar == awk) && *__first == '\\')
	{
	if (__grammar == ECMAScript)
	__first = __parse_class_escape(++__first, __last,
	__end_range, __ml);
	else
	__first = __parse_awk_escape(++__first, __last,
	&__end_range);
	}
	else
	{
	__end_range = *__first;
	++__first;
	}
	}
	__ml->__add_range(_VSTD::move(__start_range), _VSTD::move(__end_range));
	}
	else if (!__start_range.empty())
	{
	if (__start_range.size() == 1)
	__ml->__add_char(__start_range[0]);
	else
	__ml->__add_digraph(__start_range[0], __start_range[1]);
	}
	}
	else if (!__start_range.empty())
	{
	if (__start_range.size() == 1)
	__ml->__add_char(__start_range[0]);
	else
	__ml->__add_digraph(__start_range[0], __start_range[1]);
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_class_escape(_ForwardIterator __first,
	_ForwardIterator __last,
	basic_string<_CharT>& __str,
	__bracket_expression<_CharT, _Traits>* __ml)
	{
	if (__first == __last)
	__throw_regex_error<regex_constants::error_escape>();
	switch (*__first)
	{
	case 0:
	__str = *__first;
	return ++__first;
	case 'b':
	__str = _CharT(8);
	return ++__first;
	case 'd':
	__ml->__add_class(ctype_base::digit);
	return ++__first;
	case 'D':
	__ml->__add_neg_class(ctype_base::digit);
	return ++__first;
	case 's':
	__ml->__add_class(ctype_base::space);
	return ++__first;
	case 'S':
	__ml->__add_neg_class(ctype_base::space);
	return ++__first;
	case 'w':
	__ml->__add_class(ctype_base::alnum);
	__ml->__add_char('_');
	return ++__first;
	case 'W':
	__ml->__add_neg_class(ctype_base::alnum);
	__ml->__add_neg_char('_');
	return ++__first;
	}
	__first = __parse_character_escape(__first, __last, &__str);
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_awk_escape(_ForwardIterator __first,
	_ForwardIterator __last,
	basic_string<_CharT>* __str)
	{
	if (__first == __last)
	__throw_regex_error<regex_constants::error_escape>();
	switch (*__first)
	{
	case '\\':
	case '"':
	case '/':
	if (__str)
	__str = __first;
	else
	__push_char(*__first);
	return ++__first;
	case 'a':
	if (__str)
	*__str = _CharT(7);
	else
	__push_char(_CharT(7));
	return ++__first;
	case 'b':
	if (__str)
	*__str = _CharT(8);
	else
	__push_char(_CharT(8));
	return ++__first;
	case 'f':
	if (__str)
	*__str = _CharT(0xC);
	else
	__push_char(_CharT(0xC));
	return ++__first;
	case 'n':
	if (__str)
	*__str = _CharT(0xA);
	else
	__push_char(_CharT(0xA));
	return ++__first;
	case 'r':
	if (__str)
	*__str = _CharT(0xD);
	else
	__push_char(_CharT(0xD));
	return ++__first;
	case 't':
	if (__str)
	*__str = _CharT(0x9);
	else
	__push_char(_CharT(0x9));
	return ++__first;
	case 'v':
	if (__str)
	*__str = _CharT(0xB);
	else
	__push_char(_CharT(0xB));
	return ++__first;
	}
	if ('0' <= __first && __first <= '7')
	{
	unsigned __val = *__first - '0';
	if (++__first != __last && ('0' <= __first && __first <= '7'))
	{
	__val = 8 * __val + *__first - '0';
	if (++__first != __last && ('0' <= __first && __first <= '7'))
	__val = 8 * __val + *__first++ - '0';
	}
	if (__str)
	*__str = _CharT(__val);
	else
	__push_char(_CharT(__val));
	}
	else
	__throw_regex_error<regex_constants::error_escape>();
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_equivalence_class(_ForwardIterator __first,
	_ForwardIterator __last,
	__bracket_expression<_CharT, _Traits>* __ml)
	{
	// Found [=
	// This means =] must exist
	value_type _Equal_close[2] = {'=', ']'};
	_ForwardIterator __temp = _VSTD::search(__first, __last, _Equal_close,
	_Equal_close+2);
	if (__temp == __last)
	__throw_regex_error<regex_constants::error_brack>();
	// [__first, __temp) contains all text in [= ... =]
	string_type __collate_name =
	__traits_.lookup_collatename(__first, __temp);
	if (__collate_name.empty())
	__throw_regex_error<regex_constants::error_collate>();
	string_type __equiv_name =
	__traits_.transform_primary(__collate_name.begin(),
	__collate_name.end());
	if (!__equiv_name.empty())
	__ml->__add_equivalence(__equiv_name);
	else
	{
	switch (__collate_name.size())
	{
	case 1:
	__ml->__add_char(__collate_name[0]);
	break;
	case 2:
	__ml->__add_digraph(__collate_name[0], __collate_name[1]);
	break;
	default:
	__throw_regex_error<regex_constants::error_collate>();
	}
	}
	__first = _VSTD::next(__temp, 2);
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_character_class(_ForwardIterator __first,
	_ForwardIterator __last,
	__bracket_expression<_CharT, _Traits>* __ml)
	{
	// Found [:
	// This means :] must exist
	value_type _Colon_close[2] = {':', ']'};
	_ForwardIterator __temp = _VSTD::search(__first, __last, _Colon_close,
	_Colon_close+2);
	if (__temp == __last)
	__throw_regex_error<regex_constants::error_brack>();
	// [__first, __temp) contains all text in [: ... :]
	typedef typename _Traits::char_class_type char_class_type;
	char_class_type __class_type =
	__traits_.lookup_classname(__first, __temp, __flags_ & icase);
	if (__class_type == 0)
	- __throw_regex_error<regex_constants::error_brack>();
	+ __throw_regex_error<regex_constants::error_ctype>();
	__ml->__add_class(__class_type);
	__first = _VSTD::next(__temp, 2);
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_collating_symbol(_ForwardIterator __first,
	_ForwardIterator __last,
	basic_string<_CharT>& __col_sym)
	{
	// Found [.
	// This means .] must exist
	value_type _Dot_close[2] = {'.', ']'};
	_ForwardIterator __temp = _VSTD::search(__first, __last, _Dot_close,
	_Dot_close+2);
	if (__temp == __last)
	__throw_regex_error<regex_constants::error_brack>();
	// [__first, __temp) contains all text in [. ... .]
	__col_sym = __traits_.lookup_collatename(__first, __temp);
	switch (__col_sym.size())
	{
	case 1:
	case 2:
	break;
	default:
	__throw_regex_error<regex_constants::error_collate>();
	}
	__first = _VSTD::next(__temp, 2);
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_DUP_COUNT(_ForwardIterator __first,
	_ForwardIterator __last,
	int& __c)
	{
	if (__first != __last )
	{
	int __val = __traits_.value(*__first, 10);
	if ( __val != -1 )
	{
	__c = __val;
	for (++__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;
	}
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_ecma_exp(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	__owns_one_state<_CharT>* __sa = __end_;
	_ForwardIterator __temp = __parse_alternative(__first, __last);
	if (__temp == __first)
	__push_empty();
	__first = __temp;
	while (__first != __last && *__first == '\|')
	{
	__owns_one_state<_CharT>* __sb = __end_;
	__temp = __parse_alternative(++__first, __last);
	if (__temp == __first)
	__push_empty();
	__push_alternation(__sa, __sb);
	__first = __temp;
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_alternative(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	while (true)
	{
	_ForwardIterator __temp = __parse_term(__first, __last);
	if (__temp == __first)
	break;
	__first = __temp;
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_term(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	_ForwardIterator __temp = __parse_assertion(__first, __last);
	if (__temp == __first)
	{
	__owns_one_state<_CharT>* __e = __end_;
	unsigned __mexp_begin = __marked_count_;
	__temp = __parse_atom(__first, __last);
	if (__temp != __first)
	__first = __parse_ERE_dupl_symbol(__temp, __last, __e,
	__mexp_begin+1, __marked_count_+1);
	}
	else
	__first = __temp;
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last)
	{
	switch (*__first)
	{
	case '^':
	__push_l_anchor();
	++__first;
	break;
	case '$':
	__push_r_anchor();
	++__first;
	break;
	case '\\':
	{
	_ForwardIterator __temp = _VSTD::next(__first);
	if (__temp != __last)
	{
	if (*__temp == 'b')
	{
	__push_word_boundary(false);
	__first = ++__temp;
	}
	else if (*__temp == 'B')
	{
	__push_word_boundary(true);
	__first = ++__temp;
	}
	}
	}
	break;
	case '(':
	{
	_ForwardIterator __temp = _VSTD::next(__first);
	if (__temp != __last && *__temp == '?')
	{
	if (++__temp != __last)
	{
	switch (*__temp)
	{
	case '=':
	{
	basic_regex __exp;
	__exp.__flags_ = __flags_;
	__temp = __exp.__parse(++__temp, __last);
	unsigned __mexp = __exp.__marked_count_;
	__push_lookahead(_VSTD::move(__exp), false, __marked_count_);
	__marked_count_ += __mexp;
	if (__temp == __last \|\| *__temp != ')')
	__throw_regex_error<regex_constants::error_paren>();
	__first = ++__temp;
	}
	break;
	case '!':
	{
	basic_regex __exp;
	__exp.__flags_ = __flags_;
	__temp = __exp.__parse(++__temp, __last);
	unsigned __mexp = __exp.__marked_count_;
	__push_lookahead(_VSTD::move(__exp), true, __marked_count_);
	__marked_count_ += __mexp;
	if (__temp == __last \|\| *__temp != ')')
	__throw_regex_error<regex_constants::error_paren>();
	__first = ++__temp;
	}
	break;
	}
	}
	}
	}
	break;
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_atom(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last)
	{
	switch (*__first)
	{
	case '.':
	__push_match_any_but_newline();
	++__first;
	break;
	case '\\':
	__first = __parse_atom_escape(__first, __last);
	break;
	case '[':
	__first = __parse_bracket_expression(__first, __last);
	break;
	case '(':
	{
	++__first;
	if (__first == __last)
	__throw_regex_error<regex_constants::error_paren>();
	_ForwardIterator __temp = _VSTD::next(__first);
	if (__temp != __last && __first == '?' && __temp == ':')
	{
	++__open_count_;
	__first = __parse_ecma_exp(++__temp, __last);
	if (__first == __last \|\| *__first != ')')
	__throw_regex_error<regex_constants::error_paren>();
	--__open_count_;
	++__first;
	}
	else
	{
	__push_begin_marked_subexpression();
	unsigned __temp_count = __marked_count_;
	++__open_count_;
	__first = __parse_ecma_exp(__first, __last);
	if (__first == __last \|\| *__first != ')')
	__throw_regex_error<regex_constants::error_paren>();
	__push_end_marked_subexpression(__temp_count);
	--__open_count_;
	++__first;
	}
	}
	break;
	case '*':
	case '+':
	case '?':
	case '{':
	__throw_regex_error<regex_constants::error_badrepeat>();
	break;
	default:
	__first = __parse_pattern_character(__first, __last);
	break;
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_atom_escape(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last && *__first == '\\')
	{
	_ForwardIterator __t1 = _VSTD::next(__first);
	if (__t1 == __last)
	__throw_regex_error<regex_constants::error_escape>();

	_ForwardIterator __t2 = __parse_decimal_escape(__t1, __last);
	if (__t2 != __t1)
	__first = __t2;
	else
	{
	__t2 = __parse_character_class_escape(__t1, __last);
	if (__t2 != __t1)
	__first = __t2;
	else
	{
	__t2 = __parse_character_escape(__t1, __last);
	if (__t2 != __t1)
	__first = __t2;
	}
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_decimal_escape(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last)
	{
	if (*__first == '0')
	{
	__push_char(_CharT());
	++__first;
	}
	else if ('1' <= __first && __first <= '9')
	{
	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 == 0 \|\| __v > mark_count())
	__throw_regex_error<regex_constants::error_backref>();
	__push_back_ref(__v);
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_character_class_escape(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last)
	{
	__bracket_expression<_CharT, _Traits>* __ml;
	switch (*__first)
	{
	case 'd':
	__ml = __start_matching_list(false);
	__ml->__add_class(ctype_base::digit);
	++__first;
	break;
	case 'D':
	__ml = __start_matching_list(true);
	__ml->__add_class(ctype_base::digit);
	++__first;
	break;
	case 's':
	__ml = __start_matching_list(false);
	__ml->__add_class(ctype_base::space);
	++__first;
	break;
	case 'S':
	__ml = __start_matching_list(true);
	__ml->__add_class(ctype_base::space);
	++__first;
	break;
	case 'w':
	__ml = __start_matching_list(false);
	__ml->__add_class(ctype_base::alnum);
	__ml->__add_char('_');
	++__first;
	break;
	case 'W':
	__ml = __start_matching_list(true);
	__ml->__add_class(ctype_base::alnum);
	__ml->__add_char('_');
	++__first;
	break;
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_character_escape(_ForwardIterator __first,
	_ForwardIterator __last,
	basic_string<_CharT>* __str)
	{
	if (__first != __last)
	{
	_ForwardIterator __t;
	unsigned __sum = 0;
	int __hd;
	switch (*__first)
	{
	case 'f':
	if (__str)
	*__str = _CharT(0xC);
	else
	__push_char(_CharT(0xC));
	++__first;
	break;
	case 'n':
	if (__str)
	*__str = _CharT(0xA);
	else
	__push_char(_CharT(0xA));
	++__first;
	break;
	case 'r':
	if (__str)
	*__str = _CharT(0xD);
	else
	__push_char(_CharT(0xD));
	++__first;
	break;
	case 't':
	if (__str)
	*__str = _CharT(0x9);
	else
	__push_char(_CharT(0x9));
	++__first;
	break;
	case 'v':
	if (__str)
	*__str = _CharT(0xB);
	else
	__push_char(_CharT(0xB));
	++__first;
	break;
	case 'c':
	if ((__t = _VSTD::next(__first)) != __last)
	{
	if (('A' <= __t && __t <= 'Z') \|\|
	('a' <= __t && __t <= 'z'))
	{
	if (__str)
	__str = _CharT(__t % 32);
	else
	__push_char(_CharT(*__t % 32));
	__first = ++__t;
	}
	else
	__throw_regex_error<regex_constants::error_escape>();
	}
	else
	__throw_regex_error<regex_constants::error_escape>();
	break;
	case 'u':
	++__first;
	if (__first == __last)
	__throw_regex_error<regex_constants::error_escape>();
	__hd = __traits_.value(*__first, 16);
	if (__hd == -1)
	__throw_regex_error<regex_constants::error_escape>();
	__sum = 16 * __sum + static_cast<unsigned>(__hd);
	++__first;
	if (__first == __last)
	__throw_regex_error<regex_constants::error_escape>();
	__hd = __traits_.value(*__first, 16);
	if (__hd == -1)
	__throw_regex_error<regex_constants::error_escape>();
	__sum = 16 * __sum + static_cast<unsigned>(__hd);
	// drop through
	case 'x':
	++__first;
	if (__first == __last)
	__throw_regex_error<regex_constants::error_escape>();
	__hd = __traits_.value(*__first, 16);
	if (__hd == -1)
	__throw_regex_error<regex_constants::error_escape>();
	__sum = 16 * __sum + static_cast<unsigned>(__hd);
	++__first;
	if (__first == __last)
	__throw_regex_error<regex_constants::error_escape>();
	__hd = __traits_.value(*__first, 16);
	if (__hd == -1)
	__throw_regex_error<regex_constants::error_escape>();
	__sum = 16 * __sum + static_cast<unsigned>(__hd);
	if (__str)
	*__str = _CharT(__sum);
	else
	__push_char(_CharT(__sum));
	++__first;
	break;
	case '0':
	if (__str)
	*__str = _CharT(0);
	else
	__push_char(_CharT(0));
	++__first;
	break;
	default:
	if (__first != '_' && !__traits_.isctype(__first, ctype_base::alnum))
	{
	if (__str)
	__str = __first;
	else
	__push_char(*__first);
	++__first;
	}
	else
	__throw_regex_error<regex_constants::error_escape>();
	break;
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_pattern_character(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	if (__first != __last)
	{
	switch (*__first)
	{
	case '^':
	case '$':
	case '\\':
	case '.':
	case '*':
	case '+':
	case '?':
	case '(':
	case ')':
	case '[':
	case ']':
	case '{':
	case '}':
	case '\|':
	break;
	default:
	__push_char(*__first);
	++__first;
	break;
	}
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_grep(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	__owns_one_state<_CharT>* __sa = __end_;
	_ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
	if (__t1 != __first)
	__parse_basic_reg_exp(__first, __t1);
	else
	__push_empty();
	__first = __t1;
	if (__first != __last)
	++__first;
	while (__first != __last)
	{
	__t1 = _VSTD::find(__first, __last, _CharT('\n'));
	__owns_one_state<_CharT>* __sb = __end_;
	if (__t1 != __first)
	__parse_basic_reg_exp(__first, __t1);
	else
	__push_empty();
	__push_alternation(__sa, __sb);
	__first = __t1;
	if (__first != __last)
	++__first;
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	template <class _ForwardIterator>
	_ForwardIterator
	basic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first,
	_ForwardIterator __last)
	{
	__owns_one_state<_CharT>* __sa = __end_;
	_ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
	if (__t1 != __first)
	__parse_extended_reg_exp(__first, __t1);
	else
	__push_empty();
	__first = __t1;
	if (__first != __last)
	++__first;
	while (__first != __last)
	{
	__t1 = _VSTD::find(__first, __last, _CharT('\n'));
	__owns_one_state<_CharT>* __sb = __end_;
	if (__t1 != __first)
	__parse_extended_reg_exp(__first, __t1);
	else
	__push_empty();
	__push_alternation(__sa, __sb);
	__first = __t1;
	if (__first != __last)
	++__first;
	}
	return __first;
	}

	template <class _CharT, class _Traits>
	void
	basic_regex<_CharT, _Traits>::__push_loop(size_t __min, size_t __max,
	__owns_one_state<_CharT>* __s, size_t __mexp_begin, size_t __mexp_end,
	bool __greedy)
	{
	unique_ptr<__empty_state<_CharT> > __e1(new __empty_state<_CharT>(__end_->first()));
	__end_->first() = nullptr;
	unique_ptr<__loop<_CharT> > __e2(new __loop<_CharT>(__loop_count_,
	__s->first(), __e1.get(), __mexp_begin, __mexp_end, __greedy,
	__min, __max));
	__s->first() = nullptr;
	__e1.release();
	__end_->first() = new __repeat_one_loop<_CharT>(__e2.get());
	__end_ = __e2->second();
	__s->first() = __e2.release();
	++__loop_count_;
	}

	template <class _CharT, class _Traits>
	void
	basic_regex<_CharT, _Traits>::__push_char(value_type __c)
	{
	if (flags() & icase)
	__end_->first() = new __match_char_icase<_CharT, _Traits>
	(__traits_, __c, __end_->first());
	else if (flags() & collate)
	__end_->first() = new __match_char_collate<_CharT, _Traits>
	(__traits_, __c, __end_->first());
	else
	__end_->first() = new __match_char<_CharT>(__c, __end_->first());
	__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
	}

	template <class _CharT, class _Traits>
	void
	basic_regex<_CharT, _Traits>::__push_begin_marked_subexpression()
	{
	if (!(__flags_ & nosubs))
	{
	__end_->first() =
	new __begin_marked_subexpression<_CharT>(++__marked_count_,
	__end_->first());
	__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
	}
	}

	template <class _CharT, class _Traits>
	void
	basic_regex<_CharT, _Traits>::__push_end_marked_subexpression(unsigned __sub)
	{
	if (!(__flags_ & nosubs))
	{
	__end_->first() =
	new __end_marked_subexpression<_CharT>(__sub, __end_->first());
	__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
	}
	}

	template <class _CharT, class _Traits>
	void
	basic_regex<_CharT, _Traits>::__push_l_anchor()
	{
	__end_->first() = new __l_anchor<_CharT>(__end_->first());
	__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
	}

	template <class _CharT, class _Traits>
	void
	basic_regex<_CharT, _Traits>::__push_r_anchor()
	{
	__end_->first() = new __r_anchor<_CharT>(__end_->first());
	__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
	}

	template <class _CharT, class _Traits>
	void
	basic_regex<_CharT, _Traits>::__push_match_any()
	{
	__end_->first() = new __match_any<_CharT>(__end_->first());
	__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
	}

	template <class _CharT, class _Traits>
	void
	basic_regex<_CharT, _Traits>::__push_match_any_but_newline()
	{
	__end_->first() = new __match_any_but_newline<_CharT>(__end_->first());
	__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
	}

	template <class _CharT, class _Traits>
	void
	basic_regex<_CharT, _Traits>::__push_empty()
	{
	__end_->first() = new __empty_state<_CharT>(__end_->first());
	__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
	}

	template <class _CharT, class _Traits>
	void
	basic_regex<_CharT, _Traits>::__push_word_boundary(bool __invert)
	{
	__end_->first() = new __word_boundary<_CharT, _Traits>(__traits_, __invert,
	__end_->first());
	__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
	}

	template <class _CharT, class _Traits>
	void
	basic_regex<_CharT, _Traits>::__push_back_ref(int __i)
	{
	if (flags() & icase)
	__end_->first() = new __back_ref_icase<_CharT, _Traits>
	(__traits_, __i, __end_->first());
	else if (flags() & collate)
	__end_->first() = new __back_ref_collate<_CharT, _Traits>
	(__traits_, __i, __end_->first());
	else
	__end_->first() = new __back_ref<_CharT>(__i, __end_->first());
	__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
	}

	template <class _CharT, class _Traits>
	void
	basic_regex<_CharT, _Traits>::__push_alternation(__owns_one_state<_CharT>* __sa,
	__owns_one_state<_CharT>* __ea)
	{
	__sa->first() = new __alternate<_CharT>(
	static_cast<__owns_one_state<_CharT>*>(__sa->first()),
	static_cast<__owns_one_state<_CharT>*>(__ea->first()));
	__ea->first() = nullptr;
	__ea->first() = new __empty_state<_CharT>(__end_->first());
	__end_->first() = nullptr;
	__end_->first() = new __empty_non_own_state<_CharT>(__ea->first());
	__end_ = static_cast<__owns_one_state<_CharT>*>(__ea->first());
	}

	template <class _CharT, class _Traits>
	__bracket_expression<_CharT, _Traits>*
	basic_regex<_CharT, _Traits>::__start_matching_list(bool __negate)
	{
	__bracket_expression<_CharT, _Traits>* __r =
	new __bracket_expression<_CharT, _Traits>(__traits_, __end_->first(),
	__negate, __flags_ & icase,
	__flags_ & collate);
	__end_->first() = __r;
	__end_ = __r;
	return __r;
	}

	template <class _CharT, class _Traits>
	void
	basic_regex<_CharT, _Traits>::__push_lookahead(const basic_regex& __exp,
	bool __invert,
	unsigned __mexp)
	{
	__end_->first() = new __lookahead<_CharT, _Traits>(__exp, __invert,
	__end_->first(), __mexp);
	__end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
	}

	typedef basic_regex<char> regex;
	typedef basic_regex<wchar_t> wregex;

	// sub_match

	template <class _BidirectionalIterator>
	class _LIBCPP_TEMPLATE_VIS sub_match
	: public pair<_BidirectionalIterator, _BidirectionalIterator>
	{
	public:
	typedef _BidirectionalIterator iterator;
	typedef typename iterator_traits<iterator>::value_type value_type;
	typedef typename iterator_traits<iterator>::difference_type difference_type;
	typedef basic_string<value_type> string_type;

	bool matched;

	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR sub_match() : matched() {}

	_LIBCPP_INLINE_VISIBILITY
	difference_type length() const
	{return matched ? _VSTD::distance(this->first, this->second) : 0;}
	_LIBCPP_INLINE_VISIBILITY
	string_type str() const
	{return matched ? string_type(this->first, this->second) : string_type();}
	_LIBCPP_INLINE_VISIBILITY
	operator string_type() const
	{return str();}

	_LIBCPP_INLINE_VISIBILITY
	int compare(const sub_match& __s) const
	{return str().compare(__s.str());}
	_LIBCPP_INLINE_VISIBILITY
	int compare(const string_type& __s) const
	{return str().compare(__s);}
	_LIBCPP_INLINE_VISIBILITY
	int compare(const value_type* __s) const
	{return str().compare(__s);}
	};

	typedef sub_match<const char*> csub_match;
	typedef sub_match<const wchar_t*> wcsub_match;
	typedef sub_match<string::const_iterator> ssub_match;
	typedef sub_match<wstring::const_iterator> wssub_match;

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
	{
	return __x.compare(__y) == 0;
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
	{
	return !(__x == __y);
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
	{
	return __x.compare(__y) < 0;
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
	{
	return !(__y < __x);
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
	{
	return !(__x < __y);
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
	{
	return __y < __x;
	}

	template <class _BiIter, class _ST, class _SA>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
	const sub_match<_BiIter>& __y)
	{
	return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) == 0;
	}

	template <class _BiIter, class _ST, class _SA>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
	const sub_match<_BiIter>& __y)
	{
	return !(__x == __y);
	}

	template <class _BiIter, class _ST, class _SA>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
	const sub_match<_BiIter>& __y)
	{
	return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) > 0;
	}

	template <class _BiIter, class _ST, class _SA>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
	const sub_match<_BiIter>& __y)
	{
	return __y < __x;
	}

	template <class _BiIter, class _ST, class _SA>
	inline _LIBCPP_INLINE_VISIBILITY
	bool operator>=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
	const sub_match<_BiIter>& __y)
	{
	return !(__x < __y);
	}

	template <class _BiIter, class _ST, class _SA>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
	const sub_match<_BiIter>& __y)
	{
	return !(__y < __x);
	}

	template <class _BiIter, class _ST, class _SA>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const sub_match<_BiIter>& __x,
	const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
	{
	return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) == 0;
	}

	template <class _BiIter, class _ST, class _SA>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const sub_match<_BiIter>& __x,
	const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
	{
	return !(__x == __y);
	}

	template <class _BiIter, class _ST, class _SA>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<(const sub_match<_BiIter>& __x,
	const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
	{
	return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) < 0;
	}

	template <class _BiIter, class _ST, class _SA>
	inline _LIBCPP_INLINE_VISIBILITY
	bool operator>(const sub_match<_BiIter>& __x,
	const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
	{
	return __y < __x;
	}

	template <class _BiIter, class _ST, class _SA>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const sub_match<_BiIter>& __x,
	const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
	{
	return !(__x < __y);
	}

	template <class _BiIter, class _ST, class _SA>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const sub_match<_BiIter>& __x,
	const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
	{
	return !(__y < __x);
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(typename iterator_traits<_BiIter>::value_type const* __x,
	const sub_match<_BiIter>& __y)
	{
	return __y.compare(__x) == 0;
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(typename iterator_traits<_BiIter>::value_type const* __x,
	const sub_match<_BiIter>& __y)
	{
	return !(__x == __y);
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<(typename iterator_traits<_BiIter>::value_type const* __x,
	const sub_match<_BiIter>& __y)
	{
	return __y.compare(__x) > 0;
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>(typename iterator_traits<_BiIter>::value_type const* __x,
	const sub_match<_BiIter>& __y)
	{
	return __y < __x;
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(typename iterator_traits<_BiIter>::value_type const* __x,
	const sub_match<_BiIter>& __y)
	{
	return !(__x < __y);
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(typename iterator_traits<_BiIter>::value_type const* __x,
	const sub_match<_BiIter>& __y)
	{
	return !(__y < __x);
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const sub_match<_BiIter>& __x,
	typename iterator_traits<_BiIter>::value_type const* __y)
	{
	return __x.compare(__y) == 0;
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const sub_match<_BiIter>& __x,
	typename iterator_traits<_BiIter>::value_type const* __y)
	{
	return !(__x == __y);
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<(const sub_match<_BiIter>& __x,
	typename iterator_traits<_BiIter>::value_type const* __y)
	{
	return __x.compare(__y) < 0;
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>(const sub_match<_BiIter>& __x,
	typename iterator_traits<_BiIter>::value_type const* __y)
	{
	return __y < __x;
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const sub_match<_BiIter>& __x,
	typename iterator_traits<_BiIter>::value_type const* __y)
	{
	return !(__x < __y);
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const sub_match<_BiIter>& __x,
	typename iterator_traits<_BiIter>::value_type const* __y)
	{
	return !(__y < __x);
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(typename iterator_traits<_BiIter>::value_type const& __x,
	const sub_match<_BiIter>& __y)
	{
	typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
	return __y.compare(string_type(1, __x)) == 0;
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(typename iterator_traits<_BiIter>::value_type const& __x,
	const sub_match<_BiIter>& __y)
	{
	return !(__x == __y);
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<(typename iterator_traits<_BiIter>::value_type const& __x,
	const sub_match<_BiIter>& __y)
	{
	typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
	return __y.compare(string_type(1, __x)) > 0;
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>(typename iterator_traits<_BiIter>::value_type const& __x,
	const sub_match<_BiIter>& __y)
	{
	return __y < __x;
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(typename iterator_traits<_BiIter>::value_type const& __x,
	const sub_match<_BiIter>& __y)
	{
	return !(__x < __y);
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(typename iterator_traits<_BiIter>::value_type const& __x,
	const sub_match<_BiIter>& __y)
	{
	return !(__y < __x);
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const sub_match<_BiIter>& __x,
	typename iterator_traits<_BiIter>::value_type const& __y)
	{
	typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
	return __x.compare(string_type(1, __y)) == 0;
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const sub_match<_BiIter>& __x,
	typename iterator_traits<_BiIter>::value_type const& __y)
	{
	return !(__x == __y);
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<(const sub_match<_BiIter>& __x,
	typename iterator_traits<_BiIter>::value_type const& __y)
	{
	typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
	return __x.compare(string_type(1, __y)) < 0;
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>(const sub_match<_BiIter>& __x,
	typename iterator_traits<_BiIter>::value_type const& __y)
	{
	return __y < __x;
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const sub_match<_BiIter>& __x,
	typename iterator_traits<_BiIter>::value_type const& __y)
	{
	return !(__x < __y);
	}

	template <class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const sub_match<_BiIter>& __x,
	typename iterator_traits<_BiIter>::value_type const& __y)
	{
	return !(__y < __x);
	}

	template <class _CharT, class _ST, class _BiIter>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ostream<_CharT, _ST>&
	operator<<(basic_ostream<_CharT, _ST>& __os, const sub_match<_BiIter>& __m)
	{
	return __os << __m.str();
	}

	template <class _BidirectionalIterator, class _Allocator>
	class _LIBCPP_TEMPLATE_VIS match_results
	{
	public:
	typedef _Allocator allocator_type;
	typedef sub_match<_BidirectionalIterator> value_type;
	private:
	typedef vector<value_type, allocator_type> __container_type;

	__container_type __matches_;
	value_type __unmatched_;
	value_type __prefix_;
	value_type __suffix_;
	bool __ready_;
	public:
	_BidirectionalIterator __position_start_;
	typedef const value_type& const_reference;
	typedef value_type& reference;
	typedef typename __container_type::const_iterator const_iterator;
	typedef const_iterator iterator;
	typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
	typedef typename allocator_traits<allocator_type>::size_type size_type;
	typedef typename iterator_traits<_BidirectionalIterator>::value_type char_type;
	typedef basic_string<char_type> string_type;

	// construct/copy/destroy:
	explicit match_results(const allocator_type& __a = allocator_type());
	// match_results(const match_results&) = default;
	// match_results& operator=(const match_results&) = default;
	// match_results(match_results&& __m) = default;
	// match_results& operator=(match_results&& __m) = default;
	// ~match_results() = default;

	_LIBCPP_INLINE_VISIBILITY
	bool ready() const {return __ready_;}

	// size:
	_LIBCPP_INLINE_VISIBILITY
	size_type size() const _NOEXCEPT {return __matches_.size();}
	_LIBCPP_INLINE_VISIBILITY
	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
	difference_type length(size_type __sub = 0) const
	{return (*this)[__sub].length();}
	_LIBCPP_INLINE_VISIBILITY
	difference_type position(size_type __sub = 0) const
	{return _VSTD::distance(__position_start_, (*this)[__sub].first);}
	_LIBCPP_INLINE_VISIBILITY
	string_type str(size_type __sub = 0) const
	{return (*this)[__sub].str();}
	_LIBCPP_INLINE_VISIBILITY
	const_reference operator[](size_type __n) const
	{return __n < __matches_.size() ? __matches_[__n] : __unmatched_;}

	_LIBCPP_INLINE_VISIBILITY
	const_reference prefix() const {return __prefix_;}
	_LIBCPP_INLINE_VISIBILITY
	const_reference suffix() const {return __suffix_;}

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

	// format:
	template <class _OutputIter>
	_OutputIter
	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_iter, const basic_string<char_type, _ST, _SA>& __fmt,
	regex_constants::match_flag_type __flags = regex_constants::format_default) const
	{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>
	format(const basic_string<char_type, _ST, _SA>& __fmt,
	regex_constants::match_flag_type __flags = regex_constants::format_default) const
	{
	basic_string<char_type, _ST, _SA> __r;
	format(back_inserter(__r), __fmt.data(), __fmt.data() + __fmt.size(),
	__flags);
	return __r;
	}
	_LIBCPP_INLINE_VISIBILITY
	string_type
	format(const char_type* __fmt,
	regex_constants::match_flag_type __flags = regex_constants::format_default) const
	{
	string_type __r;
	format(back_inserter(__r), __fmt,
	__fmt + char_traits<char_type>::length(__fmt), __flags);
	return __r;
	}

	// allocator:
	_LIBCPP_INLINE_VISIBILITY
	allocator_type get_allocator() const {return __matches_.get_allocator();}

	// swap:
	void swap(match_results& __m);

	template <class _Bp, class _Ap>
	_LIBCPP_INLINE_VISIBILITY
	void __assign(_BidirectionalIterator __f, _BidirectionalIterator __l,
	const match_results<_Bp, _Ap>& __m, bool __no_update_pos)
	{
	_Bp __mf = __m.prefix().first;
	__matches_.resize(__m.size());
	for (size_type __i = 0; __i < __matches_.size(); ++__i)
	{
	__matches_[__i].first = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].first));
	__matches_[__i].second = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].second));
	__matches_[__i].matched = __m[__i].matched;
	}
	__unmatched_.first = __l;
	__unmatched_.second = __l;
	__unmatched_.matched = false;
	__prefix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().first));
	__prefix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().second));
	__prefix_.matched = __m.prefix().matched;
	__suffix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().first));
	__suffix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().second));
	__suffix_.matched = __m.suffix().matched;
	if (!__no_update_pos)
	__position_start_ = __prefix_.first;
	__ready_ = __m.ready();
	}

	private:
	void __init(unsigned __s,
	_BidirectionalIterator __f, _BidirectionalIterator __l,
	bool __no_update_pos = false);

	template <class, class> friend class basic_regex;

	template <class _Bp, class _Ap, class _Cp, class _Tp>
	friend
	bool
	regex_match(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&,
	regex_constants::match_flag_type);

	template <class _Bp, class _Ap>
	friend
	bool
	operator==(const match_results<_Bp, _Ap>&, const match_results<_Bp, _Ap>&);

	template <class, class> friend class __lookahead;
	};

	template <class _BidirectionalIterator, class _Allocator>
	match_results<_BidirectionalIterator, _Allocator>::match_results(
	const allocator_type& __a)
	: __matches_(__a),
	__unmatched_(),
	__prefix_(),
	__suffix_(),
	__ready_(false),
	__position_start_()
	{
	}

	template <class _BidirectionalIterator, class _Allocator>
	void
	match_results<_BidirectionalIterator, _Allocator>::__init(unsigned __s,
	_BidirectionalIterator __f, _BidirectionalIterator __l,
	bool __no_update_pos)
	{
	__unmatched_.first = __l;
	__unmatched_.second = __l;
	__unmatched_.matched = false;
	__matches_.assign(__s, __unmatched_);
	__prefix_.first = __f;
	__prefix_.second = __f;
	__prefix_.matched = false;
	__suffix_ = __unmatched_;
	if (!__no_update_pos)
	__position_start_ = __prefix_.first;
	__ready_ = true;
	}

	template <class _BidirectionalIterator, class _Allocator>
	template <class _OutputIter>
	_OutputIter
	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
	{
	if (__flags & regex_constants::format_sed)
	{
	for (; __fmt_first != __fmt_last; ++__fmt_first)
	{
	if (*__fmt_first == '&')
	__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_iter = _VSTD::copy((*this)[__i].first,
	(*this)[__i].second, __output_iter);
	}
	else
	{
	__output_iter = __fmt_first;
	++__output_iter;
	}
	}
	else
	{
	__output_iter = __fmt_first;
	++__output_iter;
	}
	}
	}
	else
	{
	for (; __fmt_first != __fmt_last; ++__fmt_first)
	{
	if (*__fmt_first == '$' && __fmt_first + 1 != __fmt_last)
	{
	switch (__fmt_first[1])
	{
	case '$':
	__output_iter = ++__fmt_first;
	++__output_iter;
	break;
	case '&':
	++__fmt_first;
	__output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second,
	__output_iter);
	break;
	case '`':
	++__fmt_first;
	__output_iter = _VSTD::copy(__prefix_.first, __prefix_.second, __output_iter);
	break;
	case '\'':
	++__fmt_first;
	__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 __idx = *__fmt_first - '0';
	if (__fmt_first + 1 != __fmt_last &&
	'0' <= __fmt_first[1] && __fmt_first[1] <= '9')
	{
	++__fmt_first;
	if (__idx >= std::numeric_limits<size_t>::max() / 10)
	__throw_regex_error<regex_constants::error_escape>();
	__idx = 10 * __idx + *__fmt_first - '0';
	}
	__output_iter = _VSTD::copy((*this)[__idx].first,
	(*this)[__idx].second, __output_iter);
	}
	else
	{
	__output_iter = __fmt_first;
	++__output_iter;
	}
	break;
	}
	}
	else
	{
	__output_iter = __fmt_first;
	++__output_iter;
	}
	}
	}
	return __output_iter;
	}

	template <class _BidirectionalIterator, class _Allocator>
	void
	match_results<_BidirectionalIterator, _Allocator>::swap(match_results& __m)
	{
	using _VSTD::swap;
	swap(__matches_, __m.__matches_);
	swap(__unmatched_, __m.__unmatched_);
	swap(__prefix_, __m.__prefix_);
	swap(__suffix_, __m.__suffix_);
	swap(__position_start_, __m.__position_start_);
	swap(__ready_, __m.__ready_);
	}

	typedef match_results<const char*> cmatch;
	typedef match_results<const wchar_t*> wcmatch;
	typedef match_results<string::const_iterator> smatch;
	typedef match_results<wstring::const_iterator> wsmatch;

	template <class _BidirectionalIterator, class _Allocator>
	bool
	operator==(const match_results<_BidirectionalIterator, _Allocator>& __x,
	const match_results<_BidirectionalIterator, _Allocator>& __y)
	{
	if (__x.__ready_ != __y.__ready_)
	return false;
	if (!__x.__ready_)
	return true;
	return __x.__matches_ == __y.__matches_ &&
	__x.__prefix_ == __y.__prefix_ &&
	__x.__suffix_ == __y.__suffix_;
	}

	template <class _BidirectionalIterator, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const match_results<_BidirectionalIterator, _Allocator>& __x,
	const match_results<_BidirectionalIterator, _Allocator>& __y)
	{
	return !(__x == __y);
	}

	template <class _BidirectionalIterator, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(match_results<_BidirectionalIterator, _Allocator>& __x,
	match_results<_BidirectionalIterator, _Allocator>& __y)
	{
	__x.swap(__y);
	}

	// regex_search

	template <class _CharT, class _Traits>
	template <class _Allocator>
	bool
	basic_regex<_CharT, _Traits>::__match_at_start_ecma(
	const _CharT* __first, const _CharT* __last,
	match_results<const _CharT*, _Allocator>& __m,
	regex_constants::match_flag_type __flags, bool __at_first) const
	{
	vector<__state> __states;
	__node* __st = __start_.get();
	if (__st)
	{
	sub_match<const _CharT*> __unmatched;
	__unmatched.first = __last;
	__unmatched.second = __last;
	__unmatched.matched = false;

	__states.push_back(__state());
	__states.back().__do_ = 0;
	__states.back().__first_ = __first;
	__states.back().__current_ = __first;
	__states.back().__last_ = __last;
	__states.back().__sub_matches_.resize(mark_count(), __unmatched);
	__states.back().__loop_data_.resize(__loop_count());
	__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);
	switch (__s.__do_)
	{
	case __state::__end_state:
	if ((__flags & regex_constants::match_not_null) &&
	__s.__current_ == __first)
	{
	__states.pop_back();
	break;
	}
	if ((__flags & regex_constants::__full_match) &&
	__s.__current_ != __last)
	{
	__states.pop_back();
	break;
	}
	__m.__matches_[0].first = __first;
	__m.__matches_[0].second = _VSTD::next(__first, __s.__current_ - __first);
	__m.__matches_[0].matched = true;
	for (unsigned __i = 0; __i < __s.__sub_matches_.size(); ++__i)
	__m.__matches_[__i+1] = __s.__sub_matches_[__i];
	return true;
	case __state::__accept_and_consume:
	case __state::__repeat:
	case __state::__accept_but_not_consume:
	break;
	case __state::__split:
	{
	__state __snext = __s;
	__s.__node_->__exec_split(true, __s);
	__snext.__node_->__exec_split(false, __snext);
	__states.push_back(_VSTD::move(__snext));
	}
	break;
	case __state::__reject:
	__states.pop_back();
	break;
	default:
	__throw_regex_error<regex_constants::__re_err_unknown>();
	break;

	}
	} while (!__states.empty());
	}
	return false;
	}

	template <class _CharT, class _Traits>
	template <class _Allocator>
	bool
	basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
	const _CharT* __first, const _CharT* __last,
	match_results<const _CharT*, _Allocator>& __m,
	regex_constants::match_flag_type __flags, bool __at_first) const
	{
	deque<__state> __states;
	ptrdiff_t __highest_j = 0;
	ptrdiff_t _Np = _VSTD::distance(__first, __last);
	__node* __st = __start_.get();
	if (__st)
	{
	__states.push_back(__state());
	__states.back().__do_ = 0;
	__states.back().__first_ = __first;
	__states.back().__current_ = __first;
	__states.back().__last_ = __last;
	__states.back().__loop_data_.resize(__loop_count());
	__states.back().__node_ = __st;
	__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);
	switch (__s.__do_)
	{
	case __state::__end_state:
	if ((__flags & regex_constants::match_not_null) &&
	__s.__current_ == __first)
	{
	__states.pop_back();
	break;
	}
	if ((__flags & regex_constants::__full_match) &&
	__s.__current_ != __last)
	{
	__states.pop_back();
	break;
	}
	if (!__matched \|\| __highest_j < __s.__current_ - __s.__first_)
	__highest_j = __s.__current_ - __s.__first_;
	__matched = true;
	if (__highest_j == _Np)
	__states.clear();
	else
	__states.pop_back();
	break;
	case __state::__consume_input:
	break;
	case __state::__accept_and_consume:
	__states.push_front(_VSTD::move(__s));
	__states.pop_back();
	break;
	case __state::__repeat:
	case __state::__accept_but_not_consume:
	break;
	case __state::__split:
	{
	__state __snext = __s;
	__s.__node_->__exec_split(true, __s);
	__snext.__node_->__exec_split(false, __snext);
	__states.push_back(_VSTD::move(__snext));
	}
	break;
	case __state::__reject:
	__states.pop_back();
	break;
	default:
	__throw_regex_error<regex_constants::__re_err_unknown>();
	break;
	}
	} while (!__states.empty());
	if (__matched)
	{
	__m.__matches_[0].first = __first;
	__m.__matches_[0].second = _VSTD::next(__first, __highest_j);
	__m.__matches_[0].matched = true;
	return true;
	}
	}
	return false;
	}

	template <class _CharT, class _Traits>
	template <class _Allocator>
	bool
	basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
	const _CharT* __first, const _CharT* __last,
	match_results<const _CharT*, _Allocator>& __m,
	regex_constants::match_flag_type __flags, bool __at_first) const
	{
	vector<__state> __states;
	__state __best_state;
	ptrdiff_t __j = 0;
	ptrdiff_t __highest_j = 0;
	ptrdiff_t _Np = _VSTD::distance(__first, __last);
	__node* __st = __start_.get();
	if (__st)
	{
	sub_match<const _CharT*> __unmatched;
	__unmatched.first = __last;
	__unmatched.second = __last;
	__unmatched.matched = false;

	__states.push_back(__state());
	__states.back().__do_ = 0;
	__states.back().__first_ = __first;
	__states.back().__current_ = __first;
	__states.back().__last_ = __last;
	__states.back().__sub_matches_.resize(mark_count(), __unmatched);
	__states.back().__loop_data_.resize(__loop_count());
	__states.back().__node_ = __st;
	__states.back().__flags_ = __flags;
	__states.back().__at_first_ = __at_first;
	const _CharT* __current = __first;
	bool __matched = false;
	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);
	switch (__s.__do_)
	{
	case __state::__end_state:
	if ((__flags & regex_constants::match_not_null) &&
	__s.__current_ == __first)
	{
	__states.pop_back();
	break;
	}
	if ((__flags & regex_constants::__full_match) &&
	__s.__current_ != __last)
	{
	__states.pop_back();
	break;
	}
	if (!__matched \|\| __highest_j < __s.__current_ - __s.__first_)
	{
	__highest_j = __s.__current_ - __s.__first_;
	__best_state = __s;
	}
	__matched = true;
	if (__highest_j == _Np)
	__states.clear();
	else
	__states.pop_back();
	break;
	case __state::__accept_and_consume:
	__j += __s.__current_ - __current;
	__current = __s.__current_;
	break;
	case __state::__repeat:
	case __state::__accept_but_not_consume:
	break;
	case __state::__split:
	{
	__state __snext = __s;
	__s.__node_->__exec_split(true, __s);
	__snext.__node_->__exec_split(false, __snext);
	__states.push_back(_VSTD::move(__snext));
	}
	break;
	case __state::__reject:
	__states.pop_back();
	break;
	default:
	__throw_regex_error<regex_constants::__re_err_unknown>();
	break;
	}
	} while (!__states.empty());
	if (__matched)
	{
	__m.__matches_[0].first = __first;
	__m.__matches_[0].second = _VSTD::next(__first, __highest_j);
	__m.__matches_[0].matched = true;
	for (unsigned __i = 0; __i < __best_state.__sub_matches_.size(); ++__i)
	__m.__matches_[__i+1] = __best_state.__sub_matches_[__i];
	return true;
	}
	}
	return false;
	}

	template <class _CharT, class _Traits>
	template <class _Allocator>
	bool
	basic_regex<_CharT, _Traits>::__match_at_start(
	const _CharT* __first, const _CharT* __last,
	match_results<const _CharT*, _Allocator>& __m,
	regex_constants::match_flag_type __flags, bool __at_first) const
	{
	if ((__flags_ & 0x1F0) == ECMAScript)
	return __match_at_start_ecma(__first, __last, __m, __flags, __at_first);
	if (mark_count() == 0)
	return __match_at_start_posix_nosubs(__first, __last, __m, __flags, __at_first);
	return __match_at_start_posix_subs(__first, __last, __m, __flags, __at_first);
	}

	template <class _CharT, class _Traits>
	template <class _Allocator>
	bool
	basic_regex<_CharT, _Traits>::__search(
	const _CharT* __first, const _CharT* __last,
	match_results<const _CharT*, _Allocator>& __m,
	regex_constants::match_flag_type __flags) const
	{
	__m.__init(1 + mark_count(), __first, __last,
	__flags & regex_constants::__no_update_pos);
	if (__match_at_start(__first, __last, __m, __flags,
	!(__flags & regex_constants::__no_update_pos)))
	{
	__m.__prefix_.second = __m[0].first;
	__m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
	__m.__suffix_.first = __m[0].second;
	__m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second;
	return true;
	}
	if (__first != __last && !(__flags & regex_constants::match_continuous))
	{
	__flags \|= regex_constants::match_prev_avail;
	for (++__first; __first != __last; ++__first)
	{
	__m.__matches_.assign(__m.size(), __m.__unmatched_);
	if (__match_at_start(__first, __last, __m, __flags, false))
	{
	__m.__prefix_.second = __m[0].first;
	__m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
	__m.__suffix_.first = __m[0].second;
	__m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second;
	return true;
	}
	__m.__matches_.assign(__m.size(), __m.__unmatched_);
	}
	}
	__m.__matches_.clear();
	return false;
	}

	template <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	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)
	{
	int __offset = (__flags & regex_constants::match_prev_avail) ? 1 : 0;
	basic_string<_CharT> __s(_VSTD::prev(__first, __offset), __last);
	match_results<const _CharT*> __mc;
	bool __r = __e.__search(__s.data() + __offset, __s.data() + __s.size(), __mc, __flags);
	__m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos);
	return __r;
	}

	template <class _Iter, class _Allocator, class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	regex_search(__wrap_iter<_Iter> __first,
	__wrap_iter<_Iter> __last,
	match_results<__wrap_iter<_Iter>, _Allocator>& __m,
	const basic_regex<_CharT, _Traits>& __e,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	match_results<const _CharT*> __mc;
	bool __r = __e.__search(__first.base(), __last.base(), __mc, __flags);
	__m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos);
	return __r;
	}

	template <class _Allocator, class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	regex_search(const _CharT* __first, const _CharT* __last,
	match_results<const _CharT*, _Allocator>& __m,
	const basic_regex<_CharT, _Traits>& __e,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	return __e.__search(__first, __last, __m, __flags);
	}

	template <class _BidirectionalIterator, class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	regex_search(_BidirectionalIterator __first, _BidirectionalIterator __last,
	const basic_regex<_CharT, _Traits>& __e,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	basic_string<_CharT> __s(__first, __last);
	match_results<const _CharT*> __mc;
	return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	regex_search(const _CharT* __first, const _CharT* __last,
	const basic_regex<_CharT, _Traits>& __e,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	match_results<const _CharT*> __mc;
	return __e.__search(__first, __last, __mc, __flags);
	}

	template <class _CharT, class _Allocator, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	regex_search(const _CharT* __str, match_results<const _CharT*, _Allocator>& __m,
	const basic_regex<_CharT, _Traits>& __e,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	return __e.__search(__str, __str + _Traits::length(__str), __m, __flags);
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	regex_search(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	match_results<const _CharT*> __m;
	return _VSTD::regex_search(__str, __m, __e, __flags);
	}

	template <class _ST, class _SA, class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	regex_search(const basic_string<_CharT, _ST, _SA>& __s,
	const basic_regex<_CharT, _Traits>& __e,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	match_results<const _CharT*> __mc;
	return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
	}

	template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	regex_search(const basic_string<_CharT, _ST, _SA>& __s,
	match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
	const basic_regex<_CharT, _Traits>& __e,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	match_results<const _CharT*> __mc;
	bool __r = __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
	__m.__assign(__s.begin(), __s.end(), __mc, __flags & regex_constants::__no_update_pos);
	return __r;
	}

	#if _LIBCPP_STD_VER > 11
	template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
	bool
	regex_search(const basic_string<_Cp, _ST, _SA>&& __s,
	match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
	const basic_regex<_Cp, _Tp>& __e,
	regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
	#endif

	// regex_match

	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)
	{
	bool __r = _VSTD::regex_search(
	__first, __last, __m, __e,
	__flags \| regex_constants::match_continuous \|
	regex_constants::__full_match);
	if (__r)
	{
	__r = !__m.suffix().matched;
	if (!__r)
	__m.__matches_.clear();
	}
	return __r;
	}

	template <class _BidirectionalIterator, class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last,
	const basic_regex<_CharT, _Traits>& __e,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	match_results<_BidirectionalIterator> __m;
	return _VSTD::regex_match(__first, __last, __m, __e, __flags);
	}

	template <class _CharT, class _Allocator, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	regex_match(const _CharT* __str, match_results<const _CharT*, _Allocator>& __m,
	const basic_regex<_CharT, _Traits>& __e,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	return _VSTD::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags);
	}

	template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	regex_match(const basic_string<_CharT, _ST, _SA>& __s,
	match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
	const basic_regex<_CharT, _Traits>& __e,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	return _VSTD::regex_match(__s.begin(), __s.end(), __m, __e, __flags);
	}

	#if _LIBCPP_STD_VER > 11
	template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	regex_match(const basic_string<_CharT, _ST, _SA>&& __s,
	match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
	const basic_regex<_CharT, _Traits>& __e,
	regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
	#endif

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	regex_match(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	return _VSTD::regex_match(__str, __str + _Traits::length(__str), __e, __flags);
	}

	template <class _ST, class _SA, class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	regex_match(const basic_string<_CharT, _ST, _SA>& __s,
	const basic_regex<_CharT, _Traits>& __e,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	return _VSTD::regex_match(__s.begin(), __s.end(), __e, __flags);
	}

	// regex_iterator

	template <class _BidirectionalIterator,
	class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
	class _Traits = regex_traits<_CharT> >
	class _LIBCPP_TEMPLATE_VIS regex_iterator
	{
	public:
	typedef basic_regex<_CharT, _Traits> regex_type;
	typedef match_results<_BidirectionalIterator> value_type;
	typedef ptrdiff_t difference_type;
	typedef const value_type* pointer;
	typedef const value_type& reference;
	typedef forward_iterator_tag iterator_category;

	private:
	_BidirectionalIterator __begin_;
	_BidirectionalIterator __end_;
	const regex_type* __pregex_;
	regex_constants::match_flag_type __flags_;
	value_type __match_;

	public:
	regex_iterator();
	regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
	const regex_type& __re,
	regex_constants::match_flag_type __m
	= regex_constants::match_default);
	#if _LIBCPP_STD_VER > 11
	regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
	const regex_type&& __re,
	regex_constants::match_flag_type __m
	= regex_constants::match_default) = delete;
	#endif

	bool operator==(const regex_iterator& __x) const;
	_LIBCPP_INLINE_VISIBILITY
	bool operator!=(const regex_iterator& __x) const {return !(*this == __x);}

	_LIBCPP_INLINE_VISIBILITY
	reference operator*() const {return __match_;}
	_LIBCPP_INLINE_VISIBILITY
	pointer operator->() const {return &__match_;}

	regex_iterator& operator++();
	_LIBCPP_INLINE_VISIBILITY
	regex_iterator operator++(int)
	{
	regex_iterator __t(*this);
	++(*this);
	return __t;
	}
	};

	template <class _BidirectionalIterator, class _CharT, class _Traits>
	regex_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_iterator()
	: __begin_(), __end_(), __pregex_(nullptr), __flags_(), __match_()
	{
	}

	template <class _BidirectionalIterator, class _CharT, class _Traits>
	regex_iterator<_BidirectionalIterator, _CharT, _Traits>::
	regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
	const regex_type& __re, regex_constants::match_flag_type __m)
	: __begin_(__a),
	__end_(__b),
	__pregex_(&__re),
	__flags_(__m)
	{
	_VSTD::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_);
	}

	template <class _BidirectionalIterator, class _CharT, class _Traits>
	bool
	regex_iterator<_BidirectionalIterator, _CharT, _Traits>::
	operator==(const regex_iterator& __x) const
	{
	if (__match_.empty() && __x.__match_.empty())
	return true;
	if (__match_.empty() \|\| __x.__match_.empty())
	return false;
	return __begin_ == __x.__begin_ &&
	__end_ == __x.__end_ &&
	__pregex_ == __x.__pregex_ &&
	__flags_ == __x.__flags_ &&
	__match_[0] == __x.__match_[0];
	}

	template <class _BidirectionalIterator, class _CharT, class _Traits>
	regex_iterator<_BidirectionalIterator, _CharT, _Traits>&
	regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
	{
	__flags_ \|= regex_constants::__no_update_pos;
	_BidirectionalIterator __start = __match_[0].second;
	if (__match_[0].first == __match_[0].second)
	{
	if (__start == __end_)
	{
	__match_ = value_type();
	return *this;
	}
	else if (_VSTD::regex_search(__start, __end_, __match_, *__pregex_,
	__flags_ \| regex_constants::match_not_null \|
	regex_constants::match_continuous))
	return *this;
	else
	++__start;
	}
	__flags_ \|= regex_constants::match_prev_avail;
	if (!_VSTD::regex_search(__start, __end_, __match_, *__pregex_, __flags_))
	__match_ = value_type();
	return *this;
	}

	typedef regex_iterator<const char*> cregex_iterator;
	typedef regex_iterator<const wchar_t*> wcregex_iterator;
	typedef regex_iterator<string::const_iterator> sregex_iterator;
	typedef regex_iterator<wstring::const_iterator> wsregex_iterator;

	// regex_token_iterator

	template <class _BidirectionalIterator,
	class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
	class _Traits = regex_traits<_CharT> >
	class _LIBCPP_TEMPLATE_VIS regex_token_iterator
	{
	public:
	typedef basic_regex<_CharT, _Traits> regex_type;
	typedef sub_match<_BidirectionalIterator> value_type;
	typedef ptrdiff_t difference_type;
	typedef const value_type* pointer;
	typedef const value_type& reference;
	typedef forward_iterator_tag iterator_category;

	private:
	typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Position;

	_Position __position_;
	const value_type* __result_;
	value_type __suffix_;
	ptrdiff_t __n_;
	vector<int> __subs_;

	public:
	regex_token_iterator();
	regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
	const regex_type& __re, int __submatch = 0,
	regex_constants::match_flag_type __m =
	regex_constants::match_default);
	#if _LIBCPP_STD_VER > 11
	regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
	const regex_type&& __re, int __submatch = 0,
	regex_constants::match_flag_type __m =
	regex_constants::match_default) = delete;
	#endif

	regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
	const regex_type& __re, const vector<int>& __submatches,
	regex_constants::match_flag_type __m =
	regex_constants::match_default);
	#if _LIBCPP_STD_VER > 11
	regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
	const regex_type&& __re, const vector<int>& __submatches,
	regex_constants::match_flag_type __m =
	regex_constants::match_default) = delete;
	#endif

	#ifndef _LIBCPP_CXX03_LANG
	regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
	const regex_type& __re,
	initializer_list<int> __submatches,
	regex_constants::match_flag_type __m =
	regex_constants::match_default);

	#if _LIBCPP_STD_VER > 11
	regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
	const regex_type&& __re,
	initializer_list<int> __submatches,
	regex_constants::match_flag_type __m =
	regex_constants::match_default) = delete;
	#endif
	#endif // _LIBCPP_CXX03_LANG
	template <size_t _Np>
	regex_token_iterator(_BidirectionalIterator __a,
	_BidirectionalIterator __b,
	const regex_type& __re,
	const int (&__submatches)[_Np],
	regex_constants::match_flag_type __m =
	regex_constants::match_default);
	#if _LIBCPP_STD_VER > 11
	template <std::size_t _Np>
	regex_token_iterator(_BidirectionalIterator __a,
	_BidirectionalIterator __b,
	const regex_type&& __re,
	const int (&__submatches)[_Np],
	regex_constants::match_flag_type __m =
	regex_constants::match_default) = delete;
	#endif

	regex_token_iterator(const regex_token_iterator&);
	regex_token_iterator& operator=(const regex_token_iterator&);

	bool operator==(const regex_token_iterator& __x) const;
	_LIBCPP_INLINE_VISIBILITY
	bool operator!=(const regex_token_iterator& __x) const {return !(*this == __x);}

	_LIBCPP_INLINE_VISIBILITY
	const value_type& operator() const {return __result_;}
	_LIBCPP_INLINE_VISIBILITY
	const value_type* operator->() const {return __result_;}

	regex_token_iterator& operator++();
	_LIBCPP_INLINE_VISIBILITY
	regex_token_iterator operator++(int)
	{
	regex_token_iterator __t(*this);
	++(*this);
	return __t;
	}

	private:
	void __init(_BidirectionalIterator __a, _BidirectionalIterator __b);
	void __establish_result () {
	if (__subs_[__n_] == -1)
	__result_ = &__position_->prefix();
	else
	__result_ = &(*__position_)[__subs_[__n_]];
	}
	};

	template <class _BidirectionalIterator, class _CharT, class _Traits>
	regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
	regex_token_iterator()
	: __result_(nullptr),
	__suffix_(),
	__n_(0)
	{
	}

	template <class _BidirectionalIterator, class _CharT, class _Traits>
	void
	regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
	__init(_BidirectionalIterator __a, _BidirectionalIterator __b)
	{
	if (__position_ != _Position())
	__establish_result ();
	else if (__subs_[__n_] == -1)
	{
	__suffix_.matched = true;
	__suffix_.first = __a;
	__suffix_.second = __b;
	__result_ = &__suffix_;
	}
	else
	__result_ = nullptr;
	}

	template <class _BidirectionalIterator, class _CharT, class _Traits>
	regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
	regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
	const regex_type& __re, int __submatch,
	regex_constants::match_flag_type __m)
	: __position_(__a, __b, __re, __m),
	__n_(0),
	__subs_(1, __submatch)
	{
	__init(__a, __b);
	}

	template <class _BidirectionalIterator, class _CharT, class _Traits>
	regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
	regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
	const regex_type& __re, const vector<int>& __submatches,
	regex_constants::match_flag_type __m)
	: __position_(__a, __b, __re, __m),
	__n_(0),
	__subs_(__submatches)
	{
	__init(__a, __b);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _BidirectionalIterator, class _CharT, class _Traits>
	regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
	regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
	const regex_type& __re,
	initializer_list<int> __submatches,
	regex_constants::match_flag_type __m)
	: __position_(__a, __b, __re, __m),
	__n_(0),
	__subs_(__submatches)
	{
	__init(__a, __b);
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _BidirectionalIterator, class _CharT, class _Traits>
	template <size_t _Np>
	regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
	regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
	const regex_type& __re,
	const int (&__submatches)[_Np],
	regex_constants::match_flag_type __m)
	: __position_(__a, __b, __re, __m),
	__n_(0),
	__subs_(__submatches, __submatches + _Np)
	{
	__init(__a, __b);
	}

	template <class _BidirectionalIterator, class _CharT, class _Traits>
	regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
	regex_token_iterator(const regex_token_iterator& __x)
	: __position_(__x.__position_),
	__result_(__x.__result_),
	__suffix_(__x.__suffix_),
	__n_(__x.__n_),
	__subs_(__x.__subs_)
	{
	if (__x.__result_ == &__x.__suffix_)
	__result_ = &__suffix_;
	else if ( __result_ != nullptr )
	__establish_result ();
	}

	template <class _BidirectionalIterator, class _CharT, class _Traits>
	regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>&
	regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
	operator=(const regex_token_iterator& __x)
	{
	if (this != &__x)
	{
	__position_ = __x.__position_;
	if (__x.__result_ == &__x.__suffix_)
	__result_ = &__suffix_;
	else
	__result_ = __x.__result_;
	__suffix_ = __x.__suffix_;
	__n_ = __x.__n_;
	__subs_ = __x.__subs_;

	if ( __result_ != nullptr && __result_ != &__suffix_ )
	__establish_result();
	}
	return *this;
	}

	template <class _BidirectionalIterator, class _CharT, class _Traits>
	bool
	regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
	operator==(const regex_token_iterator& __x) const
	{
	if (__result_ == nullptr && __x.__result_ == nullptr)
	return true;
	if (__result_ == &__suffix_ && __x.__result_ == &__x.__suffix_ &&
	__suffix_ == __x.__suffix_)
	return true;
	if (__result_ == nullptr \|\| __x.__result_ == nullptr)
	return false;
	if (__result_ == &__suffix_ \|\| __x.__result_ == &__x.__suffix_)
	return false;
	return __position_ == __x.__position_ && __n_ == __x.__n_ &&
	__subs_ == __x.__subs_;
	}

	template <class _BidirectionalIterator, class _CharT, class _Traits>
	regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>&
	regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
	{
	_Position __prev = __position_;
	if (__result_ == &__suffix_)
	__result_ = nullptr;
	else if (static_cast<size_t>(__n_ + 1) < __subs_.size())
	{
	++__n_;
	__establish_result();
	}
	else
	{
	__n_ = 0;
	++__position_;
	if (__position_ != _Position())
	__establish_result();
	else
	{
	if (_VSTD::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end()
	&& __prev->suffix().length() != 0)
	{
	__suffix_.matched = true;
	__suffix_.first = __prev->suffix().first;
	__suffix_.second = __prev->suffix().second;
	__result_ = &__suffix_;
	}
	else
	__result_ = nullptr;
	}
	}
	return *this;
	}

	typedef regex_token_iterator<const char*> cregex_token_iterator;
	typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
	typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
	typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;

	// regex_replace

	template <class _OutputIterator, class _BidirectionalIterator,
	class _Traits, class _CharT>
	_OutputIterator
	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)
	{
	typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Iter;
	_Iter __i(__first, __last, __e, __flags);
	_Iter __eof;
	if (__i == __eof)
	{
	if (!(__flags & regex_constants::format_no_copy))
	__output_iter = _VSTD::copy(__first, __last, __output_iter);
	}
	else
	{
	sub_match<_BidirectionalIterator> __lm;
	for (size_t __len = char_traits<_CharT>::length(__fmt); __i != __eof; ++__i)
	{
	if (!(__flags & regex_constants::format_no_copy))
	__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_iter = _VSTD::copy(__lm.first, __lm.second, __output_iter);
	}
	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_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_iter, __first, __last, __e, __fmt.c_str(), __flags);
	}

	template <class _Traits, class _CharT, class _ST, class _SA, class _FST,
	class _FSA>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _ST, _SA>
	regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
	const basic_regex<_CharT, _Traits>& __e,
	const basic_string<_CharT, _FST, _FSA>& __fmt,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	basic_string<_CharT, _ST, _SA> __r;
	_VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
	__fmt.c_str(), __flags);
	return __r;
	}

	template <class _Traits, class _CharT, class _ST, class _SA>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _ST, _SA>
	regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
	const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	basic_string<_CharT, _ST, _SA> __r;
	_VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
	__fmt, __flags);
	return __r;
	}

	template <class _Traits, class _CharT, class _ST, class _SA>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT>
	regex_replace(const _CharT* __s,
	const basic_regex<_CharT, _Traits>& __e,
	const basic_string<_CharT, _ST, _SA>& __fmt,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	basic_string<_CharT> __r;
	_VSTD::regex_replace(back_inserter(__r), __s,
	__s + char_traits<_CharT>::length(__s), __e,
	__fmt.c_str(), __flags);
	return __r;
	}

	template <class _Traits, class _CharT>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT>
	regex_replace(const _CharT* __s,
	const basic_regex<_CharT, _Traits>& __e,
	const _CharT* __fmt,
	regex_constants::match_flag_type __flags = regex_constants::match_default)
	{
	basic_string<_CharT> __r;
	_VSTD::regex_replace(back_inserter(__r), __s,
	__s + char_traits<_CharT>::length(__s), __e,
	__fmt, __flags);
	return __r;
	}

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_REGEX
	Index: projects/clang700-import/contrib/libc++/include/set
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/set (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/set (revision 337135)
	@@ -1,1218 +1,1218 @@
	// -- C++ --
	//===---------------------------- set -------------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is dual licensed under the MIT and the University of Illinois Open
	// Source Licenses. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP_SET
	#define _LIBCPP_SET

	/*

	set synopsis

	namespace std
	{

	template <class Key, class Compare = less<Key>,
	class Allocator = allocator<Key>>
	class set
	{
	public:
	// types:
	typedef Key key_type;
	typedef key_type value_type;
	typedef Compare key_compare;
	typedef key_compare value_compare;
	typedef Allocator allocator_type;
	typedef typename allocator_type::reference reference;
	typedef typename allocator_type::const_reference const_reference;
	typedef typename allocator_type::size_type size_type;
	typedef typename allocator_type::difference_type difference_type;
	typedef typename allocator_type::pointer pointer;
	typedef typename allocator_type::const_pointer const_pointer;

	typedef implementation-defined iterator;
	typedef implementation-defined const_iterator;
	typedef std::reverse_iterator<iterator> reverse_iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

	// construct/copy/destroy:
	set()
	noexcept(
	is_nothrow_default_constructible<allocator_type>::value &&
	is_nothrow_default_constructible<key_compare>::value &&
	is_nothrow_copy_constructible<key_compare>::value);
	explicit set(const value_compare& comp);
	set(const value_compare& comp, const allocator_type& a);
	template <class InputIterator>
	set(InputIterator first, InputIterator last,
	const value_compare& comp = value_compare());
	template <class InputIterator>
	set(InputIterator first, InputIterator last, const value_compare& comp,
	const allocator_type& a);
	set(const set& s);
	set(set&& s)
	noexcept(
	is_nothrow_move_constructible<allocator_type>::value &&
	is_nothrow_move_constructible<key_compare>::value);
	explicit set(const allocator_type& a);
	set(const set& s, const allocator_type& a);
	set(set&& s, const allocator_type& a);
	set(initializer_list<value_type> il, const value_compare& comp = value_compare());
	set(initializer_list<value_type> il, const value_compare& comp,
	const allocator_type& a);
	template <class InputIterator>
	set(InputIterator first, InputIterator last, const allocator_type& a)
	: set(first, last, Compare(), a) {} // C++14
	set(initializer_list<value_type> il, const allocator_type& a)
	: set(il, Compare(), a) {} // C++14
	~set();

	set& operator=(const set& s);
	set& operator=(set&& s)
	noexcept(
	allocator_type::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<allocator_type>::value &&
	is_nothrow_move_assignable<key_compare>::value);
	set& operator=(initializer_list<value_type> il);

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

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

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

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

	// modifiers:
	template <class... Args>
	pair<iterator, bool> emplace(Args&&... args);
	template <class... Args>
	iterator emplace_hint(const_iterator position, Args&&... args);
	pair<iterator,bool> insert(const value_type& v);
	pair<iterator,bool> insert(value_type&& v);
	iterator insert(const_iterator position, const value_type& v);
	iterator insert(const_iterator position, value_type&& v);
	template <class InputIterator>
	void insert(InputIterator first, InputIterator last);
	void insert(initializer_list<value_type> il);

	iterator erase(const_iterator position);
	iterator erase(iterator position); // C++14
	size_type erase(const key_type& k);
	iterator erase(const_iterator first, const_iterator last);
	void clear() noexcept;

	void swap(set& s)
	noexcept(
	__is_nothrow_swappable<key_compare>::value &&
	(!allocator_type::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<allocator_type>::value));

	// observers:
	allocator_type get_allocator() const noexcept;
	key_compare key_comp() const;
	value_compare value_comp() const;

	// set operations:
	iterator find(const key_type& k);
	const_iterator find(const key_type& k) const;
	template<typename K>
	iterator find(const K& x);
	template<typename K>
	const_iterator find(const K& x) const; // C++14
	template<typename K>
	size_type count(const K& x) const; // C++14

	size_type count(const key_type& k) const;
	iterator lower_bound(const key_type& k);
	const_iterator lower_bound(const key_type& k) const;
	template<typename K>
	iterator lower_bound(const K& x); // C++14
	template<typename K>
	const_iterator lower_bound(const K& x) const; // C++14

	iterator upper_bound(const key_type& k);
	const_iterator upper_bound(const key_type& k) const;
	template<typename K>
	iterator upper_bound(const K& x); // C++14
	template<typename K>
	const_iterator upper_bound(const K& x) const; // C++14
	pair<iterator,iterator> equal_range(const key_type& k);
	pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
	template<typename K>
	pair<iterator,iterator> equal_range(const K& x); // C++14
	template<typename K>
	pair<const_iterator,const_iterator> equal_range(const K& x) const; // C++14
	};

	template <class Key, class Compare, class Allocator>
	bool
	operator==(const set<Key, Compare, Allocator>& x,
	const set<Key, Compare, Allocator>& y);

	template <class Key, class Compare, class Allocator>
	bool
	operator< (const set<Key, Compare, Allocator>& x,
	const set<Key, Compare, Allocator>& y);

	template <class Key, class Compare, class Allocator>
	bool
	operator!=(const set<Key, Compare, Allocator>& x,
	const set<Key, Compare, Allocator>& y);

	template <class Key, class Compare, class Allocator>
	bool
	operator> (const set<Key, Compare, Allocator>& x,
	const set<Key, Compare, Allocator>& y);

	template <class Key, class Compare, class Allocator>
	bool
	operator>=(const set<Key, Compare, Allocator>& x,
	const set<Key, Compare, Allocator>& y);

	template <class Key, class Compare, class Allocator>
	bool
	operator<=(const set<Key, Compare, Allocator>& x,
	const set<Key, Compare, Allocator>& y);

	// specialized algorithms:
	template <class Key, class Compare, class Allocator>
	void
	swap(set<Key, Compare, Allocator>& x, set<Key, Compare, Allocator>& y)
	noexcept(noexcept(x.swap(y)));

	template <class Key, class Compare = less<Key>,
	class Allocator = allocator<Key>>
	class multiset
	{
	public:
	// types:
	typedef Key key_type;
	typedef key_type value_type;
	typedef Compare key_compare;
	typedef key_compare value_compare;
	typedef Allocator allocator_type;
	typedef typename allocator_type::reference reference;
	typedef typename allocator_type::const_reference const_reference;
	typedef typename allocator_type::size_type size_type;
	typedef typename allocator_type::difference_type difference_type;
	typedef typename allocator_type::pointer pointer;
	typedef typename allocator_type::const_pointer const_pointer;

	typedef implementation-defined iterator;
	typedef implementation-defined const_iterator;
	typedef std::reverse_iterator<iterator> reverse_iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

	// construct/copy/destroy:
	multiset()
	noexcept(
	is_nothrow_default_constructible<allocator_type>::value &&
	is_nothrow_default_constructible<key_compare>::value &&
	is_nothrow_copy_constructible<key_compare>::value);
	explicit multiset(const value_compare& comp);
	multiset(const value_compare& comp, const allocator_type& a);
	template <class InputIterator>
	multiset(InputIterator first, InputIterator last,
	const value_compare& comp = value_compare());
	template <class InputIterator>
	multiset(InputIterator first, InputIterator last,
	const value_compare& comp, const allocator_type& a);
	multiset(const multiset& s);
	multiset(multiset&& s)
	noexcept(
	is_nothrow_move_constructible<allocator_type>::value &&
	is_nothrow_move_constructible<key_compare>::value);
	explicit multiset(const allocator_type& a);
	multiset(const multiset& s, const allocator_type& a);
	multiset(multiset&& s, const allocator_type& a);
	multiset(initializer_list<value_type> il, const value_compare& comp = value_compare());
	multiset(initializer_list<value_type> il, const value_compare& comp,
	const allocator_type& a);
	template <class InputIterator>
	multiset(InputIterator first, InputIterator last, const allocator_type& a)
	: set(first, last, Compare(), a) {} // C++14
	multiset(initializer_list<value_type> il, const allocator_type& a)
	: set(il, Compare(), a) {} // C++14
	~multiset();

	multiset& operator=(const multiset& s);
	multiset& operator=(multiset&& s)
	noexcept(
	allocator_type::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<allocator_type>::value &&
	is_nothrow_move_assignable<key_compare>::value);
	multiset& operator=(initializer_list<value_type> il);

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

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

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

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

	// modifiers:
	template <class... Args>
	iterator emplace(Args&&... args);
	template <class... Args>
	iterator emplace_hint(const_iterator position, Args&&... args);
	iterator insert(const value_type& v);
	iterator insert(value_type&& v);
	iterator insert(const_iterator position, const value_type& v);
	iterator insert(const_iterator position, value_type&& v);
	template <class InputIterator>
	void insert(InputIterator first, InputIterator last);
	void insert(initializer_list<value_type> il);

	iterator erase(const_iterator position);
	iterator erase(iterator position); // C++14
	size_type erase(const key_type& k);
	iterator erase(const_iterator first, const_iterator last);
	void clear() noexcept;

	void swap(multiset& s)
	noexcept(
	__is_nothrow_swappable<key_compare>::value &&
	(!allocator_type::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<allocator_type>::value));

	// observers:
	allocator_type get_allocator() const noexcept;
	key_compare key_comp() const;
	value_compare value_comp() const;

	// set operations:
	iterator find(const key_type& k);
	const_iterator find(const key_type& k) const;
	template<typename K>
	iterator find(const K& x);
	template<typename K>
	const_iterator find(const K& x) const; // C++14

	size_type count(const key_type& k) const;
	iterator lower_bound(const key_type& k);
	const_iterator lower_bound(const key_type& k) const;
	template<typename K>
	iterator lower_bound(const K& x); // C++14
	template<typename K>
	const_iterator lower_bound(const K& x) const; // C++14

	iterator upper_bound(const key_type& k);
	const_iterator upper_bound(const key_type& k) const;
	template<typename K>
	iterator upper_bound(const K& x); // C++14
	template<typename K>
	const_iterator upper_bound(const K& x) const; // C++14

	pair<iterator,iterator> equal_range(const key_type& k);
	pair<const_iterator,const_iterator> equal_range(const key_type& k) const;
	template<typename K>
	pair<iterator,iterator> equal_range(const K& x); // C++14
	template<typename K>
	pair<const_iterator,const_iterator> equal_range(const K& x) const; // C++14
	};

	template <class Key, class Compare, class Allocator>
	bool
	operator==(const multiset<Key, Compare, Allocator>& x,
	const multiset<Key, Compare, Allocator>& y);

	template <class Key, class Compare, class Allocator>
	bool
	operator< (const multiset<Key, Compare, Allocator>& x,
	const multiset<Key, Compare, Allocator>& y);

	template <class Key, class Compare, class Allocator>
	bool
	operator!=(const multiset<Key, Compare, Allocator>& x,
	const multiset<Key, Compare, Allocator>& y);

	template <class Key, class Compare, class Allocator>
	bool
	operator> (const multiset<Key, Compare, Allocator>& x,
	const multiset<Key, Compare, Allocator>& y);

	template <class Key, class Compare, class Allocator>
	bool
	operator>=(const multiset<Key, Compare, Allocator>& x,
	const multiset<Key, Compare, Allocator>& y);

	template <class Key, class Compare, class Allocator>
	bool
	operator<=(const multiset<Key, Compare, Allocator>& x,
	const multiset<Key, Compare, Allocator>& y);

	// specialized algorithms:
	template <class Key, class Compare, class Allocator>
	void
	swap(multiset<Key, Compare, Allocator>& x, multiset<Key, Compare, Allocator>& y)
	noexcept(noexcept(x.swap(y)));

	} // std

	*/

	#include <__config>
	#include <__tree>
	#include <functional>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _Key, class _Compare = less<_Key>,
	class _Allocator = allocator<_Key> >
	class _LIBCPP_TEMPLATE_VIS set
	{
	public:
	// types:
	typedef _Key key_type;
	typedef key_type value_type;
	typedef _Compare key_compare;
	typedef key_compare value_compare;
	typedef _Allocator allocator_type;
	typedef value_type& reference;
	typedef const value_type& const_reference;

	static_assert((is_same<typename allocator_type::value_type, value_type>::value),
	"Allocator::value_type must be same type as value_type");

	private:
	typedef __tree<value_type, value_compare, allocator_type> __base;
	typedef allocator_traits<allocator_type> __alloc_traits;
	typedef typename __base::__node_holder __node_holder;

	__base __tree_;

	public:
	typedef typename __base::pointer pointer;
	typedef typename __base::const_pointer const_pointer;
	typedef typename __base::size_type size_type;
	typedef typename __base::difference_type difference_type;
	typedef typename __base::const_iterator iterator;
	typedef typename __base::const_iterator const_iterator;
	typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
	typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;

	_LIBCPP_INLINE_VISIBILITY
	set()
	_NOEXCEPT_(
	is_nothrow_default_constructible<allocator_type>::value &&
	is_nothrow_default_constructible<key_compare>::value &&
	is_nothrow_copy_constructible<key_compare>::value)
	: __tree_(value_compare()) {}

	_LIBCPP_INLINE_VISIBILITY
	explicit set(const value_compare& __comp)
	_NOEXCEPT_(
	is_nothrow_default_constructible<allocator_type>::value &&
	is_nothrow_copy_constructible<key_compare>::value)
	: __tree_(__comp) {}

	_LIBCPP_INLINE_VISIBILITY
	explicit set(const value_compare& __comp, const allocator_type& __a)
	: __tree_(__comp, __a) {}
	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	set(_InputIterator __f, _InputIterator __l,
	const value_compare& __comp = value_compare())
	: __tree_(__comp)
	{
	insert(__f, __l);
	}

	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	set(_InputIterator __f, _InputIterator __l, const value_compare& __comp,
	const allocator_type& __a)
	: __tree_(__comp, __a)
	{
	insert(__f, __l);
	}

	#if _LIBCPP_STD_VER > 11
	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	set(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
	: set(__f, __l, key_compare(), __a) {}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	set(const set& __s)
	: __tree_(__s.__tree_)
	{
	insert(__s.begin(), __s.end());
	}

	_LIBCPP_INLINE_VISIBILITY
	set& operator=(const set& __s)
	{
	__tree_ = __s.__tree_;
	return *this;
	}

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	set(set&& __s)
	_NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
	: __tree_(_VSTD::move(__s.__tree_)) {}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	explicit set(const allocator_type& __a)
	: __tree_(__a) {}

	_LIBCPP_INLINE_VISIBILITY
	set(const set& __s, const allocator_type& __a)
	: __tree_(__s.__tree_.value_comp(), __a)
	{
	insert(__s.begin(), __s.end());
	}

	#ifndef _LIBCPP_CXX03_LANG
	set(set&& __s, const allocator_type& __a);

	_LIBCPP_INLINE_VISIBILITY
	set(initializer_list<value_type> __il, const value_compare& __comp = value_compare())
	: __tree_(__comp)
	{
	insert(__il.begin(), __il.end());
	}

	_LIBCPP_INLINE_VISIBILITY
	set(initializer_list<value_type> __il, const value_compare& __comp,
	const allocator_type& __a)
	: __tree_(__comp, __a)
	{
	insert(__il.begin(), __il.end());
	}

	#if _LIBCPP_STD_VER > 11
	_LIBCPP_INLINE_VISIBILITY
	set(initializer_list<value_type> __il, const allocator_type& __a)
	: set(__il, key_compare(), __a) {}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	set& operator=(initializer_list<value_type> __il)
	{
	__tree_.__assign_unique(__il.begin(), __il.end());
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	set& operator=(set&& __s)
	_NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
	{
	__tree_ = _VSTD::move(__s.__tree_);
	return *this;
	}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	iterator begin() _NOEXCEPT {return __tree_.begin();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator begin() const _NOEXCEPT {return __tree_.begin();}
	_LIBCPP_INLINE_VISIBILITY
	iterator end() _NOEXCEPT {return __tree_.end();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator end() const _NOEXCEPT {return __tree_.end();}

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

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

	_LIBCPP_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();}
	_LIBCPP_INLINE_VISIBILITY
	size_type max_size() const _NOEXCEPT {return __tree_.max_size();}

	// modifiers:
	#ifndef _LIBCPP_CXX03_LANG
	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> emplace(_Args&&... __args)
	{return __tree_.__emplace_unique(_VSTD::forward<_Args>(__args)...);}
	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	iterator emplace_hint(const_iterator __p, _Args&&... __args)
	{return __tree_.__emplace_hint_unique(__p, _VSTD::forward<_Args>(__args)...);}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	pair<iterator,bool> insert(const value_type& __v)
	{return __tree_.__insert_unique(__v);}
	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __p, const value_type& __v)
	{return __tree_.__insert_unique(__p, __v);}

	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	void insert(_InputIterator __f, _InputIterator __l)
	{
	for (const_iterator __e = cend(); __f != __l; ++__f)
	__tree_.__insert_unique(__e, *__f);
	}

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator,bool> insert(value_type&& __v)
	{return __tree_.__insert_unique(_VSTD::move(__v));}

	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __p, value_type&& __v)
	{return __tree_.__insert_unique(__p, _VSTD::move(__v));}

	_LIBCPP_INLINE_VISIBILITY
	void insert(initializer_list<value_type> __il)
	{insert(__il.begin(), __il.end());}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	iterator erase(const_iterator __p) {return __tree_.erase(__p);}
	_LIBCPP_INLINE_VISIBILITY
	size_type erase(const key_type& __k)
	{return __tree_.__erase_unique(__k);}
	_LIBCPP_INLINE_VISIBILITY
	iterator erase(const_iterator __f, const_iterator __l)
	{return __tree_.erase(__f, __l);}
	_LIBCPP_INLINE_VISIBILITY
	void clear() _NOEXCEPT {__tree_.clear();}

	_LIBCPP_INLINE_VISIBILITY
	void swap(set& __s) _NOEXCEPT_(__is_nothrow_swappable<__base>::value)
	{__tree_.swap(__s.__tree_);}

	_LIBCPP_INLINE_VISIBILITY
	allocator_type get_allocator() const _NOEXCEPT {return __tree_.__alloc();}
	_LIBCPP_INLINE_VISIBILITY
	key_compare key_comp() const {return __tree_.value_comp();}
	_LIBCPP_INLINE_VISIBILITY
	value_compare value_comp() const {return __tree_.value_comp();}

	// set operations:
	_LIBCPP_INLINE_VISIBILITY
	iterator find(const key_type& __k) {return __tree_.find(__k);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
	find(const _K2& __k) {return __tree_.find(__k);}
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
	find(const _K2& __k) const {return __tree_.find(__k);}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	size_type count(const key_type& __k) const
	{return __tree_.__count_unique(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
	- count(const _K2& __k) const {return __tree_.__count_unique(__k);}
	+ count(const _K2& __k) const {return __tree_.__count_multi(__k);}
	#endif
	_LIBCPP_INLINE_VISIBILITY
	iterator lower_bound(const key_type& __k)
	{return __tree_.lower_bound(__k);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator lower_bound(const key_type& __k) const
	{return __tree_.lower_bound(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
	lower_bound(const _K2& __k) {return __tree_.lower_bound(__k);}

	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
	lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	iterator upper_bound(const key_type& __k)
	{return __tree_.upper_bound(__k);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator upper_bound(const key_type& __k) const
	{return __tree_.upper_bound(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
	upper_bound(const _K2& __k) {return __tree_.upper_bound(__k);}
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
	upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	pair<iterator,iterator> equal_range(const key_type& __k)
	{return __tree_.__equal_range_unique(__k);}
	_LIBCPP_INLINE_VISIBILITY
	pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
	{return __tree_.__equal_range_unique(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
	- equal_range(const _K2& __k) {return __tree_.__equal_range_unique(__k);}
	+ equal_range(const _K2& __k) {return __tree_.__equal_range_multi(__k);}
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
	- equal_range(const _K2& __k) const {return __tree_.__equal_range_unique(__k);}
	+ equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
	#endif
	};

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Key, class _Compare, class _Allocator>
	set<_Key, _Compare, _Allocator>::set(set&& __s, const allocator_type& __a)
	: __tree_(_VSTD::move(__s.__tree_), __a)
	{
	if (__a != __s.get_allocator())
	{
	const_iterator __e = cend();
	while (!__s.empty())
	insert(__e, _VSTD::move(__s.__tree_.remove(__s.begin())->__value_));
	}
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Key, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const set<_Key, _Compare, _Allocator>& __x,
	const set<_Key, _Compare, _Allocator>& __y)
	{
	return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
	}

	template <class _Key, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator< (const set<_Key, _Compare, _Allocator>& __x,
	const set<_Key, _Compare, _Allocator>& __y)
	{
	return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
	}

	template <class _Key, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const set<_Key, _Compare, _Allocator>& __x,
	const set<_Key, _Compare, _Allocator>& __y)
	{
	return !(__x == __y);
	}

	template <class _Key, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator> (const set<_Key, _Compare, _Allocator>& __x,
	const set<_Key, _Compare, _Allocator>& __y)
	{
	return __y < __x;
	}

	template <class _Key, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const set<_Key, _Compare, _Allocator>& __x,
	const set<_Key, _Compare, _Allocator>& __y)
	{
	return !(__x < __y);
	}

	template <class _Key, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const set<_Key, _Compare, _Allocator>& __x,
	const set<_Key, _Compare, _Allocator>& __y)
	{
	return !(__y < __x);
	}

	// specialized algorithms:
	template <class _Key, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(set<_Key, _Compare, _Allocator>& __x,
	set<_Key, _Compare, _Allocator>& __y)
	_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
	{
	__x.swap(__y);
	}

	template <class _Key, class _Compare = less<_Key>,
	class _Allocator = allocator<_Key> >
	class _LIBCPP_TEMPLATE_VIS multiset
	{
	public:
	// types:
	typedef _Key key_type;
	typedef key_type value_type;
	typedef _Compare key_compare;
	typedef key_compare value_compare;
	typedef _Allocator allocator_type;
	typedef value_type& reference;
	typedef const value_type& const_reference;

	static_assert((is_same<typename allocator_type::value_type, value_type>::value),
	"Allocator::value_type must be same type as value_type");

	private:
	typedef __tree<value_type, value_compare, allocator_type> __base;
	typedef allocator_traits<allocator_type> __alloc_traits;
	typedef typename __base::__node_holder __node_holder;

	__base __tree_;

	public:
	typedef typename __base::pointer pointer;
	typedef typename __base::const_pointer const_pointer;
	typedef typename __base::size_type size_type;
	typedef typename __base::difference_type difference_type;
	typedef typename __base::const_iterator iterator;
	typedef typename __base::const_iterator const_iterator;
	typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
	typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;

	// construct/copy/destroy:
	_LIBCPP_INLINE_VISIBILITY
	multiset()
	_NOEXCEPT_(
	is_nothrow_default_constructible<allocator_type>::value &&
	is_nothrow_default_constructible<key_compare>::value &&
	is_nothrow_copy_constructible<key_compare>::value)
	: __tree_(value_compare()) {}

	_LIBCPP_INLINE_VISIBILITY
	explicit multiset(const value_compare& __comp)
	_NOEXCEPT_(
	is_nothrow_default_constructible<allocator_type>::value &&
	is_nothrow_copy_constructible<key_compare>::value)
	: __tree_(__comp) {}

	_LIBCPP_INLINE_VISIBILITY
	explicit multiset(const value_compare& __comp, const allocator_type& __a)
	: __tree_(__comp, __a) {}
	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	multiset(_InputIterator __f, _InputIterator __l,
	const value_compare& __comp = value_compare())
	: __tree_(__comp)
	{
	insert(__f, __l);
	}

	#if _LIBCPP_STD_VER > 11
	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	multiset(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
	: multiset(__f, __l, key_compare(), __a) {}
	#endif

	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	multiset(_InputIterator __f, _InputIterator __l,
	const value_compare& __comp, const allocator_type& __a)
	: __tree_(__comp, __a)
	{
	insert(__f, __l);
	}

	_LIBCPP_INLINE_VISIBILITY
	multiset(const multiset& __s)
	: __tree_(__s.__tree_.value_comp(),
	__alloc_traits::select_on_container_copy_construction(__s.__tree_.__alloc()))
	{
	insert(__s.begin(), __s.end());
	}

	_LIBCPP_INLINE_VISIBILITY
	multiset& operator=(const multiset& __s)
	{
	__tree_ = __s.__tree_;
	return *this;
	}

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	multiset(multiset&& __s)
	_NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
	: __tree_(_VSTD::move(__s.__tree_)) {}

	multiset(multiset&& __s, const allocator_type& __a);
	#endif // _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	explicit multiset(const allocator_type& __a)
	: __tree_(__a) {}
	_LIBCPP_INLINE_VISIBILITY
	multiset(const multiset& __s, const allocator_type& __a)
	: __tree_(__s.__tree_.value_comp(), __a)
	{
	insert(__s.begin(), __s.end());
	}

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	multiset(initializer_list<value_type> __il, const value_compare& __comp = value_compare())
	: __tree_(__comp)
	{
	insert(__il.begin(), __il.end());
	}

	_LIBCPP_INLINE_VISIBILITY
	multiset(initializer_list<value_type> __il, const value_compare& __comp,
	const allocator_type& __a)
	: __tree_(__comp, __a)
	{
	insert(__il.begin(), __il.end());
	}

	#if _LIBCPP_STD_VER > 11
	_LIBCPP_INLINE_VISIBILITY
	multiset(initializer_list<value_type> __il, const allocator_type& __a)
	: multiset(__il, key_compare(), __a) {}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	multiset& operator=(initializer_list<value_type> __il)
	{
	__tree_.__assign_multi(__il.begin(), __il.end());
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	multiset& operator=(multiset&& __s)
	_NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
	{
	__tree_ = _VSTD::move(__s.__tree_);
	return *this;
	}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	iterator begin() _NOEXCEPT {return __tree_.begin();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator begin() const _NOEXCEPT {return __tree_.begin();}
	_LIBCPP_INLINE_VISIBILITY
	iterator end() _NOEXCEPT {return __tree_.end();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator end() const _NOEXCEPT {return __tree_.end();}

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

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

	_LIBCPP_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();}
	_LIBCPP_INLINE_VISIBILITY
	size_type max_size() const _NOEXCEPT {return __tree_.max_size();}

	// modifiers:
	#ifndef _LIBCPP_CXX03_LANG
	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	iterator emplace(_Args&&... __args)
	{return __tree_.__emplace_multi(_VSTD::forward<_Args>(__args)...);}
	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	iterator emplace_hint(const_iterator __p, _Args&&... __args)
	{return __tree_.__emplace_hint_multi(__p, _VSTD::forward<_Args>(__args)...);}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const value_type& __v)
	{return __tree_.__insert_multi(__v);}
	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __p, const value_type& __v)
	{return __tree_.__insert_multi(__p, __v);}

	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	void insert(_InputIterator __f, _InputIterator __l)
	{
	for (const_iterator __e = cend(); __f != __l; ++__f)
	__tree_.__insert_multi(__e, *__f);
	}

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	iterator insert(value_type&& __v)
	{return __tree_.__insert_multi(_VSTD::move(__v));}

	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __p, value_type&& __v)
	{return __tree_.__insert_multi(__p, _VSTD::move(__v));}

	_LIBCPP_INLINE_VISIBILITY
	void insert(initializer_list<value_type> __il)
	{insert(__il.begin(), __il.end());}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	iterator erase(const_iterator __p) {return __tree_.erase(__p);}
	_LIBCPP_INLINE_VISIBILITY
	size_type erase(const key_type& __k) {return __tree_.__erase_multi(__k);}
	_LIBCPP_INLINE_VISIBILITY
	iterator erase(const_iterator __f, const_iterator __l)
	{return __tree_.erase(__f, __l);}
	_LIBCPP_INLINE_VISIBILITY
	void clear() _NOEXCEPT {__tree_.clear();}

	_LIBCPP_INLINE_VISIBILITY
	void swap(multiset& __s)
	_NOEXCEPT_(__is_nothrow_swappable<__base>::value)
	{__tree_.swap(__s.__tree_);}

	_LIBCPP_INLINE_VISIBILITY
	allocator_type get_allocator() const _NOEXCEPT {return __tree_.__alloc();}
	_LIBCPP_INLINE_VISIBILITY
	key_compare key_comp() const {return __tree_.value_comp();}
	_LIBCPP_INLINE_VISIBILITY
	value_compare value_comp() const {return __tree_.value_comp();}

	// set operations:
	_LIBCPP_INLINE_VISIBILITY
	iterator find(const key_type& __k) {return __tree_.find(__k);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,iterator>::type
	find(const _K2& __k) {return __tree_.find(__k);}
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,const_iterator>::type
	find(const _K2& __k) const {return __tree_.find(__k);}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	size_type count(const key_type& __k) const
	{return __tree_.__count_multi(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
	- count(const _K2& __k) {return __tree_.__count_multi(__k);}
	+ count(const _K2& __k) const {return __tree_.__count_multi(__k);}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	iterator lower_bound(const key_type& __k)
	{return __tree_.lower_bound(__k);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator lower_bound(const key_type& __k) const
	{return __tree_.lower_bound(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,iterator>::type
	lower_bound(const _K2& __k) {return __tree_.lower_bound(__k);}

	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,const_iterator>::type
	lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	iterator upper_bound(const key_type& __k)
	{return __tree_.upper_bound(__k);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator upper_bound(const key_type& __k) const
	{return __tree_.upper_bound(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,iterator>::type
	upper_bound(const _K2& __k) {return __tree_.upper_bound(__k);}
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,const_iterator>::type
	upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	pair<iterator,iterator> equal_range(const key_type& __k)
	{return __tree_.__equal_range_multi(__k);}
	_LIBCPP_INLINE_VISIBILITY
	pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
	{return __tree_.__equal_range_multi(__k);}
	#if _LIBCPP_STD_VER > 11
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
	equal_range(const _K2& __k) {return __tree_.__equal_range_multi(__k);}
	template <typename _K2>
	_LIBCPP_INLINE_VISIBILITY
	typename _VSTD::enable_if<_VSTD::__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
	equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
	#endif
	};

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Key, class _Compare, class _Allocator>
	multiset<_Key, _Compare, _Allocator>::multiset(multiset&& __s, const allocator_type& __a)
	: __tree_(_VSTD::move(__s.__tree_), __a)
	{
	if (__a != __s.get_allocator())
	{
	const_iterator __e = cend();
	while (!__s.empty())
	insert(__e, _VSTD::move(__s.__tree_.remove(__s.begin())->__value_));
	}
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Key, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const multiset<_Key, _Compare, _Allocator>& __x,
	const multiset<_Key, _Compare, _Allocator>& __y)
	{
	return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
	}

	template <class _Key, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator< (const multiset<_Key, _Compare, _Allocator>& __x,
	const multiset<_Key, _Compare, _Allocator>& __y)
	{
	return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
	}

	template <class _Key, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const multiset<_Key, _Compare, _Allocator>& __x,
	const multiset<_Key, _Compare, _Allocator>& __y)
	{
	return !(__x == __y);
	}

	template <class _Key, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator> (const multiset<_Key, _Compare, _Allocator>& __x,
	const multiset<_Key, _Compare, _Allocator>& __y)
	{
	return __y < __x;
	}

	template <class _Key, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const multiset<_Key, _Compare, _Allocator>& __x,
	const multiset<_Key, _Compare, _Allocator>& __y)
	{
	return !(__x < __y);
	}

	template <class _Key, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const multiset<_Key, _Compare, _Allocator>& __x,
	const multiset<_Key, _Compare, _Allocator>& __y)
	{
	return !(__y < __x);
	}

	template <class _Key, class _Compare, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(multiset<_Key, _Compare, _Allocator>& __x,
	multiset<_Key, _Compare, _Allocator>& __y)
	_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
	{
	__x.swap(__y);
	}

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_SET
	Index: projects/clang700-import/contrib/libc++/include/setjmp.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/setjmp.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/setjmp.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/include/setjmp.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/span
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/span (nonexistent)
	+++ projects/clang700-import/contrib/libc++/include/span (revision 337135)
	@@ -0,0 +1,608 @@
	+// -- C++ --
	+//===------------------------------ span ---------------------------------===//
	+//
	+// 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_SPAN
	+#define _LIBCPP_SPAN
	+
	+/*
	+ span synopsis
	+
	+namespace std {
	+
	+// constants
	+inline constexpr ptrdiff_t dynamic_extent = -1;
	+
	+// [views.span], class template span
	+template <class ElementType, ptrdiff_t Extent = dynamic_extent>
	+ class span;
	+
	+// [span.comparison], span comparison operators
	+template <class T, ptrdiff_t X, class U, ptrdiff_t Y>
	+ constexpr bool operator==(span<T, X> l, span<U, Y> r);
	+template <class T, ptrdiff_t X, class U, ptrdiff_t Y>
	+ constexpr bool operator!=(span<T, X> l, span<U, Y> r);
	+template <class T, ptrdiff_t X, class U, ptrdiff_t Y>
	+ constexpr bool operator<(span<T, X> l, span<U, Y> r);
	+template <class T, ptrdiff_t X, class U, ptrdiff_t Y>
	+ constexpr bool operator<=(span<T, X> l, span<U, Y> r);
	+template <class T, ptrdiff_t X, class U, ptrdiff_t Y>
	+ constexpr bool operator>(span<T, X> l, span<U, Y> r);
	+template <class T, ptrdiff_t X, class U, ptrdiff_t Y>
	+ constexpr bool operator>=(span<T, X> l, span<U, Y> r);
	+
	+// [span.objectrep], views of object representation
	+template <class ElementType, ptrdiff_t Extent>
	+ span<const byte, ((Extent == dynamic_extent) ? dynamic_extent :
	+ (static_cast<ptrdiff_t>(sizeof(ElementType)) * Extent))> as_bytes(span<ElementType, Extent> s) noexcept;
	+
	+template <class ElementType, ptrdiff_t Extent>
	+ span< byte, ((Extent == dynamic_extent) ? dynamic_extent :
	+ (static_cast<ptrdiff_t>(sizeof(ElementType)) * Extent))> as_writable_bytes(span<ElementType, Extent> s) noexcept;
	+
	+
	+namespace std {
	+template <class ElementType, ptrdiff_t Extent = dynamic_extent>
	+class span {
	+public:
	+ // constants and types
	+ using element_type = ElementType;
	+ using value_type = remove_cv_t<ElementType>;
	+ using index_type = ptrdiff_t;
	+ using difference_type = ptrdiff_t;
	+ using pointer = element_type*;
	+ using reference = element_type&;
	+ using iterator = implementation-defined;
	+ using const_iterator = implementation-defined;
	+ using reverse_iterator = std::reverse_iterator<iterator>;
	+ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
	+ static constexpr index_type extent = Extent;
	+
	+ // [span.cons], span constructors, copy, assignment, and destructor
	+ constexpr span() noexcept;
	+ constexpr span(pointer ptr, index_type count);
	+ constexpr span(pointer firstElem, pointer lastElem);
	+ template <size_t N>
	+ constexpr span(element_type (&arr)[N]) noexcept;
	+ template <size_t N>
	+ constexpr span(array<value_type, N>& arr) noexcept;
	+ template <size_t N>
	+ constexpr span(const array<value_type, N>& arr) noexcept;
	+ template <class Container>
	+ constexpr span(Container& cont);
	+ template <class Container>
	+ constexpr span(const Container& cont);
	+ constexpr span(const span& other) noexcept = default;
	+ template <class OtherElementType, ptrdiff_t OtherExtent>
	+ constexpr span(const span<OtherElementType, OtherExtent>& s) noexcept;
	+ ~span() noexcept = default;
	+ constexpr span& operator=(const span& other) noexcept = default;
	+
	+ // [span.sub], span subviews
	+ template <ptrdiff_t Count>
	+ constexpr span<element_type, Count> first() const;
	+ template <ptrdiff_t Count>
	+ constexpr span<element_type, Count> last() const;
	+ template <ptrdiff_t Offset, ptrdiff_t Count = dynamic_extent>
	+ constexpr span<element_type, see below> subspan() const;
	+
	+ constexpr span<element_type, dynamic_extent> first(index_type count) const;
	+ constexpr span<element_type, dynamic_extent> last(index_type count) const;
	+ constexpr span<element_type, dynamic_extent> subspan(index_type offset, index_type count = dynamic_extent) const;
	+
	+ // [span.obs], span observers
	+ constexpr index_type size() const noexcept;
	+ constexpr index_type size_bytes() const noexcept;
	+ constexpr bool empty() const noexcept;
	+
	+ // [span.elem], span element access
	+ constexpr reference operator[](index_type idx) const;
	+ constexpr reference operator()(index_type idx) const;
	+ constexpr pointer data() const noexcept;
	+
	+ // [span.iterators], span iterator support
	+ constexpr iterator begin() const noexcept;
	+ constexpr iterator end() const noexcept;
	+ constexpr const_iterator cbegin() const noexcept;
	+ constexpr const_iterator cend() const noexcept;
	+ constexpr reverse_iterator rbegin() const noexcept;
	+ constexpr reverse_iterator rend() const noexcept;
	+ constexpr const_reverse_iterator crbegin() const noexcept;
	+ constexpr const_reverse_iterator crend() const noexcept;
	+
	+private:
	+ pointer data_; // exposition only
	+ index_type size_; // exposition only
	+};
	+
	+template<class T, size_t N>
	+ span(T (&)[N]) -> span<T, N>;
	+
	+template<class T, size_t N>
	+ span(array<T, N>&) -> span<T, N>;
	+
	+template<class T, size_t N>
	+ span(const array<T, N>&) -> span<const T, N>;
	+
	+template<class Container>
	+ span(Container&) -> span<typename Container::value_type>;
	+
	+template<class Container>
	+ span(const Container&) -> span<const typename Container::value_type>;
	+
	+} // namespace std
	+
	+*/
	+
	+#include <__config>
	+#include <cstddef> // for ptrdiff_t
	+#include <iterator> // for iterators
	+#include <array> // for array
	+#include <type_traits> // for remove_cv, etc
	+#include <cstddef> // for byte
	+
	+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	+#pragma GCC system_header
	+#endif
	+
	+_LIBCPP_BEGIN_NAMESPACE_STD
	+
	+#if _LIBCPP_STD_VER > 17
	+
	+inline constexpr ptrdiff_t dynamic_extent = -1;
	+template <typename _Tp, ptrdiff_t _Extent = dynamic_extent> class span;
	+
	+
	+template <class _Tp>
	+struct __is_span_impl : public false_type {};
	+
	+template <class _Tp, ptrdiff_t _Extent>
	+struct __is_span_impl<span<_Tp, _Extent>> : public true_type {};
	+
	+template <class _Tp>
	+struct __is_span : public __is_span_impl<remove_cv_t<_Tp>> {};
	+
	+template <class _Tp>
	+struct __is_std_array_impl : public false_type {};
	+
	+template <class _Tp, size_t _Sz>
	+struct __is_std_array_impl<array<_Tp, _Sz>> : public true_type {};
	+
	+template <class _Tp>
	+struct __is_std_array : public __is_std_array_impl<remove_cv_t<_Tp>> {};
	+
	+template <class _Tp, class _ElementType, class = void>
	+struct __is_span_compatible_container : public false_type {};
	+
	+template <class _Tp, class _ElementType>
	+struct __is_span_compatible_container<_Tp, _ElementType,
	+ void_t<
	+ // is not a specialization of span
	+ typename enable_if<!__is_span<_Tp>::value, nullptr_t>::type,
	+ // is not a specialization of array
	+ typename enable_if<!__is_std_array<_Tp>::value, nullptr_t>::type,
	+ // is_array_v<Container> is false,
	+ typename enable_if<!is_array_v<_Tp>, nullptr_t>::type,
	+ // data(cont) and size(cont) are well formed
	+ decltype(data(declval<_Tp>())),
	+ decltype(size(declval<_Tp>())),
	+ // remove_pointer_t<decltype(data(cont))>()[] is convertible to ElementType()[]
	+ typename enable_if<
	+ is_convertible_v<remove_pointer_t<decltype(data(declval<_Tp &>()))>(*)[],
	+ _ElementType(*)[]>,
	+ nullptr_t>::type
	+ >>
	+ : public true_type {};
	+
	+
	+template <typename _Tp, ptrdiff_t _Extent>
	+class _LIBCPP_TEMPLATE_VIS span {
	+public:
	+// constants and types
	+ using element_type = _Tp;
	+ using value_type = remove_cv_t<_Tp>;
	+ using index_type = ptrdiff_t;
	+ using difference_type = ptrdiff_t;
	+ using pointer = _Tp *;
	+ using const_pointer = const _Tp *; // not in standard
	+ using reference = _Tp &;
	+ using const_reference = const _Tp &; // not in standard
	+ using iterator = __wrap_iter<pointer>;
	+ using const_iterator = __wrap_iter<const_pointer>;
	+ using reverse_iterator = _VSTD::reverse_iterator<iterator>;
	+ using const_reverse_iterator = _VSTD::reverse_iterator<const_iterator>;
	+
	+ static constexpr index_type extent = _Extent;
	+ static_assert (_Extent >= 0, "Can't have a span with an extent < 0");
	+
	+// [span.cons], span constructors, copy, assignment, and destructor
	+ _LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr}
	+ { static_assert(_Extent == 0, "Can't default construct a statically sized span with size > 0"); }
	+
	+ constexpr span (const span&) noexcept = default;
	+ constexpr span& operator=(const span&) noexcept = default;
	+
	+ _LIBCPP_INLINE_VISIBILITY constexpr span(pointer __ptr, index_type __count) : __data{__ptr}
	+ { (void)__count; _LIBCPP_ASSERT(_Extent == __count, "size mismatch in span's constructor (ptr, len)"); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr span(pointer __f, pointer __l) : __data{__f}
	+ { (void)__l; _LIBCPP_ASSERT(_Extent == distance(__f, __l), "size mismatch in span's constructor (ptr, ptr)"); }
	+
	+ _LIBCPP_INLINE_VISIBILITY constexpr span(element_type (&__arr)[_Extent]) noexcept : __data{__arr} {}
	+ _LIBCPP_INLINE_VISIBILITY constexpr span( array<value_type, _Extent>& __arr) noexcept : __data{__arr.data()} {}
	+ _LIBCPP_INLINE_VISIBILITY constexpr span(const array<value_type, _Extent>& __arr) noexcept : __data{__arr.data()} {}
	+
	+ template <class _Container>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr span( _Container& __c,
	+ enable_if_t<__is_span_compatible_container<_Container, _Tp>::value, nullptr_t> = nullptr)
	+ : __data{_VSTD::data(__c)}
	+ { _LIBCPP_ASSERT(_Extent == _VSTD::size(__c), "size mismatch in span's constructor (container))"); }
	+
	+ template <class _Container>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr span(const _Container& __c,
	+ enable_if_t<__is_span_compatible_container<const _Container, _Tp>::value, nullptr_t> = nullptr)
	+ : __data{_VSTD::data(__c)}
	+ { _LIBCPP_ASSERT(_Extent == _VSTD::size(__c), "size mismatch in span's constructor (const container)"); }
	+
	+ template <class _OtherElementType>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr span(const span<_OtherElementType, _Extent>& __other,
	+ enable_if_t<
	+ is_convertible_v<_OtherElementType()[], element_type ()[]>,
	+ nullptr_t> = nullptr)
	+ : __data{__other.data()} {}
	+
	+ template <class _OtherElementType>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr span(const span<_OtherElementType, dynamic_extent>& __other,
	+ enable_if_t<
	+ is_convertible_v<_OtherElementType()[], element_type ()[]>,
	+ nullptr_t> = nullptr) noexcept
	+ : __data{__other.data()} { _LIBCPP_ASSERT(_Extent == __other.size(), "size mismatch in span's constructor (other span)"); }
	+
	+
	+// ~span() noexcept = default;
	+
	+ template <ptrdiff_t _Count>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr span<element_type, _Count> first() const noexcept
	+ {
	+ static_assert(_Count >= 0, "Count must be >= 0 in span::first()");
	+ static_assert(_Count <= _Extent, "Count out of range in span::first()");
	+ return {data(), _Count};
	+ }
	+
	+ template <ptrdiff_t _Count>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr span<element_type, _Count> last() const noexcept
	+ {
	+ static_assert(_Count >= 0, "Count must be >= 0 in span::last()");
	+ static_assert(_Count <= _Extent, "Count out of range in span::last()");
	+ return {data() + size() - _Count, _Count};
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ constexpr span<element_type, dynamic_extent> first(index_type __count) const noexcept
	+ {
	+ _LIBCPP_ASSERT(__count >= 0 && __count <= size(), "Count out of range in span::first(count)");
	+ return {data(), __count};
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ constexpr span<element_type, dynamic_extent> last(index_type __count) const noexcept
	+ {
	+ _LIBCPP_ASSERT(__count >= 0 && __count <= size(), "Count out of range in span::last(count)");
	+ return {data() + size() - __count, __count};
	+ }
	+
	+ template <ptrdiff_t _Offset, ptrdiff_t _Count = dynamic_extent>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr auto subspan() const noexcept
	+ -> span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset>
	+ {
	+ _LIBCPP_ASSERT(_Offset >= 0 && _Offset <= size(), "Offset out of range in span::subspan()");
	+ return {data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
	+ }
	+
	+
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr span<element_type, dynamic_extent>
	+ subspan(index_type __offset, index_type __count = dynamic_extent) const noexcept
	+ {
	+ _LIBCPP_ASSERT( __offset >= 0 && __offset <= size(), "Offset out of range in span::subspan(offset, count)");
	+ _LIBCPP_ASSERT((__count >= 0 && __count <= size()) \|\| __count == dynamic_extent, "Count out of range in span::subspan(offset, count)");
	+ if (__count == dynamic_extent)
	+ return {data() + __offset, size() - __offset};
	+ _LIBCPP_ASSERT(__offset + __count <= size(), "count + offset out of range in span::subspan(offset, count)");
	+ return {data() + __offset, __count};
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY constexpr index_type size() const noexcept { return _Extent; }
	+ _LIBCPP_INLINE_VISIBILITY constexpr index_type size_bytes() const noexcept { return _Extent * sizeof(element_type); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr bool empty() const noexcept { return _Extent == 0; }
	+
	+ _LIBCPP_INLINE_VISIBILITY constexpr reference operator[](index_type __idx) const noexcept
	+ {
	+ _LIBCPP_ASSERT(__idx >= 0 && __idx < size(), "span<T,N>[] index out of bounds");
	+ return __data[__idx];
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY constexpr reference operator()(index_type __idx) const noexcept
	+ {
	+ _LIBCPP_ASSERT(__idx >= 0 && __idx < size(), "span<T,N>() index out of bounds");
	+ return __data[__idx];
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY constexpr pointer data() const noexcept { return __data; }
	+
	+// [span.iter], span iterator support
	+ _LIBCPP_INLINE_VISIBILITY constexpr iterator begin() const noexcept { return iterator(data()); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr iterator end() const noexcept { return iterator(data() + size()); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr const_iterator cbegin() const noexcept { return const_iterator(data()); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr const_iterator cend() const noexcept { return const_iterator(data() + size()); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(cend()); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr const_reverse_iterator crend() const noexcept { return const_reverse_iterator(cbegin()); }
	+
	+ _LIBCPP_INLINE_VISIBILITY constexpr void swap(span &__other) noexcept
	+ {
	+ pointer __p = __data;
	+ __data = __other.__data;
	+ __other.__data = __p;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY span<const byte, _Extent * sizeof(element_type)> __as_bytes() const noexcept
	+ { return {reinterpret_cast<const byte *>(data()), size_bytes()}; }
	+
	+ _LIBCPP_INLINE_VISIBILITY span<byte, _Extent * sizeof(element_type)> __as_writeable_bytes() const noexcept
	+ { return {reinterpret_cast<byte *>(data()), size_bytes()}; }
	+
	+private:
	+ pointer __data;
	+
	+};
	+
	+
	+template <typename _Tp>
	+class _LIBCPP_TEMPLATE_VIS span<_Tp, dynamic_extent> {
	+private:
	+
	+public:
	+// constants and types
	+ using element_type = _Tp;
	+ using value_type = remove_cv_t<_Tp>;
	+ using index_type = ptrdiff_t;
	+ using difference_type = ptrdiff_t;
	+ using pointer = _Tp *;
	+ using const_pointer = const _Tp *; // not in standard
	+ using reference = _Tp &;
	+ using const_reference = const _Tp &; // not in standard
	+ using iterator = __wrap_iter<pointer>;
	+ using const_iterator = __wrap_iter<const_pointer>;
	+ using reverse_iterator = _VSTD::reverse_iterator<iterator>;
	+ using const_reverse_iterator = _VSTD::reverse_iterator<const_iterator>;
	+
	+ static constexpr index_type extent = dynamic_extent;
	+
	+// [span.cons], span constructors, copy, assignment, and destructor
	+ _LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr}, __size{0} {}
	+
	+ constexpr span (const span&) noexcept = default;
	+ constexpr span& operator=(const span&) noexcept = default;
	+
	+ _LIBCPP_INLINE_VISIBILITY constexpr span(pointer __ptr, index_type __count) : __data{__ptr}, __size{__count} {}
	+ _LIBCPP_INLINE_VISIBILITY constexpr span(pointer __f, pointer __l) : __data{__f}, __size{distance(__f, __l)} {}
	+
	+ template <size_t _Sz>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr span(element_type (&__arr)[_Sz]) noexcept : __data{__arr}, __size{_Sz} {}
	+
	+ template <size_t _Sz>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr span(array<value_type, _Sz>& __arr) noexcept : __data{__arr.data()}, __size{_Sz} {}
	+
	+ template <size_t _Sz>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr span(const array<value_type, _Sz>& __arr) noexcept : __data{__arr.data()}, __size{_Sz} {}
	+
	+ template <class _Container>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr span( _Container& __c,
	+ enable_if_t<__is_span_compatible_container<_Container, _Tp>::value, nullptr_t> = nullptr)
	+ : __data{_VSTD::data(__c)}, __size{(index_type) _VSTD::size(__c)} {}
	+
	+ template <class _Container>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr span(const _Container& __c,
	+ enable_if_t<__is_span_compatible_container<const _Container, _Tp>::value, nullptr_t> = nullptr)
	+ : __data{_VSTD::data(__c)}, __size{(index_type) _VSTD::size(__c)} {}
	+
	+
	+ template <class _OtherElementType, ptrdiff_t _OtherExtent>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr span(const span<_OtherElementType, _OtherExtent>& __other,
	+ enable_if_t<
	+ is_convertible_v<_OtherElementType()[], element_type ()[]>,
	+ nullptr_t> = nullptr) noexcept
	+ : __data{__other.data()}, __size{__other.size()} {}
	+
	+// ~span() noexcept = default;
	+
	+ template <ptrdiff_t _Count>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr span<element_type, _Count> first() const noexcept
	+ {
	+ static_assert(_Count >= 0);
	+ _LIBCPP_ASSERT(_Count <= size(), "Count out of range in span::first()");
	+ return {data(), _Count};
	+ }
	+
	+ template <ptrdiff_t _Count>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr span<element_type, _Count> last() const noexcept
	+ {
	+ static_assert(_Count >= 0);
	+ _LIBCPP_ASSERT(_Count <= size(), "Count out of range in span::last()");
	+ return {data() + size() - _Count, _Count};
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ constexpr span<element_type, dynamic_extent> first(index_type __count) const noexcept
	+ {
	+ _LIBCPP_ASSERT(__count >= 0 && __count <= size(), "Count out of range in span::first(count)");
	+ return {data(), __count};
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ constexpr span<element_type, dynamic_extent> last (index_type __count) const noexcept
	+ {
	+ _LIBCPP_ASSERT(__count >= 0 && __count <= size(), "Count out of range in span::last(count)");
	+ return {data() + size() - __count, __count};
	+ }
	+
	+ template <ptrdiff_t _Offset, ptrdiff_t _Count = dynamic_extent>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ constexpr span<_Tp, dynamic_extent> subspan() const noexcept
	+ {
	+ _LIBCPP_ASSERT(_Offset >= 0 && _Offset <= size(), "Offset out of range in span::subspan()");
	+ _LIBCPP_ASSERT(_Count == dynamic_extent \|\| _Offset + _Count <= size(), "Count out of range in span::subspan()");
	+ return {data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
	+ }
	+
	+ constexpr span<element_type, dynamic_extent>
	+ inline _LIBCPP_INLINE_VISIBILITY
	+ subspan(index_type __offset, index_type __count = dynamic_extent) const noexcept
	+ {
	+ _LIBCPP_ASSERT( __offset >= 0 && __offset <= size(), "Offset out of range in span::subspan(offset, count)");
	+ _LIBCPP_ASSERT((__count >= 0 && __count <= size()) \|\| __count == dynamic_extent, "count out of range in span::subspan(offset, count)");
	+ if (__count == dynamic_extent)
	+ return {data() + __offset, size() - __offset};
	+ _LIBCPP_ASSERT(__offset + __count <= size(), "Offset + count out of range in span::subspan(offset, count)");
	+ return {data() + __offset, __count};
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY constexpr index_type size() const noexcept { return __size; }
	+ _LIBCPP_INLINE_VISIBILITY constexpr index_type size_bytes() const noexcept { return __size * sizeof(element_type); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr bool empty() const noexcept { return __size == 0; }
	+
	+ _LIBCPP_INLINE_VISIBILITY constexpr reference operator[](index_type __idx) const noexcept
	+ {
	+ _LIBCPP_ASSERT(__idx >= 0 && __idx < size(), "span<T>[] index out of bounds");
	+ return __data[__idx];
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY constexpr reference operator()(index_type __idx) const noexcept
	+ {
	+ _LIBCPP_ASSERT(__idx >= 0 && __idx < size(), "span<T>() index out of bounds");
	+ return __data[__idx];
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY constexpr pointer data() const noexcept { return __data; }
	+
	+// [span.iter], span iterator support
	+ _LIBCPP_INLINE_VISIBILITY constexpr iterator begin() const noexcept { return iterator(data()); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr iterator end() const noexcept { return iterator(data() + size()); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr const_iterator cbegin() const noexcept { return const_iterator(data()); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr const_iterator cend() const noexcept { return const_iterator(data() + size()); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(cend()); }
	+ _LIBCPP_INLINE_VISIBILITY constexpr const_reverse_iterator crend() const noexcept { return const_reverse_iterator(cbegin()); }
	+
	+ _LIBCPP_INLINE_VISIBILITY constexpr void swap(span &__other) noexcept
	+ {
	+ pointer __p = __data;
	+ __data = __other.__data;
	+ __other.__data = __p;
	+
	+ index_type __sz = __size;
	+ __size = __other.__size;
	+ __other.__size = __sz;
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY span<const byte, dynamic_extent> __as_bytes() const noexcept
	+ { return {reinterpret_cast<const byte *>(data()), size_bytes()}; }
	+
	+ _LIBCPP_INLINE_VISIBILITY span<byte, dynamic_extent> __as_writeable_bytes() const noexcept
	+ { return {reinterpret_cast<byte *>(data()), size_bytes()}; }
	+
	+private:
	+ pointer __data;
	+ index_type __size;
	+};
	+
	+template <class _Tp1, ptrdiff_t _Extent1, class _Tp2, ptrdiff_t _Extent2>
	+ constexpr bool
	+ operator==(const span<_Tp1, _Extent1>& __lhs, const span<_Tp2, _Extent2>& __rhs)
	+ { return equal(__lhs.begin(), __lhs.end(), __rhs.begin(), __rhs.end()); }
	+
	+template <class _Tp1, ptrdiff_t _Extent1, class _Tp2, ptrdiff_t _Extent2>
	+ constexpr bool
	+ operator!=(const span<_Tp1, _Extent1>& __lhs, const span<_Tp2, _Extent2>& __rhs)
	+ { return !(__rhs == __lhs); }
	+
	+template <class _Tp1, ptrdiff_t _Extent1, class _Tp2, ptrdiff_t _Extent2>
	+ constexpr bool
	+ operator< (const span<_Tp1, _Extent1>& __lhs, const span<_Tp2, _Extent2>& __rhs)
	+ { return lexicographical_compare (__lhs.begin(), __lhs.end(), __rhs.begin(), __rhs.end()); }
	+
	+template <class _Tp1, ptrdiff_t _Extent1, class _Tp2, ptrdiff_t _Extent2>
	+ constexpr bool
	+ operator<=(const span<_Tp1, _Extent1>& __lhs, const span<_Tp2, _Extent2>& __rhs)
	+ { return !(__rhs < __lhs); }
	+
	+template <class _Tp1, ptrdiff_t _Extent1, class _Tp2, ptrdiff_t _Extent2>
	+ constexpr bool
	+ operator> (const span<_Tp1, _Extent1>& __lhs, const span<_Tp2, _Extent2>& __rhs)
	+ { return __rhs < __lhs; }
	+
	+template <class _Tp1, ptrdiff_t _Extent1, class _Tp2, ptrdiff_t _Extent2>
	+ constexpr bool
	+ operator>=(const span<_Tp1, _Extent1>& __lhs, const span<_Tp2, _Extent2>& __rhs)
	+ { return !(__lhs < __rhs); }
	+
	+// as_bytes & as_writeable_bytes
	+template <class _Tp, ptrdiff_t _Extent>
	+ auto as_bytes(span<_Tp, _Extent> __s) noexcept
	+ -> decltype(__s.__as_bytes())
	+ { return __s.__as_bytes(); }
	+
	+template <class _Tp, ptrdiff_t _Extent>
	+ auto as_writeable_bytes(span<_Tp, _Extent> __s) noexcept
	+ -> typename enable_if<!is_const_v<_Tp>, decltype(__s.__as_writeable_bytes())>::type
	+ { return __s.__as_writeable_bytes(); }
	+
	+template <class _Tp, ptrdiff_t _Extent>
	+ constexpr void swap(span<_Tp, _Extent> &__lhs, span<_Tp, _Extent> &__rhs) noexcept
	+ { __lhs.swap(__rhs); }
	+
	+
	+// Deduction guides
	+template<class _Tp, size_t _Sz>
	+ span(_Tp (&)[_Sz]) -> span<_Tp, _Sz>;
	+
	+template<class _Tp, size_t _Sz>
	+ span(array<_Tp, _Sz>&) -> span<_Tp, _Sz>;
	+
	+template<class _Tp, size_t _Sz>
	+ span(const array<_Tp, _Sz>&) -> span<const _Tp, _Sz>;
	+
	+template<class _Container>
	+ span(_Container&) -> span<typename _Container::value_type>;
	+
	+template<class _Container>
	+ span(const _Container&) -> span<const typename _Container::value_type>;
	+
	+#endif // _LIBCPP_STD_VER > 17
	+
	+_LIBCPP_END_NAMESPACE_STD
	+
	+#endif // _LIBCPP_SPAN
	Index: projects/clang700-import/contrib/libc++/include/stack
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/stack (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/stack (revision 337135)
	@@ -1,300 +1,322 @@
	// -- C++ --
	//===---------------------------- stack -----------------------------------===//
	//
	// 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_STACK
	#define _LIBCPP_STACK

	/*
	stack synopsis

	namespace std
	{

	template <class T, class Container = deque<T>>
	class stack
	{
	public:
	typedef Container container_type;
	typedef typename container_type::value_type value_type;
	typedef typename container_type::reference reference;
	typedef typename container_type::const_reference const_reference;
	typedef typename container_type::size_type size_type;

	protected:
	container_type c;

	public:
	stack() = default;
	~stack() = default;

	stack(const stack& q) = default;
	stack(stack&& q) = default;

	stack& operator=(const stack& q) = default;
	stack& operator=(stack&& q) = default;

	explicit stack(const container_type& c);
	explicit stack(container_type&& c);
	template <class Alloc> explicit stack(const Alloc& a);
	template <class Alloc> stack(const container_type& c, const Alloc& a);
	template <class Alloc> stack(container_type&& c, const Alloc& a);
	template <class Alloc> stack(const stack& c, const Alloc& a);
	template <class Alloc> stack(stack&& c, const Alloc& a);

	bool empty() const;
	size_type size() const;
	reference top();
	const_reference top() const;

	void push(const value_type& x);
	void push(value_type&& x);
	template <class... Args> reference emplace(Args&&... args); // reference in C++17
	void pop();

	void swap(stack& c) noexcept(is_nothrow_swappable_v<Container>)
	};

	+template<class Container>
	+ stack(Container) -> stack<typename Container::value_type, Container>; // C++17
	+
	+template<class Container, class Allocator>
	+ stack(Container, Allocator) -> stack<typename Container::value_type, Container>; // C++17
	+
	template <class T, class Container>
	bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
	template <class T, class Container>
	bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);
	template <class T, class Container>
	bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);
	template <class T, class Container>
	bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
	template <class T, class Container>
	bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
	template <class T, class Container>
	bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);

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

	} // std

	*/

	#include <__config>
	#include <deque>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _Tp, class _Container = deque<_Tp> > class _LIBCPP_TEMPLATE_VIS stack;

	template <class _Tp, class _Container>
	_LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);

	template <class _Tp, class _Container>
	_LIBCPP_INLINE_VISIBILITY
	bool
	operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);

	template <class _Tp, class _Container /= deque<_Tp>/>
	class _LIBCPP_TEMPLATE_VIS stack
	{
	public:
	typedef _Container container_type;
	typedef typename container_type::value_type value_type;
	typedef typename container_type::reference reference;
	typedef typename container_type::const_reference const_reference;
	typedef typename container_type::size_type size_type;
	static_assert((is_same<_Tp, value_type>::value), "" );

	protected:
	container_type c;

	public:
	_LIBCPP_INLINE_VISIBILITY
	stack()
	_NOEXCEPT_(is_nothrow_default_constructible<container_type>::value)
	: c() {}

	_LIBCPP_INLINE_VISIBILITY
	stack(const stack& __q) : c(__q.c) {}

	_LIBCPP_INLINE_VISIBILITY
	stack& operator=(const stack& __q) {c = __q.c; return *this;}


	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	stack(stack&& __q)
	_NOEXCEPT_(is_nothrow_move_constructible<container_type>::value)
	: c(_VSTD::move(__q.c)) {}

	_LIBCPP_INLINE_VISIBILITY
	stack& operator=(stack&& __q)
	_NOEXCEPT_(is_nothrow_move_assignable<container_type>::value)
	{c = _VSTD::move(__q.c); return *this;}

	_LIBCPP_INLINE_VISIBILITY
	explicit stack(container_type&& __c) : c(_VSTD::move(__c)) {}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	explicit stack(const container_type& __c) : c(__c) {}

	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	explicit stack(const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type* = 0)
	: c(__a) {}
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	stack(const container_type& __c, const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type* = 0)
	: c(__c, __a) {}
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	stack(const stack& __s, const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type* = 0)
	: c(__s.c, __a) {}
	#ifndef _LIBCPP_CXX03_LANG
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	stack(container_type&& __c, const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type* = 0)
	: c(_VSTD::move(__c), __a) {}
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	stack(stack&& __s, const _Alloc& __a,
	typename enable_if<uses_allocator<container_type,
	_Alloc>::value>::type* = 0)
	: c(_VSTD::move(__s.c), __a) {}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
	bool empty() const {return c.empty();}
	_LIBCPP_INLINE_VISIBILITY
	size_type size() const {return c.size();}
	_LIBCPP_INLINE_VISIBILITY
	reference top() {return c.back();}
	_LIBCPP_INLINE_VISIBILITY
	const_reference top() const {return c.back();}

	_LIBCPP_INLINE_VISIBILITY
	void push(const value_type& __v) {c.push_back(__v);}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	void push(value_type&& __v) {c.push_back(_VSTD::move(__v));}

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	#if _LIBCPP_STD_VER > 14
	- reference emplace(_Args&&... __args)
	+ decltype(auto) emplace(_Args&&... __args)
	{ return c.emplace_back(_VSTD::forward<_Args>(__args)...);}
	#else
	void emplace(_Args&&... __args)
	{ c.emplace_back(_VSTD::forward<_Args>(__args)...);}
	#endif
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	void pop() {c.pop_back();}

	_LIBCPP_INLINE_VISIBILITY
	void swap(stack& __s)
	_NOEXCEPT_(__is_nothrow_swappable<container_type>::value)
	{
	using _VSTD::swap;
	swap(c, __s.c);
	}

	template <class T1, class _C1>
	friend
	bool
	operator==(const stack<T1, _C1>& __x, const stack<T1, _C1>& __y);

	template <class T1, class _C1>
	friend
	bool
	operator< (const stack<T1, _C1>& __x, const stack<T1, _C1>& __y);
	};
	+
	+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
	+template<class _Container,
	+ class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type
	+>
	+stack(_Container)
	+ -> stack<typename _Container::value_type, _Container>;
	+
	+template<class _Container,
	+ class _Alloc,
	+ class = typename enable_if<!__is_allocator<_Container>::value, nullptr_t>::type,
	+ class = typename enable_if< __is_allocator<_Alloc>::value, nullptr_t>::type
	+ >
	+stack(_Container, _Alloc)
	+ -> stack<typename _Container::value_type, _Container>;
	+#endif

	template <class _Tp, class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
	{
	return __x.c == __y.c;
	}

	template <class _Tp, class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
	{
	return __x.c < __y.c;
	}

	template <class _Tp, class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
	{
	return !(__x == __y);
	}

	template <class _Tp, class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator> (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
	{
	return __y < __x;
	}

	template <class _Tp, class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
	{
	return !(__x < __y);
	}

	template <class _Tp, class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
	{
	return !(__y < __x);
	}

	template <class _Tp, class _Container>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if<
	__is_swappable<_Container>::value,
	void
	>::type
	swap(stack<_Tp, _Container>& __x, stack<_Tp, _Container>& __y)
	_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
	{
	__x.swap(__y);
	}

	template <class _Tp, class _Container, class _Alloc>
	struct _LIBCPP_TEMPLATE_VIS uses_allocator<stack<_Tp, _Container>, _Alloc>
	: public uses_allocator<_Container, _Alloc>
	{
	};

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_STACK
	Index: projects/clang700-import/contrib/libc++/include/stdbool.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/stdbool.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/stdbool.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/include/stdbool.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/stddef.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/stddef.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/stddef.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/include/stddef.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/stdexcept
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/stdexcept (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/stdexcept (revision 337135)
	@@ -1,278 +1,278 @@
	// -- C++ --
	//===--------------------------- stdexcept --------------------------------===//
	//
	// 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_STDEXCEPT
	#define _LIBCPP_STDEXCEPT

	/*
	stdexcept synopsis

	namespace std
	{

	class logic_error;
	class domain_error;
	class invalid_argument;
	class length_error;
	class out_of_range;
	class runtime_error;
	class range_error;
	class overflow_error;
	class underflow_error;

	for each class xxx_error:

	class xxx_error : public exception // at least indirectly
	{
	public:
	explicit xxx_error(const string& what_arg);
	explicit xxx_error(const char* what_arg);

	virtual const char* what() const noexcept // returns what_arg
	};

	} // std

	*/

	#include <__config>
	#include <exception>
	#include <iosfwd> // for string forward decl
	#ifdef _LIBCPP_NO_EXCEPTIONS
	#include <cstdlib>
	#endif

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	class _LIBCPP_HIDDEN __libcpp_refstring
	{
	const char* __imp_;

	bool __uses_refcount() const;
	public:
	explicit __libcpp_refstring(const char* __msg);
	__libcpp_refstring(const __libcpp_refstring& __s) _NOEXCEPT;
	__libcpp_refstring& operator=(const __libcpp_refstring& __s) _NOEXCEPT;
	~__libcpp_refstring();

	const char* c_str() const _NOEXCEPT {return __imp_;}
	};

	_LIBCPP_END_NAMESPACE_STD

	namespace std // purposefully not using versioning namespace
	{

	class _LIBCPP_EXCEPTION_ABI logic_error
	: public exception
	{
	private:
	_VSTD::__libcpp_refstring __imp_;
	public:
	explicit logic_error(const string&);
	explicit logic_error(const char*);

	logic_error(const logic_error&) _NOEXCEPT;
	logic_error& operator=(const logic_error&) _NOEXCEPT;

	virtual ~logic_error() _NOEXCEPT;

	virtual const char* what() const _NOEXCEPT;
	};

	class _LIBCPP_EXCEPTION_ABI runtime_error
	: public exception
	{
	private:
	_VSTD::__libcpp_refstring __imp_;
	public:
	explicit runtime_error(const string&);
	explicit runtime_error(const char*);

	runtime_error(const runtime_error&) _NOEXCEPT;
	runtime_error& operator=(const runtime_error&) _NOEXCEPT;

	virtual ~runtime_error() _NOEXCEPT;

	virtual const char* what() const _NOEXCEPT;
	};

	class _LIBCPP_EXCEPTION_ABI domain_error
	: public logic_error
	{
	public:
	_LIBCPP_INLINE_VISIBILITY explicit domain_error(const string& __s) : logic_error(__s) {}
	_LIBCPP_INLINE_VISIBILITY explicit domain_error(const char* __s) : logic_error(__s) {}

	virtual ~domain_error() _NOEXCEPT;
	};

	class _LIBCPP_EXCEPTION_ABI invalid_argument
	: public logic_error
	{
	public:
	_LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const string& __s) : logic_error(__s) {}
	_LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const char* __s) : logic_error(__s) {}

	virtual ~invalid_argument() _NOEXCEPT;
	};

	class _LIBCPP_EXCEPTION_ABI length_error
	: public logic_error
	{
	public:
	_LIBCPP_INLINE_VISIBILITY explicit length_error(const string& __s) : logic_error(__s) {}
	_LIBCPP_INLINE_VISIBILITY explicit length_error(const char* __s) : logic_error(__s) {}

	virtual ~length_error() _NOEXCEPT;
	};

	class _LIBCPP_EXCEPTION_ABI out_of_range
	: public logic_error
	{
	public:
	_LIBCPP_INLINE_VISIBILITY explicit out_of_range(const string& __s) : logic_error(__s) {}
	_LIBCPP_INLINE_VISIBILITY explicit out_of_range(const char* __s) : logic_error(__s) {}

	virtual ~out_of_range() _NOEXCEPT;
	};

	class _LIBCPP_EXCEPTION_ABI range_error
	: public runtime_error
	{
	public:
	_LIBCPP_INLINE_VISIBILITY explicit range_error(const string& __s) : runtime_error(__s) {}
	_LIBCPP_INLINE_VISIBILITY explicit range_error(const char* __s) : runtime_error(__s) {}

	virtual ~range_error() _NOEXCEPT;
	};

	class _LIBCPP_EXCEPTION_ABI overflow_error
	: public runtime_error
	{
	public:
	_LIBCPP_INLINE_VISIBILITY explicit overflow_error(const string& __s) : runtime_error(__s) {}
	_LIBCPP_INLINE_VISIBILITY explicit overflow_error(const char* __s) : runtime_error(__s) {}

	virtual ~overflow_error() _NOEXCEPT;
	};

	class _LIBCPP_EXCEPTION_ABI underflow_error
	: public runtime_error
	{
	public:
	_LIBCPP_INLINE_VISIBILITY explicit underflow_error(const string& __s) : runtime_error(__s) {}
	_LIBCPP_INLINE_VISIBILITY explicit underflow_error(const char* __s) : runtime_error(__s) {}

	virtual ~underflow_error() _NOEXCEPT;
	};

	} // std

	_LIBCPP_BEGIN_NAMESPACE_STD

	// in the dylib
	_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);

	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
	void __throw_logic_error(const char*__msg)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw logic_error(__msg);
	#else
	((void)__msg);
	_VSTD::abort();
	#endif
	}

	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
	void __throw_domain_error(const char*__msg)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw domain_error(__msg);
	#else
	((void)__msg);
	_VSTD::abort();
	#endif
	}

	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
	void __throw_invalid_argument(const char*__msg)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw invalid_argument(__msg);
	#else
	((void)__msg);
	_VSTD::abort();
	#endif
	}

	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
	void __throw_length_error(const char*__msg)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw length_error(__msg);
	#else
	((void)__msg);
	_VSTD::abort();
	#endif
	}

	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
	void __throw_out_of_range(const char*__msg)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw out_of_range(__msg);
	#else
	((void)__msg);
	_VSTD::abort();
	#endif
	}

	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
	void __throw_range_error(const char*__msg)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw range_error(__msg);
	#else
	((void)__msg);
	_VSTD::abort();
	#endif
	}

	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
	void __throw_overflow_error(const char*__msg)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw overflow_error(__msg);
	#else
	((void)__msg);
	_VSTD::abort();
	#endif
	}

	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
	void __throw_underflow_error(const char*__msg)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw underflow_error(__msg);
	#else
	((void)__msg);
	_VSTD::abort();
	#endif
	}

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_STDEXCEPT
	Index: projects/clang700-import/contrib/libc++/include/stdint.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/stdint.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/stdint.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/include/stdint.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/stdio.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/stdio.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/stdio.h (revision 337135)
	@@ -1,127 +1,120 @@
	// -- C++ --
	//===---------------------------- stdio.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.
	//
	//===----------------------------------------------------------------------===//

	#if defined(__need_FILE) \|\| defined(__need___FILE)

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	#include_next <stdio.h>

	#elif !defined(_LIBCPP_STDIO_H)
	#define _LIBCPP_STDIO_H

	/*
	stdio.h synopsis

	Macros:

	BUFSIZ
	EOF
	FILENAME_MAX
	FOPEN_MAX
	L_tmpnam
	NULL
	SEEK_CUR
	SEEK_END
	SEEK_SET
	TMP_MAX
	_IOFBF
	_IOLBF
	_IONBF
	stderr
	stdin
	stdout

	Types:

	FILE
	fpos_t
	size_t

	int remove(const char* filename);
	int rename(const char* old, const char* new);
	FILE* tmpfile(void);
	char* tmpnam(char* s);
	int fclose(FILE* stream);
	int fflush(FILE* stream);
	FILE* fopen(const char* restrict filename, const char* restrict mode);
	FILE* freopen(const char* restrict filename, const char * restrict mode,
	FILE * restrict stream);
	void setbuf(FILE* restrict stream, char* restrict buf);
	int setvbuf(FILE* restrict stream, char* restrict buf, int mode, size_t size);
	int fprintf(FILE* restrict stream, const char* restrict format, ...);
	int fscanf(FILE* restrict stream, const char * restrict format, ...);
	int printf(const char* restrict format, ...);
	int scanf(const char* restrict format, ...);
	int snprintf(char* restrict s, size_t n, const char* restrict format, ...); // C99
	int sprintf(char* restrict s, const char* restrict format, ...);
	int sscanf(const char* restrict s, const char* restrict format, ...);
	int vfprintf(FILE* restrict stream, const char* restrict format, va_list arg);
	int vfscanf(FILE* restrict stream, const char* restrict format, va_list arg); // C99
	int vprintf(const char* restrict format, va_list arg);
	int vscanf(const char* restrict format, va_list arg); // C99
	int vsnprintf(char* restrict s, size_t n, const char* restrict format, // C99
	va_list arg);
	int vsprintf(char* restrict s, const char* restrict format, va_list arg);
	int vsscanf(const char* restrict s, const char* restrict format, va_list arg); // C99
	int fgetc(FILE* stream);
	char* fgets(char* restrict s, int n, FILE* restrict stream);
	int fputc(int c, FILE* stream);
	int fputs(const char* restrict s, FILE* restrict stream);
	int getc(FILE* stream);
	int getchar(void);
	char* gets(char* s); // removed in C++14
	int putc(int c, FILE* stream);
	int putchar(int c);
	int puts(const char* s);
	int ungetc(int c, FILE* stream);
	size_t fread(void* restrict ptr, size_t size, size_t nmemb,
	FILE* restrict stream);
	size_t fwrite(const void* restrict ptr, size_t size, size_t nmemb,
	FILE* restrict stream);
	int fgetpos(FILE* restrict stream, fpos_t* restrict pos);
	int fseek(FILE* stream, long offset, int whence);
	int fsetpos(FILEstream, const fpos_t pos);
	long ftell(FILE* stream);
	void rewind(FILE* stream);
	void clearerr(FILE* stream);
	int feof(FILE* stream);
	int ferror(FILE* stream);
	void perror(const char* s);
	*/

	#include <__config>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	#include_next <stdio.h>

	#ifdef __cplusplus

	-// snprintf
	-#if defined(_LIBCPP_MSVCRT_LIKE)
	-extern "C" {
	-int vasprintf(char *sptr, const char __restrict fmt, va_list ap);
	-}
	-#endif
	-
	#undef getc
	#undef putc
	#undef clearerr
	#undef feof
	#undef ferror

	#endif

	#endif // _LIBCPP_STDIO_H

	Property changes on: projects/clang700-import/contrib/libc++/include/stdio.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/stdlib.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/stdlib.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/stdlib.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/include/stdlib.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/streambuf
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/streambuf (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/streambuf (revision 337135)
	@@ -1,498 +1,501 @@
	// -- C++ --
	//===------------------------- streambuf ----------------------------------===//
	//
	// 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_STEAMBUF
	#define _LIBCPP_STEAMBUF

	/*
	streambuf synopsis

	namespace std
	{

	template <class charT, class traits = char_traits<charT> >
	class basic_streambuf
	{
	public:
	// types:
	typedef charT char_type;
	typedef traits traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;

	virtual ~basic_streambuf();

	// 27.6.2.2.1 locales:
	locale pubimbue(const locale& loc);
	locale getloc() const;

	// 27.6.2.2.2 buffer and positioning:
	basic_streambuf* pubsetbuf(char_type* s, streamsize n);
	pos_type pubseekoff(off_type off, ios_base::seekdir way,
	ios_base::openmode which = ios_base::in \| ios_base::out);
	pos_type pubseekpos(pos_type sp,
	ios_base::openmode which = ios_base::in \| ios_base::out);
	int pubsync();

	// Get and put areas:
	// 27.6.2.2.3 Get area:
	streamsize in_avail();
	int_type snextc();
	int_type sbumpc();
	int_type sgetc();
	streamsize sgetn(char_type* s, streamsize n);

	// 27.6.2.2.4 Putback:
	int_type sputbackc(char_type c);
	int_type sungetc();

	// 27.6.2.2.5 Put area:
	int_type sputc(char_type c);
	streamsize sputn(const char_type* s, streamsize n);

	protected:
	basic_streambuf();
	basic_streambuf(const basic_streambuf& rhs);
	basic_streambuf& operator=(const basic_streambuf& rhs);
	void swap(basic_streambuf& rhs);

	// 27.6.2.3.2 Get area:
	char_type* eback() const;
	char_type* gptr() const;
	char_type* egptr() const;
	void gbump(int n);
	void setg(char_type* gbeg, char_type* gnext, char_type* gend);

	// 27.6.2.3.3 Put area:
	char_type* pbase() const;
	char_type* pptr() const;
	char_type* epptr() const;
	void pbump(int n);
	void setp(char_type* pbeg, char_type* pend);

	// 27.6.2.4 virtual functions:
	// 27.6.2.4.1 Locales:
	virtual void imbue(const locale& loc);

	// 27.6.2.4.2 Buffer management and positioning:
	virtual basic_streambuf* setbuf(char_type* s, streamsize n);
	virtual pos_type seekoff(off_type off, ios_base::seekdir way,
	ios_base::openmode which = ios_base::in \| ios_base::out);
	virtual pos_type seekpos(pos_type sp,
	ios_base::openmode which = ios_base::in \| ios_base::out);
	virtual int sync();

	// 27.6.2.4.3 Get area:
	virtual streamsize showmanyc();
	virtual streamsize xsgetn(char_type* s, streamsize n);
	virtual int_type underflow();
	virtual int_type uflow();

	// 27.6.2.4.4 Putback:
	virtual int_type pbackfail(int_type c = traits_type::eof());

	// 27.6.2.4.5 Put area:
	virtual streamsize xsputn(const char_type* s, streamsize n);
	virtual int_type overflow (int_type c = traits_type::eof());
	};

	} // std

	*/

	#include <__config>
	#include <iosfwd>
	#include <ios>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>

	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _CharT, class _Traits>
	class _LIBCPP_TEMPLATE_VIS basic_streambuf
	{
	public:
	// types:
	typedef _CharT char_type;
	typedef _Traits traits_type;
	typedef typename traits_type::int_type int_type;
	typedef typename traits_type::pos_type pos_type;
	typedef typename traits_type::off_type off_type;

	+ static_assert((is_same<_CharT, typename traits_type::char_type>::value),
	+ "traits_type::char_type must be the same type as CharT");
	+
	virtual ~basic_streambuf();

	// 27.6.2.2.1 locales:
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	locale pubimbue(const locale& __loc) {
	imbue(__loc);
	locale __r = __loc_;
	__loc_ = __loc;
	return __r;
	}

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	locale getloc() const { return __loc_; }

	// 27.6.2.2.2 buffer and positioning:
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	basic_streambuf* pubsetbuf(char_type* __s, streamsize __n)
	{ return setbuf(__s, __n); }

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	pos_type pubseekoff(off_type __off, ios_base::seekdir __way,
	ios_base::openmode __which = ios_base::in \| ios_base::out)
	{ return seekoff(__off, __way, __which); }

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	pos_type pubseekpos(pos_type __sp,
	ios_base::openmode __which = ios_base::in \| ios_base::out)
	{ return seekpos(__sp, __which); }

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	int pubsync() { return sync(); }

	// Get and put areas:
	// 27.6.2.2.3 Get area:
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	streamsize in_avail() {
	if (__ninp_ < __einp_)
	return static_cast<streamsize>(__einp_ - __ninp_);
	return showmanyc();
	}

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	int_type snextc() {
	if (sbumpc() == traits_type::eof())
	return traits_type::eof();
	return sgetc();
	}

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	int_type sbumpc() {
	if (__ninp_ == __einp_)
	return uflow();
	return traits_type::to_int_type(*__ninp_++);
	}

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	int_type sgetc() {
	if (__ninp_ == __einp_)
	return underflow();
	return traits_type::to_int_type(*__ninp_);
	}

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	streamsize sgetn(char_type* __s, streamsize __n)
	{ return xsgetn(__s, __n); }

	// 27.6.2.2.4 Putback:
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	int_type sputbackc(char_type __c) {
	if (__binp_ == __ninp_ \|\| !traits_type::eq(__c, __ninp_[-1]))
	return pbackfail(traits_type::to_int_type(__c));
	return traits_type::to_int_type(*--__ninp_);
	}

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	int_type sungetc() {
	if (__binp_ == __ninp_)
	return pbackfail();
	return traits_type::to_int_type(*--__ninp_);
	}

	// 27.6.2.2.5 Put area:
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	int_type sputc(char_type __c) {
	if (__nout_ == __eout_)
	return overflow(traits_type::to_int_type(__c));
	*__nout_++ = __c;
	return traits_type::to_int_type(__c);
	}

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	streamsize sputn(const char_type* __s, streamsize __n)
	{ return xsputn(__s, __n); }

	protected:
	basic_streambuf();
	basic_streambuf(const basic_streambuf& __rhs);
	basic_streambuf& operator=(const basic_streambuf& __rhs);
	void swap(basic_streambuf& __rhs);

	// 27.6.2.3.2 Get area:
	- _LIBCPP_ALWAYS_INLINE char_type* eback() const {return __binp_;}
	- _LIBCPP_ALWAYS_INLINE char_type* gptr() const {return __ninp_;}
	- _LIBCPP_ALWAYS_INLINE char_type* egptr() const {return __einp_;}
	+ _LIBCPP_INLINE_VISIBILITY char_type* eback() const {return __binp_;}
	+ _LIBCPP_INLINE_VISIBILITY char_type* gptr() const {return __ninp_;}
	+ _LIBCPP_INLINE_VISIBILITY char_type* egptr() const {return __einp_;}

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	void gbump(int __n) { __ninp_ += __n; }

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) {
	__binp_ = __gbeg;
	__ninp_ = __gnext;
	__einp_ = __gend;
	}

	// 27.6.2.3.3 Put area:
	- _LIBCPP_ALWAYS_INLINE char_type* pbase() const {return __bout_;}
	- _LIBCPP_ALWAYS_INLINE char_type* pptr() const {return __nout_;}
	- _LIBCPP_ALWAYS_INLINE char_type* epptr() const {return __eout_;}
	+ _LIBCPP_INLINE_VISIBILITY char_type* pbase() const {return __bout_;}
	+ _LIBCPP_INLINE_VISIBILITY char_type* pptr() const {return __nout_;}
	+ _LIBCPP_INLINE_VISIBILITY char_type* epptr() const {return __eout_;}

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	void pbump(int __n) { __nout_ += __n; }

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void __pbump(streamsize __n) { __nout_ += __n; }

	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	void setp(char_type* __pbeg, char_type* __pend) {
	__bout_ = __nout_ = __pbeg;
	__eout_ = __pend;
	}

	// 27.6.2.4 virtual functions:
	// 27.6.2.4.1 Locales:
	virtual void imbue(const locale& __loc);

	// 27.6.2.4.2 Buffer management and positioning:
	virtual basic_streambuf* setbuf(char_type* __s, streamsize __n);
	virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
	ios_base::openmode __which = ios_base::in \| ios_base::out);
	virtual pos_type seekpos(pos_type __sp,
	ios_base::openmode __which = ios_base::in \| ios_base::out);
	virtual int sync();

	// 27.6.2.4.3 Get area:
	virtual streamsize showmanyc();
	virtual streamsize xsgetn(char_type* __s, streamsize __n);
	virtual int_type underflow();
	virtual int_type uflow();

	// 27.6.2.4.4 Putback:
	virtual int_type pbackfail(int_type __c = traits_type::eof());

	// 27.6.2.4.5 Put area:
	virtual streamsize xsputn(const char_type* __s, streamsize __n);
	virtual int_type overflow(int_type __c = traits_type::eof());

	private:
	locale __loc_;
	char_type* __binp_;
	char_type* __ninp_;
	char_type* __einp_;
	char_type* __bout_;
	char_type* __nout_;
	char_type* __eout_;
	};

	template <class _CharT, class _Traits>
	basic_streambuf<_CharT, _Traits>::~basic_streambuf()
	{
	}

	template <class _CharT, class _Traits>
	basic_streambuf<_CharT, _Traits>::basic_streambuf()
	: __binp_(0),
	__ninp_(0),
	__einp_(0),
	__bout_(0),
	__nout_(0),
	__eout_(0)
	{
	}

	template <class _CharT, class _Traits>
	basic_streambuf<_CharT, _Traits>::basic_streambuf(const basic_streambuf& __sb)
	: __loc_(__sb.__loc_),
	__binp_(__sb.__binp_),
	__ninp_(__sb.__ninp_),
	__einp_(__sb.__einp_),
	__bout_(__sb.__bout_),
	__nout_(__sb.__nout_),
	__eout_(__sb.__eout_)
	{
	}

	template <class _CharT, class _Traits>
	basic_streambuf<_CharT, _Traits>&
	basic_streambuf<_CharT, _Traits>::operator=(const basic_streambuf& __sb)
	{
	__loc_ = __sb.__loc_;
	__binp_ = __sb.__binp_;
	__ninp_ = __sb.__ninp_;
	__einp_ = __sb.__einp_;
	__bout_ = __sb.__bout_;
	__nout_ = __sb.__nout_;
	__eout_ = __sb.__eout_;
	return *this;
	}

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

	template <class _CharT, class _Traits>
	void
	basic_streambuf<_CharT, _Traits>::imbue(const locale&)
	{
	}

	template <class _CharT, class _Traits>
	basic_streambuf<_CharT, _Traits>*
	basic_streambuf<_CharT, _Traits>::setbuf(char_type*, streamsize)
	{
	return this;
	}

	template <class _CharT, class _Traits>
	typename basic_streambuf<_CharT, _Traits>::pos_type
	basic_streambuf<_CharT, _Traits>::seekoff(off_type, ios_base::seekdir,
	ios_base::openmode)
	{
	return pos_type(off_type(-1));
	}

	template <class _CharT, class _Traits>
	typename basic_streambuf<_CharT, _Traits>::pos_type
	basic_streambuf<_CharT, _Traits>::seekpos(pos_type, ios_base::openmode)
	{
	return pos_type(off_type(-1));
	}

	template <class _CharT, class _Traits>
	int
	basic_streambuf<_CharT, _Traits>::sync()
	{
	return 0;
	}

	template <class _CharT, class _Traits>
	streamsize
	basic_streambuf<_CharT, _Traits>::showmanyc()
	{
	return 0;
	}

	template <class _CharT, class _Traits>
	streamsize
	basic_streambuf<_CharT, _Traits>::xsgetn(char_type* __s, streamsize __n)
	{
	const int_type __eof = traits_type::eof();
	int_type __c;
	streamsize __i = 0;
	while(__i < __n)
	{
	if (__ninp_ < __einp_)
	{
	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;
	this->gbump(__len);
	}
	else if ((__c = uflow()) != __eof)
	{
	*__s = traits_type::to_char_type(__c);
	++__s;
	++__i;
	}
	else
	break;
	}
	return __i;
	}

	template <class _CharT, class _Traits>
	typename basic_streambuf<_CharT, _Traits>::int_type
	basic_streambuf<_CharT, _Traits>::underflow()
	{
	return traits_type::eof();
	}

	template <class _CharT, class _Traits>
	typename basic_streambuf<_CharT, _Traits>::int_type
	basic_streambuf<_CharT, _Traits>::uflow()
	{
	if (underflow() == traits_type::eof())
	return traits_type::eof();
	return traits_type::to_int_type(*__ninp_++);
	}

	template <class _CharT, class _Traits>
	typename basic_streambuf<_CharT, _Traits>::int_type
	basic_streambuf<_CharT, _Traits>::pbackfail(int_type)
	{
	return traits_type::eof();
	}

	template <class _CharT, class _Traits>
	streamsize
	basic_streambuf<_CharT, _Traits>::xsputn(const char_type* __s, streamsize __n)
	{
	streamsize __i = 0;
	int_type __eof = traits_type::eof();
	while( __i < __n)
	{
	if (__nout_ >= __eout_)
	{
	if (overflow(traits_type::to_int_type(*__s)) == __eof)
	break;
	++__s;
	++__i;
	}
	else
	{
	streamsize __chunk_size = _VSTD::min(__eout_ - __nout_, __n - __i);
	traits_type::copy(__nout_, __s, __chunk_size);
	__nout_ += __chunk_size;
	__s += __chunk_size;
	__i += __chunk_size;
	}
	}
	return __i;
	}

	template <class _CharT, class _Traits>
	typename basic_streambuf<_CharT, _Traits>::int_type
	basic_streambuf<_CharT, _Traits>::overflow(int_type)
	{
	return traits_type::eof();
	}

	#ifndef _LIBCPP_AVAILABILITY_NO_STREAMS_EXTERN_TEMPLATE
	_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_streambuf<char>)
	_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_streambuf<wchar_t>)

	_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ios<char>)
	_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ios<wchar_t>)
	#endif

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_STEAMBUF
	Index: projects/clang700-import/contrib/libc++/include/string
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/string (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/string (revision 337135)
	@@ -1,4076 +1,4304 @@
	// -- C++ --
	//===--------------------------- string -----------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP_STRING
	#define _LIBCPP_STRING

	/*
	string synopsis

	namespace std
	{

	template <class stateT>
	class fpos
	{
	private:
	stateT st;
	public:
	fpos(streamoff = streamoff());

	operator streamoff() const;

	stateT state() const;
	void state(stateT);

	fpos& operator+=(streamoff);
	fpos operator+ (streamoff) const;
	fpos& operator-=(streamoff);
	fpos operator- (streamoff) const;
	};

	template <class stateT> streamoff operator-(const fpos<stateT>& x, const fpos<stateT>& y);

	template <class stateT> bool operator==(const fpos<stateT>& x, const fpos<stateT>& y);
	template <class stateT> bool operator!=(const fpos<stateT>& x, const fpos<stateT>& y);

	template <class charT>
	struct char_traits
	{
	typedef charT char_type;
	typedef ... int_type;
	typedef streamoff off_type;
	typedef streampos pos_type;
	typedef mbstate_t state_type;

	static void assign(char_type& c1, const char_type& c2) noexcept;
	static constexpr bool eq(char_type c1, char_type c2) noexcept;
	static constexpr bool lt(char_type c1, char_type c2) noexcept;

	static int compare(const char_type* s1, const char_type* s2, size_t n);
	static size_t length(const char_type* s);
	static const char_type* find(const char_type* s, size_t n, const char_type& a);
	static char_type* move(char_type* s1, const char_type* s2, size_t n);
	static char_type* copy(char_type* s1, const char_type* s2, size_t n);
	static char_type* assign(char_type* s, size_t n, char_type a);

	static constexpr int_type not_eof(int_type c) noexcept;
	static constexpr char_type to_char_type(int_type c) noexcept;
	static constexpr int_type to_int_type(char_type c) noexcept;
	static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept;
	static constexpr int_type eof() noexcept;
	};

	template <> struct char_traits<char>;
	template <> struct char_traits<wchar_t>;

	template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> >
	class basic_string
	{
	public:
	// types:
	typedef traits traits_type;
	typedef typename traits_type::char_type value_type;
	typedef Allocator allocator_type;
	typedef typename allocator_type::size_type size_type;
	typedef typename allocator_type::difference_type difference_type;
	typedef typename allocator_type::reference reference;
	typedef typename allocator_type::const_reference const_reference;
	typedef typename allocator_type::pointer pointer;
	typedef typename allocator_type::const_pointer const_pointer;
	typedef implementation-defined iterator;
	typedef implementation-defined const_iterator;
	typedef std::reverse_iterator<iterator> reverse_iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

	static const size_type npos = -1;

	basic_string()
	noexcept(is_nothrow_default_constructible<allocator_type>::value);
	explicit basic_string(const allocator_type& a);
	basic_string(const basic_string& str);
	basic_string(basic_string&& str)
	noexcept(is_nothrow_move_constructible<allocator_type>::value);
	basic_string(const basic_string& str, size_type pos,
	const allocator_type& a = allocator_type());
	basic_string(const basic_string& str, size_type pos, size_type n,
	const Allocator& a = Allocator());
	template<class T>
	basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator()); // C++17
	- explicit basic_string(const basic_string_view<charT, traits> sv, const Allocator& a = Allocator());
	+ template <class T>
	+ explicit basic_string(const T& t, const Allocator& a = Allocator()); // C++17
	basic_string(const value_type* s, const allocator_type& a = allocator_type());
	basic_string(const value_type* s, size_type n, const allocator_type& a = allocator_type());
	basic_string(size_type n, value_type c, const allocator_type& a = allocator_type());
	template<class InputIterator>
	basic_string(InputIterator begin, InputIterator end,
	const allocator_type& a = allocator_type());
	basic_string(initializer_list<value_type>, const Allocator& = Allocator());
	basic_string(const basic_string&, const Allocator&);
	basic_string(basic_string&&, const Allocator&);

	~basic_string();

	operator basic_string_view<charT, traits>() const noexcept;

	basic_string& operator=(const basic_string& str);
	- basic_string& operator=(basic_string_view<charT, traits> sv);
	+ template <class T>
	+ basic_string& operator=(const T& t); // C++17
	basic_string& operator=(basic_string&& str)
	noexcept(
	allocator_type::propagate_on_container_move_assignment::value \|\|
	allocator_type::is_always_equal::value ); // C++17
	basic_string& operator=(const value_type* s);
	basic_string& operator=(value_type c);
	basic_string& operator=(initializer_list<value_type>);

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

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

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

	size_type size() const noexcept;
	size_type length() const noexcept;
	size_type max_size() const noexcept;
	size_type capacity() const noexcept;

	void resize(size_type n, value_type c);
	void resize(size_type n);

	void reserve(size_type res_arg = 0);
	void shrink_to_fit();
	void clear() noexcept;
	bool empty() const noexcept;

	const_reference operator[](size_type pos) const;
	reference operator[](size_type pos);

	const_reference at(size_type n) const;
	reference at(size_type n);

	basic_string& operator+=(const basic_string& str);
	- basic_string& operator+=(basic_string_view<charT, traits> sv);
	+ template <class T>
	+ basic_string& operator+=(const T& t); // C++17
	basic_string& operator+=(const value_type* s);
	basic_string& operator+=(value_type c);
	basic_string& operator+=(initializer_list<value_type>);

	basic_string& append(const basic_string& str);
	- basic_string& append(basic_string_view<charT, traits> sv);
	+ template <class T>
	+ basic_string& append(const T& t); // C++17
	basic_string& append(const basic_string& str, size_type pos, size_type n=npos); //C++14
	template <class T>
	basic_string& append(const T& t, size_type pos, size_type n=npos); // C++17
	basic_string& append(const value_type* s, size_type n);
	basic_string& append(const value_type* s);
	basic_string& append(size_type n, value_type c);
	template<class InputIterator>
	basic_string& append(InputIterator first, InputIterator last);
	basic_string& append(initializer_list<value_type>);

	void push_back(value_type c);
	void pop_back();
	reference front();
	const_reference front() const;
	reference back();
	const_reference back() const;

	basic_string& assign(const basic_string& str);
	- basic_string& assign(basic_string_view<charT, traits> sv);
	+ template <class T>
	+ basic_string& assign(const T& t); // C++17
	basic_string& assign(basic_string&& str);
	basic_string& assign(const basic_string& str, size_type pos, size_type n=npos); // C++14
	template <class T>
	basic_string& assign(const T& t, size_type pos, size_type n=npos); // C++17
	basic_string& assign(const value_type* s, size_type n);
	basic_string& assign(const value_type* s);
	basic_string& assign(size_type n, value_type c);
	template<class InputIterator>
	basic_string& assign(InputIterator first, InputIterator last);
	basic_string& assign(initializer_list<value_type>);

	basic_string& insert(size_type pos1, const basic_string& str);
	- basic_string& insert(size_type pos1, basic_string_view<charT, traits> sv);
	+ template <class T>
	+ basic_string& insert(size_type pos1, const T& t);
	basic_string& insert(size_type pos1, const basic_string& str,
	size_type pos2, size_type n);
	template <class T>
	basic_string& insert(size_type pos1, const T& t, size_type pos2, size_type n); // C++17
	basic_string& insert(size_type pos, const value_type* s, size_type n=npos); //C++14
	basic_string& insert(size_type pos, const value_type* s);
	basic_string& insert(size_type pos, size_type n, value_type c);
	iterator insert(const_iterator p, value_type c);
	iterator insert(const_iterator p, size_type n, value_type c);
	template<class InputIterator>
	iterator insert(const_iterator p, InputIterator first, InputIterator last);
	iterator insert(const_iterator p, initializer_list<value_type>);

	basic_string& erase(size_type pos = 0, size_type n = npos);
	iterator erase(const_iterator position);
	iterator erase(const_iterator first, const_iterator last);

	basic_string& replace(size_type pos1, size_type n1, const basic_string& str);
	- basic_string& replace(size_type pos1, size_type n1, basic_string_view<charT, traits> sv);
	+ template <class T>
	+ basic_string& replace(size_type pos1, size_type n1, const T& t); // C++17
	basic_string& replace(size_type pos1, size_type n1, const basic_string& str,
	size_type pos2, size_type n2=npos); // C++14
	template <class T>
	basic_string& replace(size_type pos1, size_type n1, const T& t,
	size_type pos2, size_type n); // C++17
	basic_string& replace(size_type pos, size_type n1, const value_type* s, size_type n2);
	basic_string& replace(size_type pos, size_type n1, const value_type* s);
	basic_string& replace(size_type pos, size_type n1, size_type n2, value_type c);
	basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
	- basic_string& replace(const_iterator i1, const_iterator i2, basic_string_view<charT, traits> sv);
	+ template <class T>
	+ basic_string& replace(const_iterator i1, const_iterator i2, const T& t); // C++17
	basic_string& replace(const_iterator i1, const_iterator i2, const value_type* s, size_type n);
	basic_string& replace(const_iterator i1, const_iterator i2, const value_type* s);
	basic_string& replace(const_iterator i1, const_iterator i2, size_type n, value_type c);
	template<class InputIterator>
	basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2);
	basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<value_type>);

	size_type copy(value_type* s, size_type n, size_type pos = 0) const;
	basic_string substr(size_type pos = 0, size_type n = npos) const;

	void swap(basic_string& str)
	noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value \|\|
	allocator_traits<allocator_type>::is_always_equal::value); // C++17

	const value_type* c_str() const noexcept;
	const value_type* data() const noexcept;
	value_type* data() noexcept; // C++17

	allocator_type get_allocator() const noexcept;

	size_type find(const basic_string& str, size_type pos = 0) const noexcept;
	- size_type find(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;
	+ template <class T>
	+ size_type find(const T& t, size_type pos = 0) const; // C++17
	size_type find(const value_type* s, size_type pos, size_type n) const noexcept;
	size_type find(const value_type* s, size_type pos = 0) const noexcept;
	size_type find(value_type c, size_type pos = 0) const noexcept;

	size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
	- size_type rfind(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;
	+ template <class T>
	+ size_type rfind(const T& t, size_type pos = npos) const; // C++17
	size_type rfind(const value_type* s, size_type pos, size_type n) const noexcept;
	size_type rfind(const value_type* s, size_type pos = npos) const noexcept;
	size_type rfind(value_type c, size_type pos = npos) const noexcept;

	size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;
	- size_type find_first_of(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;
	+ template <class T>
	+ size_type find_first_of(const T& t, size_type pos = 0) const; // C++17
	size_type find_first_of(const value_type* s, size_type pos, size_type n) const noexcept;
	size_type find_first_of(const value_type* s, size_type pos = 0) const noexcept;
	size_type find_first_of(value_type c, size_type pos = 0) const noexcept;

	size_type find_last_of(const basic_string& str, size_type pos = npos) const noexcept;
	- size_type find_last_of(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;
	+ template <class T>
	+ size_type find_last_of(const T& t, size_type pos = npos) const noexcept; // C++17
	size_type find_last_of(const value_type* s, size_type pos, size_type n) const noexcept;
	size_type find_last_of(const value_type* s, size_type pos = npos) const noexcept;
	size_type find_last_of(value_type c, size_type pos = npos) const noexcept;

	size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept;
	- size_type find_first_not_of(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;
	+ template <class T>
	+ size_type find_first_not_of(const T& t, size_type pos = 0) const; // C++17
	size_type find_first_not_of(const value_type* s, size_type pos, size_type n) const noexcept;
	size_type find_first_not_of(const value_type* s, size_type pos = 0) const noexcept;
	size_type find_first_not_of(value_type c, size_type pos = 0) const noexcept;

	size_type find_last_not_of(const basic_string& str, size_type pos = npos) const noexcept;
	- size_type find_last_not_of(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;
	+ template <class T>
	+ size_type find_last_not_of(const T& t, size_type pos = npos) const; // C++17
	size_type find_last_not_of(const value_type* s, size_type pos, size_type n) const noexcept;
	size_type find_last_not_of(const value_type* s, size_type pos = npos) const noexcept;
	size_type find_last_not_of(value_type c, size_type pos = npos) const noexcept;

	int compare(const basic_string& str) const noexcept;
	- int compare(basic_string_view<charT, traits> sv) const noexcept;
	+ template <class T>
	+ int compare(const T& t) const noexcept; // C++17
	int compare(size_type pos1, size_type n1, const basic_string& str) const;
	- int compare(size_type pos1, size_type n1, basic_string_view<charT, traits> sv) const;
	+ template <class T>
	+ int compare(size_type pos1, size_type n1, const T& t) const; // C++17
	int compare(size_type pos1, size_type n1, const basic_string& str,
	size_type pos2, size_type n2=npos) const; // C++14
	template <class T>
	int compare(size_type pos1, size_type n1, const T& t,
	size_type pos2, size_type n2=npos) const; // C++17
	int compare(const value_type* s) const noexcept;
	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;
	};

	+template<class InputIterator,
	+ class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
	+basic_string(InputIterator, InputIterator, Allocator = Allocator())
	+ -> basic_string<typename iterator_traits<InputIterator>::value_type,
	+ char_traits<typename iterator_traits<InputIterator>::value_type>,
	+ Allocator>; // C++17
	+
	template<class charT, class traits, class Allocator>
	basic_string<charT, traits, Allocator>
	operator+(const basic_string<charT, traits, Allocator>& lhs,
	const basic_string<charT, traits, Allocator>& rhs);

	template<class charT, class traits, class Allocator>
	basic_string<charT, traits, Allocator>
	operator+(const charT* lhs , const basic_string<charT,traits,Allocator>&rhs);

	template<class charT, class traits, class Allocator>
	basic_string<charT, traits, Allocator>
	operator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs);

	template<class charT, class traits, class Allocator>
	basic_string<charT, traits, Allocator>
	operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);

	template<class charT, class traits, class Allocator>
	basic_string<charT, traits, Allocator>
	operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs);

	template<class charT, class traits, class Allocator>
	bool operator==(const basic_string<charT, traits, Allocator>& lhs,
	const basic_string<charT, traits, Allocator>& rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator==(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator==(const basic_string<charT,traits,Allocator>& lhs, const charT* rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator!=(const basic_string<charT,traits,Allocator>& lhs,
	const basic_string<charT, traits, Allocator>& rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator!=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator!=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator< (const basic_string<charT, traits, Allocator>& lhs,
	const basic_string<charT, traits, Allocator>& rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator< (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator< (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator> (const basic_string<charT, traits, Allocator>& lhs,
	const basic_string<charT, traits, Allocator>& rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator> (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator> (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator<=(const basic_string<charT, traits, Allocator>& lhs,
	const basic_string<charT, traits, Allocator>& rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator<=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator<=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator>=(const basic_string<charT, traits, Allocator>& lhs,
	const basic_string<charT, traits, Allocator>& rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator>=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs) noexcept;

	template<class charT, class traits, class Allocator>
	bool operator>=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;

	template<class charT, class traits, class Allocator>
	void swap(basic_string<charT, traits, Allocator>& lhs,
	basic_string<charT, traits, Allocator>& rhs)
	noexcept(noexcept(lhs.swap(rhs)));

	template<class charT, class traits, class Allocator>
	basic_istream<charT, traits>&
	operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);

	template<class charT, class traits, class Allocator>
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os, const basic_string<charT, traits, Allocator>& str);

	template<class charT, class traits, class Allocator>
	basic_istream<charT, traits>&
	getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str,
	charT delim);

	template<class charT, class traits, class Allocator>
	basic_istream<charT, traits>&
	getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);

	typedef basic_string<char> string;
	typedef basic_string<wchar_t> wstring;
	typedef basic_string<char16_t> u16string;
	typedef basic_string<char32_t> u32string;

	int stoi (const string& str, size_t* idx = 0, int base = 10);
	long stol (const string& str, size_t* idx = 0, int base = 10);
	unsigned long stoul (const string& str, size_t* idx = 0, int base = 10);
	long long stoll (const string& str, size_t* idx = 0, int base = 10);
	unsigned long long stoull(const string& str, size_t* idx = 0, int base = 10);

	float stof (const string& str, size_t* idx = 0);
	double stod (const string& str, size_t* idx = 0);
	long double stold(const string& str, size_t* idx = 0);

	string to_string(int val);
	string to_string(unsigned val);
	string to_string(long val);
	string to_string(unsigned long val);
	string to_string(long long val);
	string to_string(unsigned long long val);
	string to_string(float val);
	string to_string(double val);
	string to_string(long double val);

	int stoi (const wstring& str, size_t* idx = 0, int base = 10);
	long stol (const wstring& str, size_t* idx = 0, int base = 10);
	unsigned long stoul (const wstring& str, size_t* idx = 0, int base = 10);
	long long stoll (const wstring& str, size_t* idx = 0, int base = 10);
	unsigned long long stoull(const wstring& str, size_t* idx = 0, int base = 10);

	float stof (const wstring& str, size_t* idx = 0);
	double stod (const wstring& str, size_t* idx = 0);
	long double stold(const wstring& str, size_t* idx = 0);

	wstring to_wstring(int val);
	wstring to_wstring(unsigned val);
	wstring to_wstring(long val);
	wstring to_wstring(unsigned long val);
	wstring to_wstring(long long val);
	wstring to_wstring(unsigned long long val);
	wstring to_wstring(float val);
	wstring to_wstring(double val);
	wstring to_wstring(long double val);

	template <> struct hash<string>;
	template <> struct hash<u16string>;
	template <> struct hash<u32string>;
	template <> struct hash<wstring>;

	basic_string<char> operator "" s( const char *str, size_t len ); // C++14
	basic_string<wchar_t> operator "" s( const wchar_t *str, size_t len ); // C++14
	basic_string<char16_t> operator "" s( const char16_t *str, size_t len ); // C++14
	basic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++14

	} // std

	*/

	#include <__config>
	#include <string_view>
	#include <iosfwd>
	#include <cstring>
	#include <cstdio> // For EOF.
	#include <cwchar>
	#include <algorithm>
	#include <iterator>
	#include <utility>
	#include <memory>
	#include <stdexcept>
	#include <type_traits>
	#include <initializer_list>
	#include <__functional_base>
	#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
	#include <cstdint>
	#endif

	#include <__debug>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_STD

	// fpos

	template <class _StateT>
	class _LIBCPP_TEMPLATE_VIS fpos
	{
	private:
	_StateT __st_;
	streamoff __off_;
	public:
	_LIBCPP_INLINE_VISIBILITY fpos(streamoff __off = streamoff()) : __st_(), __off_(__off) {}

	_LIBCPP_INLINE_VISIBILITY operator streamoff() const {return __off_;}

	_LIBCPP_INLINE_VISIBILITY _StateT state() const {return __st_;}
	_LIBCPP_INLINE_VISIBILITY void state(_StateT __st) {__st_ = __st;}

	_LIBCPP_INLINE_VISIBILITY fpos& operator+=(streamoff __off) {__off_ += __off; return *this;}
	_LIBCPP_INLINE_VISIBILITY fpos operator+ (streamoff __off) const {fpos __t(*this); __t += __off; return __t;}
	_LIBCPP_INLINE_VISIBILITY fpos& operator-=(streamoff __off) {__off_ -= __off; return *this;}
	_LIBCPP_INLINE_VISIBILITY fpos operator- (streamoff __off) const {fpos __t(*this); __t -= __off; return __t;}
	};

	template <class _StateT>
	inline _LIBCPP_INLINE_VISIBILITY
	streamoff operator-(const fpos<_StateT>& __x, const fpos<_StateT>& __y)
	{return streamoff(__x) - streamoff(__y);}

	template <class _StateT>
	inline _LIBCPP_INLINE_VISIBILITY
	bool operator==(const fpos<_StateT>& __x, const fpos<_StateT>& __y)
	{return streamoff(__x) == streamoff(__y);}

	template <class _StateT>
	inline _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const fpos<_StateT>& __x, const fpos<_StateT>& __y)
	{return streamoff(__x) != streamoff(__y);}

	// basic_string

	template<class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>
	operator+(const basic_string<_CharT, _Traits, _Allocator>& __x,
	const basic_string<_CharT, _Traits, _Allocator>& __y);

	template<class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>
	operator+(const _CharT* __x, const basic_string<_CharT,_Traits,_Allocator>& __y);

	template<class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>
	operator+(_CharT __x, const basic_string<_CharT,_Traits,_Allocator>& __y);

	template<class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>
	operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, const _CharT* __y);

	template<class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>
	operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y);

	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS string operator+<char, char_traits<char>, allocator<char> >(char const*, string const&))

	template <bool>
	class _LIBCPP_TEMPLATE_VIS __basic_string_common
	{
	protected:
	_LIBCPP_NORETURN void __throw_length_error() const;
	_LIBCPP_NORETURN void __throw_out_of_range() const;
	};

	template <bool __b>
	void
	__basic_string_common<__b>::__throw_length_error() const
	{
	_VSTD::__throw_length_error("basic_string");
	}

	template <bool __b>
	void
	__basic_string_common<__b>::__throw_out_of_range() const
	{
	_VSTD::__throw_out_of_range("basic_string");
	}

	_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __basic_string_common<true>)

	#ifdef _LIBCPP_NO_EXCEPTIONS
	template <class _Iter>
	struct __libcpp_string_gets_noexcept_iterator_impl : public true_type {};
	#elif defined(_LIBCPP_HAS_NO_NOEXCEPT)
	template <class _Iter>
	struct __libcpp_string_gets_noexcept_iterator_impl : public false_type {};
	#else
	template <class _Iter, bool = __is_forward_iterator<_Iter>::value>
	struct __libcpp_string_gets_noexcept_iterator_impl : public _LIBCPP_BOOL_CONSTANT((
	noexcept(++(declval<_Iter&>())) &&
	is_nothrow_assignable<_Iter&, _Iter>::value &&
	noexcept(declval<_Iter>() == declval<_Iter>()) &&
	noexcept(*declval<_Iter>())
	)) {};

	template <class _Iter>
	struct __libcpp_string_gets_noexcept_iterator_impl<_Iter, false> : public false_type {};
	#endif


	template <class _Iter>
	struct __libcpp_string_gets_noexcept_iterator
	: public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value \|\| __libcpp_string_gets_noexcept_iterator_impl<_Iter>::value) {};

	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&, const _CharT*>::value)) {};

	#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT

	template <class _CharT, size_t = sizeof(_CharT)>
	struct __padding
	{
	unsigned char __xx[sizeof(_CharT)-1];
	};

	template <class _CharT>
	struct __padding<_CharT, 1>
	{
	};

	#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT

	template<class _CharT, class _Traits, class _Allocator>
	class _LIBCPP_TEMPLATE_VIS basic_string
	: private __basic_string_common<true>
	{
	public:
	typedef basic_string __self;
	typedef basic_string_view<_CharT, _Traits> __self_view;
	typedef _Traits traits_type;
	typedef _CharT value_type;
	typedef _Allocator allocator_type;
	typedef allocator_traits<allocator_type> __alloc_traits;
	typedef typename __alloc_traits::size_type size_type;
	typedef typename __alloc_traits::difference_type difference_type;
	typedef value_type& reference;
	typedef const value_type& const_reference;
	typedef typename __alloc_traits::pointer pointer;
	typedef typename __alloc_traits::const_pointer const_pointer;

	- static_assert(is_pod<value_type>::value, "Character type of basic_string must be a POD");
	- static_assert((is_same<_CharT, typename traits_type::char_type>::value),
	+ static_assert((!is_array<value_type>::value), "Character type of basic_string must not be an array");
	+ static_assert(( is_standard_layout<value_type>::value), "Character type of basic_string must be standard-layout");
	+ static_assert(( is_trivial<value_type>::value), "Character type of basic_string must be trivial");
	+ static_assert(( is_same<_CharT, typename traits_type::char_type>::value),
	"traits_type::char_type must be the same type as CharT");
	- static_assert((is_same<typename allocator_type::value_type, value_type>::value),
	+ static_assert(( is_same<typename allocator_type::value_type, value_type>::value),
	"Allocator::value_type must be same type as value_type");
	+
	#if defined(_LIBCPP_RAW_ITERATORS)
	typedef pointer iterator;
	typedef const_pointer const_iterator;
	#else // defined(_LIBCPP_RAW_ITERATORS)
	typedef __wrap_iter<pointer> iterator;
	typedef __wrap_iter<const_pointer> const_iterator;
	#endif // defined(_LIBCPP_RAW_ITERATORS)
	typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
	typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;

	private:

	#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT

	struct __long
	{
	pointer __data_;
	size_type __size_;
	size_type __cap_;
	};

	#ifdef _LIBCPP_BIG_ENDIAN
	static const size_type __short_mask = 0x01;
	static const size_type __long_mask = 0x1ul;
	#else // _LIBCPP_BIG_ENDIAN
	static const size_type __short_mask = 0x80;
	static const size_type __long_mask = ~(size_type(~0) >> 1);
	#endif // _LIBCPP_BIG_ENDIAN

	enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
	(sizeof(__long) - 1)/sizeof(value_type) : 2};

	struct __short
	{
	value_type __data_[__min_cap];
	struct
	: __padding<value_type>
	{
	unsigned char __size_;
	};
	};

	#else

	struct __long
	{
	size_type __cap_;
	size_type __size_;
	pointer __data_;
	};

	#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
	static const size_type __short_mask = 0x01;
	static const size_type __long_mask = 0x1ul;
	#endif // _LIBCPP_BIG_ENDIAN

	enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
	(sizeof(__long) - 1)/sizeof(value_type) : 2};

	struct __short
	{
	union
	{
	unsigned char __size_;
	value_type __lx;
	};
	value_type __data_[__min_cap];
	};

	#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT

	union __ulx{__long __lx; __short __lxx;};

	enum {__n_words = sizeof(__ulx) / sizeof(size_type)};

	struct __raw
	{
	size_type __words[__n_words];
	};

	struct __rep
	{
	union
	{
	__long __l;
	__short __s;
	__raw __r;
	};
	};

	__compressed_pair<__rep, allocator_type> __r_;

	public:
	static const size_type npos = -1;

	_LIBCPP_INLINE_VISIBILITY basic_string()
	_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);

	_LIBCPP_INLINE_VISIBILITY explicit basic_string(const allocator_type& __a)
	#if _LIBCPP_STD_VER <= 14
	_NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value);
	#else
	_NOEXCEPT;
	#endif

	basic_string(const basic_string& __str);
	basic_string(const basic_string& __str, const allocator_type& __a);

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	basic_string(basic_string&& __str)
	#if _LIBCPP_STD_VER <= 14
	_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
	#else
	_NOEXCEPT;
	#endif

	_LIBCPP_INLINE_VISIBILITY
	basic_string(basic_string&& __str, const allocator_type& __a);
	#endif // _LIBCPP_CXX03_LANG
	- _LIBCPP_INLINE_VISIBILITY basic_string(const _CharT* __s);
	+
	+ template <class = typename enable_if<__is_allocator<_Allocator>::value, nullptr_t>::type>
	_LIBCPP_INLINE_VISIBILITY
	- basic_string(const _CharT* __s, const _Allocator& __a);
	+ basic_string(const _CharT* __s) {
	+ _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr");
	+ __init(__s, traits_type::length(__s));
	+# if _LIBCPP_DEBUG_LEVEL >= 2
	+ __get_db()->__insert_c(this);
	+# endif
	+ }
	+
	+ template <class = typename enable_if<__is_allocator<_Allocator>::value, nullptr_t>::type>
	+ _LIBCPP_INLINE_VISIBILITY
	+ basic_string(const _CharT* __s, const _Allocator& __a);
	+
	_LIBCPP_INLINE_VISIBILITY
	basic_string(const _CharT* __s, size_type __n);
	_LIBCPP_INLINE_VISIBILITY
	basic_string(const _CharT* __s, size_type __n, const _Allocator& __a);
	_LIBCPP_INLINE_VISIBILITY
	basic_string(size_type __n, _CharT __c);
	- _LIBCPP_INLINE_VISIBILITY
	- basic_string(size_type __n, _CharT __c, const _Allocator& __a);
	+
	+ template <class = typename enable_if<__is_allocator<_Allocator>::value, nullptr_t>::type>
	+ _LIBCPP_INLINE_VISIBILITY
	+ basic_string(size_type __n, _CharT __c, const _Allocator& __a);
	+
	basic_string(const basic_string& __str, size_type __pos, size_type __n,
	const _Allocator& __a = _Allocator());
	_LIBCPP_INLINE_VISIBILITY
	basic_string(const basic_string& __str, size_type __pos,
	const _Allocator& __a = _Allocator());
	- template<class _Tp>
	+
	+ template<class _Tp, class = typename enable_if<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, void>::type>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	basic_string(const _Tp& __t, size_type __pos, size_type __n,
	- const allocator_type& __a = allocator_type(),
	- typename enable_if<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, void>::type* = 0);
	- _LIBCPP_INLINE_VISIBILITY explicit
	- basic_string(__self_view __sv);
	- _LIBCPP_INLINE_VISIBILITY
	- basic_string(__self_view __sv, const _Allocator& __a);
	+ const allocator_type& __a = allocator_type());
	+
	+ template<class _Tp, class = typename enable_if<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, void>::type>
	+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+ explicit basic_string(const _Tp& __t);
	+
	+ template<class _Tp, class = typename enable_if<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, void>::type>
	+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+ explicit basic_string(const _Tp& __t, const allocator_type& __a);
	+
	template<class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	basic_string(_InputIterator __first, _InputIterator __last);
	template<class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	basic_string(initializer_list<_CharT> __il);
	_LIBCPP_INLINE_VISIBILITY
	basic_string(initializer_list<_CharT> __il, const _Allocator& __a);
	#endif // _LIBCPP_CXX03_LANG

	inline ~basic_string();

	_LIBCPP_INLINE_VISIBILITY
	operator __self_view() const _NOEXCEPT { return __self_view(data(), size()); }

	basic_string& operator=(const basic_string& __str);

	+ template <class _Tp, class = typename enable_if<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, void>::type>
	+ basic_string& operator=(const _Tp& __t)
	+ {__self_view __sv = __t; return assign(__sv);}
	+
	#ifndef _LIBCPP_CXX03_LANG
	- template <class = void>
	-#endif
	_LIBCPP_INLINE_VISIBILITY
	- basic_string& operator=(__self_view __sv) {return assign(__sv);}
	-#ifndef _LIBCPP_CXX03_LANG
	- _LIBCPP_INLINE_VISIBILITY
	basic_string& operator=(basic_string&& __str)
	_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
	_LIBCPP_INLINE_VISIBILITY
	basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
	#endif
	_LIBCPP_INLINE_VISIBILITY basic_string& operator=(const value_type* __s) {return assign(__s);}
	basic_string& operator=(value_type __c);

	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_INLINE_VISIBILITY
	iterator begin() _NOEXCEPT
	{return iterator(this, __get_pointer());}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator begin() const _NOEXCEPT
	{return const_iterator(this, __get_pointer());}
	_LIBCPP_INLINE_VISIBILITY
	iterator end() _NOEXCEPT
	{return iterator(this, __get_pointer() + size());}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator end() const _NOEXCEPT
	{return const_iterator(this, __get_pointer() + size());}
	#else
	_LIBCPP_INLINE_VISIBILITY
	iterator begin() _NOEXCEPT
	{return iterator(__get_pointer());}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator begin() const _NOEXCEPT
	{return const_iterator(__get_pointer());}
	_LIBCPP_INLINE_VISIBILITY
	iterator end() _NOEXCEPT
	{return iterator(__get_pointer() + size());}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator end() const _NOEXCEPT
	{return const_iterator(__get_pointer() + size());}
	#endif // _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_INLINE_VISIBILITY
	reverse_iterator rbegin() _NOEXCEPT
	{return reverse_iterator(end());}
	_LIBCPP_INLINE_VISIBILITY
	const_reverse_iterator rbegin() const _NOEXCEPT
	{return const_reverse_iterator(end());}
	_LIBCPP_INLINE_VISIBILITY
	reverse_iterator rend() _NOEXCEPT
	{return reverse_iterator(begin());}
	_LIBCPP_INLINE_VISIBILITY
	const_reverse_iterator rend() const _NOEXCEPT
	{return const_reverse_iterator(begin());}

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

	_LIBCPP_INLINE_VISIBILITY size_type size() const _NOEXCEPT
	{return __is_long() ? __get_long_size() : __get_short_size();}
	_LIBCPP_INLINE_VISIBILITY size_type length() const _NOEXCEPT {return size();}
	_LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY size_type capacity() const _NOEXCEPT
	{return (__is_long() ? __get_long_cap()
	: static_cast<size_type>(__min_cap)) - 1;}

	void resize(size_type __n, value_type __c);
	_LIBCPP_INLINE_VISIBILITY void resize(size_type __n) {resize(__n, value_type());}

	void reserve(size_type __res_arg = 0);
	_LIBCPP_INLINE_VISIBILITY
	void shrink_to_fit() _NOEXCEPT {reserve();}
	_LIBCPP_INLINE_VISIBILITY
	void clear() _NOEXCEPT;
	_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;

	const_reference at(size_type __n) const;
	reference at(size_type __n);

	_LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const basic_string& __str) {return append(__str);}
	- _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(__self_view __sv) {return append(__sv);}
	+
	+ template <class _Tp>
	+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+ typename enable_if
	+ <
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ basic_string&
	+ >::type
	+ operator+=(const _Tp& __t) {__self_view __sv = __t; return append(__sv);}
	_LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const value_type* __s) {return append(__s);}
	_LIBCPP_INLINE_VISIBILITY basic_string& operator+=(value_type __c) {push_back(__c); return *this;}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY basic_string& operator+=(initializer_list<value_type> __il) {return append(__il);}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	basic_string& append(const basic_string& __str);
	- _LIBCPP_INLINE_VISIBILITY
	- basic_string& append(__self_view __sv) { return append(__sv.data(), __sv.size()); }
	+
	+ template <class _Tp>
	+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+ typename enable_if
	+ <
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ basic_string&
	+ >::type
	+ append(const _Tp& __t) { __self_view __sv = __t; return append(__sv.data(), __sv.size()); }
	basic_string& append(const basic_string& __str, size_type __pos, size_type __n=npos);
	+
	template <class _Tp>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	typename enable_if
	<
	__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	basic_string&
	>::type
	append(const _Tp& __t, size_type __pos, size_type __n=npos);
	basic_string& append(const value_type* __s, size_type __n);
	basic_string& append(const value_type* __s);
	basic_string& append(size_type __n, value_type __c);
	template <class _ForwardIterator>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	basic_string& __append_forward_unsafe(_ForwardIterator, _ForwardIterator);
	template<class _InputIterator>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	typename enable_if
	<
	__is_exactly_input_iterator<_InputIterator>::value
	\|\| !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
	basic_string&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	append(_InputIterator __first, _InputIterator __last) {
	const basic_string __temp (__first, __last, __alloc());
	append(__temp.data(), __temp.size());
	return *this;
	}
	template<class _ForwardIterator>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value
	&& __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
	basic_string&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	append(_ForwardIterator __first, _ForwardIterator __last) {
	return __append_forward_unsafe(__first, __last);
	}

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());}
	#endif // _LIBCPP_CXX03_LANG

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

	+ template <class _Tp>
	+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+ typename enable_if
	+ <
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ basic_string&
	+ >::type
	+ assign(const _Tp & __t) { __self_view __sv = __t; return assign(__sv.data(), __sv.size()); }
	_LIBCPP_INLINE_VISIBILITY
	- basic_string& assign(__self_view __sv) { return assign(__sv.data(), __sv.size()); }
	- _LIBCPP_INLINE_VISIBILITY
	basic_string& assign(const basic_string& __str) { return *this = __str; }
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	basic_string& assign(basic_string&& __str)
	_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
	{this = _VSTD::move(__str); return this;}
	#endif
	basic_string& assign(const basic_string& __str, size_type __pos, size_type __n=npos);
	template <class _Tp>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	typename enable_if
	<
	__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	basic_string&
	>::type
	assign(const _Tp & __t, size_type __pos, size_type __n=npos);
	basic_string& assign(const value_type* __s, size_type __n);
	basic_string& assign(const value_type* __s);
	basic_string& assign(size_type __n, value_type __c);
	template<class _InputIterator>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	typename enable_if
	<
	__is_exactly_input_iterator<_InputIterator>::value
	\|\| !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
	basic_string&
	>::type
	assign(_InputIterator __first, _InputIterator __last);
	template<class _ForwardIterator>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value
	&& __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
	basic_string&
	>::type
	assign(_ForwardIterator __first, _ForwardIterator __last);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	basic_string& insert(size_type __pos1, const basic_string& __str);
	- _LIBCPP_INLINE_VISIBILITY
	- basic_string& insert(size_type __pos1, __self_view __sv) { return insert(__pos1, __sv.data(), __sv.size()); }
	+
	template <class _Tp>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	typename enable_if
	<
	__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	basic_string&
	>::type
	+ insert(size_type __pos1, const _Tp& __t)
	+ { __self_view __sv = __t; return insert(__pos1, __sv.data(), __sv.size()); }
	+
	+ template <class _Tp>
	+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+ typename enable_if
	+ <
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ basic_string&
	+ >::type
	insert(size_type __pos1, const _Tp& __t, size_type __pos2, size_type __n=npos);
	basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n=npos);
	basic_string& insert(size_type __pos, const value_type* __s, size_type __n);
	basic_string& insert(size_type __pos, const value_type* __s);
	basic_string& insert(size_type __pos, size_type __n, value_type __c);
	iterator insert(const_iterator __pos, value_type __c);
	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __pos, size_type __n, value_type __c);
	template<class _InputIterator>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	typename enable_if
	<
	__is_exactly_input_iterator<_InputIterator>::value
	\|\| !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
	iterator
	>::type
	insert(const_iterator __pos, _InputIterator __first, _InputIterator __last);
	template<class _ForwardIterator>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value
	&& __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
	iterator
	>::type
	insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __pos, initializer_list<value_type> __il)
	{return insert(__pos, __il.begin(), __il.end());}
	#endif // _LIBCPP_CXX03_LANG

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

	_LIBCPP_INLINE_VISIBILITY
	basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str);
	- _LIBCPP_INLINE_VISIBILITY
	- basic_string& replace(size_type __pos1, size_type __n1, __self_view __sv) { return replace(__pos1, __n1, __sv.data(), __sv.size()); }
	+
	+ template <class _Tp>
	+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+ typename enable_if
	+ <
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ basic_string&
	+ >::type
	+ replace(size_type __pos1, size_type __n1, const _Tp& __t) { __self_view __sv = __t; return replace(__pos1, __n1, __sv.data(), __sv.size()); }
	basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos);
	template <class _Tp>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	typename enable_if
	<
	__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	basic_string&
	>::type
	replace(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos);
	basic_string& replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2);
	basic_string& replace(size_type __pos, size_type __n1, const value_type* __s);
	basic_string& replace(size_type __pos, size_type __n1, size_type __n2, value_type __c);
	_LIBCPP_INLINE_VISIBILITY
	basic_string& replace(const_iterator __i1, const_iterator __i2, const basic_string& __str);
	+
	+ template <class _Tp>
	+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+ typename enable_if
	+ <
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ basic_string&
	+ >::type
	+ replace(const_iterator __i1, const_iterator __i2, const _Tp& __t) { __self_view __sv = __t; return replace(__i1 - begin(), __i2 - __i1, __sv); }
	+
	_LIBCPP_INLINE_VISIBILITY
	- basic_string& replace(const_iterator __i1, const_iterator __i2, __self_view __sv) { return replace(__i1 - begin(), __i2 - __i1, __sv); }
	- _LIBCPP_INLINE_VISIBILITY
	basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n);
	_LIBCPP_INLINE_VISIBILITY
	basic_string& replace(const_iterator __i1, const_iterator __i2, const value_type* __s);
	_LIBCPP_INLINE_VISIBILITY
	basic_string& replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c);
	template<class _InputIterator>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	typename enable_if
	<
	__is_input_iterator<_InputIterator>::value,
	basic_string&
	>::type
	replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il)
	{return replace(__i1, __i2, __il.begin(), __il.end());}
	#endif // _LIBCPP_CXX03_LANG

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

	_LIBCPP_INLINE_VISIBILITY
	void swap(basic_string& __str)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT_DEBUG;
	#else
	_NOEXCEPT_DEBUG_(!__alloc_traits::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<allocator_type>::value);
	#endif

	_LIBCPP_INLINE_VISIBILITY
	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 \|\| defined(_LIBCPP_BUILDING_LIBRARY)
	_LIBCPP_INLINE_VISIBILITY
	value_type* data() _NOEXCEPT {return _VSTD::__to_raw_pointer(__get_pointer());}
	#endif

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

	_LIBCPP_INLINE_VISIBILITY
	size_type find(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
	- _LIBCPP_INLINE_VISIBILITY
	- size_type find(__self_view __sv, size_type __pos = 0) const _NOEXCEPT;
	+
	+ template <class _Tp>
	+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+ typename enable_if
	+ <
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ size_type
	+ >::type
	+ find(const _Tp& __t, size_type __pos = 0) const;
	size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	size_type find(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
	size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY
	size_type rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
	- _LIBCPP_INLINE_VISIBILITY
	- size_type rfind(__self_view __sv, size_type __pos = npos) const _NOEXCEPT;
	+
	+ template <class _Tp>
	+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+ typename enable_if
	+ <
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ size_type
	+ >::type
	+ rfind(const _Tp& __t, size_type __pos = npos) const;
	size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	size_type rfind(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
	size_type rfind(value_type __c, size_type __pos = npos) const _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY
	size_type find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
	- _LIBCPP_INLINE_VISIBILITY
	- size_type find_first_of(__self_view __sv, size_type __pos = 0) const _NOEXCEPT;
	+
	+ template <class _Tp>
	+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+ typename enable_if
	+ <
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ size_type
	+ >::type
	+ find_first_of(const _Tp& __t, size_type __pos = 0) const;
	size_type find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	size_type find_first_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	size_type find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY
	size_type find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
	- _LIBCPP_INLINE_VISIBILITY
	- size_type find_last_of(__self_view __sv, size_type __pos = npos) const _NOEXCEPT;
	+
	+ template <class _Tp>
	+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+ typename enable_if
	+ <
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ size_type
	+ >::type
	+ find_last_of(const _Tp& __t, size_type __pos = npos) const;
	size_type find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	size_type find_last_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	size_type find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY
	size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
	- _LIBCPP_INLINE_VISIBILITY
	- size_type find_first_not_of(__self_view __sv, size_type __pos = 0) const _NOEXCEPT;
	+
	+ template <class _Tp>
	+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+ typename enable_if
	+ <
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ size_type
	+ >::type
	+ find_first_not_of(const _Tp &__t, size_type __pos = 0) const;
	size_type find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	size_type find_first_not_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	size_type find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY
	size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
	- _LIBCPP_INLINE_VISIBILITY
	- size_type find_last_not_of(__self_view __sv, size_type __pos = npos) const _NOEXCEPT;
	+
	+ template <class _Tp>
	+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+ typename enable_if
	+ <
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ size_type
	+ >::type
	+ find_last_not_of(const _Tp& __t, size_type __pos = npos) const;
	size_type find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	size_type find_last_not_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	size_type find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY
	int compare(const basic_string& __str) const _NOEXCEPT;
	+
	+ template <class _Tp>
	+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+ typename enable_if
	+ <
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ int
	+ >::type
	+ compare(const _Tp &__t) const;
	+
	+ template <class _Tp>
	+ _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	+ typename enable_if
	+ <
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ int
	+ >::type
	+ compare(size_type __pos1, size_type __n1, const _Tp& __t) const;
	+
	_LIBCPP_INLINE_VISIBILITY
	- int compare(__self_view __sv) const _NOEXCEPT;
	- _LIBCPP_INLINE_VISIBILITY
	- int compare(size_type __pos1, size_type __n1, __self_view __sv) const;
	- _LIBCPP_INLINE_VISIBILITY
	int compare(size_type __pos1, size_type __n1, const basic_string& __str) const;
	int compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2=npos) const;
	+
	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	int
	>::type
	compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos) const;
	int compare(const value_type* __s) const _NOEXCEPT;
	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 void __clear_and_shrink() _NOEXCEPT;
	+
	_LIBCPP_INLINE_VISIBILITY
	bool __is_long() const _NOEXCEPT
	{return bool(__r_.first().__s.__size_ & __short_mask);}

	#if _LIBCPP_DEBUG_LEVEL >= 2

	bool __dereferenceable(const const_iterator* __i) const;
	bool __decrementable(const const_iterator* __i) const;
	bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
	bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;

	#endif // _LIBCPP_DEBUG_LEVEL >= 2

	private:
	_LIBCPP_INLINE_VISIBILITY
	allocator_type& __alloc() _NOEXCEPT
	{return __r_.second();}
	_LIBCPP_INLINE_VISIBILITY
	const allocator_type& __alloc() const _NOEXCEPT
	{return __r_.second();}

	#ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT

	_LIBCPP_INLINE_VISIBILITY
	void __set_short_size(size_type __s) _NOEXCEPT
	# ifdef _LIBCPP_BIG_ENDIAN
	{__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
	# else
	{__r_.first().__s.__size_ = (unsigned char)(__s);}
	# endif

	_LIBCPP_INLINE_VISIBILITY
	size_type __get_short_size() const _NOEXCEPT
	# ifdef _LIBCPP_BIG_ENDIAN
	{return __r_.first().__s.__size_ >> 1;}
	# else
	{return __r_.first().__s.__size_;}
	# endif

	#else // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT

	_LIBCPP_INLINE_VISIBILITY
	void __set_short_size(size_type __s) _NOEXCEPT
	# ifdef _LIBCPP_BIG_ENDIAN
	{__r_.first().__s.__size_ = (unsigned char)(__s);}
	# else
	{__r_.first().__s.__size_ = (unsigned char)(__s << 1);}
	# endif

	_LIBCPP_INLINE_VISIBILITY
	size_type __get_short_size() const _NOEXCEPT
	# ifdef _LIBCPP_BIG_ENDIAN
	{return __r_.first().__s.__size_;}
	# else
	{return __r_.first().__s.__size_ >> 1;}
	# endif

	#endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT

	_LIBCPP_INLINE_VISIBILITY
	void __set_long_size(size_type __s) _NOEXCEPT
	{__r_.first().__l.__size_ = __s;}
	_LIBCPP_INLINE_VISIBILITY
	size_type __get_long_size() const _NOEXCEPT
	{return __r_.first().__l.__size_;}
	_LIBCPP_INLINE_VISIBILITY
	void __set_size(size_type __s) _NOEXCEPT
	{if (__is_long()) __set_long_size(__s); else __set_short_size(__s);}

	_LIBCPP_INLINE_VISIBILITY
	void __set_long_cap(size_type __s) _NOEXCEPT
	{__r_.first().__l.__cap_ = __long_mask \| __s;}
	_LIBCPP_INLINE_VISIBILITY
	size_type __get_long_cap() const _NOEXCEPT
	{return __r_.first().__l.__cap_ & size_type(~__long_mask);}

	_LIBCPP_INLINE_VISIBILITY
	void __set_long_pointer(pointer __p) _NOEXCEPT
	{__r_.first().__l.__data_ = __p;}
	_LIBCPP_INLINE_VISIBILITY
	pointer __get_long_pointer() _NOEXCEPT
	{return __r_.first().__l.__data_;}
	_LIBCPP_INLINE_VISIBILITY
	const_pointer __get_long_pointer() const _NOEXCEPT
	{return __r_.first().__l.__data_;}
	_LIBCPP_INLINE_VISIBILITY
	pointer __get_short_pointer() _NOEXCEPT
	{return pointer_traits<pointer>::pointer_to(__r_.first().__s.__data_[0]);}
	_LIBCPP_INLINE_VISIBILITY
	const_pointer __get_short_pointer() const _NOEXCEPT
	{return pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__data_[0]);}
	_LIBCPP_INLINE_VISIBILITY
	pointer __get_pointer() _NOEXCEPT
	{return __is_long() ? __get_long_pointer() : __get_short_pointer();}
	_LIBCPP_INLINE_VISIBILITY
	const_pointer __get_pointer() const _NOEXCEPT
	{return __is_long() ? __get_long_pointer() : __get_short_pointer();}

	_LIBCPP_INLINE_VISIBILITY
	void __zero() _NOEXCEPT
	{
	size_type (&__a)[__n_words] = __r_.first().__r.__words;
	for (unsigned __i = 0; __i < __n_words; ++__i)
	__a[__i] = 0;
	}

	template <size_type __a> static
	_LIBCPP_INLINE_VISIBILITY
	size_type __align_it(size_type __s) _NOEXCEPT
	{return (__s + (__a-1)) & ~(__a-1);}
	enum {__alignment = 16};
	static _LIBCPP_INLINE_VISIBILITY
	size_type __recommend(size_type __s) _NOEXCEPT
	- {return (__s < __min_cap ? static_cast<size_type>(__min_cap) :
	- __align_it<sizeof(value_type) < __alignment ?
	- __alignment/sizeof(value_type) : 1 > (__s+1)) - 1;}
	+ {
	+ if (__s < __min_cap) return static_cast<size_type>(__min_cap) - 1;
	+ size_type __guess = __align_it<sizeof(value_type) < __alignment ?
	+ __alignment/sizeof(value_type) : 1 > (__s+1) - 1;
	+ if (__guess == __min_cap) ++__guess;
	+ return __guess;
	+ }

	inline
	void __init(const value_type* __s, size_type __sz, size_type __reserve);
	inline
	void __init(const value_type* __s, size_type __sz);
	inline
	void __init(size_type __n, value_type __c);

	template <class _InputIterator>
	inline
	typename enable_if
	<
	__is_exactly_input_iterator<_InputIterator>::value,
	void
	>::type
	__init(_InputIterator __first, _InputIterator __last);

	template <class _ForwardIterator>
	inline
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value,
	void
	>::type
	__init(_ForwardIterator __first, _ForwardIterator __last);

	void __grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
	size_type __n_copy, size_type __n_del, size_type __n_add = 0);
	void __grow_by_and_replace(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
	size_type __n_copy, size_type __n_del,
	size_type __n_add, const value_type* __p_new_stuff);

	_LIBCPP_INLINE_VISIBILITY
	void __erase_to_end(size_type __pos);

	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const basic_string& __str)
	{__copy_assign_alloc(__str, integral_constant<bool,
	__alloc_traits::propagate_on_container_copy_assignment::value>());}

	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const basic_string& __str, true_type)
	{
	if (__alloc() == __str.__alloc())
	__alloc() = __str.__alloc();
	else
	{
	if (!__str.__is_long())
	{
	- clear();
	- shrink_to_fit();
	+ __clear_and_shrink();
	__alloc() = __str.__alloc();
	}
	else
	{
	allocator_type __a = __str.__alloc();
	pointer __p = __alloc_traits::allocate(__a, __str.__get_long_cap());
	- clear();
	- shrink_to_fit();
	+ __clear_and_shrink();
	__alloc() = _VSTD::move(__a);
	__set_long_pointer(__p);
	__set_long_cap(__str.__get_long_cap());
	__set_long_size(__str.size());
	}
	}
	}

	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const basic_string&, false_type) _NOEXCEPT
	{}

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	void __move_assign(basic_string& __str, false_type)
	_NOEXCEPT_(__alloc_traits::is_always_equal::value);
	_LIBCPP_INLINE_VISIBILITY
	void __move_assign(basic_string& __str, true_type)
	#if _LIBCPP_STD_VER > 14
	_NOEXCEPT;
	#else
	_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
	#endif
	#endif

	_LIBCPP_INLINE_VISIBILITY
	void
	__move_assign_alloc(basic_string& __str)
	_NOEXCEPT_(
	!__alloc_traits::propagate_on_container_move_assignment::value \|\|
	is_nothrow_move_assignable<allocator_type>::value)
	{__move_assign_alloc(__str, integral_constant<bool,
	__alloc_traits::propagate_on_container_move_assignment::value>());}

	_LIBCPP_INLINE_VISIBILITY
	void __move_assign_alloc(basic_string& __c, true_type)
	_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
	{
	__alloc() = _VSTD::move(__c.__alloc());
	}

	_LIBCPP_INLINE_VISIBILITY
	void __move_assign_alloc(basic_string&, false_type)
	_NOEXCEPT
	{}

	_LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
	_LIBCPP_INLINE_VISIBILITY void __invalidate_iterators_past(size_type);

	friend basic_string operator+<>(const basic_string&, const basic_string&);
	friend basic_string operator+<>(const value_type*, const basic_string&);
	friend basic_string operator+<>(value_type, const basic_string&);
	friend basic_string operator+<>(const basic_string&, const value_type*);
	friend basic_string operator+<>(const basic_string&, value_type);
	};

	+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
	+template<class _InputIterator,
	+ class _CharT = typename iterator_traits<_InputIterator>::value_type,
	+ class _Allocator = allocator<_CharT>,
	+ class = typename enable_if<__is_input_iterator<_InputIterator>::value, void>::type,
	+ class = typename enable_if<__is_allocator<_Allocator>::value, void>::type
	+ >
	+basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
	+ -> basic_string<_CharT, char_traits<_CharT>, _Allocator>;
	+
	+template<class _CharT,
	+ class _Traits,
	+ class _Allocator = allocator<_CharT>,
	+ class = typename enable_if<__is_allocator<_Allocator>::value, void>::type
	+ >
	+explicit basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())
	+ -> basic_string<_CharT, _Traits, _Allocator>;
	+
	+template<class _CharT,
	+ class _Traits,
	+ class _Allocator = allocator<_CharT>,
	+ class = typename enable_if<__is_allocator<_Allocator>::value, void>::type,
	+ class _Sz = typename allocator_traits<_Allocator>::size_type
	+ >
	+basic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _Allocator())
	+ -> basic_string<_CharT, _Traits, _Allocator>;
	+#endif
	+
	+
	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	basic_string<_CharT, _Traits, _Allocator>::__invalidate_all_iterators()
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__invalidate_all(this);
	#endif // _LIBCPP_DEBUG_LEVEL >= 2
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__pos
	#endif
	)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__c_node* __c = __get_db()->__find_c_and_lock(this);
	if (__c)
	{
	const_pointer __new_last = __get_pointer() + __pos;
	for (__i_node** __p = __c->end_; __p != __c->beg_; )
	{
	--__p;
	const_iterator* __i = static_cast<const_iterator>((__p)->__i_);
	if (__i->base() > __new_last)
	{
	(*__p)->__c_ = nullptr;
	if (--__c->end_ != __p)
	memmove(__p, __p+1, (__c->end_ - __p)sizeof(__i_node));
	}
	}
	__get_db()->unlock();
	}
	#endif // _LIBCPP_DEBUG_LEVEL >= 2
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>::basic_string()
	_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__zero();
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>::basic_string(const allocator_type& __a)
	#if _LIBCPP_STD_VER <= 14
	_NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
	#else
	_NOEXCEPT
	#endif
	: __r_(__second_tag(), __a)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__zero();
	}

	template <class _CharT, class _Traits, class _Allocator>
	void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s,
	size_type __sz,
	size_type __reserve)
	{
	if (__reserve > max_size())
	this->__throw_length_error();
	pointer __p;
	if (__reserve < __min_cap)
	{
	__set_short_size(__sz);
	__p = __get_short_pointer();
	}
	else
	{
	size_type __cap = __recommend(__reserve);
	__p = __alloc_traits::allocate(__alloc(), __cap+1);
	__set_long_pointer(__p);
	__set_long_cap(__cap+1);
	__set_long_size(__sz);
	}
	traits_type::copy(_VSTD::__to_raw_pointer(__p), __s, __sz);
	traits_type::assign(__p[__sz], value_type());
	}

	template <class _CharT, class _Traits, class _Allocator>
	void
	basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz)
	{
	if (__sz > max_size())
	this->__throw_length_error();
	pointer __p;
	if (__sz < __min_cap)
	{
	__set_short_size(__sz);
	__p = __get_short_pointer();
	}
	else
	{
	size_type __cap = __recommend(__sz);
	__p = __alloc_traits::allocate(__alloc(), __cap+1);
	__set_long_pointer(__p);
	__set_long_cap(__cap+1);
	__set_long_size(__sz);
	}
	traits_type::copy(_VSTD::__to_raw_pointer(__p), __s, __sz);
	traits_type::assign(__p[__sz], value_type());
	}

	template <class _CharT, class _Traits, class _Allocator>
	-inline _LIBCPP_INLINE_VISIBILITY
	-basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s)
	-{
	- _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr");
	- __init(__s, traits_type::length(__s));
	-#if _LIBCPP_DEBUG_LEVEL >= 2
	- __get_db()->__insert_c(this);
	-#endif
	-}
	-
	-template <class _CharT, class _Traits, class _Allocator>
	-inline _LIBCPP_INLINE_VISIBILITY
	+template <class>
	basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, const _Allocator& __a)
	: __r_(__second_tag(), __a)
	{
	_LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr");
	__init(__s, traits_type::length(__s));
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n)
	{
	_LIBCPP_ASSERT(__n == 0 \|\| __s != nullptr, "basic_string(const char*, n) detected nullptr");
	__init(__s, __n);
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>::basic_string(const _CharT* __s, size_type __n, const _Allocator& __a)
	: __r_(__second_tag(), __a)
	{
	_LIBCPP_ASSERT(__n == 0 \|\| __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
	__init(__s, __n);
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str)
	: __r_(__second_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc()))
	{
	if (!__str.__is_long())
	__r_.first().__r = __str.__r_.first().__r;
	else
	__init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>::basic_string(
	const basic_string& __str, const allocator_type& __a)
	: __r_(__second_tag(), __a)
	{
	if (!__str.__is_long())
	__r_.first().__r = __str.__r_.first().__r;
	else
	__init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str)
	#if _LIBCPP_STD_VER <= 14
	_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
	#else
	_NOEXCEPT
	#endif
	: __r_(_VSTD::move(__str.__r_))
	{
	__str.__zero();
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	if (__is_long())
	__get_db()->swap(this, &__str);
	#endif
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a)
	: __r_(__second_tag(), __a)
	{
	if (__str.__is_long() && __a != __str.__alloc()) // copy, not move
	__init(_VSTD::__to_raw_pointer(__str.__get_long_pointer()), __str.__get_long_size());
	else
	{
	__r_.first().__r = __str.__r_.first().__r;
	__str.__zero();
	}
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	if (__is_long())
	__get_db()->swap(this, &__str);
	#endif
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits, class _Allocator>
	void
	basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c)
	{
	if (__n > max_size())
	this->__throw_length_error();
	pointer __p;
	if (__n < __min_cap)
	{
	__set_short_size(__n);
	__p = __get_short_pointer();
	}
	else
	{
	size_type __cap = __recommend(__n);
	__p = __alloc_traits::allocate(__alloc(), __cap+1);
	__set_long_pointer(__p);
	__set_long_cap(__cap+1);
	__set_long_size(__n);
	}
	traits_type::assign(_VSTD::__to_raw_pointer(__p), __n, __c);
	traits_type::assign(__p[__n], value_type());
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c)
	{
	__init(__n, __c);
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	template <class _CharT, class _Traits, class _Allocator>
	-inline _LIBCPP_INLINE_VISIBILITY
	+template <class>
	basic_string<_CharT, _Traits, _Allocator>::basic_string(size_type __n, _CharT __c, const _Allocator& __a)
	: __r_(__second_tag(), __a)
	{
	__init(__n, __c);
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str,
	size_type __pos, size_type __n,
	const _Allocator& __a)
	: __r_(__second_tag(), __a)
	{
	size_type __str_sz = __str.size();
	if (__pos > __str_sz)
	this->__throw_out_of_range();
	__init(__str.data() + __pos, _VSTD::min(__n, __str_sz - __pos));
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str, size_type __pos,
	const _Allocator& __a)
	: __r_(__second_tag(), __a)
	{
	size_type __str_sz = __str.size();
	if (__pos > __str_sz)
	this->__throw_out_of_range();
	__init(__str.data() + __pos, __str_sz - __pos);
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	template <class _CharT, class _Traits, class _Allocator>
	-template <class _Tp>
	+template <class _Tp, class>
	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 *)
	+ const _Tp& __t, size_type __pos, size_type __n, const allocator_type& __a)
	: __r_(__second_tag(), __a)
	{
	- __self_view __sv = __self_view(__t).substr(__pos, __n);
	+ __self_view __sv0 = __t;
	+ __self_view __sv = __sv0.substr(__pos, __n);
	__init(__sv.data(), __sv.size());
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	template <class _CharT, class _Traits, class _Allocator>
	-inline _LIBCPP_INLINE_VISIBILITY
	-basic_string<_CharT, _Traits, _Allocator>::basic_string(__self_view __sv)
	+template <class _Tp, class>
	+basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t)
	{
	+ __self_view __sv = __t;
	__init(__sv.data(), __sv.size());
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	template <class _CharT, class _Traits, class _Allocator>
	-inline _LIBCPP_INLINE_VISIBILITY
	-basic_string<_CharT, _Traits, _Allocator>::basic_string(__self_view __sv, const _Allocator& __a)
	+template <class _Tp, class>
	+basic_string<_CharT, _Traits, _Allocator>::basic_string(const _Tp & __t, const _Allocator& __a)
	: __r_(__second_tag(), __a)
	{
	+ __self_view __sv = __t;
	__init(__sv.data(), __sv.size());
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	template <class _CharT, class _Traits, class _Allocator>
	template <class _InputIterator>
	typename enable_if
	<
	__is_exactly_input_iterator<_InputIterator>::value,
	void
	>::type
	basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last)
	{
	__zero();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (; __first != __last; ++__first)
	push_back(*__first);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	if (__is_long())
	__alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	template <class _CharT, class _Traits, class _Allocator>
	template <class _ForwardIterator>
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value,
	void
	>::type
	basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
	{
	size_type __sz = static_cast<size_type>(_VSTD::distance(__first, __last));
	if (__sz > max_size())
	this->__throw_length_error();
	pointer __p;
	if (__sz < __min_cap)
	{
	__set_short_size(__sz);
	__p = __get_short_pointer();
	}
	else
	{
	size_type __cap = __recommend(__sz);
	__p = __alloc_traits::allocate(__alloc(), __cap+1);
	__set_long_pointer(__p);
	__set_long_cap(__cap+1);
	__set_long_size(__sz);
	}
	for (; __first != __last; ++__first, (void) ++__p)
	traits_type::assign(__p, __first);
	traits_type::assign(*__p, value_type());
	}

	template <class _CharT, class _Traits, class _Allocator>
	template<class _InputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last)
	{
	__init(__first, __last);
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	template <class _CharT, class _Traits, class _Allocator>
	template<class _InputIterator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first, _InputIterator __last,
	const allocator_type& __a)
	: __r_(__second_tag(), __a)
	{
	__init(__first, __last);
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>::basic_string(
	initializer_list<_CharT> __il)
	{
	__init(__il.begin(), __il.end());
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY

	basic_string<_CharT, _Traits, _Allocator>::basic_string(
	initializer_list<_CharT> __il, const _Allocator& __a)
	: __r_(__second_tag(), __a)
	{
	__init(__il.begin(), __il.end());
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>::~basic_string()
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__erase_c(this);
	#endif
	if (__is_long())
	__alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
	}

	template <class _CharT, class _Traits, class _Allocator>
	void
	basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace
	(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
	size_type __n_copy, size_type __n_del, size_type __n_add, const value_type* __p_new_stuff)
	{
	size_type __ms = max_size();
	if (__delta_cap > __ms - __old_cap - 1)
	this->__throw_length_error();
	pointer __old_p = __get_pointer();
	size_type __cap = __old_cap < __ms / 2 - __alignment ?
	__recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
	__ms - 1;
	pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
	__invalidate_all_iterators();
	if (__n_copy != 0)
	traits_type::copy(_VSTD::__to_raw_pointer(__p),
	_VSTD::__to_raw_pointer(__old_p), __n_copy);
	if (__n_add != 0)
	traits_type::copy(_VSTD::__to_raw_pointer(__p) + __n_copy, __p_new_stuff, __n_add);
	size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
	if (__sec_cp_sz != 0)
	traits_type::copy(_VSTD::__to_raw_pointer(__p) + __n_copy + __n_add,
	_VSTD::__to_raw_pointer(__old_p) + __n_copy + __n_del, __sec_cp_sz);
	if (__old_cap+1 != __min_cap)
	__alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
	__set_long_pointer(__p);
	__set_long_cap(__cap+1);
	__old_sz = __n_copy + __n_add + __sec_cp_sz;
	__set_long_size(__old_sz);
	traits_type::assign(__p[__old_sz], value_type());
	}

	template <class _CharT, class _Traits, class _Allocator>
	void
	basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
	size_type __n_copy, size_type __n_del, size_type __n_add)
	{
	size_type __ms = max_size();
	if (__delta_cap > __ms - __old_cap)
	this->__throw_length_error();
	pointer __old_p = __get_pointer();
	size_type __cap = __old_cap < __ms / 2 - __alignment ?
	__recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
	__ms - 1;
	pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
	__invalidate_all_iterators();
	if (__n_copy != 0)
	traits_type::copy(_VSTD::__to_raw_pointer(__p),
	_VSTD::__to_raw_pointer(__old_p), __n_copy);
	size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
	if (__sec_cp_sz != 0)
	traits_type::copy(_VSTD::__to_raw_pointer(__p) + __n_copy + __n_add,
	_VSTD::__to_raw_pointer(__old_p) + __n_copy + __n_del,
	__sec_cp_sz);
	if (__old_cap+1 != __min_cap)
	__alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
	__set_long_pointer(__p);
	__set_long_cap(__cap+1);
	}

	// assign

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n)
	{
	_LIBCPP_ASSERT(__n == 0 \|\| __s != nullptr, "string::assign received nullptr");
	size_type __cap = capacity();
	if (__cap >= __n)
	{
	value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());
	traits_type::move(__p, __s, __n);
	traits_type::assign(__p[__n], value_type());
	__set_size(__n);
	__invalidate_iterators_past(__n);
	}
	else
	{
	size_type __sz = size();
	__grow_by_and_replace(__cap, __n - __cap, __sz, 0, __sz, __n, __s);
	}
	return *this;
	}

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c)
	{
	size_type __cap = capacity();
	if (__cap < __n)
	{
	size_type __sz = size();
	__grow_by(__cap, __n - __cap, __sz, 0, __sz);
	}
	else
	__invalidate_iterators_past(__n);
	value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());
	traits_type::assign(__p, __n, __c);
	traits_type::assign(__p[__n], value_type());
	__set_size(__n);
	return *this;
	}

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::operator=(value_type __c)
	{
	pointer __p;
	if (__is_long())
	{
	__p = __get_long_pointer();
	__set_long_size(1);
	}
	else
	{
	__p = __get_short_pointer();
	__set_short_size(1);
	}
	traits_type::assign(*__p, __c);
	traits_type::assign(*++__p, value_type());
	__invalidate_iterators_past(1);
	return *this;
	}

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
	{
	if (this != &__str)
	{
	__copy_assign_alloc(__str);
	assign(__str.data(), __str.size());
	}
	return *this;
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, false_type)
	_NOEXCEPT_(__alloc_traits::is_always_equal::value)
	{
	if (__alloc() != __str.__alloc())
	assign(__str);
	else
	__move_assign(__str, true_type());
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type)
	#if _LIBCPP_STD_VER > 14
	_NOEXCEPT
	#else
	_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
	#endif
	{
	- clear();
	- shrink_to_fit();
	+ __clear_and_shrink();
	__r_.first() = __str.__r_.first();
	__move_assign_alloc(__str);
	__str.__zero();
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::operator=(basic_string&& __str)
	_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
	{
	__move_assign(__str, integral_constant<bool,
	__alloc_traits::propagate_on_container_move_assignment::value>());
	return *this;
	}

	#endif

	template <class _CharT, class _Traits, class _Allocator>
	template<class _InputIterator>
	typename enable_if
	<
	__is_exactly_input_iterator <_InputIterator>::value
	\|\| !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
	basic_string<_CharT, _Traits, _Allocator>&
	>::type
	basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
	{
	const basic_string __temp(__first, __last, __alloc());
	assign(__temp.data(), __temp.size());
	return *this;
	}

	template <class _CharT, class _Traits, class _Allocator>
	template<class _ForwardIterator>
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value
	&& __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
	basic_string<_CharT, _Traits, _Allocator>&
	>::type
	basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
	{
	size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
	size_type __cap = capacity();
	if (__cap < __n)
	{
	size_type __sz = size();
	__grow_by(__cap, __n - __cap, __sz, 0, __sz);
	}
	else
	__invalidate_iterators_past(__n);
	pointer __p = __get_pointer();
	for (; __first != __last; ++__first, ++__p)
	traits_type::assign(__p, __first);
	traits_type::assign(*__p, value_type());
	__set_size(__n);
	return *this;
	}

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n)
	{
	size_type __sz = __str.size();
	if (__pos > __sz)
	this->__throw_out_of_range();
	return assign(__str.data() + __pos, _VSTD::min(__n, __sz - __pos));
	}

	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>&
	>::type
	basic_string<_CharT, _Traits, _Allocator>::assign(const _Tp & __t, size_type __pos, size_type __n)
	{
	__self_view __sv = __t;
	size_type __sz = __sv.size();
	if (__pos > __sz)
	this->__throw_out_of_range();
	return assign(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos));
	}


	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s)
	{
	_LIBCPP_ASSERT(__s != nullptr, "string::assign received nullptr");
	return assign(__s, traits_type::length(__s));
	}

	// append

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_type __n)
	{
	_LIBCPP_ASSERT(__n == 0 \|\| __s != nullptr, "string::append received nullptr");
	size_type __cap = capacity();
	size_type __sz = size();
	if (__cap - __sz >= __n)
	{
	if (__n)
	{
	value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());
	traits_type::copy(__p + __sz, __s, __n);
	__sz += __n;
	__set_size(__sz);
	traits_type::assign(__p[__sz], value_type());
	}
	}
	else
	__grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __sz, 0, __n, __s);
	return *this;
	}

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c)
	{
	if (__n)
	{
	size_type __cap = capacity();
	size_type __sz = size();
	if (__cap - __sz < __n)
	__grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
	pointer __p = __get_pointer();
	traits_type::assign(_VSTD::__to_raw_pointer(__p) + __sz, __n, __c);
	__sz += __n;
	__set_size(__sz);
	traits_type::assign(__p[__sz], value_type());
	}
	return *this;
	}

	template <class _CharT, class _Traits, class _Allocator>
	void
	basic_string<_CharT, _Traits, _Allocator>::push_back(value_type __c)
	{
	bool __is_short = !__is_long();
	size_type __cap;
	size_type __sz;
	if (__is_short)
	{
	__cap = __min_cap - 1;
	__sz = __get_short_size();
	}
	else
	{
	__cap = __get_long_cap() - 1;
	__sz = __get_long_size();
	}
	if (__sz == __cap)
	{
	__grow_by(__cap, 1, __sz, __sz, 0);
	__is_short = !__is_long();
	}
	pointer __p;
	if (__is_short)
	{
	__p = __get_short_pointer() + __sz;
	__set_short_size(__sz+1);
	}
	else
	{
	__p = __get_long_pointer() + __sz;
	__set_long_size(__sz+1);
	}
	traits_type::assign(*__p, __c);
	traits_type::assign(*++__p, value_type());
	}

	template <class _Tp>
	bool __ptr_in_range (const _Tp* __p, const _Tp* __first, const _Tp* __last)
	{
	return __first <= __p && __p < __last;
	}

	template <class _Tp1, class _Tp2>
	bool __ptr_in_range (const _Tp1, const _Tp2, const _Tp2*)
	{
	return false;
	}

	template <class _CharT, class _Traits, class _Allocator>
	template<class _ForwardIterator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::__append_forward_unsafe(
	_ForwardIterator __first, _ForwardIterator __last)
	{
	static_assert(__is_forward_iterator<_ForwardIterator>::value,
	"function requires a ForwardIterator");
	size_type __sz = size();
	size_type __cap = capacity();
	size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
	if (__n)
	{
	typedef typename iterator_traits<_ForwardIterator>::reference _CharRef;
	_CharRef __tmp_ref = *__first;
	if (__ptr_in_range(_VSTD::addressof(__tmp_ref), data(), data() + size()))
	{
	const basic_string __temp (__first, __last, __alloc());
	append(__temp.data(), __temp.size());
	}
	else
	{
	if (__cap - __sz < __n)
	__grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
	pointer __p = __get_pointer() + __sz;
	for (; __first != __last; ++__p, ++__first)
	traits_type::assign(__p, __first);
	traits_type::assign(*__p, value_type());
	__set_size(__sz + __n);
	}
	}
	return *this;
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str)
	{
	return append(__str.data(), __str.size());
	}

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str, size_type __pos, size_type __n)
	{
	size_type __sz = __str.size();
	if (__pos > __sz)
	this->__throw_out_of_range();
	return append(__str.data() + __pos, _VSTD::min(__n, __sz - __pos));
	}

	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>&
	>::type
	basic_string<_CharT, _Traits, _Allocator>::append(const _Tp & __t, size_type __pos, size_type __n)
	{
	__self_view __sv = __t;
	size_type __sz = __sv.size();
	if (__pos > __sz)
	this->__throw_out_of_range();
	return append(__sv.data() + __pos, _VSTD::min(__n, __sz - __pos));
	}

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s)
	{
	_LIBCPP_ASSERT(__s != nullptr, "string::append received nullptr");
	return append(__s, traits_type::length(__s));
	}

	// insert

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s, size_type __n)
	{
	_LIBCPP_ASSERT(__n == 0 \|\| __s != nullptr, "string::insert received nullptr");
	size_type __sz = size();
	if (__pos > __sz)
	this->__throw_out_of_range();
	size_type __cap = capacity();
	if (__cap - __sz >= __n)
	{
	if (__n)
	{
	value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());
	size_type __n_move = __sz - __pos;
	if (__n_move != 0)
	{
	if (__p + __pos <= __s && __s < __p + __sz)
	__s += __n;
	traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
	}
	traits_type::move(__p + __pos, __s, __n);
	__sz += __n;
	__set_size(__sz);
	traits_type::assign(__p[__sz], value_type());
	}
	}
	else
	__grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s);
	return *this;
	}

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n, value_type __c)
	{
	size_type __sz = size();
	if (__pos > __sz)
	this->__throw_out_of_range();
	if (__n)
	{
	size_type __cap = capacity();
	value_type* __p;
	if (__cap - __sz >= __n)
	{
	__p = _VSTD::__to_raw_pointer(__get_pointer());
	size_type __n_move = __sz - __pos;
	if (__n_move != 0)
	traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
	}
	else
	{
	__grow_by(__cap, __sz + __n - __cap, __sz, __pos, 0, __n);
	__p = _VSTD::__to_raw_pointer(__get_long_pointer());
	}
	traits_type::assign(__p + __pos, __n, __c);
	__sz += __n;
	__set_size(__sz);
	traits_type::assign(__p[__sz], value_type());
	}
	return *this;
	}

	template <class _CharT, class _Traits, class _Allocator>
	template<class _InputIterator>
	typename enable_if
	<
	__is_exactly_input_iterator<_InputIterator>::value
	\|\| !__libcpp_string_gets_noexcept_iterator<_InputIterator>::value,
	typename basic_string<_CharT, _Traits, _Allocator>::iterator
	>::type
	basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIterator __first, _InputIterator __last)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
	"string::insert(iterator, range) called with an iterator not"
	" referring to this string");
	#endif
	const basic_string __temp(__first, __last, __alloc());
	return insert(__pos, __temp.data(), __temp.data() + __temp.size());
	}

	template <class _CharT, class _Traits, class _Allocator>
	template<class _ForwardIterator>
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value
	&& __libcpp_string_gets_noexcept_iterator<_ForwardIterator>::value,
	typename basic_string<_CharT, _Traits, _Allocator>::iterator
	>::type
	basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
	"string::insert(iterator, range) called with an iterator not"
	" referring to this string");
	#endif
	size_type __ip = static_cast<size_type>(__pos - begin());
	size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
	if (__n)
	{
	typedef typename iterator_traits<_ForwardIterator>::reference _CharRef;
	_CharRef __tmp_char = *__first;
	if (__ptr_in_range(_VSTD::addressof(__tmp_char), data(), data() + size()))
	{
	const basic_string __temp(__first, __last, __alloc());
	return insert(__pos, __temp.data(), __temp.data() + __temp.size());
	}

	size_type __sz = size();
	size_type __cap = capacity();
	value_type* __p;
	if (__cap - __sz >= __n)
	{
	__p = _VSTD::__to_raw_pointer(__get_pointer());
	size_type __n_move = __sz - __ip;
	if (__n_move != 0)
	traits_type::move(__p + __ip + __n, __p + __ip, __n_move);
	}
	else
	{
	__grow_by(__cap, __sz + __n - __cap, __sz, __ip, 0, __n);
	__p = _VSTD::__to_raw_pointer(__get_long_pointer());
	}
	__sz += __n;
	__set_size(__sz);
	traits_type::assign(__p[__sz], value_type());
	for (__p += __ip; __first != __last; ++__p, ++__first)
	traits_type::assign(__p, __first);
	}
	return begin() + __ip;
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str)
	{
	return insert(__pos1, __str.data(), __str.size());
	}

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str,
	size_type __pos2, size_type __n)
	{
	size_type __str_sz = __str.size();
	if (__pos2 > __str_sz)
	this->__throw_out_of_range();
	return insert(__pos1, __str.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2));
	}

	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>&
	>::type
	basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const _Tp& __t,
	size_type __pos2, size_type __n)
	{
	__self_view __sv = __t;
	size_type __str_sz = __sv.size();
	if (__pos2 > __str_sz)
	this->__throw_out_of_range();
	return insert(__pos1, __sv.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2));
	}

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s)
	{
	_LIBCPP_ASSERT(__s != nullptr, "string::insert received nullptr");
	return insert(__pos, __s, traits_type::length(__s));
	}

	template <class _CharT, class _Traits, class _Allocator>
	typename basic_string<_CharT, _Traits, _Allocator>::iterator
	basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_type __c)
	{
	size_type __ip = static_cast<size_type>(__pos - begin());
	size_type __sz = size();
	size_type __cap = capacity();
	value_type* __p;
	if (__cap == __sz)
	{
	__grow_by(__cap, 1, __sz, __ip, 0, 1);
	__p = _VSTD::__to_raw_pointer(__get_long_pointer());
	}
	else
	{
	__p = _VSTD::__to_raw_pointer(__get_pointer());
	size_type __n_move = __sz - __ip;
	if (__n_move != 0)
	traits_type::move(__p + __ip + 1, __p + __ip, __n_move);
	}
	traits_type::assign(__p[__ip], __c);
	traits_type::assign(__p[++__sz], value_type());
	__set_size(__sz);
	return begin() + static_cast<difference_type>(__ip);
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::iterator
	basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, size_type __n, value_type __c)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
	"string::insert(iterator, n, value) called with an iterator not"
	" referring to this string");
	#endif
	difference_type __p = __pos - begin();
	insert(static_cast<size_type>(__p), __n, __c);
	return begin() + __p;
	}

	// replace

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2)
	_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
	{
	_LIBCPP_ASSERT(__n2 == 0 \|\| __s != nullptr, "string::replace received nullptr");
	size_type __sz = size();
	if (__pos > __sz)
	this->__throw_out_of_range();
	__n1 = _VSTD::min(__n1, __sz - __pos);
	size_type __cap = capacity();
	if (__cap - __sz + __n1 >= __n2)
	{
	value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());
	if (__n1 != __n2)
	{
	size_type __n_move = __sz - __pos - __n1;
	if (__n_move != 0)
	{
	if (__n1 > __n2)
	{
	traits_type::move(__p + __pos, __s, __n2);
	traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
	goto __finish;
	}
	if (__p + __pos < __s && __s < __p + __sz)
	{
	if (__p + __pos + __n1 <= __s)
	__s += __n2 - __n1;
	else // __p + __pos < __s < __p + __pos + __n1
	{
	traits_type::move(__p + __pos, __s, __n1);
	__pos += __n1;
	__s += __n2;
	__n2 -= __n1;
	__n1 = 0;
	}
	}
	traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
	}
	}
	traits_type::move(__p + __pos, __s, __n2);
	__finish:
	// __sz += __n2 - __n1; in this and the below function below can cause unsigned integer overflow,
	// but this is a safe operation, so we disable the check.
	__sz += __n2 - __n1;
	__set_size(__sz);
	__invalidate_iterators_past(__sz);
	traits_type::assign(__p[__sz], value_type());
	}
	else
	__grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __s);
	return *this;
	}

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, size_type __n2, value_type __c)
	_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
	{
	size_type __sz = size();
	if (__pos > __sz)
	this->__throw_out_of_range();
	__n1 = _VSTD::min(__n1, __sz - __pos);
	size_type __cap = capacity();
	value_type* __p;
	if (__cap - __sz + __n1 >= __n2)
	{
	__p = _VSTD::__to_raw_pointer(__get_pointer());
	if (__n1 != __n2)
	{
	size_type __n_move = __sz - __pos - __n1;
	if (__n_move != 0)
	traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
	}
	}
	else
	{
	__grow_by(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2);
	__p = _VSTD::__to_raw_pointer(__get_long_pointer());
	}
	traits_type::assign(__p + __pos, __n2, __c);
	__sz += __n2 - __n1;
	__set_size(__sz);
	__invalidate_iterators_past(__sz);
	traits_type::assign(__p[__sz], value_type());
	return *this;
	}

	template <class _CharT, class _Traits, class _Allocator>
	template<class _InputIterator>
	typename enable_if
	<
	__is_input_iterator<_InputIterator>::value,
	basic_string<_CharT, _Traits, _Allocator>&
	>::type
	basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2,
	_InputIterator __j1, _InputIterator __j2)
	{
	const basic_string __temp(__j1, __j2, __alloc());
	return this->replace(__i1, __i2, __temp);
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str)
	{
	return replace(__pos1, __n1, __str.data(), __str.size());
	}

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str,
	size_type __pos2, size_type __n2)
	{
	size_type __str_sz = __str.size();
	if (__pos2 > __str_sz)
	this->__throw_out_of_range();
	return replace(__pos1, __n1, __str.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2));
	}

	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>&
	>::type
	basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const _Tp& __t,
	size_type __pos2, size_type __n2)
	{
	__self_view __sv = __t;
	size_type __str_sz = __sv.size();
	if (__pos2 > __str_sz)
	this->__throw_out_of_range();
	return replace(__pos1, __n1, __sv.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2));
	}

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s)
	{
	_LIBCPP_ASSERT(__s != nullptr, "string::replace received nullptr");
	return replace(__pos, __n1, __s, traits_type::length(__s));
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const basic_string& __str)
	{
	return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1),
	__str.data(), __str.size());
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s, size_type __n)
	{
	return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s, __n);
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const value_type* __s)
	{
	return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s);
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c)
	{
	return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __n, __c);
	}

	// erase

	template <class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>&
	basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos, size_type __n)
	{
	size_type __sz = size();
	if (__pos > __sz)
	this->__throw_out_of_range();
	if (__n)
	{
	value_type* __p = _VSTD::__to_raw_pointer(__get_pointer());
	__n = _VSTD::min(__n, __sz - __pos);
	size_type __n_move = __sz - __pos - __n;
	if (__n_move != 0)
	traits_type::move(__p + __pos, __p + __pos + __n, __n_move);
	__sz -= __n;
	__set_size(__sz);
	__invalidate_iterators_past(__sz);
	traits_type::assign(__p[__sz], value_type());
	}
	return *this;
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::iterator
	basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __pos)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
	"string::erase(iterator) called with an iterator not"
	" referring to this string");
	#endif
	_LIBCPP_ASSERT(__pos != end(),
	"string::erase(iterator) called with a non-dereferenceable iterator");
	iterator __b = begin();
	size_type __r = static_cast<size_type>(__pos - __b);
	erase(__r, 1);
	return __b + static_cast<difference_type>(__r);
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::iterator
	basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __first, const_iterator __last)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this,
	"string::erase(iterator, iterator) called with an iterator not"
	" referring to this string");
	#endif
	_LIBCPP_ASSERT(__first <= __last, "string::erase(first, last) called with invalid range");
	iterator __b = begin();
	size_type __r = static_cast<size_type>(__first - __b);
	erase(__r, static_cast<size_type>(__last - __first));
	return __b + static_cast<difference_type>(__r);
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	basic_string<_CharT, _Traits, _Allocator>::pop_back()
	{
	_LIBCPP_ASSERT(!empty(), "string::pop_back(): string is already empty");
	size_type __sz;
	if (__is_long())
	{
	__sz = __get_long_size() - 1;
	__set_long_size(__sz);
	traits_type::assign(*(__get_long_pointer() + __sz), value_type());
	}
	else
	{
	__sz = __get_short_size() - 1;
	__set_short_size(__sz);
	traits_type::assign(*(__get_short_pointer() + __sz), value_type());
	}
	__invalidate_iterators_past(__sz);
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	basic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPT
	{
	__invalidate_all_iterators();
	if (__is_long())
	{
	traits_type::assign(*__get_long_pointer(), value_type());
	__set_long_size(0);
	}
	else
	{
	traits_type::assign(*__get_short_pointer(), value_type());
	__set_short_size(0);
	}
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	basic_string<_CharT, _Traits, _Allocator>::__erase_to_end(size_type __pos)
	{
	if (__is_long())
	{
	traits_type::assign(*(__get_long_pointer() + __pos), value_type());
	__set_long_size(__pos);
	}
	else
	{
	traits_type::assign(*(__get_short_pointer() + __pos), value_type());
	__set_short_size(__pos);
	}
	__invalidate_iterators_past(__pos);
	}

	template <class _CharT, class _Traits, class _Allocator>
	void
	basic_string<_CharT, _Traits, _Allocator>::resize(size_type __n, value_type __c)
	{
	size_type __sz = size();
	if (__n > __sz)
	append(__n - __sz, __c);
	else
	__erase_to_end(__n);
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	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());
	#ifdef _LIBCPP_BIG_ENDIAN
	return (__m <= ~__long_mask ? __m : __m/2) - __alignment;
	#else
	return __m - __alignment;
	#endif
	}

	template <class _CharT, class _Traits, class _Allocator>
	void
	basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __res_arg)
	{
	if (__res_arg > max_size())
	this->__throw_length_error();
	size_type __cap = capacity();
	size_type __sz = size();
	__res_arg = _VSTD::max(__res_arg, __sz);
	__res_arg = __recommend(__res_arg);
	if (__res_arg != __cap)
	{
	pointer __new_data, __p;
	bool __was_long, __now_long;
	if (__res_arg == __min_cap - 1)
	{
	__was_long = true;
	__now_long = false;
	__new_data = __get_short_pointer();
	__p = __get_long_pointer();
	}
	else
	{
	if (__res_arg > __cap)
	__new_data = __alloc_traits::allocate(__alloc(), __res_arg+1);
	else
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	__new_data = __alloc_traits::allocate(__alloc(), __res_arg+1);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	return;
	}
	#else // _LIBCPP_NO_EXCEPTIONS
	if (__new_data == nullptr)
	return;
	#endif // _LIBCPP_NO_EXCEPTIONS
	}
	__now_long = true;
	__was_long = __is_long();
	__p = __get_pointer();
	}
	traits_type::copy(_VSTD::__to_raw_pointer(__new_data),
	_VSTD::__to_raw_pointer(__p), size()+1);
	if (__was_long)
	__alloc_traits::deallocate(__alloc(), __p, __cap+1);
	if (__now_long)
	{
	__set_long_cap(__res_arg+1);
	__set_long_size(__sz);
	__set_long_pointer(__new_data);
	}
	else
	__set_short_size(__sz);
	__invalidate_all_iterators();
	}
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::const_reference
	basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) const _NOEXCEPT
	{
	_LIBCPP_ASSERT(__pos <= size(), "string index out of bounds");
	return *(data() + __pos);
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::reference
	basic_string<_CharT, _Traits, _Allocator>::operator[](size_type __pos) _NOEXCEPT
	{
	_LIBCPP_ASSERT(__pos <= size(), "string index out of bounds");
	return *(__get_pointer() + __pos);
	}

	template <class _CharT, class _Traits, class _Allocator>
	typename basic_string<_CharT, _Traits, _Allocator>::const_reference
	basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) const
	{
	if (__n >= size())
	this->__throw_out_of_range();
	return (*this)[__n];
	}

	template <class _CharT, class _Traits, class _Allocator>
	typename basic_string<_CharT, _Traits, _Allocator>::reference
	basic_string<_CharT, _Traits, _Allocator>::at(size_type __n)
	{
	if (__n >= size())
	this->__throw_out_of_range();
	return (*this)[__n];
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::reference
	basic_string<_CharT, _Traits, _Allocator>::front()
	{
	_LIBCPP_ASSERT(!empty(), "string::front(): string is empty");
	return *__get_pointer();
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::const_reference
	basic_string<_CharT, _Traits, _Allocator>::front() const
	{
	_LIBCPP_ASSERT(!empty(), "string::front(): string is empty");
	return *data();
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::reference
	basic_string<_CharT, _Traits, _Allocator>::back()
	{
	_LIBCPP_ASSERT(!empty(), "string::back(): string is empty");
	return *(__get_pointer() + size() - 1);
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::const_reference
	basic_string<_CharT, _Traits, _Allocator>::back() const
	{
	_LIBCPP_ASSERT(!empty(), "string::back(): string is empty");
	return *(data() + size() - 1);
	}

	template <class _CharT, class _Traits, class _Allocator>
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::copy(value_type* __s, size_type __n, size_type __pos) const
	{
	size_type __sz = size();
	if (__pos > __sz)
	this->__throw_out_of_range();
	size_type __rlen = _VSTD::min(__n, __sz - __pos);
	traits_type::copy(__s, data() + __pos, __rlen);
	return __rlen;
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>
	basic_string<_CharT, _Traits, _Allocator>::substr(size_type __pos, size_type __n) const
	{
	return basic_string(*this, __pos, __n, __alloc());
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT_DEBUG
	#else
	_NOEXCEPT_DEBUG_(!__alloc_traits::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<allocator_type>::value)
	#endif
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	if (!__is_long())
	__get_db()->__invalidate_all(this);
	if (!__str.__is_long())
	__get_db()->__invalidate_all(&__str);
	__get_db()->swap(this, &__str);
	#endif
	_LIBCPP_ASSERT(
	__alloc_traits::propagate_on_container_swap::value \|\|
	__alloc_traits::is_always_equal::value \|\|
	__alloc() == __str.__alloc(), "swapping non-equal allocators");
	_VSTD::swap(__r_.first(), __str.__r_.first());
	__swap_allocator(__alloc(), __str.__alloc());
	}

	// find

	template <class _Traits>
	struct _LIBCPP_HIDDEN __traits_eq
	{
	typedef typename _Traits::char_type char_type;
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const char_type& __x, const char_type& __y) _NOEXCEPT
	{return _Traits::eq(__x, __y);}
	};

	template<class _CharT, class _Traits, class _Allocator>
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
	size_type __pos,
	size_type __n) const _NOEXCEPT
	{
	_LIBCPP_ASSERT(__n == 0 \|\| __s != nullptr, "string::find(): received nullptr");
	return __str_find<value_type, size_type, traits_type, npos>
	(data(), size(), __s, __pos, __n);
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str,
	size_type __pos) const _NOEXCEPT
	{
	return __str_find<value_type, size_type, traits_type, npos>
	(data(), size(), __str.data(), __pos, __str.size());
	}

	template<class _CharT, class _Traits, class _Allocator>
	-inline _LIBCPP_INLINE_VISIBILITY
	-typename basic_string<_CharT, _Traits, _Allocator>::size_type
	-basic_string<_CharT, _Traits, _Allocator>::find(__self_view __sv,
	- size_type __pos) const _NOEXCEPT
	+template <class _Tp>
	+typename enable_if
	+<
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ typename basic_string<_CharT, _Traits, _Allocator>::size_type
	+>::type
	+basic_string<_CharT, _Traits, _Allocator>::find(const _Tp &__t,
	+ size_type __pos) const
	{
	+ __self_view __sv = __t;
	return __str_find<value_type, size_type, traits_type, npos>
	(data(), size(), __sv.data(), __pos, __sv.size());
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
	size_type __pos) const _NOEXCEPT
	{
	_LIBCPP_ASSERT(__s != nullptr, "string::find(): received nullptr");
	return __str_find<value_type, size_type, traits_type, npos>
	(data(), size(), __s, __pos, traits_type::length(__s));
	}

	template<class _CharT, class _Traits, class _Allocator>
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find(value_type __c,
	size_type __pos) const _NOEXCEPT
	{
	return __str_find<value_type, size_type, traits_type, npos>
	(data(), size(), __c, __pos);
	}

	// rfind

	template<class _CharT, class _Traits, class _Allocator>
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
	size_type __pos,
	size_type __n) const _NOEXCEPT
	{
	_LIBCPP_ASSERT(__n == 0 \|\| __s != nullptr, "string::rfind(): received nullptr");
	return __str_rfind<value_type, size_type, traits_type, npos>
	(data(), size(), __s, __pos, __n);
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str,
	size_type __pos) const _NOEXCEPT
	{
	return __str_rfind<value_type, size_type, traits_type, npos>
	(data(), size(), __str.data(), __pos, __str.size());
	}

	template<class _CharT, class _Traits, class _Allocator>
	-inline _LIBCPP_INLINE_VISIBILITY
	-typename basic_string<_CharT, _Traits, _Allocator>::size_type
	-basic_string<_CharT, _Traits, _Allocator>::rfind(__self_view __sv,
	- size_type __pos) const _NOEXCEPT
	+template <class _Tp>
	+typename enable_if
	+<
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ typename basic_string<_CharT, _Traits, _Allocator>::size_type
	+>::type
	+basic_string<_CharT, _Traits, _Allocator>::rfind(const _Tp& __t,
	+ size_type __pos) const
	{
	+ __self_view __sv = __t;
	return __str_rfind<value_type, size_type, traits_type, npos>
	(data(), size(), __sv.data(), __pos, __sv.size());
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
	size_type __pos) const _NOEXCEPT
	{
	_LIBCPP_ASSERT(__s != nullptr, "string::rfind(): received nullptr");
	return __str_rfind<value_type, size_type, traits_type, npos>
	(data(), size(), __s, __pos, traits_type::length(__s));
	}

	template<class _CharT, class _Traits, class _Allocator>
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::rfind(value_type __c,
	size_type __pos) const _NOEXCEPT
	{
	return __str_rfind<value_type, size_type, traits_type, npos>
	(data(), size(), __c, __pos);
	}

	// find_first_of

	template<class _CharT, class _Traits, class _Allocator>
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
	size_type __pos,
	size_type __n) const _NOEXCEPT
	{
	_LIBCPP_ASSERT(__n == 0 \|\| __s != nullptr, "string::find_first_of(): received nullptr");
	return __str_find_first_of<value_type, size_type, traits_type, npos>
	(data(), size(), __s, __pos, __n);
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __str,
	size_type __pos) const _NOEXCEPT
	{
	return __str_find_first_of<value_type, size_type, traits_type, npos>
	(data(), size(), __str.data(), __pos, __str.size());
	}

	template<class _CharT, class _Traits, class _Allocator>
	-inline _LIBCPP_INLINE_VISIBILITY
	-typename basic_string<_CharT, _Traits, _Allocator>::size_type
	-basic_string<_CharT, _Traits, _Allocator>::find_first_of(__self_view __sv,
	- size_type __pos) const _NOEXCEPT
	+template <class _Tp>
	+typename enable_if
	+<
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ typename basic_string<_CharT, _Traits, _Allocator>::size_type
	+>::type
	+basic_string<_CharT, _Traits, _Allocator>::find_first_of(const _Tp& __t,
	+ size_type __pos) const
	{
	+ __self_view __sv = __t;
	return __str_find_first_of<value_type, size_type, traits_type, npos>
	(data(), size(), __sv.data(), __pos, __sv.size());
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
	size_type __pos) const _NOEXCEPT
	{
	_LIBCPP_ASSERT(__s != nullptr, "string::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));
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find_first_of(value_type __c,
	size_type __pos) const _NOEXCEPT
	{
	return find(__c, __pos);
	}

	// find_last_of

	template<class _CharT, class _Traits, class _Allocator>
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
	size_type __pos,
	size_type __n) const _NOEXCEPT
	{
	_LIBCPP_ASSERT(__n == 0 \|\| __s != nullptr, "string::find_last_of(): received nullptr");
	return __str_find_last_of<value_type, size_type, traits_type, npos>
	(data(), size(), __s, __pos, __n);
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __str,
	size_type __pos) const _NOEXCEPT
	{
	return __str_find_last_of<value_type, size_type, traits_type, npos>
	(data(), size(), __str.data(), __pos, __str.size());
	}

	template<class _CharT, class _Traits, class _Allocator>
	-inline _LIBCPP_INLINE_VISIBILITY
	-typename basic_string<_CharT, _Traits, _Allocator>::size_type
	-basic_string<_CharT, _Traits, _Allocator>::find_last_of(__self_view __sv,
	- size_type __pos) const _NOEXCEPT
	+template <class _Tp>
	+typename enable_if
	+<
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ typename basic_string<_CharT, _Traits, _Allocator>::size_type
	+>::type
	+basic_string<_CharT, _Traits, _Allocator>::find_last_of(const _Tp& __t,
	+ size_type __pos) const
	{
	+ __self_view __sv = __t;
	return __str_find_last_of<value_type, size_type, traits_type, npos>
	(data(), size(), __sv.data(), __pos, __sv.size());
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
	size_type __pos) const _NOEXCEPT
	{
	_LIBCPP_ASSERT(__s != nullptr, "string::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));
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find_last_of(value_type __c,
	size_type __pos) const _NOEXCEPT
	{
	return rfind(__c, __pos);
	}

	// find_first_not_of

	template<class _CharT, class _Traits, class _Allocator>
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
	size_type __pos,
	size_type __n) const _NOEXCEPT
	{
	_LIBCPP_ASSERT(__n == 0 \|\| __s != nullptr, "string::find_first_not_of(): received nullptr");
	return __str_find_first_not_of<value_type, size_type, traits_type, npos>
	(data(), size(), __s, __pos, __n);
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const basic_string& __str,
	size_type __pos) const _NOEXCEPT
	{
	return __str_find_first_not_of<value_type, size_type, traits_type, npos>
	(data(), size(), __str.data(), __pos, __str.size());
	}

	template<class _CharT, class _Traits, class _Allocator>
	-inline _LIBCPP_INLINE_VISIBILITY
	-typename basic_string<_CharT, _Traits, _Allocator>::size_type
	-basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(__self_view __sv,
	- size_type __pos) const _NOEXCEPT
	+template <class _Tp>
	+typename enable_if
	+<
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ typename basic_string<_CharT, _Traits, _Allocator>::size_type
	+>::type
	+basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const _Tp& __t,
	+ size_type __pos) const
	{
	+ __self_view __sv = __t;
	return __str_find_first_not_of<value_type, size_type, traits_type, npos>
	(data(), size(), __sv.data(), __pos, __sv.size());
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
	size_type __pos) const _NOEXCEPT
	{
	_LIBCPP_ASSERT(__s != nullptr, "string::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));
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(value_type __c,
	size_type __pos) const _NOEXCEPT
	{
	return __str_find_first_not_of<value_type, size_type, traits_type, npos>
	(data(), size(), __c, __pos);
	}

	// find_last_not_of

	template<class _CharT, class _Traits, class _Allocator>
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
	size_type __pos,
	size_type __n) const _NOEXCEPT
	{
	_LIBCPP_ASSERT(__n == 0 \|\| __s != nullptr, "string::find_last_not_of(): received nullptr");
	return __str_find_last_not_of<value_type, size_type, traits_type, npos>
	(data(), size(), __s, __pos, __n);
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const basic_string& __str,
	size_type __pos) const _NOEXCEPT
	{
	return __str_find_last_not_of<value_type, size_type, traits_type, npos>
	(data(), size(), __str.data(), __pos, __str.size());
	}

	template<class _CharT, class _Traits, class _Allocator>
	-inline _LIBCPP_INLINE_VISIBILITY
	-typename basic_string<_CharT, _Traits, _Allocator>::size_type
	-basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(__self_view __sv,
	- size_type __pos) const _NOEXCEPT
	+template <class _Tp>
	+typename enable_if
	+<
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ typename basic_string<_CharT, _Traits, _Allocator>::size_type
	+>::type
	+basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const _Tp& __t,
	+ size_type __pos) const
	{
	+ __self_view __sv = __t;
	return __str_find_last_not_of<value_type, size_type, traits_type, npos>
	(data(), size(), __sv.data(), __pos, __sv.size());
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
	size_type __pos) const _NOEXCEPT
	{
	_LIBCPP_ASSERT(__s != nullptr, "string::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));
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c,
	size_type __pos) const _NOEXCEPT
	{
	return __str_find_last_not_of<value_type, size_type, traits_type, npos>
	(data(), size(), __c, __pos);
	}

	// compare

	template <class _CharT, class _Traits, class _Allocator>
	-inline _LIBCPP_INLINE_VISIBILITY
	-int
	-basic_string<_CharT, _Traits, _Allocator>::compare(__self_view __sv) const _NOEXCEPT
	+template <class _Tp>
	+typename enable_if
	+<
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ int
	+>::type
	+basic_string<_CharT, _Traits, _Allocator>::compare(const _Tp& __t) const
	{
	+ __self_view __sv = __t;
	size_t __lhs_sz = size();
	size_t __rhs_sz = __sv.size();
	int __result = traits_type::compare(data(), __sv.data(),
	_VSTD::min(__lhs_sz, __rhs_sz));
	if (__result != 0)
	return __result;
	if (__lhs_sz < __rhs_sz)
	return -1;
	if (__lhs_sz > __rhs_sz)
	return 1;
	return 0;
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	int
	basic_string<_CharT, _Traits, _Allocator>::compare(const basic_string& __str) const _NOEXCEPT
	{
	return compare(__self_view(__str));
	}

	template <class _CharT, class _Traits, class _Allocator>
	int
	basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
	size_type __n1,
	const value_type* __s,
	size_type __n2) const
	{
	_LIBCPP_ASSERT(__n2 == 0 \|\| __s != nullptr, "string::compare(): received nullptr");
	size_type __sz = size();
	if (__pos1 > __sz \|\| __n2 == npos)
	this->__throw_out_of_range();
	size_type __rlen = _VSTD::min(__n1, __sz - __pos1);
	int __r = traits_type::compare(data() + __pos1, __s, _VSTD::min(__rlen, __n2));
	if (__r == 0)
	{
	if (__rlen < __n2)
	__r = -1;
	else if (__rlen > __n2)
	__r = 1;
	}
	return __r;
	}

	template <class _CharT, class _Traits, class _Allocator>
	-inline _LIBCPP_INLINE_VISIBILITY
	-int
	+template <class _Tp>
	+typename enable_if
	+<
	+ __can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	+ int
	+>::type
	basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
	size_type __n1,
	- __self_view __sv) const
	+ const _Tp& __t) const
	{
	+ __self_view __sv = __t;
	return compare(__pos1, __n1, __sv.data(), __sv.size());
	}

	template <class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	int
	basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
	size_type __n1,
	const basic_string& __str) const
	{
	return compare(__pos1, __n1, __str.data(), __str.size());
	}

	template <class _CharT, class _Traits, class _Allocator>
	template <class _Tp>
	typename enable_if
	<
	__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value,
	int
	>::type
	basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
	size_type __n1,
	const _Tp& __t,
	size_type __pos2,
	size_type __n2) const
	{
	__self_view __sv = __t;
	return __self_view(*this).substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
	}

	template <class _CharT, class _Traits, class _Allocator>
	int
	basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
	size_type __n1,
	const basic_string& __str,
	size_type __pos2,
	size_type __n2) const
	{
	return compare(__pos1, __n1, __self_view(__str), __pos2, __n2);
	}

	template <class _CharT, class _Traits, class _Allocator>
	int
	basic_string<_CharT, _Traits, _Allocator>::compare(const value_type* __s) const _NOEXCEPT
	{
	_LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr");
	return compare(0, npos, __s, traits_type::length(__s));
	}

	template <class _CharT, class _Traits, class _Allocator>
	int
	basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
	size_type __n1,
	const value_type* __s) const
	{
	_LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr");
	return compare(__pos1, __n1, __s, traits_type::length(__s));
	}

	// __invariants

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	basic_string<_CharT, _Traits, _Allocator>::__invariants() const
	{
	if (size() > capacity())
	return false;
	if (capacity() < __min_cap - 1)
	return false;
	if (data() == 0)
	return false;
	if (data()[size()] != value_type(0))
	return false;
	return true;
	}
	+
	+// __clear_and_shrink
	+
	+template<class _CharT, class _Traits, class _Allocator>
	+inline _LIBCPP_INLINE_VISIBILITY
	+void
	+basic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPT
	+{
	+ clear();
	+ if(__is_long())
	+ {
	+ __alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1);
	+ __set_long_cap(0);
	+ __set_short_size(0);
	+ }
	+}

	// operator==

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
	const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
	{
	size_t __lhs_sz = __lhs.size();
	return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(),
	__rhs.data(),
	__lhs_sz) == 0;
	}

	template<class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs,
	const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT
	{
	size_t __lhs_sz = __lhs.size();
	if (__lhs_sz != __rhs.size())
	return false;
	const char* __lp = __lhs.data();
	const char* __rp = __rhs.data();
	if (__lhs.__is_long())
	return char_traits<char>::compare(__lp, __rp, __lhs_sz) == 0;
	for (; __lhs_sz != 0; --__lhs_sz, ++__lp, ++__rp)
	if (__lp != __rp)
	return false;
	return true;
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const _CharT* __lhs,
	const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
	{
	typedef basic_string<_CharT, _Traits, _Allocator> _String;
	_LIBCPP_ASSERT(__lhs != nullptr, "operator==(char*, basic_string): received nullptr");
	size_t __lhs_len = _Traits::length(__lhs);
	if (__lhs_len != __rhs.size()) return false;
	return __rhs.compare(0, _String::npos, __lhs, __lhs_len) == 0;
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
	const _CharT* __rhs) _NOEXCEPT
	{
	typedef basic_string<_CharT, _Traits, _Allocator> _String;
	_LIBCPP_ASSERT(__rhs != nullptr, "operator==(basic_string, char*): received nullptr");
	size_t __rhs_len = _Traits::length(__rhs);
	if (__rhs_len != __lhs.size()) return false;
	return __lhs.compare(0, _String::npos, __rhs, __rhs_len) == 0;
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
	const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
	{
	return !(__lhs == __rhs);
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const _CharT* __lhs,
	const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
	{
	return !(__lhs == __rhs);
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
	const _CharT* __rhs) _NOEXCEPT
	{
	return !(__lhs == __rhs);
	}

	// operator<

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
	const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
	{
	return __lhs.compare(__rhs) < 0;
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
	const _CharT* __rhs) _NOEXCEPT
	{
	return __lhs.compare(__rhs) < 0;
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator< (const _CharT* __lhs,
	const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
	{
	return __rhs.compare(__lhs) > 0;
	}

	// operator>

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
	const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
	{
	return __rhs < __lhs;
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
	const _CharT* __rhs) _NOEXCEPT
	{
	return __rhs < __lhs;
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator> (const _CharT* __lhs,
	const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
	{
	return __rhs < __lhs;
	}

	// operator<=

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
	const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
	{
	return !(__rhs < __lhs);
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
	const _CharT* __rhs) _NOEXCEPT
	{
	return !(__rhs < __lhs);
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const _CharT* __lhs,
	const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
	{
	return !(__rhs < __lhs);
	}

	// operator>=

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
	const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
	{
	return !(__lhs < __rhs);
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
	const _CharT* __rhs) _NOEXCEPT
	{
	return !(__lhs < __rhs);
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const _CharT* __lhs,
	const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
	{
	return !(__lhs < __rhs);
	}

	// operator +

	template<class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>
	operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
	const basic_string<_CharT, _Traits, _Allocator>& __rhs)
	{
	basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
	typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
	typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
	__r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz);
	__r.append(__rhs.data(), __rhs_sz);
	return __r;
	}

	template<class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>
	operator+(const _CharT* __lhs , const basic_string<_CharT,_Traits,_Allocator>& __rhs)
	{
	basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator());
	typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = _Traits::length(__lhs);
	typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
	__r.__init(__lhs, __lhs_sz, __lhs_sz + __rhs_sz);
	__r.append(__rhs.data(), __rhs_sz);
	return __r;
	}

	template<class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>
	operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Allocator>& __rhs)
	{
	basic_string<_CharT, _Traits, _Allocator> __r(__rhs.get_allocator());
	typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = __rhs.size();
	__r.__init(&__lhs, 1, 1 + __rhs_sz);
	__r.append(__rhs.data(), __rhs_sz);
	return __r;
	}

	template<class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>
	operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs)
	{
	basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
	typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
	typename basic_string<_CharT, _Traits, _Allocator>::size_type __rhs_sz = _Traits::length(__rhs);
	__r.__init(__lhs.data(), __lhs_sz, __lhs_sz + __rhs_sz);
	__r.append(__rhs, __rhs_sz);
	return __r;
	}

	template<class _CharT, class _Traits, class _Allocator>
	basic_string<_CharT, _Traits, _Allocator>
	operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, _CharT __rhs)
	{
	basic_string<_CharT, _Traits, _Allocator> __r(__lhs.get_allocator());
	typename basic_string<_CharT, _Traits, _Allocator>::size_type __lhs_sz = __lhs.size();
	__r.__init(__lhs.data(), __lhs_sz, __lhs_sz + 1);
	__r.push_back(__rhs);
	return __r;
	}

	#ifndef _LIBCPP_CXX03_LANG

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>
	operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs)
	{
	return _VSTD::move(__lhs.append(__rhs));
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>
	operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
	{
	return _VSTD::move(__rhs.insert(0, __lhs));
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>
	operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
	{
	return _VSTD::move(__lhs.append(__rhs));
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>
	operator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs)
	{
	return _VSTD::move(__rhs.insert(0, __lhs));
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>
	operator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs)
	{
	__rhs.insert(__rhs.begin(), __lhs);
	return _VSTD::move(__rhs);
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>
	operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs)
	{
	return _VSTD::move(__lhs.append(__rhs));
	}

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<_CharT, _Traits, _Allocator>
	operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs)
	{
	__lhs.push_back(__rhs);
	return _VSTD::move(__lhs);
	}

	#endif // _LIBCPP_CXX03_LANG

	// swap

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(basic_string<_CharT, _Traits, _Allocator>& __lhs,
	basic_string<_CharT, _Traits, _Allocator>& __rhs)
	_NOEXCEPT_(_NOEXCEPT_(__lhs.swap(__rhs)))
	{
	__lhs.swap(__rhs);
	}

	#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS

	typedef basic_string<char16_t> u16string;
	typedef basic_string<char32_t> u32string;

	#endif // _LIBCPP_HAS_NO_UNICODE_CHARS

	_LIBCPP_FUNC_VIS int stoi (const string& __str, size_t* __idx = 0, int __base = 10);
	_LIBCPP_FUNC_VIS long stol (const string& __str, size_t* __idx = 0, int __base = 10);
	_LIBCPP_FUNC_VIS unsigned long stoul (const string& __str, size_t* __idx = 0, int __base = 10);
	_LIBCPP_FUNC_VIS long long stoll (const string& __str, size_t* __idx = 0, int __base = 10);
	_LIBCPP_FUNC_VIS unsigned long long stoull(const string& __str, size_t* __idx = 0, int __base = 10);

	_LIBCPP_FUNC_VIS float stof (const string& __str, size_t* __idx = 0);
	_LIBCPP_FUNC_VIS double stod (const string& __str, size_t* __idx = 0);
	_LIBCPP_FUNC_VIS long double stold(const string& __str, size_t* __idx = 0);

	_LIBCPP_FUNC_VIS string to_string(int __val);
	_LIBCPP_FUNC_VIS string to_string(unsigned __val);
	_LIBCPP_FUNC_VIS string to_string(long __val);
	_LIBCPP_FUNC_VIS string to_string(unsigned long __val);
	_LIBCPP_FUNC_VIS string to_string(long long __val);
	_LIBCPP_FUNC_VIS string to_string(unsigned long long __val);
	_LIBCPP_FUNC_VIS string to_string(float __val);
	_LIBCPP_FUNC_VIS string to_string(double __val);
	_LIBCPP_FUNC_VIS string to_string(long double __val);

	_LIBCPP_FUNC_VIS int stoi (const wstring& __str, size_t* __idx = 0, int __base = 10);
	_LIBCPP_FUNC_VIS long stol (const wstring& __str, size_t* __idx = 0, int __base = 10);
	_LIBCPP_FUNC_VIS unsigned long stoul (const wstring& __str, size_t* __idx = 0, int __base = 10);
	_LIBCPP_FUNC_VIS long long stoll (const wstring& __str, size_t* __idx = 0, int __base = 10);
	_LIBCPP_FUNC_VIS unsigned long long stoull(const wstring& __str, size_t* __idx = 0, int __base = 10);

	_LIBCPP_FUNC_VIS float stof (const wstring& __str, size_t* __idx = 0);
	_LIBCPP_FUNC_VIS double stod (const wstring& __str, size_t* __idx = 0);
	_LIBCPP_FUNC_VIS long double stold(const wstring& __str, size_t* __idx = 0);

	_LIBCPP_FUNC_VIS wstring to_wstring(int __val);
	_LIBCPP_FUNC_VIS wstring to_wstring(unsigned __val);
	_LIBCPP_FUNC_VIS wstring to_wstring(long __val);
	_LIBCPP_FUNC_VIS wstring to_wstring(unsigned long __val);
	_LIBCPP_FUNC_VIS wstring to_wstring(long long __val);
	_LIBCPP_FUNC_VIS wstring to_wstring(unsigned long long __val);
	_LIBCPP_FUNC_VIS wstring to_wstring(float __val);
	_LIBCPP_FUNC_VIS wstring to_wstring(double __val);
	_LIBCPP_FUNC_VIS wstring to_wstring(long double __val);

	template<class _CharT, class _Traits, class _Allocator>
	const typename basic_string<_CharT, _Traits, _Allocator>::size_type
	basic_string<_CharT, _Traits, _Allocator>::npos;

	template<class _CharT, class _Traits, class _Allocator>
	struct _LIBCPP_TEMPLATE_VIS hash<basic_string<_CharT, _Traits, _Allocator> >
	: public unary_function<basic_string<_CharT, _Traits, _Allocator>, size_t>
	{
	size_t
	operator()(const basic_string<_CharT, _Traits, _Allocator>& __val) const _NOEXCEPT;
	};

	template<class _CharT, class _Traits, class _Allocator>
	size_t
	hash<basic_string<_CharT, _Traits, _Allocator> >::operator()(
	const basic_string<_CharT, _Traits, _Allocator>& __val) const _NOEXCEPT
	{
	return __do_string_hash(__val.data(), __val.data() + __val.size());
	}

	template<class _CharT, class _Traits, class _Allocator>
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os,
	const basic_string<_CharT, _Traits, _Allocator>& __str);

	template<class _CharT, class _Traits, class _Allocator>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __is,
	basic_string<_CharT, _Traits, _Allocator>& __str);

	template<class _CharT, class _Traits, class _Allocator>
	basic_istream<_CharT, _Traits>&
	getline(basic_istream<_CharT, _Traits>& __is,
	basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_istream<_CharT, _Traits>&
	getline(basic_istream<_CharT, _Traits>& __is,
	basic_string<_CharT, _Traits, _Allocator>& __str);

	#ifndef _LIBCPP_CXX03_LANG

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_istream<_CharT, _Traits>&
	getline(basic_istream<_CharT, _Traits>&& __is,
	basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);

	template<class _CharT, class _Traits, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_istream<_CharT, _Traits>&
	getline(basic_istream<_CharT, _Traits>&& __is,
	basic_string<_CharT, _Traits, _Allocator>& __str);

	#endif // _LIBCPP_CXX03_LANG

	#if _LIBCPP_DEBUG_LEVEL >= 2

	template<class _CharT, class _Traits, class _Allocator>
	bool
	basic_string<_CharT, _Traits, _Allocator>::__dereferenceable(const const_iterator* __i) const
	{
	return this->data() <= _VSTD::__to_raw_pointer(__i->base()) &&
	_VSTD::__to_raw_pointer(__i->base()) < this->data() + this->size();
	}

	template<class _CharT, class _Traits, class _Allocator>
	bool
	basic_string<_CharT, _Traits, _Allocator>::__decrementable(const const_iterator* __i) const
	{
	return this->data() < _VSTD::__to_raw_pointer(__i->base()) &&
	_VSTD::__to_raw_pointer(__i->base()) <= this->data() + this->size();
	}

	template<class _CharT, class _Traits, class _Allocator>
	bool
	basic_string<_CharT, _Traits, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const
	{
	const value_type* __p = _VSTD::__to_raw_pointer(__i->base()) + __n;
	return this->data() <= __p && __p <= this->data() + this->size();
	}

	template<class _CharT, class _Traits, class _Allocator>
	bool
	basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const
	{
	const value_type* __p = _VSTD::__to_raw_pointer(__i->base()) + __n;
	return this->data() <= __p && __p < this->data() + this->size();
	}

	#endif // _LIBCPP_DEBUG_LEVEL >= 2

	_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_string<char>)
	_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_string<wchar_t>)

	#if _LIBCPP_STD_VER > 11
	// Literal suffixes for basic_string [basic.string.literals]
	inline namespace literals
	{
	inline namespace string_literals
	{
	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<char> operator "" s( const char *__str, size_t __len )
	{
	return basic_string<char> (__str, __len);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<wchar_t> operator "" s( const wchar_t *__str, size_t __len )
	{
	return basic_string<wchar_t> (__str, __len);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<char16_t> operator "" s( const char16_t *__str, size_t __len )
	{
	return basic_string<char16_t> (__str, __len);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len )
	{
	return basic_string<char32_t> (__str, __len);
	}
	}
	}
	#endif

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_STRING
	Index: projects/clang700-import/contrib/libc++/include/string.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/string.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/string.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/include/string.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/string_view
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/string_view (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/string_view (revision 337135)
	@@ -1,825 +1,827 @@
	// -- C++ --
	//===------------------------ string_view ---------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP_STRING_VIEW
	#define _LIBCPP_STRING_VIEW

	/*
	string_view synopsis

	namespace std {

	// 7.2, Class template basic_string_view
	template<class charT, class traits = char_traits<charT>>
	class basic_string_view;

	// 7.9, basic_string_view non-member comparison functions
	template<class charT, class traits>
	constexpr bool operator==(basic_string_view<charT, traits> x,
	basic_string_view<charT, traits> y) noexcept;
	template<class charT, class traits>
	constexpr bool operator!=(basic_string_view<charT, traits> x,
	basic_string_view<charT, traits> y) noexcept;
	template<class charT, class traits>
	constexpr bool operator< (basic_string_view<charT, traits> x,
	basic_string_view<charT, traits> y) noexcept;
	template<class charT, class traits>
	constexpr bool operator> (basic_string_view<charT, traits> x,
	basic_string_view<charT, traits> y) noexcept;
	template<class charT, class traits>
	constexpr bool operator<=(basic_string_view<charT, traits> x,
	basic_string_view<charT, traits> y) noexcept;
	template<class charT, class traits>
	constexpr bool operator>=(basic_string_view<charT, traits> x,
	basic_string_view<charT, traits> y) noexcept;
	// see below, sufficient additional overloads of comparison functions

	// 7.10, Inserters and extractors
	template<class charT, class traits>
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& os,
	basic_string_view<charT, traits> str);

	// basic_string_view typedef names
	typedef basic_string_view<char> string_view;
	typedef basic_string_view<char16_t> u16string_view;
	typedef basic_string_view<char32_t> u32string_view;
	typedef basic_string_view<wchar_t> wstring_view;

	template<class charT, class traits = char_traits<charT>>
	class basic_string_view {
	public:
	// types
	typedef traits traits_type;
	typedef charT value_type;
	typedef charT* pointer;
	typedef const charT* const_pointer;
	typedef charT& reference;
	typedef const charT& const_reference;
	typedef implementation-defined const_iterator;
	typedef const_iterator iterator;
	typedef reverse_iterator<const_iterator> const_reverse_iterator;
	typedef const_reverse_iterator reverse_iterator;
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;
	static constexpr size_type npos = size_type(-1);

	// 7.3, basic_string_view constructors and assignment operators
	constexpr basic_string_view() noexcept;
	constexpr basic_string_view(const basic_string_view&) noexcept = default;
	basic_string_view& operator=(const basic_string_view&) noexcept = default;
	template<class Allocator>
	constexpr basic_string_view(const charT* str);
	constexpr basic_string_view(const charT* str, size_type len);

	// 7.4, basic_string_view iterator support
	constexpr const_iterator begin() const noexcept;
	constexpr const_iterator end() const noexcept;
	constexpr const_iterator cbegin() const noexcept;
	constexpr const_iterator cend() const noexcept;
	const_reverse_iterator rbegin() const noexcept;
	const_reverse_iterator rend() const noexcept;
	const_reverse_iterator crbegin() const noexcept;
	const_reverse_iterator crend() const noexcept;

	// 7.5, basic_string_view capacity
	constexpr size_type size() const noexcept;
	constexpr size_type length() const noexcept;
	constexpr size_type max_size() const noexcept;
	constexpr bool empty() const noexcept;

	// 7.6, basic_string_view element access
	constexpr const_reference operator[](size_type pos) const;
	constexpr const_reference at(size_type pos) const;
	constexpr const_reference front() const;
	constexpr const_reference back() const;
	constexpr const_pointer data() const noexcept;

	// 7.7, basic_string_view modifiers
	constexpr void remove_prefix(size_type n);
	constexpr void remove_suffix(size_type n);
	constexpr void swap(basic_string_view& s) noexcept;

	size_type copy(charT* s, size_type n, size_type pos = 0) const;

	constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
	constexpr int compare(basic_string_view s) const noexcept;
	constexpr int compare(size_type pos1, size_type n1, basic_string_view s) const;
	constexpr int compare(size_type pos1, size_type n1,
	basic_string_view s, size_type pos2, size_type n2) const;
	constexpr int compare(const charT* s) const;
	constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
	constexpr int compare(size_type pos1, size_type n1,
	const charT* s, size_type n2) const;
	constexpr size_type find(basic_string_view s, size_type pos = 0) const noexcept;
	constexpr size_type find(charT c, size_type pos = 0) const noexcept;
	constexpr size_type find(const charT* s, size_type pos, size_type n) const;
	constexpr size_type find(const charT* s, size_type pos = 0) const;
	constexpr size_type rfind(basic_string_view s, size_type pos = npos) const noexcept;
	constexpr size_type rfind(charT c, size_type pos = npos) const noexcept;
	constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
	constexpr size_type rfind(const charT* s, size_type pos = npos) const;
	constexpr size_type find_first_of(basic_string_view s, size_type pos = 0) const noexcept;
	constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept;
	constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
	constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
	constexpr size_type find_last_of(basic_string_view s, size_type pos = npos) const noexcept;
	constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept;
	constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
	constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
	constexpr size_type find_first_not_of(basic_string_view s, size_type pos = 0) const noexcept;
	constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept;
	constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
	constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const;
	constexpr size_type find_last_not_of(basic_string_view s, size_type pos = npos) const noexcept;
	constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;
	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
	};

	// 7.11, Hash support
	template <class T> struct hash;
	template <> struct hash<string_view>;
	template <> struct hash<u16string_view>;
	template <> struct hash<u32string_view>;
	template <> struct hash<wstring_view>;

	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


	*/

	#include <__config>
	#include <__string>
	#include <algorithm>
	#include <iterator>
	#include <limits>
	#include <stdexcept>
	#include <__debug>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_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 _CharT* pointer;
	typedef const _CharT* const_pointer;
	typedef _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_array<value_type>::value), "Character type of basic_string_view must not be an array");
	+ static_assert(( is_standard_layout<value_type>::value), "Character type of basic_string_view must be standard-layout");
	+ static_assert(( is_trivial<value_type>::value), "Character type of basic_string_view must be trivial");
	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) {}

	_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 _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_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;
	};


	// [string.view.comparison]
	// operator ==
	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 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
	{
	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
	{
	if ( __lhs.size() != __rhs.size()) return false;
	return __lhs.compare(__rhs) == 0;
	}


	// operator !=
	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;
	}

	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
	{
	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
	{
	if ( __lhs.size() != __rhs.size())
	return true;
	return __lhs.compare(__rhs) != 0;
	}


	// operator <
	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;
	}

	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
	{
	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
	{
	return __lhs.compare(__rhs) < 0;
	}


	// operator >
	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;
	}

	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
	{
	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
	{
	return __lhs.compare(__rhs) > 0;
	}


	// operator <=
	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;
	}

	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
	{
	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
	{
	return __lhs.compare(__rhs) <= 0;
	}


	// operator >=
	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;
	}


	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
	{
	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
	{
	return __lhs.compare(__rhs) >= 0;
	}

	typedef basic_string_view<char> string_view;
	typedef basic_string_view<char16_t> u16string_view;
	typedef basic_string_view<char32_t> u32string_view;
	typedef basic_string_view<wchar_t> wstring_view;

	// [string.view.hash]
	template<class _CharT, class _Traits>
	struct _LIBCPP_TEMPLATE_VIS hash<basic_string_view<_CharT, _Traits> >
	: public unary_function<basic_string_view<_CharT, _Traits>, size_t>
	{
	size_t operator()(const basic_string_view<_CharT, _Traits> __val) const _NOEXCEPT;
	};

	template<class _CharT, class _Traits>
	size_t
	hash<basic_string_view<_CharT, _Traits> >::operator()(
	const basic_string_view<_CharT, _Traits> __val) const _NOEXCEPT
	{
	return __do_string_hash(__val.data(), __val.data() + __val.size());
	}


	#if _LIBCPP_STD_VER > 11
	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) _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) _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) _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) _NOEXCEPT
	{
	return basic_string_view<char32_t> (__str, __len);
	}
	}
	}
	#endif
	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_STRING_VIEW
	Index: projects/clang700-import/contrib/libc++/include/system_error
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/system_error (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/system_error (revision 337135)
	@@ -1,673 +1,487 @@
	// -- C++ --
	//===---------------------------- system_error ----------------------------===//
	//
	// 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_SYSTEM_ERROR
	#define _LIBCPP_SYSTEM_ERROR

	/*
	system_error synopsis

	namespace std
	{

	class error_category
	{
	public:
	virtual ~error_category() noexcept;

	constexpr error_category();
	error_category(const error_category&) = delete;
	error_category& operator=(const error_category&) = delete;

	virtual const char* name() const noexcept = 0;
	virtual error_condition default_error_condition(int ev) const noexcept;
	virtual bool equivalent(int code, const error_condition& condition) const noexcept;
	virtual bool equivalent(const error_code& code, int condition) const noexcept;
	virtual string message(int ev) const = 0;

	bool operator==(const error_category& rhs) const noexcept;
	bool operator!=(const error_category& rhs) const noexcept;
	bool operator<(const error_category& rhs) const noexcept;
	};

	const error_category& generic_category() noexcept;
	const error_category& system_category() noexcept;

	template <class T> struct is_error_code_enum
	: public false_type {};

	template <class T> struct is_error_condition_enum
	: public false_type {};

	template <class _Tp>
	inline constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; // C++17

	template <class _Tp>
	inline constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; // C++17

	class error_code
	{
	public:
	// constructors:
	error_code() noexcept;
	error_code(int val, const error_category& cat) noexcept;
	template <class ErrorCodeEnum>
	error_code(ErrorCodeEnum e) noexcept;

	// modifiers:
	void assign(int val, const error_category& cat) noexcept;
	template <class ErrorCodeEnum>
	error_code& operator=(ErrorCodeEnum e) noexcept;
	void clear() noexcept;

	// observers:
	int value() const noexcept;
	const error_category& category() const noexcept;
	error_condition default_error_condition() const noexcept;
	string message() const;
	explicit operator bool() const noexcept;
	};

	// non-member functions:
	bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
	template <class charT, class traits>
	basic_ostream<charT,traits>&
	operator<<(basic_ostream<charT,traits>& os, const error_code& ec);

	class error_condition
	{
	public:
	// constructors:
	error_condition() noexcept;
	error_condition(int val, const error_category& cat) noexcept;
	template <class ErrorConditionEnum>
	error_condition(ErrorConditionEnum e) noexcept;

	// modifiers:
	void assign(int val, const error_category& cat) noexcept;
	template <class ErrorConditionEnum>
	error_condition& operator=(ErrorConditionEnum e) noexcept;
	void clear() noexcept;

	// observers:
	int value() const noexcept;
	const error_category& category() const noexcept;
	string message() const noexcept;
	explicit operator bool() const noexcept;
	};

	bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;

	class system_error
	: public runtime_error
	{
	public:
	system_error(error_code ec, const string& what_arg);
	system_error(error_code ec, const char* what_arg);
	system_error(error_code ec);
	system_error(int ev, const error_category& ecat, const string& what_arg);
	system_error(int ev, const error_category& ecat, const char* what_arg);
	system_error(int ev, const error_category& ecat);

	const error_code& code() const noexcept;
	const char* what() const noexcept;
	};

	-enum class errc
	-{
	- address_family_not_supported, // EAFNOSUPPORT
	- address_in_use, // EADDRINUSE
	- address_not_available, // EADDRNOTAVAIL
	- already_connected, // EISCONN
	- argument_list_too_long, // E2BIG
	- argument_out_of_domain, // EDOM
	- bad_address, // EFAULT
	- bad_file_descriptor, // EBADF
	- bad_message, // EBADMSG
	- broken_pipe, // EPIPE
	- connection_aborted, // ECONNABORTED
	- connection_already_in_progress, // EALREADY
	- connection_refused, // ECONNREFUSED
	- connection_reset, // ECONNRESET
	- cross_device_link, // EXDEV
	- destination_address_required, // EDESTADDRREQ
	- device_or_resource_busy, // EBUSY
	- directory_not_empty, // ENOTEMPTY
	- executable_format_error, // ENOEXEC
	- file_exists, // EEXIST
	- file_too_large, // EFBIG
	- filename_too_long, // ENAMETOOLONG
	- function_not_supported, // ENOSYS
	- host_unreachable, // EHOSTUNREACH
	- identifier_removed, // EIDRM
	- illegal_byte_sequence, // EILSEQ
	- inappropriate_io_control_operation, // ENOTTY
	- interrupted, // EINTR
	- invalid_argument, // EINVAL
	- invalid_seek, // ESPIPE
	- io_error, // EIO
	- is_a_directory, // EISDIR
	- message_size, // EMSGSIZE
	- network_down, // ENETDOWN
	- network_reset, // ENETRESET
	- network_unreachable, // ENETUNREACH
	- no_buffer_space, // ENOBUFS
	- no_child_process, // ECHILD
	- no_link, // ENOLINK
	- no_lock_available, // ENOLCK
	- no_message_available, // ENODATA
	- no_message, // ENOMSG
	- no_protocol_option, // ENOPROTOOPT
	- no_space_on_device, // ENOSPC
	- no_stream_resources, // ENOSR
	- no_such_device_or_address, // ENXIO
	- no_such_device, // ENODEV
	- no_such_file_or_directory, // ENOENT
	- no_such_process, // ESRCH
	- not_a_directory, // ENOTDIR
	- not_a_socket, // ENOTSOCK
	- not_a_stream, // ENOSTR
	- not_connected, // ENOTCONN
	- not_enough_memory, // ENOMEM
	- not_supported, // ENOTSUP
	- operation_canceled, // ECANCELED
	- operation_in_progress, // EINPROGRESS
	- operation_not_permitted, // EPERM
	- operation_not_supported, // EOPNOTSUPP
	- operation_would_block, // EWOULDBLOCK
	- owner_dead, // EOWNERDEAD
	- permission_denied, // EACCES
	- protocol_error, // EPROTO
	- protocol_not_supported, // EPROTONOSUPPORT
	- read_only_file_system, // EROFS
	- resource_deadlock_would_occur, // EDEADLK
	- resource_unavailable_try_again, // EAGAIN
	- result_out_of_range, // ERANGE
	- state_not_recoverable, // ENOTRECOVERABLE
	- stream_timeout, // ETIME
	- text_file_busy, // ETXTBSY
	- timed_out, // ETIMEDOUT
	- too_many_files_open_in_system, // ENFILE
	- too_many_files_open, // EMFILE
	- too_many_links, // EMLINK
	- too_many_symbolic_link_levels, // ELOOP
	- value_too_large, // EOVERFLOW
	- wrong_protocol_type // EPROTOTYPE
	-};
	-
	template <> struct is_error_condition_enum<errc>
	: true_type { }

	error_code make_error_code(errc e) noexcept;
	error_condition make_error_condition(errc e) noexcept;

	// Comparison operators:
	bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
	bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
	bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;
	bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;
	bool operator!=(const error_code& lhs, const error_code& rhs) noexcept;
	bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept;
	bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept;
	bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept;

	template <> struct hash<std::error_code>;
	template <> struct hash<std::error_condition>;

	} // std

	*/

	-#include <__config>
	-#include <cerrno>
	+#include <__errc>
	#include <type_traits>
	#include <stdexcept>
	#include <__functional_base>
	#include <string>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	// is_error_code_enum

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_error_code_enum
	: public false_type {};

	#if _LIBCPP_STD_VER > 14
	template <class _Tp>
	_LIBCPP_INLINE_VAR constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value;
	#endif

	// is_error_condition_enum

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum
	: public false_type {};

	#if _LIBCPP_STD_VER > 14
	template <class _Tp>
	_LIBCPP_INLINE_VAR constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value;
	#endif

	-// Some error codes are not present on all platforms, so we provide equivalents
	-// for them:
	-
	-//enum class errc
	-_LIBCPP_DECLARE_STRONG_ENUM(errc)
	-{
	- address_family_not_supported = EAFNOSUPPORT,
	- address_in_use = EADDRINUSE,
	- address_not_available = EADDRNOTAVAIL,
	- already_connected = EISCONN,
	- argument_list_too_long = E2BIG,
	- argument_out_of_domain = EDOM,
	- bad_address = EFAULT,
	- bad_file_descriptor = EBADF,
	- bad_message = EBADMSG,
	- broken_pipe = EPIPE,
	- connection_aborted = ECONNABORTED,
	- connection_already_in_progress = EALREADY,
	- connection_refused = ECONNREFUSED,
	- connection_reset = ECONNRESET,
	- cross_device_link = EXDEV,
	- destination_address_required = EDESTADDRREQ,
	- device_or_resource_busy = EBUSY,
	- directory_not_empty = ENOTEMPTY,
	- executable_format_error = ENOEXEC,
	- file_exists = EEXIST,
	- file_too_large = EFBIG,
	- filename_too_long = ENAMETOOLONG,
	- function_not_supported = ENOSYS,
	- host_unreachable = EHOSTUNREACH,
	- identifier_removed = EIDRM,
	- illegal_byte_sequence = EILSEQ,
	- inappropriate_io_control_operation = ENOTTY,
	- interrupted = EINTR,
	- invalid_argument = EINVAL,
	- invalid_seek = ESPIPE,
	- io_error = EIO,
	- is_a_directory = EISDIR,
	- message_size = EMSGSIZE,
	- network_down = ENETDOWN,
	- network_reset = ENETRESET,
	- network_unreachable = ENETUNREACH,
	- no_buffer_space = ENOBUFS,
	- no_child_process = ECHILD,
	- no_link = ENOLINK,
	- no_lock_available = ENOLCK,
	-#ifdef ENODATA
	- no_message_available = ENODATA,
	-#else
	- no_message_available = ENOMSG,
	-#endif
	- no_message = ENOMSG,
	- no_protocol_option = ENOPROTOOPT,
	- no_space_on_device = ENOSPC,
	-#ifdef ENOSR
	- no_stream_resources = ENOSR,
	-#else
	- no_stream_resources = ENOMEM,
	-#endif
	- no_such_device_or_address = ENXIO,
	- no_such_device = ENODEV,
	- no_such_file_or_directory = ENOENT,
	- no_such_process = ESRCH,
	- not_a_directory = ENOTDIR,
	- not_a_socket = ENOTSOCK,
	-#ifdef ENOSTR
	- not_a_stream = ENOSTR,
	-#else
	- not_a_stream = EINVAL,
	-#endif
	- not_connected = ENOTCONN,
	- not_enough_memory = ENOMEM,
	- not_supported = ENOTSUP,
	- operation_canceled = ECANCELED,
	- operation_in_progress = EINPROGRESS,
	- operation_not_permitted = EPERM,
	- operation_not_supported = EOPNOTSUPP,
	- operation_would_block = EWOULDBLOCK,
	- owner_dead = EOWNERDEAD,
	- permission_denied = EACCES,
	- protocol_error = EPROTO,
	- protocol_not_supported = EPROTONOSUPPORT,
	- read_only_file_system = EROFS,
	- resource_deadlock_would_occur = EDEADLK,
	- resource_unavailable_try_again = EAGAIN,
	- result_out_of_range = ERANGE,
	- state_not_recoverable = ENOTRECOVERABLE,
	-#ifdef ETIME
	- stream_timeout = ETIME,
	-#else
	- stream_timeout = ETIMEDOUT,
	-#endif
	- text_file_busy = ETXTBSY,
	- timed_out = ETIMEDOUT,
	- too_many_files_open_in_system = ENFILE,
	- too_many_files_open = EMFILE,
	- too_many_links = EMLINK,
	- too_many_symbolic_link_levels = ELOOP,
	- value_too_large = EOVERFLOW,
	- wrong_protocol_type = EPROTOTYPE
	-};
	-_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(errc)
	-
	template <>
	struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc>
	: true_type { };

	#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
	template <>
	struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx>
	: true_type { };
	#endif

	class _LIBCPP_TYPE_VIS error_condition;
	class _LIBCPP_TYPE_VIS error_code;

	// class error_category

	class _LIBCPP_HIDDEN __do_message;

	class _LIBCPP_TYPE_VIS error_category
	{
	public:
	virtual ~error_category() _NOEXCEPT;

	#if defined(_LIBCPP_BUILDING_SYSTEM_ERROR) && \
	defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
	error_category() _NOEXCEPT;
	#else
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR_AFTER_CXX11 error_category() _NOEXCEPT _LIBCPP_DEFAULT
	#endif
	private:
	error_category(const error_category&);// = delete;
	error_category& operator=(const error_category&);// = delete;

	public:
	virtual const char* name() const _NOEXCEPT = 0;
	virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
	virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
	virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
	virtual string message(int __ev) const = 0;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}

	friend class _LIBCPP_HIDDEN __do_message;
	};

	class _LIBCPP_HIDDEN __do_message
	: public error_category
	{
	public:
	virtual string message(int ev) const;
	};

	_LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
	_LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT;

	class _LIBCPP_TYPE_VIS error_condition
	{
	int __val_;
	const error_category* __cat_;
	public:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	error_condition(int __val, const error_category& __cat) _NOEXCEPT
	: __val_(__val), __cat_(&__cat) {}

	template <class _Ep>
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	error_condition(_Ep __e,
	typename enable_if<is_error_condition_enum<_Ep>::value>::type* = 0
	) _NOEXCEPT
	{*this = make_error_condition(__e);}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void assign(int __val, const error_category& __cat) _NOEXCEPT
	{
	__val_ = __val;
	__cat_ = &__cat;
	}

	template <class _Ep>
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_error_condition_enum<_Ep>::value,
	error_condition&
	>::type
	operator=(_Ep __e) _NOEXCEPT
	{this = make_error_condition(__e); return this;}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void clear() _NOEXCEPT
	{
	__val_ = 0;
	__cat_ = &generic_category();
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	int value() const _NOEXCEPT {return __val_;}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const error_category& category() const _NOEXCEPT {return *__cat_;}
	string message() const;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_EXPLICIT
	operator bool() const _NOEXCEPT {return __val_ != 0;}
	};

	inline _LIBCPP_INLINE_VISIBILITY
	error_condition
	make_error_condition(errc __e) _NOEXCEPT
	{
	return error_condition(static_cast<int>(__e), generic_category());
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
	{
	return __x.category() < __y.category()
	\|\| (__x.category() == __y.category() && __x.value() < __y.value());
	}

	// error_code

	class _LIBCPP_TYPE_VIS error_code
	{
	int __val_;
	const error_category* __cat_;
	public:
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	error_code(int __val, const error_category& __cat) _NOEXCEPT
	: __val_(__val), __cat_(&__cat) {}

	template <class _Ep>
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	error_code(_Ep __e,
	typename enable_if<is_error_code_enum<_Ep>::value>::type* = 0
	) _NOEXCEPT
	{*this = make_error_code(__e);}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void assign(int __val, const error_category& __cat) _NOEXCEPT
	{
	__val_ = __val;
	__cat_ = &__cat;
	}

	template <class _Ep>
	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	is_error_code_enum<_Ep>::value,
	error_code&
	>::type
	operator=(_Ep __e) _NOEXCEPT
	{this = make_error_code(__e); return this;}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	void clear() _NOEXCEPT
	{
	__val_ = 0;
	__cat_ = &system_category();
	}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	int value() const _NOEXCEPT {return __val_;}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const error_category& category() const _NOEXCEPT {return *__cat_;}

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	error_condition default_error_condition() const _NOEXCEPT
	{return __cat_->default_error_condition(__val_);}

	string message() const;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_EXPLICIT
	operator bool() const _NOEXCEPT {return __val_ != 0;}
	};

	inline _LIBCPP_INLINE_VISIBILITY
	error_code
	make_error_code(errc __e) _NOEXCEPT
	{
	return error_code(static_cast<int>(__e), generic_category());
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
	{
	return __x.category() < __y.category()
	\|\| (__x.category() == __y.category() && __x.value() < __y.value());
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
	{
	return __x.category() == __y.category() && __x.value() == __y.value();
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
	{
	return __x.category().equivalent(__x.value(), __y)
	\|\| __y.category().equivalent(__x, __y.value());
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
	{
	return __y == __x;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
	{
	return __x.category() == __y.category() && __x.value() == __y.value();
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
	{return !(__x == __y);}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
	{return !(__x == __y);}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
	{return !(__x == __y);}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
	{return !(__x == __y);}

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<error_code>
	: public unary_function<error_code, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(const error_code& __ec) const _NOEXCEPT
	{
	return static_cast<size_t>(__ec.value());
	}
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<error_condition>
	: public unary_function<error_condition, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(const error_condition& __ec) const _NOEXCEPT
	{
	return static_cast<size_t>(__ec.value());
	}
	};

	// system_error

	class _LIBCPP_TYPE_VIS system_error
	: public runtime_error
	{
	error_code __ec_;
	public:
	system_error(error_code __ec, const string& __what_arg);
	system_error(error_code __ec, const char* __what_arg);
	system_error(error_code __ec);
	system_error(int __ev, const error_category& __ecat, const string& __what_arg);
	system_error(int __ev, const error_category& __ecat, const char* __what_arg);
	system_error(int __ev, const error_category& __ecat);
	~system_error() _NOEXCEPT;

	- _LIBCPP_ALWAYS_INLINE
	+ _LIBCPP_INLINE_VISIBILITY
	const error_code& code() const _NOEXCEPT {return __ec_;}

	private:
	static string __init(const error_code&, string);
	};

	_LIBCPP_NORETURN _LIBCPP_FUNC_VIS
	void __throw_system_error(int ev, const char* what_arg);

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_SYSTEM_ERROR
	Index: projects/clang700-import/contrib/libc++/include/tgmath.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/tgmath.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/tgmath.h (revision 337135)
	@@ -1,29 +1,37 @@
	// -- C++ --
	//===-------------------------- tgmath.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_TGMATH_H
	#define _LIBCPP_TGMATH_H

	/*
	tgmath.h synopsis

	-#include <complex.h>
	-#include <math.h>
	+#include <ctgmath>

	*/

	-#include <complex.h>
	-#include <math.h>
	+#include <__config>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif
	+
	+#ifdef __cplusplus
	+
	+#include <ctgmath>
	+
	+#else // __cplusplus
	+
	+#include_next <tgmath.h>
	+
	+#endif // __cplusplus

	#endif // _LIBCPP_TGMATH_H

	Property changes on: projects/clang700-import/contrib/libc++/include/tgmath.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/thread
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/thread (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/thread (revision 337135)
	@@ -1,484 +1,484 @@
	// -- C++ --
	//===--------------------------- thread -----------------------------------===//
	//
	// 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_THREAD
	#define _LIBCPP_THREAD

	/*

	thread synopsis

	#define __STDCPP_THREADS__ __cplusplus

	namespace std
	{

	class thread
	{
	public:
	class id;
	typedef pthread_t native_handle_type;

	thread() noexcept;
	template <class F, class ...Args> explicit thread(F&& f, Args&&... args);
	~thread();

	thread(const thread&) = delete;
	thread(thread&& t) noexcept;

	thread& operator=(const thread&) = delete;
	thread& operator=(thread&& t) noexcept;

	void swap(thread& t) noexcept;

	bool joinable() const noexcept;
	void join();
	void detach();
	id get_id() const noexcept;
	native_handle_type native_handle();

	static unsigned hardware_concurrency() noexcept;
	};

	void swap(thread& x, thread& y) noexcept;

	class thread::id
	{
	public:
	id() noexcept;
	};

	bool operator==(thread::id x, thread::id y) noexcept;
	bool operator!=(thread::id x, thread::id y) noexcept;
	bool operator< (thread::id x, thread::id y) noexcept;
	bool operator<=(thread::id x, thread::id y) noexcept;
	bool operator> (thread::id x, thread::id y) noexcept;
	bool operator>=(thread::id x, thread::id y) noexcept;

	template<class charT, class traits>
	basic_ostream<charT, traits>&
	operator<<(basic_ostream<charT, traits>& out, thread::id id);

	namespace this_thread
	{

	thread::id get_id() noexcept;

	void yield() noexcept;

	template <class Clock, class Duration>
	void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);

	template <class Rep, class Period>
	void sleep_for(const chrono::duration<Rep, Period>& rel_time);

	} // this_thread

	} // std

	*/

	#include <__config>
	#include <iosfwd>
	#include <__functional_base>
	#include <type_traits>
	#include <cstddef>
	#include <functional>
	#include <memory>
	#include <system_error>
	#include <chrono>
	#include <__mutex_base>
	#ifndef _LIBCPP_CXX03_LANG
	#include <tuple>
	#endif
	#include <__threading_support>
	#include <__debug>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>

	#define __STDCPP_THREADS__ __cplusplus

	#ifdef _LIBCPP_HAS_NO_THREADS
	#error <thread> is not supported on this single threaded system
	#else // !_LIBCPP_HAS_NO_THREADS

	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _Tp> class __thread_specific_ptr;
	class _LIBCPP_TYPE_VIS __thread_struct;
	class _LIBCPP_HIDDEN __thread_struct_imp;
	class __assoc_sub_state;

	_LIBCPP_FUNC_VIS __thread_specific_ptr<__thread_struct>& __thread_local_data();

	class _LIBCPP_TYPE_VIS __thread_struct
	{
	__thread_struct_imp* __p_;

	__thread_struct(const __thread_struct&);
	__thread_struct& operator=(const __thread_struct&);
	public:
	__thread_struct();
	~__thread_struct();

	void notify_all_at_thread_exit(condition_variable, mutex);
	void __make_ready_at_thread_exit(__assoc_sub_state*);
	};

	template <class _Tp>
	class __thread_specific_ptr
	{
	__libcpp_tls_key __key_;

	// Only __thread_local_data() may construct a __thread_specific_ptr
	// and only with _Tp == __thread_struct.
	static_assert((is_same<_Tp, __thread_struct>::value), "");
	__thread_specific_ptr();
	friend _LIBCPP_FUNC_VIS __thread_specific_ptr<__thread_struct>& __thread_local_data();

	__thread_specific_ptr(const __thread_specific_ptr&);
	__thread_specific_ptr& operator=(const __thread_specific_ptr&);

	static void _LIBCPP_TLS_DESTRUCTOR_CC __at_thread_exit(void*);

	public:
	typedef _Tp* pointer;

	~__thread_specific_ptr();

	_LIBCPP_INLINE_VISIBILITY
	pointer get() const {return static_cast<_Tp*>(__libcpp_tls_get(__key_));}
	_LIBCPP_INLINE_VISIBILITY
	pointer operator() const {return get();}
	_LIBCPP_INLINE_VISIBILITY
	pointer operator->() const {return get();}
	void set_pointer(pointer __p);
	};

	template <class _Tp>
	void _LIBCPP_TLS_DESTRUCTOR_CC
	__thread_specific_ptr<_Tp>::__at_thread_exit(void* __p)
	{
	delete static_cast<pointer>(__p);
	}

	template <class _Tp>
	__thread_specific_ptr<_Tp>::__thread_specific_ptr()
	{
	int __ec =
	__libcpp_tls_create(&__key_, &__thread_specific_ptr::__at_thread_exit);
	if (__ec)
	__throw_system_error(__ec, "__thread_specific_ptr construction failed");
	}

	template <class _Tp>
	__thread_specific_ptr<_Tp>::~__thread_specific_ptr()
	{
	// __thread_specific_ptr is only created with a static storage duration
	// so this destructor is only invoked during program termination. Invoking
	// pthread_key_delete(__key_) may prevent other threads from deleting their
	// thread local data. For this reason we leak the key.
	}

	template <class _Tp>
	void
	__thread_specific_ptr<_Tp>::set_pointer(pointer __p)
	{
	_LIBCPP_ASSERT(get() == nullptr,
	"Attempting to overwrite thread local data");
	__libcpp_tls_set(__key_, __p);
	}

	class _LIBCPP_TYPE_VIS thread;
	class _LIBCPP_TYPE_VIS __thread_id;

	namespace this_thread
	{

	_LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;

	} // this_thread

	template<> struct hash<__thread_id>;

	class _LIBCPP_TEMPLATE_VIS __thread_id
	{
	// FIXME: pthread_t is a pointer on Darwin but a long on Linux.
	// NULL is the no-thread value on Darwin. Someone needs to check
	// on other platforms. We assume 0 works everywhere for now.
	__libcpp_thread_id __id_;

	public:
	_LIBCPP_INLINE_VISIBILITY
	__thread_id() _NOEXCEPT : __id_(0) {}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT
	{return __libcpp_thread_id_equal(__x.__id_, __y.__id_);}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(__thread_id __x, __thread_id __y) _NOEXCEPT
	{return !(__x == __y);}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator< (__thread_id __x, __thread_id __y) _NOEXCEPT
	{return __libcpp_thread_id_less(__x.__id_, __y.__id_);}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator<=(__thread_id __x, __thread_id __y) _NOEXCEPT
	{return !(__y < __x);}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator> (__thread_id __x, __thread_id __y) _NOEXCEPT
	{return __y < __x ;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator>=(__thread_id __x, __thread_id __y) _NOEXCEPT
	{return !(__x < __y);}

	template<class _CharT, class _Traits>
	friend
	_LIBCPP_INLINE_VISIBILITY
	basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id)
	{return __os << __id.__id_;}

	private:
	_LIBCPP_INLINE_VISIBILITY
	__thread_id(__libcpp_thread_id __id) : __id_(__id) {}

	friend __thread_id this_thread::get_id() _NOEXCEPT;
	friend class _LIBCPP_TYPE_VIS thread;
	friend struct _LIBCPP_TEMPLATE_VIS hash<__thread_id>;
	};

	template<>
	struct _LIBCPP_TEMPLATE_VIS hash<__thread_id>
	: public unary_function<__thread_id, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(__thread_id __v) const _NOEXCEPT
	{
	return hash<__libcpp_thread_id>()(__v.__id_);
	}
	};

	namespace this_thread
	{

	inline _LIBCPP_INLINE_VISIBILITY
	__thread_id
	get_id() _NOEXCEPT
	{
	return __libcpp_thread_get_current_id();
	}

	} // this_thread

	class _LIBCPP_TYPE_VIS thread
	{
	__libcpp_thread_t __t_;

	thread(const thread&);
	thread& operator=(const thread&);
	public:
	typedef __thread_id id;
	typedef __libcpp_thread_t native_handle_type;

	_LIBCPP_INLINE_VISIBILITY
	thread() _NOEXCEPT : __t_(_LIBCPP_NULL_THREAD) {}
	#ifndef _LIBCPP_CXX03_LANG
	template <class _Fp, class ..._Args,
	class = typename enable_if
	<
	- !is_same<typename decay<_Fp>::type, thread>::value
	+ !is_same<typename __uncvref<_Fp>::type, thread>::value
	>::type
	>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	explicit thread(_Fp&& __f, _Args&&... __args);
	#else // _LIBCPP_CXX03_LANG
	template <class _Fp>
	_LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
	explicit thread(_Fp __f);
	#endif
	~thread();

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) {__t.__t_ = _LIBCPP_NULL_THREAD;}
	_LIBCPP_INLINE_VISIBILITY
	thread& operator=(thread&& __t) _NOEXCEPT;
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);}

	_LIBCPP_INLINE_VISIBILITY
	bool joinable() const _NOEXCEPT {return !__libcpp_thread_isnull(&__t_);}
	void join();
	void detach();
	_LIBCPP_INLINE_VISIBILITY
	id get_id() const _NOEXCEPT {return __libcpp_thread_get_id(&__t_);}
	_LIBCPP_INLINE_VISIBILITY
	native_handle_type native_handle() _NOEXCEPT {return __t_;}

	static unsigned hardware_concurrency() _NOEXCEPT;
	};

	#ifndef _LIBCPP_CXX03_LANG

	template <class _TSp, class _Fp, class ..._Args, size_t ..._Indices>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	__thread_execute(tuple<_TSp, _Fp, _Args...>& __t, __tuple_indices<_Indices...>)
	{
	__invoke(_VSTD::move(_VSTD::get<1>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...);
	}

	template <class _Fp>
	void* __thread_proxy(void* __vp)
	{
	// _Fp = std::tuple< unique_ptr<__thread_struct>, Functor, Args...>
	std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
	__thread_local_data().set_pointer(_VSTD::get<0>(*__p).release());
	typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 2>::type _Index;
	__thread_execute(*__p, _Index());
	return nullptr;
	}

	template <class _Fp, class ..._Args,
	class
	>
	thread::thread(_Fp&& __f, _Args&&... __args)
	{
	typedef unique_ptr<__thread_struct> _TSPtr;
	_TSPtr __tsp(new __thread_struct);
	typedef tuple<_TSPtr, typename decay<_Fp>::type, typename decay<_Args>::type...> _Gp;
	_VSTD::unique_ptr<_Gp> __p(
	new _Gp(std::move(__tsp),
	__decay_copy(_VSTD::forward<_Fp>(__f)),
	__decay_copy(_VSTD::forward<_Args>(__args))...));
	int __ec = __libcpp_thread_create(&__t_, &__thread_proxy<_Gp>, __p.get());
	if (__ec == 0)
	__p.release();
	else
	__throw_system_error(__ec, "thread constructor failed");
	}

	inline
	thread&
	thread::operator=(thread&& __t) _NOEXCEPT
	{
	if (!__libcpp_thread_isnull(&__t_))
	terminate();
	__t_ = __t.__t_;
	__t.__t_ = _LIBCPP_NULL_THREAD;
	return *this;
	}

	#else // _LIBCPP_CXX03_LANG

	template <class _Fp>
	struct __thread_invoke_pair {
	// This type is used to pass memory for thread local storage and a functor
	// to a newly created thread because std::pair doesn't work with
	// std::unique_ptr in C++03.
	__thread_invoke_pair(_Fp& __f) : __tsp_(new __thread_struct), __fn_(__f) {}
	unique_ptr<__thread_struct> __tsp_;
	_Fp __fn_;
	};

	template <class _Fp>
	void* __thread_proxy_cxx03(void* __vp)
	{
	std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
	__thread_local_data().set_pointer(__p->__tsp_.release());
	(__p->__fn_)();
	return nullptr;
	}

	template <class _Fp>
	thread::thread(_Fp __f)
	{

	typedef __thread_invoke_pair<_Fp> _InvokePair;
	typedef std::unique_ptr<_InvokePair> _PairPtr;
	_PairPtr __pp(new _InvokePair(__f));
	int __ec = __libcpp_thread_create(&__t_, &__thread_proxy_cxx03<_InvokePair>, __pp.get());
	if (__ec == 0)
	__pp.release();
	else
	__throw_system_error(__ec, "thread constructor failed");
	}

	#endif // _LIBCPP_CXX03_LANG

	inline _LIBCPP_INLINE_VISIBILITY
	void swap(thread& __x, thread& __y) _NOEXCEPT {__x.swap(__y);}

	namespace this_thread
	{

	_LIBCPP_FUNC_VIS void sleep_for(const chrono::nanoseconds& __ns);

	template <class _Rep, class _Period>
	void
	sleep_for(const chrono::duration<_Rep, _Period>& __d)
	{
	using namespace chrono;
	if (__d > duration<_Rep, _Period>::zero())
	{
	_LIBCPP_CONSTEXPR duration<long double> _Max = nanoseconds::max();
	nanoseconds __ns;
	if (__d < _Max)
	{
	__ns = duration_cast<nanoseconds>(__d);
	if (__ns < __d)
	++__ns;
	}
	else
	__ns = nanoseconds::max();
	sleep_for(__ns);
	}
	}

	template <class _Clock, class _Duration>
	void
	sleep_until(const chrono::time_point<_Clock, _Duration>& __t)
	{
	using namespace chrono;
	mutex __mut;
	condition_variable __cv;
	unique_lock<mutex> __lk(__mut);
	while (_Clock::now() < __t)
	__cv.wait_until(__lk, __t);
	}

	template <class _Duration>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t)
	{
	using namespace chrono;
	sleep_for(__t - steady_clock::now());
	}

	inline _LIBCPP_INLINE_VISIBILITY
	void yield() _NOEXCEPT {__libcpp_thread_yield();}

	} // this_thread

	_LIBCPP_END_NAMESPACE_STD

	#endif // !_LIBCPP_HAS_NO_THREADS

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_THREAD
	Index: projects/clang700-import/contrib/libc++/include/tuple
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/tuple (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/tuple (revision 337135)
	@@ -1,1417 +1,1412 @@
	// -- C++ --
	//===--------------------------- tuple ------------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP_TUPLE
	#define _LIBCPP_TUPLE

	/*
	tuple synopsis

	namespace std
	{

	template <class... T>
	class tuple {
	public:
	constexpr tuple();
	explicit tuple(const T&...); // constexpr in C++14
	template <class... U>
	explicit tuple(U&&...); // constexpr in C++14
	tuple(const tuple&) = default;
	tuple(tuple&&) = default;
	template <class... U>
	tuple(const tuple<U...>&); // constexpr in C++14
	template <class... U>
	tuple(tuple<U...>&&); // constexpr in C++14
	template <class U1, class U2>
	tuple(const pair<U1, U2>&); // iff sizeof...(T) == 2 // constexpr in C++14
	template <class U1, class U2>
	tuple(pair<U1, U2>&&); // iff sizeof...(T) == 2 // constexpr in C++14

	// allocator-extended constructors
	template <class Alloc>
	tuple(allocator_arg_t, const Alloc& a);
	template <class Alloc>
	tuple(allocator_arg_t, const Alloc& a, const T&...);
	template <class Alloc, class... U>
	tuple(allocator_arg_t, const Alloc& a, U&&...);
	template <class Alloc>
	tuple(allocator_arg_t, const Alloc& a, const tuple&);
	template <class Alloc>
	tuple(allocator_arg_t, const Alloc& a, tuple&&);
	template <class Alloc, class... U>
	tuple(allocator_arg_t, const Alloc& a, const tuple<U...>&);
	template <class Alloc, class... U>
	tuple(allocator_arg_t, const Alloc& a, tuple<U...>&&);
	template <class Alloc, class U1, class U2>
	tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
	template <class Alloc, class U1, class U2>
	tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);

	tuple& operator=(const tuple&);
	tuple&
	operator=(tuple&&) noexcept(AND(is_nothrow_move_assignable<T>::value ...));
	template <class... U>
	tuple& operator=(const tuple<U...>&);
	template <class... U>
	tuple& operator=(tuple<U...>&&);
	template <class U1, class U2>
	tuple& operator=(const pair<U1, U2>&); // iff sizeof...(T) == 2
	template <class U1, class U2>
	tuple& operator=(pair<U1, U2>&&); //iffsizeof...(T) == 2

	void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...));
	};

	inline constexpr unspecified ignore;

	template <class... T> tuple<V...> make_tuple(T&&...); // constexpr in C++14
	template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept; // constexpr in C++14
	template <class... T> tuple<T&...> tie(T&...) noexcept; // constexpr in C++14
	template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls); // constexpr in C++14

	// [tuple.apply], calling a function with a tuple of arguments:
	template <class F, class Tuple>
	constexpr decltype(auto) apply(F&& f, Tuple&& t); // C++17
	template <class T, class Tuple>
	constexpr T make_from_tuple(Tuple&& t); // C++17

	// 20.4.1.4, tuple helper classes:
	template <class T> class tuple_size; // undefined
	template <class... T> class tuple_size<tuple<T...>>;
	template <class T>
	inline constexpr size_t tuple_size_v = tuple_size<T>::value; // C++17
	template <size_t I, class T> class tuple_element; // undefined
	template <size_t I, class... T> class tuple_element<I, tuple<T...>>;
	template <size_t I, class T>
	using tuple_element_t = typename tuple_element <I, T>::type; // C++14

	// 20.4.1.5, element access:
	template <size_t I, class... T>
	typename tuple_element<I, tuple<T...>>::type&
	get(tuple<T...>&) noexcept; // constexpr in C++14
	template <size_t I, class... T>
	const typename tuple_element<I, tuple<T...>>::type&
	get(const tuple<T...>&) noexcept; // constexpr in C++14
	template <size_t I, class... T>
	typename tuple_element<I, tuple<T...>>::type&&
	get(tuple<T...>&&) noexcept; // constexpr in C++14
	template <size_t I, class... T>
	const typename tuple_element<I, tuple<T...>>::type&&
	get(const tuple<T...>&&) noexcept; // constexpr in C++14

	template <class T1, class... T>
	constexpr T1& get(tuple<T...>&) noexcept; // C++14
	template <class T1, class... T>
	constexpr const T1& get(const tuple<T...>&) noexcept; // C++14
	template <class T1, class... T>
	constexpr T1&& get(tuple<T...>&&) noexcept; // C++14
	template <class T1, class... T>
	constexpr const T1&& get(const tuple<T...>&&) noexcept; // C++14

	// 20.4.1.6, relational operators:
	template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
	template<class... T, class... U> bool operator<(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
	template<class... T, class... U> bool operator!=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
	template<class... T, class... U> bool operator>(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
	template<class... T, class... U> bool operator<=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14
	template<class... T, class... U> bool operator>=(const tuple<T...>&, const tuple<U...>&); // constexpr in C++14

	template <class... Types, class Alloc>
	struct uses_allocator<tuple<Types...>, Alloc>;

	template <class... Types>
	void
	swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y)));

	} // std

	*/

	#include <__config>
	#include <__tuple>
	#include <cstddef>
	#include <type_traits>
	#include <__functional_base>
	#include <utility>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	#ifndef _LIBCPP_CXX03_LANG


	// __tuple_leaf

	template <size_t _Ip, class _Hp,
	bool=is_empty<_Hp>::value && !__libcpp_is_final<_Hp>::value
	>
	class __tuple_leaf;

	template <size_t _Ip, class _Hp, bool _Ep>
	inline _LIBCPP_INLINE_VISIBILITY
	void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
	_NOEXCEPT_(__is_nothrow_swappable<_Hp>::value)
	{
	swap(__x.get(), __y.get());
	}

	template <size_t _Ip, class _Hp, bool>
	class __tuple_leaf
	{
	_Hp __value_;

	template <class _Tp>
	static constexpr bool __can_bind_reference() {
	- using _RawTp = typename remove_reference<_Tp>::type;
	- using _RawHp = typename remove_reference<_Hp>::type;
	- using _CheckLValueArg = integral_constant<bool,
	- is_lvalue_reference<_Tp>::value
	- \|\| is_same<_RawTp, reference_wrapper<_RawHp>>::value
	- \|\| is_same<_RawTp, reference_wrapper<typename remove_const<_RawHp>::type>>::value
	- >;
	- return !is_reference<_Hp>::value
	- \|\| (is_lvalue_reference<_Hp>::value && _CheckLValueArg::value)
	- \|\| (is_rvalue_reference<_Hp>::value && !is_lvalue_reference<_Tp>::value);
	+#if __has_keyword(__reference_binds_to_temporary)
	+ return !__reference_binds_to_temporary(_Hp, _Tp);
	+#else
	+ return true;
	+#endif
	}

	__tuple_leaf& operator=(const __tuple_leaf&);
	public:
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
	_NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : __value_()
	{static_assert(!is_reference<_Hp>::value,
	"Attempted to default construct a reference element in a tuple");}

	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	__tuple_leaf(integral_constant<int, 0>, const _Alloc&)
	: __value_()
	{static_assert(!is_reference<_Hp>::value,
	"Attempted to default construct a reference element in a tuple");}

	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	__tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
	: __value_(allocator_arg_t(), __a)
	{static_assert(!is_reference<_Hp>::value,
	"Attempted to default construct a reference element in a tuple");}

	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	__tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
	: __value_(__a)
	{static_assert(!is_reference<_Hp>::value,
	"Attempted to default construct a reference element in a tuple");}

	template <class _Tp,
	class = typename enable_if<
	__lazy_and<
	- __lazy_not<is_same<typename decay<_Tp>::type, __tuple_leaf>>
	+ __lazy_not<is_same<typename __uncvref<_Tp>::type, __tuple_leaf>>
	, is_constructible<_Hp, _Tp>
	>::value
	>::type
	>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
	: __value_(_VSTD::forward<_Tp>(__t))
	- {static_assert(__can_bind_reference<_Tp>(),
	- "Attempted to construct a reference element in a tuple with an rvalue");}
	+ {static_assert(__can_bind_reference<_Tp&&>(),
	+ "Attempted construction of reference element binds to a temporary whose lifetime has ended");}

	template <class _Tp, class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
	: __value_(_VSTD::forward<_Tp>(__t))
	- {static_assert(__can_bind_reference<_Tp>(),
	- "Attempted to construct a reference element in a tuple with an rvalue");}
	+ {static_assert(__can_bind_reference<_Tp&&>(),
	+ "Attempted construction of reference element binds to a temporary whose lifetime has ended");}

	template <class _Tp, class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
	: __value_(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
	{static_assert(!is_reference<_Hp>::value,
	"Attempted to uses-allocator construct a reference element in a tuple");}

	template <class _Tp, class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
	: __value_(_VSTD::forward<_Tp>(__t), __a)
	{static_assert(!is_reference<_Hp>::value,
	"Attempted to uses-allocator construct a reference element in a tuple");}

	__tuple_leaf(const __tuple_leaf& __t) = default;
	__tuple_leaf(__tuple_leaf&& __t) = default;

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	__tuple_leaf&
	operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
	{
	__value_ = _VSTD::forward<_Tp>(__t);
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
	{
	_VSTD::swap(*this, __t);
	return 0;
	}

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Hp& get() _NOEXCEPT {return __value_;}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return __value_;}
	};

	template <size_t _Ip, class _Hp>
	class __tuple_leaf<_Ip, _Hp, true>
	: private _Hp
	{

	__tuple_leaf& operator=(const __tuple_leaf&);
	public:
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
	_NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) {}

	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	__tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}

	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	__tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
	: _Hp(allocator_arg_t(), __a) {}

	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	__tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
	: _Hp(__a) {}

	template <class _Tp,
	class = typename enable_if<
	__lazy_and<
	- __lazy_not<is_same<typename decay<_Tp>::type, __tuple_leaf>>
	+ __lazy_not<is_same<typename __uncvref<_Tp>::type, __tuple_leaf>>
	, is_constructible<_Hp, _Tp>
	>::value
	>::type
	>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
	: _Hp(_VSTD::forward<_Tp>(__t)) {}

	template <class _Tp, class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
	: _Hp(_VSTD::forward<_Tp>(__t)) {}

	template <class _Tp, class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
	: _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}

	template <class _Tp, class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
	: _Hp(_VSTD::forward<_Tp>(__t), __a) {}

	__tuple_leaf(__tuple_leaf const &) = default;
	__tuple_leaf(__tuple_leaf &&) = default;

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	__tuple_leaf&
	operator=(_Tp&& __t) _NOEXCEPT_((is_nothrow_assignable<_Hp&, _Tp>::value))
	{
	_Hp::operator=(_VSTD::forward<_Tp>(__t));
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	int
	swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
	{
	_VSTD::swap(*this, __t);
	return 0;
	}

	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _Hp& get() _NOEXCEPT {return static_cast<_Hp&>(*this);}
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);}
	};

	template <class ..._Tp>
	_LIBCPP_INLINE_VISIBILITY
	void __swallow(_Tp&&...) _NOEXCEPT {}

	template <class ..._Tp>
	struct __lazy_all : __all<_Tp::value...> {};

	template <class _Tp>
	struct __all_default_constructible;

	template <class ..._Tp>
	struct __all_default_constructible<__tuple_types<_Tp...>>
	: __all<is_default_constructible<_Tp>::value...>
	{ };

	// __tuple_impl

	template<class _Indx, class ..._Tp> struct __tuple_impl;

	template<size_t ..._Indx, class ..._Tp>
	struct _LIBCPP_DECLSPEC_EMPTY_BASES __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
	: public __tuple_leaf<_Indx, _Tp>...
	{
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR __tuple_impl()
	_NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}

	template <size_t ..._Uf, class ..._Tf,
	size_t ..._Ul, class ..._Tl, class ..._Up>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	explicit
	__tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
	__tuple_indices<_Ul...>, __tuple_types<_Tl...>,
	_Up&&... __u)
	_NOEXCEPT_((__all<is_nothrow_constructible<_Tf, _Up>::value...>::value &&
	__all<is_nothrow_default_constructible<_Tl>::value...>::value)) :
	__tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))...,
	__tuple_leaf<_Ul, _Tl>()...
	{}

	template <class _Alloc, size_t ..._Uf, class ..._Tf,
	size_t ..._Ul, class ..._Tl, class ..._Up>
	_LIBCPP_INLINE_VISIBILITY
	explicit
	__tuple_impl(allocator_arg_t, const _Alloc& __a,
	__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
	__tuple_indices<_Ul...>, __tuple_types<_Tl...>,
	_Up&&... __u) :
	__tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
	_VSTD::forward<_Up>(__u))...,
	__tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
	{}

	template <class _Tuple,
	class = typename enable_if
	<
	__tuple_constructible<_Tuple, tuple<_Tp...> >::value
	>::type
	>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	__tuple_impl(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_constructible<_Tp, typename tuple_element<_Indx,
	typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
	: __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
	typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
	{}

	template <class _Alloc, class _Tuple,
	class = typename enable_if
	<
	__tuple_constructible<_Tuple, tuple<_Tp...> >::value
	>::type
	>
	_LIBCPP_INLINE_VISIBILITY
	__tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
	: __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
	typename __make_tuple_types<_Tuple>::type>::type>(), __a,
	_VSTD::forward<typename tuple_element<_Indx,
	typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
	{}

	template <class _Tuple>
	_LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__tuple_assignable<_Tuple, tuple<_Tp...> >::value,
	__tuple_impl&
	>::type
	operator=(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_assignable<_Tp&, typename tuple_element<_Indx,
	typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
	{
	__swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<typename tuple_element<_Indx,
	typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...);
	return *this;
	}

	__tuple_impl(const __tuple_impl&) = default;
	__tuple_impl(__tuple_impl&&) = default;

	_LIBCPP_INLINE_VISIBILITY
	__tuple_impl&
	operator=(const __tuple_impl& __t) _NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
	{
	__swallow(__tuple_leaf<_Indx, _Tp>::operator=(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t).get())...);
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	__tuple_impl&
	operator=(__tuple_impl&& __t) _NOEXCEPT_((__all<is_nothrow_move_assignable<_Tp>::value...>::value))
	{
	__swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<_Tp>(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t).get()))...);
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	void swap(__tuple_impl& __t)
	_NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
	{
	__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
	}
	};



	template <class ..._Tp>
	class _LIBCPP_TEMPLATE_VIS tuple
	{
	typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> _BaseT;

	_BaseT __base_;

	#if defined(_LIBCPP_ENABLE_TUPLE_IMPLICIT_REDUCED_ARITY_EXTENSION)
	static constexpr bool _EnableImplicitReducedArityExtension = true;
	#else
	static constexpr bool _EnableImplicitReducedArityExtension = false;
	#endif

	template <class ..._Args>
	struct _PackExpandsToThisTuple : false_type {};

	template <class _Arg>
	struct _PackExpandsToThisTuple<_Arg>
	: is_same<typename __uncvref<_Arg>::type, tuple> {};

	template <bool _MaybeEnable, class _Dummy = void>
	struct _CheckArgsConstructor : __check_tuple_constructor_fail {};

	template <class _Dummy>
	struct _CheckArgsConstructor<true, _Dummy>
	{
	template <class ..._Args>
	static constexpr bool __enable_default() {
	return __all<is_default_constructible<_Args>::value...>::value;
	}

	template <class ..._Args>
	static constexpr bool __enable_explicit() {
	return
	__tuple_constructible<
	tuple<_Args...>,
	typename __make_tuple_types<tuple,
	sizeof...(_Args) < sizeof...(_Tp) ?
	sizeof...(_Args) :
	sizeof...(_Tp)>::type
	>::value &&
	!__tuple_convertible<
	tuple<_Args...>,
	typename __make_tuple_types<tuple,
	sizeof...(_Args) < sizeof...(_Tp) ?
	sizeof...(_Args) :
	sizeof...(_Tp)>::type
	>::value &&
	__all_default_constructible<
	typename __make_tuple_types<tuple, sizeof...(_Tp),
	sizeof...(_Args) < sizeof...(_Tp) ?
	sizeof...(_Args) :
	sizeof...(_Tp)>::type
	>::value;
	}

	template <class ..._Args>
	static constexpr bool __enable_implicit() {
	return
	__tuple_convertible<
	tuple<_Args...>,
	typename __make_tuple_types<tuple,
	sizeof...(_Args) < sizeof...(_Tp) ?
	sizeof...(_Args) :
	sizeof...(_Tp)>::type
	>::value &&
	__all_default_constructible<
	typename __make_tuple_types<tuple, sizeof...(_Tp),
	sizeof...(_Args) < sizeof...(_Tp) ?
	sizeof...(_Args) :
	sizeof...(_Tp)>::type
	>::value;
	}
	};

	template <bool _MaybeEnable,
	bool = sizeof...(_Tp) == 1,
	class _Dummy = void>
	struct _CheckTupleLikeConstructor : __check_tuple_constructor_fail {};

	template <class _Dummy>
	struct _CheckTupleLikeConstructor<true, false, _Dummy>
	{
	template <class _Tuple>
	static constexpr bool __enable_implicit() {
	return __tuple_convertible<_Tuple, tuple>::value;
	}

	template <class _Tuple>
	static constexpr bool __enable_explicit() {
	return __tuple_constructible<_Tuple, tuple>::value
	&& !__tuple_convertible<_Tuple, tuple>::value;
	}
	};

	template <class _Dummy>
	struct _CheckTupleLikeConstructor<true, true, _Dummy>
	{
	// This trait is used to disable the tuple-like constructor when
	// the UTypes... constructor should be selected instead.
	// See LWG issue #2549.
	template <class _Tuple>
	using _PreferTupleLikeConstructor = __lazy_or<
	// Don't attempt the two checks below if the tuple we are given
	// has the same type as this tuple.
	is_same<typename __uncvref<_Tuple>::type, tuple>,
	__lazy_and<
	__lazy_not<is_constructible<_Tp..., _Tuple>>,
	__lazy_not<is_convertible<_Tuple, _Tp...>>
	>
	>;

	template <class _Tuple>
	static constexpr bool __enable_implicit() {
	return __lazy_and<
	__tuple_convertible<_Tuple, tuple>,
	_PreferTupleLikeConstructor<_Tuple>
	>::value;
	}

	template <class _Tuple>
	static constexpr bool __enable_explicit() {
	return __lazy_and<
	__tuple_constructible<_Tuple, tuple>,
	_PreferTupleLikeConstructor<_Tuple>,
	__lazy_not<__tuple_convertible<_Tuple, tuple>>
	>::value;
	}
	};

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

	template <bool _Dummy = true, class = typename enable_if<
	_CheckArgsConstructor<_Dummy>::template __enable_default<_Tp...>()
	>::type>
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR tuple()
	_NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}

	tuple(tuple const&) = default;
	tuple(tuple&&) = default;

	template <class _AllocArgT, class _Alloc, bool _Dummy = true, class = typename enable_if<
	__lazy_and<
	is_same<allocator_arg_t, _AllocArgT>,
	__lazy_all<__dependent_type<is_default_constructible<_Tp>, _Dummy>...>
	>::value
	>::type>
	_LIBCPP_INLINE_VISIBILITY
	tuple(_AllocArgT, _Alloc const& __a)
	: __base_(allocator_arg_t(), __a,
	__tuple_indices<>(), __tuple_types<>(),
	typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
	__tuple_types<_Tp...>()) {}

	template <bool _Dummy = true,
	typename enable_if
	<
	_CheckArgsConstructor<
	_Dummy
	>::template __enable_implicit<_Tp const&...>(),
	bool
	>::type = false
	>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value))
	: __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
	typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
	typename __make_tuple_indices<0>::type(),
	typename __make_tuple_types<tuple, 0>::type(),
	__t...
	) {}

	template <bool _Dummy = true,
	typename enable_if
	<
	_CheckArgsConstructor<
	_Dummy
	>::template __enable_explicit<_Tp const&...>(),
	bool
	>::type = false
	>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	explicit tuple(const _Tp& ... __t) _NOEXCEPT_((__all<is_nothrow_copy_constructible<_Tp>::value...>::value))
	: __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
	typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
	typename __make_tuple_indices<0>::type(),
	typename __make_tuple_types<tuple, 0>::type(),
	__t...
	) {}

	template <class _Alloc, bool _Dummy = true,
	typename enable_if
	<
	_CheckArgsConstructor<
	_Dummy
	>::template __enable_implicit<_Tp const&...>(),
	bool
	>::type = false
	>
	_LIBCPP_INLINE_VISIBILITY
	tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
	: __base_(allocator_arg_t(), __a,
	typename __make_tuple_indices<sizeof...(_Tp)>::type(),
	typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
	typename __make_tuple_indices<0>::type(),
	typename __make_tuple_types<tuple, 0>::type(),
	__t...
	) {}

	template <class _Alloc, bool _Dummy = true,
	typename enable_if
	<
	_CheckArgsConstructor<
	_Dummy
	>::template __enable_explicit<_Tp const&...>(),
	bool
	>::type = false
	>
	_LIBCPP_INLINE_VISIBILITY
	explicit
	tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
	: __base_(allocator_arg_t(), __a,
	typename __make_tuple_indices<sizeof...(_Tp)>::type(),
	typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
	typename __make_tuple_indices<0>::type(),
	typename __make_tuple_types<tuple, 0>::type(),
	__t...
	) {}

	template <class ..._Up,
	bool _PackIsTuple = _PackExpandsToThisTuple<_Up...>::value,
	typename enable_if
	<
	_CheckArgsConstructor<
	sizeof...(_Up) == sizeof...(_Tp)
	&& !_PackIsTuple
	>::template __enable_implicit<_Up...>() \|\|
	_CheckArgsConstructor<
	_EnableImplicitReducedArityExtension
	&& sizeof...(_Up) < sizeof...(_Tp)
	&& !_PackIsTuple
	>::template __enable_implicit<_Up...>(),
	bool
	>::type = false
	>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	tuple(_Up&&... __u)
	_NOEXCEPT_((
	is_nothrow_constructible<_BaseT,
	typename __make_tuple_indices<sizeof...(_Up)>::type,
	typename __make_tuple_types<tuple, sizeof...(_Up)>::type,
	typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type,
	typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type,
	_Up...
	>::value
	))
	: __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
	typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
	typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
	typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
	_VSTD::forward<_Up>(__u)...) {}

	template <class ..._Up,
	typename enable_if
	<
	_CheckArgsConstructor<
	sizeof...(_Up) <= sizeof...(_Tp)
	&& !_PackExpandsToThisTuple<_Up...>::value
	>::template __enable_explicit<_Up...>() \|\|
	_CheckArgsConstructor<
	!_EnableImplicitReducedArityExtension
	&& sizeof...(_Up) < sizeof...(_Tp)
	&& !_PackExpandsToThisTuple<_Up...>::value
	>::template __enable_implicit<_Up...>(),
	bool
	>::type = false
	>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	explicit
	tuple(_Up&&... __u)
	_NOEXCEPT_((
	is_nothrow_constructible<_BaseT,
	typename __make_tuple_indices<sizeof...(_Up)>::type,
	typename __make_tuple_types<tuple, sizeof...(_Up)>::type,
	typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type,
	typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type,
	_Up...
	>::value
	))
	: __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
	typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
	typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
	typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
	_VSTD::forward<_Up>(__u)...) {}

	template <class _Alloc, class ..._Up,
	typename enable_if
	<
	_CheckArgsConstructor<
	sizeof...(_Up) == sizeof...(_Tp) &&
	!_PackExpandsToThisTuple<_Up...>::value
	>::template __enable_implicit<_Up...>(),
	bool
	>::type = false
	>
	_LIBCPP_INLINE_VISIBILITY
	tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
	: __base_(allocator_arg_t(), __a,
	typename __make_tuple_indices<sizeof...(_Up)>::type(),
	typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
	typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
	typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
	_VSTD::forward<_Up>(__u)...) {}

	template <class _Alloc, class ..._Up,
	typename enable_if
	<
	_CheckArgsConstructor<
	sizeof...(_Up) == sizeof...(_Tp) &&
	!_PackExpandsToThisTuple<_Up...>::value
	>::template __enable_explicit<_Up...>(),
	bool
	>::type = false
	>
	_LIBCPP_INLINE_VISIBILITY
	explicit
	tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
	: __base_(allocator_arg_t(), __a,
	typename __make_tuple_indices<sizeof...(_Up)>::type(),
	typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
	typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
	typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
	_VSTD::forward<_Up>(__u)...) {}

	template <class _Tuple,
	typename enable_if
	<
	_CheckTupleLikeConstructor<
	__tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
	&& !_PackExpandsToThisTuple<_Tuple>::value
	>::template __enable_implicit<_Tuple>(),
	bool
	>::type = false
	>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<_BaseT, _Tuple>::value))
	: __base_(_VSTD::forward<_Tuple>(__t)) {}

	template <class _Tuple,
	typename enable_if
	<
	_CheckTupleLikeConstructor<
	__tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
	&& !_PackExpandsToThisTuple<_Tuple>::value
	>::template __enable_explicit<_Tuple>(),
	bool
	>::type = false
	>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	explicit
	tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<_BaseT, _Tuple>::value))
	: __base_(_VSTD::forward<_Tuple>(__t)) {}

	template <class _Alloc, class _Tuple,
	typename enable_if
	<
	_CheckTupleLikeConstructor<
	__tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
	>::template __enable_implicit<_Tuple>(),
	bool
	>::type = false
	>
	_LIBCPP_INLINE_VISIBILITY
	tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
	: __base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}

	template <class _Alloc, class _Tuple,
	typename enable_if
	<
	_CheckTupleLikeConstructor<
	__tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
	>::template __enable_explicit<_Tuple>(),
	bool
	>::type = false
	>
	_LIBCPP_INLINE_VISIBILITY
	explicit
	tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
	: __base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}

	using _CanCopyAssign = __all<is_copy_assignable<_Tp>::value...>;
	using _CanMoveAssign = __all<is_move_assignable<_Tp>::value...>;

	_LIBCPP_INLINE_VISIBILITY
	tuple& operator=(typename conditional<_CanCopyAssign::value, tuple, __nat>::type const& __t)
	_NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
	{
	__base_.operator=(__t.__base_);
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	tuple& operator=(typename conditional<_CanMoveAssign::value, tuple, __nat>::type&& __t)
	_NOEXCEPT_((__all<is_nothrow_move_assignable<_Tp>::value...>::value))
	{
	__base_.operator=(static_cast<_BaseT&&>(__t.__base_));
	return *this;
	}

	template <class _Tuple,
	class = typename enable_if
	<
	__tuple_assignable<_Tuple, tuple>::value
	>::type
	>
	_LIBCPP_INLINE_VISIBILITY
	tuple&
	operator=(_Tuple&& __t) _NOEXCEPT_((is_nothrow_assignable<_BaseT&, _Tuple>::value))
	{
	__base_.operator=(_VSTD::forward<_Tuple>(__t));
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
	{__base_.swap(__t.__base_);}
	};

	template <>
	class _LIBCPP_TEMPLATE_VIS tuple<>
	{
	public:
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR tuple() _NOEXCEPT {}
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
	template <class _Alloc>
	_LIBCPP_INLINE_VISIBILITY
	tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {}
	template <class _Up>
	_LIBCPP_INLINE_VISIBILITY
	tuple(array<_Up, 0>) _NOEXCEPT {}
	template <class _Alloc, class _Up>
	_LIBCPP_INLINE_VISIBILITY
	tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
	_LIBCPP_INLINE_VISIBILITY
	void swap(tuple&) _NOEXCEPT {}
	};

	#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"
	template <class _Alloc, class ..._Args>
	tuple(allocator_arg_t, const _Alloc&, tuple<_Args...> const&) -> tuple<_Args...>;
	template <class _Alloc, class ..._Args>
	tuple(allocator_arg_t, const _Alloc&, tuple<_Args...>&&) -> tuple<_Args...>;
	#endif

	template <class ..._Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__all<__is_swappable<_Tp>::value...>::value,
	void
	>::type
	swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
	_NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
	{__t.swap(__u);}

	// get

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

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

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

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

	#if _LIBCPP_STD_VER > 11

	namespace __find_detail {

	static constexpr size_t __not_found = -1;
	static constexpr size_t __ambiguous = __not_found - 1;

	inline _LIBCPP_INLINE_VISIBILITY
	constexpr size_t __find_idx_return(size_t __curr_i, size_t __res, bool __matches) {
	return !__matches ? __res :
	(__res == __not_found ? __curr_i : __ambiguous);
	}

	template <size_t _Nx>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr size_t __find_idx(size_t __i, const bool (&__matches)[_Nx]) {
	return __i == _Nx ? __not_found :
	__find_idx_return(__i, __find_idx(__i + 1, __matches), __matches[__i]);
	}

	template <class _T1, class ..._Args>
	struct __find_exactly_one_checked {
	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");
	};

	template <class _T1>
	struct __find_exactly_one_checked<_T1> {
	static_assert(!is_same<_T1, _T1>::value, "type not in empty type list");
	};

	} // namespace __find_detail;

	template <typename _T1, typename... _Args>
	struct __find_exactly_one_t
	: public __find_detail::__find_exactly_one_checked<_T1, _Args...> {
	};

	template <class _T1, class... _Args>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _T1& get(tuple<_Args...>& __tup) noexcept
	{
	return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
	}

	template <class _T1, class... _Args>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _T1 const& get(tuple<_Args...> const& __tup) noexcept
	{
	return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
	}

	template <class _T1, class... _Args>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _T1&& get(tuple<_Args...>&& __tup) noexcept
	{
	return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
	}

	template <class _T1, class... _Args>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _T1 const&& get(tuple<_Args...> const&& __tup) noexcept
	{
	return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
	}

	#endif

	// tie

	template <class ..._Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	tuple<_Tp&...>
	tie(_Tp&... __t) _NOEXCEPT
	{
	return tuple<_Tp&...>(__t...);
	}

	template <class _Up>
	struct __ignore_t
	{
	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	const __ignore_t& operator=(_Tp&&) const {return *this;}
	};

	namespace {
	_LIBCPP_INLINE_VAR constexpr __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>();
	}

	template <class _Tp>
	struct __make_tuple_return_impl
	{
	typedef _Tp type;
	};

	template <class _Tp>
	struct __make_tuple_return_impl<reference_wrapper<_Tp> >
	{
	typedef _Tp& type;
	};

	template <class _Tp>
	struct __make_tuple_return
	{
	typedef typename __make_tuple_return_impl<typename decay<_Tp>::type>::type type;
	};

	template <class... _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	tuple<typename __make_tuple_return<_Tp>::type...>
	make_tuple(_Tp&&... __t)
	{
	return tuple<typename __make_tuple_return<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
	}

	template <class... _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	tuple<_Tp&&...>
	forward_as_tuple(_Tp&&... __t) _NOEXCEPT
	{
	return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
	}

	template <size_t _Ip>
	struct __tuple_equal
	{
	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool operator()(const _Tp& __x, const _Up& __y)
	{
	return __tuple_equal<_Ip - 1>()(__x, __y) && _VSTD::get<_Ip-1>(__x) == _VSTD::get<_Ip-1>(__y);
	}
	};

	template <>
	struct __tuple_equal<0>
	{
	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool operator()(const _Tp&, const _Up&)
	{
	return true;
	}
	};

	template <class ..._Tp, class ..._Up>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
	{
	return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
	}

	template <class ..._Tp, class ..._Up>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
	{
	return !(__x == __y);
	}

	template <size_t _Ip>
	struct __tuple_less
	{
	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool operator()(const _Tp& __x, const _Up& __y)
	{
	const size_t __idx = tuple_size<_Tp>::value - _Ip;
	if (_VSTD::get<__idx>(__x) < _VSTD::get<__idx>(__y))
	return true;
	if (_VSTD::get<__idx>(__y) < _VSTD::get<__idx>(__x))
	return false;
	return __tuple_less<_Ip-1>()(__x, __y);
	}
	};

	template <>
	struct __tuple_less<0>
	{
	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool operator()(const _Tp&, const _Up&)
	{
	return false;
	}
	};

	template <class ..._Tp, class ..._Up>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
	{
	return __tuple_less<sizeof...(_Tp)>()(__x, __y);
	}

	template <class ..._Tp, class ..._Up>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
	{
	return __y < __x;
	}

	template <class ..._Tp, class ..._Up>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
	{
	return !(__x < __y);
	}

	template <class ..._Tp, class ..._Up>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
	{
	return !(__y < __x);
	}

	// tuple_cat

	template <class _Tp, class _Up> struct __tuple_cat_type;

	template <class ..._Ttypes, class ..._Utypes>
	struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
	{
	typedef tuple<_Ttypes..., _Utypes...> type;
	};

	template <class _ResultTuple, bool _Is_Tuple0TupleLike, class ..._Tuples>
	struct __tuple_cat_return_1
	{
	};

	template <class ..._Types, class _Tuple0>
	struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0>
	{
	typedef typename __tuple_cat_type<tuple<_Types...>,
	typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type>::type
	type;
	};

	template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples>
	struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
	: public __tuple_cat_return_1<
	typename __tuple_cat_type<
	tuple<_Types...>,
	typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type
	>::type,
	__tuple_like<typename remove_reference<_Tuple1>::type>::value,
	_Tuple1, _Tuples...>
	{
	};

	template <class ..._Tuples> struct __tuple_cat_return;

	template <class _Tuple0, class ..._Tuples>
	struct __tuple_cat_return<_Tuple0, _Tuples...>
	: public __tuple_cat_return_1<tuple<>,
	__tuple_like<typename remove_reference<_Tuple0>::type>::value, _Tuple0,
	_Tuples...>
	{
	};

	template <>
	struct __tuple_cat_return<>
	{
	typedef tuple<> type;
	};

	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	tuple<>
	tuple_cat()
	{
	return tuple<>();
	}

	template <class _Rp, class _Indices, class _Tuple0, class ..._Tuples>
	struct __tuple_cat_return_ref_imp;

	template <class ..._Types, size_t ..._I0, class _Tuple0>
	struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0>
	{
	typedef typename remove_reference<_Tuple0>::type _T0;
	typedef tuple<_Types..., typename __apply_cv<_Tuple0,
	typename tuple_element<_I0, _T0>::type>::type&&...> type;
	};

	template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples>
	struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>,
	_Tuple0, _Tuple1, _Tuples...>
	: public __tuple_cat_return_ref_imp<
	tuple<_Types..., typename __apply_cv<_Tuple0,
	typename tuple_element<_I0,
	typename remove_reference<_Tuple0>::type>::type>::type&&...>,
	typename __make_tuple_indices<tuple_size<typename
	remove_reference<_Tuple1>::type>::value>::type,
	_Tuple1, _Tuples...>
	{
	};

	template <class _Tuple0, class ..._Tuples>
	struct __tuple_cat_return_ref
	: public __tuple_cat_return_ref_imp<tuple<>,
	typename __make_tuple_indices<
	tuple_size<typename remove_reference<_Tuple0>::type>::value
	>::type, _Tuple0, _Tuples...>
	{
	};

	template <class _Types, class _I0, class _J0>
	struct __tuple_cat;

	template <class ..._Types, size_t ..._I0, size_t ..._J0>
	struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
	{
	template <class _Tuple0>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
	operator()(tuple<_Types...> __t, _Tuple0&& __t0)
	{
	return forward_as_tuple(_VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
	_VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
	}

	template <class _Tuple0, class _Tuple1, class ..._Tuples>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
	operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
	{
	typedef typename remove_reference<_Tuple0>::type _T0;
	typedef typename remove_reference<_Tuple1>::type _T1;
	return __tuple_cat<
	tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>,
	typename __make_tuple_indices<sizeof ...(_Types) + tuple_size<_T0>::value>::type,
	typename __make_tuple_indices<tuple_size<_T1>::value>::type>()
	(forward_as_tuple(
	_VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
	_VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...
	),
	_VSTD::forward<_Tuple1>(__t1),
	_VSTD::forward<_Tuples>(__tpls)...);
	}
	};

	template <class _Tuple0, class... _Tuples>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	typename __tuple_cat_return<_Tuple0, _Tuples...>::type
	tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
	{
	typedef typename remove_reference<_Tuple0>::type _T0;
	return __tuple_cat<tuple<>, __tuple_indices<>,
	typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
	(tuple<>(), _VSTD::forward<_Tuple0>(__t0),
	_VSTD::forward<_Tuples>(__tpls)...);
	}

	template <class ..._Tp, class _Alloc>
	struct _LIBCPP_TEMPLATE_VIS uses_allocator<tuple<_Tp...>, _Alloc>
	: true_type {};

	template <class _T1, class _T2>
	template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
	inline _LIBCPP_INLINE_VISIBILITY
	pair<_T1, _T2>::pair(piecewise_construct_t,
	tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
	__tuple_indices<_I1...>, __tuple_indices<_I2...>)
	: first(_VSTD::forward<_Args1>(_VSTD::get<_I1>( __first_args))...),
	second(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
	{
	}

	#if _LIBCPP_STD_VER > 14
	template <class _Tp>
	_LIBCPP_INLINE_VAR constexpr size_t tuple_size_v = tuple_size<_Tp>::value;

	#define _LIBCPP_NOEXCEPT_RETURN(...) noexcept(noexcept(__VA_ARGS__)) { return __VA_ARGS__; }

	template <class _Fn, class _Tuple, size_t ..._Id>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr decltype(auto) __apply_tuple_impl(_Fn && __f, _Tuple && __t,
	__tuple_indices<_Id...>)
	_LIBCPP_NOEXCEPT_RETURN(
	_VSTD::__invoke_constexpr(
	_VSTD::forward<_Fn>(__f),
	_VSTD::get<_Id>(_VSTD::forward<_Tuple>(__t))...)
	)

	template <class _Fn, class _Tuple>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr decltype(auto) apply(_Fn && __f, _Tuple && __t)
	_LIBCPP_NOEXCEPT_RETURN(
	_VSTD::__apply_tuple_impl(
	_VSTD::forward<_Fn>(__f), _VSTD::forward<_Tuple>(__t),
	- typename __make_tuple_indices<tuple_size_v<decay_t<_Tuple>>>::type{})
	+ typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{})
	)

	template <class _Tp, class _Tuple, size_t... _Idx>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>)
	_LIBCPP_NOEXCEPT_RETURN(
	_Tp(_VSTD::get<_Idx>(_VSTD::forward<_Tuple>(__t))...)
	)

	template <class _Tp, class _Tuple>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _Tp make_from_tuple(_Tuple&& __t)
	_LIBCPP_NOEXCEPT_RETURN(
	_VSTD::__make_from_tuple_impl<_Tp>(_VSTD::forward<_Tuple>(__t),
	- typename __make_tuple_indices<tuple_size_v<decay_t<_Tuple>>>::type{})
	+ typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{})
	)

	#undef _LIBCPP_NOEXCEPT_RETURN

	#endif // _LIBCPP_STD_VER > 14

	#endif // !defined(_LIBCPP_CXX03_LANG)

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_TUPLE
	Index: projects/clang700-import/contrib/libc++/include/type_traits
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/type_traits (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/type_traits (revision 337135)
	@@ -1,4977 +1,4856 @@
	// -- C++ --
	//===------------------------ type_traits ---------------------------------===//
	//
	// 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_TYPE_TRAITS
	#define _LIBCPP_TYPE_TRAITS

	/*
	type_traits synopsis

	namespace std
	{

	// helper class:
	template <class T, T v> struct integral_constant;
	typedef integral_constant<bool, true> true_type; // C++11
	typedef integral_constant<bool, false> false_type; // C++11
	-
	+
	template <bool B> // C++14
	using bool_constant = integral_constant<bool, B>; // C++14
	typedef bool_constant<true> true_type; // C++14
	typedef bool_constant<false> false_type; // C++14

	// helper traits
	template <bool, class T = void> struct enable_if;
	template <bool, class T, class F> struct conditional;

	// Primary classification traits:
	template <class T> struct is_void;
	template <class T> struct is_null_pointer; // C++14
	template <class T> struct is_integral;
	template <class T> struct is_floating_point;
	template <class T> struct is_array;
	template <class T> struct is_pointer;
	template <class T> struct is_lvalue_reference;
	template <class T> struct is_rvalue_reference;
	template <class T> struct is_member_object_pointer;
	template <class T> struct is_member_function_pointer;
	template <class T> struct is_enum;
	template <class T> struct is_union;
	template <class T> struct is_class;
	template <class T> struct is_function;

	// Secondary classification traits:
	template <class T> struct is_reference;
	template <class T> struct is_arithmetic;
	template <class T> struct is_fundamental;
	template <class T> struct is_member_pointer;
	template <class T> struct is_scalar;
	template <class T> struct is_object;
	template <class T> struct is_compound;

	// Const-volatile properties and transformations:
	template <class T> struct is_const;
	template <class T> struct is_volatile;
	template <class T> struct remove_const;
	template <class T> struct remove_volatile;
	template <class T> struct remove_cv;
	template <class T> struct add_const;
	template <class T> struct add_volatile;
	template <class T> struct add_cv;

	// Reference transformations:
	template <class T> struct remove_reference;
	template <class T> struct add_lvalue_reference;
	template <class T> struct add_rvalue_reference;

	// Pointer transformations:
	template <class T> struct remove_pointer;
	template <class T> struct add_pointer;

	// Integral properties:
	template <class T> struct is_signed;
	template <class T> struct is_unsigned;
	template <class T> struct make_signed;
	template <class T> struct make_unsigned;

	// Array properties and transformations:
	template <class T> struct rank;
	template <class T, unsigned I = 0> struct extent;
	template <class T> struct remove_extent;
	template <class T> struct remove_all_extents;

	// Member introspection:
	template <class T> struct is_pod;
	template <class T> struct is_trivial;
	template <class T> struct is_trivially_copyable;
	template <class T> struct is_standard_layout;
	template <class T> struct is_literal_type;
	template <class T> struct is_empty;
	template <class T> struct is_polymorphic;
	template <class T> struct is_abstract;
	template <class T> struct is_final; // C++14
	template <class T> struct is_aggregate; // C++17

	template <class T, class... Args> struct is_constructible;
	template <class T> struct is_default_constructible;
	template <class T> struct is_copy_constructible;
	template <class T> struct is_move_constructible;
	template <class T, class U> struct is_assignable;
	template <class T> struct is_copy_assignable;
	template <class T> struct is_move_assignable;
	template <class T, class U> struct is_swappable_with; // C++17
	template <class T> struct is_swappable; // C++17
	template <class T> struct is_destructible;

	template <class T, class... Args> struct is_trivially_constructible;
	template <class T> struct is_trivially_default_constructible;
	template <class T> struct is_trivially_copy_constructible;
	template <class T> struct is_trivially_move_constructible;
	template <class T, class U> struct is_trivially_assignable;
	template <class T> struct is_trivially_copy_assignable;
	template <class T> struct is_trivially_move_assignable;
	template <class T> struct is_trivially_destructible;

	template <class T, class... Args> struct is_nothrow_constructible;
	template <class T> struct is_nothrow_default_constructible;
	template <class T> struct is_nothrow_copy_constructible;
	template <class T> struct is_nothrow_move_constructible;
	template <class T, class U> struct is_nothrow_assignable;
	template <class T> struct is_nothrow_copy_assignable;
	template <class T> struct is_nothrow_move_assignable;
	template <class T, class U> struct is_nothrow_swappable_with; // C++17
	template <class T> struct is_nothrow_swappable; // C++17
	template <class T> struct is_nothrow_destructible;

	template <class T> struct has_virtual_destructor;

	template<class T> struct has_unique_object_representations; // C++17

	// Relationships between types:
	template <class T, class U> struct is_same;
	template <class Base, class Derived> struct is_base_of;
	template <class From, class To> struct is_convertible;

	template <class Fn, class... ArgTypes> struct is_invocable;
	template <class R, class Fn, class... ArgTypes> struct is_invocable_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>
	using remove_const_t = typename remove_const<T>::type; // C++14
	template <class T>
	using remove_volatile_t = typename remove_volatile<T>::type; // C++14
	template <class T>
	using remove_cv_t = typename remove_cv<T>::type; // C++14
	template <class T>
	using add_const_t = typename add_const<T>::type; // C++14
	template <class T>
	using add_volatile_t = typename add_volatile<T>::type; // C++14
	template <class T>
	using add_cv_t = typename add_cv<T>::type; // C++14
	-
	+
	// reference modifications:
	template <class T>
	using remove_reference_t = typename remove_reference<T>::type; // C++14
	template <class T>
	using add_lvalue_reference_t = typename add_lvalue_reference<T>::type; // C++14
	template <class T>
	using add_rvalue_reference_t = typename add_rvalue_reference<T>::type; // C++14
	-
	+
	// sign modifications:
	template <class T>
	using make_signed_t = typename make_signed<T>::type; // C++14
	template <class T>
	using make_unsigned_t = typename make_unsigned<T>::type; // C++14
	-
	+
	// array modifications:
	template <class T>
	using remove_extent_t = typename remove_extent<T>::type; // C++14
	template <class T>
	using remove_all_extents_t = typename remove_all_extents<T>::type; // C++14

	// pointer modifications:
	template <class T>
	using remove_pointer_t = typename remove_pointer<T>::type; // C++14
	template <class T>
	using add_pointer_t = typename add_pointer<T>::type; // C++14

	// other transformations:
	template <size_t Len, std::size_t Align=default-alignment>
	using aligned_storage_t = typename aligned_storage<Len,Align>::type; // C++14
	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
	template <bool b, class T, class F>
	using conditional_t = typename conditional<b,T,F>::type; // C++14
	template <class... T>
	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 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
	-
	+
	// See C++14 20.10.4.1, primary type categories
	template <class T> inline constexpr bool is_void_v
	= is_void<T>::value; // C++17
	template <class T> inline constexpr bool is_null_pointer_v
	= is_null_pointer<T>::value; // C++17
	template <class T> inline constexpr bool is_integral_v
	= is_integral<T>::value; // C++17
	template <class T> inline constexpr bool is_floating_point_v
	= is_floating_point<T>::value; // C++17
	template <class T> inline constexpr bool is_array_v
	= is_array<T>::value; // C++17
	template <class T> inline constexpr bool is_pointer_v
	= is_pointer<T>::value; // C++17
	template <class T> inline constexpr bool is_lvalue_reference_v
	= is_lvalue_reference<T>::value; // C++17
	template <class T> inline constexpr bool is_rvalue_reference_v
	= is_rvalue_reference<T>::value; // C++17
	template <class T> inline constexpr bool is_member_object_pointer_v
	= is_member_object_pointer<T>::value; // C++17
	template <class T> inline constexpr bool is_member_function_pointer_v
	= is_member_function_pointer<T>::value; // C++17
	template <class T> inline constexpr bool is_enum_v
	= is_enum<T>::value; // C++17
	template <class T> inline constexpr bool is_union_v
	= is_union<T>::value; // C++17
	template <class T> inline constexpr bool is_class_v
	= is_class<T>::value; // C++17
	template <class T> inline constexpr bool is_function_v
	= is_function<T>::value; // C++17

	// See C++14 20.10.4.2, composite type categories
	template <class T> inline constexpr bool is_reference_v
	= is_reference<T>::value; // C++17
	template <class T> inline constexpr bool is_arithmetic_v
	= is_arithmetic<T>::value; // C++17
	template <class T> inline constexpr bool is_fundamental_v
	= is_fundamental<T>::value; // C++17
	template <class T> inline constexpr bool is_object_v
	= is_object<T>::value; // C++17
	template <class T> inline constexpr bool is_scalar_v
	= is_scalar<T>::value; // C++17
	template <class T> inline constexpr bool is_compound_v
	= is_compound<T>::value; // C++17
	template <class T> inline constexpr bool is_member_pointer_v
	= is_member_pointer<T>::value; // C++17

	// See C++14 20.10.4.3, type properties
	template <class T> inline constexpr bool is_const_v
	= is_const<T>::value; // C++17
	template <class T> inline constexpr bool is_volatile_v
	= is_volatile<T>::value; // C++17
	template <class T> inline constexpr bool is_trivial_v
	= is_trivial<T>::value; // C++17
	template <class T> inline constexpr bool is_trivially_copyable_v
	= is_trivially_copyable<T>::value; // C++17
	template <class T> inline constexpr bool is_standard_layout_v
	= is_standard_layout<T>::value; // C++17
	template <class T> inline constexpr bool is_pod_v
	= is_pod<T>::value; // C++17
	template <class T> inline constexpr bool is_literal_type_v
	= is_literal_type<T>::value; // C++17
	template <class T> inline constexpr bool is_empty_v
	= is_empty<T>::value; // C++17
	template <class T> inline constexpr bool is_polymorphic_v
	= is_polymorphic<T>::value; // C++17
	template <class T> inline constexpr bool is_abstract_v
	= is_abstract<T>::value; // C++17
	template <class T> inline constexpr bool is_final_v
	= is_final<T>::value; // C++17
	template <class T> inline constexpr bool is_aggregate_v
	= is_aggregate<T>::value; // C++17
	template <class T> inline constexpr bool is_signed_v
	= is_signed<T>::value; // C++17
	template <class T> inline constexpr bool is_unsigned_v
	= is_unsigned<T>::value; // C++17
	template <class T, class... Args> inline constexpr bool is_constructible_v
	= is_constructible<T, Args...>::value; // C++17
	template <class T> inline constexpr bool is_default_constructible_v
	= is_default_constructible<T>::value; // C++17
	template <class T> inline constexpr bool is_copy_constructible_v
	= is_copy_constructible<T>::value; // C++17
	template <class T> inline constexpr bool is_move_constructible_v
	= is_move_constructible<T>::value; // C++17
	template <class T, class U> inline constexpr bool is_assignable_v
	= is_assignable<T, U>::value; // C++17
	template <class T> inline constexpr bool is_copy_assignable_v
	= is_copy_assignable<T>::value; // C++17
	template <class T> inline constexpr bool is_move_assignable_v
	= is_move_assignable<T>::value; // C++17
	template <class T, class U> inline constexpr bool is_swappable_with_v
	= is_swappable_with<T, U>::value; // C++17
	template <class T> inline constexpr bool is_swappable_v
	= is_swappable<T>::value; // C++17
	template <class T> inline constexpr bool is_destructible_v
	= is_destructible<T>::value; // C++17
	template <class T, class... Args> inline constexpr bool is_trivially_constructible_v
	= is_trivially_constructible<T, Args...>::value; // C++17
	template <class T> inline constexpr bool is_trivially_default_constructible_v
	= is_trivially_default_constructible<T>::value; // C++17
	template <class T> inline constexpr bool is_trivially_copy_constructible_v
	= is_trivially_copy_constructible<T>::value; // C++17
	template <class T> inline constexpr bool is_trivially_move_constructible_v
	= is_trivially_move_constructible<T>::value; // C++17
	template <class T, class U> inline constexpr bool is_trivially_assignable_v
	= is_trivially_assignable<T, U>::value; // C++17
	template <class T> inline constexpr bool is_trivially_copy_assignable_v
	= is_trivially_copy_assignable<T>::value; // C++17
	template <class T> inline constexpr bool is_trivially_move_assignable_v
	= is_trivially_move_assignable<T>::value; // C++17
	template <class T> inline constexpr bool is_trivially_destructible_v
	= is_trivially_destructible<T>::value; // C++17
	template <class T, class... Args> inline constexpr bool is_nothrow_constructible_v
	= is_nothrow_constructible<T, Args...>::value; // C++17
	template <class T> inline constexpr bool is_nothrow_default_constructible_v
	= is_nothrow_default_constructible<T>::value; // C++17
	template <class T> inline constexpr bool is_nothrow_copy_constructible_v
	= is_nothrow_copy_constructible<T>::value; // C++17
	template <class T> inline constexpr bool is_nothrow_move_constructible_v
	= is_nothrow_move_constructible<T>::value; // C++17
	template <class T, class U> inline constexpr bool is_nothrow_assignable_v
	= is_nothrow_assignable<T, U>::value; // C++17
	template <class T> inline constexpr bool is_nothrow_copy_assignable_v
	= is_nothrow_copy_assignable<T>::value; // C++17
	template <class T> inline constexpr bool is_nothrow_move_assignable_v
	= is_nothrow_move_assignable<T>::value; // C++17
	template <class T, class U> inline constexpr bool is_nothrow_swappable_with_v
	= is_nothrow_swappable_with<T, U>::value; // C++17
	template <class T> inline constexpr bool is_nothrow_swappable_v
	= is_nothrow_swappable<T>::value; // C++17
	template <class T> inline constexpr bool is_nothrow_destructible_v
	= is_nothrow_destructible<T>::value; // C++17
	template <class T> inline constexpr bool has_virtual_destructor_v
	= has_virtual_destructor<T>::value; // C++17
	template<class T> inline constexpr bool has_unique_object_representations_v // C++17
	= has_unique_object_representations<T>::value;

	// See C++14 20.10.5, type property queries
	template <class T> inline constexpr size_t alignment_of_v
	= alignment_of<T>::value; // C++17
	template <class T> inline constexpr size_t rank_v
	= rank<T>::value; // C++17
	template <class T, unsigned I = 0> inline constexpr size_t extent_v
	= extent<T, I>::value; // C++17

	// See C++14 20.10.6, type relations
	template <class T, class U> inline constexpr bool is_same_v
	= is_same<T, U>::value; // C++17
	template <class Base, class Derived> inline constexpr bool is_base_of_v
	= is_base_of<Base, Derived>::value; // C++17
	template <class From, class To> inline constexpr bool is_convertible_v
	= is_convertible<From, To>::value; // C++17
	template <class Fn, class... ArgTypes> inline constexpr bool is_invocable_v
	= is_invocable<Fn, ArgTypes...>::value; // C++17
	template <class R, class Fn, class... ArgTypes> inline constexpr bool is_invocable_r_v
	= is_invocable_r<R, Fn, ArgTypes...>::value; // C++17
	template <class Fn, class... ArgTypes> inline constexpr bool is_nothrow_invocable_v
	= is_nothrow_invocable<Fn, ArgTypes...>::value; // C++17
	template <class R, class Fn, class... ArgTypes> inline 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
	- template<class... B>
	+ template<class... B>
	inline constexpr bool conjunction_v = conjunction<B...>::value; // C++17
	template<class... B> struct disjunction; // C++17
	template<class... B>
	inline constexpr bool disjunction_v = disjunction<B...>::value; // C++17
	template<class B> struct negation; // C++17
	- template<class B>
	+ template<class B>
	inline constexpr bool negation_v = negation<B>::value; // C++17

	}

	*/
	#include <__config>
	#include <cstddef>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS pair;
	template <class _Tp> class _LIBCPP_TEMPLATE_VIS reference_wrapper;
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash;

	template <class>
	struct __void_t { typedef void type; };

	template <class _Tp>
	struct __identity { typedef _Tp type; };

	template <class _Tp, bool>
	struct _LIBCPP_TEMPLATE_VIS __dependent_type : public _Tp {};

	template <bool _Bp, class _If, class _Then>
	struct _LIBCPP_TEMPLATE_VIS conditional {typedef _If type;};
	template <class _If, class _Then>
	struct _LIBCPP_TEMPLATE_VIS conditional<false, _If, _Then> {typedef _Then type;};

	#if _LIBCPP_STD_VER > 11
	template <bool _Bp, class _If, class _Then> using conditional_t = typename conditional<_Bp, _If, _Then>::type;
	#endif

	template <bool, class _Tp> struct _LIBCPP_TEMPLATE_VIS __lazy_enable_if {};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS __lazy_enable_if<true, _Tp> {typedef typename _Tp::type type;};

	template <bool, class _Tp = void> struct _LIBCPP_TEMPLATE_VIS enable_if {};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS enable_if<true, _Tp> {typedef _Tp type;};

	#if _LIBCPP_STD_VER > 11
	template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp, _Tp>::type;
	#endif

	// addressof
	#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF

	template <class _Tp>
	inline _LIBCPP_CONSTEXPR_AFTER_CXX14
	_LIBCPP_NO_CFI _LIBCPP_INLINE_VISIBILITY
	_Tp*
	addressof(_Tp& __x) _NOEXCEPT
	{
	return __builtin_addressof(__x);
	}

	#else

	template <class _Tp>
	inline _LIBCPP_NO_CFI _LIBCPP_INLINE_VISIBILITY
	_Tp*
	addressof(_Tp& __x) _NOEXCEPT
	{
	return reinterpret_cast<_Tp *>(
	const_cast<char *>(&reinterpret_cast<const volatile char &>(__x)));
	}

	#endif // _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF

	#if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF)
	// Objective-C++ Automatic Reference Counting uses qualified pointers
	// that require special addressof() signatures. When
	// _LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF is defined, the compiler
	// itself is providing these definitions. Otherwise, we provide them.
	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	__strong _Tp*
	addressof(__strong _Tp& __x) _NOEXCEPT
	{
	return &__x;
	}

	#ifdef _LIBCPP_HAS_OBJC_ARC_WEAK
	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	__weak _Tp*
	addressof(__weak _Tp& __x) _NOEXCEPT
	{
	return &__x;
	}
	#endif

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	__autoreleasing _Tp*
	addressof(__autoreleasing _Tp& __x) _NOEXCEPT
	{
	return &__x;
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	__unsafe_unretained _Tp*
	addressof(__unsafe_unretained _Tp& __x) _NOEXCEPT
	{
	return &__x;
	}
	#endif

	#if !defined(_LIBCPP_CXX03_LANG)
	template <class _Tp> _Tp* addressof(const _Tp&&) noexcept = delete;
	#endif

	struct __two {char __lx[2];};

	// helper class:

	template <class _Tp, _Tp __v>
	struct _LIBCPP_TEMPLATE_VIS integral_constant
	{
	static _LIBCPP_CONSTEXPR const _Tp value = __v;
	typedef _Tp value_type;
	typedef integral_constant type;
	_LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR operator value_type() const _NOEXCEPT {return value;}
	#if _LIBCPP_STD_VER > 11
	_LIBCPP_INLINE_VISIBILITY
	constexpr value_type operator ()() const _NOEXCEPT {return value;}
	#endif
	};

	template <class _Tp, _Tp __v>
	_LIBCPP_CONSTEXPR const _Tp integral_constant<_Tp, __v>::value;

	#if _LIBCPP_STD_VER > 14
	template <bool __b>
	using bool_constant = integral_constant<bool, __b>;
	#define _LIBCPP_BOOL_CONSTANT(__b) bool_constant<(__b)>
	#else
	#define _LIBCPP_BOOL_CONSTANT(__b) integral_constant<bool,(__b)>
	#endif

	typedef _LIBCPP_BOOL_CONSTANT(true) true_type;
	typedef _LIBCPP_BOOL_CONSTANT(false) false_type;

	#if !defined(_LIBCPP_CXX03_LANG)

	// __lazy_and

	template <bool _Last, class ..._Preds>
	struct __lazy_and_impl;

	template <class ..._Preds>
	struct __lazy_and_impl<false, _Preds...> : false_type {};

	template <>
	struct __lazy_and_impl<true> : true_type {};

	template <class _Pred>
	struct __lazy_and_impl<true, _Pred> : integral_constant<bool, _Pred::type::value> {};

	template <class _Hp, class ..._Tp>
	struct __lazy_and_impl<true, _Hp, _Tp...> : __lazy_and_impl<_Hp::type::value, _Tp...> {};

	template <class _P1, class ..._Pr>
	struct __lazy_and : __lazy_and_impl<_P1::type::value, _Pr...> {};

	// __lazy_or

	template <bool _List, class ..._Preds>
	struct __lazy_or_impl;

	template <class ..._Preds>
	struct __lazy_or_impl<true, _Preds...> : true_type {};

	template <>
	struct __lazy_or_impl<false> : false_type {};

	template <class _Hp, class ..._Tp>
	struct __lazy_or_impl<false, _Hp, _Tp...>
	: __lazy_or_impl<_Hp::type::value, _Tp...> {};

	template <class _P1, class ..._Pr>
	struct __lazy_or : __lazy_or_impl<_P1::type::value, _Pr...> {};

	// __lazy_not

	template <class _Pred>
	struct __lazy_not : integral_constant<bool, !_Pred::type::value> {};

	// __and_
	template<class...> struct __and_;
	template<> struct __and_<> : true_type {};

	template<class _B0> struct __and_<_B0> : _B0 {};

	template<class _B0, class _B1>
	struct __and_<_B0, _B1> : conditional<_B0::value, _B1, _B0>::type {};

	template<class _B0, class _B1, class _B2, class... _Bn>
	-struct __and_<_B0, _B1, _B2, _Bn...>
	+struct __and_<_B0, _B1, _B2, _Bn...>
	: conditional<_B0::value, __and_<_B1, _B2, _Bn...>, _B0>::type {};

	// __or_
	template<class...> struct __or_;
	template<> struct __or_<> : false_type {};

	template<class _B0> struct __or_<_B0> : _B0 {};

	template<class _B0, class _B1>
	struct __or_<_B0, _B1> : conditional<_B0::value, _B0, _B1>::type {};

	template<class _B0, class _B1, class _B2, class... _Bn>
	-struct __or_<_B0, _B1, _B2, _Bn...>
	+struct __or_<_B0, _B1, _B2, _Bn...>
	: conditional<_B0::value, _B0, __or_<_B1, _B2, _Bn...> >::type {};

	// __not_
	-template<class _Tp>
	+template<class _Tp>
	struct __not_ : conditional<_Tp::value, false_type, true_type>::type {};

	#endif // !defined(_LIBCPP_CXX03_LANG)

	// is_const

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const : public false_type {};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const<_Tp const> : public true_type {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_const_v
	= is_const<_Tp>::value;
	#endif

	// is_volatile

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile : public false_type {};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile<_Tp volatile> : public true_type {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_volatile_v
	= is_volatile<_Tp>::value;
	#endif

	// remove_const

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const {typedef _Tp type;};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const<const _Tp> {typedef _Tp type;};
	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using remove_const_t = typename remove_const<_Tp>::type;
	#endif

	// remove_volatile

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile {typedef _Tp type;};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile<volatile _Tp> {typedef _Tp type;};
	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using remove_volatile_t = typename remove_volatile<_Tp>::type;
	#endif

	// remove_cv

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_cv
	{typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;};
	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using remove_cv_t = typename remove_cv<_Tp>::type;
	#endif

	// is_void

	template <class _Tp> struct __libcpp_is_void : public false_type {};
	template <> struct __libcpp_is_void<void> : public true_type {};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_void
	: public __libcpp_is_void<typename remove_cv<_Tp>::type> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_void_v
	= is_void<_Tp>::value;
	#endif

	// __is_nullptr_t

	template <class _Tp> struct __is_nullptr_t_impl : public false_type {};
	template <> struct __is_nullptr_t_impl<nullptr_t> : public true_type {};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS __is_nullptr_t
	: public __is_nullptr_t_impl<typename remove_cv<_Tp>::type> {};

	#if _LIBCPP_STD_VER > 11
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_null_pointer
	: public __is_nullptr_t_impl<typename remove_cv<_Tp>::type> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_null_pointer_v
	= is_null_pointer<_Tp>::value;
	#endif
	#endif

	// is_integral

	template <class _Tp> struct __libcpp_is_integral : public false_type {};
	template <> struct __libcpp_is_integral<bool> : public true_type {};
	template <> struct __libcpp_is_integral<char> : public true_type {};
	template <> struct __libcpp_is_integral<signed char> : public true_type {};
	template <> struct __libcpp_is_integral<unsigned char> : public true_type {};
	template <> struct __libcpp_is_integral<wchar_t> : public true_type {};
	#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
	template <> struct __libcpp_is_integral<char16_t> : public true_type {};
	template <> struct __libcpp_is_integral<char32_t> : public true_type {};
	#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
	template <> struct __libcpp_is_integral<short> : public true_type {};
	template <> struct __libcpp_is_integral<unsigned short> : public true_type {};
	template <> struct __libcpp_is_integral<int> : public true_type {};
	template <> struct __libcpp_is_integral<unsigned int> : public true_type {};
	template <> struct __libcpp_is_integral<long> : public true_type {};
	template <> struct __libcpp_is_integral<unsigned long> : public true_type {};
	template <> struct __libcpp_is_integral<long long> : public true_type {};
	template <> struct __libcpp_is_integral<unsigned long long> : public true_type {};
	#ifndef _LIBCPP_HAS_NO_INT128
	template <> struct __libcpp_is_integral<__int128_t> : public true_type {};
	template <> struct __libcpp_is_integral<__uint128_t> : public true_type {};
	#endif

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_integral
	: public __libcpp_is_integral<typename remove_cv<_Tp>::type> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_integral_v
	= is_integral<_Tp>::value;
	#endif

	// is_floating_point

	template <class _Tp> struct __libcpp_is_floating_point : public false_type {};
	+#ifdef __clang__
	+template <> struct __libcpp_is_floating_point<__fp16> : public true_type {};
	+#endif
	+#ifdef __FLT16_MANT_DIG__
	+template <> struct __libcpp_is_floating_point<_Float16> : public true_type {};
	+#endif
	template <> struct __libcpp_is_floating_point<float> : public true_type {};
	template <> struct __libcpp_is_floating_point<double> : public true_type {};
	template <> struct __libcpp_is_floating_point<long double> : public true_type {};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_floating_point
	: public __libcpp_is_floating_point<typename remove_cv<_Tp>::type> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_floating_point_v
	= is_floating_point<_Tp>::value;
	#endif

	// is_array

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array
	: public false_type {};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[]>
	: public true_type {};
	template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[_Np]>
	: public true_type {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_array_v
	= is_array<_Tp>::value;
	#endif

	// is_pointer

	template <class _Tp> struct __libcpp_is_pointer : public false_type {};
	template <class _Tp> struct __libcpp_is_pointer<_Tp*> : public true_type {};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pointer
	: public __libcpp_is_pointer<typename remove_cv<_Tp>::type> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_pointer_v
	= is_pointer<_Tp>::value;
	#endif

	// is_reference

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference : public false_type {};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference<_Tp&> : public true_type {};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference : public false_type {};
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference<_Tp&&> : public true_type {};
	#endif

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference : public false_type {};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference<_Tp&> : public true_type {};
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference<_Tp&&> : public true_type {};
	#endif

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_reference_v
	= is_reference<_Tp>::value;

	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_lvalue_reference_v
	= is_lvalue_reference<_Tp>::value;

	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_rvalue_reference_v
	= is_rvalue_reference<_Tp>::value;
	#endif
	// is_union

	#if __has_feature(is_union) \|\| (_GNUC_VER >= 403)

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_union
	: public integral_constant<bool, __is_union(_Tp)> {};

	#else

	template <class _Tp> struct __libcpp_union : public false_type {};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_union
	: public __libcpp_union<typename remove_cv<_Tp>::type> {};

	#endif

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_union_v
	= is_union<_Tp>::value;
	#endif

	// is_class

	#if __has_feature(is_class) \|\| (_GNUC_VER >= 403)

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_class
	: public integral_constant<bool, __is_class(_Tp)> {};

	#else

	namespace __is_class_imp
	{
	template <class _Tp> char __test(int _Tp::*);
	template <class _Tp> __two __test(...);
	}

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_class
	: public integral_constant<bool, sizeof(__is_class_imp::__test<_Tp>(0)) == 1 && !is_union<_Tp>::value> {};

	#endif

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_class_v
	= is_class<_Tp>::value;
	#endif

	// is_same

	template <class _Tp, class _Up> struct _LIBCPP_TEMPLATE_VIS is_same : public false_type {};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_same<_Tp, _Tp> : public true_type {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_same_v
	= is_same<_Tp, _Up>::value;
	#endif

	// is_function

	namespace __libcpp_is_function_imp
	{
	struct __dummy_type {};
	template <class _Tp> char __test(_Tp*);
	template <class _Tp> char __test(__dummy_type);
	template <class _Tp> __two __test(...);
	template <class _Tp> _Tp& __source(int);
	template <class _Tp> __dummy_type __source(...);
	}

	template <class _Tp, bool = is_class<_Tp>::value \|\|
	is_union<_Tp>::value \|\|
	is_void<_Tp>::value \|\|
	is_reference<_Tp>::value \|\|
	__is_nullptr_t<_Tp>::value >
	struct __libcpp_is_function
	: public integral_constant<bool, sizeof(__libcpp_is_function_imp::__test<_Tp>(__libcpp_is_function_imp::__source<_Tp>(0))) == 1>
	{};
	template <class _Tp> struct __libcpp_is_function<_Tp, true> : public false_type {};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_function
	: public __libcpp_is_function<_Tp> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_function_v
	= is_function<_Tp>::value;
	#endif

	// is_member_function_pointer

	// template <class _Tp> struct __libcpp_is_member_function_pointer : public false_type {};
	// template <class _Tp, class _Up> struct __libcpp_is_member_function_pointer<_Tp _Up::*> : public is_function<_Tp> {};
	-//
	+//

	template <class _MP, bool _IsMemberFunctionPtr, bool _IsMemberObjectPtr>
	struct __member_pointer_traits_imp
	{ // forward declaration; specializations later
	};


	template <class _Tp> struct __libcpp_is_member_function_pointer
	: public false_type {};

	template <class _Ret, class _Class>
	struct __libcpp_is_member_function_pointer<_Ret _Class::*>
	: public is_function<_Ret> {};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer
	: public __libcpp_is_member_function_pointer<typename remove_cv<_Tp>::type>::type {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_function_pointer_v
	= is_member_function_pointer<_Tp>::value;
	#endif

	// is_member_pointer

	template <class _Tp> struct __libcpp_is_member_pointer : public false_type {};
	template <class _Tp, class _Up> struct __libcpp_is_member_pointer<_Tp _Up::*> : public true_type {};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_pointer
	: public __libcpp_is_member_pointer<typename remove_cv<_Tp>::type> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_pointer_v
	= is_member_pointer<_Tp>::value;
	#endif

	// is_member_object_pointer

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer
	: public integral_constant<bool, is_member_pointer<_Tp>::value &&
	!is_member_function_pointer<_Tp>::value> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_object_pointer_v
	= is_member_object_pointer<_Tp>::value;
	#endif

	// is_enum

	#if __has_feature(is_enum) \|\| (_GNUC_VER >= 403)

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum
	: public integral_constant<bool, __is_enum(_Tp)> {};

	#else

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum
	: public integral_constant<bool, !is_void<_Tp>::value &&
	!is_integral<_Tp>::value &&
	!is_floating_point<_Tp>::value &&
	!is_array<_Tp>::value &&
	!is_pointer<_Tp>::value &&
	!is_reference<_Tp>::value &&
	!is_member_pointer<_Tp>::value &&
	!is_union<_Tp>::value &&
	!is_class<_Tp>::value &&
	!is_function<_Tp>::value > {};

	#endif

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_enum_v
	= is_enum<_Tp>::value;
	#endif

	// is_arithmetic

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_arithmetic
	: public integral_constant<bool, is_integral<_Tp>::value \|\|
	is_floating_point<_Tp>::value> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_arithmetic_v
	= is_arithmetic<_Tp>::value;
	#endif

	// is_fundamental

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_fundamental
	: public integral_constant<bool, is_void<_Tp>::value \|\|
	__is_nullptr_t<_Tp>::value \|\|
	is_arithmetic<_Tp>::value> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_fundamental_v
	= is_fundamental<_Tp>::value;
	#endif

	// is_scalar

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_scalar
	: public integral_constant<bool, is_arithmetic<_Tp>::value \|\|
	is_member_pointer<_Tp>::value \|\|
	is_pointer<_Tp>::value \|\|
	__is_nullptr_t<_Tp>::value \|\|
	is_enum<_Tp>::value > {};

	template <> struct _LIBCPP_TEMPLATE_VIS is_scalar<nullptr_t> : public true_type {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_scalar_v
	= is_scalar<_Tp>::value;
	#endif

	// is_object

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_object
	: public integral_constant<bool, is_scalar<_Tp>::value \|\|
	is_array<_Tp>::value \|\|
	is_union<_Tp>::value \|\|
	is_class<_Tp>::value > {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_object_v
	= is_object<_Tp>::value;
	#endif

	// is_compound

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_compound
	: public integral_constant<bool, !is_fundamental<_Tp>::value> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_compound_v
	= is_compound<_Tp>::value;
	#endif


	// __is_referenceable [defns.referenceable]

	struct __is_referenceable_impl {
	template <class _Tp> static _Tp& __test(int);
	template <class _Tp> static __two __test(...);
	};

	template <class _Tp>
	struct __is_referenceable : integral_constant<bool,
	!is_same<decltype(__is_referenceable_impl::__test<_Tp>(0)), __two>::value> {};


	// add_const

	template <class _Tp, bool = is_reference<_Tp>::value \|\|
	is_function<_Tp>::value \|\|
	is_const<_Tp>::value >
	struct __add_const {typedef _Tp type;};

	template <class _Tp>
	struct __add_const<_Tp, false> {typedef const _Tp type;};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_const
	{typedef typename __add_const<_Tp>::type type;};

	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using add_const_t = typename add_const<_Tp>::type;
	#endif

	// add_volatile

	template <class _Tp, bool = is_reference<_Tp>::value \|\|
	is_function<_Tp>::value \|\|
	is_volatile<_Tp>::value >
	struct __add_volatile {typedef _Tp type;};

	template <class _Tp>
	struct __add_volatile<_Tp, false> {typedef volatile _Tp type;};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_volatile
	{typedef typename __add_volatile<_Tp>::type type;};

	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using add_volatile_t = typename add_volatile<_Tp>::type;
	#endif

	// add_cv

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_cv
	{typedef typename add_const<typename add_volatile<_Tp>::type>::type type;};

	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type;
	#endif

	// remove_reference

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference {typedef _Tp type;};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&> {typedef _Tp type;};
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&&> {typedef _Tp type;};
	#endif

	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using remove_reference_t = typename remove_reference<_Tp>::type;
	#endif

	// add_lvalue_reference

	template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_lvalue_reference_impl { typedef _Tp type; };
	template <class _Tp > struct __add_lvalue_reference_impl<_Tp, true> { typedef _Tp& type; };

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_lvalue_reference
	{typedef typename __add_lvalue_reference_impl<_Tp>::type type;};

	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
	#endif

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_rvalue_reference_impl { typedef _Tp type; };
	template <class _Tp > struct __add_rvalue_reference_impl<_Tp, true> { typedef _Tp&& type; };

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_rvalue_reference
	{typedef typename __add_rvalue_reference_impl<_Tp>::type type;};

	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
	#endif

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Tp> _Tp&& __declval(int);
	template <class _Tp> _Tp __declval(long);

	template <class _Tp>
	decltype(_VSTD::__declval<_Tp>(0))
	declval() _NOEXCEPT;

	#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Tp>
	typename add_lvalue_reference<_Tp>::type
	declval();

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	// __uncvref

	template <class _Tp>
	struct __uncvref {
	typedef typename remove_cv<typename remove_reference<_Tp>::type>::type type;
	};

	template <class _Tp>
	struct __unconstref {
	typedef typename remove_const<typename remove_reference<_Tp>::type>::type type;
	};

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Tp>
	using __uncvref_t = typename __uncvref<_Tp>::type;
	#endif

	// __is_same_uncvref

	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
	+// remove_cvref - same as __uncvref
	template <class _Tp>
	-struct remove_cvref {
	- using type = remove_cv_t<remove_reference_t<_Tp>>;
	-};
	+struct remove_cvref : public __uncvref<_Tp> {};

	template <class _Tp> using remove_cvref_t = typename remove_cvref<_Tp>::type;
	#endif


	struct __any
	{
	__any(...);
	};

	// remove_pointer

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer {typedef _Tp type;};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp*> {typedef _Tp type;};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const> {typedef _Tp type;};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* volatile> {typedef _Tp type;};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const volatile> {typedef _Tp type;};

	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using remove_pointer_t = typename remove_pointer<_Tp>::type;
	#endif

	// add_pointer

	-template <class _Tp,
	- bool = __is_referenceable<_Tp>::value \|\|
	+template <class _Tp,
	+ bool = __is_referenceable<_Tp>::value \|\|
	is_same<typename remove_cv<_Tp>::type, void>::value>
	struct __add_pointer_impl
	{typedef typename remove_reference<_Tp>::type* type;};
	-template <class _Tp> struct __add_pointer_impl<_Tp, false>
	+template <class _Tp> struct __add_pointer_impl<_Tp, false>
	{typedef _Tp type;};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_pointer
	{typedef typename __add_pointer_impl<_Tp>::type type;};

	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using add_pointer_t = typename add_pointer<_Tp>::type;
	#endif

	// is_signed

	template <class _Tp, bool = is_integral<_Tp>::value>
	struct __libcpp_is_signed_impl : public _LIBCPP_BOOL_CONSTANT(_Tp(-1) < _Tp(0)) {};

	template <class _Tp>
	struct __libcpp_is_signed_impl<_Tp, false> : public true_type {}; // floating point

	template <class _Tp, bool = is_arithmetic<_Tp>::value>
	struct __libcpp_is_signed : public __libcpp_is_signed_impl<_Tp> {};

	template <class _Tp> struct __libcpp_is_signed<_Tp, false> : public false_type {};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_signed : public __libcpp_is_signed<_Tp> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_signed_v
	= is_signed<_Tp>::value;
	#endif

	// is_unsigned

	template <class _Tp, bool = is_integral<_Tp>::value>
	struct __libcpp_is_unsigned_impl : public _LIBCPP_BOOL_CONSTANT(_Tp(0) < _Tp(-1)) {};

	template <class _Tp>
	struct __libcpp_is_unsigned_impl<_Tp, false> : public false_type {}; // floating point

	template <class _Tp, bool = is_arithmetic<_Tp>::value>
	struct __libcpp_is_unsigned : public __libcpp_is_unsigned_impl<_Tp> {};

	template <class _Tp> struct __libcpp_is_unsigned<_Tp, false> : public false_type {};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_unsigned : public __libcpp_is_unsigned<_Tp> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_unsigned_v
	= is_unsigned<_Tp>::value;
	#endif

	// rank

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank
	: public integral_constant<size_t, 0> {};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank<_Tp[]>
	: public integral_constant<size_t, rank<_Tp>::value + 1> {};
	template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS rank<_Tp[_Np]>
	: public integral_constant<size_t, rank<_Tp>::value + 1> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR size_t rank_v
	= rank<_Tp>::value;
	#endif

	// extent

	template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_TEMPLATE_VIS extent
	: public integral_constant<size_t, 0> {};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], 0>
	: public integral_constant<size_t, 0> {};
	template <class _Tp, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], _Ip>
	: public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
	template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], 0>
	: public integral_constant<size_t, _Np> {};
	template <class _Tp, size_t _Np, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], _Ip>
	: public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp, unsigned _Ip = 0>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR size_t extent_v
	= extent<_Tp, _Ip>::value;
	#endif

	// remove_extent

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent
	{typedef _Tp type;};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[]>
	{typedef _Tp type;};
	template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[_Np]>
	{typedef _Tp type;};

	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using remove_extent_t = typename remove_extent<_Tp>::type;
	#endif

	// remove_all_extents

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_all_extents
	{typedef _Tp type;};
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[]>
	{typedef typename remove_all_extents<_Tp>::type type;};
	template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[_Np]>
	{typedef typename remove_all_extents<_Tp>::type type;};

	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
	#endif

	// decay

	template <class _Up, bool>
	struct __decay {
	typedef typename remove_cv<_Up>::type type;
	};

	template <class _Up>
	struct __decay<_Up, true> {
	public:
	typedef typename conditional
	<
	is_array<_Up>::value,
	typename remove_extent<_Up>::type*,
	typename conditional
	<
	is_function<_Up>::value,
	typename add_pointer<_Up>::type,
	typename remove_cv<_Up>::type
	>::type
	>::type type;
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS decay
	{
	private:
	typedef typename remove_reference<_Tp>::type _Up;
	public:
	typedef typename __decay<_Up, __is_referenceable<_Up>::value>::type type;
	};

	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using decay_t = typename decay<_Tp>::type;
	#endif

	// is_abstract

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_abstract
	: public integral_constant<bool, __is_abstract(_Tp)> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_abstract_v
	= is_abstract<_Tp>::value;
	#endif

	// is_final

	#if defined(_LIBCPP_HAS_IS_FINAL)
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS
	__libcpp_is_final : public integral_constant<bool, __is_final(_Tp)> {};
	#else
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS
	__libcpp_is_final : public false_type {};
	#endif

	#if defined(_LIBCPP_HAS_IS_FINAL) && _LIBCPP_STD_VER > 11
	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS
	is_final : public integral_constant<bool, __is_final(_Tp)> {};
	#endif

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_final_v
	= is_final<_Tp>::value;
	#endif

	// is_aggregate
	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_IS_AGGREGATE)

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS
	is_aggregate : public integral_constant<bool, __is_aggregate(_Tp)> {};

	#if !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR constexpr bool is_aggregate_v
	= is_aggregate<_Tp>::value;
	#endif

	#endif // _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_IS_AGGREGATE)

	// is_base_of

	#ifdef _LIBCPP_HAS_IS_BASE_OF

	template <class _Bp, class _Dp>
	struct _LIBCPP_TEMPLATE_VIS is_base_of
	: public integral_constant<bool, __is_base_of(_Bp, _Dp)> {};

	#else // _LIBCPP_HAS_IS_BASE_OF

	namespace __is_base_of_imp
	{
	template <class _Tp>
	struct _Dst
	{
	_Dst(const volatile _Tp &);
	};
	template <class _Tp>
	struct _Src
	{
	operator const volatile _Tp &();
	template <class _Up> operator const _Dst<_Up> &();
	};
	template <size_t> struct __one { typedef char type; };
	template <class _Bp, class _Dp> typename __one<sizeof(_Dst<_Bp>(declval<_Src<_Dp> >()))>::type __test(int);
	template <class _Bp, class _Dp> __two __test(...);
	}

	template <class _Bp, class _Dp>
	struct _LIBCPP_TEMPLATE_VIS is_base_of
	: public integral_constant<bool, is_class<_Bp>::value &&
	sizeof(__is_base_of_imp::__test<_Bp, _Dp>(0)) == 2> {};

	#endif // _LIBCPP_HAS_IS_BASE_OF

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Bp, class _Dp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_base_of_v
	= is_base_of<_Bp, _Dp>::value;
	#endif

	// is_convertible

	#if __has_feature(is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK)

	template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS is_convertible
	: public integral_constant<bool, __is_convertible_to(_T1, _T2) &&
	!is_abstract<_T2>::value> {};

	#else // __has_feature(is_convertible_to)

	namespace __is_convertible_imp
	{
	template <class _Tp> void __test_convert(_Tp);

	template <class _From, class _To, class = void>
	struct __is_convertible_test : public false_type {};

	template <class _From, class _To>
	struct __is_convertible_test<_From, _To,
	decltype(_VSTD::__is_convertible_imp::__test_convert<_To>(_VSTD::declval<_From>()))> : public true_type
	{};

	template <class _Tp, bool _IsArray = is_array<_Tp>::value,
	bool _IsFunction = is_function<_Tp>::value,
	bool _IsVoid = is_void<_Tp>::value>
	struct __is_array_function_or_void {enum {value = 0};};
	template <class _Tp> struct __is_array_function_or_void<_Tp, true, false, false> {enum {value = 1};};
	template <class _Tp> struct __is_array_function_or_void<_Tp, false, true, false> {enum {value = 2};};
	template <class _Tp> struct __is_array_function_or_void<_Tp, false, false, true> {enum {value = 3};};
	}

	template <class _Tp,
	unsigned = __is_convertible_imp::__is_array_function_or_void<typename remove_reference<_Tp>::type>::value>
	struct __is_convertible_check
	{
	static const size_t __v = 0;
	};

	template <class _Tp>
	struct __is_convertible_check<_Tp, 0>
	{
	static const size_t __v = sizeof(_Tp);
	};

	template <class _T1, class _T2,
	unsigned _T1_is_array_function_or_void = __is_convertible_imp::__is_array_function_or_void<_T1>::value,
	unsigned _T2_is_array_function_or_void = __is_convertible_imp::__is_array_function_or_void<_T2>::value>
	struct __is_convertible
	: public integral_constant<bool,
	__is_convertible_imp::__is_convertible_test<_T1, _T2>::value
	#if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
	&& !(!is_function<_T1>::value && !is_reference<_T1>::value && is_reference<_T2>::value
	&& (!is_const<typename remove_reference<_T2>::type>::value
	\|\| is_volatile<typename remove_reference<_T2>::type>::value)
	&& (is_same<typename remove_cv<_T1>::type,
	typename remove_cv<typename remove_reference<_T2>::type>::type>::value
	\|\| is_base_of<typename remove_reference<_T2>::type, _T1>::value))
	#endif
	>
	{};

	template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 1> : public false_type {};
	template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 1> : public false_type {};
	template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 1> : public false_type {};
	template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 1> : public false_type {};

	template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 2> : public false_type {};
	template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 2> : public false_type {};
	template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 2> : public false_type {};
	template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 2> : public false_type {};

	template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 3> : public false_type {};
	template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 3> : public false_type {};
	template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 3> : public false_type {};
	template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 3> : public true_type {};

	template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS is_convertible
	: public __is_convertible<_T1, _T2>
	{
	static const size_t __complete_check1 = __is_convertible_check<_T1>::__v;
	static const size_t __complete_check2 = __is_convertible_check<_T2>::__v;
	};

	#endif // __has_feature(is_convertible_to)

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _From, class _To>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_convertible_v
	= is_convertible<_From, _To>::value;
	#endif

	// is_empty

	#if __has_feature(is_empty) \|\| (_GNUC_VER >= 407)

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_empty
	: public integral_constant<bool, __is_empty(_Tp)> {};

	#else // __has_feature(is_empty)

	template <class _Tp>
	struct __is_empty1
	: public _Tp
	{
	double __lx;
	};

	struct __is_empty2
	{
	double __lx;
	};

	template <class _Tp, bool = is_class<_Tp>::value>
	struct __libcpp_empty : public integral_constant<bool, sizeof(__is_empty1<_Tp>) == sizeof(__is_empty2)> {};

	template <class _Tp> struct __libcpp_empty<_Tp, false> : public false_type {};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_empty : public __libcpp_empty<_Tp> {};

	#endif // __has_feature(is_empty)

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_empty_v
	= is_empty<_Tp>::value;
	#endif

	// is_polymorphic

	#if __has_feature(is_polymorphic) \|\| defined(_LIBCPP_COMPILER_MSVC)

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_polymorphic
	: public integral_constant<bool, __is_polymorphic(_Tp)> {};

	#else

	template<typename _Tp> char &__is_polymorphic_impl(
	typename enable_if<sizeof((_Tp)dynamic_cast<const volatile void>(declval<_Tp*>())) != 0,
	int>::type);
	template<typename _Tp> __two &__is_polymorphic_impl(...);

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_polymorphic
	: public integral_constant<bool, sizeof(__is_polymorphic_impl<_Tp>(0)) == 1> {};

	#endif // __has_feature(is_polymorphic)

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_polymorphic_v
	= is_polymorphic<_Tp>::value;
	#endif

	// has_virtual_destructor

	#if __has_feature(has_virtual_destructor) \|\| (_GNUC_VER >= 403)

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_virtual_destructor
	: public integral_constant<bool, __has_virtual_destructor(_Tp)> {};

	#else

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_virtual_destructor
	: public false_type {};

	#endif

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool has_virtual_destructor_v
	= has_virtual_destructor<_Tp>::value;
	#endif

	// has_unique_object_representations

	#if _LIBCPP_STD_VER > 14 && defined(_LIBCPP_HAS_UNIQUE_OBJECT_REPRESENTATIONS)

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_unique_object_representations
	- : public integral_constant<bool,
	+ : public integral_constant<bool,
	__has_unique_object_representations(remove_cv_t<remove_all_extents_t<_Tp>>)> {};

	#if !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool has_unique_object_representations_v
	= has_unique_object_representations<_Tp>::value;
	#endif

	#endif

	// alignment_of

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS alignment_of
	: public integral_constant<size_t, __alignof__(_Tp)> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR size_t alignment_of_v
	= alignment_of<_Tp>::value;
	#endif

	// aligned_storage

	template <class _Hp, class _Tp>
	struct __type_list
	{
	typedef _Hp _Head;
	typedef _Tp _Tail;
	};

	struct __nat
	{
	#ifndef _LIBCPP_CXX03_LANG
	__nat() = delete;
	__nat(const __nat&) = delete;
	__nat& operator=(const __nat&) = delete;
	~__nat() = delete;
	#endif
	};

	template <class _Tp>
	struct __align_type
	{
	static const size_t value = alignment_of<_Tp>::value;
	typedef _Tp type;
	};

	struct __struct_double {long double __lx;};
	struct __struct_double4 {double __lx[4];};

	typedef
	__type_list<__align_type<unsigned char>,
	__type_list<__align_type<unsigned short>,
	__type_list<__align_type<unsigned int>,
	__type_list<__align_type<unsigned long>,
	__type_list<__align_type<unsigned long long>,
	__type_list<__align_type<double>,
	__type_list<__align_type<long double>,
	__type_list<__align_type<__struct_double>,
	__type_list<__align_type<__struct_double4>,
	__type_list<__align_type<int*>,
	__nat
	> > > > > > > > > > __all_types;

	template <class _TL, size_t _Align> struct __find_pod;

	template <class _Hp, size_t _Align>
	struct __find_pod<__type_list<_Hp, __nat>, _Align>
	{
	typedef typename conditional<
	_Align == _Hp::value,
	typename _Hp::type,
	void
	>::type type;
	};

	template <class _Hp, class _Tp, size_t _Align>
	struct __find_pod<__type_list<_Hp, _Tp>, _Align>
	{
	typedef typename conditional<
	_Align == _Hp::value,
	typename _Hp::type,
	typename __find_pod<_Tp, _Align>::type
	>::type type;
	};

	template <class _TL, size_t _Len> struct __find_max_align;

	template <class _Hp, size_t _Len>
	struct __find_max_align<__type_list<_Hp, __nat>, _Len> : public integral_constant<size_t, _Hp::value> {};

	template <size_t _Len, size_t _A1, size_t _A2>
	struct __select_align
	{
	private:
	static const size_t __min = _A2 < _A1 ? _A2 : _A1;
	static const size_t __max = _A1 < _A2 ? _A2 : _A1;
	public:
	static const size_t value = _Len < __max ? __min : __max;
	};

	template <class _Hp, class _Tp, size_t _Len>
	struct __find_max_align<__type_list<_Hp, _Tp>, _Len>
	: public integral_constant<size_t, __select_align<_Len, _Hp::value, __find_max_align<_Tp, _Len>::value>::value> {};

	template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
	struct _LIBCPP_TEMPLATE_VIS aligned_storage
	{
	typedef typename __find_pod<__all_types, _Align>::type _Aligner;
	static_assert(!is_void<_Aligner>::value, "");
	union type
	{
	_Aligner __align;
	unsigned char __data[(_Len + _Align - 1)/_Align * _Align];
	};
	};

	#if _LIBCPP_STD_VER > 11
	template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
	using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
	#endif

	#define _CREATE_ALIGNED_STORAGE_SPECIALIZATION(n) \
	template <size_t _Len>\
	struct _LIBCPP_TEMPLATE_VIS aligned_storage<_Len, n>\
	{\
	struct _ALIGNAS(n) type\
	{\
	unsigned char __lx[(_Len + n - 1)/n * n];\
	};\
	}

	_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1);
	_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x2);
	_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4);
	_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x8);
	_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x10);
	_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x20);
	_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x40);
	_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x80);
	_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x100);
	_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x200);
	_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x400);
	_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x800);
	_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1000);
	_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x2000);
	// PE/COFF does not support alignment beyond 8192 (=0x2000)
	#if !defined(_LIBCPP_OBJECT_FORMAT_COFF)
	_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4000);
	#endif // !defined(_LIBCPP_OBJECT_FORMAT_COFF)

	#undef _CREATE_ALIGNED_STORAGE_SPECIALIZATION

	#ifndef _LIBCPP_HAS_NO_VARIADICS

	// aligned_union

	template <size_t _I0, size_t ..._In>
	struct __static_max;

	template <size_t _I0>
	struct __static_max<_I0>
	{
	static const size_t value = _I0;
	};

	template <size_t _I0, size_t _I1, size_t ..._In>
	struct __static_max<_I0, _I1, _In...>
	{
	static const size_t value = _I0 >= _I1 ? __static_max<_I0, _In...>::value :
	__static_max<_I1, _In...>::value;
	};

	template <size_t _Len, class _Type0, class ..._Types>
	struct aligned_union
	{
	static const size_t alignment_value = __static_max<__alignof__(_Type0),
	__alignof__(_Types)...>::value;
	static const size_t __len = __static_max<_Len, sizeof(_Type0),
	sizeof(_Types)...>::value;
	typedef typename aligned_storage<__len, alignment_value>::type type;
	};

	#if _LIBCPP_STD_VER > 11
	template <size_t _Len, class ..._Types> using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
	#endif

	#endif // _LIBCPP_HAS_NO_VARIADICS

	template <class _Tp>
	struct __numeric_type
	{
	static void __test(...);
	static float __test(float);
	static double __test(char);
	static double __test(int);
	static double __test(unsigned);
	static double __test(long);
	static double __test(unsigned long);
	static double __test(long long);
	static double __test(unsigned long long);
	static double __test(double);
	static long double __test(long double);

	typedef decltype(__test(declval<_Tp>())) type;
	static const bool value = !is_same<type, void>::value;
	};

	template <>
	struct __numeric_type<void>
	{
	static const bool value = true;
	};

	// __promote

	template <class _A1, class _A2 = void, class _A3 = void,
	bool = __numeric_type<_A1>::value &&
	__numeric_type<_A2>::value &&
	__numeric_type<_A3>::value>
	class __promote_imp
	{
	public:
	static const bool value = false;
	};

	template <class _A1, class _A2, class _A3>
	class __promote_imp<_A1, _A2, _A3, true>
	{
	private:
	typedef typename __promote_imp<_A1>::type __type1;
	typedef typename __promote_imp<_A2>::type __type2;
	typedef typename __promote_imp<_A3>::type __type3;
	public:
	typedef decltype(__type1() + __type2() + __type3()) type;
	static const bool value = true;
	};

	template <class _A1, class _A2>
	class __promote_imp<_A1, _A2, void, true>
	{
	private:
	typedef typename __promote_imp<_A1>::type __type1;
	typedef typename __promote_imp<_A2>::type __type2;
	public:
	typedef decltype(__type1() + __type2()) type;
	static const bool value = true;
	};

	template <class _A1>
	class __promote_imp<_A1, void, void, true>
	{
	public:
	typedef typename __numeric_type<_A1>::type type;
	static const bool value = true;
	};

	template <class _A1, class _A2 = void, class _A3 = void>
	class __promote : public __promote_imp<_A1, _A2, _A3> {};

	// make_signed / make_unsigned

	typedef
	__type_list<signed char,
	__type_list<signed short,
	__type_list<signed int,
	__type_list<signed long,
	__type_list<signed long long,
	#ifndef _LIBCPP_HAS_NO_INT128
	__type_list<__int128_t,
	#endif
	__nat
	#ifndef _LIBCPP_HAS_NO_INT128
	>
	#endif
	> > > > > __signed_types;

	typedef
	__type_list<unsigned char,
	__type_list<unsigned short,
	__type_list<unsigned int,
	__type_list<unsigned long,
	__type_list<unsigned long long,
	#ifndef _LIBCPP_HAS_NO_INT128
	__type_list<__uint128_t,
	#endif
	__nat
	#ifndef _LIBCPP_HAS_NO_INT128
	>
	#endif
	> > > > > __unsigned_types;

	template <class _TypeList, size_t _Size, bool = _Size <= sizeof(typename _TypeList::_Head)> struct __find_first;

	template <class _Hp, class _Tp, size_t _Size>
	struct __find_first<__type_list<_Hp, _Tp>, _Size, true>
	{
	typedef _Hp type;
	};

	template <class _Hp, class _Tp, size_t _Size>
	struct __find_first<__type_list<_Hp, _Tp>, _Size, false>
	{
	typedef typename __find_first<_Tp, _Size>::type type;
	};

	template <class _Tp, class _Up, bool = is_const<typename remove_reference<_Tp>::type>::value,
	bool = is_volatile<typename remove_reference<_Tp>::type>::value>
	struct __apply_cv
	{
	typedef _Up type;
	};

	template <class _Tp, class _Up>
	struct __apply_cv<_Tp, _Up, true, false>
	{
	typedef const _Up type;
	};

	template <class _Tp, class _Up>
	struct __apply_cv<_Tp, _Up, false, true>
	{
	typedef volatile _Up type;
	};

	template <class _Tp, class _Up>
	struct __apply_cv<_Tp, _Up, true, true>
	{
	typedef const volatile _Up type;
	};

	template <class _Tp, class _Up>
	struct __apply_cv<_Tp&, _Up, false, false>
	{
	typedef _Up& type;
	};

	template <class _Tp, class _Up>
	struct __apply_cv<_Tp&, _Up, true, false>
	{
	typedef const _Up& type;
	};

	template <class _Tp, class _Up>
	struct __apply_cv<_Tp&, _Up, false, true>
	{
	typedef volatile _Up& type;
	};

	template <class _Tp, class _Up>
	struct __apply_cv<_Tp&, _Up, true, true>
	{
	typedef const volatile _Up& type;
	};

	template <class _Tp, bool = is_integral<_Tp>::value \|\| is_enum<_Tp>::value>
	struct __make_signed {};

	template <class _Tp>
	struct __make_signed<_Tp, true>
	{
	typedef typename __find_first<__signed_types, sizeof(_Tp)>::type type;
	};

	template <> struct __make_signed<bool, true> {};
	template <> struct __make_signed< signed short, true> {typedef short type;};
	template <> struct __make_signed<unsigned short, true> {typedef short type;};
	template <> struct __make_signed< signed int, true> {typedef int type;};
	template <> struct __make_signed<unsigned int, true> {typedef int type;};
	template <> struct __make_signed< signed long, true> {typedef long type;};
	template <> struct __make_signed<unsigned long, true> {typedef long type;};
	template <> struct __make_signed< signed long long, true> {typedef long long type;};
	template <> struct __make_signed<unsigned long long, true> {typedef long long type;};
	#ifndef _LIBCPP_HAS_NO_INT128
	template <> struct __make_signed<__int128_t, true> {typedef __int128_t type;};
	template <> struct __make_signed<__uint128_t, true> {typedef __int128_t type;};
	#endif

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS make_signed
	{
	typedef typename __apply_cv<_Tp, typename __make_signed<typename remove_cv<_Tp>::type>::type>::type type;
	};

	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using make_signed_t = typename make_signed<_Tp>::type;
	#endif

	template <class _Tp, bool = is_integral<_Tp>::value \|\| is_enum<_Tp>::value>
	struct __make_unsigned {};

	template <class _Tp>
	struct __make_unsigned<_Tp, true>
	{
	typedef typename __find_first<__unsigned_types, sizeof(_Tp)>::type type;
	};

	template <> struct __make_unsigned<bool, true> {};
	template <> struct __make_unsigned< signed short, true> {typedef unsigned short type;};
	template <> struct __make_unsigned<unsigned short, true> {typedef unsigned short type;};
	template <> struct __make_unsigned< signed int, true> {typedef unsigned int type;};
	template <> struct __make_unsigned<unsigned int, true> {typedef unsigned int type;};
	template <> struct __make_unsigned< signed long, true> {typedef unsigned long type;};
	template <> struct __make_unsigned<unsigned long, true> {typedef unsigned long type;};
	template <> struct __make_unsigned< signed long long, true> {typedef unsigned long long type;};
	template <> struct __make_unsigned<unsigned long long, true> {typedef unsigned long long type;};
	#ifndef _LIBCPP_HAS_NO_INT128
	template <> struct __make_unsigned<__int128_t, true> {typedef __uint128_t type;};
	template <> struct __make_unsigned<__uint128_t, true> {typedef __uint128_t type;};
	#endif

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS make_unsigned
	{
	typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type;
	};

	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using make_unsigned_t = typename make_unsigned<_Tp>::type;
	#endif

	#ifdef _LIBCPP_HAS_NO_VARIADICS

	template <class _Tp, class _Up = void, class _Vp = void>
	struct _LIBCPP_TEMPLATE_VIS common_type
	{
	public:
	typedef typename common_type<typename common_type<_Tp, _Up>::type, _Vp>::type type;
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS common_type<void, void, void>
	{
	public:
	typedef void type;
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS common_type<_Tp, void, void>
	{
	public:
	typedef typename common_type<_Tp, _Tp>::type type;
	};

	template <class _Tp, class _Up>
	struct _LIBCPP_TEMPLATE_VIS common_type<_Tp, _Up, void>
	{
	typedef typename decay<decltype(
	true ? _VSTD::declval<_Tp>() : _VSTD::declval<_Up>()
	)>::type type;
	};

	#else // _LIBCPP_HAS_NO_VARIADICS

	// bullet 1 - sizeof...(Tp) == 0

	template <class ..._Tp>
	struct _LIBCPP_TEMPLATE_VIS common_type {};

	// bullet 2 - sizeof...(Tp) == 1

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS common_type<_Tp>
	: public common_type<_Tp, _Tp> {};

	// bullet 3 - sizeof...(Tp) == 2

	template <class _Tp, class _Up, class = void>
	struct __common_type2_imp {};

	template <class _Tp, class _Up>
	struct __common_type2_imp<_Tp, _Up,
	typename __void_t<decltype(
	true ? _VSTD::declval<_Tp>() : _VSTD::declval<_Up>()
	)>::type>
	{
	typedef typename decay<decltype(
	true ? _VSTD::declval<_Tp>() : _VSTD::declval<_Up>()
	)>::type type;
	};

	template <class _Tp, class _Up,
	class _DTp = typename decay<_Tp>::type,
	class _DUp = typename decay<_Up>::type>
	using __common_type2 =
	typename conditional<
	is_same<_Tp, _DTp>::value && is_same<_Up, _DUp>::value,
	__common_type2_imp<_Tp, _Up>,
	common_type<_DTp, _DUp>
	>::type;

	template <class _Tp, class _Up>
	struct _LIBCPP_TEMPLATE_VIS common_type<_Tp, _Up>
	: __common_type2<_Tp, _Up> {};

	// bullet 4 - sizeof...(Tp) > 2

	template <class ...Tp> struct __common_types;

	template <class, class = void>
	struct __common_type_impl {};

	template <class _Tp, class _Up>
	struct __common_type_impl<
	__common_types<_Tp, _Up>,
	typename __void_t<typename common_type<_Tp, _Up>::type>::type>
	{
	typedef typename common_type<_Tp, _Up>::type type;
	};

	template <class _Tp, class _Up, class ..._Vp>
	struct __common_type_impl<__common_types<_Tp, _Up, _Vp...>,
	typename __void_t<typename common_type<_Tp, _Up>::type>::type>
	: __common_type_impl<
	__common_types<typename common_type<_Tp, _Up>::type, _Vp...> >
	{

	};

	template <class _Tp, class _Up, class ..._Vp>
	struct _LIBCPP_TEMPLATE_VIS common_type<_Tp, _Up, _Vp...>
	: __common_type_impl<__common_types<_Tp, _Up, _Vp...> > {};

	#if _LIBCPP_STD_VER > 11
	template <class ..._Tp> using common_type_t = typename common_type<_Tp...>::type;
	#endif

	#endif // _LIBCPP_HAS_NO_VARIADICS

	// is_assignable

	template<typename, typename _Tp> struct __select_2nd { typedef _Tp type; };

	template <class _Tp, class _Arg>
	typename __select_2nd<decltype((_VSTD::declval<_Tp>() = _VSTD::declval<_Arg>())), true_type>::type
	__is_assignable_test(int);

	template <class, class>
	false_type __is_assignable_test(...);


	template <class _Tp, class _Arg, bool = is_void<_Tp>::value \|\| is_void<_Arg>::value>
	struct __is_assignable_imp
	: public decltype((_VSTD::__is_assignable_test<_Tp, _Arg>(0))) {};

	template <class _Tp, class _Arg>
	struct __is_assignable_imp<_Tp, _Arg, true>
	: public false_type
	{
	};

	template <class _Tp, class _Arg>
	struct is_assignable
	: public __is_assignable_imp<_Tp, _Arg> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp, class _Arg>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_assignable_v
	= is_assignable<_Tp, _Arg>::value;
	#endif

	// is_copy_assignable

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_copy_assignable
	: public is_assignable<typename add_lvalue_reference<_Tp>::type,
	typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_copy_assignable_v
	= is_copy_assignable<_Tp>::value;
	#endif

	// is_move_assignable

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_move_assignable
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	: public is_assignable<typename add_lvalue_reference<_Tp>::type,
	typename add_rvalue_reference<_Tp>::type> {};
	#else
	: public is_copy_assignable<_Tp> {};
	#endif

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_move_assignable_v
	= is_move_assignable<_Tp>::value;
	#endif

	// is_destructible

	// if it's a reference, return true
	// if it's a function, return false
	// if it's void, return false
	// if it's an array of unknown bound, return false
	// Otherwise, return "std::declval<_Up&>().~_Up()" is well-formed
	// where _Up is remove_all_extents<_Tp>::type

	template <class>
	struct __is_destructible_apply { typedef int type; };

	template <typename _Tp>
	struct __is_destructor_wellformed {
	template <typename _Tp1>
	static char __test (
	typename __is_destructible_apply<decltype(_VSTD::declval<_Tp1&>().~_Tp1())>::type
	);

	template <typename _Tp1>
	static __two __test (...);
	-
	+
	static const bool value = sizeof(__test<_Tp>(12)) == sizeof(char);
	};

	template <class _Tp, bool>
	struct __destructible_imp;

	template <class _Tp>
	-struct __destructible_imp<_Tp, false>
	- : public _VSTD::integral_constant<bool,
	+struct __destructible_imp<_Tp, false>
	+ : public _VSTD::integral_constant<bool,
	__is_destructor_wellformed<typename _VSTD::remove_all_extents<_Tp>::type>::value> {};

	template <class _Tp>
	struct __destructible_imp<_Tp, true>
	: public _VSTD::true_type {};

	template <class _Tp, bool>
	struct __destructible_false;

	template <class _Tp>
	struct __destructible_false<_Tp, false> : public __destructible_imp<_Tp, _VSTD::is_reference<_Tp>::value> {};

	template <class _Tp>
	struct __destructible_false<_Tp, true> : public _VSTD::false_type {};

	template <class _Tp>
	struct is_destructible
	: public __destructible_false<_Tp, _VSTD::is_function<_Tp>::value> {};

	template <class _Tp>
	struct is_destructible<_Tp[]>
	: public _VSTD::false_type {};

	template <>
	struct is_destructible<void>
	: public _VSTD::false_type {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_destructible_v
	= is_destructible<_Tp>::value;
	#endif

	// move

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	typename remove_reference<_Tp>::type&&
	move(_Tp&& __t) _NOEXCEPT
	{
	typedef typename remove_reference<_Tp>::type _Up;
	return static_cast<_Up&&>(__t);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	_Tp&&
	forward(typename remove_reference<_Tp>::type& __t) _NOEXCEPT
	{
	return static_cast<_Tp&&>(__t);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	_Tp&&
	forward(typename remove_reference<_Tp>::type&& __t) _NOEXCEPT
	{
	static_assert(!is_lvalue_reference<_Tp>::value,
	"can not forward an rvalue as an lvalue");
	return static_cast<_Tp&&>(__t);
	}

	#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp&
	move(_Tp& __t)
	{
	return __t;
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	const _Tp&
	move(const _Tp& __t)
	{
	return __t;
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp&
	forward(typename remove_reference<_Tp>::type& __t) _NOEXCEPT
	{
	return __t;
	}


	template <class _Tp>
	class __rv
	{
	typedef typename remove_reference<_Tp>::type _Trr;
	_Trr& t_;
	public:
	_LIBCPP_INLINE_VISIBILITY
	_Trr* operator->() {return &t_;}
	_LIBCPP_INLINE_VISIBILITY
	explicit __rv(_Trr& __t) : t_(__t) {}
	};

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename decay<_Tp>::type
	__decay_copy(_Tp&& __t)
	{
	return _VSTD::forward<_Tp>(__t);
	}

	#else

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	typename decay<_Tp>::type
	__decay_copy(const _Tp& __t)
	{
	return _VSTD::forward<_Tp>(__t);
	}

	#endif

	#ifndef _LIBCPP_HAS_NO_VARIADICS

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...), true, false>
	{
	typedef _Class _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...), true, false>
	{
	typedef _Class _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param..., ...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const, true, false>
	{
	typedef _Class const _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const, true, false>
	{
	typedef _Class const _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param..., ...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile, true, false>
	{
	typedef _Class volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) volatile, true, false>
	{
	typedef _Class volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param..., ...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile, true, false>
	{
	typedef _Class const volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatile, true, false>
	{
	typedef _Class const volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param..., ...);
	};

	#if __has_feature(cxx_reference_qualified_functions) \|\| \
	(defined(_GNUC_VER) && _GNUC_VER >= 409)

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &, true, false>
	{
	typedef _Class& _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) &, true, false>
	{
	typedef _Class& _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param..., ...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const&, true, false>
	{
	typedef _Class const& _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const&, true, false>
	{
	typedef _Class const& _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param..., ...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile&, true, false>
	{
	typedef _Class volatile& _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) volatile&, true, false>
	{
	typedef _Class volatile& _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param..., ...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile&, true, false>
	{
	typedef _Class const volatile& _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatile&, true, false>
	{
	typedef _Class const volatile& _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param..., ...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &&, true, false>
	{
	typedef _Class&& _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) &&, true, false>
	{
	typedef _Class&& _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param..., ...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const&&, true, false>
	{
	typedef _Class const&& _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const&&, true, false>
	{
	typedef _Class const&& _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param..., ...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile&&, true, false>
	{
	typedef _Class volatile&& _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) volatile&&, true, false>
	{
	typedef _Class volatile&& _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param..., ...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile&&, true, false>
	{
	typedef _Class const volatile&& _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param...);
	};

	template <class _Rp, class _Class, class ..._Param>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatile&&, true, false>
	{
	typedef _Class const volatile&& _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_Param..., ...);
	};

	#endif // __has_feature(cxx_reference_qualified_functions) \|\| _GNUC_VER >= 409

	#else // _LIBCPP_HAS_NO_VARIADICS

	template <class _Rp, class _Class>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(), true, false>
	{
	typedef _Class _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) ();
	};

	template <class _Rp, class _Class>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(...), true, false>
	{
	typedef _Class _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (...);
	};

	template <class _Rp, class _Class, class _P0>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0), true, false>
	{
	typedef _Class _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0);
	};

	template <class _Rp, class _Class, class _P0>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, ...), true, false>
	{
	typedef _Class _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, ...);
	};

	template <class _Rp, class _Class, class _P0, class _P1>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1), true, false>
	{
	typedef _Class _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, _P1);
	};

	template <class _Rp, class _Class, class _P0, class _P1>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1, ...), true, false>
	{
	typedef _Class _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, _P1, ...);
	};

	template <class _Rp, class _Class, class _P0, class _P1, class _P2>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1, _P2), true, false>
	{
	typedef _Class _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, _P1, _P2);
	};

	template <class _Rp, class _Class, class _P0, class _P1, class _P2>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1, _P2, ...), true, false>
	{
	typedef _Class _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, _P1, _P2, ...);
	};

	template <class _Rp, class _Class>
	struct __member_pointer_traits_imp<_Rp (_Class::*)() const, true, false>
	{
	typedef _Class const _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) ();
	};

	template <class _Rp, class _Class>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(...) const, true, false>
	{
	typedef _Class const _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (...);
	};

	template <class _Rp, class _Class, class _P0>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0) const, true, false>
	{
	typedef _Class const _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0);
	};

	template <class _Rp, class _Class, class _P0>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, ...) const, true, false>
	{
	typedef _Class const _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, ...);
	};

	template <class _Rp, class _Class, class _P0, class _P1>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1) const, true, false>
	{
	typedef _Class const _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, _P1);
	};

	template <class _Rp, class _Class, class _P0, class _P1>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1, ...) const, true, false>
	{
	typedef _Class const _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, _P1, ...);
	};

	template <class _Rp, class _Class, class _P0, class _P1, class _P2>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1, _P2) const, true, false>
	{
	typedef _Class const _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, _P1, _P2);
	};

	template <class _Rp, class _Class, class _P0, class _P1, class _P2>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1, _P2, ...) const, true, false>
	{
	typedef _Class const _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, _P1, _P2, ...);
	};

	template <class _Rp, class _Class>
	struct __member_pointer_traits_imp<_Rp (_Class::*)() volatile, true, false>
	{
	typedef _Class volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) ();
	};

	template <class _Rp, class _Class>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(...) volatile, true, false>
	{
	typedef _Class volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (...);
	};

	template <class _Rp, class _Class, class _P0>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0) volatile, true, false>
	{
	typedef _Class volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0);
	};

	template <class _Rp, class _Class, class _P0>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, ...) volatile, true, false>
	{
	typedef _Class volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, ...);
	};

	template <class _Rp, class _Class, class _P0, class _P1>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1) volatile, true, false>
	{
	typedef _Class volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, _P1);
	};

	template <class _Rp, class _Class, class _P0, class _P1>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1, ...) volatile, true, false>
	{
	typedef _Class volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, _P1, ...);
	};

	template <class _Rp, class _Class, class _P0, class _P1, class _P2>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1, _P2) volatile, true, false>
	{
	typedef _Class volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, _P1, _P2);
	};

	template <class _Rp, class _Class, class _P0, class _P1, class _P2>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1, _P2, ...) volatile, true, false>
	{
	typedef _Class volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, _P1, _P2, ...);
	};

	template <class _Rp, class _Class>
	struct __member_pointer_traits_imp<_Rp (_Class::*)() const volatile, true, false>
	{
	typedef _Class const volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) ();
	};

	template <class _Rp, class _Class>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(...) const volatile, true, false>
	{
	typedef _Class const volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (...);
	};

	template <class _Rp, class _Class, class _P0>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0) const volatile, true, false>
	{
	typedef _Class const volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0);
	};

	template <class _Rp, class _Class, class _P0>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, ...) const volatile, true, false>
	{
	typedef _Class const volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, ...);
	};

	template <class _Rp, class _Class, class _P0, class _P1>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1) const volatile, true, false>
	{
	typedef _Class const volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, _P1);
	};

	template <class _Rp, class _Class, class _P0, class _P1>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1, ...) const volatile, true, false>
	{
	typedef _Class const volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, _P1, ...);
	};

	template <class _Rp, class _Class, class _P0, class _P1, class _P2>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1, _P2) const volatile, true, false>
	{
	typedef _Class const volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, _P1, _P2);
	};

	template <class _Rp, class _Class, class _P0, class _P1, class _P2>
	struct __member_pointer_traits_imp<_Rp (_Class::*)(_P0, _P1, _P2, ...) const volatile, true, false>
	{
	typedef _Class const volatile _ClassType;
	typedef _Rp _ReturnType;
	typedef _Rp (_FnType) (_P0, _P1, _P2, ...);
	};

	#endif // _LIBCPP_HAS_NO_VARIADICS

	template <class _Rp, class _Class>
	struct __member_pointer_traits_imp<_Rp _Class::*, false, true>
	{
	typedef _Class _ClassType;
	typedef _Rp _ReturnType;
	};

	template <class _MP>
	struct __member_pointer_traits
	: public __member_pointer_traits_imp<typename remove_cv<_MP>::type,
	is_member_function_pointer<_MP>::value,
	is_member_object_pointer<_MP>::value>
	{
	// typedef ... _ClassType;
	// typedef ... _ReturnType;
	// typedef ... _FnType;
	};


	template <class _DecayedFp>
	struct __member_pointer_class_type {};

	template <class _Ret, class _ClassType>
	struct __member_pointer_class_type<_Ret _ClassType::*> {
	typedef _ClassType type;
	};

	// result_of

	template <class _Callable> class result_of;

	#ifdef _LIBCPP_HAS_NO_VARIADICS

	template <class _Fn, bool, bool>
	class __result_of
	{
	};

	template <class _Fn>
	class __result_of<_Fn(), true, false>
	{
	public:
	typedef decltype(declval<_Fn>()()) type;
	};

	template <class _Fn, class _A0>
	class __result_of<_Fn(_A0), true, false>
	{
	public:
	typedef decltype(declval<_Fn>()(declval<_A0>())) type;
	};

	template <class _Fn, class _A0, class _A1>
	class __result_of<_Fn(_A0, _A1), true, false>
	{
	public:
	typedef decltype(declval<_Fn>()(declval<_A0>(), declval<_A1>())) type;
	};

	template <class _Fn, class _A0, class _A1, class _A2>
	class __result_of<_Fn(_A0, _A1, _A2), true, false>
	{
	public:
	typedef decltype(declval<_Fn>()(declval<_A0>(), declval<_A1>(), declval<_A2>())) type;
	};

	template <class _MP, class _Tp, bool _IsMemberFunctionPtr>
	struct __result_of_mp;

	// member function pointer

	template <class _MP, class _Tp>
	struct __result_of_mp<_MP, _Tp, true>
	: public __identity<typename __member_pointer_traits<_MP>::_ReturnType>
	{
	};

	// member data pointer

	template <class _MP, class _Tp, bool>
	struct __result_of_mdp;

	template <class _Rp, class _Class, class _Tp>
	struct __result_of_mdp<_Rp _Class::*, _Tp, false>
	{
	typedef typename __apply_cv<decltype(*_VSTD::declval<_Tp>()), _Rp>::type& type;
	};

	template <class _Rp, class _Class, class _Tp>
	struct __result_of_mdp<_Rp _Class::*, _Tp, true>
	{
	typedef typename __apply_cv<_Tp, _Rp>::type& type;
	};

	template <class _Rp, class _Class, class _Tp>
	struct __result_of_mp<_Rp _Class::*, _Tp, false>
	: public __result_of_mdp<_Rp _Class::*, _Tp,
	is_base_of<_Class, typename remove_reference<_Tp>::type>::value>
	{
	};



	template <class _Fn, class _Tp>
	class __result_of<_Fn(_Tp), false, true> // _Fn must be member pointer
	: public __result_of_mp<typename remove_reference<_Fn>::type,
	_Tp,
	is_member_function_pointer<typename remove_reference<_Fn>::type>::value>
	{
	};

	template <class _Fn, class _Tp, class _A0>
	class __result_of<_Fn(_Tp, _A0), false, true> // _Fn must be member pointer
	: public __result_of_mp<typename remove_reference<_Fn>::type,
	_Tp,
	is_member_function_pointer<typename remove_reference<_Fn>::type>::value>
	{
	};

	template <class _Fn, class _Tp, class _A0, class _A1>
	class __result_of<_Fn(_Tp, _A0, _A1), false, true> // _Fn must be member pointer
	: public __result_of_mp<typename remove_reference<_Fn>::type,
	_Tp,
	is_member_function_pointer<typename remove_reference<_Fn>::type>::value>
	{
	};

	template <class _Fn, class _Tp, class _A0, class _A1, class _A2>
	class __result_of<_Fn(_Tp, _A0, _A1, _A2), false, true> // _Fn must be member pointer
	: public __result_of_mp<typename remove_reference<_Fn>::type,
	_Tp,
	is_member_function_pointer<typename remove_reference<_Fn>::type>::value>
	{
	};

	// result_of

	template <class _Fn>
	class _LIBCPP_TEMPLATE_VIS result_of<_Fn()>
	: public __result_of<_Fn(),
	is_class<typename remove_reference<_Fn>::type>::value \|\|
	is_function<typename remove_pointer<typename remove_reference<_Fn>::type>::type>::value,
	is_member_pointer<typename remove_reference<_Fn>::type>::value
	>
	{
	};

	template <class _Fn, class _A0>
	class _LIBCPP_TEMPLATE_VIS result_of<_Fn(_A0)>
	: public __result_of<_Fn(_A0),
	is_class<typename remove_reference<_Fn>::type>::value \|\|
	is_function<typename remove_pointer<typename remove_reference<_Fn>::type>::type>::value,
	is_member_pointer<typename remove_reference<_Fn>::type>::value
	>
	{
	};

	template <class _Fn, class _A0, class _A1>
	class _LIBCPP_TEMPLATE_VIS result_of<_Fn(_A0, _A1)>
	: public __result_of<_Fn(_A0, _A1),
	is_class<typename remove_reference<_Fn>::type>::value \|\|
	is_function<typename remove_pointer<typename remove_reference<_Fn>::type>::type>::value,
	is_member_pointer<typename remove_reference<_Fn>::type>::value
	>
	{
	};

	template <class _Fn, class _A0, class _A1, class _A2>
	class _LIBCPP_TEMPLATE_VIS result_of<_Fn(_A0, _A1, _A2)>
	: public __result_of<_Fn(_A0, _A1, _A2),
	is_class<typename remove_reference<_Fn>::type>::value \|\|
	is_function<typename remove_pointer<typename remove_reference<_Fn>::type>::type>::value,
	is_member_pointer<typename remove_reference<_Fn>::type>::value
	>
	{
	};

	#endif // _LIBCPP_HAS_NO_VARIADICS

	// template <class T, class... Args> struct is_constructible;

	namespace __is_construct
	{
	struct __nat {};
	}

	#if !defined(_LIBCPP_CXX03_LANG) && (!__has_feature(is_constructible) \|\| \
	defined(_LIBCPP_TESTING_FALLBACK_IS_CONSTRUCTIBLE))

	template <class _Tp, class... _Args>
	struct __libcpp_is_constructible;

	template <class _To, class _From>
	struct __is_invalid_base_to_derived_cast {
	static_assert(is_reference<_To>::value, "Wrong specialization");
	using _RawFrom = __uncvref_t<_From>;
	using _RawTo = __uncvref_t<_To>;
	static const bool value = __lazy_and<
	__lazy_not<is_same<_RawFrom, _RawTo>>,
	is_base_of<_RawFrom, _RawTo>,
	__lazy_not<__libcpp_is_constructible<_RawTo, _From>>
	>::value;
	};

	template <class _To, class _From>
	struct __is_invalid_lvalue_to_rvalue_cast : false_type {
	static_assert(is_reference<_To>::value, "Wrong specialization");
	};

	template <class _ToRef, class _FromRef>
	struct __is_invalid_lvalue_to_rvalue_cast<_ToRef&&, _FromRef&> {
	using _RawFrom = __uncvref_t<_FromRef>;
	using _RawTo = __uncvref_t<_ToRef>;
	static const bool value = __lazy_and<
	__lazy_not<is_function<_RawTo>>,
	__lazy_or<
	is_same<_RawFrom, _RawTo>,
	is_base_of<_RawTo, _RawFrom>>
	>::value;
	};

	struct __is_constructible_helper
	{
	template <class _To>
	static void __eat(_To);

	// This overload is needed to work around a Clang bug that disallows
	// static_cast<T&&>(e) for non-reference-compatible types.
	// Example: static_cast<int&&>(declval<double>());
	// NOTE: The static_cast implementation below is required to support
	// classes with explicit conversion operators.
	template <class _To, class _From,
	class = decltype(__eat<_To>(_VSTD::declval<_From>()))>
	static true_type __test_cast(int);

	template <class _To, class _From,
	class = decltype(static_cast<_To>(_VSTD::declval<_From>()))>
	static integral_constant<bool,
	!__is_invalid_base_to_derived_cast<_To, _From>::value &&
	!__is_invalid_lvalue_to_rvalue_cast<_To, _From>::value
	> __test_cast(long);

	template <class, class>
	static false_type __test_cast(...);

	template <class _Tp, class ..._Args,
	class = decltype(_Tp(_VSTD::declval<_Args>()...))>
	static true_type __test_nary(int);
	template <class _Tp, class...>
	static false_type __test_nary(...);

	template <class _Tp, class _A0, class = decltype(::new _Tp(_VSTD::declval<_A0>()))>
	static is_destructible<_Tp> __test_unary(int);
	template <class, class>
	static false_type __test_unary(...);
	};

	template <class _Tp, bool = is_void<_Tp>::value>
	struct __is_default_constructible
	: decltype(__is_constructible_helper::__test_nary<_Tp>(0))
	{};

	template <class _Tp>
	struct __is_default_constructible<_Tp, true> : false_type {};

	template <class _Tp>
	struct __is_default_constructible<_Tp[], false> : false_type {};

	template <class _Tp, size_t _Nx>
	struct __is_default_constructible<_Tp[_Nx], false>
	: __is_default_constructible<typename remove_all_extents<_Tp>::type> {};

	template <class _Tp, class... _Args>
	struct __libcpp_is_constructible
	{
	static_assert(sizeof...(_Args) > 1, "Wrong specialization");
	typedef decltype(__is_constructible_helper::__test_nary<_Tp, _Args...>(0))
	type;
	};

	template <class _Tp>
	struct __libcpp_is_constructible<_Tp> : __is_default_constructible<_Tp> {};

	template <class _Tp, class _A0>
	struct __libcpp_is_constructible<_Tp, _A0>
	: public decltype(__is_constructible_helper::__test_unary<_Tp, _A0>(0))
	{};

	template <class _Tp, class _A0>
	struct __libcpp_is_constructible<_Tp&, _A0>
	: public decltype(__is_constructible_helper::
	__test_cast<_Tp&, _A0>(0))
	{};

	template <class _Tp, class _A0>
	struct __libcpp_is_constructible<_Tp&&, _A0>
	: public decltype(__is_constructible_helper::
	__test_cast<_Tp&&, _A0>(0))
	{};

	#endif

	#if __has_feature(is_constructible)
	template <class _Tp, class ..._Args>
	struct _LIBCPP_TEMPLATE_VIS is_constructible
	: public integral_constant<bool, __is_constructible(_Tp, _Args...)>
	{};
	#elif !defined(_LIBCPP_CXX03_LANG)
	template <class _Tp, class... _Args>
	struct _LIBCPP_TEMPLATE_VIS is_constructible
	: public __libcpp_is_constructible<_Tp, _Args...>::type {};
	#else
	// template <class T> struct is_constructible0;

	// main is_constructible0 test

	template <class _Tp>
	decltype((_Tp(), true_type()))
	__is_constructible0_test(_Tp&);

	false_type
	__is_constructible0_test(__any);

	template <class _Tp, class _A0>
	decltype((_Tp(_VSTD::declval<_A0>()), true_type()))
	__is_constructible1_test(_Tp&, _A0&);

	template <class _A0>
	false_type
	__is_constructible1_test(__any, _A0&);

	template <class _Tp, class _A0, class _A1>
	decltype((_Tp(_VSTD::declval<_A0>(), _VSTD::declval<_A1>()), true_type()))
	__is_constructible2_test(_Tp&, _A0&, _A1&);

	template <class _A0, class _A1>
	false_type
	__is_constructible2_test(__any, _A0&, _A1&);

	template <class _Tp, class _A0, class _A1, class _A2>
	decltype((_Tp(_VSTD::declval<_A0>(), _VSTD::declval<_A1>(), _VSTD::declval<_A2>()), true_type()))
	__is_constructible3_test(_Tp&, _A0&, _A1&, _A2&);

	template <class _A0, class _A1, class _A2>
	false_type
	__is_constructible3_test(__any, _A0&, _A1&, _A2&);

	template <bool, class _Tp>
	struct __is_constructible0_imp // false, _Tp is not a scalar
	: public common_type
	<
	decltype(__is_constructible0_test(declval<_Tp&>()))
	>::type
	{};

	template <bool, class _Tp, class _A0>
	struct __is_constructible1_imp // false, _Tp is not a scalar
	: public common_type
	<
	decltype(__is_constructible1_test(declval<_Tp&>(), declval<_A0&>()))
	>::type
	{};

	template <bool, class _Tp, class _A0, class _A1>
	struct __is_constructible2_imp // false, _Tp is not a scalar
	: public common_type
	<
	decltype(__is_constructible2_test(declval<_Tp&>(), declval<_A0>(), declval<_A1>()))
	>::type
	{};

	template <bool, class _Tp, class _A0, class _A1, class _A2>
	struct __is_constructible3_imp // false, _Tp is not a scalar
	: public common_type
	<
	decltype(__is_constructible3_test(declval<_Tp&>(), declval<_A0>(), declval<_A1>(), declval<_A2>()))
	>::type
	{};

	// handle scalars and reference types

	// Scalars are default constructible, references are not

	template <class _Tp>
	struct __is_constructible0_imp<true, _Tp>
	: public is_scalar<_Tp>
	{};

	template <class _Tp, class _A0>
	struct __is_constructible1_imp<true, _Tp, _A0>
	: public is_convertible<_A0, _Tp>
	{};

	template <class _Tp, class _A0, class _A1>
	struct __is_constructible2_imp<true, _Tp, _A0, _A1>
	: public false_type
	{};

	template <class _Tp, class _A0, class _A1, class _A2>
	struct __is_constructible3_imp<true, _Tp, _A0, _A1, _A2>
	: public false_type
	{};

	// Treat scalars and reference types separately

	template <bool, class _Tp>
	struct __is_constructible0_void_check
	: public __is_constructible0_imp<is_scalar<_Tp>::value \|\| is_reference<_Tp>::value,
	_Tp>
	{};

	template <bool, class _Tp, class _A0>
	struct __is_constructible1_void_check
	: public __is_constructible1_imp<is_scalar<_Tp>::value \|\| is_reference<_Tp>::value,
	_Tp, _A0>
	{};

	template <bool, class _Tp, class _A0, class _A1>
	struct __is_constructible2_void_check
	: public __is_constructible2_imp<is_scalar<_Tp>::value \|\| is_reference<_Tp>::value,
	_Tp, _A0, _A1>
	{};

	template <bool, class _Tp, class _A0, class _A1, class _A2>
	struct __is_constructible3_void_check
	: public __is_constructible3_imp<is_scalar<_Tp>::value \|\| is_reference<_Tp>::value,
	_Tp, _A0, _A1, _A2>
	{};

	// If any of T or Args is void, is_constructible should be false

	template <class _Tp>
	struct __is_constructible0_void_check<true, _Tp>
	: public false_type
	{};

	template <class _Tp, class _A0>
	struct __is_constructible1_void_check<true, _Tp, _A0>
	: public false_type
	{};

	template <class _Tp, class _A0, class _A1>
	struct __is_constructible2_void_check<true, _Tp, _A0, _A1>
	: public false_type
	{};

	template <class _Tp, class _A0, class _A1, class _A2>
	struct __is_constructible3_void_check<true, _Tp, _A0, _A1, _A2>
	: public false_type
	{};

	// is_constructible entry point

	template <class _Tp, class _A0 = __is_construct::__nat,
	class _A1 = __is_construct::__nat,
	class _A2 = __is_construct::__nat>
	struct _LIBCPP_TEMPLATE_VIS is_constructible
	: public __is_constructible3_void_check<is_void<_Tp>::value
	\|\| is_abstract<_Tp>::value
	\|\| is_function<_Tp>::value
	\|\| is_void<_A0>::value
	\|\| is_void<_A1>::value
	\|\| is_void<_A2>::value,
	_Tp, _A0, _A1, _A2>
	{};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_constructible<_Tp, __is_construct::__nat, __is_construct::__nat>
	: public __is_constructible0_void_check<is_void<_Tp>::value
	\|\| is_abstract<_Tp>::value
	\|\| is_function<_Tp>::value,
	_Tp>
	{};

	template <class _Tp, class _A0>
	struct _LIBCPP_TEMPLATE_VIS is_constructible<_Tp, _A0, __is_construct::__nat>
	: public __is_constructible1_void_check<is_void<_Tp>::value
	\|\| is_abstract<_Tp>::value
	\|\| is_function<_Tp>::value
	\|\| is_void<_A0>::value,
	_Tp, _A0>
	{};

	template <class _Tp, class _A0, class _A1>
	struct _LIBCPP_TEMPLATE_VIS is_constructible<_Tp, _A0, _A1, __is_construct::__nat>
	: public __is_constructible2_void_check<is_void<_Tp>::value
	\|\| is_abstract<_Tp>::value
	\|\| is_function<_Tp>::value
	\|\| is_void<_A0>::value
	\|\| is_void<_A1>::value,
	_Tp, _A0, _A1>
	{};

	// Array types are default constructible if their element type
	// is default constructible

	template <class _Ap, size_t _Np>
	struct __is_constructible0_imp<false, _Ap[_Np]>
	: public is_constructible<typename remove_all_extents<_Ap>::type>
	{};

	template <class _Ap, size_t _Np, class _A0>
	struct __is_constructible1_imp<false, _Ap[_Np], _A0>
	: public false_type
	{};

	template <class _Ap, size_t _Np, class _A0, class _A1>
	struct __is_constructible2_imp<false, _Ap[_Np], _A0, _A1>
	: public false_type
	{};

	template <class _Ap, size_t _Np, class _A0, class _A1, class _A2>
	struct __is_constructible3_imp<false, _Ap[_Np], _A0, _A1, _A2>
	: public false_type
	{};

	// Incomplete array types are not constructible

	template <class _Ap>
	struct __is_constructible0_imp<false, _Ap[]>
	: public false_type
	{};

	template <class _Ap, class _A0>
	struct __is_constructible1_imp<false, _Ap[], _A0>
	: public false_type
	{};

	template <class _Ap, class _A0, class _A1>
	struct __is_constructible2_imp<false, _Ap[], _A0, _A1>
	: public false_type
	{};

	template <class _Ap, class _A0, class _A1, class _A2>
	struct __is_constructible3_imp<false, _Ap[], _A0, _A1, _A2>
	: public false_type
	{};

	#endif // __has_feature(is_constructible)


	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
	template <class _Tp, class ..._Args>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_constructible_v
	= is_constructible<_Tp, _Args...>::value;
	#endif

	// is_default_constructible

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_default_constructible
	: public is_constructible<_Tp>
	{};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_default_constructible_v
	= is_default_constructible<_Tp>::value;
	#endif

	// is_copy_constructible

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_copy_constructible
	- : public is_constructible<_Tp,
	+ : public is_constructible<_Tp,
	typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_copy_constructible_v
	= is_copy_constructible<_Tp>::value;
	#endif

	// is_move_constructible

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_move_constructible
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	: public is_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
	#else
	: public is_copy_constructible<_Tp>
	#endif
	{};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_move_constructible_v
	= is_move_constructible<_Tp>::value;
	#endif

	// is_trivially_constructible

	#ifndef _LIBCPP_HAS_NO_VARIADICS

	#if __has_feature(is_trivially_constructible) \|\| _GNUC_VER >= 501

	template <class _Tp, class... _Args>
	struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible
	: integral_constant<bool, __is_trivially_constructible(_Tp, _Args...)>
	{
	};

	#else // !__has_feature(is_trivially_constructible)

	template <class _Tp, class... _Args>
	struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible
	: false_type
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp>
	#if __has_feature(has_trivial_constructor) \|\| (_GNUC_VER >= 403)
	: integral_constant<bool, __has_trivial_constructor(_Tp)>
	#else
	: integral_constant<bool, is_scalar<_Tp>::value>
	#endif
	{
	};

	template <class _Tp>
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, _Tp&&>
	#else
	struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, _Tp>
	#endif
	: integral_constant<bool, is_scalar<_Tp>::value>
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, const _Tp&>
	: integral_constant<bool, is_scalar<_Tp>::value>
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, _Tp&>
	: integral_constant<bool, is_scalar<_Tp>::value>
	{
	};

	#endif // !__has_feature(is_trivially_constructible)

	#else // _LIBCPP_HAS_NO_VARIADICS

	template <class _Tp, class _A0 = __is_construct::__nat,
	class _A1 = __is_construct::__nat>
	struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible
	: false_type
	{
	};

	#if __has_feature(is_trivially_constructible) \|\| _GNUC_VER >= 501

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, __is_construct::__nat,
	__is_construct::__nat>
	: integral_constant<bool, __is_trivially_constructible(_Tp)>
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, _Tp,
	__is_construct::__nat>
	: integral_constant<bool, __is_trivially_constructible(_Tp, _Tp)>
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, const _Tp&,
	__is_construct::__nat>
	: integral_constant<bool, __is_trivially_constructible(_Tp, const _Tp&)>
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, _Tp&,
	__is_construct::__nat>
	: integral_constant<bool, __is_trivially_constructible(_Tp, _Tp&)>
	{
	};

	#else // !__has_feature(is_trivially_constructible)

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, __is_construct::__nat,
	__is_construct::__nat>
	: integral_constant<bool, is_scalar<_Tp>::value>
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, _Tp,
	__is_construct::__nat>
	: integral_constant<bool, is_scalar<_Tp>::value>
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, const _Tp&,
	__is_construct::__nat>
	: integral_constant<bool, is_scalar<_Tp>::value>
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible<_Tp, _Tp&,
	__is_construct::__nat>
	: integral_constant<bool, is_scalar<_Tp>::value>
	{
	};

	#endif // !__has_feature(is_trivially_constructible)

	#endif // _LIBCPP_HAS_NO_VARIADICS

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
	template <class _Tp, class... _Args>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_trivially_constructible_v
	= is_trivially_constructible<_Tp, _Args...>::value;
	#endif

	// is_trivially_default_constructible

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_default_constructible
	: public is_trivially_constructible<_Tp>
	{};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_trivially_default_constructible_v
	= is_trivially_default_constructible<_Tp>::value;
	#endif

	// is_trivially_copy_constructible

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_constructible
	: public is_trivially_constructible<_Tp, typename add_lvalue_reference<const _Tp>::type>
	{};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_trivially_copy_constructible_v
	= is_trivially_copy_constructible<_Tp>::value;
	#endif

	// is_trivially_move_constructible

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_move_constructible
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	: public is_trivially_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
	#else
	: public is_trivially_copy_constructible<_Tp>
	#endif
	{};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_trivially_move_constructible_v
	= is_trivially_move_constructible<_Tp>::value;
	#endif

	// is_trivially_assignable

	#if __has_feature(is_trivially_assignable) \|\| _GNUC_VER >= 501

	template <class _Tp, class _Arg>
	struct is_trivially_assignable
	: integral_constant<bool, __is_trivially_assignable(_Tp, _Arg)>
	{
	};

	#else // !__has_feature(is_trivially_assignable)

	template <class _Tp, class _Arg>
	struct is_trivially_assignable
	: public false_type {};

	template <class _Tp>
	struct is_trivially_assignable<_Tp&, _Tp>
	: integral_constant<bool, is_scalar<_Tp>::value> {};

	template <class _Tp>
	struct is_trivially_assignable<_Tp&, _Tp&>
	: integral_constant<bool, is_scalar<_Tp>::value> {};

	template <class _Tp>
	struct is_trivially_assignable<_Tp&, const _Tp&>
	: integral_constant<bool, is_scalar<_Tp>::value> {};

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Tp>
	struct is_trivially_assignable<_Tp&, _Tp&&>
	: integral_constant<bool, is_scalar<_Tp>::value> {};

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	#endif // !__has_feature(is_trivially_assignable)

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp, class _Arg>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_trivially_assignable_v
	= is_trivially_assignable<_Tp, _Arg>::value;
	#endif

	// is_trivially_copy_assignable

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_assignable
	: public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
	typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_trivially_copy_assignable_v
	= is_trivially_copy_assignable<_Tp>::value;
	#endif

	// is_trivially_move_assignable

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_move_assignable
	: public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	typename add_rvalue_reference<_Tp>::type>
	#else
	typename add_lvalue_reference<_Tp>::type>
	#endif
	{};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_trivially_move_assignable_v
	= is_trivially_move_assignable<_Tp>::value;
	#endif

	// is_trivially_destructible

	#if __has_feature(has_trivial_destructor) \|\| (_GNUC_VER >= 403)

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible
	: public integral_constant<bool, is_destructible<_Tp>::value && __has_trivial_destructor(_Tp)> {};

	#else

	template <class _Tp> struct __libcpp_trivial_destructor
	: public integral_constant<bool, is_scalar<_Tp>::value \|\|
	is_reference<_Tp>::value> {};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible
	: public __libcpp_trivial_destructor<typename remove_all_extents<_Tp>::type> {};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible<_Tp[]>
	: public false_type {};

	#endif

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_trivially_destructible_v
	= is_trivially_destructible<_Tp>::value;
	#endif

	// is_nothrow_constructible

	#if 0
	template <class _Tp, class... _Args>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible
	: public integral_constant<bool, __is_nothrow_constructible(_Tp(_Args...))>
	{
	};

	#else

	#ifndef _LIBCPP_HAS_NO_VARIADICS

	#if __has_feature(cxx_noexcept) \|\| (_GNUC_VER >= 407 && __cplusplus >= 201103L)

	template <bool, bool, class _Tp, class... _Args> struct __libcpp_is_nothrow_constructible;

	template <class _Tp, class... _Args>
	struct __libcpp_is_nothrow_constructible</is constructible/true, /is reference/false, _Tp, _Args...>
	: public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
	{
	};

	template <class _Tp>
	void __implicit_conversion_to(_Tp) noexcept { }

	template <class _Tp, class _Arg>
	struct __libcpp_is_nothrow_constructible</is constructible/true, /is reference/true, _Tp, _Arg>
	: public integral_constant<bool, noexcept(__implicit_conversion_to<_Tp>(declval<_Arg>()))>
	{
	};

	template <class _Tp, bool _IsReference, class... _Args>
	struct __libcpp_is_nothrow_constructible</is constructible/false, _IsReference, _Tp, _Args...>
	: public false_type
	{
	};

	template <class _Tp, class... _Args>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible
	: __libcpp_is_nothrow_constructible<is_constructible<_Tp, _Args...>::value, is_reference<_Tp>::value, _Tp, _Args...>
	{
	};

	template <class _Tp, size_t _Ns>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp[_Ns]>
	: __libcpp_is_nothrow_constructible<is_constructible<_Tp>::value, is_reference<_Tp>::value, _Tp>
	{
	};

	#else // __has_feature(cxx_noexcept)

	template <class _Tp, class... _Args>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible
	: false_type
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp>
	#if __has_feature(has_nothrow_constructor) \|\| (_GNUC_VER >= 403)
	: integral_constant<bool, __has_nothrow_constructor(_Tp)>
	#else
	: integral_constant<bool, is_scalar<_Tp>::value>
	#endif
	{
	};

	template <class _Tp>
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp, _Tp&&>
	#else
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp, _Tp>
	#endif
	#if __has_feature(has_nothrow_copy) \|\| (_GNUC_VER >= 403)
	: integral_constant<bool, __has_nothrow_copy(_Tp)>
	#else
	: integral_constant<bool, is_scalar<_Tp>::value>
	#endif
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp, const _Tp&>
	#if __has_feature(has_nothrow_copy) \|\| (_GNUC_VER >= 403)
	: integral_constant<bool, __has_nothrow_copy(_Tp)>
	#else
	: integral_constant<bool, is_scalar<_Tp>::value>
	#endif
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp, _Tp&>
	#if __has_feature(has_nothrow_copy) \|\| (_GNUC_VER >= 403)
	: integral_constant<bool, __has_nothrow_copy(_Tp)>
	#else
	: integral_constant<bool, is_scalar<_Tp>::value>
	#endif
	{
	};

	#endif // __has_feature(cxx_noexcept)

	#else // _LIBCPP_HAS_NO_VARIADICS

	template <class _Tp, class _A0 = __is_construct::__nat,
	class _A1 = __is_construct::__nat>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible
	: false_type
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp, __is_construct::__nat,
	__is_construct::__nat>
	#if __has_feature(has_nothrow_constructor) \|\| (_GNUC_VER >= 403)
	: integral_constant<bool, __has_nothrow_constructor(_Tp)>
	#else
	: integral_constant<bool, is_scalar<_Tp>::value>
	#endif
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp, _Tp,
	__is_construct::__nat>
	#if __has_feature(has_nothrow_copy) \|\| (_GNUC_VER >= 403)
	: integral_constant<bool, __has_nothrow_copy(_Tp)>
	#else
	: integral_constant<bool, is_scalar<_Tp>::value>
	#endif
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp, const _Tp&,
	__is_construct::__nat>
	#if __has_feature(has_nothrow_copy) \|\| (_GNUC_VER >= 403)
	: integral_constant<bool, __has_nothrow_copy(_Tp)>
	#else
	: integral_constant<bool, is_scalar<_Tp>::value>
	#endif
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp, _Tp&,
	__is_construct::__nat>
	#if __has_feature(has_nothrow_copy) \|\| (_GNUC_VER >= 403)
	: integral_constant<bool, __has_nothrow_copy(_Tp)>
	#else
	: integral_constant<bool, is_scalar<_Tp>::value>
	#endif
	{
	};

	#endif // _LIBCPP_HAS_NO_VARIADICS
	#endif // __has_feature(is_nothrow_constructible)

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
	template <class _Tp, class ..._Args>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_nothrow_constructible_v
	= is_nothrow_constructible<_Tp, _Args...>::value;
	#endif

	// is_nothrow_default_constructible

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_default_constructible
	: public is_nothrow_constructible<_Tp>
	{};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_nothrow_default_constructible_v
	= is_nothrow_default_constructible<_Tp>::value;
	#endif

	// is_nothrow_copy_constructible

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_constructible
	: public is_nothrow_constructible<_Tp,
	typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_nothrow_copy_constructible_v
	= is_nothrow_copy_constructible<_Tp>::value;
	#endif

	// is_nothrow_move_constructible

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_constructible
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	: public is_nothrow_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
	#else
	: public is_nothrow_copy_constructible<_Tp>
	#endif
	{};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_nothrow_move_constructible_v
	= is_nothrow_move_constructible<_Tp>::value;
	#endif

	// is_nothrow_assignable

	#if __has_feature(cxx_noexcept) \|\| (_GNUC_VER >= 407 && __cplusplus >= 201103L)

	template <bool, class _Tp, class _Arg> struct __libcpp_is_nothrow_assignable;

	template <class _Tp, class _Arg>
	struct __libcpp_is_nothrow_assignable<false, _Tp, _Arg>
	: public false_type
	{
	};

	template <class _Tp, class _Arg>
	struct __libcpp_is_nothrow_assignable<true, _Tp, _Arg>
	: public integral_constant<bool, noexcept(_VSTD::declval<_Tp>() = _VSTD::declval<_Arg>()) >
	{
	};

	template <class _Tp, class _Arg>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable
	: public __libcpp_is_nothrow_assignable<is_assignable<_Tp, _Arg>::value, _Tp, _Arg>
	{
	};

	#else // __has_feature(cxx_noexcept)

	template <class _Tp, class _Arg>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable
	: public false_type {};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable<_Tp&, _Tp>
	#if __has_feature(has_nothrow_assign) \|\| (_GNUC_VER >= 403)
	: integral_constant<bool, __has_nothrow_assign(_Tp)> {};
	#else
	: integral_constant<bool, is_scalar<_Tp>::value> {};
	#endif

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable<_Tp&, _Tp&>
	#if __has_feature(has_nothrow_assign) \|\| (_GNUC_VER >= 403)
	: integral_constant<bool, __has_nothrow_assign(_Tp)> {};
	#else
	: integral_constant<bool, is_scalar<_Tp>::value> {};
	#endif

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable<_Tp&, const _Tp&>
	#if __has_feature(has_nothrow_assign) \|\| (_GNUC_VER >= 403)
	: integral_constant<bool, __has_nothrow_assign(_Tp)> {};
	#else
	: integral_constant<bool, is_scalar<_Tp>::value> {};
	#endif

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Tp>
	struct is_nothrow_assignable<_Tp&, _Tp&&>
	#if __has_feature(has_nothrow_assign) \|\| (_GNUC_VER >= 403)
	: integral_constant<bool, __has_nothrow_assign(_Tp)> {};
	#else
	: integral_constant<bool, is_scalar<_Tp>::value> {};
	#endif

	#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

	#endif // __has_feature(cxx_noexcept)

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp, class _Arg>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_nothrow_assignable_v
	= is_nothrow_assignable<_Tp, _Arg>::value;
	#endif

	// is_nothrow_copy_assignable

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_assignable
	: public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
	typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_nothrow_copy_assignable_v
	= is_nothrow_copy_assignable<_Tp>::value;
	#endif

	// is_nothrow_move_assignable

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_assignable
	: public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
	typename add_rvalue_reference<_Tp>::type>
	#else
	typename add_lvalue_reference<_Tp>::type>
	#endif
	{};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_nothrow_move_assignable_v
	= is_nothrow_move_assignable<_Tp>::value;
	#endif

	// is_nothrow_destructible

	#if __has_feature(cxx_noexcept) \|\| (_GNUC_VER >= 407 && __cplusplus >= 201103L)

	template <bool, class _Tp> struct __libcpp_is_nothrow_destructible;

	template <class _Tp>
	struct __libcpp_is_nothrow_destructible<false, _Tp>
	: public false_type
	{
	};

	template <class _Tp>
	struct __libcpp_is_nothrow_destructible<true, _Tp>
	: public integral_constant<bool, noexcept(_VSTD::declval<_Tp>().~_Tp()) >
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible
	: public __libcpp_is_nothrow_destructible<is_destructible<_Tp>::value, _Tp>
	{
	};

	template <class _Tp, size_t _Ns>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp[_Ns]>
	: public is_nothrow_destructible<_Tp>
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp&>
	: public true_type
	{
	};

	#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp&&>
	: public true_type
	{
	};

	#endif

	#else

	template <class _Tp> struct __libcpp_nothrow_destructor
	: public integral_constant<bool, is_scalar<_Tp>::value \|\|
	is_reference<_Tp>::value> {};

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible
	: public __libcpp_nothrow_destructor<typename remove_all_extents<_Tp>::type> {};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp[]>
	: public false_type {};

	#endif

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_nothrow_destructible_v
	= is_nothrow_destructible<_Tp>::value;
	#endif

	// is_pod

	#if __has_feature(is_pod) \|\| (_GNUC_VER >= 403)

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pod
	: public integral_constant<bool, __is_pod(_Tp)> {};

	#else

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pod
	: public integral_constant<bool, is_trivially_default_constructible<_Tp>::value &&
	is_trivially_copy_constructible<_Tp>::value &&
	is_trivially_copy_assignable<_Tp>::value &&
	is_trivially_destructible<_Tp>::value> {};

	#endif

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_pod_v
	= is_pod<_Tp>::value;
	#endif

	// is_literal_type;

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_literal_type
	#ifdef _LIBCPP_IS_LITERAL
	: public integral_constant<bool, _LIBCPP_IS_LITERAL(_Tp)>
	#else
	: integral_constant<bool, is_scalar<typename remove_all_extents<_Tp>::type>::value \|\|
	is_reference<typename remove_all_extents<_Tp>::type>::value>
	#endif
	{};
	-
	+
	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_literal_type_v
	= is_literal_type<_Tp>::value;
	#endif

	// is_standard_layout;

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_standard_layout
	#if __has_feature(is_standard_layout) \|\| (_GNUC_VER >= 407)
	: public integral_constant<bool, __is_standard_layout(_Tp)>
	#else
	: integral_constant<bool, is_scalar<typename remove_all_extents<_Tp>::type>::value>
	#endif
	{};
	-
	+
	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_standard_layout_v
	= is_standard_layout<_Tp>::value;
	#endif

	// is_trivially_copyable;

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copyable
	#if __has_feature(is_trivially_copyable)
	: public integral_constant<bool, __is_trivially_copyable(_Tp)>
	#elif _GNUC_VER >= 501
	: public integral_constant<bool, !is_volatile<_Tp>::value && __is_trivially_copyable(_Tp)>
	#else
	: integral_constant<bool, is_scalar<typename remove_all_extents<_Tp>::type>::value>
	#endif
	{};
	-
	+
	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_trivially_copyable_v
	= is_trivially_copyable<_Tp>::value;
	#endif

	// is_trivial;

	template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivial
	#if __has_feature(is_trivial) \|\| _GNUC_VER >= 407
	: public integral_constant<bool, __is_trivial(_Tp)>
	#else
	: integral_constant<bool, is_trivially_copyable<_Tp>::value &&
	is_trivially_default_constructible<_Tp>::value>
	#endif
	{};

	#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
	template <class _Tp>
	_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_trivial_v
	= is_trivial<_Tp>::value;
	#endif

	template <class _Tp> struct __is_reference_wrapper_impl : public false_type {};
	template <class _Tp> struct __is_reference_wrapper_impl<reference_wrapper<_Tp> > : public true_type {};
	template <class _Tp> struct __is_reference_wrapper
	: public __is_reference_wrapper_impl<typename remove_cv<_Tp>::type> {};

	#ifndef _LIBCPP_CXX03_LANG

	-// Check for complete types
	-
	-template <class ..._Tp> struct __check_complete;
	-
	-template <>
	-struct __check_complete<>
	-{
	-};
	-
	-template <class _Hp, class _T0, class ..._Tp>
	-struct __check_complete<_Hp, _T0, _Tp...>
	- : private __check_complete<_Hp>,
	- private __check_complete<_T0, _Tp...>
	-{
	-};
	-
	-template <class _Hp>
	-struct __check_complete<_Hp, _Hp>
	- : private __check_complete<_Hp>
	-{
	-};
	-
	-template <class _Tp>
	-struct __check_complete<_Tp>
	-{
	- static_assert(sizeof(_Tp) > 0, "Type must be complete.");
	-};
	-
	-template <class _Tp>
	-struct __check_complete<_Tp&>
	- : private __check_complete<_Tp>
	-{
	-};
	-
	-template <class _Tp>
	-struct __check_complete<_Tp&&>
	- : private __check_complete<_Tp>
	-{
	-};
	-
	-template <class _Rp, class ..._Param>
	-struct __check_complete<_Rp (*)(_Param...)>
	- : private __check_complete<_Rp>
	-{
	-};
	-
	-template <class ..._Param>
	-struct __check_complete<void (*)(_Param...)>
	-{
	-};
	-
	-template <class _Rp, class ..._Param>
	-struct __check_complete<_Rp (_Param...)>
	- : private __check_complete<_Rp>
	-{
	-};
	-
	-template <class ..._Param>
	-struct __check_complete<void (_Param...)>
	-{
	-};
	-
	-template <class _Rp, class _Class, class ..._Param>
	-struct __check_complete<_Rp (_Class::*)(_Param...)>
	- : private __check_complete<_Class>
	-{
	-};
	-
	-template <class _Rp, class _Class, class ..._Param>
	-struct __check_complete<_Rp (_Class::*)(_Param...) const>
	- : private __check_complete<_Class>
	-{
	-};
	-
	-template <class _Rp, class _Class, class ..._Param>
	-struct __check_complete<_Rp (_Class::*)(_Param...) volatile>
	- : private __check_complete<_Class>
	-{
	-};
	-
	-template <class _Rp, class _Class, class ..._Param>
	-struct __check_complete<_Rp (_Class::*)(_Param...) const volatile>
	- : private __check_complete<_Class>
	-{
	-};
	-
	-template <class _Rp, class _Class, class ..._Param>
	-struct __check_complete<_Rp (_Class::*)(_Param...) &>
	- : private __check_complete<_Class>
	-{
	-};
	-
	-template <class _Rp, class _Class, class ..._Param>
	-struct __check_complete<_Rp (_Class::*)(_Param...) const&>
	- : private __check_complete<_Class>
	-{
	-};
	-
	-template <class _Rp, class _Class, class ..._Param>
	-struct __check_complete<_Rp (_Class::*)(_Param...) volatile&>
	- : private __check_complete<_Class>
	-{
	-};
	-
	-template <class _Rp, class _Class, class ..._Param>
	-struct __check_complete<_Rp (_Class::*)(_Param...) const volatile&>
	- : private __check_complete<_Class>
	-{
	-};
	-
	-template <class _Rp, class _Class, class ..._Param>
	-struct __check_complete<_Rp (_Class::*)(_Param...) &&>
	- : private __check_complete<_Class>
	-{
	-};
	-
	-template <class _Rp, class _Class, class ..._Param>
	-struct __check_complete<_Rp (_Class::*)(_Param...) const&&>
	- : private __check_complete<_Class>
	-{
	-};
	-
	-template <class _Rp, class _Class, class ..._Param>
	-struct __check_complete<_Rp (_Class::*)(_Param...) volatile&&>
	- : private __check_complete<_Class>
	-{
	-};
	-
	-template <class _Rp, class _Class, class ..._Param>
	-struct __check_complete<_Rp (_Class::*)(_Param...) const volatile&&>
	- : private __check_complete<_Class>
	-{
	-};
	-
	-template <class _Rp, class _Class>
	-struct __check_complete<_Rp _Class::*>
	- : private __check_complete<_Class>
	-{
	-};
	-
	-
	template <class _Fp, class _A0,
	class _DecayFp = typename decay<_Fp>::type,
	class _DecayA0 = typename decay<_A0>::type,
	class _ClassT = typename __member_pointer_class_type<_DecayFp>::type>
	using __enable_if_bullet1 = typename enable_if
	<
	is_member_function_pointer<_DecayFp>::value
	&& is_base_of<_ClassT, _DecayA0>::value
	>::type;

	template <class _Fp, class _A0,
	class _DecayFp = typename decay<_Fp>::type,
	class _DecayA0 = typename decay<_A0>::type>
	using __enable_if_bullet2 = typename enable_if
	<
	is_member_function_pointer<_DecayFp>::value
	&& __is_reference_wrapper<_DecayA0>::value
	>::type;

	template <class _Fp, class _A0,
	class _DecayFp = typename decay<_Fp>::type,
	class _DecayA0 = typename decay<_A0>::type,
	class _ClassT = typename __member_pointer_class_type<_DecayFp>::type>
	using __enable_if_bullet3 = typename enable_if
	<
	is_member_function_pointer<_DecayFp>::value
	&& !is_base_of<_ClassT, _DecayA0>::value
	&& !__is_reference_wrapper<_DecayA0>::value
	>::type;

	template <class _Fp, class _A0,
	class _DecayFp = typename decay<_Fp>::type,
	class _DecayA0 = typename decay<_A0>::type,
	class _ClassT = typename __member_pointer_class_type<_DecayFp>::type>
	using __enable_if_bullet4 = typename enable_if
	<
	is_member_object_pointer<_DecayFp>::value
	&& is_base_of<_ClassT, _DecayA0>::value
	>::type;

	template <class _Fp, class _A0,
	class _DecayFp = typename decay<_Fp>::type,
	class _DecayA0 = typename decay<_A0>::type>
	using __enable_if_bullet5 = typename enable_if
	<
	is_member_object_pointer<_DecayFp>::value
	&& __is_reference_wrapper<_DecayA0>::value
	>::type;

	template <class _Fp, class _A0,
	class _DecayFp = typename decay<_Fp>::type,
	class _DecayA0 = typename decay<_A0>::type,
	class _ClassT = typename __member_pointer_class_type<_DecayFp>::type>
	using __enable_if_bullet6 = typename enable_if
	<
	is_member_object_pointer<_DecayFp>::value
	&& !is_base_of<_ClassT, _DecayA0>::value
	&& !__is_reference_wrapper<_DecayA0>::value
	>::type;

	// __invoke forward declarations

	// fall back - none of the bullets

	#define _LIBCPP_INVOKE_RETURN(...) \
	noexcept(noexcept(__VA_ARGS__)) -> decltype(__VA_ARGS__) \
	{ return __VA_ARGS__; }

	template <class ..._Args>
	auto __invoke(__any, _Args&& ...__args) -> __nat;

	template <class ..._Args>
	auto __invoke_constexpr(__any, _Args&& ...__args) -> __nat;

	// bullets 1, 2 and 3

	template <class _Fp, class _A0, class ..._Args,
	class = __enable_if_bullet1<_Fp, _A0>>
	inline _LIBCPP_INLINE_VISIBILITY
	auto
	__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
	_LIBCPP_INVOKE_RETURN((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...))

	template <class _Fp, class _A0, class ..._Args,
	class = __enable_if_bullet1<_Fp, _A0>>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR auto
	__invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
	_LIBCPP_INVOKE_RETURN((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...))

	template <class _Fp, class _A0, class ..._Args,
	class = __enable_if_bullet2<_Fp, _A0>>
	inline _LIBCPP_INLINE_VISIBILITY
	auto
	__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
	_LIBCPP_INVOKE_RETURN((__a0.get().*__f)(_VSTD::forward<_Args>(__args)...))

	template <class _Fp, class _A0, class ..._Args,
	class = __enable_if_bullet2<_Fp, _A0>>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR auto
	__invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
	_LIBCPP_INVOKE_RETURN((__a0.get().*__f)(_VSTD::forward<_Args>(__args)...))

	template <class _Fp, class _A0, class ..._Args,
	class = __enable_if_bullet3<_Fp, _A0>>
	inline _LIBCPP_INLINE_VISIBILITY
	auto
	__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
	_LIBCPP_INVOKE_RETURN(((_VSTD::forward<_A0>(__a0)).__f)(_VSTD::forward<_Args>(__args)...))

	template <class _Fp, class _A0, class ..._Args,
	class = __enable_if_bullet3<_Fp, _A0>>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR auto
	__invoke_constexpr(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
	_LIBCPP_INVOKE_RETURN(((_VSTD::forward<_A0>(__a0)).__f)(_VSTD::forward<_Args>(__args)...))

	// bullets 4, 5 and 6

	template <class _Fp, class _A0,
	class = __enable_if_bullet4<_Fp, _A0>>
	inline _LIBCPP_INLINE_VISIBILITY
	auto
	__invoke(_Fp&& __f, _A0&& __a0)
	_LIBCPP_INVOKE_RETURN(_VSTD::forward<_A0>(__a0).*__f)

	template <class _Fp, class _A0,
	class = __enable_if_bullet4<_Fp, _A0>>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR auto
	__invoke_constexpr(_Fp&& __f, _A0&& __a0)
	_LIBCPP_INVOKE_RETURN(_VSTD::forward<_A0>(__a0).*__f)

	template <class _Fp, class _A0,
	class = __enable_if_bullet5<_Fp, _A0>>
	inline _LIBCPP_INLINE_VISIBILITY
	auto
	__invoke(_Fp&& __f, _A0&& __a0)
	_LIBCPP_INVOKE_RETURN(__a0.get().*__f)

	template <class _Fp, class _A0,
	class = __enable_if_bullet5<_Fp, _A0>>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR auto
	__invoke_constexpr(_Fp&& __f, _A0&& __a0)
	_LIBCPP_INVOKE_RETURN(__a0.get().*__f)

	template <class _Fp, class _A0,
	class = __enable_if_bullet6<_Fp, _A0>>
	inline _LIBCPP_INLINE_VISIBILITY
	auto
	__invoke(_Fp&& __f, _A0&& __a0)
	_LIBCPP_INVOKE_RETURN((_VSTD::forward<_A0>(__a0)).__f)

	template <class _Fp, class _A0,
	class = __enable_if_bullet6<_Fp, _A0>>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR auto
	__invoke_constexpr(_Fp&& __f, _A0&& __a0)
	_LIBCPP_INVOKE_RETURN((_VSTD::forward<_A0>(__a0)).__f)

	// bullet 7

	template <class _Fp, class ..._Args>
	inline _LIBCPP_INLINE_VISIBILITY
	auto
	__invoke(_Fp&& __f, _Args&& ...__args)
	_LIBCPP_INVOKE_RETURN(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...))

	template <class _Fp, class ..._Args>
	inline _LIBCPP_INLINE_VISIBILITY
	_LIBCPP_CONSTEXPR auto
	__invoke_constexpr(_Fp&& __f, _Args&& ...__args)
	_LIBCPP_INVOKE_RETURN(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...))

	#undef _LIBCPP_INVOKE_RETURN

	// __invokable

	template <class _Ret, class _Fp, class ..._Args>
	struct __invokable_r
	- : private __check_complete<_Fp>
	{
	+ // FIXME: Check that _Ret, _Fp, and _Args... are all complete types, cv void,
	+ // or incomplete array types as required by the standard.
	using _Result = decltype(
	_VSTD::__invoke(_VSTD::declval<_Fp>(), _VSTD::declval<_Args>()...));

	using type =
	typename conditional<
	!is_same<_Result, __nat>::value,
	typename conditional<
	is_void<_Ret>::value,
	true_type,
	is_convertible<_Result, _Ret>
	>::type,
	false_type
	>::type;
	static const bool value = type::value;
	};

	template <class _Fp, class ..._Args>
	using __invokable = __invokable_r<void, _Fp, _Args...>;

	template <bool _IsInvokable, bool _IsCVVoid, class _Ret, class _Fp, class ..._Args>
	struct __nothrow_invokable_r_imp {
	static const bool value = false;
	};

	template <class _Ret, class _Fp, class ..._Args>
	struct __nothrow_invokable_r_imp<true, false, _Ret, _Fp, _Args...>
	{
	typedef __nothrow_invokable_r_imp _ThisT;

	template <class _Tp>
	static void __test_noexcept(_Tp) noexcept;

	static const bool value = noexcept(_ThisT::__test_noexcept<_Ret>(
	_VSTD::__invoke(_VSTD::declval<_Fp>(), _VSTD::declval<_Args>()...)));
	};

	template <class _Ret, class _Fp, class ..._Args>
	struct __nothrow_invokable_r_imp<true, true, _Ret, _Fp, _Args...>
	{
	static const bool value = noexcept(
	_VSTD::__invoke(_VSTD::declval<_Fp>(), _VSTD::declval<_Args>()...));
	};

	template <class _Ret, class _Fp, class ..._Args>
	using __nothrow_invokable_r =
	__nothrow_invokable_r_imp<
	__invokable_r<_Ret, _Fp, _Args...>::value,
	is_void<_Ret>::value,
	_Ret, _Fp, _Args...
	>;

	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,
	typename __invokable_r<void, _Fp, _Args...>::_Result>
	{
	};

	// result_of

	template <class _Fp, class ..._Args>
	class _LIBCPP_TEMPLATE_VIS result_of<_Fp(_Args...)>
	: public __invoke_of<_Fp, _Args...>
	{
	};

	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using result_of_t = typename result_of<_Tp>::type;
	#endif

	#if _LIBCPP_STD_VER > 14

	// 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 ..._Args>
	struct _LIBCPP_TEMPLATE_VIS is_invocable
	: integral_constant<bool, __invokable<_Fn, _Args...>::value> {};

	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 ..._Args>
	_LIBCPP_INLINE_VAR constexpr bool is_invocable_v
	= is_invocable<_Fn, _Args...>::value;

	template <class _Ret, class _Fn, class ..._Args>
	_LIBCPP_INLINE_VAR constexpr bool is_invocable_r_v
	= is_invocable_r<_Ret, _Fn, _Args...>::value;

	// is_nothrow_invocable

	template <class _Fn, class ..._Args>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_invocable
	: integral_constant<bool, __nothrow_invokable<_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>
	_LIBCPP_INLINE_VAR constexpr bool is_nothrow_invocable_v
	= is_nothrow_invocable<_Fn, _Args...>::value;

	template <class _Ret, class _Fn, class ..._Args>
	_LIBCPP_INLINE_VAR constexpr bool is_nothrow_invocable_r_v
	= is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value;

	#endif // _LIBCPP_STD_VER > 14

	#endif // !defined(_LIBCPP_CXX03_LANG)

	template <class _Tp> struct __is_swappable;
	template <class _Tp> struct __is_nothrow_swappable;

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	#ifndef _LIBCPP_CXX03_LANG
	typename enable_if
	<
	is_move_constructible<_Tp>::value &&
	is_move_assignable<_Tp>::value
	>::type
	#else
	void
	#endif
	swap(_Tp& __x, _Tp& __y) _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value &&
	is_nothrow_move_assignable<_Tp>::value)
	{
	_Tp __t(_VSTD::move(__x));
	__x = _VSTD::move(__y);
	__y = _VSTD::move(__t);
	}

	template<class _Tp, size_t _Np>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if<
	__is_swappable<_Tp>::value
	>::type
	swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value);

	template <class _ForwardIterator1, class _ForwardIterator2>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
	// _NOEXCEPT_(_NOEXCEPT_(swap(__a, __b)))
	_NOEXCEPT_(_NOEXCEPT_(swap(*_VSTD::declval<_ForwardIterator1>(),
	*_VSTD::declval<_ForwardIterator2>())))
	{
	swap(__a, __b);
	}

	// __swappable

	namespace __detail
	{
	// ALL generic swap overloads MUST already have a declaration available at this point.

	template <class _Tp, class _Up = _Tp,
	bool _NotVoid = !is_void<_Tp>::value && !is_void<_Up>::value>
	struct __swappable_with
	{
	template <class _LHS, class _RHS>
	static decltype(swap(_VSTD::declval<_LHS>(), _VSTD::declval<_RHS>()))
	__test_swap(int);
	template <class, class>
	static __nat __test_swap(long);

	// Extra parens are needed for the C++03 definition of decltype.
	typedef decltype((__test_swap<_Tp, _Up>(0))) __swap1;
	typedef decltype((__test_swap<_Up, _Tp>(0))) __swap2;

	static const bool value = !is_same<__swap1, __nat>::value
	&& !is_same<__swap2, __nat>::value;
	};

	template <class _Tp, class _Up>
	struct __swappable_with<_Tp, _Up, false> : false_type {};

	template <class _Tp, class _Up = _Tp, bool _Swappable = __swappable_with<_Tp, _Up>::value>
	struct __nothrow_swappable_with {
	static const bool value =
	#ifndef _LIBCPP_HAS_NO_NOEXCEPT
	noexcept(swap(_VSTD::declval<_Tp>(), _VSTD::declval<_Up>()))
	&& noexcept(swap(_VSTD::declval<_Up>(), _VSTD::declval<_Tp>()));
	#else
	false;
	#endif
	};

	template <class _Tp, class _Up>
	struct __nothrow_swappable_with<_Tp, _Up, false> : false_type {};

	} // __detail

	template <class _Tp>
	struct __is_swappable
	: public integral_constant<bool, __detail::__swappable_with<_Tp&>::value>
	{
	};

	template <class _Tp>
	struct __is_nothrow_swappable
	: public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp&>::value>
	{
	};

	#if _LIBCPP_STD_VER > 14

	template <class _Tp, class _Up>
	struct _LIBCPP_TEMPLATE_VIS is_swappable_with
	: public integral_constant<bool, __detail::__swappable_with<_Tp, _Up>::value>
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_swappable
	: public conditional<
	__is_referenceable<_Tp>::value,
	is_swappable_with<
	typename add_lvalue_reference<_Tp>::type,
	typename add_lvalue_reference<_Tp>::type>,
	false_type
	>::type
	{
	};

	template <class _Tp, class _Up>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable_with
	: public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp, _Up>::value>
	{
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable
	: public conditional<
	__is_referenceable<_Tp>::value,
	is_nothrow_swappable_with<
	typename add_lvalue_reference<_Tp>::type,
	typename add_lvalue_reference<_Tp>::type>,
	false_type
	>::type
	{
	};

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VAR constexpr bool is_swappable_with_v
	= is_swappable_with<_Tp, _Up>::value;

	template <class _Tp>
	_LIBCPP_INLINE_VAR constexpr bool is_swappable_v
	= is_swappable<_Tp>::value;

	template <class _Tp, class _Up>
	_LIBCPP_INLINE_VAR constexpr bool is_nothrow_swappable_with_v
	= is_nothrow_swappable_with<_Tp, _Up>::value;

	template <class _Tp>
	_LIBCPP_INLINE_VAR constexpr bool is_nothrow_swappable_v
	= is_nothrow_swappable<_Tp>::value;

	#endif // _LIBCPP_STD_VER > 14

	#ifdef _LIBCPP_UNDERLYING_TYPE

	template <class _Tp>
	struct underlying_type
	{
	typedef _LIBCPP_UNDERLYING_TYPE(_Tp) type;
	};

	#if _LIBCPP_STD_VER > 11
	template <class _Tp> using underlying_type_t = typename underlying_type<_Tp>::type;
	#endif

	#else // _LIBCPP_UNDERLYING_TYPE

	template <class _Tp, bool _Support = false>
	struct underlying_type
	{
	static_assert(_Support, "The underyling_type trait requires compiler "
	"support. Either no such support exists or "
	"libc++ does not know how to use it.");
	};

	#endif // _LIBCPP_UNDERLYING_TYPE


	template <class _Tp, bool = is_enum<_Tp>::value>
	struct __sfinae_underlying_type
	{
	typedef typename underlying_type<_Tp>::type type;
	typedef decltype(((type)1) + 0) __promoted_type;
	};

	template <class _Tp>
	struct __sfinae_underlying_type<_Tp, false> {};

	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	int __convert_to_integral(int __val) { return __val; }

	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	unsigned __convert_to_integral(unsigned __val) { return __val; }

	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	long __convert_to_integral(long __val) { return __val; }

	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	unsigned long __convert_to_integral(unsigned long __val) { return __val; }

	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	long long __convert_to_integral(long long __val) { return __val; }

	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	unsigned long long __convert_to_integral(unsigned long long __val) {return __val; }

	template<typename _Fp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	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
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	__int128_t __convert_to_integral(__int128_t __val) { return __val; }

	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	__uint128_t __convert_to_integral(__uint128_t __val) { return __val; }
	#endif

	template <class _Tp>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	typename __sfinae_underlying_type<_Tp>::__promoted_type
	__convert_to_integral(_Tp __val) { return __val; }

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp>
	struct __has_operator_addressof_member_imp
	{
	template <class _Up>
	static auto __test(int)
	-> typename __select_2nd<decltype(_VSTD::declval<_Up>().operator&()), true_type>::type;
	template <class>
	static auto __test(long) -> false_type;

	static const bool value = decltype(__test<_Tp>(0))::value;
	};

	template <class _Tp>
	struct __has_operator_addressof_free_imp
	{
	template <class _Up>
	static auto __test(int)
	-> typename __select_2nd<decltype(operator&(_VSTD::declval<_Up>())), true_type>::type;
	template <class>
	static auto __test(long) -> false_type;

	static const bool value = decltype(__test<_Tp>(0))::value;
	};

	template <class _Tp>
	struct __has_operator_addressof
	: public integral_constant<bool, __has_operator_addressof_member_imp<_Tp>::value
	\|\| __has_operator_addressof_free_imp<_Tp>::value>
	{};

	#endif // _LIBCPP_CXX03_LANG

	#if _LIBCPP_STD_VER > 14

	#define __cpp_lib_void_t 201411
	template <class...> using void_t = void;

	# ifndef _LIBCPP_HAS_NO_VARIADICS
	template <class... _Args>
	struct conjunction : __and_<_Args...> {};
	template<class... _Args>
	_LIBCPP_INLINE_VAR constexpr bool conjunction_v
	= conjunction<_Args...>::value;

	template <class... _Args>
	struct disjunction : __or_<_Args...> {};
	template<class... _Args>
	_LIBCPP_INLINE_VAR constexpr bool disjunction_v
	= disjunction<_Args...>::value;

	template <class _Tp>
	struct negation : __not_<_Tp> {};
	template<class _Tp>
	_LIBCPP_INLINE_VAR constexpr bool negation_v
	= negation<_Tp>::value;
	# endif // _LIBCPP_HAS_NO_VARIADICS
	#endif // _LIBCPP_STD_VER > 14

	// These traits are used in __tree and __hash_table
	#ifndef _LIBCPP_CXX03_LANG
	struct __extract_key_fail_tag {};
	struct __extract_key_self_tag {};
	struct __extract_key_first_tag {};

	template <class _ValTy, class _Key,
	class _RawValTy = typename __unconstref<_ValTy>::type>
	struct __can_extract_key
	: conditional<is_same<_RawValTy, _Key>::value, __extract_key_self_tag,
	__extract_key_fail_tag>::type {};

	template <class _Pair, class _Key, class _First, class _Second>
	struct __can_extract_key<_Pair, _Key, pair<_First, _Second>>
	: conditional<is_same<typename remove_const<_First>::type, _Key>::value,
	__extract_key_first_tag, __extract_key_fail_tag>::type {};

	// __can_extract_map_key uses true_type/false_type instead of the tags.
	// It returns true if _Key != _ContainerValueTy (the container is a map not a set)
	// and _ValTy == _Key.
	template <class _ValTy, class _Key, class _ContainerValueTy,
	class _RawValTy = typename __unconstref<_ValTy>::type>
	struct __can_extract_map_key
	: integral_constant<bool, is_same<_RawValTy, _Key>::value> {};

	// This specialization returns __extract_key_fail_tag for non-map containers
	// because _Key == _ContainerValueTy
	template <class _ValTy, class _Key, class _RawValTy>
	struct __can_extract_map_key<_ValTy, _Key, _Key, _RawValTy>
	: false_type {};

	#endif

	+#if _LIBCPP_STD_VER > 17
	+enum class endian
	+{
	+ little = 0xDEAD,
	+ big = 0xFACE,
	+#if defined(_LIBCPP_LITTLE_ENDIAN)
	+ native = little
	+#elif defined(_LIBCPP_BIG_ENDIAN)
	+ native = big
	+#else
	+ native = 0xCAFE
	+#endif
	+};
	+#endif
	+
	_LIBCPP_END_NAMESPACE_STD

	#if _LIBCPP_STD_VER > 14
	// std::byte
	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 = __lhs << __shift; }
	-
	+
	template <class _Integer>
	constexpr typename enable_if<is_integral_v<_Integer>, byte>::type
	operator<< (byte __lhs, _Integer __shift) noexcept
	{ 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 = __lhs >> __shift; }

	template <class _Integer>
	constexpr typename enable_if<is_integral_v<_Integer>, byte>::type
	operator>> (byte __lhs, _Integer __shift) noexcept
	{ 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 static_cast<_Integer>(__b); }

	}
	#endif

	#endif // _LIBCPP_TYPE_TRAITS
	Index: projects/clang700-import/contrib/libc++/include/typeinfo
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/typeinfo (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/typeinfo (revision 337135)
	@@ -1,234 +1,240 @@
	// -- C++ --
	//===-------------------------- typeinfo ----------------------------------===//
	//
	// 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_TYPEINFO
	#define __LIBCPP_TYPEINFO

	/*

	typeinfo synopsis

	namespace std {

	class type_info
	{
	public:
	virtual ~type_info();

	bool operator==(const type_info& rhs) const noexcept;
	bool operator!=(const type_info& rhs) const noexcept;

	bool before(const type_info& rhs) const noexcept;
	size_t hash_code() const noexcept;
	const char* name() const noexcept;

	type_info(const type_info& rhs) = delete;
	type_info& operator=(const type_info& rhs) = delete;
	};

	class bad_cast
	: public exception
	{
	public:
	bad_cast() noexcept;
	bad_cast(const bad_cast&) noexcept;
	bad_cast& operator=(const bad_cast&) noexcept;
	virtual const char* what() const noexcept;
	};

	class bad_typeid
	: public exception
	{
	public:
	bad_typeid() noexcept;
	bad_typeid(const bad_typeid&) noexcept;
	bad_typeid& operator=(const bad_typeid&) noexcept;
	virtual const char* what() const noexcept;
	};

	} // std

	*/

	#include <__config>
	#include <exception>
	#include <cstddef>
	#include <cstdint>
	#ifdef _LIBCPP_NO_EXCEPTIONS
	#include <cstdlib>
	#endif

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	+#if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_NO_VCRUNTIME)
	+#include <vcruntime_typeinfo.h>
	+#else
	+
	#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
	{

	class _LIBCPP_EXCEPTION_ABI type_info
	{
	type_info& operator=(const type_info&);
	type_info(const type_info&);

	#if defined(_LIBCPP_HAS_NONUNIQUE_TYPEINFO)
	_LIBCPP_INLINE_VISIBILITY
	int __compare_nonunique_names(const type_info &__arg) const _NOEXCEPT
	{ 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;

	_LIBCPP_INLINE_VISIBILITY
	explicit type_info(const char* __n)
	: __type_name(reinterpret_cast<uintptr_t>(__n)) {}
	#else
	const char *__type_name;

	_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
	{
	return reinterpret_cast<const char*>(__type_name &
	~_LIBCPP_NONUNIQUE_RTTI_BIT);
	}

	_LIBCPP_INLINE_VISIBILITY
	bool before(const type_info& __arg) const _NOEXCEPT
	{
	if (!((__type_name & __arg.__type_name) & _LIBCPP_NONUNIQUE_RTTI_BIT))
	return __type_name < __arg.__type_name;
	return __compare_nonunique_names(__arg) < 0;
	}

	_LIBCPP_INLINE_VISIBILITY
	size_t hash_code() const _NOEXCEPT
	{
	if (!(__type_name & _LIBCPP_NONUNIQUE_RTTI_BIT))
	return __type_name;

	const char* __ptr = name();
	size_t __hash = 5381;
	while (unsigned char __c = static_cast<unsigned char>(*__ptr++))
	__hash = (__hash * 33) ^ __c;
	return __hash;
	}

	_LIBCPP_INLINE_VISIBILITY
	bool operator==(const type_info& __arg) const _NOEXCEPT
	{
	if (__type_name == __arg.__type_name)
	return true;

	if (!((__type_name & __arg.__type_name) & _LIBCPP_NONUNIQUE_RTTI_BIT))
	return false;
	return __compare_nonunique_names(__arg) == 0;
	}
	#else
	_LIBCPP_INLINE_VISIBILITY
	const char* name() const _NOEXCEPT
	{ return __type_name; }

	_LIBCPP_INLINE_VISIBILITY
	bool before(const type_info& __arg) const _NOEXCEPT
	{ return __type_name < __arg.__type_name; }

	_LIBCPP_INLINE_VISIBILITY
	size_t hash_code() const _NOEXCEPT
	{ return reinterpret_cast<size_t>(__type_name); }

	_LIBCPP_INLINE_VISIBILITY
	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
	{ return !operator==(__arg); }
	};

	class _LIBCPP_EXCEPTION_ABI bad_cast
	: public exception
	{
	public:
	bad_cast() _NOEXCEPT;
	virtual ~bad_cast() _NOEXCEPT;
	virtual const char* what() const _NOEXCEPT;
	};

	class _LIBCPP_EXCEPTION_ABI bad_typeid
	: public exception
	{
	public:
	bad_typeid() _NOEXCEPT;
	virtual ~bad_typeid() _NOEXCEPT;
	virtual const char* what() const _NOEXCEPT;
	};

	} // std

	+#endif // defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_NO_VCRUNTIME)
	+
	_LIBCPP_BEGIN_NAMESPACE_STD
	-_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
	+_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
	void __throw_bad_cast()
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw bad_cast();
	#else
	_VSTD::abort();
	#endif
	}
	_LIBCPP_END_NAMESPACE_STD

	#endif // __LIBCPP_TYPEINFO
	Index: projects/clang700-import/contrib/libc++/include/unordered_map
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/unordered_map (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/unordered_map (revision 337135)
	@@ -1,2043 +1,2093 @@
	// -- C++ --
	//===-------------------------- unordered_map -----------------------------===//
	//
	// 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_UNORDERED_MAP
	#define _LIBCPP_UNORDERED_MAP

	/*

	unordered_map synopsis

	#include <initializer_list>

	namespace std
	{

	template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
	class Alloc = allocator<pair<const Key, T>>>
	class unordered_map
	{
	public:
	// types
	typedef Key key_type;
	typedef T mapped_type;
	typedef Hash hasher;
	typedef Pred key_equal;
	typedef Alloc allocator_type;
	typedef pair<const key_type, mapped_type> value_type;
	typedef value_type& reference;
	typedef const value_type& const_reference;
	typedef typename allocator_traits<allocator_type>::pointer pointer;
	typedef typename allocator_traits<allocator_type>::const_pointer const_pointer;
	typedef typename allocator_traits<allocator_type>::size_type size_type;
	typedef typename allocator_traits<allocator_type>::difference_type difference_type;

	typedef /unspecified/ iterator;
	typedef /unspecified/ const_iterator;
	typedef /unspecified/ local_iterator;
	typedef /unspecified/ const_local_iterator;

	unordered_map()
	noexcept(
	is_nothrow_default_constructible<hasher>::value &&
	is_nothrow_default_constructible<key_equal>::value &&
	is_nothrow_default_constructible<allocator_type>::value);
	explicit unordered_map(size_type n, const hasher& hf = hasher(),
	const key_equal& eql = key_equal(),
	const allocator_type& a = allocator_type());
	template <class InputIterator>
	unordered_map(InputIterator f, InputIterator l,
	size_type n = 0, const hasher& hf = hasher(),
	const key_equal& eql = key_equal(),
	const allocator_type& a = allocator_type());
	explicit unordered_map(const allocator_type&);
	unordered_map(const unordered_map&);
	unordered_map(const unordered_map&, const Allocator&);
	unordered_map(unordered_map&&)
	noexcept(
	is_nothrow_move_constructible<hasher>::value &&
	is_nothrow_move_constructible<key_equal>::value &&
	is_nothrow_move_constructible<allocator_type>::value);
	unordered_map(unordered_map&&, const Allocator&);
	unordered_map(initializer_list<value_type>, size_type n = 0,
	const hasher& hf = hasher(), const key_equal& eql = key_equal(),
	const allocator_type& a = allocator_type());
	unordered_map(size_type n, const allocator_type& a)
	: unordered_map(n, hasher(), key_equal(), a) {} // C++14
	unordered_map(size_type n, const hasher& hf, const allocator_type& a)
	: unordered_map(n, hf, key_equal(), a) {} // C++14
	template <class InputIterator>
	unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
	: unordered_map(f, l, n, hasher(), key_equal(), a) {} // C++14
	template <class InputIterator>
	unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf,
	const allocator_type& a)
	: unordered_map(f, l, n, hf, key_equal(), a) {} // C++14
	unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
	: unordered_map(il, n, hasher(), key_equal(), a) {} // C++14
	unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf,
	const allocator_type& a)
	: unordered_map(il, n, hf, key_equal(), a) {} // C++14
	~unordered_map();
	unordered_map& operator=(const unordered_map&);
	unordered_map& operator=(unordered_map&&)
	noexcept(
	allocator_type::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<allocator_type>::value &&
	is_nothrow_move_assignable<hasher>::value &&
	is_nothrow_move_assignable<key_equal>::value);
	unordered_map& operator=(initializer_list<value_type>);

	allocator_type get_allocator() const noexcept;

	bool empty() const noexcept;
	size_type size() const noexcept;
	size_type max_size() const noexcept;

	iterator begin() noexcept;
	iterator end() noexcept;
	const_iterator begin() const noexcept;
	const_iterator end() const noexcept;
	const_iterator cbegin() const noexcept;
	const_iterator cend() const noexcept;

	template <class... Args>
	pair<iterator, bool> emplace(Args&&... args);
	template <class... Args>
	iterator emplace_hint(const_iterator position, Args&&... args);
	pair<iterator, bool> insert(const value_type& obj);
	template <class P>
	pair<iterator, bool> insert(P&& obj);
	iterator insert(const_iterator hint, const value_type& obj);
	template <class P>
	iterator insert(const_iterator hint, P&& obj);
	template <class InputIterator>
	void insert(InputIterator first, InputIterator last);
	void insert(initializer_list<value_type>);

	template <class... Args>
	pair<iterator, bool> try_emplace(const key_type& k, Args&&... args); // C++17
	template <class... Args>
	pair<iterator, bool> try_emplace(key_type&& k, Args&&... args); // C++17
	template <class... Args>
	iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); // C++17
	template <class... Args>
	iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args); // C++17
	template <class M>
	pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj); // C++17
	template <class M>
	pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj); // C++17
	template <class M>
	iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj); // C++17
	template <class M>
	iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj); // C++17

	iterator erase(const_iterator position);
	iterator erase(iterator position); // C++14
	size_type erase(const key_type& k);
	iterator erase(const_iterator first, const_iterator last);
	void clear() noexcept;

	void swap(unordered_map&)
	noexcept(
	(!allocator_type::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<allocator_type>::value) &&
	__is_nothrow_swappable<hasher>::value &&
	__is_nothrow_swappable<key_equal>::value);

	hasher hash_function() const;
	key_equal key_eq() const;

	iterator find(const key_type& k);
	const_iterator find(const key_type& k) const;
	size_type count(const key_type& k) const;
	pair<iterator, iterator> equal_range(const key_type& k);
	pair<const_iterator, const_iterator> equal_range(const key_type& k) const;

	mapped_type& operator[](const key_type& k);
	mapped_type& operator[](key_type&& k);

	mapped_type& at(const key_type& k);
	const mapped_type& at(const key_type& k) const;

	size_type bucket_count() const noexcept;
	size_type max_bucket_count() const noexcept;

	size_type bucket_size(size_type n) const;
	size_type bucket(const key_type& k) const;

	local_iterator begin(size_type n);
	local_iterator end(size_type n);
	const_local_iterator begin(size_type n) const;
	const_local_iterator end(size_type n) const;
	const_local_iterator cbegin(size_type n) const;
	const_local_iterator cend(size_type n) const;

	float load_factor() const noexcept;
	float max_load_factor() const noexcept;
	void max_load_factor(float z);
	void rehash(size_type n);
	void reserve(size_type n);
	};

	template <class Key, class T, class Hash, class Pred, class Alloc>
	void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
	unordered_map<Key, T, Hash, Pred, Alloc>& y)
	noexcept(noexcept(x.swap(y)));

	template <class Key, class T, class Hash, class Pred, class Alloc>
	bool
	operator==(const unordered_map<Key, T, Hash, Pred, Alloc>& x,
	const unordered_map<Key, T, Hash, Pred, Alloc>& y);

	template <class Key, class T, class Hash, class Pred, class Alloc>
	bool
	operator!=(const unordered_map<Key, T, Hash, Pred, Alloc>& x,
	const unordered_map<Key, T, Hash, Pred, Alloc>& y);

	template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
	class Alloc = allocator<pair<const Key, T>>>
	class unordered_multimap
	{
	public:
	// types
	typedef Key key_type;
	typedef T mapped_type;
	typedef Hash hasher;
	typedef Pred key_equal;
	typedef Alloc allocator_type;
	typedef pair<const key_type, mapped_type> value_type;
	typedef value_type& reference;
	typedef const value_type& const_reference;
	typedef typename allocator_traits<allocator_type>::pointer pointer;
	typedef typename allocator_traits<allocator_type>::const_pointer const_pointer;
	typedef typename allocator_traits<allocator_type>::size_type size_type;
	typedef typename allocator_traits<allocator_type>::difference_type difference_type;

	typedef /unspecified/ iterator;
	typedef /unspecified/ const_iterator;
	typedef /unspecified/ local_iterator;
	typedef /unspecified/ const_local_iterator;

	unordered_multimap()
	noexcept(
	is_nothrow_default_constructible<hasher>::value &&
	is_nothrow_default_constructible<key_equal>::value &&
	is_nothrow_default_constructible<allocator_type>::value);
	explicit unordered_multimap(size_type n, const hasher& hf = hasher(),
	const key_equal& eql = key_equal(),
	const allocator_type& a = allocator_type());
	template <class InputIterator>
	unordered_multimap(InputIterator f, InputIterator l,
	size_type n = 0, const hasher& hf = hasher(),
	const key_equal& eql = key_equal(),
	const allocator_type& a = allocator_type());
	explicit unordered_multimap(const allocator_type&);
	unordered_multimap(const unordered_multimap&);
	unordered_multimap(const unordered_multimap&, const Allocator&);
	unordered_multimap(unordered_multimap&&)
	noexcept(
	is_nothrow_move_constructible<hasher>::value &&
	is_nothrow_move_constructible<key_equal>::value &&
	is_nothrow_move_constructible<allocator_type>::value);
	unordered_multimap(unordered_multimap&&, const Allocator&);
	unordered_multimap(initializer_list<value_type>, size_type n = 0,
	const hasher& hf = hasher(), const key_equal& eql = key_equal(),
	const allocator_type& a = allocator_type());
	unordered_multimap(size_type n, const allocator_type& a)
	: unordered_multimap(n, hasher(), key_equal(), a) {} // C++14
	unordered_multimap(size_type n, const hasher& hf, const allocator_type& a)
	: unordered_multimap(n, hf, key_equal(), a) {} // C++14
	template <class InputIterator>
	unordered_multimap(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
	: unordered_multimap(f, l, n, hasher(), key_equal(), a) {} // C++14
	template <class InputIterator>
	unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf,
	const allocator_type& a)
	: unordered_multimap(f, l, n, hf, key_equal(), a) {} // C++14
	unordered_multimap(initializer_list<value_type> il, size_type n, const allocator_type& a)
	: unordered_multimap(il, n, hasher(), key_equal(), a) {} // C++14
	unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf,
	const allocator_type& a)
	: unordered_multimap(il, n, hf, key_equal(), a) {} // C++14
	~unordered_multimap();
	unordered_multimap& operator=(const unordered_multimap&);
	unordered_multimap& operator=(unordered_multimap&&)
	noexcept(
	allocator_type::propagate_on_container_move_assignment::value &&
	is_nothrow_move_assignable<allocator_type>::value &&
	is_nothrow_move_assignable<hasher>::value &&
	is_nothrow_move_assignable<key_equal>::value);
	unordered_multimap& operator=(initializer_list<value_type>);

	allocator_type get_allocator() const noexcept;

	bool empty() const noexcept;
	size_type size() const noexcept;
	size_type max_size() const noexcept;

	iterator begin() noexcept;
	iterator end() noexcept;
	const_iterator begin() const noexcept;
	const_iterator end() const noexcept;
	const_iterator cbegin() const noexcept;
	const_iterator cend() const noexcept;

	template <class... Args>
	iterator emplace(Args&&... args);
	template <class... Args>
	iterator emplace_hint(const_iterator position, Args&&... args);
	iterator insert(const value_type& obj);
	template <class P>
	iterator insert(P&& obj);
	iterator insert(const_iterator hint, const value_type& obj);
	template <class P>
	iterator insert(const_iterator hint, P&& obj);
	template <class InputIterator>
	void insert(InputIterator first, InputIterator last);
	void insert(initializer_list<value_type>);

	iterator erase(const_iterator position);
	iterator erase(iterator position); // C++14
	size_type erase(const key_type& k);
	iterator erase(const_iterator first, const_iterator last);
	void clear() noexcept;

	void swap(unordered_multimap&)
	noexcept(
	(!allocator_type::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<allocator_type>::value) &&
	__is_nothrow_swappable<hasher>::value &&
	__is_nothrow_swappable<key_equal>::value);

	hasher hash_function() const;
	key_equal key_eq() const;

	iterator find(const key_type& k);
	const_iterator find(const key_type& k) const;
	size_type count(const key_type& k) const;
	pair<iterator, iterator> equal_range(const key_type& k);
	pair<const_iterator, const_iterator> equal_range(const key_type& k) const;

	size_type bucket_count() const noexcept;
	size_type max_bucket_count() const noexcept;

	size_type bucket_size(size_type n) const;
	size_type bucket(const key_type& k) const;

	local_iterator begin(size_type n);
	local_iterator end(size_type n);
	const_local_iterator begin(size_type n) const;
	const_local_iterator end(size_type n) const;
	const_local_iterator cbegin(size_type n) const;
	const_local_iterator cend(size_type n) const;

	float load_factor() const noexcept;
	float max_load_factor() const noexcept;
	void max_load_factor(float z);
	void rehash(size_type n);
	void reserve(size_type n);
	};

	template <class Key, class T, class Hash, class Pred, class Alloc>
	void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
	unordered_multimap<Key, T, Hash, Pred, Alloc>& y)
	noexcept(noexcept(x.swap(y)));

	template <class Key, class T, class Hash, class Pred, class Alloc>
	bool
	operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
	const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);

	template <class Key, class T, class Hash, class Pred, class Alloc>
	bool
	operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
	const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);

	} // std

	*/

	#include <__config>
	#include <__hash_table>
	#include <functional>
	#include <stdexcept>
	#include <tuple>

	#include <__debug>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	template <class _Key, class _Cp, class _Hash, bool _IsEmpty>
	class __unordered_map_hasher
	: private _Hash
	{
	public:
	_LIBCPP_INLINE_VISIBILITY
	__unordered_map_hasher()
	_NOEXCEPT_(is_nothrow_default_constructible<_Hash>::value)
	: _Hash() {}
	_LIBCPP_INLINE_VISIBILITY
	__unordered_map_hasher(const _Hash& __h)
	_NOEXCEPT_(is_nothrow_copy_constructible<_Hash>::value)
	: _Hash(__h) {}
	_LIBCPP_INLINE_VISIBILITY
	const _Hash& hash_function() const _NOEXCEPT {return *this;}
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(const _Cp& __x) const
	- {return static_cast<const _Hash&>(*this)(__x.__cc.first);}
	+ {return static_cast<const _Hash&>(*this)(__x.__get_value().first);}
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(const _Key& __x) const
	{return static_cast<const _Hash&>(*this)(__x);}
	void swap(__unordered_map_hasher&__y)
	_NOEXCEPT_(__is_nothrow_swappable<_Hash>::value)
	{
	using _VSTD::swap;
	swap(static_cast<_Hash&>(*this), static_cast<_Hash&>(__y));
	}
	};

	template <class _Key, class _Cp, class _Hash>
	class __unordered_map_hasher<_Key, _Cp, _Hash, false>
	{
	_Hash __hash_;
	public:
	_LIBCPP_INLINE_VISIBILITY
	__unordered_map_hasher()
	_NOEXCEPT_(is_nothrow_default_constructible<_Hash>::value)
	: __hash_() {}
	_LIBCPP_INLINE_VISIBILITY
	__unordered_map_hasher(const _Hash& __h)
	_NOEXCEPT_(is_nothrow_copy_constructible<_Hash>::value)
	: __hash_(__h) {}
	_LIBCPP_INLINE_VISIBILITY
	const _Hash& hash_function() const _NOEXCEPT {return __hash_;}
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(const _Cp& __x) const
	- {return __hash_(__x.__cc.first);}
	+ {return __hash_(__x.__get_value().first);}
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(const _Key& __x) const
	{return __hash_(__x);}
	void swap(__unordered_map_hasher&__y)
	_NOEXCEPT_(__is_nothrow_swappable<_Hash>::value)
	{
	using _VSTD::swap;
	swap(__hash_, __y.__hash_);
	}
	};

	template <class _Key, class _Cp, class _Hash, bool __b>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(__unordered_map_hasher<_Key, _Cp, _Hash, __b>& __x,
	__unordered_map_hasher<_Key, _Cp, _Hash, __b>& __y)
	_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
	{
	__x.swap(__y);
	}

	template <class _Key, class _Cp, class _Pred, bool _IsEmpty>
	class __unordered_map_equal
	: private _Pred
	{
	public:
	_LIBCPP_INLINE_VISIBILITY
	__unordered_map_equal()
	_NOEXCEPT_(is_nothrow_default_constructible<_Pred>::value)
	: _Pred() {}
	_LIBCPP_INLINE_VISIBILITY
	__unordered_map_equal(const _Pred& __p)
	_NOEXCEPT_(is_nothrow_copy_constructible<_Pred>::value)
	: _Pred(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	const _Pred& key_eq() const _NOEXCEPT {return *this;}
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Cp& __x, const _Cp& __y) const
	- {return static_cast<const _Pred&>(*this)(__x.__cc.first, __y.__cc.first);}
	+ {return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y.__get_value().first);}
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Cp& __x, const _Key& __y) const
	- {return static_cast<const _Pred&>(*this)(__x.__cc.first, __y);}
	+ {return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y);}
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Key& __x, const _Cp& __y) const
	- {return static_cast<const _Pred&>(*this)(__x, __y.__cc.first);}
	+ {return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);}
	void swap(__unordered_map_equal&__y)
	_NOEXCEPT_(__is_nothrow_swappable<_Pred>::value)
	{
	using _VSTD::swap;
	swap(static_cast<_Pred&>(*this), static_cast<_Pred&>(__y));
	}
	};

	template <class _Key, class _Cp, class _Pred>
	class __unordered_map_equal<_Key, _Cp, _Pred, false>
	{
	_Pred __pred_;
	public:
	_LIBCPP_INLINE_VISIBILITY
	__unordered_map_equal()
	_NOEXCEPT_(is_nothrow_default_constructible<_Pred>::value)
	: __pred_() {}
	_LIBCPP_INLINE_VISIBILITY
	__unordered_map_equal(const _Pred& __p)
	_NOEXCEPT_(is_nothrow_copy_constructible<_Pred>::value)
	: __pred_(__p) {}
	_LIBCPP_INLINE_VISIBILITY
	const _Pred& key_eq() const _NOEXCEPT {return __pred_;}
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Cp& __x, const _Cp& __y) const
	- {return __pred_(__x.__cc.first, __y.__cc.first);}
	+ {return __pred_(__x.__get_value().first, __y.__get_value().first);}
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Cp& __x, const _Key& __y) const
	- {return __pred_(__x.__cc.first, __y);}
	+ {return __pred_(__x.__get_value().first, __y);}
	_LIBCPP_INLINE_VISIBILITY
	bool operator()(const _Key& __x, const _Cp& __y) const
	- {return __pred_(__x, __y.__cc.first);}
	+ {return __pred_(__x, __y.__get_value().first);}
	void swap(__unordered_map_equal&__y)
	_NOEXCEPT_(__is_nothrow_swappable<_Pred>::value)
	{
	using _VSTD::swap;
	swap(__pred_, __y.__pred_);
	}
	};

	template <class _Key, class _Cp, class _Pred, bool __b>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(__unordered_map_equal<_Key, _Cp, _Pred, __b>& __x,
	__unordered_map_equal<_Key, _Cp, _Pred, __b>& __y)
	_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
	{
	__x.swap(__y);
	}

	template <class _Alloc>
	class __hash_map_node_destructor
	{
	typedef _Alloc allocator_type;
	typedef allocator_traits<allocator_type> __alloc_traits;

	public:

	typedef typename __alloc_traits::pointer pointer;
	private:

	allocator_type& __na_;

	__hash_map_node_destructor& operator=(const __hash_map_node_destructor&);

	public:
	bool __first_constructed;
	bool __second_constructed;

	_LIBCPP_INLINE_VISIBILITY
	explicit __hash_map_node_destructor(allocator_type& __na) _NOEXCEPT
	: __na_(__na),
	__first_constructed(false),
	__second_constructed(false)
	{}

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	__hash_map_node_destructor(__hash_node_destructor<allocator_type>&& __x)
	_NOEXCEPT
	: __na_(__x.__na_),
	__first_constructed(__x.__value_constructed),
	__second_constructed(__x.__value_constructed)
	{
	__x.__value_constructed = false;
	}
	#else // _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	__hash_map_node_destructor(const __hash_node_destructor<allocator_type>& __x)
	: __na_(__x.__na_),
	__first_constructed(__x.__value_constructed),
	__second_constructed(__x.__value_constructed)
	{
	const_cast<bool&>(__x.__value_constructed) = false;
	}
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	void operator()(pointer __p) _NOEXCEPT
	{
	if (__second_constructed)
	- __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__cc.second));
	+ __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().second));
	if (__first_constructed)
	- __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__cc.first));
	+ __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().first));
	if (__p)
	__alloc_traits::deallocate(__na_, __p, 1);
	}
	};

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Key, class _Tp>
	-union __hash_value_type
	+struct __hash_value_type
	{
	typedef _Key key_type;
	typedef _Tp mapped_type;
	typedef pair<const key_type, mapped_type> value_type;
	- typedef pair<key_type, mapped_type> __nc_value_type;
	+ typedef pair<key_type&, mapped_type&> __nc_ref_pair_type;
	+ typedef pair<key_type&&, mapped_type&&> __nc_rref_pair_type;

	+private:
	value_type __cc;
	- __nc_value_type __nc;

	+public:
	_LIBCPP_INLINE_VISIBILITY
	+ value_type& __get_value()
	+ {
	+#if _LIBCPP_STD_VER > 14
	+ return *_VSTD::launder(_VSTD::addressof(__cc));
	+#else
	+ return __cc;
	+#endif
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ const value_type& __get_value() const
	+ {
	+#if _LIBCPP_STD_VER > 14
	+ return *_VSTD::launder(_VSTD::addressof(__cc));
	+#else
	+ return __cc;
	+#endif
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ __nc_ref_pair_type __ref()
	+ {
	+ value_type& __v = __get_value();
	+ return __nc_ref_pair_type(const_cast<key_type&>(__v.first), __v.second);
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	+ __nc_rref_pair_type __move()
	+ {
	+ value_type& __v = __get_value();
	+ return __nc_rref_pair_type(
	+ _VSTD::move(const_cast<key_type&>(__v.first)),
	+ _VSTD::move(__v.second));
	+ }
	+
	+ _LIBCPP_INLINE_VISIBILITY
	__hash_value_type& operator=(const __hash_value_type& __v)
	- {__nc = __v.__cc; return *this;}
	+ {
	+ __ref() = __v.__get_value();
	+ return *this;
	+ }

	_LIBCPP_INLINE_VISIBILITY
	__hash_value_type& operator=(__hash_value_type&& __v)
	- {__nc = _VSTD::move(__v.__nc); return *this;}
	+ {
	+ __ref() = __v.__move();
	+ return *this;
	+ }

	template <class _ValueTp,
	class = typename enable_if<
	__is_same_uncvref<_ValueTp, value_type>::value
	>::type
	>
	_LIBCPP_INLINE_VISIBILITY
	- __hash_value_type& operator=(_ValueTp&& __v) {
	- __nc = _VSTD::forward<_ValueTp>(__v); return *this;
	+ __hash_value_type& operator=(_ValueTp&& __v)
	+ {
	+ __ref() = _VSTD::forward<_ValueTp>(__v);
	+ return *this;
	}

	private:
	__hash_value_type(const __hash_value_type& __v) = delete;
	__hash_value_type(__hash_value_type&& __v) = delete;
	template <class ..._Args>
	explicit __hash_value_type(_Args&& ...__args) = delete;

	~__hash_value_type() = delete;
	};

	#else

	template <class _Key, class _Tp>
	struct __hash_value_type
	{
	typedef _Key key_type;
	typedef _Tp mapped_type;
	typedef pair<const key_type, mapped_type> value_type;

	+private:
	value_type __cc;

	+public:
	+ _LIBCPP_INLINE_VISIBILITY
	+ value_type& __get_value() { return __cc; }
	+ _LIBCPP_INLINE_VISIBILITY
	+ const value_type& __get_value() const { return __cc; }
	+
	private:
	~__hash_value_type();
	};

	#endif

	template <class _HashIterator>
	class _LIBCPP_TEMPLATE_VIS __hash_map_iterator
	{
	_HashIterator __i_;

	typedef __hash_node_types_from_iterator<_HashIterator> _NodeTypes;

	public:
	typedef forward_iterator_tag iterator_category;
	typedef typename _NodeTypes::__map_value_type value_type;
	typedef typename _NodeTypes::difference_type difference_type;
	typedef value_type& reference;
	typedef typename _NodeTypes::__map_value_type_pointer pointer;

	_LIBCPP_INLINE_VISIBILITY
	__hash_map_iterator() _NOEXCEPT {}

	_LIBCPP_INLINE_VISIBILITY
	__hash_map_iterator(_HashIterator __i) _NOEXCEPT : __i_(__i) {}

	_LIBCPP_INLINE_VISIBILITY
	- reference operator*() const {return __i_->__cc;}
	+ reference operator*() const {return __i_->__get_value();}
	_LIBCPP_INLINE_VISIBILITY
	- pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__cc);}
	+ pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__get_value());}

	_LIBCPP_INLINE_VISIBILITY
	__hash_map_iterator& operator++() {++__i_; return *this;}
	_LIBCPP_INLINE_VISIBILITY
	__hash_map_iterator operator++(int)
	{
	__hash_map_iterator __t(*this);
	++(*this);
	return __t;
	}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
	{return __x.__i_ == __y.__i_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
	{return __x.__i_ != __y.__i_;}

	template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
	template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
	template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
	template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
	template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
	};

	template <class _HashIterator>
	class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator
	{
	_HashIterator __i_;

	typedef __hash_node_types_from_iterator<_HashIterator> _NodeTypes;

	public:
	typedef forward_iterator_tag iterator_category;
	typedef typename _NodeTypes::__map_value_type value_type;
	typedef typename _NodeTypes::difference_type difference_type;
	typedef const value_type& reference;
	typedef typename _NodeTypes::__const_map_value_type_pointer pointer;

	_LIBCPP_INLINE_VISIBILITY
	__hash_map_const_iterator() _NOEXCEPT {}

	_LIBCPP_INLINE_VISIBILITY
	__hash_map_const_iterator(_HashIterator __i) _NOEXCEPT : __i_(__i) {}
	_LIBCPP_INLINE_VISIBILITY
	__hash_map_const_iterator(
	__hash_map_iterator<typename _HashIterator::__non_const_iterator> __i)
	_NOEXCEPT
	: __i_(__i.__i_) {}

	_LIBCPP_INLINE_VISIBILITY
	- reference operator*() const {return __i_->__cc;}
	+ reference operator*() const {return __i_->__get_value();}
	_LIBCPP_INLINE_VISIBILITY
	- pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__cc);}
	+ pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__get_value());}

	_LIBCPP_INLINE_VISIBILITY
	__hash_map_const_iterator& operator++() {++__i_; return *this;}
	_LIBCPP_INLINE_VISIBILITY
	__hash_map_const_iterator operator++(int)
	{
	__hash_map_const_iterator __t(*this);
	++(*this);
	return __t;
	}

	friend _LIBCPP_INLINE_VISIBILITY
	bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
	{return __x.__i_ == __y.__i_;}
	friend _LIBCPP_INLINE_VISIBILITY
	bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
	{return __x.__i_ != __y.__i_;}

	template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
	template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
	template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
	template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
	};

	template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
	class _Alloc = allocator<pair<const _Key, _Tp> > >
	class _LIBCPP_TEMPLATE_VIS unordered_map
	{
	public:
	// types
	typedef _Key key_type;
	typedef _Tp mapped_type;
	typedef _Hash hasher;
	typedef _Pred key_equal;
	typedef _Alloc allocator_type;
	typedef pair<const key_type, mapped_type> value_type;
	- typedef pair<key_type, mapped_type> __nc_value_type;
	typedef value_type& reference;
	typedef const value_type& const_reference;
	static_assert((is_same<value_type, typename allocator_type::value_type>::value),
	"Invalid allocator::value_type");

	private:
	typedef __hash_value_type<key_type, mapped_type> __value_type;
	typedef __unordered_map_hasher<key_type, __value_type, hasher> __hasher;
	typedef __unordered_map_equal<key_type, __value_type, key_equal> __key_equal;
	typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>,
	__value_type>::type __allocator_type;

	typedef __hash_table<__value_type, __hasher,
	__key_equal, __allocator_type> __table;

	__table __table_;

	typedef typename __table::_NodeTypes _NodeTypes;
	typedef typename __table::__node_pointer __node_pointer;
	typedef typename __table::__node_const_pointer __node_const_pointer;
	typedef typename __table::__node_traits __node_traits;
	typedef typename __table::__node_allocator __node_allocator;
	typedef typename __table::__node __node;
	typedef __hash_map_node_destructor<__node_allocator> _Dp;
	typedef unique_ptr<__node, _Dp> __node_holder;
	typedef allocator_traits<allocator_type> __alloc_traits;

	static_assert((is_same<typename __table::__container_value_type, value_type>::value), "");
	static_assert((is_same<typename __table::__node_value_type, __value_type>::value), "");
	public:
	typedef typename __alloc_traits::pointer pointer;
	typedef typename __alloc_traits::const_pointer const_pointer;
	typedef typename __table::size_type size_type;
	typedef typename __table::difference_type difference_type;

	typedef __hash_map_iterator<typename __table::iterator> iterator;
	typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
	typedef __hash_map_iterator<typename __table::local_iterator> local_iterator;
	typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator;

	_LIBCPP_INLINE_VISIBILITY
	unordered_map()
	_NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}
	explicit unordered_map(size_type __n, const hasher& __hf = hasher(),
	const key_equal& __eql = key_equal());
	unordered_map(size_type __n, const hasher& __hf,
	const key_equal& __eql,
	const allocator_type& __a);
	template <class _InputIterator>
	unordered_map(_InputIterator __first, _InputIterator __last);
	template <class _InputIterator>
	unordered_map(_InputIterator __first, _InputIterator __last,
	size_type __n, const hasher& __hf = hasher(),
	const key_equal& __eql = key_equal());
	template <class _InputIterator>
	unordered_map(_InputIterator __first, _InputIterator __last,
	size_type __n, const hasher& __hf,
	const key_equal& __eql,
	const allocator_type& __a);
	_LIBCPP_INLINE_VISIBILITY
	explicit unordered_map(const allocator_type& __a);
	unordered_map(const unordered_map& __u);
	unordered_map(const unordered_map& __u, const allocator_type& __a);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	unordered_map(unordered_map&& __u)
	_NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
	unordered_map(unordered_map&& __u, const allocator_type& __a);
	unordered_map(initializer_list<value_type> __il);
	unordered_map(initializer_list<value_type> __il, size_type __n,
	const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
	unordered_map(initializer_list<value_type> __il, size_type __n,
	const hasher& __hf, const key_equal& __eql,
	const allocator_type& __a);
	#endif // _LIBCPP_CXX03_LANG
	#if _LIBCPP_STD_VER > 11
	_LIBCPP_INLINE_VISIBILITY
	unordered_map(size_type __n, const allocator_type& __a)
	: unordered_map(__n, hasher(), key_equal(), __a) {}
	_LIBCPP_INLINE_VISIBILITY
	unordered_map(size_type __n, const hasher& __hf, const allocator_type& __a)
	: unordered_map(__n, __hf, key_equal(), __a) {}
	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a)
	: unordered_map(__first, __last, __n, hasher(), key_equal(), __a) {}
	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf,
	const allocator_type& __a)
	: unordered_map(__first, __last, __n, __hf, key_equal(), __a) {}
	_LIBCPP_INLINE_VISIBILITY
	unordered_map(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
	: unordered_map(__il, __n, hasher(), key_equal(), __a) {}
	_LIBCPP_INLINE_VISIBILITY
	unordered_map(initializer_list<value_type> __il, size_type __n, const hasher& __hf,
	const allocator_type& __a)
	: unordered_map(__il, __n, __hf, key_equal(), __a) {}
	#endif
	// ~unordered_map() = default;
	_LIBCPP_INLINE_VISIBILITY
	unordered_map& operator=(const unordered_map& __u)
	{
	#ifndef _LIBCPP_CXX03_LANG
	__table_ = __u.__table_;
	#else
	if (this != &__u) {
	__table_.clear();
	__table_.hash_function() = __u.__table_.hash_function();
	__table_.key_eq() = __u.__table_.key_eq();
	__table_.max_load_factor() = __u.__table_.max_load_factor();
	__table_.__copy_assign_alloc(__u.__table_);
	insert(__u.begin(), __u.end());
	}
	#endif
	return *this;
	}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	unordered_map& operator=(unordered_map&& __u)
	_NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
	_LIBCPP_INLINE_VISIBILITY
	unordered_map& operator=(initializer_list<value_type> __il);
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	allocator_type get_allocator() const _NOEXCEPT
	{return allocator_type(__table_.__node_alloc());}

	_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();}
	_LIBCPP_INLINE_VISIBILITY
	size_type max_size() const _NOEXCEPT {return __table_.max_size();}

	_LIBCPP_INLINE_VISIBILITY
	iterator begin() _NOEXCEPT {return __table_.begin();}
	_LIBCPP_INLINE_VISIBILITY
	iterator end() _NOEXCEPT {return __table_.end();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator begin() const _NOEXCEPT {return __table_.begin();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator end() const _NOEXCEPT {return __table_.end();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator cend() const _NOEXCEPT {return __table_.end();}

	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> insert(const value_type& __x)
	{return __table_.__insert_unique(__x);}

	iterator insert(const_iterator __p, const value_type& __x) {
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"unordered_map::insert(const_iterator, const value_type&) called with an iterator not"
	" referring to this unordered_map");
	#else
	((void)__p);
	#endif
	return insert(__x).first;
	}

	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	void insert(_InputIterator __first, _InputIterator __last);

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	void insert(initializer_list<value_type> __il)
	{insert(__il.begin(), __il.end());}

	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> insert(value_type&& __x)
	{return __table_.__insert_unique(_VSTD::move(__x));}

	iterator insert(const_iterator __p, value_type&& __x) {
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"unordered_map::insert(const_iterator, const value_type&) called with an iterator not"
	" referring to this unordered_map");
	#else
	((void)__p);
	#endif
	return __table_.__insert_unique(_VSTD::move(__x)).first;
	}

	template <class _Pp,
	class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> insert(_Pp&& __x)
	{return __table_.__insert_unique(_VSTD::forward<_Pp>(__x));}

	template <class _Pp,
	class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __p, _Pp&& __x)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"unordered_map::insert(const_iterator, value_type&&) called with an iterator not"
	" referring to this unordered_map");
	#else
	((void)__p);
	#endif
	return insert(_VSTD::forward<_Pp>(__x)).first;
	}

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> emplace(_Args&&... __args) {
	return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...);
	}

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	iterator emplace_hint(const_iterator __p, _Args&&... __args) {
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this,
	"unordered_map::emplace_hint(const_iterator, args...) called with an iterator not"
	" referring to this unordered_map");
	#else
	((void)__p);
	#endif
	return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first;
	}

	#endif // _LIBCPP_CXX03_LANG

	#if _LIBCPP_STD_VER > 14
	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args)
	{
	return __table_.__emplace_unique_key_args(__k, _VSTD::piecewise_construct,
	_VSTD::forward_as_tuple(__k),
	_VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
	}

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> try_emplace(key_type&& __k, _Args&&... __args)
	{
	return __table_.__emplace_unique_key_args(__k, _VSTD::piecewise_construct,
	_VSTD::forward_as_tuple(_VSTD::move(__k)),
	_VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
	}

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	iterator try_emplace(const_iterator __h, const key_type& __k, _Args&&... __args)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__h) == this,
	"unordered_map::try_emplace(const_iterator, key, args...) called with an iterator not"
	" referring to this unordered_map");
	#else
	((void)__h);
	#endif
	return try_emplace(__k, _VSTD::forward<_Args>(__args)...).first;
	}

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	iterator try_emplace(const_iterator __h, key_type&& __k, _Args&&... __args)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__h) == this,
	"unordered_map::try_emplace(const_iterator, key, args...) called with an iterator not"
	" referring to this unordered_map");
	#else
	((void)__h);
	#endif
	return try_emplace(_VSTD::move(__k), _VSTD::forward<_Args>(__args)...).first;
	}

	template <class _Vp>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> insert_or_assign(const key_type& __k, _Vp&& __v)
	{
	pair<iterator, bool> __res = __table_.__emplace_unique_key_args(__k,
	__k, _VSTD::forward<_Vp>(__v));
	if (!__res.second) {
	__res.first->second = _VSTD::forward<_Vp>(__v);
	}
	return __res;
	}

	template <class _Vp>
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, bool> insert_or_assign(key_type&& __k, _Vp&& __v)
	{
	pair<iterator, bool> __res = __table_.__emplace_unique_key_args(__k,
	_VSTD::move(__k), _VSTD::forward<_Vp>(__v));
	if (!__res.second) {
	__res.first->second = _VSTD::forward<_Vp>(__v);
	}
	return __res;
	}

	template <class _Vp>
	_LIBCPP_INLINE_VISIBILITY
	iterator insert_or_assign(const_iterator, const key_type& __k, _Vp&& __v)
	{
	// FIXME: Add debug mode checking for the iterator input
	return insert_or_assign(__k, _VSTD::forward<_Vp>(__v)).first;
	}

	template <class _Vp>
	_LIBCPP_INLINE_VISIBILITY
	iterator insert_or_assign(const_iterator, key_type&& __k, _Vp&& __v)
	{
	// FIXME: Add debug mode checking for the iterator input
	return insert_or_assign(_VSTD::move(__k), _VSTD::forward<_Vp>(__v)).first;
	}
	#endif // _LIBCPP_STD_VER > 14

	_LIBCPP_INLINE_VISIBILITY
	iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);}
	_LIBCPP_INLINE_VISIBILITY
	iterator erase(iterator __p) {return __table_.erase(__p.__i_);}
	_LIBCPP_INLINE_VISIBILITY
	size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
	_LIBCPP_INLINE_VISIBILITY
	iterator erase(const_iterator __first, const_iterator __last)
	{return __table_.erase(__first.__i_, __last.__i_);}
	_LIBCPP_INLINE_VISIBILITY
	void clear() _NOEXCEPT {__table_.clear();}

	_LIBCPP_INLINE_VISIBILITY
	void swap(unordered_map& __u)
	_NOEXCEPT_(__is_nothrow_swappable<__table>::value)
	{ __table_.swap(__u.__table_);}

	_LIBCPP_INLINE_VISIBILITY
	hasher hash_function() const
	{return __table_.hash_function().hash_function();}
	_LIBCPP_INLINE_VISIBILITY
	key_equal key_eq() const
	{return __table_.key_eq().key_eq();}

	_LIBCPP_INLINE_VISIBILITY
	iterator find(const key_type& __k) {return __table_.find(__k);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator find(const key_type& __k) const {return __table_.find(__k);}
	_LIBCPP_INLINE_VISIBILITY
	size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, iterator> equal_range(const key_type& __k)
	{return __table_.__equal_range_unique(__k);}
	_LIBCPP_INLINE_VISIBILITY
	pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
	{return __table_.__equal_range_unique(__k);}

	mapped_type& operator[](const key_type& __k);
	#ifndef _LIBCPP_CXX03_LANG
	mapped_type& operator[](key_type&& __k);
	#endif

	mapped_type& at(const key_type& __k);
	const mapped_type& at(const key_type& __k) const;

	_LIBCPP_INLINE_VISIBILITY
	size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
	_LIBCPP_INLINE_VISIBILITY
	size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();}

	_LIBCPP_INLINE_VISIBILITY
	size_type bucket_size(size_type __n) const
	{return __table_.bucket_size(__n);}
	_LIBCPP_INLINE_VISIBILITY
	size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}

	_LIBCPP_INLINE_VISIBILITY
	local_iterator begin(size_type __n) {return __table_.begin(__n);}
	_LIBCPP_INLINE_VISIBILITY
	local_iterator end(size_type __n) {return __table_.end(__n);}
	_LIBCPP_INLINE_VISIBILITY
	const_local_iterator begin(size_type __n) const {return __table_.cbegin(__n);}
	_LIBCPP_INLINE_VISIBILITY
	const_local_iterator end(size_type __n) const {return __table_.cend(__n);}
	_LIBCPP_INLINE_VISIBILITY
	const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
	_LIBCPP_INLINE_VISIBILITY
	const_local_iterator cend(size_type __n) const {return __table_.cend(__n);}

	_LIBCPP_INLINE_VISIBILITY
	float load_factor() const _NOEXCEPT {return __table_.load_factor();}
	_LIBCPP_INLINE_VISIBILITY
	float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
	_LIBCPP_INLINE_VISIBILITY
	void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
	_LIBCPP_INLINE_VISIBILITY
	void rehash(size_type __n) {__table_.rehash(__n);}
	_LIBCPP_INLINE_VISIBILITY
	void reserve(size_type __n) {__table_.reserve(__n);}

	#if _LIBCPP_DEBUG_LEVEL >= 2

	bool __dereferenceable(const const_iterator* __i) const
	{return __table_.__dereferenceable(&__i->__i_);}
	bool __decrementable(const const_iterator* __i) const
	{return __table_.__decrementable(&__i->__i_);}
	bool __addable(const const_iterator* __i, ptrdiff_t __n) const
	{return __table_.__addable(&__i->__i_, __n);}
	bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
	{return __table_.__addable(&__i->__i_, __n);}

	#endif // _LIBCPP_DEBUG_LEVEL >= 2

	private:

	#ifdef _LIBCPP_CXX03_LANG
	__node_holder __construct_node_with_key(const key_type& __k);
	#endif
	};

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
	size_type __n, const hasher& __hf, const key_equal& __eql)
	: __table_(__hf, __eql)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__table_.rehash(__n);
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
	size_type __n, const hasher& __hf, const key_equal& __eql,
	const allocator_type& __a)
	: __table_(__hf, __eql, typename __table::allocator_type(__a))
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__table_.rehash(__n);
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	inline
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
	const allocator_type& __a)
	: __table_(typename __table::allocator_type(__a))
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	template <class _InputIterator>
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
	_InputIterator __first, _InputIterator __last)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	insert(__first, __last);
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	template <class _InputIterator>
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
	_InputIterator __first, _InputIterator __last, size_type __n,
	const hasher& __hf, const key_equal& __eql)
	: __table_(__hf, __eql)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__table_.rehash(__n);
	insert(__first, __last);
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	template <class _InputIterator>
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
	_InputIterator __first, _InputIterator __last, size_type __n,
	const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
	: __table_(__hf, __eql, typename __table::allocator_type(__a))
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__table_.rehash(__n);
	insert(__first, __last);
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
	const unordered_map& __u)
	: __table_(__u.__table_)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__table_.rehash(__u.bucket_count());
	insert(__u.begin(), __u.end());
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
	const unordered_map& __u, const allocator_type& __a)
	: __table_(__u.__table_, typename __table::allocator_type(__a))
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__table_.rehash(__u.bucket_count());
	insert(__u.begin(), __u.end());
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	inline
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
	unordered_map&& __u)
	_NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
	: __table_(_VSTD::move(__u.__table_))
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	__get_db()->swap(this, &__u);
	#endif
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
	unordered_map&& __u, const allocator_type& __a)
	: __table_(_VSTD::move(__u.__table_), typename __table::allocator_type(__a))
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	if (__a != __u.get_allocator())
	{
	iterator __i = __u.begin();
	while (__u.size() != 0) {
	- __table_.__emplace_unique(_VSTD::move(
	- __u.__table_.remove((__i++).__i_)->__value_.__nc));
	+ __table_.__emplace_unique(
	+ __u.__table_.remove((__i++).__i_)->__value_.__move());
	}
	}
	#if _LIBCPP_DEBUG_LEVEL >= 2
	else
	__get_db()->swap(this, &__u);
	#endif
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
	initializer_list<value_type> __il)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	insert(__il.begin(), __il.end());
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
	initializer_list<value_type> __il, size_type __n, const hasher& __hf,
	const key_equal& __eql)
	: __table_(__hf, __eql)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__table_.rehash(__n);
	insert(__il.begin(), __il.end());
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
	initializer_list<value_type> __il, size_type __n, const hasher& __hf,
	const key_equal& __eql, const allocator_type& __a)
	: __table_(__hf, __eql, typename __table::allocator_type(__a))
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__table_.rehash(__n);
	insert(__il.begin(), __il.end());
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	inline
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_map&& __u)
	_NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
	{
	__table_ = _VSTD::move(__u.__table_);
	return *this;
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	inline
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
	initializer_list<value_type> __il)
	{
	__table_.__assign_unique(__il.begin(), __il.end());
	return *this;
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	template <class _InputIterator>
	inline
	void
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
	_InputIterator __last)
	{
	for (; __first != __last; ++__first)
	__table_.__insert_unique(*__first);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	_Tp&
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
	{
	return __table_.__emplace_unique_key_args(__k,
	std::piecewise_construct, std::forward_as_tuple(__k),
	- std::forward_as_tuple()).first->__cc.second;
	+ std::forward_as_tuple()).first->__get_value().second;
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	_Tp&
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](key_type&& __k)
	{
	return __table_.__emplace_unique_key_args(__k,
	std::piecewise_construct, std::forward_as_tuple(std::move(__k)),
	- std::forward_as_tuple()).first->__cc.second;
	+ std::forward_as_tuple()).first->__get_value().second;
	}
	#else // _LIBCPP_CXX03_LANG

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node_with_key(const key_type& __k)
	{
	__node_allocator& __na = __table_.__node_alloc();
	__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
	- __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.first), __k);
	+ __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().first), __k);
	__h.get_deleter().__first_constructed = true;
	- __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.second));
	+ __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().second));
	__h.get_deleter().__second_constructed = true;
	return _LIBCPP_EXPLICIT_MOVE(__h); // explicitly moved for C++03
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	_Tp&
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
	{
	iterator __i = find(__k);
	if (__i != end())
	return __i->second;
	__node_holder __h = __construct_node_with_key(__k);
	pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get());
	__h.release();
	return __r.first->second;
	}

	#endif // _LIBCPP_CXX03_MODE

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	_Tp&
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k)
	{
	iterator __i = find(__k);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	if (__i == end())
	throw out_of_range("unordered_map::at: key not found");
	#endif // _LIBCPP_NO_EXCEPTIONS
	return __i->second;
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	const _Tp&
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k) const
	{
	const_iterator __i = find(__k);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	if (__i == end())
	throw out_of_range("unordered_map::at: key not found");
	#endif // _LIBCPP_NO_EXCEPTIONS
	return __i->second;
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
	unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
	_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
	{
	__x.swap(__y);
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	bool
	operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
	const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
	{
	if (__x.size() != __y.size())
	return false;
	typedef typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::const_iterator
	const_iterator;
	for (const_iterator __i = __x.begin(), __ex = __x.end(), __ey = __y.end();
	__i != __ex; ++__i)
	{
	const_iterator __j = __y.find(__i->first);
	if (__j == __ey \|\| !(__i == __j))
	return false;
	}
	return true;
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
	const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
	{
	return !(__x == __y);
	}

	template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
	class _Alloc = allocator<pair<const _Key, _Tp> > >
	class _LIBCPP_TEMPLATE_VIS unordered_multimap
	{
	public:
	// types
	typedef _Key key_type;
	typedef _Tp mapped_type;
	typedef _Hash hasher;
	typedef _Pred key_equal;
	typedef _Alloc allocator_type;
	typedef pair<const key_type, mapped_type> value_type;
	- typedef pair<key_type, mapped_type> __nc_value_type;
	typedef value_type& reference;
	typedef const value_type& const_reference;
	static_assert((is_same<value_type, typename allocator_type::value_type>::value),
	"Invalid allocator::value_type");

	private:
	typedef __hash_value_type<key_type, mapped_type> __value_type;
	typedef __unordered_map_hasher<key_type, __value_type, hasher> __hasher;
	typedef __unordered_map_equal<key_type, __value_type, key_equal> __key_equal;
	typedef typename __rebind_alloc_helper<allocator_traits<allocator_type>,
	__value_type>::type __allocator_type;

	typedef __hash_table<__value_type, __hasher,
	__key_equal, __allocator_type> __table;

	__table __table_;

	typedef typename __table::_NodeTypes _NodeTypes;
	typedef typename __table::__node_traits __node_traits;
	typedef typename __table::__node_allocator __node_allocator;
	typedef typename __table::__node __node;
	typedef __hash_map_node_destructor<__node_allocator> _Dp;
	typedef unique_ptr<__node, _Dp> __node_holder;
	typedef allocator_traits<allocator_type> __alloc_traits;
	static_assert((is_same<typename __node_traits::size_type,
	typename __alloc_traits::size_type>::value),
	"Allocator uses different size_type for different types");
	public:
	typedef typename __alloc_traits::pointer pointer;
	typedef typename __alloc_traits::const_pointer const_pointer;
	typedef typename __table::size_type size_type;
	typedef typename __table::difference_type difference_type;

	typedef __hash_map_iterator<typename __table::iterator> iterator;
	typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
	typedef __hash_map_iterator<typename __table::local_iterator> local_iterator;
	typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator;

	_LIBCPP_INLINE_VISIBILITY
	unordered_multimap()
	_NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}
	explicit unordered_multimap(size_type __n, const hasher& __hf = hasher(),
	const key_equal& __eql = key_equal());
	unordered_multimap(size_type __n, const hasher& __hf,
	const key_equal& __eql,
	const allocator_type& __a);
	template <class _InputIterator>
	unordered_multimap(_InputIterator __first, _InputIterator __last);
	template <class _InputIterator>
	unordered_multimap(_InputIterator __first, _InputIterator __last,
	size_type __n, const hasher& __hf = hasher(),
	const key_equal& __eql = key_equal());
	template <class _InputIterator>
	unordered_multimap(_InputIterator __first, _InputIterator __last,
	size_type __n, const hasher& __hf,
	const key_equal& __eql,
	const allocator_type& __a);
	_LIBCPP_INLINE_VISIBILITY
	explicit unordered_multimap(const allocator_type& __a);
	unordered_multimap(const unordered_multimap& __u);
	unordered_multimap(const unordered_multimap& __u, const allocator_type& __a);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	unordered_multimap(unordered_multimap&& __u)
	_NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
	unordered_multimap(unordered_multimap&& __u, const allocator_type& __a);
	unordered_multimap(initializer_list<value_type> __il);
	unordered_multimap(initializer_list<value_type> __il, size_type __n,
	const hasher& __hf = hasher(),
	const key_equal& __eql = key_equal());
	unordered_multimap(initializer_list<value_type> __il, size_type __n,
	const hasher& __hf, const key_equal& __eql,
	const allocator_type& __a);
	#endif // _LIBCPP_CXX03_LANG
	#if _LIBCPP_STD_VER > 11
	_LIBCPP_INLINE_VISIBILITY
	unordered_multimap(size_type __n, const allocator_type& __a)
	: unordered_multimap(__n, hasher(), key_equal(), __a) {}
	_LIBCPP_INLINE_VISIBILITY
	unordered_multimap(size_type __n, const hasher& __hf, const allocator_type& __a)
	: unordered_multimap(__n, __hf, key_equal(), __a) {}
	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a)
	: unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a) {}
	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf,
	const allocator_type& __a)
	: unordered_multimap(__first, __last, __n, __hf, key_equal(), __a) {}
	_LIBCPP_INLINE_VISIBILITY
	unordered_multimap(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
	: unordered_multimap(__il, __n, hasher(), key_equal(), __a) {}
	_LIBCPP_INLINE_VISIBILITY
	unordered_multimap(initializer_list<value_type> __il, size_type __n, const hasher& __hf,
	const allocator_type& __a)
	: unordered_multimap(__il, __n, __hf, key_equal(), __a) {}
	#endif
	// ~unordered_multimap() = default;
	_LIBCPP_INLINE_VISIBILITY
	unordered_multimap& operator=(const unordered_multimap& __u)
	{
	#ifndef _LIBCPP_CXX03_LANG
	__table_ = __u.__table_;
	#else
	if (this != &__u) {
	__table_.clear();
	__table_.hash_function() = __u.__table_.hash_function();
	__table_.key_eq() = __u.__table_.key_eq();
	__table_.max_load_factor() = __u.__table_.max_load_factor();
	__table_.__copy_assign_alloc(__u.__table_);
	insert(__u.begin(), __u.end());
	}
	#endif
	return *this;
	}
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	unordered_multimap& operator=(unordered_multimap&& __u)
	_NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
	_LIBCPP_INLINE_VISIBILITY
	unordered_multimap& operator=(initializer_list<value_type> __il);
	#endif // _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	allocator_type get_allocator() const _NOEXCEPT
	{return allocator_type(__table_.__node_alloc());}

	_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();}
	_LIBCPP_INLINE_VISIBILITY
	size_type max_size() const _NOEXCEPT {return __table_.max_size();}

	_LIBCPP_INLINE_VISIBILITY
	iterator begin() _NOEXCEPT {return __table_.begin();}
	_LIBCPP_INLINE_VISIBILITY
	iterator end() _NOEXCEPT {return __table_.end();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator begin() const _NOEXCEPT {return __table_.begin();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator end() const _NOEXCEPT {return __table_.end();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator cend() const _NOEXCEPT {return __table_.end();}

	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}

	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __p, const value_type& __x)
	{return __table_.__insert_multi(__p.__i_, __x);}

	template <class _InputIterator>
	_LIBCPP_INLINE_VISIBILITY
	void insert(_InputIterator __first, _InputIterator __last);

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	void insert(initializer_list<value_type> __il)
	{insert(__il.begin(), __il.end());}
	_LIBCPP_INLINE_VISIBILITY
	iterator insert(value_type&& __x) {return __table_.__insert_multi(_VSTD::move(__x));}

	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __p, value_type&& __x)
	{return __table_.__insert_multi(__p.__i_, _VSTD::move(__x));}

	template <class _Pp,
	class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
	_LIBCPP_INLINE_VISIBILITY
	iterator insert(_Pp&& __x)
	{return __table_.__insert_multi(_VSTD::forward<_Pp>(__x));}

	template <class _Pp,
	class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __p, _Pp&& __x)
	{return __table_.__insert_multi(__p.__i_, _VSTD::forward<_Pp>(__x));}

	template <class... _Args>
	iterator emplace(_Args&&... __args) {
	return __table_.__emplace_multi(_VSTD::forward<_Args>(__args)...);
	}

	template <class... _Args>
	iterator emplace_hint(const_iterator __p, _Args&&... __args) {
	return __table_.__emplace_hint_multi(__p.__i_, _VSTD::forward<_Args>(__args)...);
	}
	#endif // _LIBCPP_CXX03_LANG


	_LIBCPP_INLINE_VISIBILITY
	iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);}
	_LIBCPP_INLINE_VISIBILITY
	iterator erase(iterator __p) {return __table_.erase(__p.__i_);}
	_LIBCPP_INLINE_VISIBILITY
	size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);}
	_LIBCPP_INLINE_VISIBILITY
	iterator erase(const_iterator __first, const_iterator __last)
	{return __table_.erase(__first.__i_, __last.__i_);}
	_LIBCPP_INLINE_VISIBILITY
	void clear() _NOEXCEPT {__table_.clear();}

	_LIBCPP_INLINE_VISIBILITY
	void swap(unordered_multimap& __u)
	_NOEXCEPT_(__is_nothrow_swappable<__table>::value)
	{__table_.swap(__u.__table_);}

	_LIBCPP_INLINE_VISIBILITY
	hasher hash_function() const
	{return __table_.hash_function().hash_function();}
	_LIBCPP_INLINE_VISIBILITY
	key_equal key_eq() const
	{return __table_.key_eq().key_eq();}

	_LIBCPP_INLINE_VISIBILITY
	iterator find(const key_type& __k) {return __table_.find(__k);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator find(const key_type& __k) const {return __table_.find(__k);}
	_LIBCPP_INLINE_VISIBILITY
	size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
	_LIBCPP_INLINE_VISIBILITY
	pair<iterator, iterator> equal_range(const key_type& __k)
	{return __table_.__equal_range_multi(__k);}
	_LIBCPP_INLINE_VISIBILITY
	pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
	{return __table_.__equal_range_multi(__k);}

	_LIBCPP_INLINE_VISIBILITY
	size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
	_LIBCPP_INLINE_VISIBILITY
	size_type max_bucket_count() const _NOEXCEPT
	{return __table_.max_bucket_count();}

	_LIBCPP_INLINE_VISIBILITY
	size_type bucket_size(size_type __n) const
	{return __table_.bucket_size(__n);}
	_LIBCPP_INLINE_VISIBILITY
	size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}

	_LIBCPP_INLINE_VISIBILITY
	local_iterator begin(size_type __n) {return __table_.begin(__n);}
	_LIBCPP_INLINE_VISIBILITY
	local_iterator end(size_type __n) {return __table_.end(__n);}
	_LIBCPP_INLINE_VISIBILITY
	const_local_iterator begin(size_type __n) const {return __table_.cbegin(__n);}
	_LIBCPP_INLINE_VISIBILITY
	const_local_iterator end(size_type __n) const {return __table_.cend(__n);}
	_LIBCPP_INLINE_VISIBILITY
	const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
	_LIBCPP_INLINE_VISIBILITY
	const_local_iterator cend(size_type __n) const {return __table_.cend(__n);}

	_LIBCPP_INLINE_VISIBILITY
	float load_factor() const _NOEXCEPT {return __table_.load_factor();}
	_LIBCPP_INLINE_VISIBILITY
	float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
	_LIBCPP_INLINE_VISIBILITY
	void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
	_LIBCPP_INLINE_VISIBILITY
	void rehash(size_type __n) {__table_.rehash(__n);}
	_LIBCPP_INLINE_VISIBILITY
	void reserve(size_type __n) {__table_.reserve(__n);}

	#if _LIBCPP_DEBUG_LEVEL >= 2

	bool __dereferenceable(const const_iterator* __i) const
	{return __table_.__dereferenceable(&__i->__i_);}
	bool __decrementable(const const_iterator* __i) const
	{return __table_.__decrementable(&__i->__i_);}
	bool __addable(const const_iterator* __i, ptrdiff_t __n) const
	{return __table_.__addable(&__i->__i_, __n);}
	bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
	{return __table_.__addable(&__i->__i_, __n);}

	#endif // _LIBCPP_DEBUG_LEVEL >= 2


	};

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
	size_type __n, const hasher& __hf, const key_equal& __eql)
	: __table_(__hf, __eql)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__table_.rehash(__n);
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
	size_type __n, const hasher& __hf, const key_equal& __eql,
	const allocator_type& __a)
	: __table_(__hf, __eql, typename __table::allocator_type(__a))
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__table_.rehash(__n);
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	template <class _InputIterator>
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
	_InputIterator __first, _InputIterator __last)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	insert(__first, __last);
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	template <class _InputIterator>
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
	_InputIterator __first, _InputIterator __last, size_type __n,
	const hasher& __hf, const key_equal& __eql)
	: __table_(__hf, __eql)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__table_.rehash(__n);
	insert(__first, __last);
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	template <class _InputIterator>
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
	_InputIterator __first, _InputIterator __last, size_type __n,
	const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
	: __table_(__hf, __eql, typename __table::allocator_type(__a))
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__table_.rehash(__n);
	insert(__first, __last);
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	inline
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
	const allocator_type& __a)
	: __table_(typename __table::allocator_type(__a))
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
	const unordered_multimap& __u)
	: __table_(__u.__table_)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__table_.rehash(__u.bucket_count());
	insert(__u.begin(), __u.end());
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
	const unordered_multimap& __u, const allocator_type& __a)
	: __table_(__u.__table_, typename __table::allocator_type(__a))
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__table_.rehash(__u.bucket_count());
	insert(__u.begin(), __u.end());
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	inline
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
	unordered_multimap&& __u)
	_NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
	: __table_(_VSTD::move(__u.__table_))
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	__get_db()->swap(this, &__u);
	#endif
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
	unordered_multimap&& __u, const allocator_type& __a)
	: __table_(_VSTD::move(__u.__table_), typename __table::allocator_type(__a))
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	if (__a != __u.get_allocator())
	{
	iterator __i = __u.begin();
	while (__u.size() != 0)
	{
	__table_.__insert_multi(
	- _VSTD::move(__u.__table_.remove((__i++).__i_)->__value_.__nc)
	- );
	+ __u.__table_.remove((__i++).__i_)->__value_.__move());
	}
	}
	#if _LIBCPP_DEBUG_LEVEL >= 2
	else
	__get_db()->swap(this, &__u);
	#endif
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
	initializer_list<value_type> __il)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	insert(__il.begin(), __il.end());
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
	initializer_list<value_type> __il, size_type __n, const hasher& __hf,
	const key_equal& __eql)
	: __table_(__hf, __eql)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__table_.rehash(__n);
	insert(__il.begin(), __il.end());
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
	initializer_list<value_type> __il, size_type __n, const hasher& __hf,
	const key_equal& __eql, const allocator_type& __a)
	: __table_(__hf, __eql, typename __table::allocator_type(__a))
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	__table_.rehash(__n);
	insert(__il.begin(), __il.end());
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	inline
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_multimap&& __u)
	_NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
	{
	__table_ = _VSTD::move(__u.__table_);
	return *this;
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	inline
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
	initializer_list<value_type> __il)
	{
	__table_.__assign_multi(__il.begin(), __il.end());
	return *this;
	}

	#endif // _LIBCPP_CXX03_LANG



	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	template <class _InputIterator>
	inline
	void
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
	_InputIterator __last)
	{
	for (; __first != __last; ++__first)
	__table_.__insert_multi(*__first);
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
	unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
	_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
	{
	__x.swap(__y);
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	bool
	operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
	const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
	{
	if (__x.size() != __y.size())
	return false;
	typedef typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::const_iterator
	const_iterator;
	typedef pair<const_iterator, const_iterator> _EqRng;
	for (const_iterator __i = __x.begin(), __ex = __x.end(); __i != __ex;)
	{
	_EqRng __xeq = __x.equal_range(__i->first);
	_EqRng __yeq = __y.equal_range(__i->first);
	if (_VSTD::distance(__xeq.first, __xeq.second) !=
	_VSTD::distance(__yeq.first, __yeq.second) \|\|
	!_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
	return false;
	__i = __xeq.second;
	}
	return true;
	}

	template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
	const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
	{
	return !(__x == __y);
	}

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_UNORDERED_MAP
	Index: projects/clang700-import/contrib/libc++/include/utility
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/utility (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/utility (revision 337135)
	@@ -1,1594 +1,1596 @@
	// -- C++ --
	//===-------------------------- utility -----------------------------------===//
	//
	// 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_UTILITY
	#define _LIBCPP_UTILITY

	/*
	utility synopsis

	+#include <initializer_list>
	+
	namespace std
	{

	template <class T>
	void
	swap(T& a, T& b);

	namespace rel_ops
	{
	template<class T> bool operator!=(const T&, const T&);
	template<class T> bool operator> (const T&, const T&);
	template<class T> bool operator<=(const T&, const T&);
	template<class T> bool operator>=(const T&, const T&);
	}

	template<class T>
	void
	swap(T& a, T& b) noexcept(is_nothrow_move_constructible<T>::value &&
	is_nothrow_move_assignable<T>::value);

	template <class T, size_t N>
	void
	swap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(a, b)));

	template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept; // constexpr in C++14
	template <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept; // constexpr in C++14

	template <class T> typename remove_reference<T>::type&& move(T&&) noexcept; // constexpr in C++14

	template <class T>
	typename conditional
	<
	!is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value,
	const T&,
	T&&
	>::type
	move_if_noexcept(T& x) noexcept; // constexpr in C++14

	-template <class T> constexpr add_const<T>_t& as_const(T& t) noexcept; // C++17
	+template <class T> constexpr add_const_t<T>& as_const(T& t) noexcept; // C++17
	template <class T> void as_const(const T&&) = delete; // C++17

	template <class T> typename add_rvalue_reference<T>::type declval() noexcept;

	template <class T1, class T2>
	struct pair
	{
	typedef T1 first_type;
	typedef T2 second_type;

	T1 first;
	T2 second;

	pair(const pair&) = default;
	pair(pair&&) = default;
	constexpr pair();
	pair(const T1& x, const T2& y); // constexpr in C++14
	template <class U, class V> pair(U&& x, V&& y); // constexpr in C++14
	template <class U, class V> pair(const pair<U, V>& p); // constexpr in C++14
	template <class U, class V> pair(pair<U, V>&& p); // constexpr in C++14
	template <class... Args1, class... Args2>
	pair(piecewise_construct_t, tuple<Args1...> first_args,
	tuple<Args2...> second_args);

	template <class U, class V> pair& operator=(const pair<U, V>& p);
	pair& operator=(pair&& p) noexcept(is_nothrow_move_assignable<T1>::value &&
	is_nothrow_move_assignable<T2>::value);
	template <class U, class V> pair& operator=(pair<U, V>&& p);

	void swap(pair& p) noexcept(is_nothrow_swappable_v<T1> &&
	is_nothrow_swappable_v<T2>);
	};

	template <class T1, class T2> bool operator==(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
	template <class T1, class T2> bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
	template <class T1, class T2> bool operator< (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
	template <class T1, class T2> bool operator> (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
	template <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
	template <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14

	template <class T1, class T2> pair<V1, V2> make_pair(T1&&, T2&&); // constexpr in C++14
	template <class T1, class T2>
	void
	swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));

	struct piecewise_construct_t { };
	inline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();

	template <class T> class tuple_size;
	template <size_t I, class T> class tuple_element;

	template <class T1, class T2> struct tuple_size<pair<T1, T2> >;
	template <class T1, class T2> struct tuple_element<0, pair<T1, T2> >;
	template <class T1, class T2> struct tuple_element<1, pair<T1, T2> >;

	template<size_t I, class T1, class T2>
	typename tuple_element<I, pair<T1, T2> >::type&
	get(pair<T1, T2>&) noexcept; // constexpr in C++14

	template<size_t I, class T1, class T2>
	const typename tuple_element<I, pair<T1, T2> >::type&
	get(const pair<T1, T2>&) noexcept; // constexpr in C++14

	template<size_t I, class T1, class T2>
	typename tuple_element<I, pair<T1, T2> >::type&&
	get(pair<T1, T2>&&) noexcept; // constexpr in C++14

	template<size_t I, class T1, class T2>
	const typename tuple_element<I, pair<T1, T2> >::type&&
	get(const pair<T1, T2>&&) noexcept; // constexpr in C++14

	template<class T1, class T2>
	constexpr T1& get(pair<T1, T2>&) noexcept; // C++14

	template<class T1, class T2>
	constexpr const T1& get(const pair<T1, T2>&) noexcept; // C++14

	template<class T1, class T2>
	constexpr T1&& get(pair<T1, T2>&&) noexcept; // C++14

	template<class T1, class T2>
	constexpr const T1&& get(const pair<T1, T2>&&) noexcept; // C++14

	template<class T1, class T2>
	constexpr T1& get(pair<T2, T1>&) noexcept; // C++14

	template<class T1, class T2>
	constexpr const T1& get(const pair<T2, T1>&) noexcept; // C++14

	template<class T1, class T2>
	constexpr T1&& get(pair<T2, T1>&&) noexcept; // C++14

	template<class T1, class T2>
	constexpr const T1&& get(const pair<T2, T1>&&) noexcept; // C++14

	// C++14

	template<class T, T... I>
	struct integer_sequence
	{
	typedef T value_type;

	static constexpr size_t size() noexcept;
	};

	template<size_t... I>
	using index_sequence = integer_sequence<size_t, I...>;

	template<class T, T N>
	using make_integer_sequence = integer_sequence<T, 0, 1, ..., N-1>;
	template<size_t N>
	using make_index_sequence = make_integer_sequence<size_t, N>;

	template<class... T>
	using index_sequence_for = make_index_sequence<sizeof...(T)>;

	template<class T, class U=T>
	T exchange(T& obj, U&& new_value);

	// 20.2.7, in-place construction // C++17
	struct in_place_t {
	explicit in_place_t() = default;
	};
	inline constexpr in_place_t in_place{};
	template <class T>
	struct in_place_type_t {
	explicit in_place_type_t() = default;
	};
	template <class T>
	inline constexpr in_place_type_t<T> in_place_type{};
	template <size_t I>
	struct in_place_index_t {
	explicit in_place_index_t() = default;
	};
	template <size_t I>
	inline constexpr in_place_index_t<I> in_place_index{};

	} // std

	*/

	#include <__config>
	#include <__tuple>
	#include <type_traits>
	#include <initializer_list>
	#include <cstddef>
	#include <cstring>
	#include <cstdint>
	#include <__debug>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	namespace rel_ops
	{

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const _Tp& __x, const _Tp& __y)
	{
	return !(__x == __y);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator> (const _Tp& __x, const _Tp& __y)
	{
	return __y < __x;
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const _Tp& __x, const _Tp& __y)
	{
	return !(__y < __x);
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const _Tp& __x, const _Tp& __y)
	{
	return !(__x < __y);
	}

	} // rel_ops

	// swap_ranges


	template <class _ForwardIterator1, class _ForwardIterator2>
	inline _LIBCPP_INLINE_VISIBILITY
	_ForwardIterator2
	swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)
	{
	for(; __first1 != __last1; ++__first1, (void) ++__first2)
	swap(__first1, __first2);
	return __first2;
	}

	// forward declared in <type_traits>
	template<class _Tp, size_t _Np>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if<
	__is_swappable<_Tp>::value
	>::type
	swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
	{
	_VSTD::swap_ranges(__a, __a + _Np, __b);
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	#ifndef _LIBCPP_CXX03_LANG
	typename conditional
	<
	!is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value,
	const _Tp&,
	_Tp&&
	>::type
	#else // _LIBCPP_CXX03_LANG
	const _Tp&
	#endif
	move_if_noexcept(_Tp& __x) _NOEXCEPT
	{
	return _VSTD::move(__x);
	}

	#if _LIBCPP_STD_VER > 14
	template <class _Tp> constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; }
	template <class _Tp> void as_const(const _Tp&&) = delete;
	#endif

	struct _LIBCPP_TEMPLATE_VIS piecewise_construct_t { };
	#if defined(_LIBCPP_CXX03_LANG) \|\| defined(_LIBCPP_BUILDING_UTILITY)
	extern const piecewise_construct_t piecewise_construct;// = piecewise_construct_t();
	#else
	/* _LIBCPP_INLINE_VAR */ constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
	#endif

	#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
	struct __non_trivially_copyable_base {
	_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
	__non_trivially_copyable_base() _NOEXCEPT {}
	_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
	__non_trivially_copyable_base(__non_trivially_copyable_base const&) _NOEXCEPT {}
	};
	#endif

	template <class _T1, class _T2>
	struct _LIBCPP_TEMPLATE_VIS pair
	#if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
	: private __non_trivially_copyable_base
	#endif
	{
	typedef _T1 first_type;
	typedef _T2 second_type;

	_T1 first;
	_T2 second;

	#if !defined(_LIBCPP_CXX03_LANG)
	pair(pair const&) = default;
	pair(pair&&) = default;
	#else
	// Use the implicitly declared copy constructor in C++03
	#endif

	#ifdef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	pair() : first(), second() {}

	_LIBCPP_INLINE_VISIBILITY
	pair(_T1 const& __t1, _T2 const& __t2) : first(__t1), second(__t2) {}

	template <class _U1, class _U2>
	_LIBCPP_INLINE_VISIBILITY
	pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {}

	_LIBCPP_INLINE_VISIBILITY
	pair& operator=(pair const& __p) {
	first = __p.first;
	second = __p.second;
	return *this;
	}
	#else
	template <bool _Val>
	using _EnableB = typename enable_if<_Val, bool>::type;

	struct _CheckArgs {
	template <class _U1, class _U2>
	static constexpr bool __enable_default() {
	return is_default_constructible<_U1>::value
	&& is_default_constructible<_U2>::value;
	}

	template <class _U1, class _U2>
	static constexpr bool __enable_explicit() {
	return is_constructible<first_type, _U1>::value
	&& is_constructible<second_type, _U2>::value
	&& (!is_convertible<_U1, first_type>::value
	\|\| !is_convertible<_U2, second_type>::value);
	}

	template <class _U1, class _U2>
	static constexpr bool __enable_implicit() {
	return is_constructible<first_type, _U1>::value
	&& is_constructible<second_type, _U2>::value
	&& is_convertible<_U1, first_type>::value
	&& is_convertible<_U2, second_type>::value;
	}
	};

	template <bool _MaybeEnable>
	using _CheckArgsDep = typename conditional<
	_MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type;

	struct _CheckTupleLikeConstructor {
	template <class _Tuple>
	static constexpr bool __enable_implicit() {
	return __tuple_convertible<_Tuple, pair>::value;
	}

	template <class _Tuple>
	static constexpr bool __enable_explicit() {
	return __tuple_constructible<_Tuple, pair>::value
	&& !__tuple_convertible<_Tuple, pair>::value;
	}

	template <class _Tuple>
	static constexpr bool __enable_assign() {
	return __tuple_assignable<_Tuple, pair>::value;
	}
	};

	template <class _Tuple>
	using _CheckTLC = typename conditional<
	__tuple_like_with_size<_Tuple, 2>::value
	&& !is_same<typename decay<_Tuple>::type, pair>::value,
	_CheckTupleLikeConstructor,
	__check_tuple_constructor_fail
	>::type;

	template<bool _Dummy = true, _EnableB<
	_CheckArgsDep<_Dummy>::template __enable_default<_T1, _T2>()
	> = false>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
	pair() : first(), second() {}

	template <bool _Dummy = true, _EnableB<
	_CheckArgsDep<_Dummy>::template __enable_explicit<_T1 const&, _T2 const&>()
	> = false>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	explicit pair(_T1 const& __t1, _T2 const& __t2)
	: first(__t1), second(__t2) {}

	template<bool _Dummy = true, _EnableB<
	_CheckArgsDep<_Dummy>::template __enable_implicit<_T1 const&, _T2 const&>()
	> = false>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	pair(_T1 const& __t1, _T2 const& __t2)
	: first(__t1), second(__t2) {}

	template<class _U1, class _U2, _EnableB<
	_CheckArgs::template __enable_explicit<_U1, _U2>()
	> = false>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	explicit pair(_U1&& __u1, _U2&& __u2)
	: first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}

	template<class _U1, class _U2, _EnableB<
	_CheckArgs::template __enable_implicit<_U1, _U2>()
	> = false>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	pair(_U1&& __u1, _U2&& __u2)
	: first(_VSTD::forward<_U1>(__u1)), second(_VSTD::forward<_U2>(__u2)) {}

	template<class _U1, class _U2, _EnableB<
	_CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>()
	> = false>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	explicit pair(pair<_U1, _U2> const& __p)
	: first(__p.first), second(__p.second) {}

	template<class _U1, class _U2, _EnableB<
	_CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>()
	> = false>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	pair(pair<_U1, _U2> const& __p)
	: first(__p.first), second(__p.second) {}

	template<class _U1, class _U2, _EnableB<
	_CheckArgs::template __enable_explicit<_U1, _U2>()
	> = false>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	explicit pair(pair<_U1, _U2>&&__p)
	: first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}

	template<class _U1, class _U2, _EnableB<
	_CheckArgs::template __enable_implicit<_U1, _U2>()
	> = false>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	pair(pair<_U1, _U2>&& __p)
	: first(_VSTD::forward<_U1>(__p.first)), second(_VSTD::forward<_U2>(__p.second)) {}

	template<class _Tuple, _EnableB<
	_CheckTLC<_Tuple>::template __enable_explicit<_Tuple>()
	> = false>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	explicit pair(_Tuple&& __p)
	: first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
	second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}

	template<class _Tuple, _EnableB<
	_CheckTLC<_Tuple>::template __enable_implicit<_Tuple>()
	> = false>
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	pair(_Tuple&& __p)
	: first(_VSTD::get<0>(_VSTD::forward<_Tuple>(__p))),
	second(_VSTD::get<1>(_VSTD::forward<_Tuple>(__p))) {}

	template <class... _Args1, class... _Args2>
	_LIBCPP_INLINE_VISIBILITY
	pair(piecewise_construct_t __pc,
	tuple<_Args1...> __first_args, tuple<_Args2...> __second_args)
	: pair(__pc, __first_args, __second_args,
	typename __make_tuple_indices<sizeof...(_Args1)>::type(),
	typename __make_tuple_indices<sizeof...(_Args2) >::type()) {}

	_LIBCPP_INLINE_VISIBILITY
	pair& operator=(typename conditional<
	is_copy_assignable<first_type>::value &&
	is_copy_assignable<second_type>::value,
	pair, __nat>::type const& __p)
	_NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
	is_nothrow_copy_assignable<second_type>::value)
	{
	first = __p.first;
	second = __p.second;
	return *this;
	}

	_LIBCPP_INLINE_VISIBILITY
	pair& operator=(typename conditional<
	is_move_assignable<first_type>::value &&
	is_move_assignable<second_type>::value,
	pair, __nat>::type&& __p)
	_NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
	is_nothrow_move_assignable<second_type>::value)
	{
	first = _VSTD::forward<first_type>(__p.first);
	second = _VSTD::forward<second_type>(__p.second);
	return *this;
	}

	template <class _Tuple, _EnableB<
	_CheckTLC<_Tuple>::template __enable_assign<_Tuple>()
	> = false>
	_LIBCPP_INLINE_VISIBILITY
	pair& operator=(_Tuple&& __p) {
	first = _VSTD::get<0>(_VSTD::forward<_Tuple>(__p));
	second = _VSTD::get<1>(_VSTD::forward<_Tuple>(__p));
	return *this;
	}
	#endif

	_LIBCPP_INLINE_VISIBILITY
	void
	swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value &&
	__is_nothrow_swappable<second_type>::value)
	{
	using _VSTD::swap;
	swap(first, __p.first);
	swap(second, __p.second);
	}
	private:

	#ifndef _LIBCPP_CXX03_LANG
	template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
	_LIBCPP_INLINE_VISIBILITY
	pair(piecewise_construct_t,
	tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
	__tuple_indices<_I1...>, __tuple_indices<_I2...>);
	#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
	operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
	{
	return __x.first == __y.first && __x.second == __y.second;
	}

	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
	{
	return !(__x == __y);
	}

	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator< (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
	{
	return __x.first < __y.first \|\| (!(__y.first < __x.first) && __x.second < __y.second);
	}

	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator> (const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
	{
	return __y < __x;
	}

	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator>=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
	{
	return !(__x < __y);
	}

	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	bool
	operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
	{
	return !(__y < __x);
	}

	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_swappable<_T1>::value &&
	__is_swappable<_T2>::value,
	void
	>::type
	swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
	_NOEXCEPT_((__is_nothrow_swappable<_T1>::value &&
	__is_nothrow_swappable<_T2>::value))
	{
	__x.swap(__y);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp>
	struct __make_pair_return_impl
	{
	typedef _Tp type;
	};

	template <class _Tp>
	struct __make_pair_return_impl<reference_wrapper<_Tp>>
	{
	typedef _Tp& type;
	};

	template <class _Tp>
	struct __make_pair_return
	{
	typedef typename __make_pair_return_impl<typename decay<_Tp>::type>::type type;
	};

	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>
	make_pair(_T1&& __t1, _T2&& __t2)
	{
	return pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>
	(_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2));
	}

	#else // _LIBCPP_CXX03_LANG

	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY
	pair<_T1,_T2>
	make_pair(_T1 __x, _T2 __y)
	{
	return pair<_T1, _T2>(__x, __y);
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _T1, class _T2>
	class _LIBCPP_TEMPLATE_VIS tuple_size<pair<_T1, _T2> >
	: public integral_constant<size_t, 2> {};

	template <size_t _Ip, class _T1, class _T2>
	class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, pair<_T1, _T2> >
	{
	static_assert(_Ip < 2, "Index out of bounds in std::tuple_element<std::pair<T1, T2>>");
	};

	template <class _T1, class _T2>
	class _LIBCPP_TEMPLATE_VIS tuple_element<0, pair<_T1, _T2> >
	{
	public:
	typedef _T1 type;
	};

	template <class _T1, class _T2>
	class _LIBCPP_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> >
	{
	public:
	typedef _T2 type;
	};

	template <size_t _Ip> struct __get_pair;

	template <>
	struct __get_pair<0>
	{
	template <class _T1, class _T2>
	static
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_T1&
	get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}

	template <class _T1, class _T2>
	static
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	const _T1&
	get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}

	#ifndef _LIBCPP_CXX03_LANG
	template <class _T1, class _T2>
	static
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_T1&&
	get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);}

	template <class _T1, class _T2>
	static
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	const _T1&&
	get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T1>(__p.first);}
	#endif // _LIBCPP_CXX03_LANG
	};

	template <>
	struct __get_pair<1>
	{
	template <class _T1, class _T2>
	static
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_T2&
	get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}

	template <class _T1, class _T2>
	static
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	const _T2&
	get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}

	#ifndef _LIBCPP_CXX03_LANG
	template <class _T1, class _T2>
	static
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	_T2&&
	get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);}

	template <class _T1, class _T2>
	static
	_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	const _T2&&
	get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<const _T2>(__p.second);}
	#endif // _LIBCPP_CXX03_LANG
	};

	template <size_t _Ip, class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	typename tuple_element<_Ip, pair<_T1, _T2> >::type&
	get(pair<_T1, _T2>& __p) _NOEXCEPT
	{
	return __get_pair<_Ip>::get(__p);
	}

	template <size_t _Ip, class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
	get(const pair<_T1, _T2>& __p) _NOEXCEPT
	{
	return __get_pair<_Ip>::get(__p);
	}

	#ifndef _LIBCPP_CXX03_LANG
	template <size_t _Ip, class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
	get(pair<_T1, _T2>&& __p) _NOEXCEPT
	{
	return __get_pair<_Ip>::get(_VSTD::move(__p));
	}

	template <size_t _Ip, class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
	const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
	get(const pair<_T1, _T2>&& __p) _NOEXCEPT
	{
	return __get_pair<_Ip>::get(_VSTD::move(__p));
	}
	#endif // _LIBCPP_CXX03_LANG

	#if _LIBCPP_STD_VER > 11
	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _T1 & get(pair<_T1, _T2>& __p) _NOEXCEPT
	{
	return __get_pair<0>::get(__p);
	}

	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _T1 const & get(pair<_T1, _T2> const& __p) _NOEXCEPT
	{
	return __get_pair<0>::get(__p);
	}

	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _T1 && get(pair<_T1, _T2>&& __p) _NOEXCEPT
	{
	return __get_pair<0>::get(_VSTD::move(__p));
	}

	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _T1 const && get(pair<_T1, _T2> const&& __p) _NOEXCEPT
	{
	return __get_pair<0>::get(_VSTD::move(__p));
	}

	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _T1 & get(pair<_T2, _T1>& __p) _NOEXCEPT
	{
	return __get_pair<1>::get(__p);
	}

	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _T1 const & get(pair<_T2, _T1> const& __p) _NOEXCEPT
	{
	return __get_pair<1>::get(__p);
	}

	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _T1 && get(pair<_T2, _T1>&& __p) _NOEXCEPT
	{
	return __get_pair<1>::get(_VSTD::move(__p));
	}

	template <class _T1, class _T2>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _T1 const && get(pair<_T2, _T1> const&& __p) _NOEXCEPT
	{
	return __get_pair<1>::get(_VSTD::move(__p));
	}

	#endif

	#if _LIBCPP_STD_VER > 11

	template<class _Tp, _Tp... _Ip>
	struct _LIBCPP_TEMPLATE_VIS integer_sequence
	{
	typedef _Tp value_type;
	static_assert( is_integral<_Tp>::value,
	"std::integer_sequence can only be instantiated with an integral type" );
	static
	_LIBCPP_INLINE_VISIBILITY
	constexpr
	size_t
	size() noexcept { return sizeof...(_Ip); }
	};

	template<size_t... _Ip>
	using index_sequence = integer_sequence<size_t, _Ip...>;

	#if __has_builtin(__make_integer_seq) && !defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)

	template <class _Tp, _Tp _Ep>
	using __make_integer_sequence = __make_integer_seq<integer_sequence, _Tp, _Ep>;

	#else

	template<typename _Tp, _Tp _Np> using __make_integer_sequence_unchecked =
	typename __detail::__make<_Np>::type::template __convert<integer_sequence, _Tp>;

	template <class _Tp, _Tp _Ep>
	struct __make_integer_sequence_checked
	{
	static_assert(is_integral<_Tp>::value,
	"std::make_integer_sequence can only be instantiated with an integral type" );
	static_assert(0 <= _Ep, "std::make_integer_sequence must have a non-negative sequence length");
	// Workaround GCC bug by preventing bad installations when 0 <= _Ep
	// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=68929
	typedef __make_integer_sequence_unchecked<_Tp, 0 <= _Ep ? _Ep : 0> type;
	};

	template <class _Tp, _Tp _Ep>
	using __make_integer_sequence = typename __make_integer_sequence_checked<_Tp, _Ep>::type;

	#endif

	template<class _Tp, _Tp _Np>
	using make_integer_sequence = __make_integer_sequence<_Tp, _Np>;

	template<size_t _Np>
	using make_index_sequence = make_integer_sequence<size_t, _Np>;

	template<class... _Tp>
	using index_sequence_for = make_index_sequence<sizeof...(_Tp)>;

	#endif // _LIBCPP_STD_VER > 11

	#if _LIBCPP_STD_VER > 11
	template<class _T1, class _T2 = _T1>
	-inline _LIBCPP_INLINE_VISIBILITY
	+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
	_T1 exchange(_T1& __obj, _T2 && __new_value)
	{
	_T1 __old_value = _VSTD::move(__obj);
	__obj = _VSTD::forward<_T2>(__new_value);
	return __old_value;
	}
	#endif // _LIBCPP_STD_VER > 11

	#if _LIBCPP_STD_VER > 14

	struct _LIBCPP_TYPE_VIS in_place_t {
	explicit in_place_t() = default;
	};
	_LIBCPP_INLINE_VAR constexpr in_place_t in_place{};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS in_place_type_t {
	explicit in_place_type_t() = default;
	};
	template <class _Tp>
	_LIBCPP_INLINE_VAR constexpr in_place_type_t<_Tp> in_place_type{};

	template <size_t _Idx>
	struct _LIBCPP_TYPE_VIS in_place_index_t {
	explicit in_place_index_t() = default;
	};
	template <size_t _Idx>
	_LIBCPP_INLINE_VAR constexpr in_place_index_t<_Idx> in_place_index{};

	template <class _Tp> struct __is_inplace_type_imp : false_type {};
	template <class _Tp> struct __is_inplace_type_imp<in_place_type_t<_Tp>> : true_type {};

	template <class _Tp>
	using __is_inplace_type = __is_inplace_type_imp<__uncvref_t<_Tp>>;

	template <class _Tp> struct __is_inplace_index_imp : false_type {};
	template <size_t _Idx> struct __is_inplace_index_imp<in_place_index_t<_Idx>> : true_type {};

	template <class _Tp>
	using __is_inplace_index = __is_inplace_index_imp<__uncvref_t<_Tp>>;

	#endif // _LIBCPP_STD_VER > 14

	template <class _Arg, class _Result>
	struct _LIBCPP_TEMPLATE_VIS unary_function
	{
	typedef _Arg argument_type;
	typedef _Result result_type;
	};

	template <class _Size>
	inline _LIBCPP_INLINE_VISIBILITY
	_Size
	__loadword(const void* __p)
	{
	_Size __r;
	std::memcpy(&__r, __p, sizeof(__r));
	return __r;
	}

	// We use murmur2 when size_t is 32 bits, and cityhash64 when size_t
	// is 64 bits. This is because cityhash64 uses 64bit x 64bit
	// multiplication, which can be very slow on 32-bit systems.
	template <class _Size, size_t = sizeof(_Size)*__CHAR_BIT__>
	struct __murmur2_or_cityhash;

	template <class _Size>
	struct __murmur2_or_cityhash<_Size, 32>
	{
	inline _Size operator()(const void* __key, _Size __len)
	_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK;
	};

	// murmur2
	template <class _Size>
	_Size
	__murmur2_or_cityhash<_Size, 32>::operator()(const void* __key, _Size __len)
	{
	const _Size __m = 0x5bd1e995;
	const _Size __r = 24;
	_Size __h = __len;
	const unsigned char* __data = static_cast<const unsigned char*>(__key);
	for (; __len >= 4; __data += 4, __len -= 4)
	{
	_Size __k = __loadword<_Size>(__data);
	__k *= __m;
	__k ^= __k >> __r;
	__k *= __m;
	__h *= __m;
	__h ^= __k;
	}
	switch (__len)
	{
	case 3:
	__h ^= __data[2] << 16;
	case 2:
	__h ^= __data[1] << 8;
	case 1:
	__h ^= __data[0];
	__h *= __m;
	}
	__h ^= __h >> 13;
	__h *= __m;
	__h ^= __h >> 15;
	return __h;
	}

	template <class _Size>
	struct __murmur2_or_cityhash<_Size, 64>
	{
	inline _Size operator()(const void* __key, _Size __len) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK;

	private:
	// Some primes between 2^63 and 2^64.
	static const _Size __k0 = 0xc3a5c85c97cb3127ULL;
	static const _Size __k1 = 0xb492b66fbe98f273ULL;
	static const _Size __k2 = 0x9ae16a3b2f90404fULL;
	static const _Size __k3 = 0xc949d7c7509e6557ULL;

	static _Size __rotate(_Size __val, int __shift) {
	return __shift == 0 ? __val : ((__val >> __shift) \| (__val << (64 - __shift)));
	}

	static _Size __rotate_by_at_least_1(_Size __val, int __shift) {
	return (__val >> __shift) \| (__val << (64 - __shift));
	}

	static _Size __shift_mix(_Size __val) {
	return __val ^ (__val >> 47);
	}

	static _Size __hash_len_16(_Size __u, _Size __v)
	_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
	{
	const _Size __mul = 0x9ddfea08eb382d69ULL;
	_Size __a = (__u ^ __v) * __mul;
	__a ^= (__a >> 47);
	_Size __b = (__v ^ __a) * __mul;
	__b ^= (__b >> 47);
	__b *= __mul;
	return __b;
	}

	static _Size __hash_len_0_to_16(const char* __s, _Size __len)
	_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
	{
	if (__len > 8) {
	const _Size __a = __loadword<_Size>(__s);
	const _Size __b = __loadword<_Size>(__s + __len - 8);
	return __hash_len_16(__a, __rotate_by_at_least_1(__b + __len, __len)) ^ __b;
	}
	if (__len >= 4) {
	const uint32_t __a = __loadword<uint32_t>(__s);
	const uint32_t __b = __loadword<uint32_t>(__s + __len - 4);
	return __hash_len_16(__len + (__a << 3), __b);
	}
	if (__len > 0) {
	const unsigned char __a = __s[0];
	const unsigned char __b = __s[__len >> 1];
	const unsigned char __c = __s[__len - 1];
	const uint32_t __y = static_cast<uint32_t>(__a) +
	(static_cast<uint32_t>(__b) << 8);
	const uint32_t __z = __len + (static_cast<uint32_t>(__c) << 2);
	return __shift_mix(__y * __k2 ^ __z * __k3) * __k2;
	}
	return __k2;
	}

	static _Size __hash_len_17_to_32(const char *__s, _Size __len)
	_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
	{
	const _Size __a = __loadword<_Size>(__s) * __k1;
	const _Size __b = __loadword<_Size>(__s + 8);
	const _Size __c = __loadword<_Size>(__s + __len - 8) * __k2;
	const _Size __d = __loadword<_Size>(__s + __len - 16) * __k0;
	return __hash_len_16(__rotate(__a - __b, 43) + __rotate(__c, 30) + __d,
	__a + __rotate(__b ^ __k3, 20) - __c + __len);
	}

	// Return a 16-byte hash for 48 bytes. Quick and dirty.
	// Callers do best to use "random-looking" values for a and b.
	static pair<_Size, _Size> __weak_hash_len_32_with_seeds(
	_Size __w, _Size __x, _Size __y, _Size __z, _Size __a, _Size __b)
	_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
	{
	__a += __w;
	__b = __rotate(__b + __a + __z, 21);
	const _Size __c = __a;
	__a += __x;
	__a += __y;
	__b += __rotate(__a, 44);
	return pair<_Size, _Size>(__a + __z, __b + __c);
	}

	// Return a 16-byte hash for s[0] ... s[31], a, and b. Quick and dirty.
	static pair<_Size, _Size> __weak_hash_len_32_with_seeds(
	const char* __s, _Size __a, _Size __b)
	_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
	{
	return __weak_hash_len_32_with_seeds(__loadword<_Size>(__s),
	__loadword<_Size>(__s + 8),
	__loadword<_Size>(__s + 16),
	__loadword<_Size>(__s + 24),
	__a,
	__b);
	}

	// Return an 8-byte hash for 33 to 64 bytes.
	static _Size __hash_len_33_to_64(const char *__s, size_t __len)
	_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
	{
	_Size __z = __loadword<_Size>(__s + 24);
	_Size __a = __loadword<_Size>(__s) +
	(__len + __loadword<_Size>(__s + __len - 16)) * __k0;
	_Size __b = __rotate(__a + __z, 52);
	_Size __c = __rotate(__a, 37);
	__a += __loadword<_Size>(__s + 8);
	__c += __rotate(__a, 7);
	__a += __loadword<_Size>(__s + 16);
	_Size __vf = __a + __z;
	_Size __vs = __b + __rotate(__a, 31) + __c;
	__a = __loadword<_Size>(__s + 16) + __loadword<_Size>(__s + __len - 32);
	__z += __loadword<_Size>(__s + __len - 8);
	__b = __rotate(__a + __z, 52);
	__c = __rotate(__a, 37);
	__a += __loadword<_Size>(__s + __len - 24);
	__c += __rotate(__a, 7);
	__a += __loadword<_Size>(__s + __len - 16);
	_Size __wf = __a + __z;
	_Size __ws = __b + __rotate(__a, 31) + __c;
	_Size __r = __shift_mix((__vf + __ws) * __k2 + (__wf + __vs) * __k0);
	return __shift_mix(__r * __k0 + __vs) * __k2;
	}
	};

	// cityhash64
	template <class _Size>
	_Size
	__murmur2_or_cityhash<_Size, 64>::operator()(const void* __key, _Size __len)
	{
	const char* __s = static_cast<const char*>(__key);
	if (__len <= 32) {
	if (__len <= 16) {
	return __hash_len_0_to_16(__s, __len);
	} else {
	return __hash_len_17_to_32(__s, __len);
	}
	} else if (__len <= 64) {
	return __hash_len_33_to_64(__s, __len);
	}

	// For strings over 64 bytes we hash the end first, and then as we
	// loop we keep 56 bytes of state: v, w, x, y, and z.
	_Size __x = __loadword<_Size>(__s + __len - 40);
	_Size __y = __loadword<_Size>(__s + __len - 16) +
	__loadword<_Size>(__s + __len - 56);
	_Size __z = __hash_len_16(__loadword<_Size>(__s + __len - 48) + __len,
	__loadword<_Size>(__s + __len - 24));
	pair<_Size, _Size> __v = __weak_hash_len_32_with_seeds(__s + __len - 64, __len, __z);
	pair<_Size, _Size> __w = __weak_hash_len_32_with_seeds(__s + __len - 32, __y + __k1, __x);
	__x = __x * __k1 + __loadword<_Size>(__s);

	// Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
	__len = (__len - 1) & ~static_cast<_Size>(63);
	do {
	__x = __rotate(__x + __y + __v.first + __loadword<_Size>(__s + 8), 37) * __k1;
	__y = __rotate(__y + __v.second + __loadword<_Size>(__s + 48), 42) * __k1;
	__x ^= __w.second;
	__y += __v.first + __loadword<_Size>(__s + 40);
	__z = __rotate(__z + __w.first, 33) * __k1;
	__v = __weak_hash_len_32_with_seeds(__s, __v.second * __k1, __x + __w.first);
	__w = __weak_hash_len_32_with_seeds(__s + 32, __z + __w.second,
	__y + __loadword<_Size>(__s + 16));
	std::swap(__z, __x);
	__s += 64;
	__len -= 64;
	} while (__len != 0);
	return __hash_len_16(
	__hash_len_16(__v.first, __w.first) + __shift_mix(__y) * __k1 + __z,
	__hash_len_16(__v.second, __w.second) + __x);
	}

	template <class _Tp, size_t = sizeof(_Tp) / sizeof(size_t)>
	struct __scalar_hash;

	template <class _Tp>
	struct __scalar_hash<_Tp, 0>
	: public unary_function<_Tp, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(_Tp __v) const _NOEXCEPT
	{
	union
	{
	_Tp __t;
	size_t __a;
	} __u;
	__u.__a = 0;
	__u.__t = __v;
	return __u.__a;
	}
	};

	template <class _Tp>
	struct __scalar_hash<_Tp, 1>
	: public unary_function<_Tp, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(_Tp __v) const _NOEXCEPT
	{
	union
	{
	_Tp __t;
	size_t __a;
	} __u;
	__u.__t = __v;
	return __u.__a;
	}
	};

	template <class _Tp>
	struct __scalar_hash<_Tp, 2>
	: public unary_function<_Tp, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(_Tp __v) const _NOEXCEPT
	{
	union
	{
	_Tp __t;
	struct
	{
	size_t __a;
	size_t __b;
	} __s;
	} __u;
	__u.__t = __v;
	return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
	}
	};

	template <class _Tp>
	struct __scalar_hash<_Tp, 3>
	: public unary_function<_Tp, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(_Tp __v) const _NOEXCEPT
	{
	union
	{
	_Tp __t;
	struct
	{
	size_t __a;
	size_t __b;
	size_t __c;
	} __s;
	} __u;
	__u.__t = __v;
	return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
	}
	};

	template <class _Tp>
	struct __scalar_hash<_Tp, 4>
	: public unary_function<_Tp, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(_Tp __v) const _NOEXCEPT
	{
	union
	{
	_Tp __t;
	struct
	{
	size_t __a;
	size_t __b;
	size_t __c;
	size_t __d;
	} __s;
	} __u;
	__u.__t = __v;
	return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
	}
	};

	struct _PairT {
	size_t first;
	size_t second;
	};

	_LIBCPP_INLINE_VISIBILITY
	inline size_t __hash_combine(size_t __lhs, size_t __rhs) _NOEXCEPT {
	typedef __scalar_hash<_PairT> _HashT;
	const _PairT __p = {__lhs, __rhs};
	return _HashT()(__p);
	}

	template<class _Tp>
	struct _LIBCPP_TEMPLATE_VIS hash<_Tp*>
	: public unary_function<_Tp*, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(_Tp* __v) const _NOEXCEPT
	{
	union
	{
	_Tp* __t;
	size_t __a;
	} __u;
	__u.__t = __v;
	return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
	}
	};


	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<bool>
	: public unary_function<bool, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<char>
	: public unary_function<char, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<signed char>
	: public unary_function<signed char, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<unsigned char>
	: public unary_function<unsigned char, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
	};

	#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<char16_t>
	: public unary_function<char16_t, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<char32_t>
	: public unary_function<char32_t, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
	};

	#endif // _LIBCPP_HAS_NO_UNICODE_CHARS

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<wchar_t>
	: public unary_function<wchar_t, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<short>
	: public unary_function<short, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<unsigned short>
	: public unary_function<unsigned short, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<int>
	: public unary_function<int, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<unsigned int>
	: public unary_function<unsigned int, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<long>
	: public unary_function<long, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<unsigned long>
	: public unary_function<unsigned long, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<long long>
	: public __scalar_hash<long long>
	{
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<unsigned long long>
	: public __scalar_hash<unsigned long long>
	{
	};

	#ifndef _LIBCPP_HAS_NO_INT128

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<__int128_t>
	: public __scalar_hash<__int128_t>
	{
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<__uint128_t>
	: public __scalar_hash<__uint128_t>
	{
	};

	#endif

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<float>
	: public __scalar_hash<float>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(float __v) const _NOEXCEPT
	{
	// -0.0 and 0.0 should return same hash
	if (__v == 0)
	return 0;
	return __scalar_hash<float>::operator()(__v);
	}
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<double>
	: public __scalar_hash<double>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(double __v) const _NOEXCEPT
	{
	// -0.0 and 0.0 should return same hash
	if (__v == 0)
	return 0;
	return __scalar_hash<double>::operator()(__v);
	}
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<long double>
	: public __scalar_hash<long double>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(long double __v) const _NOEXCEPT
	{
	// -0.0 and 0.0 should return same hash
	if (__v == 0)
	return 0;
	#if defined(__i386__)
	// Zero out padding bits
	union
	{
	long double __t;
	struct
	{
	size_t __a;
	size_t __b;
	size_t __c;
	size_t __d;
	} __s;
	} __u;
	__u.__s.__a = 0;
	__u.__s.__b = 0;
	__u.__s.__c = 0;
	__u.__s.__d = 0;
	__u.__t = __v;
	return __u.__s.__a ^ __u.__s.__b ^ __u.__s.__c ^ __u.__s.__d;
	#elif defined(__x86_64__)
	// Zero out padding bits
	union
	{
	long double __t;
	struct
	{
	size_t __a;
	size_t __b;
	} __s;
	} __u;
	__u.__s.__a = 0;
	__u.__s.__b = 0;
	__u.__t = __v;
	return __u.__s.__a ^ __u.__s.__b;
	#else
	return __scalar_hash<long double>::operator()(__v);
	#endif
	}
	};

	#if _LIBCPP_STD_VER > 11

	template <class _Tp, bool = is_enum<_Tp>::value>
	struct _LIBCPP_TEMPLATE_VIS __enum_hash
	: public unary_function<_Tp, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(_Tp __v) const _NOEXCEPT
	{
	typedef typename underlying_type<_Tp>::type type;
	return hash<type>{}(static_cast<type>(__v));
	}
	};
	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS __enum_hash<_Tp, false> {
	__enum_hash() = delete;
	__enum_hash(__enum_hash const&) = delete;
	__enum_hash& operator=(__enum_hash const&) = delete;
	};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS hash : public __enum_hash<_Tp>
	{
	};
	#endif

	#if _LIBCPP_STD_VER > 14

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<nullptr_t>
	: public unary_function<nullptr_t, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(nullptr_t) const _NOEXCEPT {
	return 662607004ull;
	}
	};
	#endif

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Key, class _Hash>
	using __check_hash_requirements = integral_constant<bool,
	is_copy_constructible<_Hash>::value &&
	is_move_constructible<_Hash>::value &&
	__invokable_r<size_t, _Hash, _Key const&>::value
	>;

	template <class _Key, class _Hash = std::hash<_Key> >
	using __has_enabled_hash = integral_constant<bool,
	__check_hash_requirements<_Key, _Hash>::value &&
	is_default_constructible<_Hash>::value
	>;

	#if _LIBCPP_STD_VER > 14
	template <class _Type, class>
	using __enable_hash_helper_imp = _Type;

	template <class _Type, class ..._Keys>
	using __enable_hash_helper = __enable_hash_helper_imp<_Type,
	typename enable_if<__all<__has_enabled_hash<_Keys>::value...>::value>::type
	>;
	#else
	template <class _Type, class ...>
	using __enable_hash_helper = _Type;
	#endif

	#endif // !_LIBCPP_CXX03_LANG

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_UTILITY
	Index: projects/clang700-import/contrib/libc++/include/valarray
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/valarray (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/valarray (revision 337135)
	@@ -1,4872 +1,4927 @@
	// -- C++ --
	//===-------------------------- valarray ----------------------------------===//
	//
	// 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_VALARRAY
	#define _LIBCPP_VALARRAY

	/*
	valarray synopsis

	namespace std
	{

	template<class T>
	class valarray
	{
	public:
	typedef T value_type;

	// construct/destroy:
	valarray();
	explicit valarray(size_t n);
	valarray(const value_type& x, size_t n);
	valarray(const value_type* px, size_t n);
	valarray(const valarray& v);
	valarray(valarray&& v) noexcept;
	valarray(const slice_array<value_type>& sa);
	valarray(const gslice_array<value_type>& ga);
	valarray(const mask_array<value_type>& ma);
	valarray(const indirect_array<value_type>& ia);
	valarray(initializer_list<value_type> il);
	~valarray();

	// assignment:
	valarray& operator=(const valarray& v);
	valarray& operator=(valarray&& v) noexcept;
	valarray& operator=(initializer_list<value_type> il);
	valarray& operator=(const value_type& x);
	valarray& operator=(const slice_array<value_type>& sa);
	valarray& operator=(const gslice_array<value_type>& ga);
	valarray& operator=(const mask_array<value_type>& ma);
	valarray& operator=(const indirect_array<value_type>& ia);

	// element access:
	const value_type& operator[](size_t i) const;
	value_type& operator[](size_t i);

	// subset operations:
	valarray operator[](slice s) const;
	slice_array<value_type> operator[](slice s);
	valarray operator[](const gslice& gs) const;
	gslice_array<value_type> operator[](const gslice& gs);
	valarray operator[](const valarray<bool>& vb) const;
	mask_array<value_type> operator[](const valarray<bool>& vb);
	valarray operator[](const valarray<size_t>& vs) const;
	indirect_array<value_type> operator[](const valarray<size_t>& vs);

	// unary operators:
	valarray operator+() const;
	valarray operator-() const;
	valarray operator~() const;
	valarray<bool> operator!() const;

	// computed assignment:
	valarray& operator*= (const value_type& x);
	valarray& operator/= (const value_type& x);
	valarray& operator%= (const value_type& x);
	valarray& operator+= (const value_type& x);
	valarray& operator-= (const value_type& x);
	valarray& operator^= (const value_type& x);
	valarray& operator&= (const value_type& x);
	valarray& operator\|= (const value_type& x);
	valarray& operator<<=(const value_type& x);
	valarray& operator>>=(const value_type& x);

	valarray& operator*= (const valarray& v);
	valarray& operator/= (const valarray& v);
	valarray& operator%= (const valarray& v);
	valarray& operator+= (const valarray& v);
	valarray& operator-= (const valarray& v);
	valarray& operator^= (const valarray& v);
	valarray& operator\|= (const valarray& v);
	valarray& operator&= (const valarray& v);
	valarray& operator<<=(const valarray& v);
	valarray& operator>>=(const valarray& v);

	// member functions:
	void swap(valarray& v) noexcept;

	size_t size() const;

	value_type sum() const;
	value_type min() const;
	value_type max() const;

	valarray shift (int i) const;
	valarray cshift(int i) const;
	valarray apply(value_type f(value_type)) const;
	valarray apply(value_type f(const value_type&)) const;
	void resize(size_t n, value_type x = value_type());
	};

	class slice
	{
	public:
	slice();
	slice(size_t start, size_t size, size_t stride);

	size_t start() const;
	size_t size() const;
	size_t stride() const;
	};

	template <class T>
	class slice_array
	{
	public:
	typedef T value_type;

	const slice_array& operator=(const slice_array& sa) const;
	void operator= (const valarray<value_type>& v) const;
	void operator*= (const valarray<value_type>& v) const;
	void operator/= (const valarray<value_type>& v) const;
	void operator%= (const valarray<value_type>& v) const;
	void operator+= (const valarray<value_type>& v) const;
	void operator-= (const valarray<value_type>& v) const;
	void operator^= (const valarray<value_type>& v) const;
	void operator&= (const valarray<value_type>& v) const;
	void operator\|= (const valarray<value_type>& v) const;
	void operator<<=(const valarray<value_type>& v) const;
	void operator>>=(const valarray<value_type>& v) const;

	void operator=(const value_type& x) const;

	slice_array() = delete;
	};

	class gslice
	{
	public:
	gslice();
	gslice(size_t start, const valarray<size_t>& size,
	const valarray<size_t>& stride);

	size_t start() const;
	valarray<size_t> size() const;
	valarray<size_t> stride() const;
	};

	template <class T>
	class gslice_array
	{
	public:
	typedef T value_type;

	void operator= (const valarray<value_type>& v) const;
	void operator*= (const valarray<value_type>& v) const;
	void operator/= (const valarray<value_type>& v) const;
	void operator%= (const valarray<value_type>& v) const;
	void operator+= (const valarray<value_type>& v) const;
	void operator-= (const valarray<value_type>& v) const;
	void operator^= (const valarray<value_type>& v) const;
	void operator&= (const valarray<value_type>& v) const;
	void operator\|= (const valarray<value_type>& v) const;
	void operator<<=(const valarray<value_type>& v) const;
	void operator>>=(const valarray<value_type>& v) const;

	gslice_array(const gslice_array& ga);
	~gslice_array();
	const gslice_array& operator=(const gslice_array& ga) const;
	void operator=(const value_type& x) const;

	gslice_array() = delete;
	};

	template <class T>
	class mask_array
	{
	public:
	typedef T value_type;

	void operator= (const valarray<value_type>& v) const;
	void operator*= (const valarray<value_type>& v) const;
	void operator/= (const valarray<value_type>& v) const;
	void operator%= (const valarray<value_type>& v) const;
	void operator+= (const valarray<value_type>& v) const;
	void operator-= (const valarray<value_type>& v) const;
	void operator^= (const valarray<value_type>& v) const;
	void operator&= (const valarray<value_type>& v) const;
	void operator\|= (const valarray<value_type>& v) const;
	void operator<<=(const valarray<value_type>& v) const;
	void operator>>=(const valarray<value_type>& v) const;

	mask_array(const mask_array& ma);
	~mask_array();
	const mask_array& operator=(const mask_array& ma) const;
	void operator=(const value_type& x) const;

	mask_array() = delete;
	};

	template <class T>
	class indirect_array
	{
	public:
	typedef T value_type;

	void operator= (const valarray<value_type>& v) const;
	void operator*= (const valarray<value_type>& v) const;
	void operator/= (const valarray<value_type>& v) const;
	void operator%= (const valarray<value_type>& v) const;
	void operator+= (const valarray<value_type>& v) const;
	void operator-= (const valarray<value_type>& v) const;
	void operator^= (const valarray<value_type>& v) const;
	void operator&= (const valarray<value_type>& v) const;
	void operator\|= (const valarray<value_type>& v) const;
	void operator<<=(const valarray<value_type>& v) const;
	void operator>>=(const valarray<value_type>& v) const;

	indirect_array(const indirect_array& ia);
	~indirect_array();
	const indirect_array& operator=(const indirect_array& ia) const;
	void operator=(const value_type& x) const;

	indirect_array() = delete;
	};

	template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept;

	template<class T> valarray<T> operator* (const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<T> operator* (const valarray<T>& x, const T& y);
	template<class T> valarray<T> operator* (const T& x, const valarray<T>& y);

	template<class T> valarray<T> operator/ (const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<T> operator/ (const valarray<T>& x, const T& y);
	template<class T> valarray<T> operator/ (const T& x, const valarray<T>& y);

	template<class T> valarray<T> operator% (const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<T> operator% (const valarray<T>& x, const T& y);
	template<class T> valarray<T> operator% (const T& x, const valarray<T>& y);

	template<class T> valarray<T> operator+ (const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<T> operator+ (const valarray<T>& x, const T& y);
	template<class T> valarray<T> operator+ (const T& x, const valarray<T>& y);

	template<class T> valarray<T> operator- (const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<T> operator- (const valarray<T>& x, const T& y);
	template<class T> valarray<T> operator- (const T& x, const valarray<T>& y);

	template<class T> valarray<T> operator^ (const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<T> operator^ (const valarray<T>& x, const T& y);
	template<class T> valarray<T> operator^ (const T& x, const valarray<T>& y);

	template<class T> valarray<T> operator& (const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<T> operator& (const valarray<T>& x, const T& y);
	template<class T> valarray<T> operator& (const T& x, const valarray<T>& y);

	template<class T> valarray<T> operator\| (const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<T> operator\| (const valarray<T>& x, const T& y);
	template<class T> valarray<T> operator\| (const T& x, const valarray<T>& y);

	template<class T> valarray<T> operator<<(const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<T> operator<<(const valarray<T>& x, const T& y);
	template<class T> valarray<T> operator<<(const T& x, const valarray<T>& y);

	template<class T> valarray<T> operator>>(const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<T> operator>>(const valarray<T>& x, const T& y);
	template<class T> valarray<T> operator>>(const T& x, const valarray<T>& y);

	template<class T> valarray<bool> operator&&(const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<bool> operator&&(const valarray<T>& x, const T& y);
	template<class T> valarray<bool> operator&&(const T& x, const valarray<T>& y);

	template<class T> valarray<bool> operator\|\|(const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<bool> operator\|\|(const valarray<T>& x, const T& y);
	template<class T> valarray<bool> operator\|\|(const T& x, const valarray<T>& y);

	template<class T> valarray<bool> operator==(const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<bool> operator==(const valarray<T>& x, const T& y);
	template<class T> valarray<bool> operator==(const T& x, const valarray<T>& y);

	template<class T> valarray<bool> operator!=(const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<bool> operator!=(const valarray<T>& x, const T& y);
	template<class T> valarray<bool> operator!=(const T& x, const valarray<T>& y);

	template<class T> valarray<bool> operator< (const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<bool> operator< (const valarray<T>& x, const T& y);
	template<class T> valarray<bool> operator< (const T& x, const valarray<T>& y);

	template<class T> valarray<bool> operator> (const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<bool> operator> (const valarray<T>& x, const T& y);
	template<class T> valarray<bool> operator> (const T& x, const valarray<T>& y);

	template<class T> valarray<bool> operator<=(const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<bool> operator<=(const valarray<T>& x, const T& y);
	template<class T> valarray<bool> operator<=(const T& x, const valarray<T>& y);

	template<class T> valarray<bool> operator>=(const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<bool> operator>=(const valarray<T>& x, const T& y);
	template<class T> valarray<bool> operator>=(const T& x, const valarray<T>& y);

	template<class T> valarray<T> abs (const valarray<T>& x);
	template<class T> valarray<T> acos (const valarray<T>& x);
	template<class T> valarray<T> asin (const valarray<T>& x);
	template<class T> valarray<T> atan (const valarray<T>& x);

	template<class T> valarray<T> atan2(const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<T> atan2(const valarray<T>& x, const T& y);
	template<class T> valarray<T> atan2(const T& x, const valarray<T>& y);

	template<class T> valarray<T> cos (const valarray<T>& x);
	template<class T> valarray<T> cosh (const valarray<T>& x);
	template<class T> valarray<T> exp (const valarray<T>& x);
	template<class T> valarray<T> log (const valarray<T>& x);
	template<class T> valarray<T> log10(const valarray<T>& x);

	template<class T> valarray<T> pow(const valarray<T>& x, const valarray<T>& y);
	template<class T> valarray<T> pow(const valarray<T>& x, const T& y);
	template<class T> valarray<T> pow(const T& x, const valarray<T>& y);

	template<class T> valarray<T> sin (const valarray<T>& x);
	template<class T> valarray<T> sinh (const valarray<T>& x);
	template<class T> valarray<T> sqrt (const valarray<T>& x);
	template<class T> valarray<T> tan (const valarray<T>& x);
	template<class T> valarray<T> tanh (const valarray<T>& x);

	template <class T> unspecified1 begin(valarray<T>& v);
	template <class T> unspecified2 begin(const valarray<T>& v);
	template <class T> unspecified1 end(valarray<T>& v);
	template <class T> unspecified2 end(const valarray<T>& v);

	} // std

	*/

	#include <__config>
	#include <cstddef>
	#include <cmath>
	#include <initializer_list>
	#include <algorithm>
	#include <functional>
	#include <new>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_STD

	template<class _Tp> class _LIBCPP_TEMPLATE_VIS valarray;

	class _LIBCPP_TEMPLATE_VIS slice
	{
	size_t __start_;
	size_t __size_;
	size_t __stride_;
	public:
	_LIBCPP_INLINE_VISIBILITY
	slice()
	: __start_(0),
	__size_(0),
	__stride_(0)
	{}

	_LIBCPP_INLINE_VISIBILITY
	slice(size_t __start, size_t __size, size_t __stride)
	: __start_(__start),
	__size_(__size),
	__stride_(__stride)
	{}

	_LIBCPP_INLINE_VISIBILITY size_t start() const {return __start_;}
	_LIBCPP_INLINE_VISIBILITY size_t size() const {return __size_;}
	_LIBCPP_INLINE_VISIBILITY size_t stride() const {return __stride_;}
	};

	template <class _Tp> class _LIBCPP_TEMPLATE_VIS slice_array;
	class _LIBCPP_TYPE_VIS gslice;
	template <class _Tp> class _LIBCPP_TEMPLATE_VIS gslice_array;
	template <class _Tp> class _LIBCPP_TEMPLATE_VIS mask_array;
	template <class _Tp> class _LIBCPP_TEMPLATE_VIS indirect_array;

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	_Tp*
	begin(valarray<_Tp>& __v);

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	const _Tp*
	begin(const valarray<_Tp>& __v);

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	_Tp*
	end(valarray<_Tp>& __v);

	template <class _Tp>
	_LIBCPP_INLINE_VISIBILITY
	const _Tp*
	end(const valarray<_Tp>& __v);

	template <class _Op, class _A0>
	struct _UnaryOp
	{
	typedef typename _Op::result_type result_type;
	typedef typename _A0::value_type value_type;

	_Op __op_;
	_A0 __a0_;

	_LIBCPP_INLINE_VISIBILITY
	_UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {}

	_LIBCPP_INLINE_VISIBILITY
	result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}

	_LIBCPP_INLINE_VISIBILITY
	size_t size() const {return __a0_.size();}
	};

	template <class _Op, class _A0, class _A1>
	struct _BinaryOp
	{
	typedef typename _Op::result_type result_type;
	typedef typename _A0::value_type value_type;

	_Op __op_;
	_A0 __a0_;
	_A1 __a1_;

	_LIBCPP_INLINE_VISIBILITY
	_BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1)
	: __op_(__op), __a0_(__a0), __a1_(__a1) {}

	_LIBCPP_INLINE_VISIBILITY
	value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}

	_LIBCPP_INLINE_VISIBILITY
	size_t size() const {return __a0_.size();}
	};

	template <class _Tp>
	class __scalar_expr
	{
	public:
	typedef _Tp value_type;
	typedef const _Tp& result_type;
	private:
	const value_type& __t_;
	size_t __s_;
	public:
	_LIBCPP_INLINE_VISIBILITY
	explicit __scalar_expr(const value_type& __t, size_t __s) : __t_(__t), __s_(__s) {}

	_LIBCPP_INLINE_VISIBILITY
	result_type operator[](size_t) const {return __t_;}

	_LIBCPP_INLINE_VISIBILITY
	size_t size() const {return __s_;}
	};

	template <class _Tp>
	struct __unary_plus : unary_function<_Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return +__x;}
	};

	template <class _Tp>
	struct __bit_not : unary_function<_Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return ~__x;}
	};

	template <class _Tp>
	struct __bit_shift_left : binary_function<_Tp, _Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x, const _Tp& __y) const
	{return __x << __y;}
	};

	template <class _Tp>
	struct __bit_shift_right : binary_function<_Tp, _Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x, const _Tp& __y) const
	{return __x >> __y;}
	};

	template <class _Tp, class _Fp>
	struct __apply_expr : unary_function<_Tp, _Tp>
	{
	private:
	_Fp __f_;
	public:
	_LIBCPP_INLINE_VISIBILITY
	explicit __apply_expr(_Fp __f) : __f_(__f) {}

	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return __f_(__x);}
	};

	template <class _Tp>
	struct __abs_expr : unary_function<_Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return abs(__x);}
	};

	template <class _Tp>
	struct __acos_expr : unary_function<_Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return acos(__x);}
	};

	template <class _Tp>
	struct __asin_expr : unary_function<_Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return asin(__x);}
	};

	template <class _Tp>
	struct __atan_expr : unary_function<_Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return atan(__x);}
	};

	template <class _Tp>
	struct __atan2_expr : binary_function<_Tp, _Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x, const _Tp& __y) const
	{return atan2(__x, __y);}
	};

	template <class _Tp>
	struct __cos_expr : unary_function<_Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return cos(__x);}
	};

	template <class _Tp>
	struct __cosh_expr : unary_function<_Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return cosh(__x);}
	};

	template <class _Tp>
	struct __exp_expr : unary_function<_Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return exp(__x);}
	};

	template <class _Tp>
	struct __log_expr : unary_function<_Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return log(__x);}
	};

	template <class _Tp>
	struct __log10_expr : unary_function<_Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return log10(__x);}
	};

	template <class _Tp>
	struct __pow_expr : binary_function<_Tp, _Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x, const _Tp& __y) const
	{return pow(__x, __y);}
	};

	template <class _Tp>
	struct __sin_expr : unary_function<_Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return sin(__x);}
	};

	template <class _Tp>
	struct __sinh_expr : unary_function<_Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return sinh(__x);}
	};

	template <class _Tp>
	struct __sqrt_expr : unary_function<_Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return sqrt(__x);}
	};

	template <class _Tp>
	struct __tan_expr : unary_function<_Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return tan(__x);}
	};

	template <class _Tp>
	struct __tanh_expr : unary_function<_Tp, _Tp>
	{
	_LIBCPP_INLINE_VISIBILITY
	_Tp operator()(const _Tp& __x) const
	{return tanh(__x);}
	};

	template <class _ValExpr>
	class __slice_expr
	{
	typedef typename remove_reference<_ValExpr>::type _RmExpr;
	public:
	typedef typename _RmExpr::value_type value_type;
	typedef value_type result_type;

	private:
	_ValExpr __expr_;
	size_t __start_;
	size_t __size_;
	size_t __stride_;

	_LIBCPP_INLINE_VISIBILITY
	__slice_expr(const slice& __sl, const _RmExpr& __e)
	: __expr_(__e),
	__start_(__sl.start()),
	__size_(__sl.size()),
	__stride_(__sl.stride())
	{}
	public:

	_LIBCPP_INLINE_VISIBILITY
	result_type operator[](size_t __i) const
	{return __expr_[__start_ + __i * __stride_];}

	_LIBCPP_INLINE_VISIBILITY
	size_t size() const {return __size_;}

	template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
	};

	template <class _ValExpr>
	class __mask_expr;

	template <class _ValExpr>
	class __indirect_expr;

	template <class _ValExpr>
	class __shift_expr
	{
	typedef typename remove_reference<_ValExpr>::type _RmExpr;
	public:
	typedef typename _RmExpr::value_type value_type;
	typedef value_type result_type;

	private:
	_ValExpr __expr_;
	size_t __size_;
	ptrdiff_t __ul_;
	ptrdiff_t __sn_;
	ptrdiff_t __n_;
	static const ptrdiff_t _Np = static_cast<ptrdiff_t>(
	sizeof(ptrdiff_t) * __CHAR_BIT__ - 1);

	_LIBCPP_INLINE_VISIBILITY
	__shift_expr(int __n, const _RmExpr& __e)
	: __expr_(__e),
	__size_(__e.size()),
	__n_(__n)
	{
	ptrdiff_t __neg_n = static_cast<ptrdiff_t>(__n_ >> _Np);
	__sn_ = __neg_n \| static_cast<ptrdiff_t>(static_cast<size_t>(-__n_) >> _Np);
	__ul_ = ((__size_ - __n_) & ~__neg_n) \| ((__n_ + 1) & __neg_n);
	}
	public:

	_LIBCPP_INLINE_VISIBILITY
	result_type operator[](size_t __j) const
	{
	ptrdiff_t __i = static_cast<ptrdiff_t>(__j);
	ptrdiff_t __m = (__sn_ * __i - __ul_) >> _Np;
	return (__expr_[(__i + __n_) & __m] & __m) \| (value_type() & ~__m);
	}

	_LIBCPP_INLINE_VISIBILITY
	size_t size() const {return __size_;}

	template <class> friend class __val_expr;
	};

	template <class _ValExpr>
	class __cshift_expr
	{
	typedef typename remove_reference<_ValExpr>::type _RmExpr;
	public:
	typedef typename _RmExpr::value_type value_type;
	typedef value_type result_type;

	private:
	_ValExpr __expr_;
	size_t __size_;
	size_t __m_;
	size_t __o1_;
	size_t __o2_;

	_LIBCPP_INLINE_VISIBILITY
	__cshift_expr(int __n, const _RmExpr& __e)
	: __expr_(__e),
	__size_(__e.size())
	{
	__n %= static_cast<int>(__size_);
	if (__n >= 0)
	{
	__m_ = __size_ - __n;
	__o1_ = __n;
	__o2_ = __n - __size_;
	}
	else
	{
	__m_ = -__n;
	__o1_ = __n + __size_;
	__o2_ = __n;
	}
	}
	public:

	_LIBCPP_INLINE_VISIBILITY
	result_type operator[](size_t __i) const
	{
	if (__i < __m_)
	return __expr_[__i + __o1_];
	return __expr_[__i + __o2_];
	}

	_LIBCPP_INLINE_VISIBILITY
	size_t size() const {return __size_;}

	template <class> friend class __val_expr;
	};

	template<class _ValExpr>
	class __val_expr;

	template<class _ValExpr>
	struct __is_val_expr : false_type {};

	template<class _ValExpr>
	struct __is_val_expr<__val_expr<_ValExpr> > : true_type {};

	template<class _Tp>
	struct __is_val_expr<valarray<_Tp> > : true_type {};

	template<class _Tp>
	class _LIBCPP_TEMPLATE_VIS valarray
	{
	public:
	typedef _Tp value_type;
	typedef _Tp result_type;

	private:
	value_type* __begin_;
	value_type* __end_;

	public:
	// construct/destroy:
	_LIBCPP_INLINE_VISIBILITY
	valarray() : __begin_(0), __end_(0) {}
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	explicit valarray(size_t __n);
	_LIBCPP_INLINE_VISIBILITY
	valarray(const value_type& __x, size_t __n);
	valarray(const value_type* __p, size_t __n);
	valarray(const valarray& __v);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	valarray(valarray&& __v) _NOEXCEPT;
	valarray(initializer_list<value_type> __il);
	#endif // _LIBCPP_CXX03_LANG
	valarray(const slice_array<value_type>& __sa);
	valarray(const gslice_array<value_type>& __ga);
	valarray(const mask_array<value_type>& __ma);
	valarray(const indirect_array<value_type>& __ia);
	inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
	~valarray();

	// assignment:
	valarray& operator=(const valarray& __v);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator=(valarray&& __v) _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator=(initializer_list<value_type>);
	#endif // _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator=(const value_type& __x);
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator=(const slice_array<value_type>& __sa);
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator=(const gslice_array<value_type>& __ga);
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator=(const mask_array<value_type>& __ma);
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator=(const indirect_array<value_type>& __ia);
	template <class _ValExpr>
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator=(const __val_expr<_ValExpr>& __v);

	// element access:
	_LIBCPP_INLINE_VISIBILITY
	const value_type& operator[](size_t __i) const {return __begin_[__i];}

	_LIBCPP_INLINE_VISIBILITY
	value_type& operator[](size_t __i) {return __begin_[__i];}

	// subset operations:
	_LIBCPP_INLINE_VISIBILITY
	__val_expr<__slice_expr<const valarray&> > operator[](slice __s) const;
	_LIBCPP_INLINE_VISIBILITY
	slice_array<value_type> operator[](slice __s);
	_LIBCPP_INLINE_VISIBILITY
	__val_expr<__indirect_expr<const valarray&> > operator[](const gslice& __gs) const;
	_LIBCPP_INLINE_VISIBILITY
	gslice_array<value_type> operator[](const gslice& __gs);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	__val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const;
	_LIBCPP_INLINE_VISIBILITY
	gslice_array<value_type> operator[](gslice&& __gs);
	#endif // _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	__val_expr<__mask_expr<const valarray&> > operator[](const valarray<bool>& __vb) const;
	_LIBCPP_INLINE_VISIBILITY
	mask_array<value_type> operator[](const valarray<bool>& __vb);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	__val_expr<__mask_expr<const valarray&> > operator[](valarray<bool>&& __vb) const;
	_LIBCPP_INLINE_VISIBILITY
	mask_array<value_type> operator[](valarray<bool>&& __vb);
	#endif // _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	__val_expr<__indirect_expr<const valarray&> > operator[](const valarray<size_t>& __vs) const;
	_LIBCPP_INLINE_VISIBILITY
	indirect_array<value_type> operator[](const valarray<size_t>& __vs);
	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	__val_expr<__indirect_expr<const valarray&> > operator[](valarray<size_t>&& __vs) const;
	_LIBCPP_INLINE_VISIBILITY
	indirect_array<value_type> operator[](valarray<size_t>&& __vs);
	#endif // _LIBCPP_CXX03_LANG

	// unary operators:
	valarray operator+() const;
	valarray operator-() const;
	valarray operator~() const;
	valarray<bool> operator!() const;

	// computed assignment:
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator*= (const value_type& __x);
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator/= (const value_type& __x);
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator%= (const value_type& __x);
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator+= (const value_type& __x);
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator-= (const value_type& __x);
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator^= (const value_type& __x);
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator&= (const value_type& __x);
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator\|= (const value_type& __x);
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator<<=(const value_type& __x);
	_LIBCPP_INLINE_VISIBILITY
	valarray& operator>>=(const value_type& __x);

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator*= (const _Expr& __v);

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator/= (const _Expr& __v);

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator%= (const _Expr& __v);

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator+= (const _Expr& __v);

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator-= (const _Expr& __v);

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator^= (const _Expr& __v);

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator\|= (const _Expr& __v);

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator&= (const _Expr& __v);

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator<<= (const _Expr& __v);

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray&
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator>>= (const _Expr& __v);

	// member functions:
	_LIBCPP_INLINE_VISIBILITY
	void swap(valarray& __v) _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY
	size_t size() const {return static_cast<size_t>(__end_ - __begin_);}

	_LIBCPP_INLINE_VISIBILITY
	value_type sum() const;
	_LIBCPP_INLINE_VISIBILITY
	value_type min() const;
	_LIBCPP_INLINE_VISIBILITY
	value_type max() const;

	valarray shift (int __i) const;
	valarray cshift(int __i) const;
	valarray apply(value_type __f(value_type)) const;
	valarray apply(value_type __f(const value_type&)) const;
	void resize(size_t __n, value_type __x = value_type());

	private:
	template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
	template <class> friend class _LIBCPP_TEMPLATE_VIS slice_array;
	template <class> friend class _LIBCPP_TEMPLATE_VIS gslice_array;
	template <class> friend class _LIBCPP_TEMPLATE_VIS mask_array;
	template <class> friend class __mask_expr;
	template <class> friend class _LIBCPP_TEMPLATE_VIS indirect_array;
	template <class> friend class __indirect_expr;
	template <class> friend class __val_expr;

	template <class _Up>
	friend
	_Up*
	begin(valarray<_Up>& __v);

	template <class _Up>
	friend
	const _Up*
	begin(const valarray<_Up>& __v);

	template <class _Up>
	friend
	_Up*
	end(valarray<_Up>& __v);

	template <class _Up>
	friend
	const _Up*
	end(const valarray<_Up>& __v);
	+
	+ void __clear();
	+ valarray& __assign_range(const value_type* __f, const value_type* __l);
	};

	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS valarray<size_t>::valarray(size_t))
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS valarray<size_t>::~valarray())
	_LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void valarray<size_t>::resize(size_t, size_t))

	template <class _Op, class _Tp>
	struct _UnaryOp<_Op, valarray<_Tp> >
	{
	typedef typename _Op::result_type result_type;
	typedef _Tp value_type;

	_Op __op_;
	const valarray<_Tp>& __a0_;

	_LIBCPP_INLINE_VISIBILITY
	_UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {}

	_LIBCPP_INLINE_VISIBILITY
	result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}

	_LIBCPP_INLINE_VISIBILITY
	size_t size() const {return __a0_.size();}
	};

	template <class _Op, class _Tp, class _A1>
	struct _BinaryOp<_Op, valarray<_Tp>, _A1>
	{
	typedef typename _Op::result_type result_type;
	typedef _Tp value_type;

	_Op __op_;
	const valarray<_Tp>& __a0_;
	_A1 __a1_;

	_LIBCPP_INLINE_VISIBILITY
	_BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1)
	: __op_(__op), __a0_(__a0), __a1_(__a1) {}

	_LIBCPP_INLINE_VISIBILITY
	value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}

	_LIBCPP_INLINE_VISIBILITY
	size_t size() const {return __a0_.size();}
	};

	template <class _Op, class _A0, class _Tp>
	struct _BinaryOp<_Op, _A0, valarray<_Tp> >
	{
	typedef typename _Op::result_type result_type;
	typedef _Tp value_type;

	_Op __op_;
	_A0 __a0_;
	const valarray<_Tp>& __a1_;

	_LIBCPP_INLINE_VISIBILITY
	_BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1)
	: __op_(__op), __a0_(__a0), __a1_(__a1) {}

	_LIBCPP_INLINE_VISIBILITY
	value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}

	_LIBCPP_INLINE_VISIBILITY
	size_t size() const {return __a0_.size();}
	};

	template <class _Op, class _Tp>
	struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> >
	{
	typedef typename _Op::result_type result_type;
	typedef _Tp value_type;

	_Op __op_;
	const valarray<_Tp>& __a0_;
	const valarray<_Tp>& __a1_;

	_LIBCPP_INLINE_VISIBILITY
	_BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1)
	: __op_(__op), __a0_(__a0), __a1_(__a1) {}

	_LIBCPP_INLINE_VISIBILITY
	value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}

	_LIBCPP_INLINE_VISIBILITY
	size_t size() const {return __a0_.size();}
	};

	// slice_array

	template <class _Tp>
	class _LIBCPP_TEMPLATE_VIS slice_array
	{
	public:
	typedef _Tp value_type;

	private:
	value_type* __vp_;
	size_t __size_;
	size_t __stride_;

	public:
	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator*=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator/=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator%=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator+=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator-=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator^=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator&=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator\|=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator<<=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator>>=(const _Expr& __v) const;

	_LIBCPP_INLINE_VISIBILITY
	const slice_array& operator=(const slice_array& __sa) const;

	_LIBCPP_INLINE_VISIBILITY
	void operator=(const value_type& __x) const;

	private:
	_LIBCPP_INLINE_VISIBILITY
	slice_array(const slice& __sl, const valarray<value_type>& __v)
	: __vp_(const_cast<value_type*>(__v.__begin_ + __sl.start())),
	__size_(__sl.size()),
	__stride_(__sl.stride())
	{}

	template <class> friend class valarray;
	template <class> friend class sliceExpr;
	};

	template <class _Tp>
	inline
	const slice_array<_Tp>&
	slice_array<_Tp>::operator=(const slice_array& __sa) const
	{
	value_type* __t = __vp_;
	const value_type* __s = __sa.__vp_;
	for (size_t __n = __size_; __n; --__n, __t += __stride_, __s += __sa.__stride_)
	__t = __s;
	return *this;
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	slice_array<_Tp>::operator=(const _Expr& __v) const
	{
	value_type* __t = __vp_;
	for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
	*__t = __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	slice_array<_Tp>::operator*=(const _Expr& __v) const
	{
	value_type* __t = __vp_;
	for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
	__t = __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	slice_array<_Tp>::operator/=(const _Expr& __v) const
	{
	value_type* __t = __vp_;
	for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
	*__t /= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	slice_array<_Tp>::operator%=(const _Expr& __v) const
	{
	value_type* __t = __vp_;
	for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
	*__t %= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	slice_array<_Tp>::operator+=(const _Expr& __v) const
	{
	value_type* __t = __vp_;
	for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
	*__t += __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	slice_array<_Tp>::operator-=(const _Expr& __v) const
	{
	value_type* __t = __vp_;
	for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
	*__t -= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	slice_array<_Tp>::operator^=(const _Expr& __v) const
	{
	value_type* __t = __vp_;
	for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
	*__t ^= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	slice_array<_Tp>::operator&=(const _Expr& __v) const
	{
	value_type* __t = __vp_;
	for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
	*__t &= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	slice_array<_Tp>::operator\|=(const _Expr& __v) const
	{
	value_type* __t = __vp_;
	for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
	*__t \|= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	slice_array<_Tp>::operator<<=(const _Expr& __v) const
	{
	value_type* __t = __vp_;
	for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
	*__t <<= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	slice_array<_Tp>::operator>>=(const _Expr& __v) const
	{
	value_type* __t = __vp_;
	for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
	*__t >>= __v[__i];
	}

	template <class _Tp>
	inline
	void
	slice_array<_Tp>::operator=(const value_type& __x) const
	{
	value_type* __t = __vp_;
	for (size_t __n = __size_; __n; --__n, __t += __stride_)
	*__t = __x;
	}

	// gslice

	class _LIBCPP_TYPE_VIS gslice
	{
	valarray<size_t> __size_;
	valarray<size_t> __stride_;
	valarray<size_t> __1d_;

	public:
	_LIBCPP_INLINE_VISIBILITY
	gslice() {}

	_LIBCPP_INLINE_VISIBILITY
	gslice(size_t __start, const valarray<size_t>& __size,
	const valarray<size_t>& __stride)
	: __size_(__size),
	__stride_(__stride)
	{__init(__start);}

	#ifndef _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	gslice(size_t __start, const valarray<size_t>& __size,
	valarray<size_t>&& __stride)
	: __size_(__size),
	__stride_(move(__stride))
	{__init(__start);}

	_LIBCPP_INLINE_VISIBILITY
	gslice(size_t __start, valarray<size_t>&& __size,
	const valarray<size_t>& __stride)
	: __size_(move(__size)),
	__stride_(__stride)
	{__init(__start);}

	_LIBCPP_INLINE_VISIBILITY
	gslice(size_t __start, valarray<size_t>&& __size,
	valarray<size_t>&& __stride)
	: __size_(move(__size)),
	__stride_(move(__stride))
	{__init(__start);}

	#endif // _LIBCPP_CXX03_LANG

	// gslice(const gslice&) = default;
	// gslice(gslice&&) = default;
	// gslice& operator=(const gslice&) = default;
	// gslice& operator=(gslice&&) = default;

	_LIBCPP_INLINE_VISIBILITY
	size_t start() const {return __1d_.size() ? __1d_[0] : 0;}

	_LIBCPP_INLINE_VISIBILITY
	valarray<size_t> size() const {return __size_;}

	_LIBCPP_INLINE_VISIBILITY
	valarray<size_t> stride() const {return __stride_;}

	private:
	void __init(size_t __start);

	template <class> friend class gslice_array;
	template <class> friend class valarray;
	template <class> friend class __val_expr;
	};

	// gslice_array

	template <class _Tp>
	class _LIBCPP_TEMPLATE_VIS gslice_array
	{
	public:
	typedef _Tp value_type;

	private:
	value_type* __vp_;
	valarray<size_t> __1d_;

	public:
	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator*=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator/=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator%=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator+=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator-=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator^=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator&=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator\|=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator<<=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator>>=(const _Expr& __v) const;

	_LIBCPP_INLINE_VISIBILITY
	const gslice_array& operator=(const gslice_array& __ga) const;

	_LIBCPP_INLINE_VISIBILITY
	void operator=(const value_type& __x) const;

	// gslice_array(const gslice_array&) = default;
	// gslice_array(gslice_array&&) = default;
	// gslice_array& operator=(const gslice_array&) = default;
	// gslice_array& operator=(gslice_array&&) = default;

	private:
	gslice_array(const gslice& __gs, const valarray<value_type>& __v)
	: __vp_(const_cast<value_type*>(__v.__begin_)),
	__1d_(__gs.__1d_)
	{}

	#ifndef _LIBCPP_CXX03_LANG
	gslice_array(gslice&& __gs, const valarray<value_type>& __v)
	: __vp_(const_cast<value_type*>(__v.__begin_)),
	__1d_(move(__gs.__1d_))
	{}
	#endif // _LIBCPP_CXX03_LANG

	template <class> friend class valarray;
	};

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	gslice_array<_Tp>::operator=(const _Expr& __v) const
	{
	typedef const size_t* _Ip;
	size_t __j = 0;
	for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
	__vp_[*__i] = __v[__j];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	gslice_array<_Tp>::operator*=(const _Expr& __v) const
	{
	typedef const size_t* _Ip;
	size_t __j = 0;
	for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
	__vp_[__i] = __v[__j];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	gslice_array<_Tp>::operator/=(const _Expr& __v) const
	{
	typedef const size_t* _Ip;
	size_t __j = 0;
	for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
	__vp_[*__i] /= __v[__j];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	gslice_array<_Tp>::operator%=(const _Expr& __v) const
	{
	typedef const size_t* _Ip;
	size_t __j = 0;
	for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
	__vp_[*__i] %= __v[__j];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	gslice_array<_Tp>::operator+=(const _Expr& __v) const
	{
	typedef const size_t* _Ip;
	size_t __j = 0;
	for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
	__vp_[*__i] += __v[__j];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	gslice_array<_Tp>::operator-=(const _Expr& __v) const
	{
	typedef const size_t* _Ip;
	size_t __j = 0;
	for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
	__vp_[*__i] -= __v[__j];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	gslice_array<_Tp>::operator^=(const _Expr& __v) const
	{
	typedef const size_t* _Ip;
	size_t __j = 0;
	for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
	__vp_[*__i] ^= __v[__j];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	gslice_array<_Tp>::operator&=(const _Expr& __v) const
	{
	typedef const size_t* _Ip;
	size_t __j = 0;
	for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
	__vp_[*__i] &= __v[__j];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	gslice_array<_Tp>::operator\|=(const _Expr& __v) const
	{
	typedef const size_t* _Ip;
	size_t __j = 0;
	for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
	__vp_[*__i] \|= __v[__j];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	gslice_array<_Tp>::operator<<=(const _Expr& __v) const
	{
	typedef const size_t* _Ip;
	size_t __j = 0;
	for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
	__vp_[*__i] <<= __v[__j];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	gslice_array<_Tp>::operator>>=(const _Expr& __v) const
	{
	typedef const size_t* _Ip;
	size_t __j = 0;
	for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
	__vp_[*__i] >>= __v[__j];
	}

	template <class _Tp>
	inline
	const gslice_array<_Tp>&
	gslice_array<_Tp>::operator=(const gslice_array& __ga) const
	{
	typedef const size_t* _Ip;
	const value_type* __s = __ga.__vp_;
	for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ga.__1d_.__begin_;
	__i != __e; ++__i, ++__j)
	__vp_[__i] = __s[__j];
	return *this;
	}

	template <class _Tp>
	inline
	void
	gslice_array<_Tp>::operator=(const value_type& __x) const
	{
	typedef const size_t* _Ip;
	for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
	__vp_[*__i] = __x;
	}

	// mask_array

	template <class _Tp>
	class _LIBCPP_TEMPLATE_VIS mask_array
	{
	public:
	typedef _Tp value_type;

	private:
	value_type* __vp_;
	valarray<size_t> __1d_;

	public:
	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator*=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator/=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator%=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator+=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator-=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator^=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator&=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator\|=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator<<=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator>>=(const _Expr& __v) const;

	_LIBCPP_INLINE_VISIBILITY
	const mask_array& operator=(const mask_array& __ma) const;

	_LIBCPP_INLINE_VISIBILITY
	void operator=(const value_type& __x) const;

	// mask_array(const mask_array&) = default;
	// mask_array(mask_array&&) = default;
	// mask_array& operator=(const mask_array&) = default;
	// mask_array& operator=(mask_array&&) = default;

	private:
	_LIBCPP_INLINE_VISIBILITY
	mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v)
	: __vp_(const_cast<value_type*>(__v.__begin_)),
	__1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true)))
	{
	size_t __j = 0;
	for (size_t __i = 0; __i < __vb.size(); ++__i)
	if (__vb[__i])
	__1d_[__j++] = __i;
	}

	template <class> friend class valarray;
	};

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	mask_array<_Tp>::operator=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] = __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	mask_array<_Tp>::operator*=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] *= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	mask_array<_Tp>::operator/=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] /= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	mask_array<_Tp>::operator%=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] %= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	mask_array<_Tp>::operator+=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] += __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	mask_array<_Tp>::operator-=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] -= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	mask_array<_Tp>::operator^=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] ^= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	mask_array<_Tp>::operator&=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] &= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	mask_array<_Tp>::operator\|=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] \|= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	mask_array<_Tp>::operator<<=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] <<= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	mask_array<_Tp>::operator>>=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] >>= __v[__i];
	}

	template <class _Tp>
	inline
	const mask_array<_Tp>&
	mask_array<_Tp>::operator=(const mask_array& __ma) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] = __ma.__vp_[__1d_[__i]];
	return *this;
	}

	template <class _Tp>
	inline
	void
	mask_array<_Tp>::operator=(const value_type& __x) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] = __x;
	}

	template <class _ValExpr>
	class __mask_expr
	{
	typedef typename remove_reference<_ValExpr>::type _RmExpr;
	public:
	typedef typename _RmExpr::value_type value_type;
	typedef value_type result_type;

	private:
	_ValExpr __expr_;
	valarray<size_t> __1d_;

	_LIBCPP_INLINE_VISIBILITY
	__mask_expr(const valarray<bool>& __vb, const _RmExpr& __e)
	: __expr_(__e),
	__1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true)))
	{
	size_t __j = 0;
	for (size_t __i = 0; __i < __vb.size(); ++__i)
	if (__vb[__i])
	__1d_[__j++] = __i;
	}

	public:
	_LIBCPP_INLINE_VISIBILITY
	result_type operator[](size_t __i) const
	{return __expr_[__1d_[__i]];}

	_LIBCPP_INLINE_VISIBILITY
	size_t size() const {return __1d_.size();}

	template <class> friend class valarray;
	};

	// indirect_array

	template <class _Tp>
	class _LIBCPP_TEMPLATE_VIS indirect_array
	{
	public:
	typedef _Tp value_type;

	private:
	value_type* __vp_;
	valarray<size_t> __1d_;

	public:
	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator*=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator/=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator%=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator+=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator-=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator^=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator&=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator\|=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator<<=(const _Expr& __v) const;

	template <class _Expr>
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	_LIBCPP_INLINE_VISIBILITY
	operator>>=(const _Expr& __v) const;

	_LIBCPP_INLINE_VISIBILITY
	const indirect_array& operator=(const indirect_array& __ia) const;

	_LIBCPP_INLINE_VISIBILITY
	void operator=(const value_type& __x) const;

	// indirect_array(const indirect_array&) = default;
	// indirect_array(indirect_array&&) = default;
	// indirect_array& operator=(const indirect_array&) = default;
	// indirect_array& operator=(indirect_array&&) = default;

	private:
	_LIBCPP_INLINE_VISIBILITY
	indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v)
	: __vp_(const_cast<value_type*>(__v.__begin_)),
	__1d_(__ia)
	{}

	#ifndef _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	indirect_array(valarray<size_t>&& __ia, const valarray<value_type>& __v)
	: __vp_(const_cast<value_type*>(__v.__begin_)),
	__1d_(move(__ia))
	{}

	#endif // _LIBCPP_CXX03_LANG

	template <class> friend class valarray;
	};

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	indirect_array<_Tp>::operator=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] = __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	indirect_array<_Tp>::operator*=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] *= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	indirect_array<_Tp>::operator/=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] /= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	indirect_array<_Tp>::operator%=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] %= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	indirect_array<_Tp>::operator+=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] += __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	indirect_array<_Tp>::operator-=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] -= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	indirect_array<_Tp>::operator^=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] ^= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	indirect_array<_Tp>::operator&=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] &= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	indirect_array<_Tp>::operator\|=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] \|= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	indirect_array<_Tp>::operator<<=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] <<= __v[__i];
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	void
	>::type
	indirect_array<_Tp>::operator>>=(const _Expr& __v) const
	{
	size_t __n = __1d_.size();
	for (size_t __i = 0; __i < __n; ++__i)
	__vp_[__1d_[__i]] >>= __v[__i];
	}

	template <class _Tp>
	inline
	const indirect_array<_Tp>&
	indirect_array<_Tp>::operator=(const indirect_array& __ia) const
	{
	typedef const size_t* _Ip;
	const value_type* __s = __ia.__vp_;
	for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ia.__1d_.__begin_;
	__i != __e; ++__i, ++__j)
	__vp_[__i] = __s[__j];
	return *this;
	}

	template <class _Tp>
	inline
	void
	indirect_array<_Tp>::operator=(const value_type& __x) const
	{
	typedef const size_t* _Ip;
	for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
	__vp_[*__i] = __x;
	}

	template <class _ValExpr>
	class __indirect_expr
	{
	typedef typename remove_reference<_ValExpr>::type _RmExpr;
	public:
	typedef typename _RmExpr::value_type value_type;
	typedef value_type result_type;

	private:
	_ValExpr __expr_;
	valarray<size_t> __1d_;

	_LIBCPP_INLINE_VISIBILITY
	__indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e)
	: __expr_(__e),
	__1d_(__ia)
	{}

	#ifndef _LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	__indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e)
	: __expr_(__e),
	__1d_(move(__ia))
	{}

	#endif // _LIBCPP_CXX03_LANG

	public:
	_LIBCPP_INLINE_VISIBILITY
	result_type operator[](size_t __i) const
	{return __expr_[__1d_[__i]];}

	_LIBCPP_INLINE_VISIBILITY
	size_t size() const {return __1d_.size();}

	template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
	};

	template<class _ValExpr>
	class __val_expr
	{
	typedef typename remove_reference<_ValExpr>::type _RmExpr;

	_ValExpr __expr_;
	public:
	typedef typename _RmExpr::value_type value_type;
	typedef typename _RmExpr::result_type result_type;

	_LIBCPP_INLINE_VISIBILITY
	explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {}

	_LIBCPP_INLINE_VISIBILITY
	result_type operator[](size_t __i) const
	{return __expr_[__i];}

	_LIBCPP_INLINE_VISIBILITY
	__val_expr<__slice_expr<_ValExpr> > operator[](slice __s) const
	{return __val_expr<__slice_expr<_ValExpr> >(__expr_, __s);}

	_LIBCPP_INLINE_VISIBILITY
	__val_expr<__indirect_expr<_ValExpr> > operator[](const gslice& __gs) const
	{return __val_expr<__indirect_expr<_ValExpr> >(__expr_, __gs.__1d_);}

	_LIBCPP_INLINE_VISIBILITY
	__val_expr<__mask_expr<_ValExpr> > operator[](const valarray<bool>& __vb) const
	{return __val_expr<__mask_expr<_ValExpr> >(__expr_, __vb);}

	_LIBCPP_INLINE_VISIBILITY
	__val_expr<__indirect_expr<_ValExpr> > operator[](const valarray<size_t>& __vs) const
	{return __val_expr<__indirect_expr<_ValExpr> >(__expr_, __vs);}

	_LIBCPP_INLINE_VISIBILITY
	__val_expr<_UnaryOp<__unary_plus<value_type>, _ValExpr> >
	operator+() const
	{
	typedef _UnaryOp<__unary_plus<value_type>, _ValExpr> _NewExpr;
	return __val_expr<_NewExpr>(_NewExpr(__unary_plus<value_type>(), __expr_));
	}

	_LIBCPP_INLINE_VISIBILITY
	__val_expr<_UnaryOp<negate<value_type>, _ValExpr> >
	operator-() const
	{
	typedef _UnaryOp<negate<value_type>, _ValExpr> _NewExpr;
	return __val_expr<_NewExpr>(_NewExpr(negate<value_type>(), __expr_));
	}

	_LIBCPP_INLINE_VISIBILITY
	__val_expr<_UnaryOp<__bit_not<value_type>, _ValExpr> >
	operator~() const
	{
	typedef _UnaryOp<__bit_not<value_type>, _ValExpr> _NewExpr;
	return __val_expr<_NewExpr>(_NewExpr(__bit_not<value_type>(), __expr_));
	}

	_LIBCPP_INLINE_VISIBILITY
	__val_expr<_UnaryOp<logical_not<value_type>, _ValExpr> >
	operator!() const
	{
	typedef _UnaryOp<logical_not<value_type>, _ValExpr> _NewExpr;
	return __val_expr<_NewExpr>(_NewExpr(logical_not<value_type>(), __expr_));
	}

	operator valarray<result_type>() const;

	_LIBCPP_INLINE_VISIBILITY
	size_t size() const {return __expr_.size();}

	_LIBCPP_INLINE_VISIBILITY
	result_type sum() const
	{
	size_t __n = __expr_.size();
	result_type __r = __n ? __expr_[0] : result_type();
	for (size_t __i = 1; __i < __n; ++__i)
	__r += __expr_[__i];
	return __r;
	}

	_LIBCPP_INLINE_VISIBILITY
	result_type min() const
	{
	size_t __n = size();
	result_type __r = __n ? (*this)[0] : result_type();
	for (size_t __i = 1; __i < __n; ++__i)
	{
	result_type __x = __expr_[__i];
	if (__x < __r)
	__r = __x;
	}
	return __r;
	}

	_LIBCPP_INLINE_VISIBILITY
	result_type max() const
	{
	size_t __n = size();
	result_type __r = __n ? (*this)[0] : result_type();
	for (size_t __i = 1; __i < __n; ++__i)
	{
	result_type __x = __expr_[__i];
	if (__r < __x)
	__r = __x;
	}
	return __r;
	}

	_LIBCPP_INLINE_VISIBILITY
	__val_expr<__shift_expr<_ValExpr> > shift (int __i) const
	{return __val_expr<__shift_expr<_ValExpr> >(__shift_expr<_ValExpr>(__i, __expr_));}

	_LIBCPP_INLINE_VISIBILITY
	__val_expr<__cshift_expr<_ValExpr> > cshift(int __i) const
	{return __val_expr<__cshift_expr<_ValExpr> >(__cshift_expr<_ValExpr>(__i, __expr_));}

	_LIBCPP_INLINE_VISIBILITY
	__val_expr<_UnaryOp<__apply_expr<value_type, value_type(*)(value_type)>, _ValExpr> >
	apply(value_type __f(value_type)) const
	{
	typedef __apply_expr<value_type, value_type(*)(value_type)> _Op;
	typedef _UnaryOp<_Op, _ValExpr> _NewExpr;
	return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_));
	}

	_LIBCPP_INLINE_VISIBILITY
	__val_expr<_UnaryOp<__apply_expr<value_type, value_type(*)(const value_type&)>, _ValExpr> >
	apply(value_type __f(const value_type&)) const
	{
	typedef __apply_expr<value_type, value_type(*)(const value_type&)> _Op;
	typedef _UnaryOp<_Op, _ValExpr> _NewExpr;
	return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_));
	}
	};

	template<class _ValExpr>
	__val_expr<_ValExpr>::operator valarray<__val_expr::result_type>() const
	{
	valarray<result_type> __r;
	size_t __n = __expr_.size();
	if (__n)
	{
	__r.__begin_ =
	__r.__end_ =
	- static_cast<result_type>(_VSTD::__allocate(__n sizeof(result_type)));
	+ static_cast<result_type*>(
	+ _VSTD::__libcpp_allocate(__n * sizeof(result_type), __alignof(result_type)));
	for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i)
	::new (__r.__end_) result_type(__expr_[__i]);
	}
	return __r;
	}

	// valarray

	template <class _Tp>
	inline
	valarray<_Tp>::valarray(size_t __n)
	: __begin_(0),
	__end_(0)
	{
	- resize(__n);
	+ if (__n)
	+ {
	+ __begin_ = __end_ = static_cast<value_type*>(
	+ _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
	+#ifndef _LIBCPP_NO_EXCEPTIONS
	+ try
	+ {
	+#endif // _LIBCPP_NO_EXCEPTIONS
	+ for (; __n; --__n, ++__end_)
	+ ::new (__end_) value_type();
	+#ifndef _LIBCPP_NO_EXCEPTIONS
	+ }
	+ catch (...)
	+ {
	+ __clear();
	+ throw;
	+ }
	+#endif // _LIBCPP_NO_EXCEPTIONS
	+ }
	}

	template <class _Tp>
	inline
	valarray<_Tp>::valarray(const value_type& __x, size_t __n)
	: __begin_(0),
	__end_(0)
	{
	resize(__n, __x);
	}

	template <class _Tp>
	valarray<_Tp>::valarray(const value_type* __p, size_t __n)
	: __begin_(0),
	__end_(0)
	{
	if (__n)
	{
	- __begin_ = __end_ = static_cast<value_type>(_VSTD::__allocate(__n sizeof(value_type)));
	+ __begin_ = __end_ = static_cast<value_type*>(
	+ _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (; __n; ++__end_, ++__p, --__n)
	::new (__end_) value_type(*__p);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	- resize(0);
	+ __clear();
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}
	}

	template <class _Tp>
	valarray<_Tp>::valarray(const valarray& __v)
	: __begin_(0),
	__end_(0)
	{
	if (__v.size())
	{
	- __begin_ = __end_ = static_cast<value_type>(_VSTD::__allocate(__v.size() sizeof(value_type)));
	+ __begin_ = __end_ = static_cast<value_type*>(
	+ _VSTD::__libcpp_allocate(__v.size() * sizeof(value_type), __alignof(value_type)));
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p)
	::new (__end_) value_type(*__p);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	- resize(0);
	+ __clear();
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp>
	inline
	valarray<_Tp>::valarray(valarray&& __v) _NOEXCEPT
	: __begin_(__v.__begin_),
	__end_(__v.__end_)
	{
	__v.__begin_ = __v.__end_ = nullptr;
	}

	template <class _Tp>
	valarray<_Tp>::valarray(initializer_list<value_type> __il)
	: __begin_(0),
	__end_(0)
	{
	size_t __n = __il.size();
	if (__n)
	{
	- __begin_ = __end_ = static_cast<value_type>(_VSTD::__allocate(__n sizeof(value_type)));
	+ __begin_ = __end_ = static_cast<value_type*>(
	+_VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (const value_type* __p = __il.begin(); __n; ++__end_, ++__p, --__n)
	::new (__end_) value_type(*__p);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	- resize(0);
	+ __clear();
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp>
	valarray<_Tp>::valarray(const slice_array<value_type>& __sa)
	: __begin_(0),
	__end_(0)
	{
	size_t __n = __sa.__size_;
	if (__n)
	{
	- __begin_ = __end_ = static_cast<value_type>(_VSTD::__allocate(__n sizeof(value_type)));
	+ __begin_ = __end_ = static_cast<value_type*>(
	+ _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (const value_type* __p = __sa.__vp_; __n; ++__end_, __p += __sa.__stride_, --__n)
	::new (__end_) value_type(*__p);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	- resize(0);
	+ __clear();
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}
	}

	template <class _Tp>
	valarray<_Tp>::valarray(const gslice_array<value_type>& __ga)
	: __begin_(0),
	__end_(0)
	{
	size_t __n = __ga.__1d_.size();
	if (__n)
	{
	- __begin_ = __end_ = static_cast<value_type>(_VSTD::__allocate(__n sizeof(value_type)));
	+ __begin_ = __end_ = static_cast<value_type*>(
	+ _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typedef const size_t* _Ip;
	const value_type* __s = __ga.__vp_;
	for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_;
	__i != __e; ++__i, ++__end_)
	::new (__end_) value_type(__s[*__i]);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	- resize(0);
	+ __clear();
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}
	}

	template <class _Tp>
	valarray<_Tp>::valarray(const mask_array<value_type>& __ma)
	: __begin_(0),
	__end_(0)
	{
	size_t __n = __ma.__1d_.size();
	if (__n)
	{
	- __begin_ = __end_ = static_cast<value_type>(_VSTD::__allocate(__n sizeof(value_type)));
	+ __begin_ = __end_ = static_cast<value_type*>(
	+ _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typedef const size_t* _Ip;
	const value_type* __s = __ma.__vp_;
	for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_;
	__i != __e; ++__i, ++__end_)
	::new (__end_) value_type(__s[*__i]);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	- resize(0);
	+ __clear();
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}
	}

	template <class _Tp>
	valarray<_Tp>::valarray(const indirect_array<value_type>& __ia)
	: __begin_(0),
	__end_(0)
	{
	size_t __n = __ia.__1d_.size();
	if (__n)
	{
	- __begin_ = __end_ = static_cast<value_type>(_VSTD::__allocate(__n sizeof(value_type)));
	+ __begin_ = __end_ = static_cast<value_type*>(
	+ _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	typedef const size_t* _Ip;
	const value_type* __s = __ia.__vp_;
	for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_;
	__i != __e; ++__i, ++__end_)
	::new (__end_) value_type(__s[*__i]);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	- resize(0);
	+ __clear();
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}
	}

	template <class _Tp>
	inline
	valarray<_Tp>::~valarray()
	{
	- resize(0);
	+ __clear();
	}

	template <class _Tp>
	valarray<_Tp>&
	-valarray<_Tp>::operator=(const valarray& __v)
	+valarray<_Tp>::__assign_range(const value_type* __f, const value_type* __l)
	{
	- if (this != &__v)
	+ size_t __n = __l - __f;
	+ if (size() != __n)
	{
	- if (size() != __v.size())
	- resize(__v.size());
	- _VSTD::copy(__v.__begin_, __v.__end_, __begin_);
	+ __clear();
	+ __begin_ = static_cast<value_type*>(
	+ _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
	+ __end_ = __begin_ + __n;
	+ _VSTD::uninitialized_copy(__f, __l, __begin_);
	+ } else {
	+ _VSTD::copy(__f, __l, __begin_);
	}
	return *this;
	}

	+template <class _Tp>
	+valarray<_Tp>&
	+valarray<_Tp>::operator=(const valarray& __v)
	+{
	+ if (this != &__v)
	+ return __assign_range(__v.__begin_, __v.__end_);
	+ return *this;
	+}
	+
	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT
	{
	- resize(0);
	+ __clear();
	__begin_ = __v.__begin_;
	__end_ = __v.__end_;
	__v.__begin_ = nullptr;
	__v.__end_ = nullptr;
	return *this;
	}

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator=(initializer_list<value_type> __il)
	{
	- if (size() != __il.size())
	- resize(__il.size());
	- _VSTD::copy(__il.begin(), __il.end(), __begin_);
	- return *this;
	+ return __assign_range(__il.begin(), __il.end());
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator=(const value_type& __x)
	{
	_VSTD::fill(__begin_, __end_, __x);
	return *this;
	}

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator=(const slice_array<value_type>& __sa)
	{
	value_type* __t = __begin_;
	const value_type* __s = __sa.__vp_;
	for (size_t __n = __sa.__size_; __n; --__n, __s += __sa.__stride_, ++__t)
	__t = __s;
	return *this;
	}

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator=(const gslice_array<value_type>& __ga)
	{
	typedef const size_t* _Ip;
	value_type* __t = __begin_;
	const value_type* __s = __ga.__vp_;
	for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_;
	__i != __e; ++__i, ++__t)
	__t = __s[__i];
	return *this;
	}

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator=(const mask_array<value_type>& __ma)
	{
	typedef const size_t* _Ip;
	value_type* __t = __begin_;
	const value_type* __s = __ma.__vp_;
	for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_;
	__i != __e; ++__i, ++__t)
	__t = __s[__i];
	return *this;
	}

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator=(const indirect_array<value_type>& __ia)
	{
	typedef const size_t* _Ip;
	value_type* __t = __begin_;
	const value_type* __s = __ia.__vp_;
	for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_;
	__i != __e; ++__i, ++__t)
	__t = __s[__i];
	return *this;
	}

	template <class _Tp>
	template <class _ValExpr>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator=(const __val_expr<_ValExpr>& __v)
	{
	size_t __n = __v.size();
	if (size() != __n)
	resize(__n);
	value_type* __t = __begin_;
	for (size_t __i = 0; __i != __n; ++__t, ++__i)
	*__t = result_type(__v[__i]);
	return *this;
	}

	template <class _Tp>
	inline
	__val_expr<__slice_expr<const valarray<_Tp>&> >
	valarray<_Tp>::operator[](slice __s) const
	{
	return __val_expr<__slice_expr<const valarray&> >(__slice_expr<const valarray&>(__s, *this));
	}

	template <class _Tp>
	inline
	slice_array<_Tp>
	valarray<_Tp>::operator[](slice __s)
	{
	return slice_array<value_type>(__s, *this);
	}

	template <class _Tp>
	inline
	__val_expr<__indirect_expr<const valarray<_Tp>&> >
	valarray<_Tp>::operator[](const gslice& __gs) const
	{
	return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__gs.__1d_, *this));
	}

	template <class _Tp>
	inline
	gslice_array<_Tp>
	valarray<_Tp>::operator[](const gslice& __gs)
	{
	return gslice_array<value_type>(__gs, *this);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp>
	inline
	__val_expr<__indirect_expr<const valarray<_Tp>&> >
	valarray<_Tp>::operator[](gslice&& __gs) const
	{
	return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(move(__gs.__1d_), *this));
	}

	template <class _Tp>
	inline
	gslice_array<_Tp>
	valarray<_Tp>::operator[](gslice&& __gs)
	{
	return gslice_array<value_type>(move(__gs), *this);
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp>
	inline
	__val_expr<__mask_expr<const valarray<_Tp>&> >
	valarray<_Tp>::operator[](const valarray<bool>& __vb) const
	{
	return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(__vb, *this));
	}

	template <class _Tp>
	inline
	mask_array<_Tp>
	valarray<_Tp>::operator[](const valarray<bool>& __vb)
	{
	return mask_array<value_type>(__vb, *this);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp>
	inline
	__val_expr<__mask_expr<const valarray<_Tp>&> >
	valarray<_Tp>::operator[](valarray<bool>&& __vb) const
	{
	return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(move(__vb), *this));
	}

	template <class _Tp>
	inline
	mask_array<_Tp>
	valarray<_Tp>::operator[](valarray<bool>&& __vb)
	{
	return mask_array<value_type>(move(__vb), *this);
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp>
	inline
	__val_expr<__indirect_expr<const valarray<_Tp>&> >
	valarray<_Tp>::operator[](const valarray<size_t>& __vs) const
	{
	return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__vs, *this));
	}

	template <class _Tp>
	inline
	indirect_array<_Tp>
	valarray<_Tp>::operator[](const valarray<size_t>& __vs)
	{
	return indirect_array<value_type>(__vs, *this);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp>
	inline
	__val_expr<__indirect_expr<const valarray<_Tp>&> >
	valarray<_Tp>::operator[](valarray<size_t>&& __vs) const
	{
	return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(move(__vs), *this));
	}

	template <class _Tp>
	inline
	indirect_array<_Tp>
	valarray<_Tp>::operator[](valarray<size_t>&& __vs)
	{
	return indirect_array<value_type>(move(__vs), *this);
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Tp>
	valarray<_Tp>
	valarray<_Tp>::operator+() const
	{
	valarray<value_type> __r;
	size_t __n = size();
	if (__n)
	{
	__r.__begin_ =
	__r.__end_ =
	- static_cast<value_type>(_VSTD::__allocate(__n sizeof(value_type)));
	+ static_cast<value_type*>(
	+ _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
	for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
	::new (__r.__end_) value_type(+*__p);
	}
	return __r;
	}

	template <class _Tp>
	valarray<_Tp>
	valarray<_Tp>::operator-() const
	{
	valarray<value_type> __r;
	size_t __n = size();
	if (__n)
	{
	__r.__begin_ =
	__r.__end_ =
	- static_cast<value_type>(_VSTD::__allocate(__n sizeof(value_type)));
	+ static_cast<value_type*>(
	+ _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
	for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
	::new (__r.__end_) value_type(-*__p);
	}
	return __r;
	}

	template <class _Tp>
	valarray<_Tp>
	valarray<_Tp>::operator~() const
	{
	valarray<value_type> __r;
	size_t __n = size();
	if (__n)
	{
	__r.__begin_ =
	__r.__end_ =
	- static_cast<value_type>(_VSTD::__allocate(__n sizeof(value_type)));
	+ static_cast<value_type*>(
	+ _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
	for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
	::new (__r.__end_) value_type(~*__p);
	}
	return __r;
	}

	template <class _Tp>
	valarray<bool>
	valarray<_Tp>::operator!() const
	{
	valarray<bool> __r;
	size_t __n = size();
	if (__n)
	{
	__r.__begin_ =
	__r.__end_ =
	- static_cast<bool>(_VSTD::__allocate(__n sizeof(bool)));
	+ static_cast<bool>(_VSTD::__libcpp_allocate(__n sizeof(bool), __alignof(bool)));
	for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
	::new (__r.__end_) bool(!*__p);
	}
	return __r;
	}

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator*=(const value_type& __x)
	{
	for (value_type* __p = __begin_; __p != __end_; ++__p)
	__p = __x;
	return *this;
	}

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator/=(const value_type& __x)
	{
	for (value_type* __p = __begin_; __p != __end_; ++__p)
	*__p /= __x;
	return *this;
	}

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator%=(const value_type& __x)
	{
	for (value_type* __p = __begin_; __p != __end_; ++__p)
	*__p %= __x;
	return *this;
	}

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator+=(const value_type& __x)
	{
	for (value_type* __p = __begin_; __p != __end_; ++__p)
	*__p += __x;
	return *this;
	}

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator-=(const value_type& __x)
	{
	for (value_type* __p = __begin_; __p != __end_; ++__p)
	*__p -= __x;
	return *this;
	}

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator^=(const value_type& __x)
	{
	for (value_type* __p = __begin_; __p != __end_; ++__p)
	*__p ^= __x;
	return *this;
	}

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator&=(const value_type& __x)
	{
	for (value_type* __p = __begin_; __p != __end_; ++__p)
	*__p &= __x;
	return *this;
	}

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator\|=(const value_type& __x)
	{
	for (value_type* __p = __begin_; __p != __end_; ++__p)
	*__p \|= __x;
	return *this;
	}

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator<<=(const value_type& __x)
	{
	for (value_type* __p = __begin_; __p != __end_; ++__p)
	*__p <<= __x;
	return *this;
	}

	template <class _Tp>
	inline
	valarray<_Tp>&
	valarray<_Tp>::operator>>=(const value_type& __x)
	{
	for (value_type* __p = __begin_; __p != __end_; ++__p)
	*__p >>= __x;
	return *this;
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray<_Tp>&
	>::type
	valarray<_Tp>::operator*=(const _Expr& __v)
	{
	size_t __i = 0;
	for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
	__t = __v[__i];
	return *this;
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray<_Tp>&
	>::type
	valarray<_Tp>::operator/=(const _Expr& __v)
	{
	size_t __i = 0;
	for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
	*__t /= __v[__i];
	return *this;
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray<_Tp>&
	>::type
	valarray<_Tp>::operator%=(const _Expr& __v)
	{
	size_t __i = 0;
	for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
	*__t %= __v[__i];
	return *this;
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray<_Tp>&
	>::type
	valarray<_Tp>::operator+=(const _Expr& __v)
	{
	size_t __i = 0;
	for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
	*__t += __v[__i];
	return *this;
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray<_Tp>&
	>::type
	valarray<_Tp>::operator-=(const _Expr& __v)
	{
	size_t __i = 0;
	for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
	*__t -= __v[__i];
	return *this;
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray<_Tp>&
	>::type
	valarray<_Tp>::operator^=(const _Expr& __v)
	{
	size_t __i = 0;
	for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
	*__t ^= __v[__i];
	return *this;
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray<_Tp>&
	>::type
	valarray<_Tp>::operator\|=(const _Expr& __v)
	{
	size_t __i = 0;
	for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
	*__t \|= __v[__i];
	return *this;
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray<_Tp>&
	>::type
	valarray<_Tp>::operator&=(const _Expr& __v)
	{
	size_t __i = 0;
	for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
	*__t &= __v[__i];
	return *this;
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray<_Tp>&
	>::type
	valarray<_Tp>::operator<<=(const _Expr& __v)
	{
	size_t __i = 0;
	for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
	*__t <<= __v[__i];
	return *this;
	}

	template <class _Tp>
	template <class _Expr>
	inline
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	valarray<_Tp>&
	>::type
	valarray<_Tp>::operator>>=(const _Expr& __v)
	{
	size_t __i = 0;
	for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
	*__t >>= __v[__i];
	return *this;
	}

	template <class _Tp>
	inline
	void
	valarray<_Tp>::swap(valarray& __v) _NOEXCEPT
	{
	_VSTD::swap(__begin_, __v.__begin_);
	_VSTD::swap(__end_, __v.__end_);
	}

	template <class _Tp>
	inline
	_Tp
	valarray<_Tp>::sum() const
	{
	if (__begin_ == __end_)
	return value_type();
	const value_type* __p = __begin_;
	_Tp __r = *__p;
	for (++__p; __p != __end_; ++__p)
	__r += *__p;
	return __r;
	}

	template <class _Tp>
	inline
	_Tp
	valarray<_Tp>::min() const
	{
	if (__begin_ == __end_)
	return value_type();
	return *_VSTD::min_element(__begin_, __end_);
	}

	template <class _Tp>
	inline
	_Tp
	valarray<_Tp>::max() const
	{
	if (__begin_ == __end_)
	return value_type();
	return *_VSTD::max_element(__begin_, __end_);
	}

	template <class _Tp>
	valarray<_Tp>
	valarray<_Tp>::shift(int __i) const
	{
	valarray<value_type> __r;
	size_t __n = size();
	if (__n)
	{
	__r.__begin_ =
	__r.__end_ =
	- static_cast<value_type>(_VSTD::__allocate(__n sizeof(value_type)));
	+ static_cast<value_type*>(
	+ _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
	const value_type* __sb;
	value_type* __tb;
	value_type* __te;
	if (__i >= 0)
	{
	__i = _VSTD::min(__i, static_cast<int>(__n));
	__sb = __begin_ + __i;
	__tb = __r.__begin_;
	__te = __r.__begin_ + (__n - __i);
	}
	else
	{
	__i = _VSTD::min(-__i, static_cast<int>(__n));
	__sb = __begin_;
	__tb = __r.__begin_ + __i;
	__te = __r.__begin_ + __n;
	}
	for (; __r.__end_ != __tb; ++__r.__end_)
	::new (__r.__end_) value_type();
	for (; __r.__end_ != __te; ++__r.__end_, ++__sb)
	::new (__r.__end_) value_type(*__sb);
	for (__te = __r.__begin_ + __n; __r.__end_ != __te; ++__r.__end_)
	::new (__r.__end_) value_type();
	}
	return __r;
	}

	template <class _Tp>
	valarray<_Tp>
	valarray<_Tp>::cshift(int __i) const
	{
	valarray<value_type> __r;
	size_t __n = size();
	if (__n)
	{
	__r.__begin_ =
	__r.__end_ =
	- static_cast<value_type>(_VSTD::__allocate(__n sizeof(value_type)));
	+ static_cast<value_type*>(
	+ _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
	__i %= static_cast<int>(__n);
	const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i;
	for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s)
	::new (__r.__end_) value_type(*__s);
	for (const value_type* __s = __begin_; __s != __m; ++__r.__end_, ++__s)
	::new (__r.__end_) value_type(*__s);
	}
	return __r;
	}

	template <class _Tp>
	valarray<_Tp>
	valarray<_Tp>::apply(value_type __f(value_type)) const
	{
	valarray<value_type> __r;
	size_t __n = size();
	if (__n)
	{
	__r.__begin_ =
	__r.__end_ =
	- static_cast<value_type>(_VSTD::__allocate(__n sizeof(value_type)));
	+ static_cast<value_type*>(
	+ _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
	for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
	::new (__r.__end_) value_type(__f(*__p));
	}
	return __r;
	}

	template <class _Tp>
	valarray<_Tp>
	valarray<_Tp>::apply(value_type __f(const value_type&)) const
	{
	valarray<value_type> __r;
	size_t __n = size();
	if (__n)
	{
	__r.__begin_ =
	__r.__end_ =
	- static_cast<value_type>(_VSTD::__allocate(__n sizeof(value_type)));
	+ static_cast<value_type*>(
	+ _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
	for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
	::new (__r.__end_) value_type(__f(*__p));
	}
	return __r;
	}

	template <class _Tp>
	void
	-valarray<_Tp>::resize(size_t __n, value_type __x)
	+valarray<_Tp>::__clear()
	{
	if (__begin_ != nullptr)
	{
	while (__end_ != __begin_)
	(--__end_)->~value_type();
	- _VSTD::__libcpp_deallocate(__begin_);
	+ _VSTD::__libcpp_deallocate(__begin_, __alignof(value_type));
	__begin_ = __end_ = nullptr;
	}
	+}
	+
	+template <class _Tp>
	+void
	+valarray<_Tp>::resize(size_t __n, value_type __x)
	+{
	+ __clear();
	if (__n)
	{
	- __begin_ = __end_ = static_cast<value_type>(_VSTD::__allocate(__n sizeof(value_type)));
	+ __begin_ = __end_ = static_cast<value_type*>(
	+ _VSTD::__libcpp_allocate(__n * sizeof(value_type), __alignof(value_type)));
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (; __n; --__n, ++__end_)
	::new (__end_) value_type(__x);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	- resize(0);
	+ __clear();
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}
	}

	template<class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT
	{
	__x.swap(__y);
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<multiplies<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator*(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<multiplies<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<multiplies<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator*(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<multiplies<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(multiplies<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<multiplies<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator*(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<multiplies<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(multiplies<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<divides<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator/(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<divides<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(divides<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<divides<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator/(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<divides<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(divides<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<divides<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator/(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<divides<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(divides<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<modulus<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator%(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<modulus<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<modulus<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator%(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<modulus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(modulus<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<modulus<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator%(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<modulus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(modulus<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<plus<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator+(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<plus<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(plus<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<plus<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator+(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<plus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(plus<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<plus<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator+(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<plus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(plus<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<minus<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator-(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<minus<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(minus<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<minus<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator-(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<minus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(minus<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<minus<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator-(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<minus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(minus<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<bit_xor<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator^(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<bit_xor<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator^(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<bit_xor<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(bit_xor<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator^(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<bit_xor<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(bit_xor<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<bit_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator&(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<bit_and<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<bit_and<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator&(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<bit_and<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(bit_and<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<bit_and<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator&(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<bit_and<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(bit_and<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<bit_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator\|(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<bit_or<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<bit_or<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator\|(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<bit_or<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(bit_or<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<bit_or<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator\|(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<bit_or<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(bit_or<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<__bit_shift_left<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator<<(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<__bit_shift_left<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator<<(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<__bit_shift_left<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator<<(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<__bit_shift_left<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<__bit_shift_right<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator>>(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<__bit_shift_right<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator>>(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<__bit_shift_right<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator>>(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<__bit_shift_right<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<logical_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator&&(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<logical_and<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<logical_and<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator&&(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<logical_and<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(logical_and<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<logical_and<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator&&(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<logical_and<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(logical_and<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<logical_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator\|\|(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<logical_or<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<logical_or<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator\|\|(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<logical_or<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(logical_or<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<logical_or<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator\|\|(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<logical_or<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(logical_or<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator==(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<equal_to<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<equal_to<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator==(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(equal_to<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<equal_to<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator==(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(equal_to<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<not_equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator!=(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<not_equal_to<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator!=(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<not_equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(not_equal_to<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator!=(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<not_equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(not_equal_to<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<less<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator<(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<less<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(less<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<less<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator<(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<less<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(less<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<less<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator<(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<less<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(less<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<greater<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator>(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<greater<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(greater<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<greater<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator>(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<greater<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(greater<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<greater<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator>(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<greater<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(greater<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<less_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator<=(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<less_equal<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<less_equal<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator<=(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<less_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(less_equal<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<less_equal<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator<=(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<less_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(less_equal<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<greater_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	operator>=(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<greater_equal<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	operator>=(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<greater_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(greater_equal<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	operator>=(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<greater_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(greater_equal<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> >
	>::type
	abs(const _Expr& __x)
	{
	typedef typename _Expr::value_type value_type;
	typedef _UnaryOp<__abs_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__abs_expr<value_type>(), __x));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> >
	>::type
	acos(const _Expr& __x)
	{
	typedef typename _Expr::value_type value_type;
	typedef _UnaryOp<__acos_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__acos_expr<value_type>(), __x));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> >
	>::type
	asin(const _Expr& __x)
	{
	typedef typename _Expr::value_type value_type;
	typedef _UnaryOp<__asin_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__asin_expr<value_type>(), __x));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> >
	>::type
	atan(const _Expr& __x)
	{
	typedef typename _Expr::value_type value_type;
	typedef _UnaryOp<__atan_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__atan_expr<value_type>(), __x));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	atan2(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<__atan2_expr<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	atan2(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<__atan2_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(__atan2_expr<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	atan2(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<__atan2_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__atan2_expr<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> >
	>::type
	cos(const _Expr& __x)
	{
	typedef typename _Expr::value_type value_type;
	typedef _UnaryOp<__cos_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__cos_expr<value_type>(), __x));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> >
	>::type
	cosh(const _Expr& __x)
	{
	typedef typename _Expr::value_type value_type;
	typedef _UnaryOp<__cosh_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__cosh_expr<value_type>(), __x));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> >
	>::type
	exp(const _Expr& __x)
	{
	typedef typename _Expr::value_type value_type;
	typedef _UnaryOp<__exp_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__exp_expr<value_type>(), __x));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> >
	>::type
	log(const _Expr& __x)
	{
	typedef typename _Expr::value_type value_type;
	typedef _UnaryOp<__log_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__log_expr<value_type>(), __x));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> >
	>::type
	log10(const _Expr& __x)
	{
	typedef typename _Expr::value_type value_type;
	typedef _UnaryOp<__log10_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__log10_expr<value_type>(), __x));
	}

	template<class _Expr1, class _Expr2>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
	__val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
	>::type
	pow(const _Expr1& __x, const _Expr2& __y)
	{
	typedef typename _Expr1::value_type value_type;
	typedef _BinaryOp<__pow_expr<value_type>, _Expr1, _Expr2> _Op;
	return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>,
	_Expr, __scalar_expr<typename _Expr::value_type> > >
	>::type
	pow(const _Expr& __x, const typename _Expr::value_type& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<__pow_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
	return __val_expr<_Op>(_Op(__pow_expr<value_type>(),
	__x, __scalar_expr<value_type>(__y, __x.size())));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>,
	__scalar_expr<typename _Expr::value_type>, _Expr> >
	>::type
	pow(const typename _Expr::value_type& __x, const _Expr& __y)
	{
	typedef typename _Expr::value_type value_type;
	typedef _BinaryOp<__pow_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__pow_expr<value_type>(),
	__scalar_expr<value_type>(__x, __y.size()), __y));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> >
	>::type
	sin(const _Expr& __x)
	{
	typedef typename _Expr::value_type value_type;
	typedef _UnaryOp<__sin_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__sin_expr<value_type>(), __x));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> >
	>::type
	sinh(const _Expr& __x)
	{
	typedef typename _Expr::value_type value_type;
	typedef _UnaryOp<__sinh_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__sinh_expr<value_type>(), __x));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> >
	>::type
	sqrt(const _Expr& __x)
	{
	typedef typename _Expr::value_type value_type;
	typedef _UnaryOp<__sqrt_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__sqrt_expr<value_type>(), __x));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> >
	>::type
	tan(const _Expr& __x)
	{
	typedef typename _Expr::value_type value_type;
	typedef _UnaryOp<__tan_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__tan_expr<value_type>(), __x));
	}

	template<class _Expr>
	inline _LIBCPP_INLINE_VISIBILITY
	typename enable_if
	<
	__is_val_expr<_Expr>::value,
	__val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> >
	>::type
	tanh(const _Expr& __x)
	{
	typedef typename _Expr::value_type value_type;
	typedef _UnaryOp<__tanh_expr<value_type>, _Expr> _Op;
	return __val_expr<_Op>(_Op(__tanh_expr<value_type>(), __x));
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp*
	begin(valarray<_Tp>& __v)
	{
	return __v.__begin_;
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	const _Tp*
	begin(const valarray<_Tp>& __v)
	{
	return __v.__begin_;
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp*
	end(valarray<_Tp>& __v)
	{
	return __v.__end_;
	}

	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	const _Tp*
	end(const valarray<_Tp>& __v)
	{
	return __v.__end_;
	}

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_VALARRAY
	Index: projects/clang700-import/contrib/libc++/include/variant
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/variant (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/variant (revision 337135)
	@@ -1,1594 +1,1594 @@
	// -- C++ --
	//===------------------------------ variant -------------------------------===//
	//
	// 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_VARIANT
	#define _LIBCPP_VARIANT

	/*
	variant synopsis

	namespace std {

	// 20.7.2, class template variant
	template <class... Types>
	class variant {
	public:

	// 20.7.2.1, constructors
	constexpr variant() noexcept(see below);
	variant(const variant&);
	variant(variant&&) noexcept(see below);

	template <class T> constexpr variant(T&&) noexcept(see below);

	template <class T, class... Args>
	constexpr explicit variant(in_place_type_t<T>, Args&&...);

	template <class T, class U, class... Args>
	constexpr explicit variant(
	in_place_type_t<T>, initializer_list<U>, Args&&...);

	template <size_t I, class... Args>
	constexpr explicit variant(in_place_index_t<I>, Args&&...);

	template <size_t I, class U, class... Args>
	constexpr explicit variant(
	in_place_index_t<I>, initializer_list<U>, Args&&...);

	// 20.7.2.2, destructor
	~variant();

	// 20.7.2.3, assignment
	variant& operator=(const variant&);
	variant& operator=(variant&&) noexcept(see below);

	template <class T> variant& operator=(T&&) noexcept(see below);

	// 20.7.2.4, modifiers
	template <class T, class... Args>
	T& emplace(Args&&...);

	template <class T, class U, class... Args>
	T& emplace(initializer_list<U>, Args&&...);

	template <size_t I, class... Args>
	variant_alternative_t<I, variant>& emplace(Args&&...);

	template <size_t I, class U, class... Args>
	variant_alternative_t<I, variant>& emplace(initializer_list<U>, Args&&...);

	// 20.7.2.5, value status
	constexpr bool valueless_by_exception() const noexcept;
	constexpr size_t index() const noexcept;

	// 20.7.2.6, swap
	void swap(variant&) noexcept(see below);
	};

	// 20.7.3, variant helper classes
	template <class T> struct variant_size; // undefined

	template <class T>
	inline constexpr size_t variant_size_v = variant_size<T>::value;

	template <class T> struct variant_size<const T>;
	template <class T> struct variant_size<volatile T>;
	template <class T> struct variant_size<const volatile T>;

	template <class... Types>
	struct variant_size<variant<Types...>>;

	template <size_t I, class T> struct variant_alternative; // undefined

	template <size_t I, class T>
	using variant_alternative_t = typename variant_alternative<I, T>::type;

	template <size_t I, class T> struct variant_alternative<I, const T>;
	template <size_t I, class T> struct variant_alternative<I, volatile T>;
	template <size_t I, class T> struct variant_alternative<I, const volatile T>;

	template <size_t I, class... Types>
	struct variant_alternative<I, variant<Types...>>;

	inline constexpr size_t variant_npos = -1;

	// 20.7.4, value access
	template <class T, class... Types>
	constexpr bool holds_alternative(const variant<Types...>&) noexcept;

	template <size_t I, class... Types>
	constexpr variant_alternative_t<I, variant<Types...>>&
	get(variant<Types...>&);

	template <size_t I, class... Types>
	constexpr variant_alternative_t<I, variant<Types...>>&&
	get(variant<Types...>&&);

	template <size_t I, class... Types>
	constexpr variant_alternative_t<I, variant<Types...>> const&
	get(const variant<Types...>&);

	template <size_t I, class... Types>
	constexpr variant_alternative_t<I, variant<Types...>> const&&
	get(const variant<Types...>&&);

	template <class T, class... Types>
	constexpr T& get(variant<Types...>&);

	template <class T, class... Types>
	constexpr T&& get(variant<Types...>&&);

	template <class T, class... Types>
	constexpr const T& get(const variant<Types...>&);

	template <class T, class... Types>
	constexpr const T&& get(const variant<Types...>&&);

	template <size_t I, class... Types>
	constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
	get_if(variant<Types...>*) noexcept;

	template <size_t I, class... Types>
	constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
	get_if(const variant<Types...>*) noexcept;

	template <class T, class... Types>
	constexpr add_pointer_t<T>
	get_if(variant<Types...>*) noexcept;

	template <class T, class... Types>
	constexpr add_pointer_t<const T>
	get_if(const variant<Types...>*) noexcept;

	// 20.7.5, relational operators
	template <class... Types>
	constexpr bool operator==(const variant<Types...>&, const variant<Types...>&);

	template <class... Types>
	constexpr bool operator!=(const variant<Types...>&, const variant<Types...>&);

	template <class... Types>
	constexpr bool operator<(const variant<Types...>&, const variant<Types...>&);

	template <class... Types>
	constexpr bool operator>(const variant<Types...>&, const variant<Types...>&);

	template <class... Types>
	constexpr bool operator<=(const variant<Types...>&, const variant<Types...>&);

	template <class... Types>
	constexpr bool operator>=(const variant<Types...>&, const variant<Types...>&);

	// 20.7.6, visitation
	template <class Visitor, class... Variants>
	constexpr see below visit(Visitor&&, Variants&&...);

	// 20.7.7, class monostate
	struct monostate;

	// 20.7.8, monostate relational operators
	constexpr bool operator<(monostate, monostate) noexcept;
	constexpr bool operator>(monostate, monostate) noexcept;
	constexpr bool operator<=(monostate, monostate) noexcept;
	constexpr bool operator>=(monostate, monostate) noexcept;
	constexpr bool operator==(monostate, monostate) noexcept;
	constexpr bool operator!=(monostate, monostate) noexcept;

	// 20.7.9, specialized algorithms
	template <class... Types>
	void swap(variant<Types...>&, variant<Types...>&) noexcept(see below);

	// 20.7.10, class bad_variant_access
	class bad_variant_access;

	// 20.7.11, hash support
	template <class T> struct hash;
	template <class... Types> struct hash<variant<Types...>>;
	template <> struct hash<monostate>;

	} // namespace std

	*/

	#include <__config>
	#include <__tuple>
	#include <array>
	#include <exception>
	#include <functional>
	#include <initializer_list>
	#include <new>
	#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 {
	public:
	virtual const char* what() const _NOEXCEPT;
	};

	} // namespace std

	_LIBCPP_BEGIN_NAMESPACE_STD

	#if _LIBCPP_STD_VER > 14

	_LIBCPP_NORETURN
	inline _LIBCPP_INLINE_VISIBILITY
	void __throw_bad_variant_access() {
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw bad_variant_access();
	#else
	_VSTD::abort();
	#endif
	}

	template <class... _Types>
	class _LIBCPP_TEMPLATE_VIS variant;

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS variant_size;

	template <class _Tp>
	_LIBCPP_INLINE_VAR constexpr size_t variant_size_v = variant_size<_Tp>::value;

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS variant_size<const _Tp> : variant_size<_Tp> {};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS variant_size<volatile _Tp> : variant_size<_Tp> {};

	template <class _Tp>
	struct _LIBCPP_TEMPLATE_VIS variant_size<const volatile _Tp>
	: variant_size<_Tp> {};

	template <class... _Types>
	struct _LIBCPP_TEMPLATE_VIS variant_size<variant<_Types...>>
	: integral_constant<size_t, sizeof...(_Types)> {};

	template <size_t _Ip, class _Tp>
	struct _LIBCPP_TEMPLATE_VIS variant_alternative;

	template <size_t _Ip, class _Tp>
	using variant_alternative_t = typename variant_alternative<_Ip, _Tp>::type;

	template <size_t _Ip, class _Tp>
	struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, const _Tp>
	: add_const<variant_alternative_t<_Ip, _Tp>> {};

	template <size_t _Ip, class _Tp>
	struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, volatile _Tp>
	: add_volatile<variant_alternative_t<_Ip, _Tp>> {};

	template <size_t _Ip, class _Tp>
	struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, const volatile _Tp>
	: add_cv<variant_alternative_t<_Ip, _Tp>> {};

	template <size_t _Ip, class... _Types>
	struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, variant<_Types...>> {
	static_assert(_Ip < sizeof...(_Types), "Index out of bounds in std::variant_alternative<>");
	using type = __type_pack_element<_Ip, _Types...>;
	};

	_LIBCPP_INLINE_VAR constexpr size_t variant_npos = static_cast<size_t>(-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 {

	template <class _Tp, class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr size_t __find_index() {
	constexpr bool __matches[] = {is_same_v<_Tp, _Types>...};
	size_t __result = __not_found;
	for (size_t __i = 0; __i < sizeof...(_Types); ++__i) {
	if (__matches[__i]) {
	if (__result != __not_found) {
	return __ambiguous;
	}
	__result = __i;
	}
	}
	return __result;
	}

	template <size_t _Index>
	struct __find_unambiguous_index_sfinae_impl
	: integral_constant<size_t, _Index> {};

	template <>
	struct __find_unambiguous_index_sfinae_impl<__not_found> {};

	template <>
	struct __find_unambiguous_index_sfinae_impl<__ambiguous> {};

	template <class _Tp, class... _Types>
	struct __find_unambiguous_index_sfinae
	: __find_unambiguous_index_sfinae_impl<__find_index<_Tp, _Types...>()> {};

	} // namespace __find_detail

	namespace __variant_detail {

	struct __valueless_t {};

	enum class _Trait { _TriviallyAvailable, _Available, _Unavailable };

	template <typename _Tp,
	template <typename> class _IsTriviallyAvailable,
	template <typename> class _IsAvailable>
	constexpr _Trait __trait =
	_IsTriviallyAvailable<_Tp>::value
	? _Trait::_TriviallyAvailable
	: _IsAvailable<_Tp>::value ? _Trait::_Available : _Trait::_Unavailable;

	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _Trait __common_trait(initializer_list<_Trait> __traits) {
	_Trait __result = _Trait::_TriviallyAvailable;
	for (_Trait __t : __traits) {
	if (static_cast<int>(__t) > static_cast<int>(__result)) {
	__result = __t;
	}
	}
	return __result;
	}

	template <typename... _Types>
	struct __traits {
	static constexpr _Trait __copy_constructible_trait =
	__common_trait({__trait<_Types,
	is_trivially_copy_constructible,
	is_copy_constructible>...});

	static constexpr _Trait __move_constructible_trait =
	__common_trait({__trait<_Types,
	is_trivially_move_constructible,
	is_move_constructible>...});

	static constexpr _Trait __copy_assignable_trait = __common_trait(
	{__copy_constructible_trait,
	__trait<_Types, is_trivially_copy_assignable, is_copy_assignable>...});

	static constexpr _Trait __move_assignable_trait = __common_trait(
	{__move_constructible_trait,
	__trait<_Types, is_trivially_move_assignable, is_move_assignable>...});

	static constexpr _Trait __destructible_trait = __common_trait(
	{__trait<_Types, is_trivially_destructible, is_destructible>...});
	};

	namespace __access {

	struct __union {
	template <class _Vp>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<0>) {
	return _VSTD::forward<_Vp>(__v).__head;
	}

	template <class _Vp, size_t _Ip>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<_Ip>) {
	return __get_alt(_VSTD::forward<_Vp>(__v).__tail, in_place_index<_Ip - 1>);
	}
	};

	struct __base {
	template <size_t _Ip, class _Vp>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr auto&& __get_alt(_Vp&& __v) {
	return __union::__get_alt(_VSTD::forward<_Vp>(__v).__data,
	in_place_index<_Ip>);
	}
	};

	struct __variant {
	template <size_t _Ip, class _Vp>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr auto&& __get_alt(_Vp&& __v) {
	return __base::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v).__impl);
	}
	};

	} // namespace __access

	namespace __visitation {

	struct __base {
	template <class _Visitor, class... _Vs>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr decltype(auto)
	__visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
	constexpr auto __fdiagonal =
	__make_fdiagonal<_Visitor&&,
	decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>();
	return __fdiagonal[__index](_VSTD::forward<_Visitor>(__visitor),
	_VSTD::forward<_Vs>(__vs).__as_base()...);
	}

	template <class _Visitor, class... _Vs>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor,
	_Vs&&... __vs) {
	constexpr auto __fmatrix =
	__make_fmatrix<_Visitor&&,
	decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>();
	return __at(__fmatrix, __vs.index()...)(
	_VSTD::forward<_Visitor>(__visitor),
	_VSTD::forward<_Vs>(__vs).__as_base()...);
	}

	private:
	template <class _Tp>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr const _Tp& __at(const _Tp& __elem) { return __elem; }

	template <class _Tp, size_t _Np, typename... _Indices>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr auto&& __at(const array<_Tp, _Np>& __elems,
	size_t __index, _Indices... __indices) {
	return __at(__elems[__index], __indices...);
	}

	template <class _Fp, class... _Fs>
	static constexpr void __std_visit_visitor_return_type_check() {
	static_assert(
	__all<is_same_v<_Fp, _Fs>...>::value,
	"`std::visit` requires the visitor to have a single return type.");
	}

	template <class... _Fs>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr auto __make_farray(_Fs&&... __fs) {
	- __std_visit_visitor_return_type_check<decay_t<_Fs>...>();
	- using __result = array<common_type_t<decay_t<_Fs>...>, sizeof...(_Fs)>;
	+ __std_visit_visitor_return_type_check<__uncvref_t<_Fs>...>();
	+ using __result = array<common_type_t<__uncvref_t<_Fs>...>, sizeof...(_Fs)>;
	return __result{{_VSTD::forward<_Fs>(__fs)...}};
	}

	template <std::size_t... _Is>
	struct __dispatcher {
	template <class _Fp, class... _Vs>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr decltype(auto) __dispatch(_Fp __f, _Vs... __vs) {
	return __invoke_constexpr(
	static_cast<_Fp>(__f),
	__access::__base::__get_alt<_Is>(static_cast<_Vs>(__vs))...);
	}
	};

	template <class _Fp, class... _Vs, size_t... _Is>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr auto __make_dispatch(index_sequence<_Is...>) {
	return __dispatcher<_Is...>::template __dispatch<_Fp, _Vs...>;
	}

	template <size_t _Ip, class _Fp, class... _Vs>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr auto __make_fdiagonal_impl() {
	return __make_dispatch<_Fp, _Vs...>(
	index_sequence<(__identity<_Vs>{}, _Ip)...>{});
	}

	template <class _Fp, class... _Vs, size_t... _Is>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr auto __make_fdiagonal_impl(index_sequence<_Is...>) {
	return __base::__make_farray(__make_fdiagonal_impl<_Is, _Fp, _Vs...>()...);
	}

	template <class _Fp, class _Vp, class... _Vs>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr auto __make_fdiagonal() {
	- constexpr size_t _Np = decay_t<_Vp>::__size();
	- static_assert(__all<(_Np == decay_t<_Vs>::__size())...>::value);
	+ constexpr size_t _Np = __uncvref_t<_Vp>::__size();
	+ static_assert(__all<(_Np == __uncvref_t<_Vs>::__size())...>::value);
	return __make_fdiagonal_impl<_Fp, _Vp, _Vs...>(make_index_sequence<_Np>{});
	}

	template <class _Fp, class... _Vs, size_t... _Is>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr auto __make_fmatrix_impl(index_sequence<_Is...> __is) {
	return __make_dispatch<_Fp, _Vs...>(__is);
	}

	template <class _Fp, class... _Vs, size_t... _Is, size_t... _Js, class... _Ls>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr auto __make_fmatrix_impl(index_sequence<_Is...>,
	index_sequence<_Js...>,
	_Ls... __ls) {
	return __base::__make_farray(__make_fmatrix_impl<_Fp, _Vs...>(
	index_sequence<_Is..., _Js>{}, __ls...)...);
	}

	template <class _Fp, class... _Vs>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr auto __make_fmatrix() {
	return __make_fmatrix_impl<_Fp, _Vs...>(
	- index_sequence<>{}, make_index_sequence<decay_t<_Vs>::__size()>{}...);
	+ index_sequence<>{}, make_index_sequence<__uncvref_t<_Vs>::__size()>{}...);
	}
	};

	struct __variant {
	template <class _Visitor, class... _Vs>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr decltype(auto)
	__visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
	return __base::__visit_alt_at(__index,
	_VSTD::forward<_Visitor>(__visitor),
	_VSTD::forward<_Vs>(__vs).__impl...);
	}

	template <class _Visitor, class... _Vs>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor,
	_Vs&&... __vs) {
	return __base::__visit_alt(_VSTD::forward<_Visitor>(__visitor),
	_VSTD::forward<_Vs>(__vs).__impl...);
	}

	template <class _Visitor, class... _Vs>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr decltype(auto)
	__visit_value_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
	return __visit_alt_at(
	__index,
	__make_value_visitor(_VSTD::forward<_Visitor>(__visitor)),
	_VSTD::forward<_Vs>(__vs)...);
	}

	template <class _Visitor, class... _Vs>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr decltype(auto) __visit_value(_Visitor&& __visitor,
	_Vs&&... __vs) {
	return __visit_alt(
	__make_value_visitor(_VSTD::forward<_Visitor>(__visitor)),
	_VSTD::forward<_Vs>(__vs)...);
	}

	private:
	template <class _Visitor, class... _Values>
	static constexpr void __std_visit_exhaustive_visitor_check() {
	static_assert(is_invocable_v<_Visitor, _Values...>,
	"`std::visit` requires the visitor to be exhaustive.");
	}

	template <class _Visitor>
	struct __value_visitor {
	template <class... _Alts>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr decltype(auto) operator()(_Alts&&... __alts) const {
	__std_visit_exhaustive_visitor_check<
	_Visitor,
	decltype((_VSTD::forward<_Alts>(__alts).__value))...>();
	return __invoke_constexpr(_VSTD::forward<_Visitor>(__visitor),
	_VSTD::forward<_Alts>(__alts).__value...);
	}
	_Visitor&& __visitor;
	};

	template <class _Visitor>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr auto __make_value_visitor(_Visitor&& __visitor) {
	return __value_visitor<_Visitor>{_VSTD::forward<_Visitor>(__visitor)};
	}
	};

	} // namespace __visitation

	template <size_t _Index, class _Tp>
	struct _LIBCPP_TEMPLATE_VIS __alt {
	using __value_type = _Tp;

	template <class... _Args>
	inline _LIBCPP_INLINE_VISIBILITY
	explicit constexpr __alt(in_place_t, _Args&&... __args)
	: __value(_VSTD::forward<_Args>(__args)...) {}

	__value_type __value;
	};

	template <_Trait _DestructibleTrait, size_t _Index, class... _Types>
	union _LIBCPP_TEMPLATE_VIS __union;

	template <_Trait _DestructibleTrait, size_t _Index>
	union _LIBCPP_TEMPLATE_VIS __union<_DestructibleTrait, _Index> {};

	#define _LIBCPP_VARIANT_UNION(destructible_trait, destructor) \
	template <size_t _Index, class _Tp, class... _Types> \
	union _LIBCPP_TEMPLATE_VIS __union<destructible_trait, \
	_Index, \
	_Tp, \
	_Types...> { \
	public: \
	inline _LIBCPP_INLINE_VISIBILITY \
	explicit constexpr __union(__valueless_t) noexcept : __dummy{} {} \
	\
	template <class... _Args> \
	inline _LIBCPP_INLINE_VISIBILITY \
	explicit constexpr __union(in_place_index_t<0>, _Args&&... __args) \
	: __head(in_place, _VSTD::forward<_Args>(__args)...) {} \
	\
	template <size_t _Ip, class... _Args> \
	inline _LIBCPP_INLINE_VISIBILITY \
	explicit constexpr __union(in_place_index_t<_Ip>, _Args&&... __args) \
	: __tail(in_place_index<_Ip - 1>, _VSTD::forward<_Args>(__args)...) {} \
	\
	__union(const __union&) = default; \
	__union(__union&&) = default; \
	\
	destructor \
	\
	__union& operator=(const __union&) = default; \
	__union& operator=(__union&&) = default; \
	\
	private: \
	char __dummy; \
	__alt<_Index, _Tp> __head; \
	__union<destructible_trait, _Index + 1, _Types...> __tail; \
	\
	friend struct __access::__union; \
	}

	_LIBCPP_VARIANT_UNION(_Trait::_TriviallyAvailable, ~__union() = default;);
	_LIBCPP_VARIANT_UNION(_Trait::_Available, ~__union() {});
	_LIBCPP_VARIANT_UNION(_Trait::_Unavailable, ~__union() = delete;);

	#undef _LIBCPP_VARIANT_UNION

	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<__index_t>) {}

	template <size_t _Ip, class... _Args>
	inline _LIBCPP_INLINE_VISIBILITY
	explicit constexpr __base(in_place_index_t<_Ip>, _Args&&... __args)
	:
	__data(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...),
	__index(_Ip) {}

	inline _LIBCPP_INLINE_VISIBILITY
	constexpr bool valueless_by_exception() const noexcept {
	return index() == variant_npos;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	constexpr size_t index() const noexcept {
	return __index == __variant_npos<__index_t> ? variant_npos : __index;
	}

	protected:
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr auto&& __as_base() & { return *this; }

	inline _LIBCPP_INLINE_VISIBILITY
	constexpr auto&& __as_base() && { return _VSTD::move(*this); }

	inline _LIBCPP_INLINE_VISIBILITY
	constexpr auto&& __as_base() const & { return *this; }

	inline _LIBCPP_INLINE_VISIBILITY
	constexpr auto&& __as_base() const && { return _VSTD::move(*this); }

	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr size_t __size() { return sizeof...(_Types); }

	__union<_DestructibleTrait, 0, _Types...> __data;
	__index_t __index;

	friend struct __access::__base;
	friend struct __visitation::__base;
	};

	template <class _Traits, _Trait = _Traits::__destructible_trait>
	class _LIBCPP_TEMPLATE_VIS __destructor;

	#define _LIBCPP_VARIANT_DESTRUCTOR(destructible_trait, destructor, destroy) \
	template <class... _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; \
	using __base_type::operator=; \
	\
	__destructor(const __destructor&) = default; \
	__destructor(__destructor&&) = default; \
	destructor \
	__destructor& operator=(const __destructor&) = default; \
	__destructor& operator=(__destructor&&) = default; \
	\
	protected: \
	inline _LIBCPP_INLINE_VISIBILITY \
	destroy \
	}

	_LIBCPP_VARIANT_DESTRUCTOR(
	_Trait::_TriviallyAvailable,
	~__destructor() = default;,
	void __destroy() noexcept { this->__index = __variant_npos<__index_t>; });

	_LIBCPP_VARIANT_DESTRUCTOR(
	_Trait::_Available,
	~__destructor() { __destroy(); },
	void __destroy() noexcept {
	if (!this->valueless_by_exception()) {
	__visitation::__base::__visit_alt(
	[](auto& __alt) noexcept {
	- using __alt_type = decay_t<decltype(__alt)>;
	+ using __alt_type = __uncvref_t<decltype(__alt)>;
	__alt.~__alt_type();
	},
	*this);
	}
	this->__index = __variant_npos<__index_t>;
	});

	_LIBCPP_VARIANT_DESTRUCTOR(
	_Trait::_Unavailable,
	~__destructor() = delete;,
	void __destroy() noexcept = delete;);

	#undef _LIBCPP_VARIANT_DESTRUCTOR

	template <class _Traits>
	class _LIBCPP_TEMPLATE_VIS __constructor : public __destructor<_Traits> {
	using __base_type = __destructor<_Traits>;

	public:
	using __base_type::__base_type;
	using __base_type::operator=;

	protected:
	template <size_t _Ip, class _Tp, class... _Args>
	inline _LIBCPP_INLINE_VISIBILITY
	static _Tp& __construct_alt(__alt<_Ip, _Tp>& __a, _Args&&... __args) {
	::new ((void*)_VSTD::addressof(__a))
	__alt<_Ip, _Tp>(in_place, _VSTD::forward<_Args>(__args)...);
	return __a.__value;
	}

	template <class _Rhs>
	inline _LIBCPP_INLINE_VISIBILITY
	static void __generic_construct(__constructor& __lhs, _Rhs&& __rhs) {
	__lhs.__destroy();
	if (!__rhs.valueless_by_exception()) {
	__visitation::__base::__visit_alt_at(
	__rhs.index(),
	[](auto& __lhs_alt, auto&& __rhs_alt) {
	__construct_alt(
	__lhs_alt,
	_VSTD::forward<decltype(__rhs_alt)>(__rhs_alt).__value);
	},
	__lhs, _VSTD::forward<_Rhs>(__rhs));
	__lhs.__index = __rhs.index();
	}
	}
	};

	template <class _Traits, _Trait = _Traits::__move_constructible_trait>
	class _LIBCPP_TEMPLATE_VIS __move_constructor;

	#define _LIBCPP_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, \
	move_constructor) \
	template <class... _Types> \
	class _LIBCPP_TEMPLATE_VIS __move_constructor<__traits<_Types...>, \
	move_constructible_trait> \
	: public __constructor<__traits<_Types...>> { \
	using __base_type = __constructor<__traits<_Types...>>; \
	\
	public: \
	using __base_type::__base_type; \
	using __base_type::operator=; \
	\
	__move_constructor(const __move_constructor&) = default; \
	move_constructor \
	~__move_constructor() = default; \
	__move_constructor& operator=(const __move_constructor&) = default; \
	__move_constructor& operator=(__move_constructor&&) = default; \
	}

	_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
	_Trait::_TriviallyAvailable,
	__move_constructor(__move_constructor&& __that) = default;);

	_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
	_Trait::_Available,
	__move_constructor(__move_constructor&& __that) noexcept(
	__all<is_nothrow_move_constructible_v<_Types>...>::value)
	: __move_constructor(__valueless_t{}) {
	this->__generic_construct(*this, _VSTD::move(__that));
	});

	_LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
	_Trait::_Unavailable,
	__move_constructor(__move_constructor&&) = delete;);

	#undef _LIBCPP_VARIANT_MOVE_CONSTRUCTOR

	template <class _Traits, _Trait = _Traits::__copy_constructible_trait>
	class _LIBCPP_TEMPLATE_VIS __copy_constructor;

	#define _LIBCPP_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, \
	copy_constructor) \
	template <class... _Types> \
	class _LIBCPP_TEMPLATE_VIS __copy_constructor<__traits<_Types...>, \
	copy_constructible_trait> \
	: public __move_constructor<__traits<_Types...>> { \
	using __base_type = __move_constructor<__traits<_Types...>>; \
	\
	public: \
	using __base_type::__base_type; \
	using __base_type::operator=; \
	\
	copy_constructor \
	__copy_constructor(__copy_constructor&&) = default; \
	~__copy_constructor() = default; \
	__copy_constructor& operator=(const __copy_constructor&) = default; \
	__copy_constructor& operator=(__copy_constructor&&) = default; \
	}

	_LIBCPP_VARIANT_COPY_CONSTRUCTOR(
	_Trait::_TriviallyAvailable,
	__copy_constructor(const __copy_constructor& __that) = default;);

	_LIBCPP_VARIANT_COPY_CONSTRUCTOR(
	_Trait::_Available,
	__copy_constructor(const __copy_constructor& __that)
	: __copy_constructor(__valueless_t{}) {
	this->__generic_construct(*this, __that);
	});

	_LIBCPP_VARIANT_COPY_CONSTRUCTOR(
	_Trait::_Unavailable,
	__copy_constructor(const __copy_constructor&) = delete;);

	#undef _LIBCPP_VARIANT_COPY_CONSTRUCTOR

	template <class _Traits>
	class _LIBCPP_TEMPLATE_VIS __assignment : public __copy_constructor<_Traits> {
	using __base_type = __copy_constructor<_Traits>;

	public:
	using __base_type::__base_type;
	using __base_type::operator=;

	template <size_t _Ip, class... _Args>
	inline _LIBCPP_INLINE_VISIBILITY
	auto& __emplace(_Args&&... __args) {
	this->__destroy();
	auto& __res = this->__construct_alt(__access::__base::__get_alt<_Ip>(*this),
	_VSTD::forward<_Args>(__args)...);
	this->__index = _Ip;
	return __res;
	}

	protected:
	template <size_t _Ip, class _Tp, class _Arg>
	inline _LIBCPP_INLINE_VISIBILITY
	void __assign_alt(__alt<_Ip, _Tp>& __a, _Arg&& __arg) {
	if (this->index() == _Ip) {
	__a.__value = _VSTD::forward<_Arg>(__arg);
	} else {
	struct {
	void operator()(true_type) const {
	__this->__emplace<_Ip>(_VSTD::forward<_Arg>(__arg));
	}
	void operator()(false_type) const {
	__this->__emplace<_Ip>(_Tp(_VSTD::forward<_Arg>(__arg)));
	}
	__assignment* __this;
	_Arg&& __arg;
	} __impl{this, _VSTD::forward<_Arg>(__arg)};
	__impl(bool_constant<is_nothrow_constructible_v<_Tp, _Arg> \|\|
	!is_nothrow_move_constructible_v<_Tp>>{});
	}
	}

	template <class _That>
	inline _LIBCPP_INLINE_VISIBILITY
	void __generic_assign(_That&& __that) {
	if (this->valueless_by_exception() && __that.valueless_by_exception()) {
	// do nothing.
	} else if (__that.valueless_by_exception()) {
	this->__destroy();
	} else {
	__visitation::__base::__visit_alt_at(
	__that.index(),
	[this](auto& __this_alt, auto&& __that_alt) {
	this->__assign_alt(
	__this_alt,
	_VSTD::forward<decltype(__that_alt)>(__that_alt).__value);
	},
	*this, _VSTD::forward<_That>(__that));
	}
	}
	};

	template <class _Traits, _Trait = _Traits::__move_assignable_trait>
	class _LIBCPP_TEMPLATE_VIS __move_assignment;

	#define _LIBCPP_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, \
	move_assignment) \
	template <class... _Types> \
	class _LIBCPP_TEMPLATE_VIS __move_assignment<__traits<_Types...>, \
	move_assignable_trait> \
	: public __assignment<__traits<_Types...>> { \
	using __base_type = __assignment<__traits<_Types...>>; \
	\
	public: \
	using __base_type::__base_type; \
	using __base_type::operator=; \
	\
	__move_assignment(const __move_assignment&) = default; \
	__move_assignment(__move_assignment&&) = default; \
	~__move_assignment() = default; \
	__move_assignment& operator=(const __move_assignment&) = default; \
	move_assignment \
	}

	_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
	_Trait::_TriviallyAvailable,
	__move_assignment& operator=(__move_assignment&& __that) = default;);

	_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
	_Trait::_Available,
	__move_assignment& operator=(__move_assignment&& __that) noexcept(
	__all<(is_nothrow_move_constructible_v<_Types> &&
	is_nothrow_move_assignable_v<_Types>)...>::value) {
	this->__generic_assign(_VSTD::move(__that));
	return *this;
	});

	_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
	_Trait::_Unavailable,
	__move_assignment& operator=(__move_assignment&&) = delete;);

	#undef _LIBCPP_VARIANT_MOVE_ASSIGNMENT

	template <class _Traits, _Trait = _Traits::__copy_assignable_trait>
	class _LIBCPP_TEMPLATE_VIS __copy_assignment;

	#define _LIBCPP_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, \
	copy_assignment) \
	template <class... _Types> \
	class _LIBCPP_TEMPLATE_VIS __copy_assignment<__traits<_Types...>, \
	copy_assignable_trait> \
	: public __move_assignment<__traits<_Types...>> { \
	using __base_type = __move_assignment<__traits<_Types...>>; \
	\
	public: \
	using __base_type::__base_type; \
	using __base_type::operator=; \
	\
	__copy_assignment(const __copy_assignment&) = default; \
	__copy_assignment(__copy_assignment&&) = default; \
	~__copy_assignment() = default; \
	copy_assignment \
	__copy_assignment& operator=(__copy_assignment&&) = default; \
	}

	_LIBCPP_VARIANT_COPY_ASSIGNMENT(
	_Trait::_TriviallyAvailable,
	__copy_assignment& operator=(const __copy_assignment& __that) = default;);

	_LIBCPP_VARIANT_COPY_ASSIGNMENT(
	_Trait::_Available,
	__copy_assignment& operator=(const __copy_assignment& __that) {
	this->__generic_assign(__that);
	return *this;
	});

	_LIBCPP_VARIANT_COPY_ASSIGNMENT(
	_Trait::_Unavailable,
	__copy_assignment& operator=(const __copy_assignment&) = delete;);

	#undef _LIBCPP_VARIANT_COPY_ASSIGNMENT

	template <class... _Types>
	class _LIBCPP_TEMPLATE_VIS __impl
	: public __copy_assignment<__traits<_Types...>> {
	using __base_type = __copy_assignment<__traits<_Types...>>;

	public:
	using __base_type::__base_type;
	using __base_type::operator=;

	template <size_t _Ip, class _Arg>
	inline _LIBCPP_INLINE_VISIBILITY
	void __assign(_Arg&& __arg) {
	this->__assign_alt(__access::__base::__get_alt<_Ip>(*this),
	_VSTD::forward<_Arg>(__arg));
	}

	inline _LIBCPP_INLINE_VISIBILITY
	void __swap(__impl& __that) {
	if (this->valueless_by_exception() && __that.valueless_by_exception()) {
	// do nothing.
	} else if (this->index() == __that.index()) {
	__visitation::__base::__visit_alt_at(
	this->index(),
	[](auto& __this_alt, auto& __that_alt) {
	using _VSTD::swap;
	swap(__this_alt.__value, __that_alt.__value);
	},
	*this,
	__that);
	} else {
	__impl* __lhs = this;
	__impl* __rhs = _VSTD::addressof(__that);
	if (__lhs->__move_nothrow() && !__rhs->__move_nothrow()) {
	_VSTD::swap(__lhs, __rhs);
	}
	__impl __tmp(_VSTD::move(*__rhs));
	#ifndef _LIBCPP_NO_EXCEPTIONS
	// EXTENSION: When the move construction of `__lhs` into `__rhs` throws
	// and `__tmp` is nothrow move constructible then we move `__tmp` back
	// into `__rhs` and provide the strong exception safety guarentee.
	try {
	this->__generic_construct(__rhs, _VSTD::move(__lhs));
	} catch (...) {
	if (__tmp.__move_nothrow()) {
	this->__generic_construct(*__rhs, _VSTD::move(__tmp));
	}
	throw;
	}
	#else
	this->__generic_construct(__rhs, _VSTD::move(__lhs));
	#endif
	this->__generic_construct(*__lhs, _VSTD::move(__tmp));
	}
	}

	private:
	inline _LIBCPP_INLINE_VISIBILITY
	bool __move_nothrow() const {
	constexpr bool __results[] = {is_nothrow_move_constructible_v<_Types>...};
	return this->valueless_by_exception() \|\| __results[this->index()];
	}
	};

	template <class... _Types>
	struct __overload;

	template <>
	struct __overload<> { void operator()() const; };

	template <class _Tp, class... _Types>
	struct __overload<_Tp, _Types...> : __overload<_Types...> {
	using __overload<_Types...>::operator();
	__identity<_Tp> operator()(_Tp) const;
	};

	template <class _Tp, class... _Types>
	using __best_match_t = typename result_of_t<__overload<_Types...>(_Tp&&)>::type;

	} // __variant_detail

	template <class... _Types>
	class _LIBCPP_TEMPLATE_VIS variant
	: private __sfinae_ctor_base<
	__all<is_copy_constructible_v<_Types>...>::value,
	__all<is_move_constructible_v<_Types>...>::value>,
	private __sfinae_assign_base<
	__all<(is_copy_constructible_v<_Types> &&
	is_copy_assignable_v<_Types>)...>::value,
	__all<(is_move_constructible_v<_Types> &&
	is_move_assignable_v<_Types>)...>::value> {
	static_assert(0 < sizeof...(_Types),
	"variant must consist of at least one alternative.");

	static_assert(__all<!is_array_v<_Types>...>::value,
	"variant can not have an array type as an alternative.");

	static_assert(__all<!is_reference_v<_Types>...>::value,
	"variant can not have a reference type as an alternative.");

	static_assert(__all<!is_void_v<_Types>...>::value,
	"variant can not have a void type as an alternative.");

	using __first_type = variant_alternative_t<0, variant>;

	public:
	template <bool _Dummy = true,
	enable_if_t<__dependent_type<is_default_constructible<__first_type>,
	_Dummy>::value,
	int> = 0>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr variant() noexcept(is_nothrow_default_constructible_v<__first_type>)
	: __impl(in_place_index<0>) {}

	variant(const variant&) = default;
	variant(variant&&) = default;

	template <
	class _Arg,
	- enable_if_t<!is_same_v<decay_t<_Arg>, variant>, int> = 0,
	- enable_if_t<!__is_inplace_type<decay_t<_Arg>>::value, int> = 0,
	- enable_if_t<!__is_inplace_index<decay_t<_Arg>>::value, int> = 0,
	+ enable_if_t<!is_same_v<__uncvref_t<_Arg>, variant>, int> = 0,
	+ enable_if_t<!__is_inplace_type<__uncvref_t<_Arg>>::value, int> = 0,
	+ enable_if_t<!__is_inplace_index<__uncvref_t<_Arg>>::value, int> = 0,
	class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>,
	size_t _Ip =
	__find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
	enable_if_t<is_constructible_v<_Tp, _Arg>, int> = 0>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr variant(_Arg&& __arg) noexcept(
	is_nothrow_constructible_v<_Tp, _Arg>)
	: __impl(in_place_index<_Ip>, _VSTD::forward<_Arg>(__arg)) {}

	template <size_t _Ip, class... _Args,
	class = enable_if_t<(_Ip < sizeof...(_Types)), int>,
	class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
	enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
	inline _LIBCPP_INLINE_VISIBILITY
	explicit constexpr variant(
	in_place_index_t<_Ip>,
	_Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
	: __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {}

	template <
	size_t _Ip,
	class _Up,
	class... _Args,
	enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
	class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
	enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
	int> = 0>
	inline _LIBCPP_INLINE_VISIBILITY
	explicit constexpr variant(
	in_place_index_t<_Ip>,
	initializer_list<_Up> __il,
	_Args&&... __args) noexcept(
	is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>)
	: __impl(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {}

	template <
	class _Tp,
	class... _Args,
	size_t _Ip =
	__find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
	enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
	inline _LIBCPP_INLINE_VISIBILITY
	explicit constexpr variant(in_place_type_t<_Tp>, _Args&&... __args) noexcept(
	is_nothrow_constructible_v<_Tp, _Args...>)
	: __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {}

	template <
	class _Tp,
	class _Up,
	class... _Args,
	size_t _Ip =
	__find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
	enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
	int> = 0>
	inline _LIBCPP_INLINE_VISIBILITY
	explicit constexpr variant(
	in_place_type_t<_Tp>,
	initializer_list<_Up> __il,
	_Args&&... __args) noexcept(
	is_nothrow_constructible_v<_Tp, initializer_list< _Up>&, _Args...>)
	: __impl(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {}

	~variant() = default;

	variant& operator=(const variant&) = default;
	variant& operator=(variant&&) = default;

	template <
	class _Arg,
	- enable_if_t<!is_same_v<decay_t<_Arg>, variant>, int> = 0,
	+ enable_if_t<!is_same_v<__uncvref_t<_Arg>, variant>, int> = 0,
	class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>,
	size_t _Ip =
	__find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
	enable_if_t<is_assignable_v<_Tp&, _Arg> && is_constructible_v<_Tp, _Arg>,
	int> = 0>
	inline _LIBCPP_INLINE_VISIBILITY
	variant& operator=(_Arg&& __arg) noexcept(
	is_nothrow_assignable_v<_Tp&, _Arg> &&
	is_nothrow_constructible_v<_Tp, _Arg>) {
	__impl.template __assign<_Ip>(_VSTD::forward<_Arg>(__arg));
	return *this;
	}

	template <
	size_t _Ip,
	class... _Args,
	enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
	class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
	enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp& emplace(_Args&&... __args) {
	return __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...);
	}

	template <
	size_t _Ip,
	class _Up,
	class... _Args,
	enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
	class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
	enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
	int> = 0>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
	return __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...);
	}

	template <
	class _Tp,
	class... _Args,
	size_t _Ip =
	__find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
	enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp& emplace(_Args&&... __args) {
	return __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...);
	}

	template <
	class _Tp,
	class _Up,
	class... _Args,
	size_t _Ip =
	__find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
	enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
	int> = 0>
	inline _LIBCPP_INLINE_VISIBILITY
	_Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
	return __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	constexpr bool valueless_by_exception() const noexcept {
	return __impl.valueless_by_exception();
	}

	inline _LIBCPP_INLINE_VISIBILITY
	constexpr size_t index() const noexcept { return __impl.index(); }

	template <
	bool _Dummy = true,
	enable_if_t<
	__all<(
	__dependent_type<is_move_constructible<_Types>, _Dummy>::value &&
	__dependent_type<is_swappable<_Types>, _Dummy>::value)...>::value,
	int> = 0>
	inline _LIBCPP_INLINE_VISIBILITY
	void swap(variant& __that) noexcept(
	__all<(is_nothrow_move_constructible_v<_Types> &&
	is_nothrow_swappable_v<_Types>)...>::value) {
	__impl.__swap(__that.__impl);
	}

	private:
	__variant_detail::__impl<_Types...> __impl;

	friend struct __variant_detail::__access::__variant;
	friend struct __variant_detail::__visitation::__variant;
	};

	template <size_t _Ip, class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr bool __holds_alternative(const variant<_Types...>& __v) noexcept {
	return __v.index() == _Ip;
	}

	template <class _Tp, class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr bool holds_alternative(const variant<_Types...>& __v) noexcept {
	return __holds_alternative<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
	}

	template <size_t _Ip, class _Vp>
	inline _LIBCPP_INLINE_VISIBILITY
	static constexpr auto&& __generic_get(_Vp&& __v) {
	using __variant_detail::__access::__variant;
	if (!__holds_alternative<_Ip>(__v)) {
	__throw_bad_variant_access();
	}
	return __variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value;
	}

	template <size_t _Ip, class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr variant_alternative_t<_Ip, variant<_Types...>>& get(
	variant<_Types...>& __v) {
	static_assert(_Ip < sizeof...(_Types));
	static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
	return __generic_get<_Ip>(__v);
	}

	template <size_t _Ip, class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr variant_alternative_t<_Ip, variant<_Types...>>&& get(
	variant<_Types...>&& __v) {
	static_assert(_Ip < sizeof...(_Types));
	static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
	return __generic_get<_Ip>(_VSTD::move(__v));
	}

	template <size_t _Ip, class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr const variant_alternative_t<_Ip, variant<_Types...>>& get(
	const variant<_Types...>& __v) {
	static_assert(_Ip < sizeof...(_Types));
	static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
	return __generic_get<_Ip>(__v);
	}

	template <size_t _Ip, class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr const variant_alternative_t<_Ip, variant<_Types...>>&& get(
	const variant<_Types...>&& __v) {
	static_assert(_Ip < sizeof...(_Types));
	static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
	return __generic_get<_Ip>(_VSTD::move(__v));
	}

	template <class _Tp, class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _Tp& get(variant<_Types...>& __v) {
	static_assert(!is_void_v<_Tp>);
	return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
	}

	template <class _Tp, class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr _Tp&& get(variant<_Types...>&& __v) {
	static_assert(!is_void_v<_Tp>);
	return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(
	_VSTD::move(__v));
	}

	template <class _Tp, class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr const _Tp& get(const variant<_Types...>& __v) {
	static_assert(!is_void_v<_Tp>);
	return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
	}

	template <class _Tp, class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr const _Tp&& get(const variant<_Types...>&& __v) {
	static_assert(!is_void_v<_Tp>);
	return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(
	_VSTD::move(__v));
	}

	template <size_t _Ip, class _Vp>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr auto* __generic_get_if(_Vp* __v) noexcept {
	using __variant_detail::__access::__variant;
	return __v && __holds_alternative<_Ip>(*__v)
	? _VSTD::addressof(__variant::__get_alt<_Ip>(*__v).__value)
	: nullptr;
	}

	template <size_t _Ip, class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr add_pointer_t<variant_alternative_t<_Ip, variant<_Types...>>>
	get_if(variant<_Types...>* __v) noexcept {
	static_assert(_Ip < sizeof...(_Types));
	static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
	return __generic_get_if<_Ip>(__v);
	}

	template <size_t _Ip, class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr add_pointer_t<const variant_alternative_t<_Ip, variant<_Types...>>>
	get_if(const variant<_Types...>* __v) noexcept {
	static_assert(_Ip < sizeof...(_Types));
	static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
	return __generic_get_if<_Ip>(__v);
	}

	template <class _Tp, class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr add_pointer_t<_Tp>
	get_if(variant<_Types...>* __v) noexcept {
	static_assert(!is_void_v<_Tp>);
	return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
	}

	template <class _Tp, class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr add_pointer_t<const _Tp>
	get_if(const variant<_Types...>* __v) noexcept {
	static_assert(!is_void_v<_Tp>);
	return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
	}

	template <class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr bool operator==(const variant<_Types...>& __lhs,
	const variant<_Types...>& __rhs) {
	using __variant_detail::__visitation::__variant;
	if (__lhs.index() != __rhs.index()) return false;
	if (__lhs.valueless_by_exception()) return true;
	return __variant::__visit_value_at(__lhs.index(), equal_to<>{}, __lhs, __rhs);
	}

	template <class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr bool operator!=(const variant<_Types...>& __lhs,
	const variant<_Types...>& __rhs) {
	using __variant_detail::__visitation::__variant;
	if (__lhs.index() != __rhs.index()) return true;
	if (__lhs.valueless_by_exception()) return false;
	return __variant::__visit_value_at(
	__lhs.index(), not_equal_to<>{}, __lhs, __rhs);
	}

	template <class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr bool operator<(const variant<_Types...>& __lhs,
	const variant<_Types...>& __rhs) {
	using __variant_detail::__visitation::__variant;
	if (__rhs.valueless_by_exception()) return false;
	if (__lhs.valueless_by_exception()) return true;
	if (__lhs.index() < __rhs.index()) return true;
	if (__lhs.index() > __rhs.index()) return false;
	return __variant::__visit_value_at(__lhs.index(), less<>{}, __lhs, __rhs);
	}

	template <class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr bool operator>(const variant<_Types...>& __lhs,
	const variant<_Types...>& __rhs) {
	using __variant_detail::__visitation::__variant;
	if (__lhs.valueless_by_exception()) return false;
	if (__rhs.valueless_by_exception()) return true;
	if (__lhs.index() > __rhs.index()) return true;
	if (__lhs.index() < __rhs.index()) return false;
	return __variant::__visit_value_at(__lhs.index(), greater<>{}, __lhs, __rhs);
	}

	template <class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr bool operator<=(const variant<_Types...>& __lhs,
	const variant<_Types...>& __rhs) {
	using __variant_detail::__visitation::__variant;
	if (__lhs.valueless_by_exception()) return true;
	if (__rhs.valueless_by_exception()) return false;
	if (__lhs.index() < __rhs.index()) return true;
	if (__lhs.index() > __rhs.index()) return false;
	return __variant::__visit_value_at(
	__lhs.index(), less_equal<>{}, __lhs, __rhs);
	}

	template <class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr bool operator>=(const variant<_Types...>& __lhs,
	const variant<_Types...>& __rhs) {
	using __variant_detail::__visitation::__variant;
	if (__rhs.valueless_by_exception()) return true;
	if (__lhs.valueless_by_exception()) return false;
	if (__lhs.index() > __rhs.index()) return true;
	if (__lhs.index() < __rhs.index()) return false;
	return __variant::__visit_value_at(
	__lhs.index(), greater_equal<>{}, __lhs, __rhs);
	}

	template <class _Visitor, class... _Vs>
	inline _LIBCPP_INLINE_VISIBILITY
	constexpr decltype(auto) visit(_Visitor&& __visitor, _Vs&&... __vs) {
	using __variant_detail::__visitation::__variant;
	bool __results[] = {__vs.valueless_by_exception()...};
	for (bool __result : __results) {
	if (__result) {
	__throw_bad_variant_access();
	}
	}
	return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor),
	_VSTD::forward<_Vs>(__vs)...);
	}

	struct _LIBCPP_TEMPLATE_VIS monostate {};

	inline _LIBCPP_INLINE_VISIBILITY
	constexpr bool operator<(monostate, monostate) noexcept { return false; }

	inline _LIBCPP_INLINE_VISIBILITY
	constexpr bool operator>(monostate, monostate) noexcept { return false; }

	inline _LIBCPP_INLINE_VISIBILITY
	constexpr bool operator<=(monostate, monostate) noexcept { return true; }

	inline _LIBCPP_INLINE_VISIBILITY
	constexpr bool operator>=(monostate, monostate) noexcept { return true; }

	inline _LIBCPP_INLINE_VISIBILITY
	constexpr bool operator==(monostate, monostate) noexcept { return true; }

	inline _LIBCPP_INLINE_VISIBILITY
	constexpr bool operator!=(monostate, monostate) noexcept { return false; }

	template <class... _Types>
	inline _LIBCPP_INLINE_VISIBILITY
	auto swap(variant<_Types...>& __lhs,
	variant<_Types...>& __rhs) noexcept(noexcept(__lhs.swap(__rhs)))
	-> decltype(__lhs.swap(__rhs)) {
	__lhs.swap(__rhs);
	}

	template <class... _Types>
	struct _LIBCPP_TEMPLATE_VIS hash<
	__enable_hash_helper<variant<_Types...>, remove_const_t<_Types>...>> {
	using argument_type = variant<_Types...>;
	using result_type = size_t;

	inline _LIBCPP_INLINE_VISIBILITY
	result_type operator()(const argument_type& __v) const {
	using __variant_detail::__visitation::__variant;
	size_t __res =
	__v.valueless_by_exception()
	? 299792458 // Random value chosen by the universe upon creation
	: __variant::__visit_alt(
	[](const auto& __alt) {
	- using __alt_type = decay_t<decltype(__alt)>;
	+ using __alt_type = __uncvref_t<decltype(__alt)>;
	using __value_type = remove_const_t<
	typename __alt_type::__value_type>;
	return hash<__value_type>{}(__alt.__value);
	},
	__v);
	return __hash_combine(__res, hash<size_t>{}(__v.index()));
	}
	};

	template <>
	struct _LIBCPP_TEMPLATE_VIS hash<monostate> {
	using argument_type = monostate;
	using result_type = size_t;

	inline _LIBCPP_INLINE_VISIBILITY
	result_type operator()(const argument_type&) const _NOEXCEPT {
	return 66740831; // return a fundamentally attractive random value.
	}
	};

	#endif // _LIBCPP_STD_VER > 14

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_VARIANT
	Index: projects/clang700-import/contrib/libc++/include/vector
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/vector (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/vector (revision 337135)
	@@ -1,3368 +1,3399 @@
	// -- C++ --
	//===------------------------------ vector --------------------------------===//
	//
	// 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_VECTOR
	#define _LIBCPP_VECTOR

	/*
	vector synopsis

	namespace std
	{

	template <class T, class Allocator = allocator<T> >
	class vector
	{
	public:
	typedef T value_type;
	typedef Allocator allocator_type;
	typedef typename allocator_type::reference reference;
	typedef typename allocator_type::const_reference const_reference;
	typedef implementation-defined iterator;
	typedef implementation-defined const_iterator;
	typedef typename allocator_type::size_type size_type;
	typedef typename allocator_type::difference_type difference_type;
	typedef typename allocator_type::pointer pointer;
	typedef typename allocator_type::const_pointer const_pointer;
	typedef std::reverse_iterator<iterator> reverse_iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

	vector()
	noexcept(is_nothrow_default_constructible<allocator_type>::value);
	explicit vector(const allocator_type&);
	explicit vector(size_type n);
	explicit vector(size_type n, const allocator_type&); // C++14
	vector(size_type n, const value_type& value, const allocator_type& = allocator_type());
	template <class InputIterator>
	vector(InputIterator first, InputIterator last, const allocator_type& = allocator_type());
	vector(const vector& x);
	vector(vector&& x)
	noexcept(is_nothrow_move_constructible<allocator_type>::value);
	vector(initializer_list<value_type> il);
	vector(initializer_list<value_type> il, const allocator_type& a);
	~vector();
	vector& operator=(const vector& x);
	vector& operator=(vector&& x)
	noexcept(
	allocator_type::propagate_on_container_move_assignment::value \|\|
	allocator_type::is_always_equal::value); // C++17
	vector& operator=(initializer_list<value_type> il);
	template <class InputIterator>
	void assign(InputIterator first, InputIterator last);
	void assign(size_type n, const value_type& u);
	void assign(initializer_list<value_type> il);

	allocator_type get_allocator() const noexcept;

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

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

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

	size_type size() const noexcept;
	size_type max_size() const noexcept;
	size_type capacity() const noexcept;
	bool empty() const noexcept;
	void reserve(size_type n);
	void shrink_to_fit() noexcept;

	reference operator[](size_type n);
	const_reference operator[](size_type n) const;
	reference at(size_type n);
	const_reference at(size_type n) const;

	reference front();
	const_reference front() const;
	reference back();
	const_reference back() const;

	value_type* data() noexcept;
	const value_type* data() const noexcept;

	void push_back(const value_type& x);
	void push_back(value_type&& x);
	template <class... Args>
	reference emplace_back(Args&&... args); // reference in C++17
	void pop_back();

	template <class... Args> iterator emplace(const_iterator position, Args&&... args);
	iterator insert(const_iterator position, const value_type& x);
	iterator insert(const_iterator position, value_type&& x);
	iterator insert(const_iterator position, size_type n, const value_type& x);
	template <class InputIterator>
	iterator insert(const_iterator position, InputIterator first, InputIterator last);
	iterator insert(const_iterator position, initializer_list<value_type> il);

	iterator erase(const_iterator position);
	iterator erase(const_iterator first, const_iterator last);

	void clear() noexcept;

	void resize(size_type sz);
	void resize(size_type sz, const value_type& c);

	void swap(vector&)
	noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value \|\|
	allocator_traits<allocator_type>::is_always_equal::value); // C++17

	bool __invariants() const;
	};

	template <class Allocator = allocator<T> >
	class vector<bool, Allocator>
	{
	public:
	typedef bool value_type;
	typedef Allocator allocator_type;
	typedef implementation-defined iterator;
	typedef implementation-defined const_iterator;
	typedef typename allocator_type::size_type size_type;
	typedef typename allocator_type::difference_type difference_type;
	typedef iterator pointer;
	typedef const_iterator const_pointer;
	typedef std::reverse_iterator<iterator> reverse_iterator;
	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

	class reference
	{
	public:
	reference(const reference&) noexcept;
	operator bool() const noexcept;
	reference& operator=(const bool x) noexcept;
	reference& operator=(const reference& x) noexcept;
	iterator operator&() const noexcept;
	void flip() noexcept;
	};

	class const_reference
	{
	public:
	const_reference(const reference&) noexcept;
	operator bool() const noexcept;
	const_iterator operator&() const noexcept;
	};

	vector()
	noexcept(is_nothrow_default_constructible<allocator_type>::value);
	explicit vector(const allocator_type&);
	explicit vector(size_type n, const allocator_type& a = allocator_type()); // C++14
	vector(size_type n, const value_type& value, const allocator_type& = allocator_type());
	template <class InputIterator>
	vector(InputIterator first, InputIterator last, const allocator_type& = allocator_type());
	vector(const vector& x);
	vector(vector&& x)
	noexcept(is_nothrow_move_constructible<allocator_type>::value);
	vector(initializer_list<value_type> il);
	vector(initializer_list<value_type> il, const allocator_type& a);
	~vector();
	vector& operator=(const vector& x);
	vector& operator=(vector&& x)
	noexcept(
	allocator_type::propagate_on_container_move_assignment::value \|\|
	allocator_type::is_always_equal::value); // C++17
	vector& operator=(initializer_list<value_type> il);
	template <class InputIterator>
	void assign(InputIterator first, InputIterator last);
	void assign(size_type n, const value_type& u);
	void assign(initializer_list<value_type> il);

	allocator_type get_allocator() const noexcept;

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

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

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

	size_type size() const noexcept;
	size_type max_size() const noexcept;
	size_type capacity() const noexcept;
	bool empty() const noexcept;
	void reserve(size_type n);
	void shrink_to_fit() noexcept;

	reference operator[](size_type n);
	const_reference operator[](size_type n) const;
	reference at(size_type n);
	const_reference at(size_type n) const;

	reference front();
	const_reference front() const;
	reference back();
	const_reference back() const;

	void push_back(const value_type& x);
	template <class... Args> reference emplace_back(Args&&... args); // C++14; reference in C++17
	void pop_back();

	template <class... Args> iterator emplace(const_iterator position, Args&&... args); // C++14
	iterator insert(const_iterator position, const value_type& x);
	iterator insert(const_iterator position, size_type n, const value_type& x);
	template <class InputIterator>
	iterator insert(const_iterator position, InputIterator first, InputIterator last);
	iterator insert(const_iterator position, initializer_list<value_type> il);

	iterator erase(const_iterator position);
	iterator erase(const_iterator first, const_iterator last);

	void clear() noexcept;

	void resize(size_type sz);
	void resize(size_type sz, value_type x);

	void swap(vector&)
	noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value \|\|
	allocator_traits<allocator_type>::is_always_equal::value); // C++17
	void flip() noexcept;

	bool __invariants() const;
	};

	+template <class InputIterator, class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
	+ vector(InputIterator, InputIterator, Allocator = Allocator())
	+ -> vector<typename iterator_traits<InputIterator>::value_type, Allocator>;
	+
	template <class Allocator> struct hash<std::vector<bool, Allocator>>;

	template <class T, class Allocator> bool operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
	template <class T, class Allocator> bool operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y);
	template <class T, class Allocator> bool operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
	template <class T, class Allocator> bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y);
	template <class T, class Allocator> bool operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
	template <class T, class Allocator> bool operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);

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

	} // std

	*/

	#include <__config>
	#include <iosfwd> // for forward declaration of vector
	#include <__bit_reference>
	#include <type_traits>
	#include <climits>
	#include <limits>
	#include <initializer_list>
	#include <memory>
	#include <stdexcept>
	#include <algorithm>
	#include <cstring>
	#include <__split_buffer>
	#include <__functional_base>

	#include <__debug>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>


	_LIBCPP_BEGIN_NAMESPACE_STD

	template <bool>
	class __vector_base_common
	{
	protected:
	- _LIBCPP_ALWAYS_INLINE __vector_base_common() {}
	+ _LIBCPP_INLINE_VISIBILITY __vector_base_common() {}
	_LIBCPP_NORETURN void __throw_length_error() const;
	_LIBCPP_NORETURN void __throw_out_of_range() const;
	};

	template <bool __b>
	void
	__vector_base_common<__b>::__throw_length_error() const
	{
	_VSTD::__throw_length_error("vector");
	}

	template <bool __b>
	void
	__vector_base_common<__b>::__throw_out_of_range() const
	{
	_VSTD::__throw_out_of_range("vector");
	}

	_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __vector_base_common<true>)

	template <class _Tp, class _Allocator>
	class __vector_base
	: protected __vector_base_common<true>
	{
	-protected:
	- typedef _Tp value_type;
	+public:
	typedef _Allocator allocator_type;
	typedef allocator_traits<allocator_type> __alloc_traits;
	+ typedef typename __alloc_traits::size_type size_type;
	+protected:
	+ typedef _Tp value_type;
	typedef value_type& reference;
	typedef const value_type& const_reference;
	- typedef typename __alloc_traits::size_type size_type;
	typedef typename __alloc_traits::difference_type difference_type;
	typedef typename __alloc_traits::pointer pointer;
	typedef typename __alloc_traits::const_pointer const_pointer;
	typedef pointer iterator;
	typedef const_pointer const_iterator;

	pointer __begin_;
	pointer __end_;
	__compressed_pair<pointer, allocator_type> __end_cap_;

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

	_LIBCPP_INLINE_VISIBILITY
	__vector_base()
	_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
	_LIBCPP_INLINE_VISIBILITY __vector_base(const allocator_type& __a);
	+#ifndef _LIBCPP_CXX03_LANG
	+ _LIBCPP_INLINE_VISIBILITY __vector_base(allocator_type&& __a) _NOEXCEPT;
	+#endif
	~__vector_base();

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

	_LIBCPP_INLINE_VISIBILITY
	void __destruct_at_end(pointer __new_last) _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const __vector_base& __c)
	{__copy_assign_alloc(__c, integral_constant<bool,
	__alloc_traits::propagate_on_container_copy_assignment::value>());}

	_LIBCPP_INLINE_VISIBILITY
	void __move_assign_alloc(__vector_base& __c)
	_NOEXCEPT_(
	!__alloc_traits::propagate_on_container_move_assignment::value \|\|
	is_nothrow_move_assignable<allocator_type>::value)
	{__move_assign_alloc(__c, integral_constant<bool,
	__alloc_traits::propagate_on_container_move_assignment::value>());}
	private:
	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const __vector_base& __c, true_type)
	{
	if (__alloc() != __c.__alloc())
	{
	clear();
	__alloc_traits::deallocate(__alloc(), __begin_, capacity());
	__begin_ = __end_ = __end_cap() = nullptr;
	}
	__alloc() = __c.__alloc();
	}

	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const __vector_base&, false_type)
	{}

	_LIBCPP_INLINE_VISIBILITY
	void __move_assign_alloc(__vector_base& __c, true_type)
	_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
	{
	__alloc() = _VSTD::move(__c.__alloc());
	}

	_LIBCPP_INLINE_VISIBILITY
	void __move_assign_alloc(__vector_base&, false_type)
	_NOEXCEPT
	{}
	};

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	__vector_base<_Tp, _Allocator>::__destruct_at_end(pointer __new_last) _NOEXCEPT
	{
	pointer __soon_to_be_end = __end_;
	while (__new_last != __soon_to_be_end)
	__alloc_traits::destroy(__alloc(), _VSTD::__to_raw_pointer(--__soon_to_be_end));
	__end_ = __new_last;
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	__vector_base<_Tp, _Allocator>::__vector_base()
	_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
	: __begin_(nullptr),
	__end_(nullptr),
	__end_cap_(nullptr)
	{
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	__vector_base<_Tp, _Allocator>::__vector_base(const allocator_type& __a)
	: __begin_(nullptr),
	__end_(nullptr),
	__end_cap_(nullptr, __a)
	{
	}

	+#ifndef _LIBCPP_CXX03_LANG
	template <class _Tp, class _Allocator>
	+inline _LIBCPP_INLINE_VISIBILITY
	+__vector_base<_Tp, _Allocator>::__vector_base(allocator_type&& __a) _NOEXCEPT
	+ : __begin_(nullptr),
	+ __end_(nullptr),
	+ __end_cap_(nullptr, std::move(__a)) {}
	+#endif
	+
	+template <class _Tp, class _Allocator>
	__vector_base<_Tp, _Allocator>::~__vector_base()
	{
	if (__begin_ != nullptr)
	{
	clear();
	__alloc_traits::deallocate(__alloc(), __begin_, capacity());
	}
	}

	template <class _Tp, class _Allocator /* = allocator<_Tp> */>
	class _LIBCPP_TEMPLATE_VIS vector
	: private __vector_base<_Tp, _Allocator>
	{
	private:
	typedef __vector_base<_Tp, _Allocator> __base;
	typedef allocator<_Tp> __default_allocator_type;
	public:
	typedef vector __self;
	typedef _Tp value_type;
	typedef _Allocator allocator_type;
	typedef typename __base::__alloc_traits __alloc_traits;
	typedef typename __base::reference reference;
	typedef typename __base::const_reference const_reference;
	typedef typename __base::size_type size_type;
	typedef typename __base::difference_type difference_type;
	typedef typename __base::pointer pointer;
	typedef typename __base::const_pointer const_pointer;
	typedef __wrap_iter<pointer> iterator;
	typedef __wrap_iter<const_pointer> const_iterator;
	typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
	typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;

	static_assert((is_same<typename allocator_type::value_type, value_type>::value),
	"Allocator::value_type must be same type as value_type");

	_LIBCPP_INLINE_VISIBILITY
	vector() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}
	_LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a)
	#if _LIBCPP_STD_VER <= 14
	_NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
	#else
	_NOEXCEPT
	#endif
	: __base(__a)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	}
	explicit vector(size_type __n);
	#if _LIBCPP_STD_VER > 11
	explicit vector(size_type __n, const allocator_type& __a);
	#endif
	- vector(size_type __n, const_reference __x);
	- vector(size_type __n, const_reference __x, const allocator_type& __a);
	+ vector(size_type __n, const value_type& __x);
	+ vector(size_type __n, const value_type& __x, const allocator_type& __a);
	template <class _InputIterator>
	vector(_InputIterator __first,
	typename enable_if<__is_input_iterator <_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value &&
	is_constructible<
	value_type,
	typename iterator_traits<_InputIterator>::reference>::value,
	_InputIterator>::type __last);
	template <class _InputIterator>
	vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
	typename enable_if<__is_input_iterator <_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value &&
	is_constructible<
	value_type,
	typename iterator_traits<_InputIterator>::reference>::value>::type* = 0);
	template <class _ForwardIterator>
	vector(_ForwardIterator __first,
	typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&
	is_constructible<
	value_type,
	typename iterator_traits<_ForwardIterator>::reference>::value,
	_ForwardIterator>::type __last);
	template <class _ForwardIterator>
	vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
	typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&
	is_constructible<
	value_type,
	typename iterator_traits<_ForwardIterator>::reference>::value>::type* = 0);

	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_INLINE_VISIBILITY
	~vector()
	{
	__get_db()->__erase_c(this);
	}
	#endif

	vector(const vector& __x);
	vector(const vector& __x, const allocator_type& __a);
	_LIBCPP_INLINE_VISIBILITY
	vector& operator=(const vector& __x);

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	vector(initializer_list<value_type> __il);

	_LIBCPP_INLINE_VISIBILITY
	vector(initializer_list<value_type> __il, const allocator_type& __a);

	_LIBCPP_INLINE_VISIBILITY
	vector(vector&& __x)
	#if _LIBCPP_STD_VER > 14
	_NOEXCEPT;
	#else
	_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
	#endif

	_LIBCPP_INLINE_VISIBILITY
	vector(vector&& __x, const allocator_type& __a);
	_LIBCPP_INLINE_VISIBILITY
	vector& operator=(vector&& __x)
	_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));

	_LIBCPP_INLINE_VISIBILITY
	vector& operator=(initializer_list<value_type> __il)
	{assign(__il.begin(), __il.end()); return *this;}

	#endif // !_LIBCPP_CXX03_LANG

	template <class _InputIterator>
	typename enable_if
	<
	__is_input_iterator <_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value &&
	is_constructible<
	value_type,
	typename iterator_traits<_InputIterator>::reference>::value,
	void
	>::type
	assign(_InputIterator __first, _InputIterator __last);
	template <class _ForwardIterator>
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value &&
	is_constructible<
	value_type,
	typename iterator_traits<_ForwardIterator>::reference>::value,
	void
	>::type
	assign(_ForwardIterator __first, _ForwardIterator __last);

	void assign(size_type __n, const_reference __u);

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	void assign(initializer_list<value_type> __il)
	{assign(__il.begin(), __il.end());}
	#endif

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

	_LIBCPP_INLINE_VISIBILITY iterator begin() _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY iterator end() _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT;

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

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

	_LIBCPP_INLINE_VISIBILITY
	size_type size() const _NOEXCEPT
	{return static_cast<size_type>(this->__end_ - this->__begin_);}
	_LIBCPP_INLINE_VISIBILITY
	size_type capacity() const _NOEXCEPT
	{return __base::capacity();}
	_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
	bool empty() const _NOEXCEPT
	{return this->__begin_ == this->__end_;}
	size_type max_size() const _NOEXCEPT;
	void reserve(size_type __n);
	void shrink_to_fit() _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n);
	_LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const;
	reference at(size_type __n);
	const_reference at(size_type __n) const;

	_LIBCPP_INLINE_VISIBILITY reference front()
	{
	_LIBCPP_ASSERT(!empty(), "front() called for empty vector");
	return *this->__begin_;
	}
	_LIBCPP_INLINE_VISIBILITY const_reference front() const
	{
	_LIBCPP_ASSERT(!empty(), "front() called for empty vector");
	return *this->__begin_;
	}
	_LIBCPP_INLINE_VISIBILITY reference back()
	{
	_LIBCPP_ASSERT(!empty(), "back() called for empty vector");
	return *(this->__end_ - 1);
	}
	_LIBCPP_INLINE_VISIBILITY const_reference back() const
	{
	_LIBCPP_ASSERT(!empty(), "back() called for empty vector");
	return *(this->__end_ - 1);
	}

	_LIBCPP_INLINE_VISIBILITY
	value_type* data() _NOEXCEPT
	{return _VSTD::__to_raw_pointer(this->__begin_);}
	_LIBCPP_INLINE_VISIBILITY
	const value_type* data() const _NOEXCEPT
	{return _VSTD::__to_raw_pointer(this->__begin_);}

	#ifdef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	void __emplace_back(const value_type& __x) { push_back(__x); }
	#else
	template <class _Arg>
	_LIBCPP_INLINE_VISIBILITY
	void __emplace_back(_Arg&& __arg) {
	emplace_back(_VSTD::forward<_Arg>(__arg));
	}
	#endif

	_LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x);

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY void push_back(value_type&& __x);

	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY
	#if _LIBCPP_STD_VER > 14
	reference emplace_back(_Args&&... __args);
	#else
	void emplace_back(_Args&&... __args);
	#endif
	#endif // !_LIBCPP_CXX03_LANG

	_LIBCPP_INLINE_VISIBILITY
	void pop_back();

	iterator insert(const_iterator __position, const_reference __x);

	#ifndef _LIBCPP_CXX03_LANG
	iterator insert(const_iterator __position, value_type&& __x);
	template <class... _Args>
	iterator emplace(const_iterator __position, _Args&&... __args);
	#endif // !_LIBCPP_CXX03_LANG

	iterator insert(const_iterator __position, size_type __n, const_reference __x);
	template <class _InputIterator>
	typename enable_if
	<
	__is_input_iterator <_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value &&
	is_constructible<
	value_type,
	typename iterator_traits<_InputIterator>::reference>::value,
	iterator
	>::type
	insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
	template <class _ForwardIterator>
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value &&
	is_constructible<
	value_type,
	typename iterator_traits<_ForwardIterator>::reference>::value,
	iterator
	>::type
	insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __position, initializer_list<value_type> __il)
	{return insert(__position, __il.begin(), __il.end());}
	#endif

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

	_LIBCPP_INLINE_VISIBILITY
	void clear() _NOEXCEPT
	{
	size_type __old_size = size();
	__base::clear();
	__annotate_shrink(__old_size);
	__invalidate_all_iterators();
	}

	void resize(size_type __sz);
	void resize(size_type __sz, const_reference __x);

	void swap(vector&)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT_DEBUG;
	#else
	_NOEXCEPT_DEBUG_(!__alloc_traits::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<allocator_type>::value);
	#endif

	bool __invariants() const;

	#if _LIBCPP_DEBUG_LEVEL >= 2

	bool __dereferenceable(const const_iterator* __i) const;
	bool __decrementable(const const_iterator* __i) const;
	bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
	bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;

	#endif // _LIBCPP_DEBUG_LEVEL >= 2

	private:
	_LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
	_LIBCPP_INLINE_VISIBILITY void __invalidate_iterators_past(pointer __new_last);
	- void allocate(size_type __n);
	- void deallocate() _NOEXCEPT;
	+ void __vallocate(size_type __n);
	+ void __vdeallocate() _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY size_type __recommend(size_type __new_size) const;
	void __construct_at_end(size_type __n);
	_LIBCPP_INLINE_VISIBILITY
	void __construct_at_end(size_type __n, const_reference __x);
	template <class _ForwardIterator>
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value,
	void
	>::type
	__construct_at_end(_ForwardIterator __first, _ForwardIterator __last, size_type __n);
	void __append(size_type __n);
	void __append(size_type __n, const_reference __x);
	_LIBCPP_INLINE_VISIBILITY
	iterator __make_iter(pointer __p) _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	const_iterator __make_iter(const_pointer __p) const _NOEXCEPT;
	void __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v);
	pointer __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p);
	void __move_range(pointer __from_s, pointer __from_e, pointer __to);
	void __move_assign(vector& __c, true_type)
	_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
	void __move_assign(vector& __c, false_type)
	_NOEXCEPT_(__alloc_traits::is_always_equal::value);
	_LIBCPP_INLINE_VISIBILITY
	void __destruct_at_end(pointer __new_last) _NOEXCEPT
	{
	__invalidate_iterators_past(__new_last);
	size_type __old_size = size();
	__base::__destruct_at_end(__new_last);
	__annotate_shrink(__old_size);
	}

	#ifndef _LIBCPP_CXX03_LANG
	template <class _Up> void __push_back_slow_path(_Up&& __x);

	template <class... _Args>
	void __emplace_back_slow_path(_Args&&... __args);
	#else
	template <class _Up> void __push_back_slow_path(_Up& __x);
	#endif

	// The following functions are no-ops outside of AddressSanitizer mode.
	// We call annotatations only for the default Allocator because other allocators
	// may not meet the AddressSanitizer alignment constraints.
	// See the documentation for __sanitizer_annotate_contiguous_container for more details.
	#ifndef _LIBCPP_HAS_NO_ASAN
	void __annotate_contiguous_container(const void __beg, const void __end,
	const void *__old_mid,
	const void *__new_mid) const
	{

	if (__beg && is_same<allocator_type, __default_allocator_type>::value)
	__sanitizer_annotate_contiguous_container(__beg, __end, __old_mid, __new_mid);
	}
	#else
	_LIBCPP_INLINE_VISIBILITY
	void __annotate_contiguous_container(const void, const void, const void*,
	const void*) const {}
	#endif
	_LIBCPP_INLINE_VISIBILITY
	void __annotate_new(size_type __current_size) const {
	__annotate_contiguous_container(data(), data() + capacity(),
	data() + capacity(), data() + __current_size);
	}

	_LIBCPP_INLINE_VISIBILITY
	void __annotate_delete() const {
	__annotate_contiguous_container(data(), data() + capacity(),
	data() + size(), data() + capacity());
	}

	_LIBCPP_INLINE_VISIBILITY
	void __annotate_increase(size_type __n) const
	{
	__annotate_contiguous_container(data(), data() + capacity(),
	data() + size(), data() + size() + __n);
	}

	_LIBCPP_INLINE_VISIBILITY
	void __annotate_shrink(size_type __old_size) const
	{
	__annotate_contiguous_container(data(), data() + capacity(),
	data() + __old_size, data() + size());
	}
	#ifndef _LIBCPP_HAS_NO_ASAN
	// The annotation for size increase should happen before the actual increase,
	// but if an exception is thrown after that the annotation has to be undone.
	struct __RAII_IncreaseAnnotator {
	__RAII_IncreaseAnnotator(const vector &__v, size_type __n = 1)
	: __commit(false), __v(__v), __old_size(__v.size() + __n) {
	__v.__annotate_increase(__n);
	}
	void __done() { __commit = true; }
	~__RAII_IncreaseAnnotator() {
	if (__commit) return;
	__v.__annotate_shrink(__old_size);
	}
	bool __commit;
	const vector &__v;
	size_type __old_size;
	};
	#else
	struct __RAII_IncreaseAnnotator {
	_LIBCPP_INLINE_VISIBILITY
	__RAII_IncreaseAnnotator(const vector &, size_type = 1) {}
	_LIBCPP_INLINE_VISIBILITY void __done() {}
	};
	#endif

	};

	+#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
	+template<class _InputIterator,
	+ class _Alloc = typename std::allocator<typename iterator_traits<_InputIterator>::value_type>,
	+ class = typename enable_if<__is_allocator<_Alloc>::value, void>::type
	+ >
	+vector(_InputIterator, _InputIterator)
	+ -> vector<typename iterator_traits<_InputIterator>::value_type, _Alloc>;
	+
	+template<class _InputIterator,
	+ class _Alloc,
	+ class = typename enable_if<__is_allocator<_Alloc>::value, void>::type
	+ >
	+vector(_InputIterator, _InputIterator, _Alloc)
	+ -> vector<typename iterator_traits<_InputIterator>::value_type, _Alloc>;
	+#endif
	+
	template <class _Tp, class _Allocator>
	void
	vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v)
	{
	__annotate_delete();
	__alloc_traits::__construct_backward(this->__alloc(), this->__begin_, this->__end_, __v.__begin_);
	_VSTD::swap(this->__begin_, __v.__begin_);
	_VSTD::swap(this->__end_, __v.__end_);
	_VSTD::swap(this->__end_cap(), __v.__end_cap());
	__v.__first_ = __v.__begin_;
	__annotate_new(size());
	__invalidate_all_iterators();
	}

	template <class _Tp, class _Allocator>
	typename vector<_Tp, _Allocator>::pointer
	vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p)
	{
	__annotate_delete();
	pointer __r = __v.__begin_;
	__alloc_traits::__construct_backward(this->__alloc(), this->__begin_, __p, __v.__begin_);
	__alloc_traits::__construct_forward(this->__alloc(), __p, this->__end_, __v.__end_);
	_VSTD::swap(this->__begin_, __v.__begin_);
	_VSTD::swap(this->__end_, __v.__end_);
	_VSTD::swap(this->__end_cap(), __v.__end_cap());
	__v.__first_ = __v.__begin_;
	__annotate_new(size());
	__invalidate_all_iterators();
	return __r;
	}

	// Allocate space for __n objects
	// throws length_error if __n > max_size()
	// throws (probably bad_alloc) if memory run out
	// Precondition: __begin_ == __end_ == __end_cap() == 0
	// Precondition: __n > 0
	// Postcondition: capacity() == __n
	// Postcondition: size() == 0
	template <class _Tp, class _Allocator>
	void
	-vector<_Tp, _Allocator>::allocate(size_type __n)
	+vector<_Tp, _Allocator>::__vallocate(size_type __n)
	{
	if (__n > max_size())
	this->__throw_length_error();
	this->__begin_ = this->__end_ = __alloc_traits::allocate(this->__alloc(), __n);
	this->__end_cap() = this->__begin_ + __n;
	__annotate_new(0);
	}

	template <class _Tp, class _Allocator>
	void
	-vector<_Tp, _Allocator>::deallocate() _NOEXCEPT
	+vector<_Tp, _Allocator>::__vdeallocate() _NOEXCEPT
	{
	if (this->__begin_ != nullptr)
	{
	clear();
	__alloc_traits::deallocate(this->__alloc(), this->__begin_, capacity());
	this->__begin_ = this->__end_ = this->__end_cap() = nullptr;
	}
	}

	template <class _Tp, class _Allocator>
	typename vector<_Tp, _Allocator>::size_type
	vector<_Tp, _Allocator>::max_size() const _NOEXCEPT
	{
	return _VSTD::min<size_type>(__alloc_traits::max_size(this->__alloc()),
	numeric_limits<difference_type>::max());
	}

	// Precondition: __new_size > capacity()
	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename vector<_Tp, _Allocator>::size_type
	vector<_Tp, _Allocator>::__recommend(size_type __new_size) const
	{
	const size_type __ms = max_size();
	if (__new_size > __ms)
	this->__throw_length_error();
	const size_type __cap = capacity();
	if (__cap >= __ms / 2)
	return __ms;
	return _VSTD::max<size_type>(2*__cap, __new_size);
	}

	// Default constructs __n objects starting at __end_
	// throws if construction throws
	// Precondition: __n > 0
	// Precondition: size() + __n <= capacity()
	// Postcondition: size() == size() + __n
	template <class _Tp, class _Allocator>
	void
	vector<_Tp, _Allocator>::__construct_at_end(size_type __n)
	{
	allocator_type& __a = this->__alloc();
	do
	{
	__RAII_IncreaseAnnotator __annotator(*this);
	__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_));
	++this->__end_;
	--__n;
	__annotator.__done();
	} while (__n > 0);
	}

	// Copy constructs __n objects starting at __end_ from __x
	// throws if construction throws
	// Precondition: __n > 0
	// Precondition: size() + __n <= capacity()
	// Postcondition: size() == old size() + __n
	// Postcondition: [i] == __x for all i in [size() - __n, __n)
	template <class _Tp, class _Allocator>
	inline
	void
	vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
	{
	allocator_type& __a = this->__alloc();
	do
	{
	__RAII_IncreaseAnnotator __annotator(*this);
	__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), __x);
	++this->__end_;
	--__n;
	__annotator.__done();
	} while (__n > 0);
	}

	template <class _Tp, class _Allocator>
	template <class _ForwardIterator>
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value,
	void
	>::type
	vector<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last, size_type __n)
	{
	allocator_type& __a = this->__alloc();
	__RAII_IncreaseAnnotator __annotator(*this, __n);
	__alloc_traits::__construct_range_forward(__a, __first, __last, this->__end_);
	__annotator.__done();
	}

	// Default constructs __n objects starting at __end_
	// throws if construction throws
	// Postcondition: size() == size() + __n
	// Exception safety: strong.
	template <class _Tp, class _Allocator>
	void
	vector<_Tp, _Allocator>::__append(size_type __n)
	{
	if (static_cast<size_type>(this->__end_cap() - this->__end_) >= __n)
	this->__construct_at_end(__n);
	else
	{
	allocator_type& __a = this->__alloc();
	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), __a);
	__v.__construct_at_end(__n);
	__swap_out_circular_buffer(__v);
	}
	}

	// Default constructs __n objects starting at __end_
	// throws if construction throws
	// Postcondition: size() == size() + __n
	// Exception safety: strong.
	template <class _Tp, class _Allocator>
	void
	vector<_Tp, _Allocator>::__append(size_type __n, const_reference __x)
	{
	if (static_cast<size_type>(this->__end_cap() - this->__end_) >= __n)
	this->__construct_at_end(__n, __x);
	else
	{
	allocator_type& __a = this->__alloc();
	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), __a);
	__v.__construct_at_end(__n, __x);
	__swap_out_circular_buffer(__v);
	}
	}

	template <class _Tp, class _Allocator>
	vector<_Tp, _Allocator>::vector(size_type __n)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	if (__n > 0)
	{
	- allocate(__n);
	+ __vallocate(__n);
	__construct_at_end(__n);
	}
	}

	#if _LIBCPP_STD_VER > 11
	template <class _Tp, class _Allocator>
	vector<_Tp, _Allocator>::vector(size_type __n, const allocator_type& __a)
	: __base(__a)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	if (__n > 0)
	{
	- allocate(__n);
	+ __vallocate(__n);
	__construct_at_end(__n);
	}
	}
	#endif

	template <class _Tp, class _Allocator>
	-vector<_Tp, _Allocator>::vector(size_type __n, const_reference __x)
	+vector<_Tp, _Allocator>::vector(size_type __n, const value_type& __x)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	if (__n > 0)
	{
	- allocate(__n);
	+ __vallocate(__n);
	__construct_at_end(__n, __x);
	}
	}

	template <class _Tp, class _Allocator>
	-vector<_Tp, _Allocator>::vector(size_type __n, const_reference __x, const allocator_type& __a)
	+vector<_Tp, _Allocator>::vector(size_type __n, const value_type& __x, const allocator_type& __a)
	: __base(__a)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	if (__n > 0)
	{
	- allocate(__n);
	+ __vallocate(__n);
	__construct_at_end(__n, __x);
	}
	}

	template <class _Tp, class _Allocator>
	template <class _InputIterator>
	vector<_Tp, _Allocator>::vector(_InputIterator __first,
	typename enable_if<__is_input_iterator <_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value &&
	is_constructible<
	value_type,
	typename iterator_traits<_InputIterator>::reference>::value,
	_InputIterator>::type __last)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	for (; __first != __last; ++__first)
	__emplace_back(*__first);
	}

	template <class _Tp, class _Allocator>
	template <class _InputIterator>
	vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
	typename enable_if<__is_input_iterator <_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value &&
	is_constructible<
	value_type,
	typename iterator_traits<_InputIterator>::reference>::value>::type*)
	: __base(__a)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	for (; __first != __last; ++__first)
	__emplace_back(*__first);
	}

	template <class _Tp, class _Allocator>
	template <class _ForwardIterator>
	vector<_Tp, _Allocator>::vector(_ForwardIterator __first,
	typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&
	is_constructible<
	value_type,
	typename iterator_traits<_ForwardIterator>::reference>::value,
	_ForwardIterator>::type __last)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
	if (__n > 0)
	{
	- allocate(__n);
	+ __vallocate(__n);
	__construct_at_end(__first, __last, __n);
	}
	}

	template <class _Tp, class _Allocator>
	template <class _ForwardIterator>
	vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
	typename enable_if<__is_forward_iterator<_ForwardIterator>::value &&
	is_constructible<
	value_type,
	typename iterator_traits<_ForwardIterator>::reference>::value>::type*)
	: __base(__a)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
	if (__n > 0)
	{
	- allocate(__n);
	+ __vallocate(__n);
	__construct_at_end(__first, __last, __n);
	}
	}

	template <class _Tp, class _Allocator>
	vector<_Tp, _Allocator>::vector(const vector& __x)
	: __base(__alloc_traits::select_on_container_copy_construction(__x.__alloc()))
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	size_type __n = __x.size();
	if (__n > 0)
	{
	- allocate(__n);
	+ __vallocate(__n);
	__construct_at_end(__x.__begin_, __x.__end_, __n);
	}
	}

	template <class _Tp, class _Allocator>
	vector<_Tp, _Allocator>::vector(const vector& __x, const allocator_type& __a)
	: __base(__a)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	size_type __n = __x.size();
	if (__n > 0)
	{
	- allocate(__n);
	+ __vallocate(__n);
	__construct_at_end(__x.__begin_, __x.__end_, __n);
	}
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	vector<_Tp, _Allocator>::vector(vector&& __x)
	#if _LIBCPP_STD_VER > 14
	_NOEXCEPT
	#else
	_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
	#endif
	: __base(_VSTD::move(__x.__alloc()))
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	__get_db()->swap(this, &__x);
	#endif
	this->__begin_ = __x.__begin_;
	this->__end_ = __x.__end_;
	this->__end_cap() = __x.__end_cap();
	__x.__begin_ = __x.__end_ = __x.__end_cap() = nullptr;
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	vector<_Tp, _Allocator>::vector(vector&& __x, const allocator_type& __a)
	: __base(__a)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	if (__a == __x.__alloc())
	{
	this->__begin_ = __x.__begin_;
	this->__end_ = __x.__end_;
	this->__end_cap() = __x.__end_cap();
	__x.__begin_ = __x.__end_ = __x.__end_cap() = nullptr;
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->swap(this, &__x);
	#endif
	}
	else
	{
	typedef move_iterator<iterator> _Ip;
	assign(_Ip(__x.begin()), _Ip(__x.end()));
	}
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	if (__il.size() > 0)
	{
	- allocate(__il.size());
	+ __vallocate(__il.size());
	__construct_at_end(__il.begin(), __il.end(), __il.size());
	}
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il, const allocator_type& __a)
	: __base(__a)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__insert_c(this);
	#endif
	if (__il.size() > 0)
	{
	- allocate(__il.size());
	+ __vallocate(__il.size());
	__construct_at_end(__il.begin(), __il.end(), __il.size());
	}
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	vector<_Tp, _Allocator>&
	vector<_Tp, _Allocator>::operator=(vector&& __x)
	_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
	{
	__move_assign(__x, integral_constant<bool,
	__alloc_traits::propagate_on_container_move_assignment::value>());
	return *this;
	}

	template <class _Tp, class _Allocator>
	void
	vector<_Tp, _Allocator>::__move_assign(vector& __c, false_type)
	_NOEXCEPT_(__alloc_traits::is_always_equal::value)
	{
	if (__base::__alloc() != __c.__alloc())
	{
	typedef move_iterator<iterator> _Ip;
	assign(_Ip(__c.begin()), _Ip(__c.end()));
	}
	else
	__move_assign(__c, true_type());
	}

	template <class _Tp, class _Allocator>
	void
	vector<_Tp, _Allocator>::__move_assign(vector& __c, true_type)
	_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
	{
	- deallocate();
	+ __vdeallocate();
	__base::__move_assign_alloc(__c); // this can throw
	this->__begin_ = __c.__begin_;
	this->__end_ = __c.__end_;
	this->__end_cap() = __c.__end_cap();
	__c.__begin_ = __c.__end_ = __c.__end_cap() = nullptr;
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->swap(this, &__c);
	#endif
	}

	#endif // !_LIBCPP_CXX03_LANG

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	vector<_Tp, _Allocator>&
	vector<_Tp, _Allocator>::operator=(const vector& __x)
	{
	if (this != &__x)
	{
	__base::__copy_assign_alloc(__x);
	assign(__x.__begin_, __x.__end_);
	}
	return *this;
	}

	template <class _Tp, class _Allocator>
	template <class _InputIterator>
	typename enable_if
	<
	__is_input_iterator <_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value &&
	is_constructible<
	_Tp,
	typename iterator_traits<_InputIterator>::reference>::value,
	void
	>::type
	vector<_Tp, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
	{
	clear();
	for (; __first != __last; ++__first)
	__emplace_back(*__first);
	}

	template <class _Tp, class _Allocator>
	template <class _ForwardIterator>
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value &&
	is_constructible<
	_Tp,
	typename iterator_traits<_ForwardIterator>::reference>::value,
	void
	>::type
	vector<_Tp, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
	{
	size_type __new_size = static_cast<size_type>(_VSTD::distance(__first, __last));
	if (__new_size <= capacity())
	{
	_ForwardIterator __mid = __last;
	bool __growing = false;
	if (__new_size > size())
	{
	__growing = true;
	__mid = __first;
	_VSTD::advance(__mid, size());
	}
	pointer __m = _VSTD::copy(__first, __mid, this->__begin_);
	if (__growing)
	__construct_at_end(__mid, __last, __new_size - size());
	else
	this->__destruct_at_end(__m);
	}
	else
	{
	- deallocate();
	- allocate(__recommend(__new_size));
	+ __vdeallocate();
	+ __vallocate(__recommend(__new_size));
	__construct_at_end(__first, __last, __new_size);
	}
	__invalidate_all_iterators();
	}

	template <class _Tp, class _Allocator>
	void
	vector<_Tp, _Allocator>::assign(size_type __n, const_reference __u)
	{
	if (__n <= capacity())
	{
	size_type __s = size();
	_VSTD::fill_n(this->__begin_, _VSTD::min(__n, __s), __u);
	if (__n > __s)
	__construct_at_end(__n - __s, __u);
	else
	this->__destruct_at_end(this->__begin_ + __n);
	}
	else
	{
	- deallocate();
	- allocate(__recommend(static_cast<size_type>(__n)));
	+ __vdeallocate();
	+ __vallocate(__recommend(static_cast<size_type>(__n)));
	__construct_at_end(__n, __u);
	}
	__invalidate_all_iterators();
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename vector<_Tp, _Allocator>::iterator
	vector<_Tp, _Allocator>::__make_iter(pointer __p) _NOEXCEPT
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return iterator(this, __p);
	#else
	return iterator(__p);
	#endif
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename vector<_Tp, _Allocator>::const_iterator
	vector<_Tp, _Allocator>::__make_iter(const_pointer __p) const _NOEXCEPT
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	return const_iterator(this, __p);
	#else
	return const_iterator(__p);
	#endif
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename vector<_Tp, _Allocator>::iterator
	vector<_Tp, _Allocator>::begin() _NOEXCEPT
	{
	return __make_iter(this->__begin_);
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename vector<_Tp, _Allocator>::const_iterator
	vector<_Tp, _Allocator>::begin() const _NOEXCEPT
	{
	return __make_iter(this->__begin_);
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename vector<_Tp, _Allocator>::iterator
	vector<_Tp, _Allocator>::end() _NOEXCEPT
	{
	return __make_iter(this->__end_);
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename vector<_Tp, _Allocator>::const_iterator
	vector<_Tp, _Allocator>::end() const _NOEXCEPT
	{
	return __make_iter(this->__end_);
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename vector<_Tp, _Allocator>::reference
	vector<_Tp, _Allocator>::operator[](size_type __n)
	{
	_LIBCPP_ASSERT(__n < size(), "vector[] index out of bounds");
	return this->__begin_[__n];
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename vector<_Tp, _Allocator>::const_reference
	vector<_Tp, _Allocator>::operator[](size_type __n) const
	{
	_LIBCPP_ASSERT(__n < size(), "vector[] index out of bounds");
	return this->__begin_[__n];
	}

	template <class _Tp, class _Allocator>
	typename vector<_Tp, _Allocator>::reference
	vector<_Tp, _Allocator>::at(size_type __n)
	{
	if (__n >= size())
	this->__throw_out_of_range();
	return this->__begin_[__n];
	}

	template <class _Tp, class _Allocator>
	typename vector<_Tp, _Allocator>::const_reference
	vector<_Tp, _Allocator>::at(size_type __n) const
	{
	if (__n >= size())
	this->__throw_out_of_range();
	return this->__begin_[__n];
	}

	template <class _Tp, class _Allocator>
	void
	vector<_Tp, _Allocator>::reserve(size_type __n)
	{
	if (__n > capacity())
	{
	allocator_type& __a = this->__alloc();
	__split_buffer<value_type, allocator_type&> __v(__n, size(), __a);
	__swap_out_circular_buffer(__v);
	}
	}

	template <class _Tp, class _Allocator>
	void
	vector<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
	{
	if (capacity() > size())
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	allocator_type& __a = this->__alloc();
	__split_buffer<value_type, allocator_type&> __v(size(), size(), __a);
	__swap_out_circular_buffer(__v);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}
	}

	template <class _Tp, class _Allocator>
	template <class _Up>
	void
	#ifndef _LIBCPP_CXX03_LANG
	vector<_Tp, _Allocator>::__push_back_slow_path(_Up&& __x)
	#else
	vector<_Tp, _Allocator>::__push_back_slow_path(_Up& __x)
	#endif
	{
	allocator_type& __a = this->__alloc();
	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
	// __v.push_back(_VSTD::forward<_Up>(__x));
	__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(__v.__end_), _VSTD::forward<_Up>(__x));
	__v.__end_++;
	__swap_out_circular_buffer(__v);
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	vector<_Tp, _Allocator>::push_back(const_reference __x)
	{
	if (this->__end_ != this->__end_cap())
	{
	__RAII_IncreaseAnnotator __annotator(*this);
	__alloc_traits::construct(this->__alloc(),
	_VSTD::__to_raw_pointer(this->__end_), __x);
	__annotator.__done();
	++this->__end_;
	}
	else
	__push_back_slow_path(__x);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	vector<_Tp, _Allocator>::push_back(value_type&& __x)
	{
	if (this->__end_ < this->__end_cap())
	{
	__RAII_IncreaseAnnotator __annotator(*this);
	__alloc_traits::construct(this->__alloc(),
	_VSTD::__to_raw_pointer(this->__end_),
	_VSTD::move(__x));
	__annotator.__done();
	++this->__end_;
	}
	else
	__push_back_slow_path(_VSTD::move(__x));
	}

	template <class _Tp, class _Allocator>
	template <class... _Args>
	void
	vector<_Tp, _Allocator>::__emplace_back_slow_path(_Args&&... __args)
	{
	allocator_type& __a = this->__alloc();
	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
	// __v.emplace_back(_VSTD::forward<_Args>(__args)...);
	__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(__v.__end_), _VSTD::forward<_Args>(__args)...);
	__v.__end_++;
	__swap_out_circular_buffer(__v);
	}

	template <class _Tp, class _Allocator>
	template <class... _Args>
	inline
	#if _LIBCPP_STD_VER > 14
	typename vector<_Tp, _Allocator>::reference
	#else
	void
	#endif
	vector<_Tp, _Allocator>::emplace_back(_Args&&... __args)
	{
	if (this->__end_ < this->__end_cap())
	{
	__RAII_IncreaseAnnotator __annotator(*this);
	__alloc_traits::construct(this->__alloc(),
	_VSTD::__to_raw_pointer(this->__end_),
	_VSTD::forward<_Args>(__args)...);
	__annotator.__done();
	++this->__end_;
	}
	else
	__emplace_back_slow_path(_VSTD::forward<_Args>(__args)...);
	#if _LIBCPP_STD_VER > 14
	return this->back();
	#endif
	}

	#endif // !_LIBCPP_CXX03_LANG

	template <class _Tp, class _Allocator>
	inline
	void
	vector<_Tp, _Allocator>::pop_back()
	{
	_LIBCPP_ASSERT(!empty(), "vector::pop_back called for empty vector");
	this->__destruct_at_end(this->__end_ - 1);
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename vector<_Tp, _Allocator>::iterator
	vector<_Tp, _Allocator>::erase(const_iterator __position)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
	"vector::erase(iterator) called with an iterator not"
	" referring to this vector");
	#endif
	_LIBCPP_ASSERT(__position != end(),
	"vector::erase(iterator) called with a non-dereferenceable iterator");
	difference_type __ps = __position - cbegin();
	pointer __p = this->__begin_ + __ps;
	this->__destruct_at_end(_VSTD::move(__p + 1, this->__end_, __p));
	this->__invalidate_iterators_past(__p-1);
	iterator __r = __make_iter(__p);
	return __r;
	}

	template <class _Tp, class _Allocator>
	typename vector<_Tp, _Allocator>::iterator
	vector<_Tp, _Allocator>::erase(const_iterator __first, const_iterator __last)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this,
	"vector::erase(iterator, iterator) called with an iterator not"
	" referring to this vector");
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__last) == this,
	"vector::erase(iterator, iterator) called with an iterator not"
	" referring to this vector");
	#endif
	_LIBCPP_ASSERT(__first <= __last, "vector::erase(first, last) called with invalid range");
	pointer __p = this->__begin_ + (__first - begin());
	if (__first != __last) {
	this->__destruct_at_end(_VSTD::move(__p + (__last - __first), this->__end_, __p));
	this->__invalidate_iterators_past(__p - 1);
	}
	iterator __r = __make_iter(__p);
	return __r;
	}

	template <class _Tp, class _Allocator>
	void
	vector<_Tp, _Allocator>::__move_range(pointer __from_s, pointer __from_e, pointer __to)
	{
	pointer __old_last = this->__end_;
	difference_type __n = __old_last - __to;
	for (pointer __i = __from_s + __n; __i < __from_e; ++__i, ++this->__end_)
	__alloc_traits::construct(this->__alloc(),
	_VSTD::__to_raw_pointer(this->__end_),
	_VSTD::move(*__i));
	_VSTD::move_backward(__from_s, __from_s + __n, __old_last);
	}

	template <class _Tp, class _Allocator>
	typename vector<_Tp, _Allocator>::iterator
	vector<_Tp, _Allocator>::insert(const_iterator __position, const_reference __x)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
	"vector::insert(iterator, x) called with an iterator not"
	" referring to this vector");
	#endif
	pointer __p = this->__begin_ + (__position - begin());
	if (this->__end_ < this->__end_cap())
	{
	__RAII_IncreaseAnnotator __annotator(*this);
	if (__p == this->__end_)
	{
	__alloc_traits::construct(this->__alloc(),
	_VSTD::__to_raw_pointer(this->__end_), __x);
	++this->__end_;
	}
	else
	{
	__move_range(__p, this->__end_, __p + 1);
	const_pointer __xr = pointer_traits<const_pointer>::pointer_to(__x);
	if (__p <= __xr && __xr < this->__end_)
	++__xr;
	__p = __xr;
	}
	__annotator.__done();
	}
	else
	{
	allocator_type& __a = this->__alloc();
	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
	__v.push_back(__x);
	__p = __swap_out_circular_buffer(__v, __p);
	}
	return __make_iter(__p);
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Tp, class _Allocator>
	typename vector<_Tp, _Allocator>::iterator
	vector<_Tp, _Allocator>::insert(const_iterator __position, value_type&& __x)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
	"vector::insert(iterator, x) called with an iterator not"
	" referring to this vector");
	#endif
	pointer __p = this->__begin_ + (__position - begin());
	if (this->__end_ < this->__end_cap())
	{
	__RAII_IncreaseAnnotator __annotator(*this);
	if (__p == this->__end_)
	{
	__alloc_traits::construct(this->__alloc(),
	_VSTD::__to_raw_pointer(this->__end_),
	_VSTD::move(__x));
	++this->__end_;
	}
	else
	{
	__move_range(__p, this->__end_, __p + 1);
	*__p = _VSTD::move(__x);
	}
	__annotator.__done();
	}
	else
	{
	allocator_type& __a = this->__alloc();
	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
	__v.push_back(_VSTD::move(__x));
	__p = __swap_out_circular_buffer(__v, __p);
	}
	return __make_iter(__p);
	}

	template <class _Tp, class _Allocator>
	template <class... _Args>
	typename vector<_Tp, _Allocator>::iterator
	vector<_Tp, _Allocator>::emplace(const_iterator __position, _Args&&... __args)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
	"vector::emplace(iterator, x) called with an iterator not"
	" referring to this vector");
	#endif
	pointer __p = this->__begin_ + (__position - begin());
	if (this->__end_ < this->__end_cap())
	{
	__RAII_IncreaseAnnotator __annotator(*this);
	if (__p == this->__end_)
	{
	__alloc_traits::construct(this->__alloc(),
	_VSTD::__to_raw_pointer(this->__end_),
	_VSTD::forward<_Args>(__args)...);
	++this->__end_;
	}
	else
	{
	__temp_value<value_type, _Allocator> __tmp(this->__alloc(), _VSTD::forward<_Args>(__args)...);
	__move_range(__p, this->__end_, __p + 1);
	*__p = _VSTD::move(__tmp.get());
	}
	__annotator.__done();
	}
	else
	{
	allocator_type& __a = this->__alloc();
	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
	__v.emplace_back(_VSTD::forward<_Args>(__args)...);
	__p = __swap_out_circular_buffer(__v, __p);
	}
	return __make_iter(__p);
	}

	#endif // !_LIBCPP_CXX03_LANG

	template <class _Tp, class _Allocator>
	typename vector<_Tp, _Allocator>::iterator
	vector<_Tp, _Allocator>::insert(const_iterator __position, size_type __n, const_reference __x)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
	"vector::insert(iterator, n, x) called with an iterator not"
	" referring to this vector");
	#endif
	pointer __p = this->__begin_ + (__position - begin());
	if (__n > 0)
	{
	if (__n <= static_cast<size_type>(this->__end_cap() - this->__end_))
	{
	size_type __old_n = __n;
	pointer __old_last = this->__end_;
	if (__n > static_cast<size_type>(this->__end_ - __p))
	{
	size_type __cx = __n - (this->__end_ - __p);
	__construct_at_end(__cx, __x);
	__n -= __cx;
	}
	if (__n > 0)
	{
	__RAII_IncreaseAnnotator __annotator(*this, __n);
	__move_range(__p, __old_last, __p + __old_n);
	__annotator.__done();
	const_pointer __xr = pointer_traits<const_pointer>::pointer_to(__x);
	if (__p <= __xr && __xr < this->__end_)
	__xr += __old_n;
	_VSTD::fill_n(__p, __n, *__xr);
	}
	}
	else
	{
	allocator_type& __a = this->__alloc();
	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), __p - this->__begin_, __a);
	__v.__construct_at_end(__n, __x);
	__p = __swap_out_circular_buffer(__v, __p);
	}
	}
	return __make_iter(__p);
	}

	template <class _Tp, class _Allocator>
	template <class _InputIterator>
	typename enable_if
	<
	__is_input_iterator <_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value &&
	is_constructible<
	_Tp,
	typename iterator_traits<_InputIterator>::reference>::value,
	typename vector<_Tp, _Allocator>::iterator
	>::type
	vector<_Tp, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
	"vector::insert(iterator, range) called with an iterator not"
	" referring to this vector");
	#endif
	difference_type __off = __position - begin();
	pointer __p = this->__begin_ + __off;
	allocator_type& __a = this->__alloc();
	pointer __old_last = this->__end_;
	for (; this->__end_ != this->__end_cap() && __first != __last; ++__first)
	{
	__RAII_IncreaseAnnotator __annotator(*this);
	__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_),
	*__first);
	++this->__end_;
	__annotator.__done();
	}
	__split_buffer<value_type, allocator_type&> __v(__a);
	if (__first != __last)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	__v.__construct_at_end(__first, __last);
	difference_type __old_size = __old_last - this->__begin_;
	difference_type __old_p = __p - this->__begin_;
	reserve(__recommend(size() + __v.size()));
	__p = this->__begin_ + __old_p;
	__old_last = this->__begin_ + __old_size;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	erase(__make_iter(__old_last), end());
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}
	__p = _VSTD::rotate(__p, __old_last, this->__end_);
	insert(__make_iter(__p), make_move_iterator(__v.begin()),
	make_move_iterator(__v.end()));
	return begin() + __off;
	}

	template <class _Tp, class _Allocator>
	template <class _ForwardIterator>
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value &&
	is_constructible<
	_Tp,
	typename iterator_traits<_ForwardIterator>::reference>::value,
	typename vector<_Tp, _Allocator>::iterator
	>::type
	vector<_Tp, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	_LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__position) == this,
	"vector::insert(iterator, range) called with an iterator not"
	" referring to this vector");
	#endif
	pointer __p = this->__begin_ + (__position - begin());
	difference_type __n = _VSTD::distance(__first, __last);
	if (__n > 0)
	{
	if (__n <= this->__end_cap() - this->__end_)
	{
	size_type __old_n = __n;
	pointer __old_last = this->__end_;
	_ForwardIterator __m = __last;
	difference_type __dx = this->__end_ - __p;
	if (__n > __dx)
	{
	__m = __first;
	difference_type __diff = this->__end_ - __p;
	_VSTD::advance(__m, __diff);
	__construct_at_end(__m, __last, __n - __diff);
	__n = __dx;
	}
	if (__n > 0)
	{
	__RAII_IncreaseAnnotator __annotator(*this, __n);
	__move_range(__p, __old_last, __p + __old_n);
	__annotator.__done();
	_VSTD::copy(__first, __m, __p);
	}
	}
	else
	{
	allocator_type& __a = this->__alloc();
	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), __p - this->__begin_, __a);
	__v.__construct_at_end(__first, __last);
	__p = __swap_out_circular_buffer(__v, __p);
	}
	}
	return __make_iter(__p);
	}

	template <class _Tp, class _Allocator>
	void
	vector<_Tp, _Allocator>::resize(size_type __sz)
	{
	size_type __cs = size();
	if (__cs < __sz)
	this->__append(__sz - __cs);
	else if (__cs > __sz)
	this->__destruct_at_end(this->__begin_ + __sz);
	}

	template <class _Tp, class _Allocator>
	void
	vector<_Tp, _Allocator>::resize(size_type __sz, const_reference __x)
	{
	size_type __cs = size();
	if (__cs < __sz)
	this->__append(__sz - __cs, __x);
	else if (__cs > __sz)
	this->__destruct_at_end(this->__begin_ + __sz);
	}

	template <class _Tp, class _Allocator>
	void
	vector<_Tp, _Allocator>::swap(vector& __x)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT_DEBUG
	#else
	_NOEXCEPT_DEBUG_(!__alloc_traits::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<allocator_type>::value)
	#endif
	{
	_LIBCPP_ASSERT(__alloc_traits::propagate_on_container_swap::value \|\|
	this->__alloc() == __x.__alloc(),
	"vector::swap: Either propagate_on_container_swap must be true"
	" or the allocators must compare equal");
	_VSTD::swap(this->__begin_, __x.__begin_);
	_VSTD::swap(this->__end_, __x.__end_);
	_VSTD::swap(this->__end_cap(), __x.__end_cap());
	__swap_allocator(this->__alloc(), __x.__alloc(),
	integral_constant<bool,__alloc_traits::propagate_on_container_swap::value>());
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->swap(this, &__x);
	#endif // _LIBCPP_DEBUG_LEVEL >= 2
	}

	template <class _Tp, class _Allocator>
	bool
	vector<_Tp, _Allocator>::__invariants() const
	{
	if (this->__begin_ == nullptr)
	{
	if (this->__end_ != nullptr \|\| this->__end_cap() != nullptr)
	return false;
	}
	else
	{
	if (this->__begin_ > this->__end_)
	return false;
	if (this->__begin_ == this->__end_cap())
	return false;
	if (this->__end_ > this->__end_cap())
	return false;
	}
	return true;
	}

	#if _LIBCPP_DEBUG_LEVEL >= 2

	template <class _Tp, class _Allocator>
	bool
	vector<_Tp, _Allocator>::__dereferenceable(const const_iterator* __i) const
	{
	return this->__begin_ <= __i->base() && __i->base() < this->__end_;
	}

	template <class _Tp, class _Allocator>
	bool
	vector<_Tp, _Allocator>::__decrementable(const const_iterator* __i) const
	{
	return this->__begin_ < __i->base() && __i->base() <= this->__end_;
	}

	template <class _Tp, class _Allocator>
	bool
	vector<_Tp, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const
	{
	const_pointer __p = __i->base() + __n;
	return this->__begin_ <= __p && __p <= this->__end_;
	}

	template <class _Tp, class _Allocator>
	bool
	vector<_Tp, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const
	{
	const_pointer __p = __i->base() + __n;
	return this->__begin_ <= __p && __p < this->__end_;
	}

	#endif // _LIBCPP_DEBUG_LEVEL >= 2

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	vector<_Tp, _Allocator>::__invalidate_all_iterators()
	{
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__get_db()->__invalidate_all(this);
	#endif // _LIBCPP_DEBUG_LEVEL >= 2
	}


	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	vector<_Tp, _Allocator>::__invalidate_iterators_past(pointer __new_last) {
	#if _LIBCPP_DEBUG_LEVEL >= 2
	__c_node* __c = __get_db()->__find_c_and_lock(this);
	for (__i_node** __p = __c->end_; __p != __c->beg_; ) {
	--__p;
	const_iterator* __i = static_cast<const_iterator>((__p)->__i_);
	if (__i->base() > __new_last) {
	(*__p)->__c_ = nullptr;
	if (--__c->end_ != __p)
	memmove(__p, __p+1, (__c->end_ - __p)sizeof(__i_node));
	}
	}
	__get_db()->unlock();
	#else
	((void)__new_last);
	#endif
	}

	// vector<bool>

	template <class _Allocator> class vector<bool, _Allocator>;

	template <class _Allocator> struct hash<vector<bool, _Allocator> >;

	template <class _Allocator>
	struct __has_storage_type<vector<bool, _Allocator> >
	{
	static const bool value = true;
	};

	template <class _Allocator>
	class _LIBCPP_TEMPLATE_VIS vector<bool, _Allocator>
	: private __vector_base_common<true>
	{
	public:
	typedef vector __self;
	typedef bool value_type;
	typedef _Allocator allocator_type;
	typedef allocator_traits<allocator_type> __alloc_traits;
	typedef typename __alloc_traits::size_type size_type;
	typedef typename __alloc_traits::difference_type difference_type;
	typedef size_type __storage_type;
	typedef __bit_iterator<vector, false> pointer;
	typedef __bit_iterator<vector, true> const_pointer;
	typedef pointer iterator;
	typedef const_pointer const_iterator;
	typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
	typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;

	private:
	typedef typename __rebind_alloc_helper<__alloc_traits, __storage_type>::type __storage_allocator;
	typedef allocator_traits<__storage_allocator> __storage_traits;
	typedef typename __storage_traits::pointer __storage_pointer;
	typedef typename __storage_traits::const_pointer __const_storage_pointer;

	__storage_pointer __begin_;
	size_type __size_;
	__compressed_pair<size_type, __storage_allocator> __cap_alloc_;
	public:
	typedef __bit_reference<vector> reference;
	typedef __bit_const_reference<vector> const_reference;
	private:
	_LIBCPP_INLINE_VISIBILITY
	size_type& __cap() _NOEXCEPT
	{return __cap_alloc_.first();}
	_LIBCPP_INLINE_VISIBILITY
	const size_type& __cap() const _NOEXCEPT
	{return __cap_alloc_.first();}
	_LIBCPP_INLINE_VISIBILITY
	__storage_allocator& __alloc() _NOEXCEPT
	{return __cap_alloc_.second();}
	_LIBCPP_INLINE_VISIBILITY
	const __storage_allocator& __alloc() const _NOEXCEPT
	{return __cap_alloc_.second();}

	static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);

	_LIBCPP_INLINE_VISIBILITY
	static size_type __internal_cap_to_external(size_type __n) _NOEXCEPT
	{return __n * __bits_per_word;}
	_LIBCPP_INLINE_VISIBILITY
	static size_type __external_cap_to_internal(size_type __n) _NOEXCEPT
	{return (__n - 1) / __bits_per_word + 1;}

	public:
	_LIBCPP_INLINE_VISIBILITY
	vector() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);

	_LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a)
	#if _LIBCPP_STD_VER <= 14
	_NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value);
	#else
	_NOEXCEPT;
	#endif
	~vector();
	explicit vector(size_type __n);
	#if _LIBCPP_STD_VER > 11
	explicit vector(size_type __n, const allocator_type& __a);
	#endif
	vector(size_type __n, const value_type& __v);
	vector(size_type __n, const value_type& __v, const allocator_type& __a);
	template <class _InputIterator>
	vector(_InputIterator __first, _InputIterator __last,
	typename enable_if<__is_input_iterator <_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value>::type* = 0);
	template <class _InputIterator>
	vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
	typename enable_if<__is_input_iterator <_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value>::type* = 0);
	template <class _ForwardIterator>
	vector(_ForwardIterator __first, _ForwardIterator __last,
	typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type* = 0);
	template <class _ForwardIterator>
	vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
	typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type* = 0);

	vector(const vector& __v);
	vector(const vector& __v, const allocator_type& __a);
	vector& operator=(const vector& __v);

	#ifndef _LIBCPP_CXX03_LANG
	vector(initializer_list<value_type> __il);
	vector(initializer_list<value_type> __il, const allocator_type& __a);

	_LIBCPP_INLINE_VISIBILITY
	vector(vector&& __v)
	#if _LIBCPP_STD_VER > 14
	_NOEXCEPT;
	#else
	_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
	#endif
	vector(vector&& __v, const allocator_type& __a);
	_LIBCPP_INLINE_VISIBILITY
	vector& operator=(vector&& __v)
	_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));

	_LIBCPP_INLINE_VISIBILITY
	vector& operator=(initializer_list<value_type> __il)
	{assign(__il.begin(), __il.end()); return *this;}

	#endif // !_LIBCPP_CXX03_LANG

	template <class _InputIterator>
	typename enable_if
	<
	__is_input_iterator<_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value,
	void
	>::type
	assign(_InputIterator __first, _InputIterator __last);
	template <class _ForwardIterator>
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value,
	void
	>::type
	assign(_ForwardIterator __first, _ForwardIterator __last);

	void assign(size_type __n, const value_type& __x);

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	void assign(initializer_list<value_type> __il)
	{assign(__il.begin(), __il.end());}
	#endif

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

	size_type max_size() const _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	size_type capacity() const _NOEXCEPT
	{return __internal_cap_to_external(__cap());}
	_LIBCPP_INLINE_VISIBILITY
	size_type size() const _NOEXCEPT
	{return __size_;}
	_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
	bool empty() const _NOEXCEPT
	{return __size_ == 0;}
	void reserve(size_type __n);
	void shrink_to_fit() _NOEXCEPT;

	_LIBCPP_INLINE_VISIBILITY
	iterator begin() _NOEXCEPT
	{return __make_iter(0);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator begin() const _NOEXCEPT
	{return __make_iter(0);}
	_LIBCPP_INLINE_VISIBILITY
	iterator end() _NOEXCEPT
	{return __make_iter(__size_);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator end() const _NOEXCEPT
	{return __make_iter(__size_);}

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

	_LIBCPP_INLINE_VISIBILITY
	const_iterator cbegin() const _NOEXCEPT
	{return __make_iter(0);}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator cend() const _NOEXCEPT
	{return __make_iter(__size_);}
	_LIBCPP_INLINE_VISIBILITY
	const_reverse_iterator crbegin() const _NOEXCEPT
	{return rbegin();}
	_LIBCPP_INLINE_VISIBILITY
	const_reverse_iterator crend() const _NOEXCEPT
	{return rend();}

	_LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n) {return __make_ref(__n);}
	_LIBCPP_INLINE_VISIBILITY const_reference operator[](size_type __n) const {return __make_ref(__n);}
	reference at(size_type __n);
	const_reference at(size_type __n) const;

	_LIBCPP_INLINE_VISIBILITY reference front() {return __make_ref(0);}
	_LIBCPP_INLINE_VISIBILITY const_reference front() const {return __make_ref(0);}
	_LIBCPP_INLINE_VISIBILITY reference back() {return __make_ref(__size_ - 1);}
	_LIBCPP_INLINE_VISIBILITY const_reference back() const {return __make_ref(__size_ - 1);}

	void push_back(const value_type& __x);
	#if _LIBCPP_STD_VER > 11
	template <class... _Args>
	#if _LIBCPP_STD_VER > 14
	_LIBCPP_INLINE_VISIBILITY reference emplace_back(_Args&&... __args)
	#else
	_LIBCPP_INLINE_VISIBILITY void emplace_back(_Args&&... __args)
	#endif
	{
	push_back ( value_type ( _VSTD::forward<_Args>(__args)... ));
	#if _LIBCPP_STD_VER > 14
	return this->back();
	#endif
	}
	#endif

	_LIBCPP_INLINE_VISIBILITY void pop_back() {--__size_;}

	#if _LIBCPP_STD_VER > 11
	template <class... _Args>
	_LIBCPP_INLINE_VISIBILITY iterator emplace(const_iterator position, _Args&&... __args)
	{ return insert ( position, value_type ( _VSTD::forward<_Args>(__args)... )); }
	#endif

	iterator insert(const_iterator __position, const value_type& __x);
	iterator insert(const_iterator __position, size_type __n, const value_type& __x);
	iterator insert(const_iterator __position, size_type __n, const_reference __x);
	template <class _InputIterator>
	typename enable_if
	<
	__is_input_iterator <_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value,
	iterator
	>::type
	insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
	template <class _ForwardIterator>
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value,
	iterator
	>::type
	insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);

	#ifndef _LIBCPP_CXX03_LANG
	_LIBCPP_INLINE_VISIBILITY
	iterator insert(const_iterator __position, initializer_list<value_type> __il)
	{return insert(__position, __il.begin(), __il.end());}
	#endif

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

	_LIBCPP_INLINE_VISIBILITY
	void clear() _NOEXCEPT {__size_ = 0;}

	void swap(vector&)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT;
	#else
	_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<allocator_type>::value);
	#endif
	static void swap(reference __x, reference __y) _NOEXCEPT { _VSTD::swap(__x, __y); }

	void resize(size_type __sz, value_type __x = false);
	void flip() _NOEXCEPT;

	bool __invariants() const;

	private:
	_LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
	- void allocate(size_type __n);
	- void deallocate() _NOEXCEPT;
	+ void __vallocate(size_type __n);
	+ void __vdeallocate() _NOEXCEPT;
	_LIBCPP_INLINE_VISIBILITY
	static size_type __align_it(size_type __new_size) _NOEXCEPT
	{return __new_size + (__bits_per_word-1) & ~((size_type)__bits_per_word-1);};
	_LIBCPP_INLINE_VISIBILITY size_type __recommend(size_type __new_size) const;
	_LIBCPP_INLINE_VISIBILITY void __construct_at_end(size_type __n, bool __x);
	template <class _ForwardIterator>
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value,
	void
	>::type
	__construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
	void __append(size_type __n, const_reference __x);
	_LIBCPP_INLINE_VISIBILITY
	reference __make_ref(size_type __pos) _NOEXCEPT
	{return reference(__begin_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
	_LIBCPP_INLINE_VISIBILITY
	const_reference __make_ref(size_type __pos) const _NOEXCEPT
	{return const_reference(__begin_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
	_LIBCPP_INLINE_VISIBILITY
	iterator __make_iter(size_type __pos) _NOEXCEPT
	{return iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));}
	_LIBCPP_INLINE_VISIBILITY
	const_iterator __make_iter(size_type __pos) const _NOEXCEPT
	{return const_iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));}
	_LIBCPP_INLINE_VISIBILITY
	iterator __const_iterator_cast(const_iterator __p) _NOEXCEPT
	{return begin() + (__p - cbegin());}

	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const vector& __v)
	{__copy_assign_alloc(__v, integral_constant<bool,
	__storage_traits::propagate_on_container_copy_assignment::value>());}
	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const vector& __c, true_type)
	{
	if (__alloc() != __c.__alloc())
	- deallocate();
	+ __vdeallocate();
	__alloc() = __c.__alloc();
	}

	_LIBCPP_INLINE_VISIBILITY
	void __copy_assign_alloc(const vector&, false_type)
	{}

	void __move_assign(vector& __c, false_type);
	void __move_assign(vector& __c, true_type)
	_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
	_LIBCPP_INLINE_VISIBILITY
	void __move_assign_alloc(vector& __c)
	_NOEXCEPT_(
	!__storage_traits::propagate_on_container_move_assignment::value \|\|
	is_nothrow_move_assignable<allocator_type>::value)
	{__move_assign_alloc(__c, integral_constant<bool,
	__storage_traits::propagate_on_container_move_assignment::value>());}
	_LIBCPP_INLINE_VISIBILITY
	void __move_assign_alloc(vector& __c, true_type)
	_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
	{
	__alloc() = _VSTD::move(__c.__alloc());
	}

	_LIBCPP_INLINE_VISIBILITY
	void __move_assign_alloc(vector&, false_type)
	_NOEXCEPT
	{}

	size_t __hash_code() const _NOEXCEPT;

	friend class __bit_reference<vector>;
	friend class __bit_const_reference<vector>;
	friend class __bit_iterator<vector, false>;
	friend class __bit_iterator<vector, true>;
	friend struct __bit_array<vector>;
	friend struct _LIBCPP_TEMPLATE_VIS hash<vector>;
	};

	template <class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	vector<bool, _Allocator>::__invalidate_all_iterators()
	{
	}

	// Allocate space for __n objects
	// throws length_error if __n > max_size()
	// throws (probably bad_alloc) if memory run out
	// Precondition: __begin_ == __end_ == __cap() == 0
	// Precondition: __n > 0
	// Postcondition: capacity() == __n
	// Postcondition: size() == 0
	template <class _Allocator>
	void
	-vector<bool, _Allocator>::allocate(size_type __n)
	+vector<bool, _Allocator>::__vallocate(size_type __n)
	{
	if (__n > max_size())
	this->__throw_length_error();
	__n = __external_cap_to_internal(__n);
	this->__begin_ = __storage_traits::allocate(this->__alloc(), __n);
	this->__size_ = 0;
	this->__cap() = __n;
	}

	template <class _Allocator>
	void
	-vector<bool, _Allocator>::deallocate() _NOEXCEPT
	+vector<bool, _Allocator>::__vdeallocate() _NOEXCEPT
	{
	if (this->__begin_ != nullptr)
	{
	__storage_traits::deallocate(this->__alloc(), this->__begin_, __cap());
	__invalidate_all_iterators();
	this->__begin_ = nullptr;
	this->__size_ = this->__cap() = 0;
	}
	}

	template <class _Allocator>
	typename vector<bool, _Allocator>::size_type
	vector<bool, _Allocator>::max_size() const _NOEXCEPT
	{
	size_type __amax = __storage_traits::max_size(__alloc());
	size_type __nmax = numeric_limits<size_type>::max() / 2; // end() >= begin(), always
	if (__nmax / __bits_per_word <= __amax)
	return __nmax;
	return __internal_cap_to_external(__amax);
	}

	// Precondition: __new_size > capacity()
	template <class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename vector<bool, _Allocator>::size_type
	vector<bool, _Allocator>::__recommend(size_type __new_size) const
	{
	const size_type __ms = max_size();
	if (__new_size > __ms)
	this->__throw_length_error();
	const size_type __cap = capacity();
	if (__cap >= __ms / 2)
	return __ms;
	return _VSTD::max(2*__cap, __align_it(__new_size));
	}

	// Default constructs __n objects starting at __end_
	// Precondition: __n > 0
	// Precondition: size() + __n <= capacity()
	// Postcondition: size() == size() + __n
	template <class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	vector<bool, _Allocator>::__construct_at_end(size_type __n, bool __x)
	{
	size_type __old_size = this->__size_;
	this->__size_ += __n;
	_VSTD::fill_n(__make_iter(__old_size), __n, __x);
	}

	template <class _Allocator>
	template <class _ForwardIterator>
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value,
	void
	>::type
	vector<bool, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last)
	{
	size_type __old_size = this->__size_;
	this->__size_ += _VSTD::distance(__first, __last);
	_VSTD::copy(__first, __last, __make_iter(__old_size));
	}

	template <class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	vector<bool, _Allocator>::vector()
	_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
	: __begin_(nullptr),
	__size_(0),
	__cap_alloc_(0)
	{
	}

	template <class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	vector<bool, _Allocator>::vector(const allocator_type& __a)
	#if _LIBCPP_STD_VER <= 14
	_NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
	#else
	_NOEXCEPT
	#endif
	: __begin_(nullptr),
	__size_(0),
	__cap_alloc_(0, static_cast<__storage_allocator>(__a))
	{
	}

	template <class _Allocator>
	vector<bool, _Allocator>::vector(size_type __n)
	: __begin_(nullptr),
	__size_(0),
	__cap_alloc_(0)
	{
	if (__n > 0)
	{
	- allocate(__n);
	+ __vallocate(__n);
	__construct_at_end(__n, false);
	}
	}

	#if _LIBCPP_STD_VER > 11
	template <class _Allocator>
	vector<bool, _Allocator>::vector(size_type __n, const allocator_type& __a)
	: __begin_(nullptr),
	__size_(0),
	__cap_alloc_(0, static_cast<__storage_allocator>(__a))
	{
	if (__n > 0)
	{
	- allocate(__n);
	+ __vallocate(__n);
	__construct_at_end(__n, false);
	}
	}
	#endif

	template <class _Allocator>
	vector<bool, _Allocator>::vector(size_type __n, const value_type& __x)
	: __begin_(nullptr),
	__size_(0),
	__cap_alloc_(0)
	{
	if (__n > 0)
	{
	- allocate(__n);
	+ __vallocate(__n);
	__construct_at_end(__n, __x);
	}
	}

	template <class _Allocator>
	vector<bool, _Allocator>::vector(size_type __n, const value_type& __x, const allocator_type& __a)
	: __begin_(nullptr),
	__size_(0),
	__cap_alloc_(0, static_cast<__storage_allocator>(__a))
	{
	if (__n > 0)
	{
	- allocate(__n);
	+ __vallocate(__n);
	__construct_at_end(__n, __x);
	}
	}

	template <class _Allocator>
	template <class _InputIterator>
	vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last,
	typename enable_if<__is_input_iterator <_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value>::type*)
	: __begin_(nullptr),
	__size_(0),
	__cap_alloc_(0)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (; __first != __last; ++__first)
	push_back(*__first);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	if (__begin_ != nullptr)
	__storage_traits::deallocate(__alloc(), __begin_, __cap());
	__invalidate_all_iterators();
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	template <class _Allocator>
	template <class _InputIterator>
	vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
	typename enable_if<__is_input_iterator <_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value>::type*)
	: __begin_(nullptr),
	__size_(0),
	__cap_alloc_(0, static_cast<__storage_allocator>(__a))
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	for (; __first != __last; ++__first)
	push_back(*__first);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	if (__begin_ != nullptr)
	__storage_traits::deallocate(__alloc(), __begin_, __cap());
	__invalidate_all_iterators();
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	template <class _Allocator>
	template <class _ForwardIterator>
	vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last,
	typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type*)
	: __begin_(nullptr),
	__size_(0),
	__cap_alloc_(0)
	{
	size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
	if (__n > 0)
	{
	- allocate(__n);
	+ __vallocate(__n);
	__construct_at_end(__first, __last);
	}
	}

	template <class _Allocator>
	template <class _ForwardIterator>
	vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
	typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type*)
	: __begin_(nullptr),
	__size_(0),
	__cap_alloc_(0, static_cast<__storage_allocator>(__a))
	{
	size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
	if (__n > 0)
	{
	- allocate(__n);
	+ __vallocate(__n);
	__construct_at_end(__first, __last);
	}
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Allocator>
	vector<bool, _Allocator>::vector(initializer_list<value_type> __il)
	: __begin_(nullptr),
	__size_(0),
	__cap_alloc_(0)
	{
	size_type __n = static_cast<size_type>(__il.size());
	if (__n > 0)
	{
	- allocate(__n);
	+ __vallocate(__n);
	__construct_at_end(__il.begin(), __il.end());
	}
	}

	template <class _Allocator>
	vector<bool, _Allocator>::vector(initializer_list<value_type> __il, const allocator_type& __a)
	: __begin_(nullptr),
	__size_(0),
	__cap_alloc_(0, static_cast<__storage_allocator>(__a))
	{
	size_type __n = static_cast<size_type>(__il.size());
	if (__n > 0)
	{
	- allocate(__n);
	+ __vallocate(__n);
	__construct_at_end(__il.begin(), __il.end());
	}
	}

	#endif // _LIBCPP_CXX03_LANG

	template <class _Allocator>
	vector<bool, _Allocator>::~vector()
	{
	if (__begin_ != nullptr)
	__storage_traits::deallocate(__alloc(), __begin_, __cap());
	__invalidate_all_iterators();
	}

	template <class _Allocator>
	vector<bool, _Allocator>::vector(const vector& __v)
	: __begin_(nullptr),
	__size_(0),
	__cap_alloc_(0, __storage_traits::select_on_container_copy_construction(__v.__alloc()))
	{
	if (__v.size() > 0)
	{
	- allocate(__v.size());
	+ __vallocate(__v.size());
	__construct_at_end(__v.begin(), __v.end());
	}
	}

	template <class _Allocator>
	vector<bool, _Allocator>::vector(const vector& __v, const allocator_type& __a)
	: __begin_(nullptr),
	__size_(0),
	__cap_alloc_(0, __a)
	{
	if (__v.size() > 0)
	{
	- allocate(__v.size());
	+ __vallocate(__v.size());
	__construct_at_end(__v.begin(), __v.end());
	}
	}

	template <class _Allocator>
	vector<bool, _Allocator>&
	vector<bool, _Allocator>::operator=(const vector& __v)
	{
	if (this != &__v)
	{
	__copy_assign_alloc(__v);
	if (__v.__size_)
	{
	if (__v.__size_ > capacity())
	{
	- deallocate();
	- allocate(__v.__size_);
	+ __vdeallocate();
	+ __vallocate(__v.__size_);
	}
	_VSTD::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.__size_), __begin_);
	}
	__size_ = __v.__size_;
	}
	return *this;
	}

	#ifndef _LIBCPP_CXX03_LANG

	template <class _Allocator>
	-inline _LIBCPP_INLINE_VISIBILITY
	-vector<bool, _Allocator>::vector(vector&& __v)
	+inline _LIBCPP_INLINE_VISIBILITY vector<bool, _Allocator>::vector(vector&& __v)
	#if _LIBCPP_STD_VER > 14
	- _NOEXCEPT
	+ _NOEXCEPT
	#else
	- _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
	+ _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
	#endif
	: __begin_(__v.__begin_),
	__size_(__v.__size_),
	- __cap_alloc_(__v.__cap_alloc_)
	-{
	+ __cap_alloc_(std::move(__v.__cap_alloc_)) {
	__v.__begin_ = nullptr;
	__v.__size_ = 0;
	__v.__cap() = 0;
	}

	template <class _Allocator>
	vector<bool, _Allocator>::vector(vector&& __v, const allocator_type& __a)
	: __begin_(nullptr),
	__size_(0),
	__cap_alloc_(0, __a)
	{
	if (__a == allocator_type(__v.__alloc()))
	{
	this->__begin_ = __v.__begin_;
	this->__size_ = __v.__size_;
	this->__cap() = __v.__cap();
	__v.__begin_ = nullptr;
	__v.__cap() = __v.__size_ = 0;
	}
	else if (__v.size() > 0)
	{
	- allocate(__v.size());
	+ __vallocate(__v.size());
	__construct_at_end(__v.begin(), __v.end());
	}
	}

	template <class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	vector<bool, _Allocator>&
	vector<bool, _Allocator>::operator=(vector&& __v)
	_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
	{
	__move_assign(__v, integral_constant<bool,
	__storage_traits::propagate_on_container_move_assignment::value>());
	return *this;
	}

	template <class _Allocator>
	void
	vector<bool, _Allocator>::__move_assign(vector& __c, false_type)
	{
	if (__alloc() != __c.__alloc())
	assign(__c.begin(), __c.end());
	else
	__move_assign(__c, true_type());
	}

	template <class _Allocator>
	void
	vector<bool, _Allocator>::__move_assign(vector& __c, true_type)
	_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
	{
	- deallocate();
	+ __vdeallocate();
	__move_assign_alloc(__c);
	this->__begin_ = __c.__begin_;
	this->__size_ = __c.__size_;
	this->__cap() = __c.__cap();
	__c.__begin_ = nullptr;
	__c.__cap() = __c.__size_ = 0;
	}

	#endif // !_LIBCPP_CXX03_LANG

	template <class _Allocator>
	void
	vector<bool, _Allocator>::assign(size_type __n, const value_type& __x)
	{
	__size_ = 0;
	if (__n > 0)
	{
	size_type __c = capacity();
	if (__n <= __c)
	__size_ = __n;
	else
	{
	vector __v(__alloc());
	__v.reserve(__recommend(__n));
	__v.__size_ = __n;
	swap(__v);
	}
	_VSTD::fill_n(begin(), __n, __x);
	}
	__invalidate_all_iterators();
	}

	template <class _Allocator>
	template <class _InputIterator>
	typename enable_if
	<
	__is_input_iterator<_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value,
	void
	>::type
	vector<bool, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
	{
	clear();
	for (; __first != __last; ++__first)
	push_back(*__first);
	}

	template <class _Allocator>
	template <class _ForwardIterator>
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value,
	void
	>::type
	vector<bool, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
	{
	clear();
	difference_type __ns = _VSTD::distance(__first, __last);
	_LIBCPP_ASSERT(__ns >= 0, "invalid range specified");
	const size_t __n = static_cast<size_type>(__ns);
	if (__n)
	{
	if (__n > capacity())
	{
	- deallocate();
	- allocate(__n);
	+ __vdeallocate();
	+ __vallocate(__n);
	}
	__construct_at_end(__first, __last);
	}
	}

	template <class _Allocator>
	void
	vector<bool, _Allocator>::reserve(size_type __n)
	{
	if (__n > capacity())
	{
	vector __v(this->__alloc());
	- __v.allocate(__n);
	+ __v.__vallocate(__n);
	__v.__construct_at_end(this->begin(), this->end());
	swap(__v);
	__invalidate_all_iterators();
	}
	}

	template <class _Allocator>
	void
	vector<bool, _Allocator>::shrink_to_fit() _NOEXCEPT
	{
	if (__external_cap_to_internal(size()) > __cap())
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	vector(this, allocator_type(__alloc())).swap(this);
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}
	}

	template <class _Allocator>
	typename vector<bool, _Allocator>::reference
	vector<bool, _Allocator>::at(size_type __n)
	{
	if (__n >= size())
	this->__throw_out_of_range();
	return (*this)[__n];
	}

	template <class _Allocator>
	typename vector<bool, _Allocator>::const_reference
	vector<bool, _Allocator>::at(size_type __n) const
	{
	if (__n >= size())
	this->__throw_out_of_range();
	return (*this)[__n];
	}

	template <class _Allocator>
	void
	vector<bool, _Allocator>::push_back(const value_type& __x)
	{
	if (this->__size_ == this->capacity())
	reserve(__recommend(this->__size_ + 1));
	++this->__size_;
	back() = __x;
	}

	template <class _Allocator>
	typename vector<bool, _Allocator>::iterator
	vector<bool, _Allocator>::insert(const_iterator __position, const value_type& __x)
	{
	iterator __r;
	if (size() < capacity())
	{
	const_iterator __old_end = end();
	++__size_;
	_VSTD::copy_backward(__position, __old_end, end());
	__r = __const_iterator_cast(__position);
	}
	else
	{
	vector __v(__alloc());
	__v.reserve(__recommend(__size_ + 1));
	__v.__size_ = __size_ + 1;
	__r = _VSTD::copy(cbegin(), __position, __v.begin());
	_VSTD::copy_backward(__position, cend(), __v.end());
	swap(__v);
	}
	*__r = __x;
	return __r;
	}

	template <class _Allocator>
	typename vector<bool, _Allocator>::iterator
	vector<bool, _Allocator>::insert(const_iterator __position, size_type __n, const value_type& __x)
	{
	iterator __r;
	size_type __c = capacity();
	if (__n <= __c && size() <= __c - __n)
	{
	const_iterator __old_end = end();
	__size_ += __n;
	_VSTD::copy_backward(__position, __old_end, end());
	__r = __const_iterator_cast(__position);
	}
	else
	{
	vector __v(__alloc());
	__v.reserve(__recommend(__size_ + __n));
	__v.__size_ = __size_ + __n;
	__r = _VSTD::copy(cbegin(), __position, __v.begin());
	_VSTD::copy_backward(__position, cend(), __v.end());
	swap(__v);
	}
	_VSTD::fill_n(__r, __n, __x);
	return __r;
	}

	template <class _Allocator>
	template <class _InputIterator>
	typename enable_if
	<
	__is_input_iterator <_InputIterator>::value &&
	!__is_forward_iterator<_InputIterator>::value,
	typename vector<bool, _Allocator>::iterator
	>::type
	vector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
	{
	difference_type __off = __position - begin();
	iterator __p = __const_iterator_cast(__position);
	iterator __old_end = end();
	for (; size() != capacity() && __first != __last; ++__first)
	{
	++this->__size_;
	back() = *__first;
	}
	vector __v(__alloc());
	if (__first != __last)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	__v.assign(__first, __last);
	difference_type __old_size = static_cast<difference_type>(__old_end - begin());
	difference_type __old_p = __p - begin();
	reserve(__recommend(size() + __v.size()));
	__p = begin() + __old_p;
	__old_end = begin() + __old_size;
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	erase(__old_end, end());
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}
	__p = _VSTD::rotate(__p, __old_end, end());
	insert(__p, __v.begin(), __v.end());
	return begin() + __off;
	}

	template <class _Allocator>
	template <class _ForwardIterator>
	typename enable_if
	<
	__is_forward_iterator<_ForwardIterator>::value,
	typename vector<bool, _Allocator>::iterator
	>::type
	vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
	{
	const difference_type __n_signed = _VSTD::distance(__first, __last);
	_LIBCPP_ASSERT(__n_signed >= 0, "invalid range specified");
	const size_type __n = static_cast<size_type>(__n_signed);
	iterator __r;
	size_type __c = capacity();
	if (__n <= __c && size() <= __c - __n)
	{
	const_iterator __old_end = end();
	__size_ += __n;
	_VSTD::copy_backward(__position, __old_end, end());
	__r = __const_iterator_cast(__position);
	}
	else
	{
	vector __v(__alloc());
	__v.reserve(__recommend(__size_ + __n));
	__v.__size_ = __size_ + __n;
	__r = _VSTD::copy(cbegin(), __position, __v.begin());
	_VSTD::copy_backward(__position, cend(), __v.end());
	swap(__v);
	}
	_VSTD::copy(__first, __last, __r);
	return __r;
	}

	template <class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	typename vector<bool, _Allocator>::iterator
	vector<bool, _Allocator>::erase(const_iterator __position)
	{
	iterator __r = __const_iterator_cast(__position);
	_VSTD::copy(__position + 1, this->cend(), __r);
	--__size_;
	return __r;
	}

	template <class _Allocator>
	typename vector<bool, _Allocator>::iterator
	vector<bool, _Allocator>::erase(const_iterator __first, const_iterator __last)
	{
	iterator __r = __const_iterator_cast(__first);
	difference_type __d = __last - __first;
	_VSTD::copy(__last, this->cend(), __r);
	__size_ -= __d;
	return __r;
	}

	template <class _Allocator>
	void
	vector<bool, _Allocator>::swap(vector& __x)
	#if _LIBCPP_STD_VER >= 14
	_NOEXCEPT
	#else
	_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value \|\|
	__is_nothrow_swappable<allocator_type>::value)
	#endif
	{
	_VSTD::swap(this->__begin_, __x.__begin_);
	_VSTD::swap(this->__size_, __x.__size_);
	_VSTD::swap(this->__cap(), __x.__cap());
	__swap_allocator(this->__alloc(), __x.__alloc(),
	integral_constant<bool, __alloc_traits::propagate_on_container_swap::value>());
	}

	template <class _Allocator>
	void
	vector<bool, _Allocator>::resize(size_type __sz, value_type __x)
	{
	size_type __cs = size();
	if (__cs < __sz)
	{
	iterator __r;
	size_type __c = capacity();
	size_type __n = __sz - __cs;
	if (__n <= __c && __cs <= __c - __n)
	{
	__r = end();
	__size_ += __n;
	}
	else
	{
	vector __v(__alloc());
	__v.reserve(__recommend(__size_ + __n));
	__v.__size_ = __size_ + __n;
	__r = _VSTD::copy(cbegin(), cend(), __v.begin());
	swap(__v);
	}
	_VSTD::fill_n(__r, __n, __x);
	}
	else
	__size_ = __sz;
	}

	template <class _Allocator>
	void
	vector<bool, _Allocator>::flip() _NOEXCEPT
	{
	// do middle whole words
	size_type __n = __size_;
	__storage_pointer __p = __begin_;
	for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
	__p = ~__p;
	// do last partial word
	if (__n > 0)
	{
	__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
	__storage_type __b = *__p & __m;
	*__p &= ~__m;
	*__p \|= ~__b & __m;
	}
	}

	template <class _Allocator>
	bool
	vector<bool, _Allocator>::__invariants() const
	{
	if (this->__begin_ == nullptr)
	{
	if (this->__size_ != 0 \|\| this->__cap() != 0)
	return false;
	}
	else
	{
	if (this->__cap() == 0)
	return false;
	if (this->__size_ > this->capacity())
	return false;
	}
	return true;
	}

	template <class _Allocator>
	size_t
	vector<bool, _Allocator>::__hash_code() const _NOEXCEPT
	{
	size_t __h = 0;
	// do middle whole words
	size_type __n = __size_;
	__storage_pointer __p = __begin_;
	for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
	__h ^= *__p;
	// do last partial word
	if (__n > 0)
	{
	const __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
	__h ^= *__p & __m;
	}
	return __h;
	}

	template <class _Allocator>
	struct _LIBCPP_TEMPLATE_VIS hash<vector<bool, _Allocator> >
	: public unary_function<vector<bool, _Allocator>, size_t>
	{
	_LIBCPP_INLINE_VISIBILITY
	size_t operator()(const vector<bool, _Allocator>& __vec) const _NOEXCEPT
	{return __vec.__hash_code();}
	};

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator==(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
	{
	const typename vector<_Tp, _Allocator>::size_type __sz = __x.size();
	return __sz == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator!=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
	{
	return !(__x == __y);
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator< (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
	{
	return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator> (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
	{
	return __y < __x;
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator>=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
	{
	return !(__x < __y);
	}

	template <class _Tp, class _Allocator>
	inline _LIBCPP_INLINE_VISIBILITY
	bool
	operator<=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
	{
	return !(__y < __x);
	}

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

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP_VECTOR
	Index: projects/clang700-import/contrib/libc++/include/version
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/version (nonexistent)
	+++ projects/clang700-import/contrib/libc++/include/version (revision 337135)
	@@ -0,0 +1,25 @@
	+// -- C++ --
	+//===--------------------------- version ----------------------------------===//
	+//
	+// 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_VERSIONH
	+#define _LIBCPP_VERSIONH
	+
	+/*
	+ version synopsis
	+
	+*/
	+
	+#include <__config>
	+
	+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	+#pragma GCC system_header
	+#endif
	+
	+#endif // _LIBCPP_VERSIONH
	Index: projects/clang700-import/contrib/libc++/include/wchar.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/wchar.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/wchar.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/include/wchar.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/include/wctype.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/include/wctype.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/include/wctype.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/include/wctype.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/algorithm.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/algorithm.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/algorithm.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/algorithm.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/any.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/any.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/any.cpp (revision 337135)
	@@ -1,23 +1,35 @@
	//===---------------------------- any.cpp ---------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is dual licensed under the MIT and the University of Illinois Open
	// Source Licenses. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include "any"
	-#include "experimental/any"

	namespace std {
	const char* bad_any_cast::what() const _NOEXCEPT {
	return "bad any cast";
	}
	}

	+
	+#include <experimental/__config>
	+
	+// Preserve std::experimental::any_bad_cast for ABI compatibility
	+// Even though it no longer exists in a header file
	_LIBCPP_BEGIN_NAMESPACE_LFTS
	+
	+class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast
	+{
	+public:
	+ virtual const char* what() const _NOEXCEPT;
	+};
	+
	const char* bad_any_cast::what() const _NOEXCEPT {
	return "bad any cast";
	}
	+
	_LIBCPP_END_NAMESPACE_LFTS

	Property changes on: projects/clang700-import/contrib/libc++/src/any.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/bind.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/bind.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/bind.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/bind.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/chrono.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/chrono.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/chrono.cpp (revision 337135)
	@@ -1,237 +1,220 @@
	//===------------------------- chrono.cpp ---------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is dual licensed under the MIT and the University of Illinois Open
	// Source Licenses. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include "chrono"
	#include "cerrno" // errno
	#include "system_error" // __throw_system_error
	#include <time.h> // clock_gettime, CLOCK_MONOTONIC and CLOCK_REALTIME
	+#include "include/apple_availability.h"

	-#if (__APPLE__)
	-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
	-#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101200
	-#define _LIBCXX_USE_CLOCK_GETTIME
	-#endif
	-#elif defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
	-#if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 100000
	-#define _LIBCXX_USE_CLOCK_GETTIME
	-#endif
	-#elif defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__)
	-#if __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 100000
	-#define _LIBCXX_USE_CLOCK_GETTIME
	-#endif
	-#elif defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__)
	-#if __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 30000
	-#define _LIBCXX_USE_CLOCK_GETTIME
	-#endif
	-#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__
	-#else
	-#define _LIBCXX_USE_CLOCK_GETTIME
	+#if !defined(__APPLE__)
	+#define _LIBCPP_USE_CLOCK_GETTIME
	#endif // __APPLE__

	#if defined(_LIBCPP_WIN32API)
	#define WIN32_LEAN_AND_MEAN
	#define VC_EXTRA_LEAN
	#include <windows.h>
	#if _WIN32_WINNT >= _WIN32_WINNT_WIN8
	#include <winapifamily.h>
	#endif
	#else
	-#if !defined(CLOCK_REALTIME) \|\| !defined(_LIBCXX_USE_CLOCK_GETTIME)
	+#if !defined(CLOCK_REALTIME) \|\| !defined(_LIBCPP_USE_CLOCK_GETTIME)
	#include <sys/time.h> // for gettimeofday and timeval
	#endif // !defined(CLOCK_REALTIME)
	#endif // defined(_LIBCPP_WIN32API)

	#if !defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK)
	#if __APPLE__
	#include <mach/mach_time.h> // mach_absolute_time, mach_timebase_info_data_t
	#elif !defined(_LIBCPP_WIN32API) && !defined(CLOCK_MONOTONIC)
	#error "Monotonic clock not implemented"
	#endif
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	namespace chrono
	{

	// system_clock

	const bool system_clock::is_steady;

	system_clock::time_point
	system_clock::now() _NOEXCEPT
	{
	#if defined(_LIBCPP_WIN32API)
	// FILETIME is in 100ns units
	using filetime_duration =
	_VSTD::chrono::duration<__int64,
	_VSTD::ratio_multiply<_VSTD::ratio<100, 1>,
	nanoseconds::period>>;

	// The Windows epoch is Jan 1 1601, the Unix epoch Jan 1 1970.
	static _LIBCPP_CONSTEXPR const seconds nt_to_unix_epoch{11644473600};

	FILETIME ft;
	#if _WIN32_WINNT >= _WIN32_WINNT_WIN8
	#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
	GetSystemTimePreciseAsFileTime(&ft);
	#else
	GetSystemTimeAsFileTime(&ft);
	#endif
	#else
	GetSystemTimeAsFileTime(&ft);
	#endif

	filetime_duration d{(static_cast<__int64>(ft.dwHighDateTime) << 32) \|
	static_cast<__int64>(ft.dwLowDateTime)};
	return time_point(duration_cast<duration>(d - nt_to_unix_epoch));
	#else
	-#if defined(_LIBCXX_USE_CLOCK_GETTIME) && defined(CLOCK_REALTIME)
	- struct timespec tp;
	- if (0 != clock_gettime(CLOCK_REALTIME, &tp))
	- __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
	- return time_point(seconds(tp.tv_sec) + microseconds(tp.tv_nsec / 1000));
	+#if defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_REALTIME)
	+ struct timespec tp;
	+ if (0 != clock_gettime(CLOCK_REALTIME, &tp))
	+ __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
	+ return time_point(seconds(tp.tv_sec) + microseconds(tp.tv_nsec / 1000));
	#else
	timeval tv;
	gettimeofday(&tv, 0);
	return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
	-#endif // _LIBCXX_USE_CLOCK_GETTIME && CLOCK_REALTIME
	+#endif // _LIBCPP_USE_CLOCK_GETTIME && CLOCK_REALTIME
	#endif
	}

	time_t
	system_clock::to_time_t(const time_point& t) _NOEXCEPT
	{
	return time_t(duration_cast<seconds>(t.time_since_epoch()).count());
	}

	system_clock::time_point
	system_clock::from_time_t(time_t t) _NOEXCEPT
	{
	return system_clock::time_point(seconds(t));
	}

	#ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
	// steady_clock
	//
	// Warning: If this is not truly steady, then it is non-conforming. It is
	// better for it to not exist and have the rest of libc++ use system_clock
	// instead.

	const bool steady_clock::is_steady;

	#if defined(__APPLE__)

	// Darwin libc versions >= 1133 provide ns precision via CLOCK_UPTIME_RAW
	-#if defined(_LIBCXX_USE_CLOCK_GETTIME) && defined(CLOCK_UPTIME_RAW)
	+#if defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_UPTIME_RAW)
	steady_clock::time_point
	steady_clock::now() _NOEXCEPT
	{
	struct timespec tp;
	if (0 != clock_gettime(CLOCK_UPTIME_RAW, &tp))
	__throw_system_error(errno, "clock_gettime(CLOCK_UPTIME_RAW) failed");
	return time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
	}

	#else
	// mach_absolute_time() * MachInfo.numer / MachInfo.denom is the number of
	// nanoseconds since the computer booted up. MachInfo.numer and MachInfo.denom
	// are run time constants supplied by the OS. This clock has no relationship
	// to the Gregorian calendar. It's main use is as a high resolution timer.

	// MachInfo.numer / MachInfo.denom is often 1 on the latest equipment. Specialize
	// for that case as an optimization.

	static
	steady_clock::rep
	steady_simplified()
	{
	return static_cast<steady_clock::rep>(mach_absolute_time());
	}

	static
	double
	compute_steady_factor()
	{
	mach_timebase_info_data_t MachInfo;
	mach_timebase_info(&MachInfo);
	return static_cast<double>(MachInfo.numer) / MachInfo.denom;
	}

	static
	steady_clock::rep
	steady_full()
	{
	static const double factor = compute_steady_factor();
	return static_cast<steady_clock::rep>(mach_absolute_time() * factor);
	}

	typedef steady_clock::rep (*FP)();

	static
	FP
	init_steady_clock()
	{
	mach_timebase_info_data_t MachInfo;
	mach_timebase_info(&MachInfo);
	if (MachInfo.numer == MachInfo.denom)
	return &steady_simplified;
	return &steady_full;
	}

	steady_clock::time_point
	steady_clock::now() _NOEXCEPT
	{
	static FP fp = init_steady_clock();
	return time_point(duration(fp()));
	}
	-#endif // defined(_LIBCXX_USE_CLOCK_GETTIME) && defined(CLOCK_UPTIME_RAW)
	+#endif // defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_UPTIME_RAW)

	#elif defined(_LIBCPP_WIN32API)

	steady_clock::time_point
	steady_clock::now() _NOEXCEPT
	{
	static LARGE_INTEGER freq;
	static BOOL initialized = FALSE;
	if (!initialized)
	initialized = QueryPerformanceFrequency(&freq); // always succceeds

	LARGE_INTEGER counter;
	QueryPerformanceCounter(&counter);
	return time_point(duration(counter.QuadPart * nano::den / freq.QuadPart));
	}

	#elif defined(CLOCK_MONOTONIC)

	// On Apple platforms only CLOCK_UPTIME_RAW or mach_absolute_time are able to
	// time functions in the nanosecond range. Thus, they are the only acceptable
	// implementations of steady_clock.
	#ifdef __APPLE__
	#error "Never use CLOCK_MONOTONIC for steady_clock::now on Apple platforms"
	#endif

	steady_clock::time_point
	steady_clock::now() _NOEXCEPT
	{
	struct timespec tp;
	if (0 != clock_gettime(CLOCK_MONOTONIC, &tp))
	__throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC) failed");
	return time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
	}

	#else
	#error "Monotonic clock not implemented"
	#endif

	#endif // !_LIBCPP_HAS_NO_MONOTONIC_CLOCK

	}

	_LIBCPP_END_NAMESPACE_STD

	Property changes on: projects/clang700-import/contrib/libc++/src/chrono.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/condition_variable.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/condition_variable.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/condition_variable.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/condition_variable.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/debug.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/debug.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/debug.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/debug.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/exception.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/exception.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/exception.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/exception.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/experimental/filesystem/path.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/experimental/filesystem/path.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/experimental/filesystem/path.cpp (nonexistent)
	@@ -1,448 +0,0 @@
	-//===--------------------- filesystem/path.cpp ----------------------------===//
	-//
	-// The LLVM Compiler Infrastructure
	-//
	-// This file is dual licensed under the MIT and the University of Illinois Open
	-// Source Licenses. See LICENSE.TXT for details.
	-//
	-//===----------------------------------------------------------------------===//
	-#include "experimental/filesystem"
	-#include "string_view"
	-#include "utility"
	-
	-namespace { namespace parser
	-{
	-using namespace std;
	-using namespace std::experimental::filesystem;
	-
	-using string_view_t = path::__string_view;
	-using string_view_pair = pair<string_view_t, string_view_t>;
	-using PosPtr = path::value_type const*;
	-
	-struct PathParser {
	- enum ParserState : unsigned char {
	- // Zero is a special sentinel value used by default constructed iterators.
	- PS_BeforeBegin = 1,
	- PS_InRootName,
	- PS_InRootDir,
	- PS_InFilenames,
	- PS_InTrailingSep,
	- PS_AtEnd
	- };
	-
	- const string_view_t Path;
	- string_view_t RawEntry;
	- ParserState State;
	-
	-private:
	- PathParser(string_view_t P, ParserState State) noexcept
	- : Path(P), State(State) {}
	-
	-public:
	- PathParser(string_view_t P, string_view_t E, unsigned char S)
	- : Path(P), RawEntry(E), State(static_cast<ParserState>(S)) {
	- // S cannot be '0' or PS_BeforeBegin.
	- }
	-
	- static PathParser CreateBegin(string_view_t P) noexcept {
	- PathParser PP(P, PS_BeforeBegin);
	- PP.increment();
	- return PP;
	- }
	-
	- static PathParser CreateEnd(string_view_t P) noexcept {
	- PathParser PP(P, PS_AtEnd);
	- return PP;
	- }
	-
	- PosPtr peek() const noexcept {
	- auto TkEnd = getNextTokenStartPos();
	- auto End = getAfterBack();
	- return TkEnd == End ? nullptr : TkEnd;
	- }
	-
	- void increment() noexcept {
	- const PosPtr End = getAfterBack();
	- const PosPtr Start = getNextTokenStartPos();
	- if (Start == End)
	- return makeState(PS_AtEnd);
	-
	- switch (State) {
	- case PS_BeforeBegin: {
	- PosPtr TkEnd = consumeSeparator(Start, End);
	- // If we consumed exactly two separators we have a root name.
	- if (TkEnd && TkEnd == Start + 2) {
	- // FIXME Do we need to consume a name or is '//' a root name on its own?
	- // what about '//.', '//..', '//...'?
	- auto NameEnd = consumeName(TkEnd, End);
	- if (NameEnd)
	- TkEnd = NameEnd;
	- return makeState(PS_InRootName, Start, TkEnd);
	- }
	- else if (TkEnd)
	- return makeState(PS_InRootDir, Start, TkEnd);
	- else
	- return makeState(PS_InFilenames, Start, consumeName(Start, End));
	- }
	-
	- case PS_InRootName:
	- return makeState(PS_InRootDir, Start, consumeSeparator(Start, End));
	- case PS_InRootDir:
	- return makeState(PS_InFilenames, Start, consumeName(Start, End));
	-
	- case PS_InFilenames: {
	- PosPtr SepEnd = consumeSeparator(Start, End);
	- if (SepEnd != End) {
	- PosPtr TkEnd = consumeName(SepEnd, End);
	- if (TkEnd)
	- return makeState(PS_InFilenames, SepEnd, TkEnd);
	- }
	- return makeState(PS_InTrailingSep, Start, SepEnd);
	- }
	-
	- case PS_InTrailingSep:
	- return makeState(PS_AtEnd);
	-
	- case PS_AtEnd:
	- _LIBCPP_UNREACHABLE();
	- }
	- }
	-
	- void decrement() noexcept {
	- const PosPtr REnd = getBeforeFront();
	- const PosPtr RStart = getCurrentTokenStartPos() - 1;
	-
	- switch (State) {
	- case PS_AtEnd: {
	- // Try to consume a trailing separator or root directory first.
	- if (PosPtr SepEnd = consumeSeparator(RStart, REnd)) {
	- if (SepEnd == REnd)
	- return makeState((RStart == REnd + 2) ? PS_InRootName : PS_InRootDir,
	- Path.data(), RStart + 1);
	- // Check if we're seeing the root directory separator
	- auto PP = CreateBegin(Path);
	- bool InRootDir = PP.State == PS_InRootName &&
	- &PP.RawEntry.back() == SepEnd;
	- return makeState(InRootDir ? PS_InRootDir : PS_InTrailingSep,
	- SepEnd + 1, RStart + 1);
	- } else {
	- PosPtr TkStart = consumeName(RStart, REnd);
	- if (TkStart == REnd + 2 && consumeSeparator(TkStart, REnd) == REnd)
	- return makeState(PS_InRootName, Path.data(), RStart + 1);
	- else
	- return makeState(PS_InFilenames, TkStart + 1, RStart + 1);
	- }
	- }
	- case PS_InTrailingSep:
	- return makeState(PS_InFilenames, consumeName(RStart, REnd) + 1, RStart + 1);
	- case PS_InFilenames: {
	- PosPtr SepEnd = consumeSeparator(RStart, REnd);
	- if (SepEnd == REnd)
	- return makeState((RStart == REnd + 2) ? PS_InRootName : PS_InRootDir,
	- Path.data(), RStart + 1);
	- PosPtr TkEnd = consumeName(SepEnd, REnd);
	- if (TkEnd == REnd + 2 && consumeSeparator(TkEnd, REnd) == REnd)
	- return makeState(PS_InRootDir, SepEnd + 1, RStart + 1);
	- return makeState(PS_InFilenames, TkEnd + 1, SepEnd + 1);
	- }
	- case PS_InRootDir:
	- return makeState(PS_InRootName, Path.data(), RStart + 1);
	- case PS_InRootName:
	- case PS_BeforeBegin:
	- _LIBCPP_UNREACHABLE();
	- }
	- }
	-
	- /// \brief Return a view with the "preferred representation" of the current
	- /// element. For example trailing separators are represented as a '.'
	- string_view_t operator*() const noexcept {
	- switch (State) {
	- case PS_BeforeBegin:
	- case PS_AtEnd:
	- return "";
	- case PS_InRootDir:
	- return "/";
	- case PS_InTrailingSep:
	- return ".";
	- case PS_InRootName:
	- case PS_InFilenames:
	- return RawEntry;
	- }
	- _LIBCPP_UNREACHABLE();
	- }
	-
	- explicit operator bool() const noexcept {
	- return State != PS_BeforeBegin && State != PS_AtEnd;
	- }
	-
	- PathParser& operator++() noexcept {
	- increment();
	- return *this;
	- }
	-
	- PathParser& operator--() noexcept {
	- decrement();
	- return *this;
	- }
	-
	-private:
	- void makeState(ParserState NewState, PosPtr Start, PosPtr End) noexcept {
	- State = NewState;
	- RawEntry = string_view_t(Start, End - Start);
	- }
	- void makeState(ParserState NewState) noexcept {
	- State = NewState;
	- RawEntry = {};
	- }
	-
	- PosPtr getAfterBack() const noexcept {
	- return Path.data() + Path.size();
	- }
	-
	- PosPtr getBeforeFront() const noexcept {
	- return Path.data() - 1;
	- }
	-
	- /// \brief Return a pointer to the first character after the currently
	- /// lexed element.
	- PosPtr getNextTokenStartPos() const noexcept {
	- switch (State) {
	- case PS_BeforeBegin:
	- return Path.data();
	- case PS_InRootName:
	- case PS_InRootDir:
	- case PS_InFilenames:
	- return &RawEntry.back() + 1;
	- case PS_InTrailingSep:
	- case PS_AtEnd:
	- return getAfterBack();
	- }
	- _LIBCPP_UNREACHABLE();
	- }
	-
	- /// \brief Return a pointer to the first character in the currently lexed
	- /// element.
	- PosPtr getCurrentTokenStartPos() const noexcept {
	- switch (State) {
	- case PS_BeforeBegin:
	- case PS_InRootName:
	- return &Path.front();
	- case PS_InRootDir:
	- case PS_InFilenames:
	- case PS_InTrailingSep:
	- return &RawEntry.front();
	- case PS_AtEnd:
	- return &Path.back() + 1;
	- }
	- _LIBCPP_UNREACHABLE();
	- }
	-
	- PosPtr consumeSeparator(PosPtr P, PosPtr End) const noexcept {
	- if (P == End \|\| *P != '/')
	- return nullptr;
	- const int Inc = P < End ? 1 : -1;
	- P += Inc;
	- while (P != End && *P == '/')
	- P += Inc;
	- return P;
	- }
	-
	- PosPtr consumeName(PosPtr P, PosPtr End) const noexcept {
	- if (P == End \|\| *P == '/')
	- return nullptr;
	- const int Inc = P < End ? 1 : -1;
	- P += Inc;
	- while (P != End && *P != '/')
	- P += Inc;
	- return P;
	- }
	-};
	-
	-string_view_pair separate_filename(string_view_t const & s) {
	- if (s == "." \|\| s == ".." \|\| s.empty()) return string_view_pair{s, ""};
	- auto pos = s.find_last_of('.');
	- if (pos == string_view_t::npos)
	- return string_view_pair{s, string_view_t{}};
	- return string_view_pair{s.substr(0, pos), s.substr(pos)};
	-}
	-
	-string_view_t createView(PosPtr S, PosPtr E) noexcept {
	- return {S, static_cast<size_t>(E - S) + 1};
	-}
	-
	-}} // namespace parser
	-
	-_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
	-
	-using parser::string_view_t;
	-using parser::string_view_pair;
	-using parser::PathParser;
	-using parser::createView;
	-
	-///////////////////////////////////////////////////////////////////////////////
	-// path definitions
	-///////////////////////////////////////////////////////////////////////////////
	-
	-constexpr path::value_type path::preferred_separator;
	-
	-path & path::replace_extension(path const & replacement)
	-{
	- path p = extension();
	- if (not p.empty()) {
	- __pn_.erase(__pn_.size() - p.native().size());
	- }
	- if (!replacement.empty()) {
	- if (replacement.native()[0] != '.') {
	- __pn_ += ".";
	- }
	- __pn_.append(replacement.__pn_);
	- }
	- return *this;
	-}
	-
	-///////////////////////////////////////////////////////////////////////////////
	-// path.decompose
	-
	-string_view_t path::__root_name() const
	-{
	- auto PP = PathParser::CreateBegin(__pn_);
	- if (PP.State == PathParser::PS_InRootName)
	- return *PP;
	- return {};
	-}
	-
	-string_view_t path::__root_directory() const
	-{
	- auto PP = PathParser::CreateBegin(__pn_);
	- if (PP.State == PathParser::PS_InRootName)
	- ++PP;
	- if (PP.State == PathParser::PS_InRootDir)
	- return *PP;
	- return {};
	-}
	-
	-string_view_t path::__root_path_raw() const
	-{
	- auto PP = PathParser::CreateBegin(__pn_);
	- if (PP.State == PathParser::PS_InRootName) {
	- auto NextCh = PP.peek();
	- if (NextCh && *NextCh == '/') {
	- ++PP;
	- return createView(__pn_.data(), &PP.RawEntry.back());
	- }
	- return PP.RawEntry;
	- }
	- if (PP.State == PathParser::PS_InRootDir)
	- return *PP;
	- return {};
	-}
	-
	-string_view_t path::__relative_path() const
	-{
	- auto PP = PathParser::CreateBegin(__pn_);
	- while (PP.State <= PathParser::PS_InRootDir)
	- ++PP;
	- if (PP.State == PathParser::PS_AtEnd)
	- return {};
	- return createView(PP.RawEntry.data(), &__pn_.back());
	-}
	-
	-string_view_t path::__parent_path() const
	-{
	- if (empty())
	- return {};
	- auto PP = PathParser::CreateEnd(__pn_);
	- --PP;
	- if (PP.RawEntry.data() == __pn_.data())
	- return {};
	- --PP;
	- return createView(__pn_.data(), &PP.RawEntry.back());
	-}
	-
	-string_view_t path::__filename() const
	-{
	- if (empty()) return {};
	- return *(--PathParser::CreateEnd(__pn_));
	-}
	-
	-string_view_t path::__stem() const
	-{
	- return parser::separate_filename(__filename()).first;
	-}
	-
	-string_view_t path::__extension() const
	-{
	- return parser::separate_filename(__filename()).second;
	-}
	-
	-////////////////////////////////////////////////////////////////////////////
	-// path.comparisons
	-int path::__compare(string_view_t __s) const {
	- auto PP = PathParser::CreateBegin(__pn_);
	- auto PP2 = PathParser::CreateBegin(__s);
	- while (PP && PP2) {
	- int res = (PP).compare(PP2);
	- if (res != 0) return res;
	- ++PP; ++PP2;
	- }
	- if (PP.State == PP2.State && PP.State == PathParser::PS_AtEnd)
	- return 0;
	- if (PP.State == PathParser::PS_AtEnd)
	- return -1;
	- return 1;
	-}
	-
	-////////////////////////////////////////////////////////////////////////////
	-// path.nonmembers
	-size_t hash_value(const path& __p) noexcept {
	- auto PP = PathParser::CreateBegin(__p.native());
	- size_t hash_value = 0;
	- std::hash<string_view_t> hasher;
	- while (PP) {
	- hash_value = __hash_combine(hash_value, hasher(*PP));
	- ++PP;
	- }
	- return hash_value;
	-}
	-
	-////////////////////////////////////////////////////////////////////////////
	-// path.itr
	-path::iterator path::begin() const
	-{
	- auto PP = PathParser::CreateBegin(__pn_);
	- iterator it;
	- it.__path_ptr_ = this;
	- it.__state_ = PP.State;
	- it.__entry_ = PP.RawEntry;
	- it.__stashed_elem_.__assign_view(*PP);
	- return it;
	-}
	-
	-path::iterator path::end() const
	-{
	- iterator it{};
	- it.__state_ = PathParser::PS_AtEnd;
	- it.__path_ptr_ = this;
	- return it;
	-}
	-
	-path::iterator& path::iterator::__increment() {
	- static_assert(__at_end == PathParser::PS_AtEnd, "");
	- PathParser PP(__path_ptr_->native(), __entry_, __state_);
	- ++PP;
	- __state_ = PP.State;
	- __entry_ = PP.RawEntry;
	- __stashed_elem_.__assign_view(*PP);
	- return *this;
	-}
	-
	-path::iterator& path::iterator::__decrement() {
	- PathParser PP(__path_ptr_->native(), __entry_, __state_);
	- --PP;
	- __state_ = PP.State;
	- __entry_ = PP.RawEntry;
	- __stashed_elem_.__assign_view(*PP);
	- return *this;
	-}
	-
	-_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM

	Property changes on: projects/clang700-import/contrib/libc++/src/experimental/filesystem/path.cpp
	___________________________________________________________________
	Deleted: svn:eol-style
	## -1 +0,0 ##
	-native
	\ No newline at end of property
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Deleted: svn:mime-type
	## -1 +0,0 ##
	-text/plain
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/experimental/filesystem/filesystem_time_helper.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/experimental/filesystem/filesystem_time_helper.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/experimental/filesystem/filesystem_time_helper.h (nonexistent)
	@@ -1,173 +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.
	-//
	-//===----------------------------------------------------------------------===////
	-
	-#ifndef FILESYSTEM_TIME_HELPER_H
	-#define FILESYSTEM_TIME_HELPER_H
	-
	-#include "experimental/__config"
	-#include "chrono"
	-#include "cstdlib"
	-#include "climits"
	-
	-#include <unistd.h>
	-#include <sys/stat.h>
	-#if !defined(UTIME_OMIT)
	-#include <sys/time.h> // for ::utimes as used in __last_write_time
	-#endif
	-
	-_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
	-
	-namespace time_detail { namespace {
	-
	-using namespace chrono;
	-
	-template <class FileTimeT,
	- bool IsFloat = is_floating_point<typename FileTimeT::rep>::value>
	-struct fs_time_util_base {
	- static constexpr auto max_seconds =
	- duration_cast<seconds>(FileTimeT::duration::max()).count();
	-
	- static constexpr auto max_nsec =
	- duration_cast<nanoseconds>(FileTimeT::duration::max() -
	- seconds(max_seconds))
	- .count();
	-
	- static constexpr auto min_seconds =
	- duration_cast<seconds>(FileTimeT::duration::min()).count();
	-
	- static constexpr auto min_nsec_timespec =
	- duration_cast<nanoseconds>(
	- (FileTimeT::duration::min() - seconds(min_seconds)) + seconds(1))
	- .count();
	-
	- // Static assert that these values properly round trip.
	- static_assert((seconds(min_seconds) +
	- duration_cast<microseconds>(nanoseconds(min_nsec_timespec))) -
	- duration_cast<microseconds>(seconds(1)) ==
	- FileTimeT::duration::min(),
	- "");
	-};
	-
	-template <class FileTimeT>
	-struct fs_time_util_base<FileTimeT, true> {
	- static const long long max_seconds;
	- static const long long max_nsec;
	- static const long long min_seconds;
	- static const long long min_nsec_timespec;
	-};
	-
	-template <class FileTimeT>
	-const long long fs_time_util_base<FileTimeT, true>::max_seconds =
	- duration_cast<seconds>(FileTimeT::duration::max()).count();
	-
	-template <class FileTimeT>
	-const long long fs_time_util_base<FileTimeT, true>::max_nsec =
	- duration_cast<nanoseconds>(FileTimeT::duration::max() -
	- seconds(max_seconds))
	- .count();
	-
	-template <class FileTimeT>
	-const long long fs_time_util_base<FileTimeT, true>::min_seconds =
	- duration_cast<seconds>(FileTimeT::duration::min()).count();
	-
	-template <class FileTimeT>
	-const long long fs_time_util_base<FileTimeT, true>::min_nsec_timespec =
	- duration_cast<nanoseconds>((FileTimeT::duration::min() -
	- seconds(min_seconds)) +
	- seconds(1))
	- .count();
	-
	-template <class FileTimeT, class TimeT, class TimeSpecT>
	-struct fs_time_util : fs_time_util_base<FileTimeT> {
	- using Base = fs_time_util_base<FileTimeT>;
	- using Base::max_nsec;
	- using Base::max_seconds;
	- using Base::min_nsec_timespec;
	- using Base::min_seconds;
	-
	-public:
	- template <class CType, class ChronoType>
	- static bool checked_set(CType* out, ChronoType time) {
	- using Lim = numeric_limits<CType>;
	- if (time > Lim::max() \|\| time < Lim::min())
	- return false;
	- *out = static_cast<CType>(time);
	- return true;
	- }
	-
	- static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool is_representable(TimeSpecT tm) {
	- if (tm.tv_sec >= 0) {
	- return (tm.tv_sec < max_seconds) \|\|
	- (tm.tv_sec == max_seconds && tm.tv_nsec <= max_nsec);
	- } else if (tm.tv_sec == (min_seconds - 1)) {
	- return tm.tv_nsec >= min_nsec_timespec;
	- } else {
	- return (tm.tv_sec >= min_seconds);
	- }
	- }
	-
	- static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool is_representable(FileTimeT tm) {
	- auto secs = duration_cast<seconds>(tm.time_since_epoch());
	- auto nsecs = duration_cast<nanoseconds>(tm.time_since_epoch() - secs);
	- if (nsecs.count() < 0) {
	- secs = secs + seconds(1);
	- nsecs = nsecs + seconds(1);
	- }
	- using TLim = numeric_limits<TimeT>;
	- if (secs.count() >= 0)
	- return secs.count() <= TLim::max();
	- return secs.count() >= TLim::min();
	- }
	-
	- static _LIBCPP_CONSTEXPR_AFTER_CXX11 FileTimeT
	- convert_timespec(TimeSpecT tm) {
	- auto adj_msec = duration_cast<microseconds>(nanoseconds(tm.tv_nsec));
	- if (tm.tv_sec >= 0) {
	- auto Dur = seconds(tm.tv_sec) + microseconds(adj_msec);
	- return FileTimeT(Dur);
	- } else if (duration_cast<microseconds>(nanoseconds(tm.tv_nsec)).count() ==
	- 0) {
	- return FileTimeT(seconds(tm.tv_sec));
	- } else { // tm.tv_sec < 0
	- auto adj_subsec =
	- duration_cast<microseconds>(seconds(1) - nanoseconds(tm.tv_nsec));
	- auto Dur = seconds(tm.tv_sec + 1) - adj_subsec;
	- return FileTimeT(Dur);
	- }
	- }
	-
	- template <class SubSecDurT, class SubSecT>
	- static bool set_times_checked(TimeT* sec_out, SubSecT* subsec_out,
	- FileTimeT tp) {
	- using namespace chrono;
	- auto dur = tp.time_since_epoch();
	- auto sec_dur = duration_cast<seconds>(dur);
	- auto subsec_dur = duration_cast<SubSecDurT>(dur - sec_dur);
	- // The tv_nsec and tv_usec fields must not be negative so adjust accordingly
	- if (subsec_dur.count() < 0) {
	- if (sec_dur.count() > min_seconds) {
	- sec_dur -= seconds(1);
	- subsec_dur += seconds(1);
	- } else {
	- subsec_dur = SubSecDurT::zero();
	- }
	- }
	- return checked_set(sec_out, sec_dur.count()) &&
	- checked_set(subsec_out, subsec_dur.count());
	- }
	-};
	-
	-} // end namespace
	-} // end namespace time_detail
	-
	-using time_detail::fs_time_util;
	-
	-_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM
	-
	-#endif // FILESYSTEM_TIME_HELPER_H

	Property changes on: projects/clang700-import/contrib/libc++/src/experimental/filesystem/filesystem_time_helper.h
	___________________________________________________________________
	Deleted: svn:eol-style
	## -1 +0,0 ##
	-native
	\ No newline at end of property
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Deleted: svn:mime-type
	## -1 +0,0 ##
	-text/plain
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/experimental/filesystem/operations.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/experimental/filesystem/operations.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/experimental/filesystem/operations.cpp (nonexistent)
	@@ -1,808 +0,0 @@
	-//===--------------------- filesystem/ops.cpp -----------------------------===//
	-//
	-// The LLVM Compiler Infrastructure
	-//
	-// This file is dual licensed under the MIT and the University of Illinois Open
	-// Source Licenses. See LICENSE.TXT for details.
	-//
	-//===----------------------------------------------------------------------===//
	-
	-#include "experimental/filesystem"
	-#include "iterator"
	-#include "fstream"
	-#include "type_traits"
	-#include "random" /* for unique_path */
	-#include "cstdlib"
	-#include "climits"
	-
	-#include "filesystem_time_helper.h"
	-
	-#include <unistd.h>
	-#include <sys/stat.h>
	-#include <sys/statvfs.h>
	-#include <fcntl.h> /* values for fchmodat */
	-#if !defined(UTIME_OMIT)
	-#include <sys/time.h> // for ::utimes as used in __last_write_time
	-#endif
	-
	-_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
	-
	-filesystem_error::~filesystem_error() {}
	-
	-
	-// POSIX HELPERS
	-
	-namespace detail { namespace {
	-
	-using value_type = path::value_type;
	-using string_type = path::string_type;
	-
	-inline std::error_code capture_errno() {
	- _LIBCPP_ASSERT(errno, "Expected errno to be non-zero");
	- return std::error_code(errno, std::generic_category());
	-}
	-
	-void set_or_throw(std::error_code const& m_ec, std::error_code* ec,
	- const char* msg, path const& p = {}, path const& p2 = {})
	-{
	- if (ec) {
	- *ec = m_ec;
	- } else {
	- string msg_s("std::experimental::filesystem::");
	- msg_s += msg;
	- __throw_filesystem_error(msg_s, p, p2, m_ec);
	- }
	-}
	-
	-void set_or_throw(std::error_code* ec, const char* msg,
	- path const& p = {}, path const& p2 = {})
	-{
	- return set_or_throw(capture_errno(), ec, msg, p, p2);
	-}
	-
	-perms posix_get_perms(const struct ::stat & st) noexcept {
	- return static_cast<perms>(st.st_mode) & perms::mask;
	-}
	-
	-::mode_t posix_convert_perms(perms prms) {
	- return static_cast< ::mode_t>(prms & perms::mask);
	-}
	-
	-file_status create_file_status(std::error_code& m_ec, path const& p,
	- struct ::stat& path_stat,
	- std::error_code* ec)
	-{
	- if (ec) *ec = m_ec;
	- if (m_ec && (m_ec.value() == ENOENT \|\| m_ec.value() == ENOTDIR)) {
	- return file_status(file_type::not_found);
	- }
	- else if (m_ec) {
	- set_or_throw(m_ec, ec, "posix_stat", p);
	- return file_status(file_type::none);
	- }
	- // else
	-
	- file_status fs_tmp;
	- auto const mode = path_stat.st_mode;
	- if (S_ISLNK(mode)) fs_tmp.type(file_type::symlink);
	- else if (S_ISREG(mode)) fs_tmp.type(file_type::regular);
	- else if (S_ISDIR(mode)) fs_tmp.type(file_type::directory);
	- else if (S_ISBLK(mode)) fs_tmp.type(file_type::block);
	- else if (S_ISCHR(mode)) fs_tmp.type(file_type::character);
	- else if (S_ISFIFO(mode)) fs_tmp.type(file_type::fifo);
	- else if (S_ISSOCK(mode)) fs_tmp.type(file_type::socket);
	- else fs_tmp.type(file_type::unknown);
	-
	- fs_tmp.permissions(detail::posix_get_perms(path_stat));
	- return fs_tmp;
	-}
	-
	-file_status posix_stat(path const & p, struct ::stat& path_stat,
	- std::error_code* ec)
	-{
	- std::error_code m_ec;
	- if (::stat(p.c_str(), &path_stat) == -1)
	- m_ec = detail::capture_errno();
	- return create_file_status(m_ec, p, path_stat, ec);
	-}
	-
	-file_status posix_stat(path const & p, std::error_code* ec) {
	- struct ::stat path_stat;
	- return posix_stat(p, path_stat, ec);
	-}
	-
	-file_status posix_lstat(path const & p, struct ::stat & path_stat,
	- std::error_code* ec)
	-{
	- std::error_code m_ec;
	- if (::lstat(p.c_str(), &path_stat) == -1)
	- m_ec = detail::capture_errno();
	- return create_file_status(m_ec, p, path_stat, ec);
	-}
	-
	-file_status posix_lstat(path const & p, std::error_code* ec) {
	- struct ::stat path_stat;
	- return posix_lstat(p, path_stat, ec);
	-}
	-
	-bool stat_equivalent(struct ::stat& st1, struct ::stat& st2) {
	- return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
	-}
	-
	-// DETAIL::MISC
	-
	-
	-bool copy_file_impl(const path& from, const path& to, perms from_perms,
	- std::error_code *ec)
	-{
	- std::ifstream in(from.c_str(), std::ios::binary);
	- std::ofstream out(to.c_str(), std::ios::binary);
	-
	- if (in.good() && out.good()) {
	- using InIt = std::istreambuf_iterator<char>;
	- using OutIt = std::ostreambuf_iterator<char>;
	- InIt bin(in);
	- InIt ein;
	- OutIt bout(out);
	- std::copy(bin, ein, bout);
	- }
	- if (out.fail() \|\| in.fail()) {
	- set_or_throw(make_error_code(errc::operation_not_permitted),
	- ec, "copy_file", from, to);
	- return false;
	- }
	- __permissions(to, from_perms, ec);
	- // TODO what if permissions fails?
	- return true;
	-}
	-
	-}} // end namespace detail
	-
	-using detail::set_or_throw;
	-
	-path __canonical(path const & orig_p, const path& base, std::error_code *ec)
	-{
	- path p = absolute(orig_p, base);
	- char buff[PATH_MAX + 1];
	- char *ret;
	- if ((ret = ::realpath(p.c_str(), buff)) == nullptr) {
	- set_or_throw(ec, "canonical", orig_p, base);
	- return {};
	- }
	- if (ec) ec->clear();
	- return {ret};
	-}
	-
	-void __copy(const path& from, const path& to, copy_options options,
	- std::error_code *ec)
	-{
	- const bool sym_status = bool(options &
	- (copy_options::create_symlinks \| copy_options::skip_symlinks));
	-
	- const bool sym_status2 = bool(options &
	- copy_options::copy_symlinks);
	-
	- std::error_code m_ec1;
	- struct ::stat f_st = {};
	- const file_status f = sym_status \|\| sym_status2
	- ? 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_ec1)
	- : detail::posix_stat(to, t_st, &m_ec1);
	-
	- if (not status_known(t))
	- 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))
	- \|\| detail::stat_equivalent(f_st, t_st))
	- {
	- return set_or_throw(make_error_code(errc::function_not_supported),
	- ec, "copy", from, to);
	- }
	-
	- if (ec) ec->clear();
	-
	- if (is_symlink(f)) {
	- if (bool(copy_options::skip_symlinks & options)) {
	- // do nothing
	- } else if (not exists(t)) {
	- __copy_symlink(from, to, ec);
	- } else {
	- set_or_throw(make_error_code(errc::file_exists),
	- ec, "copy", from, to);
	- }
	- return;
	- }
	- else if (is_regular_file(f)) {
	- if (bool(copy_options::directories_only & options)) {
	- // do nothing
	- }
	- else if (bool(copy_options::create_symlinks & options)) {
	- __create_symlink(from, to, ec);
	- }
	- else if (bool(copy_options::create_hard_links & options)) {
	- __create_hard_link(from, to, ec);
	- }
	- else if (is_directory(t)) {
	- __copy_file(from, to / from.filename(), options, ec);
	- } else {
	- __copy_file(from, to, options, ec);
	- }
	- return;
	- }
	- else if (is_directory(f) && bool(copy_options::create_symlinks & options)) {
	- return set_or_throw(make_error_code(errc::is_a_directory), ec, "copy");
	- }
	- else if (is_directory(f) && (bool(copy_options::recursive & options) \|\|
	- copy_options::none == options)) {
	-
	- if (!exists(t)) {
	- // create directory to with attributes from 'from'.
	- __create_directory(to, from, ec);
	- if (ec && *ec) { return; }
	- }
	- directory_iterator it = ec ? directory_iterator(from, *ec)
	- : directory_iterator(from);
	- if (ec && *ec) { return; }
	- 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; }
	- }
	- }
	-}
	-
	-
	-bool __copy_file(const path& from, const path& to, copy_options options,
	- std::error_code *ec)
	-{
	- if (ec) ec->clear();
	-
	- std::error_code m_ec;
	- auto from_st = detail::posix_stat(from, &m_ec);
	- if (not is_regular_file(from_st)) {
	- if (not m_ec)
	- m_ec = make_error_code(errc::not_supported);
	- set_or_throw(m_ec, ec, "copy_file", from, to);
	- return false;
	- }
	-
	- auto to_st = detail::posix_stat(to, &m_ec);
	- if (!status_known(to_st)) {
	- set_or_throw(m_ec, ec, "copy_file", from, to);
	- return false;
	- }
	-
	- const bool to_exists = exists(to_st);
	- if (to_exists && !is_regular_file(to_st)) {
	- set_or_throw(make_error_code(errc::not_supported), ec, "copy_file", from, to);
	- return false;
	- }
	- if (to_exists && bool(copy_options::skip_existing & options)) {
	- return false;
	- }
	- else if (to_exists && bool(copy_options::update_existing & options)) {
	- auto from_time = __last_write_time(from, ec);
	- if (ec && *ec) { return false; }
	- auto to_time = __last_write_time(to, ec);
	- if (ec && *ec) { return false; }
	- if (from_time <= to_time) {
	- return false;
	- }
	- return detail::copy_file_impl(from, to, from_st.permissions(), ec);
	- }
	- else if (!to_exists \|\| bool(copy_options::overwrite_existing & options)) {
	- return detail::copy_file_impl(from, to, from_st.permissions(), ec);
	- }
	- else {
	- set_or_throw(make_error_code(errc::file_exists), ec, "copy", from, to);
	- return false;
	- }
	-
	- _LIBCPP_UNREACHABLE();
	-}
	-
	-void __copy_symlink(const path& existing_symlink, const path& new_symlink,
	- std::error_code *ec)
	-{
	- const path real_path(__read_symlink(existing_symlink, ec));
	- if (ec && *ec) { return; }
	- // NOTE: proposal says you should detect if you should call
	- // create_symlink or create_directory_symlink. I don't think this
	- // is needed with POSIX
	- __create_symlink(real_path, new_symlink, ec);
	-}
	-
	-
	-bool __create_directories(const path& p, std::error_code *ec)
	-{
	- std::error_code m_ec;
	- auto const st = detail::posix_stat(p, &m_ec);
	- if (!status_known(st)) {
	- set_or_throw(m_ec, ec, "create_directories", p);
	- return false;
	- }
	- else if (is_directory(st)) {
	- if (ec) ec->clear();
	- return false;
	- }
	- else if (exists(st)) {
	- set_or_throw(make_error_code(errc::file_exists),
	- ec, "create_directories", p);
	- return false;
	- }
	-
	- const path parent = p.parent_path();
	- if (!parent.empty()) {
	- const file_status parent_st = status(parent, m_ec);
	- if (not status_known(parent_st)) {
	- set_or_throw(m_ec, ec, "create_directories", p);
	- return false;
	- }
	- if (not exists(parent_st)) {
	- __create_directories(parent, ec);
	- if (ec && *ec) { return false; }
	- }
	- }
	- return __create_directory(p, ec);
	-}
	-
	-bool __create_directory(const path& p, std::error_code *ec)
	-{
	- if (ec) ec->clear();
	- if (::mkdir(p.c_str(), static_cast<int>(perms::all)) == 0)
	- return true;
	- if (errno != EEXIST \|\| !is_directory(p))
	- set_or_throw(ec, "create_directory", p);
	- return false;
	-}
	-
	-bool __create_directory(path const & p, path const & attributes,
	- std::error_code *ec)
	-{
	- struct ::stat attr_stat;
	- std::error_code mec;
	- auto st = detail::posix_stat(attributes, attr_stat, &mec);
	- if (!status_known(st)) {
	- set_or_throw(mec, ec, "create_directory", p, attributes);
	- return false;
	- }
	- if (ec) ec->clear();
	- if (::mkdir(p.c_str(), attr_stat.st_mode) == 0)
	- return true;
	- if (errno != EEXIST \|\| !is_directory(p))
	- set_or_throw(ec, "create_directory", p, attributes);
	- return false;
	-}
	-
	-void __create_directory_symlink(path const & from, path const & to,
	- std::error_code *ec){
	- if (::symlink(from.c_str(), to.c_str()) != 0)
	- set_or_throw(ec, "create_directory_symlink", from, to);
	- else if (ec)
	- ec->clear();
	-}
	-
	-void __create_hard_link(const path& from, const path& to, std::error_code *ec){
	- if (::link(from.c_str(), to.c_str()) == -1)
	- set_or_throw(ec, "create_hard_link", from, to);
	- else if (ec)
	- ec->clear();
	-}
	-
	-void __create_symlink(path const & from, path const & to, std::error_code *ec) {
	-
	- if (::symlink(from.c_str(), to.c_str()) == -1)
	- set_or_throw(ec, "create_symlink", from, to);
	- else if (ec)
	- ec->clear();
	-}
	-
	-path __current_path(std::error_code *ec) {
	- auto size = ::pathconf(".", _PC_PATH_MAX);
	- _LIBCPP_ASSERT(size >= 0, "pathconf returned a 0 as max size");
	-
	- auto buff = std::unique_ptr<char[]>(new char[size + 1]);
	- char* ret;
	- if ((ret = ::getcwd(buff.get(), static_cast<size_t>(size))) == nullptr) {
	- set_or_throw(ec, "current_path");
	- return {};
	- }
	- if (ec) ec->clear();
	- return {buff.get()};
	-}
	-
	-void __current_path(const path& p, std::error_code *ec) {
	- if (::chdir(p.c_str()) == -1)
	- set_or_throw(ec, "current_path", p);
	- else if (ec)
	- ec->clear();
	-}
	-
	-bool __equivalent(const path& p1, const path& p2, std::error_code *ec)
	-{
	- auto make_unsupported_error = [&]() {
	- set_or_throw(make_error_code(errc::not_supported), ec,
	- "equivalent", p1, p2);
	- return false;
	- };
	- std::error_code ec1, ec2;
	- struct ::stat st1 = {};
	- struct ::stat st2 = {};
	- auto s1 = detail::posix_stat(p1.native(), st1, &ec1);
	- if (!exists(s1))
	- return make_unsupported_error();
	- auto s2 = detail::posix_stat(p2.native(), st2, &ec2);
	- if (!exists(s2))
	- return make_unsupported_error();
	- if (ec) ec->clear();
	- return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
	-}
	-
	-
	-std::uintmax_t __file_size(const path& p, std::error_code *ec)
	-{
	- std::error_code m_ec;
	- struct ::stat st;
	- file_status fst = detail::posix_stat(p, st, &m_ec);
	- if (!exists(fst) \|\| !is_regular_file(fst)) {
	- if (!m_ec)
	- m_ec = make_error_code(errc::not_supported);
	- set_or_throw(m_ec, ec, "file_size", p);
	- return static_cast<uintmax_t>(-1);
	- }
	- // is_regular_file(p) == true
	- if (ec) ec->clear();
	- return static_cast<std::uintmax_t>(st.st_size);
	-}
	-
	-std::uintmax_t __hard_link_count(const path& p, std::error_code *ec)
	-{
	- std::error_code m_ec;
	- struct ::stat st;
	- detail::posix_stat(p, st, &m_ec);
	- if (m_ec) {
	- set_or_throw(m_ec, ec, "hard_link_count", p);
	- return static_cast<std::uintmax_t>(-1);
	- }
	- if (ec) ec->clear();
	- return static_cast<std::uintmax_t>(st.st_nlink);
	-}
	-
	-
	-bool __fs_is_empty(const path& p, std::error_code *ec)
	-{
	- if (ec) ec->clear();
	- std::error_code m_ec;
	- struct ::stat pst;
	- auto st = detail::posix_stat(p, pst, &m_ec);
	- if (m_ec) {
	- set_or_throw(m_ec, ec, "is_empty", p);
	- return false;
	- }
	- else if (!is_directory(st) && !is_regular_file(st)) {
	- m_ec = make_error_code(errc::not_supported);
	- set_or_throw(m_ec, ec, "is_empty");
	- return false;
	- }
	- else if (is_directory(st)) {
	- auto it = ec ? directory_iterator(p, *ec) : directory_iterator(p);
	- if (ec && *ec)
	- return false;
	- return it == directory_iterator{};
	- }
	- else if (is_regular_file(st))
	- return static_cast<std::uintmax_t>(pst.st_size) == 0;
	-
	- _LIBCPP_UNREACHABLE();
	-}
	-
	-
	-namespace detail { namespace {
	-
	-using TimeSpec = struct timespec;
	-using StatT = struct stat;
	-
	-#if defined(__APPLE__)
	-TimeSpec extract_mtime(StatT const& st) { return st.st_mtimespec; }
	-__attribute__((unused)) // Suppress warning
	-TimeSpec extract_atime(StatT const& st) { return st.st_atimespec; }
	-#else
	-TimeSpec extract_mtime(StatT const& st) { return st.st_mtim; }
	-__attribute__((unused)) // Suppress warning
	-TimeSpec extract_atime(StatT const& st) { return st.st_atim; }
	-#endif
	-
	-}} // end namespace detail
	-
	-using FSTime = fs_time_util<file_time_type, time_t, struct timespec>;
	-
	-file_time_type __last_write_time(const path& p, std::error_code *ec)
	-{
	- using namespace ::std::chrono;
	- std::error_code m_ec;
	- struct ::stat st;
	- detail::posix_stat(p, st, &m_ec);
	- if (m_ec) {
	- set_or_throw(m_ec, ec, "last_write_time", p);
	- return file_time_type::min();
	- }
	- if (ec) ec->clear();
	- auto ts = detail::extract_mtime(st);
	- if (!FSTime::is_representable(ts)) {
	- set_or_throw(error_code(EOVERFLOW, generic_category()), ec,
	- "last_write_time", p);
	- return file_time_type::min();
	- }
	- return FSTime::convert_timespec(ts);
	-}
	-
	-void __last_write_time(const path& p, file_time_type new_time,
	- std::error_code *ec)
	-{
	- using namespace std::chrono;
	- std::error_code m_ec;
	-
	- // We can use the presence of UTIME_OMIT to detect platforms that do not
	- // provide utimensat.
	-#if !defined(UTIME_OMIT)
	- // This implementation has a race condition between determining the
	- // last access time and attempting to set it to the same value using
	- // ::utimes
	- struct ::stat st;
	- file_status fst = detail::posix_stat(p, st, &m_ec);
	- if (m_ec && !status_known(fst)) {
	- set_or_throw(m_ec, ec, "last_write_time", p);
	- return;
	- }
	- auto atime = detail::extract_atime(st);
	- struct ::timeval tbuf[2];
	- tbuf[0].tv_sec = atime.tv_sec;
	- tbuf[0].tv_usec = duration_cast<microseconds>(nanoseconds(atime.tv_nsec)).count();
	- const bool overflowed = !FSTime::set_times_checked<microseconds>(
	- &tbuf[1].tv_sec, &tbuf[1].tv_usec, new_time);
	-
	- if (overflowed) {
	- set_or_throw(make_error_code(errc::invalid_argument), ec,
	- "last_write_time", p);
	- return;
	- }
	- if (::utimes(p.c_str(), tbuf) == -1) {
	- m_ec = detail::capture_errno();
	- }
	-#else
	- struct ::timespec tbuf[2];
	- tbuf[0].tv_sec = 0;
	- tbuf[0].tv_nsec = UTIME_OMIT;
	-
	- const bool overflowed = !FSTime::set_times_checked<nanoseconds>(
	- &tbuf[1].tv_sec, &tbuf[1].tv_nsec, new_time);
	- if (overflowed) {
	- set_or_throw(make_error_code(errc::invalid_argument),
	- ec, "last_write_time", p);
	- return;
	- }
	- if (::utimensat(AT_FDCWD, p.c_str(), tbuf, 0) == -1) {
	- m_ec = detail::capture_errno();
	- }
	-#endif
	- if (m_ec)
	- set_or_throw(m_ec, ec, "last_write_time", p);
	- else if (ec)
	- ec->clear();
	-}
	-
	-
	-void __permissions(const path& p, perms prms, std::error_code *ec)
	-{
	-
	- const bool resolve_symlinks = !bool(perms::symlink_nofollow & prms);
	- const bool add_perms = bool(perms::add_perms & prms);
	- const bool remove_perms = bool(perms::remove_perms & prms);
	- _LIBCPP_ASSERT(!(add_perms && remove_perms),
	- "Both add_perms and remove_perms are set");
	-
	- bool set_sym_perms = false;
	- prms &= perms::mask;
	- if (!resolve_symlinks \|\| (add_perms \|\| remove_perms)) {
	- std::error_code m_ec;
	- file_status st = resolve_symlinks ? detail::posix_stat(p, &m_ec)
	- : detail::posix_lstat(p, &m_ec);
	- set_sym_perms = is_symlink(st);
	- if (m_ec) return set_or_throw(m_ec, ec, "permissions", p);
	- _LIBCPP_ASSERT(st.permissions() != perms::unknown,
	- "Permissions unexpectedly unknown");
	- if (add_perms)
	- prms \|= st.permissions();
	- else if (remove_perms)
	- prms = st.permissions() & ~prms;
	- }
	- const auto real_perms = detail::posix_convert_perms(prms);
	-
	-# if defined(AT_SYMLINK_NOFOLLOW) && defined(AT_FDCWD)
	- const int flags = set_sym_perms ? AT_SYMLINK_NOFOLLOW : 0;
	- if (::fchmodat(AT_FDCWD, p.c_str(), real_perms, flags) == -1) {
	- return set_or_throw(ec, "permissions", p);
	- }
	-# else
	- if (set_sym_perms)
	- return set_or_throw(make_error_code(errc::operation_not_supported),
	- ec, "permissions", p);
	- if (::chmod(p.c_str(), real_perms) == -1) {
	- return set_or_throw(ec, "permissions", p);
	- }
	-# endif
	- if (ec) ec->clear();
	-}
	-
	-
	-path __read_symlink(const path& p, std::error_code *ec) {
	- char buff[PATH_MAX + 1];
	- std::error_code m_ec;
	- ::ssize_t ret;
	- if ((ret = ::readlink(p.c_str(), buff, PATH_MAX)) == -1) {
	- set_or_throw(ec, "read_symlink", p);
	- return {};
	- }
	- _LIBCPP_ASSERT(ret <= PATH_MAX, "TODO");
	- _LIBCPP_ASSERT(ret > 0, "TODO");
	- if (ec) ec->clear();
	- buff[ret] = 0;
	- return {buff};
	-}
	-
	-
	-bool __remove(const path& p, std::error_code *ec) {
	- if (ec) ec->clear();
	- if (::remove(p.c_str()) == -1) {
	- set_or_throw(ec, "remove", p);
	- return false;
	- }
	- return true;
	-}
	-
	-namespace {
	-
	-std::uintmax_t remove_all_impl(path const & p, std::error_code& ec)
	-{
	- const auto npos = static_cast<std::uintmax_t>(-1);
	- const file_status st = __symlink_status(p, &ec);
	- if (ec) return npos;
	- std::uintmax_t count = 1;
	- if (is_directory(st)) {
	- for (directory_iterator it(p, ec); !ec && it != directory_iterator();
	- it.increment(ec)) {
	- auto other_count = remove_all_impl(it->path(), ec);
	- if (ec) return npos;
	- count += other_count;
	- }
	- if (ec) return npos;
	- }
	- if (!__remove(p, &ec)) return npos;
	- return count;
	-}
	-
	-} // end namespace
	-
	-std::uintmax_t __remove_all(const path& p, std::error_code *ec) {
	- std::error_code mec;
	- auto count = remove_all_impl(p, mec);
	- if (mec) {
	- set_or_throw(mec, ec, "remove_all", p);
	- return static_cast<std::uintmax_t>(-1);
	- }
	- if (ec) ec->clear();
	- return count;
	-}
	-
	-void __rename(const path& from, const path& to, std::error_code *ec) {
	- if (::rename(from.c_str(), to.c_str()) == -1)
	- set_or_throw(ec, "rename", from, to);
	- else if (ec)
	- ec->clear();
	-}
	-
	-void __resize_file(const path& p, std::uintmax_t size, std::error_code *ec) {
	- if (::truncate(p.c_str(), static_cast<::off_t>(size)) == -1)
	- set_or_throw(ec, "resize_file", p);
	- else if (ec)
	- ec->clear();
	-}
	-
	-space_info __space(const path& p, std::error_code *ec) {
	- space_info si;
	- struct statvfs m_svfs = {};
	- if (::statvfs(p.c_str(), &m_svfs) == -1) {
	- set_or_throw(ec, "space", p);
	- si.capacity = si.free = si.available =
	- static_cast<std::uintmax_t>(-1);
	- return si;
	- }
	- if (ec) ec->clear();
	- // Multiply with overflow checking.
	- auto do_mult = [&](std::uintmax_t& out, std::uintmax_t other) {
	- out = other * m_svfs.f_frsize;
	- if (other == 0 \|\| out / other != m_svfs.f_frsize)
	- out = static_cast<std::uintmax_t>(-1);
	- };
	- do_mult(si.capacity, m_svfs.f_blocks);
	- do_mult(si.free, m_svfs.f_bfree);
	- do_mult(si.available, m_svfs.f_bavail);
	- return si;
	-}
	-
	-file_status __status(const path& p, std::error_code *ec) {
	- return detail::posix_stat(p, ec);
	-}
	-
	-file_status __symlink_status(const path& p, std::error_code *ec) {
	- return detail::posix_lstat(p, ec);
	-}
	-
	-path __system_complete(const path& p, std::error_code *ec) {
	- if (ec) ec->clear();
	- return absolute(p, current_path());
	-}
	-
	-path __temp_directory_path(std::error_code* ec) {
	- const char* env_paths[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"};
	- const char* ret = nullptr;
	-
	- for (auto& ep : env_paths)
	- if ((ret = std::getenv(ep)))
	- break;
	- if (ret == nullptr)
	- ret = "/tmp";
	-
	- path p(ret);
	- std::error_code m_ec;
	- if (!exists(p, m_ec) \|\| !is_directory(p, m_ec)) {
	- if (!m_ec \|\| m_ec == make_error_code(errc::no_such_file_or_directory))
	- m_ec = make_error_code(errc::not_a_directory);
	- set_or_throw(m_ec, ec, "temp_directory_path");
	- return {};
	- }
	-
	- if (ec)
	- ec->clear();
	- return p;
	-}
	-
	-// An absolute path is composed according to the table in [fs.op.absolute].
	-path absolute(const path& p, const path& base) {
	- auto root_name = p.root_name();
	- auto root_dir = p.root_directory();
	-
	- if (!root_name.empty() && !root_dir.empty())
	- return p;
	-
	- auto abs_base = base.is_absolute() ? base : absolute(base);
	-
	- /* !has_root_name && !has_root_dir */
	- if (root_name.empty() && root_dir.empty())
	- {
	- return abs_base / p;
	- }
	- else if (!root_name.empty()) /* has_root_name && !has_root_dir */
	- {
	- return root_name / abs_base.root_directory()
	- /
	- abs_base.relative_path() / p.relative_path();
	- }
	- else /* !has_root_name && has_root_dir */
	- {
	- if (abs_base.has_root_name())
	- return abs_base.root_name() / p;
	- // else p is absolute, return outside of block
	- }
	- return p;
	-}
	-
	-_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM

	Property changes on: projects/clang700-import/contrib/libc++/src/experimental/filesystem/operations.cpp
	___________________________________________________________________
	Deleted: svn:eol-style
	## -1 +0,0 ##
	-native
	\ No newline at end of property
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Deleted: svn:mime-type
	## -1 +0,0 ##
	-text/plain
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/experimental/filesystem/directory_iterator.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/experimental/filesystem/directory_iterator.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/experimental/filesystem/directory_iterator.cpp (nonexistent)
	@@ -1,342 +0,0 @@
	-//===------------------ directory_iterator.cpp ----------------------------===//
	-//
	-// The LLVM Compiler Infrastructure
	-//
	-// This file is dual licensed under the MIT and the University of Illinois Open
	-// Source Licenses. See LICENSE.TXT for details.
	-//
	-//===----------------------------------------------------------------------===//
	-
	-#include "experimental/filesystem"
	-#include "__config"
	-#if defined(_LIBCPP_WIN32API)
	-#define WIN32_LEAN_AND_MEAN
	-#include <Windows.h>
	-#else
	-#include <dirent.h>
	-#endif
	-#include <errno.h>
	-
	-_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
	-
	-namespace { namespace detail {
	-
	-#if !defined(_LIBCPP_WIN32API)
	-inline error_code capture_errno() {
	- _LIBCPP_ASSERT(errno, "Expected errno to be non-zero");
	- return error_code{errno, std::generic_category()};
	-}
	-#endif
	-
	-template <class ...Args>
	-inline bool set_or_throw(std::error_code& my_ec,
	- std::error_code* user_ec,
	- const char* msg, Args&&... args)
	-{
	- if (user_ec) {
	- *user_ec = my_ec;
	- return true;
	- }
	- __throw_filesystem_error(msg, std::forward<Args>(args)..., my_ec);
	- return false;
	-}
	-
	-#if !defined(_LIBCPP_WIN32API)
	-inline path::string_type posix_readdir(DIR *dir_stream, error_code& ec) {
	- struct dirent* dir_entry_ptr = nullptr;
	- errno = 0; // zero errno in order to detect errors
	- ec.clear();
	- if ((dir_entry_ptr = ::readdir(dir_stream)) == nullptr) {
	- if (errno)
	- ec = capture_errno();
	- return {};
	- } else {
	- return dir_entry_ptr->d_name;
	- }
	-}
	-#endif
	-
	-}} // namespace detail
	-
	-using detail::set_or_throw;
	-
	-#if defined(_LIBCPP_WIN32API)
	-class __dir_stream {
	-public:
	- __dir_stream() = delete;
	- __dir_stream& operator=(const __dir_stream&) = delete;
	-
	- __dir_stream(__dir_stream&& __ds) noexcept
	- : __stream_(__ds.__stream_), __root_(std::move(__ds.__root_)),
	- __entry_(std::move(__ds.__entry_)) {
	- __ds.__stream_ = INVALID_HANDLE_VALUE;
	- }
	-
	- __dir_stream(const path& root, directory_options opts, error_code& ec)
	- : __stream_(INVALID_HANDLE_VALUE), __root_(root) {
	- __stream_ = ::FindFirstFile(root.c_str(), &__data_);
	- if (__stream_ == INVALID_HANDLE_VALUE) {
	- ec = error_code(::GetLastError(), std::generic_category());
	- const bool ignore_permission_denied =
	- bool(opts & directory_options::skip_permission_denied);
	- if (ignore_permission_denied && ec.value() == ERROR_ACCESS_DENIED)
	- ec.clear();
	- return;
	- }
	- }
	-
	- ~__dir_stream() noexcept {
	- if (__stream_ == INVALID_HANDLE_VALUE)
	- return;
	- close();
	- }
	-
	- bool good() const noexcept { return __stream_ != INVALID_HANDLE_VALUE; }
	-
	- bool advance(error_code& ec) {
	- while (::FindNextFile(__stream_, &__data_)) {
	- if (!strcmp(__data_.cFileName, ".") \|\| strcmp(__data_.cFileName, ".."))
	- continue;
	- __entry_.assign(__root_ / __data_.cFileName);
	- return true;
	- }
	- ec = error_code(::GetLastError(), std::generic_category());
	- close();
	- return false;
	- }
	-
	-private:
	- std::error_code close() noexcept {
	- std::error_code ec;
	- if (!::FindClose(__stream_))
	- ec = error_code(::GetLastError(), std::generic_category());
	- __stream_ = INVALID_HANDLE_VALUE;
	- return ec;
	- }
	-
	- HANDLE __stream_{INVALID_HANDLE_VALUE};
	- WIN32_FIND_DATA __data_;
	-
	-public:
	- path __root_;
	- directory_entry __entry_;
	-};
	-#else
	-class __dir_stream {
	-public:
	- __dir_stream() = delete;
	- __dir_stream& operator=(const __dir_stream&) = delete;
	-
	- __dir_stream(__dir_stream&& other) noexcept
	- : __stream_(other.__stream_), __root_(std::move(other.__root_)),
	- __entry_(std::move(other.__entry_))
	- {
	- other.__stream_ = nullptr;
	- }
	-
	-
	- __dir_stream(const path& root, directory_options opts, error_code& ec)
	- : __stream_(nullptr),
	- __root_(root)
	- {
	- if ((__stream_ = ::opendir(root.c_str())) == nullptr) {
	- ec = detail::capture_errno();
	- const bool allow_eacess =
	- bool(opts & directory_options::skip_permission_denied);
	- if (allow_eacess && ec.value() == EACCES)
	- ec.clear();
	- return;
	- }
	- advance(ec);
	- }
	-
	- ~__dir_stream() noexcept
	- { if (__stream_) close(); }
	-
	- bool good() const noexcept { return __stream_ != nullptr; }
	-
	- bool advance(error_code &ec) {
	- while (true) {
	- auto str = detail::posix_readdir(__stream_, ec);
	- if (str == "." \|\| str == "..") {
	- continue;
	- } else if (ec \|\| str.empty()) {
	- close();
	- return false;
	- } else {
	- __entry_.assign(__root_ / str);
	- return true;
	- }
	- }
	- }
	-private:
	- std::error_code close() noexcept {
	- std::error_code m_ec;
	- if (::closedir(__stream_) == -1)
	- m_ec = detail::capture_errno();
	- __stream_ = nullptr;
	- return m_ec;
	- }
	-
	- DIR * __stream_{nullptr};
	-public:
	- path __root_;
	- directory_entry __entry_;
	-};
	-#endif
	-
	-// directory_iterator
	-
	-directory_iterator::directory_iterator(const path& p, error_code *ec,
	- directory_options opts)
	-{
	- std::error_code m_ec;
	- __imp_ = make_shared<__dir_stream>(p, opts, m_ec);
	- if (ec) *ec = m_ec;
	- if (!__imp_->good()) {
	- __imp_.reset();
	- if (m_ec)
	- set_or_throw(m_ec, ec,
	- "directory_iterator::directory_iterator(...)", p);
	- }
	-}
	-
	-directory_iterator& directory_iterator::__increment(error_code *ec)
	-{
	- _LIBCPP_ASSERT(__imp_, "Attempting to increment an invalid iterator");
	- std::error_code m_ec;
	- if (!__imp_->advance(m_ec)) {
	- __imp_.reset();
	- if (m_ec)
	- set_or_throw(m_ec, ec, "directory_iterator::operator++()");
	- } else {
	- if (ec) ec->clear();
	- }
	- return *this;
	-
	-}
	-
	-directory_entry const& directory_iterator::__dereference() const {
	- _LIBCPP_ASSERT(__imp_, "Attempting to dereference an invalid iterator");
	- return __imp_->__entry_;
	-}
	-
	-// recursive_directory_iterator
	-
	-struct recursive_directory_iterator::__shared_imp {
	- stack<__dir_stream> __stack_;
	- directory_options __options_;
	-};
	-
	-recursive_directory_iterator::recursive_directory_iterator(const path& p,
	- directory_options opt, error_code *ec)
	- : __imp_(nullptr), __rec_(true)
	-{
	- if (ec) ec->clear();
	- std::error_code m_ec;
	- __dir_stream new_s(p, opt, m_ec);
	- if (m_ec) set_or_throw(m_ec, ec, "recursive_directory_iterator", p);
	- if (m_ec \|\| !new_s.good()) return;
	-
	- __imp_ = _VSTD::make_shared<__shared_imp>();
	- __imp_->__options_ = opt;
	- __imp_->__stack_.push(_VSTD::move(new_s));
	-}
	-
	-void recursive_directory_iterator::__pop(error_code* ec)
	-{
	- _LIBCPP_ASSERT(__imp_, "Popping the end iterator");
	- if (ec) ec->clear();
	- __imp_->__stack_.pop();
	- if (__imp_->__stack_.size() == 0)
	- __imp_.reset();
	- else
	- __advance(ec);
	-}
	-
	-directory_options recursive_directory_iterator::options() const {
	- return __imp_->__options_;
	-}
	-
	-int recursive_directory_iterator::depth() const {
	- return __imp_->__stack_.size() - 1;
	-}
	-
	-const directory_entry& recursive_directory_iterator::__dereference() const {
	- return __imp_->__stack_.top().__entry_;
	-}
	-
	-recursive_directory_iterator&
	-recursive_directory_iterator::__increment(error_code *ec)
	-{
	- if (ec) ec->clear();
	- if (recursion_pending()) {
	- if (__try_recursion(ec) \|\| (ec && *ec))
	- return *this;
	- }
	- __rec_ = true;
	- __advance(ec);
	- return *this;
	-}
	-
	-void recursive_directory_iterator::__advance(error_code* ec) {
	- // REQUIRES: ec must be cleared before calling this function.
	- const directory_iterator end_it;
	- auto& stack = __imp_->__stack_;
	- std::error_code m_ec;
	- while (stack.size() > 0) {
	- if (stack.top().advance(m_ec))
	- return;
	- if (m_ec) break;
	- stack.pop();
	- }
	- __imp_.reset();
	- if (m_ec)
	- set_or_throw(m_ec, ec, "recursive_directory_iterator::operator++()");
	-}
	-
	-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();
	-
	- 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) {
	- 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;
	-}
	-
	-
	-_LIBCPP_END_NAMESPACE_EXPERIMENTAL_FILESYSTEM

	Property changes on: projects/clang700-import/contrib/libc++/src/experimental/filesystem/directory_iterator.cpp
	___________________________________________________________________
	Deleted: svn:eol-style
	## -1 +0,0 ##
	-native
	\ No newline at end of property
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Deleted: svn:mime-type
	## -1 +0,0 ##
	-text/plain
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/experimental/memory_resource.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/experimental/memory_resource.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/experimental/memory_resource.cpp (revision 337135)
	@@ -1,143 +1,154 @@
	//===------------------------ memory_resource.cpp -------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is dual licensed under the MIT and the University of Illinois Open
	// Source Licenses. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include "experimental/memory_resource"

	#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
	#include "atomic"
	#elif !defined(_LIBCPP_HAS_NO_THREADS)
	#include "mutex"
	#endif

	_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR

	// memory_resource

	//memory_resource::~memory_resource() {}

	// new_delete_resource()

	class _LIBCPP_TYPE_VIS __new_delete_memory_resource_imp
	: public memory_resource
	{
	public:
	~__new_delete_memory_resource_imp() = default;

	protected:
	virtual void* do_allocate(size_t __size, size_t __align)
	- { return __allocate(__size); }
	+ { return _VSTD::__libcpp_allocate(__size, __align); /* FIXME */}

	- virtual void do_deallocate(void * __p, size_t, size_t)
	- { _VSTD::__libcpp_deallocate(__p); }
	+ virtual void do_deallocate(void * __p, size_t, size_t __align)
	+ { _VSTD::__libcpp_deallocate(__p, __align); /* FIXME */ }

	virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT
	{ return &__other == this; }
	};

	// null_memory_resource()

	class _LIBCPP_TYPE_VIS __null_memory_resource_imp
	: public memory_resource
	{
	public:
	~__null_memory_resource_imp() = default;

	protected:
	virtual void* do_allocate(size_t, size_t) {
	__throw_bad_alloc();
	}
	virtual void do_deallocate(void *, size_t, size_t) {}
	virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT
	{ return &__other == this; }
	};

	namespace {

	union ResourceInitHelper {
	struct {
	__new_delete_memory_resource_imp new_delete_res;
	__null_memory_resource_imp null_res;
	} resources;
	char dummy;
	_LIBCPP_CONSTEXPR_AFTER_CXX11 ResourceInitHelper() : resources() {}
	~ResourceInitHelper() {}
	};
	+
	+// Detect if the init_priority attribute is supported.
	+#if (defined(_LIBCPP_COMPILER_GCC) && defined(__APPLE__)) \
	+ \|\| defined(_LIBCPP_COMPILER_MSVC)
	+// GCC on Apple doesn't support the init priority attribute,
	+// and MSVC doesn't support any GCC attributes.
	+# define _LIBCPP_INIT_PRIORITY_MAX
	+#else
	+# define _LIBCPP_INIT_PRIORITY_MAX __attribute__((init_priority(101)))
	+#endif
	+
	// When compiled in C++14 this initialization should be a constant expression.
	// Only in C++11 is "init_priority" needed to ensure initialization order.
	#if _LIBCPP_STD_VER > 11
	_LIBCPP_SAFE_STATIC
	#endif
	-ResourceInitHelper res_init __attribute__((init_priority (101)));
	+ResourceInitHelper res_init _LIBCPP_INIT_PRIORITY_MAX;

	} // end namespace


	memory_resource * new_delete_resource() _NOEXCEPT {
	return &res_init.resources.new_delete_res;
	}

	memory_resource * null_memory_resource() _NOEXCEPT {
	return &res_init.resources.null_res;
	}

	// default_memory_resource()

	static memory_resource *
	__default_memory_resource(bool set = false, memory_resource * new_res = nullptr) _NOEXCEPT
	{
	#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
	_LIBCPP_SAFE_STATIC static atomic<memory_resource*> __res =
	ATOMIC_VAR_INIT(&res_init.resources.new_delete_res);
	if (set) {
	new_res = new_res ? new_res : new_delete_resource();
	// TODO: Can a weaker ordering be used?
	return _VSTD::atomic_exchange_explicit(
	&__res, new_res, memory_order::memory_order_acq_rel);
	}
	else {
	return _VSTD::atomic_load_explicit(
	&__res, memory_order::memory_order_acquire);
	}
	#elif !defined(_LIBCPP_HAS_NO_THREADS)
	_LIBCPP_SAFE_STATIC static memory_resource * res = &res_init.resources.new_delete_res;
	static mutex res_lock;
	if (set) {
	new_res = new_res ? new_res : new_delete_resource();
	lock_guard<mutex> guard(res_lock);
	memory_resource * old_res = res;
	res = new_res;
	return old_res;
	} else {
	lock_guard<mutex> guard(res_lock);
	return res;
	}
	#else
	_LIBCPP_SAFE_STATIC static memory_resource* res = &res_init.resources.new_delete_res;
	if (set) {
	new_res = new_res ? new_res : new_delete_resource();
	memory_resource * old_res = res;
	res = new_res;
	return old_res;
	} else {
	return res;
	}
	#endif
	}

	memory_resource * get_default_resource() _NOEXCEPT
	{
	return __default_memory_resource();
	}

	memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT
	{
	return __default_memory_resource(true, __new_res);
	}

	_LIBCPP_END_NAMESPACE_LFTS_PMR

	Property changes on: projects/clang700-import/contrib/libc++/src/experimental/memory_resource.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/filesystem/directory_iterator.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/filesystem/directory_iterator.cpp (nonexistent)
	+++ projects/clang700-import/contrib/libc++/src/filesystem/directory_iterator.cpp (revision 337135)
	@@ -0,0 +1,396 @@
	+//===------------------ directory_iterator.cpp ----------------------------===//
	+//
	+// The LLVM Compiler Infrastructure
	+//
	+// This file is dual licensed under the MIT and the University of Illinois Open
	+// Source Licenses. See LICENSE.TXT for details.
	+//
	+//===----------------------------------------------------------------------===//
	+
	+#include "filesystem"
	+#include "__config"
	+#if defined(_LIBCPP_WIN32API)
	+#define WIN32_LEAN_AND_MEAN
	+#include <Windows.h>
	+#else
	+#include <dirent.h>
	+#endif
	+#include <errno.h>
	+
	+#include "filesystem_common.h"
	+
	+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
	+
	+namespace detail {
	+namespace {
	+
	+#if !defined(_LIBCPP_WIN32API)
	+template <class DirEntT, class = decltype(DirEntT::d_type)>
	+static file_type get_file_type(DirEntT* ent, int) {
	+ switch (ent->d_type) {
	+ case DT_BLK:
	+ return file_type::block;
	+ case DT_CHR:
	+ return file_type::character;
	+ case DT_DIR:
	+ return file_type::directory;
	+ case DT_FIFO:
	+ return file_type::fifo;
	+ case DT_LNK:
	+ return file_type::symlink;
	+ case DT_REG:
	+ return file_type::regular;
	+ case DT_SOCK:
	+ return file_type::socket;
	+ // Unlike in lstat, hitting "unknown" here simply means that the underlying
	+ // filesystem doesn't support d_type. Report is as 'none' so we correctly
	+ // set the cache to empty.
	+ case DT_UNKNOWN:
	+ break;
	+ }
	+ return file_type::none;
	+}
	+
	+template <class DirEntT>
	+static file_type get_file_type(DirEntT* ent, long) {
	+ return file_type::none;
	+}
	+
	+static pair<string_view, file_type> posix_readdir(DIR* dir_stream,
	+ error_code& ec) {
	+ struct dirent* dir_entry_ptr = nullptr;
	+ errno = 0; // zero errno in order to detect errors
	+ ec.clear();
	+ if ((dir_entry_ptr = ::readdir(dir_stream)) == nullptr) {
	+ if (errno)
	+ ec = capture_errno();
	+ return {};
	+ } else {
	+ return {dir_entry_ptr->d_name, get_file_type(dir_entry_ptr, 0)};
	+ }
	+}
	+#else
	+
	+static file_type get_file_type(const WIN32_FIND_DATA& data) {
	+ //auto attrs = data.dwFileAttributes;
	+ // FIXME(EricWF)
	+ return file_type::unknown;
	+}
	+static uintmax_t get_file_size(const WIN32_FIND_DATA& data) {
	+ return (data.nFileSizeHight * (MAXDWORD + 1)) + data.nFileSizeLow;
	+}
	+static file_time_type get_write_time(const WIN32_FIND_DATA& data) {
	+ ULARGE_INTEGER tmp;
	+ FILETIME& time = data.ftLastWriteTime;
	+ tmp.u.LowPart = time.dwLowDateTime;
	+ tmp.u.HighPart = time.dwHighDateTime;
	+ return file_time_type(file_time_type::duration(time.QuadPart));
	+}
	+
	+#endif
	+
	+} // namespace
	+} // namespace detail
	+
	+using detail::ErrorHandler;
	+
	+#if defined(_LIBCPP_WIN32API)
	+class __dir_stream {
	+public:
	+ __dir_stream() = delete;
	+ __dir_stream& operator=(const __dir_stream&) = delete;
	+
	+ __dir_stream(__dir_stream&& __ds) noexcept : __stream_(__ds.__stream_),
	+ __root_(move(__ds.__root_)),
	+ __entry_(move(__ds.__entry_)) {
	+ __ds.__stream_ = INVALID_HANDLE_VALUE;
	+ }
	+
	+ __dir_stream(const path& root, directory_options opts, error_code& ec)
	+ : __stream_(INVALID_HANDLE_VALUE), __root_(root) {
	+ __stream_ = ::FindFirstFileEx(root.c_str(), &__data_);
	+ if (__stream_ == INVALID_HANDLE_VALUE) {
	+ ec = error_code(::GetLastError(), generic_category());
	+ const bool ignore_permission_denied =
	+ bool(opts & directory_options::skip_permission_denied);
	+ if (ignore_permission_denied && ec.value() == ERROR_ACCESS_DENIED)
	+ ec.clear();
	+ return;
	+ }
	+ }
	+
	+ ~__dir_stream() noexcept {
	+ if (__stream_ == INVALID_HANDLE_VALUE)
	+ return;
	+ close();
	+ }
	+
	+ bool good() const noexcept { return __stream_ != INVALID_HANDLE_VALUE; }
	+
	+ bool advance(error_code& ec) {
	+ while (::FindNextFile(__stream_, &__data_)) {
	+ if (!strcmp(__data_.cFileName, ".") \|\| strcmp(__data_.cFileName, ".."))
	+ continue;
	+ // FIXME: Cache more of this
	+ //directory_entry::__cached_data cdata;
	+ //cdata.__type_ = get_file_type(__data_);
	+ //cdata.__size_ = get_file_size(__data_);
	+ //cdata.__write_time_ = get_write_time(__data_);
	+ __entry_.__assign_iter_entry(
	+ __root_ / __data_.cFileName,
	+ directory_entry::__create_iter_result(get_file_type(__data)));
	+ return true;
	+ }
	+ ec = error_code(::GetLastError(), generic_category());
	+ close();
	+ return false;
	+ }
	+
	+private:
	+ error_code close() noexcept {
	+ error_code ec;
	+ if (!::FindClose(__stream_))
	+ ec = error_code(::GetLastError(), generic_category());
	+ __stream_ = INVALID_HANDLE_VALUE;
	+ return ec;
	+ }
	+
	+ HANDLE __stream_{INVALID_HANDLE_VALUE};
	+ WIN32_FIND_DATA __data_;
	+
	+public:
	+ path __root_;
	+ directory_entry __entry_;
	+};
	+#else
	+class __dir_stream {
	+public:
	+ __dir_stream() = delete;
	+ __dir_stream& operator=(const __dir_stream&) = delete;
	+
	+ __dir_stream(__dir_stream&& other) noexcept : __stream_(other.__stream_),
	+ __root_(move(other.__root_)),
	+ __entry_(move(other.__entry_)) {
	+ other.__stream_ = nullptr;
	+ }
	+
	+ __dir_stream(const path& root, directory_options opts, error_code& ec)
	+ : __stream_(nullptr), __root_(root) {
	+ if ((__stream_ = ::opendir(root.c_str())) == nullptr) {
	+ ec = detail::capture_errno();
	+ const bool allow_eacess =
	+ bool(opts & directory_options::skip_permission_denied);
	+ if (allow_eacess && ec.value() == EACCES)
	+ ec.clear();
	+ return;
	+ }
	+ advance(ec);
	+ }
	+
	+ ~__dir_stream() noexcept {
	+ if (__stream_)
	+ close();
	+ }
	+
	+ bool good() const noexcept { return __stream_ != nullptr; }
	+
	+ bool advance(error_code& ec) {
	+ while (true) {
	+ auto str_type_pair = detail::posix_readdir(__stream_, ec);
	+ auto& str = str_type_pair.first;
	+ if (str == "." \|\| str == "..") {
	+ continue;
	+ } else if (ec \|\| str.empty()) {
	+ close();
	+ return false;
	+ } else {
	+ __entry_.__assign_iter_entry(
	+ __root_ / str,
	+ directory_entry::__create_iter_result(str_type_pair.second));
	+ return true;
	+ }
	+ }
	+ }
	+
	+private:
	+ error_code close() noexcept {
	+ error_code m_ec;
	+ if (::closedir(__stream_) == -1)
	+ m_ec = detail::capture_errno();
	+ __stream_ = nullptr;
	+ return m_ec;
	+ }
	+
	+ DIR* __stream_{nullptr};
	+
	+public:
	+ path __root_;
	+ directory_entry __entry_;
	+};
	+#endif
	+
	+// directory_iterator
	+
	+directory_iterator::directory_iterator(const path& p, error_code* ec,
	+ directory_options opts) {
	+ ErrorHandler<void> err("directory_iterator::directory_iterator(...)", ec, &p);
	+
	+ error_code m_ec;
	+ __imp_ = make_shared<__dir_stream>(p, opts, m_ec);
	+ if (ec)
	+ *ec = m_ec;
	+ if (!__imp_->good()) {
	+ __imp_.reset();
	+ if (m_ec)
	+ err.report(m_ec);
	+ }
	+}
	+
	+directory_iterator& directory_iterator::__increment(error_code* ec) {
	+ _LIBCPP_ASSERT(__imp_, "Attempting to increment an invalid iterator");
	+ ErrorHandler<void> err("directory_iterator::operator++()", ec);
	+
	+ error_code m_ec;
	+ if (!__imp_->advance(m_ec)) {
	+ path root = move(__imp_->__root_);
	+ __imp_.reset();
	+ if (m_ec)
	+ err.report(m_ec, "at root \"%s\"", root);
	+ }
	+ return *this;
	+}
	+
	+directory_entry const& directory_iterator::__dereference() const {
	+ _LIBCPP_ASSERT(__imp_, "Attempting to dereference an invalid iterator");
	+ return __imp_->__entry_;
	+}
	+
	+// recursive_directory_iterator
	+
	+struct recursive_directory_iterator::__shared_imp {
	+ stack<__dir_stream> __stack_;
	+ directory_options __options_;
	+};
	+
	+recursive_directory_iterator::recursive_directory_iterator(
	+ const path& p, directory_options opt, error_code* ec)
	+ : __imp_(nullptr), __rec_(true) {
	+ ErrorHandler<void> err("recursive_directory_iterator", ec, &p);
	+
	+ error_code m_ec;
	+ __dir_stream new_s(p, opt, m_ec);
	+ if (m_ec)
	+ err.report(m_ec);
	+ if (m_ec \|\| !new_s.good())
	+ return;
	+
	+ __imp_ = make_shared<__shared_imp>();
	+ __imp_->__options_ = opt;
	+ __imp_->__stack_.push(move(new_s));
	+}
	+
	+void recursive_directory_iterator::__pop(error_code* ec) {
	+ _LIBCPP_ASSERT(__imp_, "Popping the end iterator");
	+ if (ec)
	+ ec->clear();
	+ __imp_->__stack_.pop();
	+ if (__imp_->__stack_.size() == 0)
	+ __imp_.reset();
	+ else
	+ __advance(ec);
	+}
	+
	+directory_options recursive_directory_iterator::options() const {
	+ return __imp_->__options_;
	+}
	+
	+int recursive_directory_iterator::depth() const {
	+ return __imp_->__stack_.size() - 1;
	+}
	+
	+const directory_entry& recursive_directory_iterator::__dereference() const {
	+ return __imp_->__stack_.top().__entry_;
	+}
	+
	+recursive_directory_iterator&
	+recursive_directory_iterator::__increment(error_code* ec) {
	+ if (ec)
	+ ec->clear();
	+ if (recursion_pending()) {
	+ if (__try_recursion(ec) \|\| (ec && *ec))
	+ return *this;
	+ }
	+ __rec_ = true;
	+ __advance(ec);
	+ return *this;
	+}
	+
	+void recursive_directory_iterator::__advance(error_code* ec) {
	+ ErrorHandler<void> err("recursive_directory_iterator::operator++()", ec);
	+
	+ const directory_iterator end_it;
	+ auto& stack = __imp_->__stack_;
	+ error_code m_ec;
	+ while (stack.size() > 0) {
	+ if (stack.top().advance(m_ec))
	+ return;
	+ if (m_ec)
	+ break;
	+ stack.pop();
	+ }
	+
	+ if (m_ec) {
	+ path root = move(stack.top().__root_);
	+ __imp_.reset();
	+ err.report(m_ec, "at root \"%s\"", root);
	+ } else {
	+ __imp_.reset();
	+ }
	+}
	+
	+bool recursive_directory_iterator::__try_recursion(error_code* ec) {
	+ ErrorHandler<void> err("recursive_directory_iterator::operator++()", ec);
	+
	+ bool rec_sym = bool(options() & directory_options::follow_directory_symlink);
	+
	+ auto& curr_it = __imp_->__stack_.top();
	+
	+ bool skip_rec = false;
	+ error_code m_ec;
	+ if (!rec_sym) {
	+ file_status st(curr_it.__entry_.__get_sym_ft(&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_.__get_ft(&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(move(new_it));
	+ return true;
	+ }
	+ }
	+ 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 {
	+ path at_ent = move(curr_it.__entry_.__p_);
	+ __imp_.reset();
	+ err.report(m_ec, "attempting recursion into \"%s\"", at_ent);
	+ }
	+ }
	+ return false;
	+}
	+
	+_LIBCPP_END_NAMESPACE_FILESYSTEM

	Property changes on: projects/clang700-import/contrib/libc++/src/filesystem/directory_iterator.cpp
	___________________________________________________________________
	Added: svn:eol-style
	## -0,0 +1 ##
	+native
	\ No newline at end of property
	Added: svn:mime-type
	## -0,0 +1 ##
	+text/plain
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/filesystem/filesystem_common.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/filesystem/filesystem_common.h (nonexistent)
	+++ projects/clang700-import/contrib/libc++/src/filesystem/filesystem_common.h (revision 337135)
	@@ -0,0 +1,429 @@
	+//===----------------------------------------------------------------------===////
	+//
	+// 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 FILESYSTEM_COMMON_H
	+#define FILESYSTEM_COMMON_H
	+
	+#include "__config"
	+#include "filesystem"
	+#include "array"
	+#include "chrono"
	+#include "cstdlib"
	+#include "climits"
	+
	+#include <unistd.h>
	+#include <sys/stat.h>
	+#include <sys/statvfs.h>
	+#include <sys/time.h> // for ::utimes as used in __last_write_time
	+#include <fcntl.h> /* values for fchmodat */
	+
	+#include "../include/apple_availability.h"
	+
	+#if !defined(__APPLE__)
	+// We can use the presence of UTIME_OMIT to detect platforms that provide
	+// utimensat.
	+#if defined(UTIME_OMIT)
	+#define _LIBCPP_USE_UTIMENSAT
	+#endif
	+#endif
	+
	+#if defined(__GNUC__)
	+#pragma GCC diagnostic push
	+#pragma GCC diagnostic ignored "-Wunused-function"
	+#endif
	+
	+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
	+
	+namespace detail {
	+namespace {
	+
	+static string format_string_imp(const char* msg, ...) {
	+ // we might need a second shot at this, so pre-emptivly make a copy
	+ struct GuardVAList {
	+ va_list& target;
	+ bool active = true;
	+ GuardVAList(va_list& target) : target(target), active(true) {}
	+ void clear() {
	+ if (active)
	+ va_end(target);
	+ active = false;
	+ }
	+ ~GuardVAList() {
	+ if (active)
	+ va_end(target);
	+ }
	+ };
	+ va_list args;
	+ va_start(args, msg);
	+ GuardVAList args_guard(args);
	+
	+ va_list args_cp;
	+ va_copy(args_cp, args);
	+ GuardVAList args_copy_guard(args_cp);
	+
	+ array<char, 256> local_buff;
	+ size_t size = local_buff.size();
	+ auto ret = ::vsnprintf(local_buff.data(), size, msg, args_cp);
	+
	+ args_copy_guard.clear();
	+
	+ // handle empty expansion
	+ if (ret == 0)
	+ return string{};
	+ if (static_cast<size_t>(ret) < size)
	+ return string(local_buff.data());
	+
	+ // we did not provide a long enough buffer on our first attempt.
	+ // add 1 to size to account for null-byte in size cast to prevent overflow
	+ size = static_cast<size_t>(ret) + 1;
	+ auto buff_ptr = unique_ptr<char[]>(new char[size]);
	+ ret = ::vsnprintf(buff_ptr.get(), size, msg, args);
	+ return string(buff_ptr.get());
	+}
	+
	+const char* unwrap(string const& s) { return s.c_str(); }
	+const char* unwrap(path const& p) { return p.native().c_str(); }
	+template <class Arg>
	+Arg const& unwrap(Arg const& a) {
	+ static_assert(!is_class<Arg>::value, "cannot pass class here");
	+ return a;
	+}
	+
	+template <class... Args>
	+string format_string(const char* fmt, Args const&... args) {
	+ return format_string_imp(fmt, unwrap(args)...);
	+}
	+
	+error_code capture_errno() {
	+ _LIBCPP_ASSERT(errno, "Expected errno to be non-zero");
	+ return error_code(errno, generic_category());
	+}
	+
	+template <class T>
	+T error_value();
	+template <>
	+_LIBCPP_CONSTEXPR_AFTER_CXX11 void error_value<void>() {}
	+template <>
	+bool error_value<bool>() {
	+ return false;
	+}
	+template <>
	+uintmax_t error_value<uintmax_t>() {
	+ return uintmax_t(-1);
	+}
	+template <>
	+_LIBCPP_CONSTEXPR_AFTER_CXX11 file_time_type error_value<file_time_type>() {
	+ return file_time_type::min();
	+}
	+template <>
	+path error_value<path>() {
	+ return {};
	+}
	+
	+template <class T>
	+struct ErrorHandler {
	+ const char* func_name;
	+ error_code* ec = nullptr;
	+ const path* p1 = nullptr;
	+ const path* p2 = nullptr;
	+
	+ ErrorHandler(const char* fname, error_code* ec, const path* p1 = nullptr,
	+ const path* p2 = nullptr)
	+ : func_name(fname), ec(ec), p1(p1), p2(p2) {
	+ if (ec)
	+ ec->clear();
	+ }
	+
	+ T report(const error_code& m_ec) const {
	+ if (ec) {
	+ *ec = m_ec;
	+ return error_value<T>();
	+ }
	+ string what = string("in ") + func_name;
	+ switch (bool(p1) + bool(p2)) {
	+ case 0:
	+ __throw_filesystem_error(what, m_ec);
	+ case 1:
	+ __throw_filesystem_error(what, *p1, m_ec);
	+ case 2:
	+ __throw_filesystem_error(what, p1, p2, m_ec);
	+ }
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ template <class... Args>
	+ T report(const error_code& m_ec, const char* msg, Args const&... args) const {
	+ if (ec) {
	+ *ec = m_ec;
	+ return error_value<T>();
	+ }
	+ string what =
	+ string("in ") + func_name + ": " + format_string(msg, args...);
	+ switch (bool(p1) + bool(p2)) {
	+ case 0:
	+ __throw_filesystem_error(what, m_ec);
	+ case 1:
	+ __throw_filesystem_error(what, *p1, m_ec);
	+ case 2:
	+ __throw_filesystem_error(what, p1, p2, m_ec);
	+ }
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ T report(errc const& err) const { return report(make_error_code(err)); }
	+
	+ template <class... Args>
	+ T report(errc const& err, const char* msg, Args const&... args) const {
	+ return report(make_error_code(err), msg, args...);
	+ }
	+
	+private:
	+ ErrorHandler(ErrorHandler const&) = delete;
	+ ErrorHandler& operator=(ErrorHandler const&) = delete;
	+};
	+
	+using chrono::duration;
	+using chrono::duration_cast;
	+
	+using TimeSpec = struct ::timespec;
	+using StatT = struct ::stat;
	+
	+template <class FileTimeT, class TimeT,
	+ bool IsFloat = is_floating_point<typename FileTimeT::rep>::value>
	+struct time_util_base {
	+ using rep = typename FileTimeT::rep;
	+ using fs_duration = typename FileTimeT::duration;
	+ using fs_seconds = duration<rep>;
	+ using fs_nanoseconds = duration<rep, nano>;
	+ using fs_microseconds = duration<rep, micro>;
	+
	+ static constexpr rep max_seconds =
	+ duration_cast<fs_seconds>(FileTimeT::duration::max()).count();
	+
	+ static constexpr rep max_nsec =
	+ duration_cast<fs_nanoseconds>(FileTimeT::duration::max() -
	+ fs_seconds(max_seconds))
	+ .count();
	+
	+ static constexpr rep min_seconds =
	+ duration_cast<fs_seconds>(FileTimeT::duration::min()).count();
	+
	+ static constexpr rep min_nsec_timespec =
	+ duration_cast<fs_nanoseconds>(
	+ (FileTimeT::duration::min() - fs_seconds(min_seconds)) +
	+ fs_seconds(1))
	+ .count();
	+
	+private:
	+#if _LIBCPP_STD_VER > 11 && !defined(_LIBCPP_HAS_NO_CXX14_CONSTEXPR)
	+ static constexpr fs_duration get_min_nsecs() {
	+ return duration_cast<fs_duration>(
	+ fs_nanoseconds(min_nsec_timespec) -
	+ duration_cast<fs_nanoseconds>(fs_seconds(1)));
	+ }
	+ // Static assert that these values properly round trip.
	+ static_assert(fs_seconds(min_seconds) + get_min_nsecs() ==
	+ FileTimeT::duration::min(),
	+ "value doesn't roundtrip");
	+
	+ static constexpr bool check_range() {
	+ // This kinda sucks, but it's what happens when we don't have __int128_t.
	+ if (sizeof(TimeT) == sizeof(rep)) {
	+ typedef duration<long long, ratio<3600 * 24 * 365> > Years;
	+ return duration_cast<Years>(fs_seconds(max_seconds)) > Years(250) &&
	+ duration_cast<Years>(fs_seconds(min_seconds)) < Years(-250);
	+ }
	+ return max_seconds >= numeric_limits<TimeT>::max() &&
	+ min_seconds <= numeric_limits<TimeT>::min();
	+ }
	+ static_assert(check_range(), "the representable range is unacceptable small");
	+#endif
	+};
	+
	+template <class FileTimeT, class TimeT>
	+struct time_util_base<FileTimeT, TimeT, true> {
	+ using rep = typename FileTimeT::rep;
	+ using fs_duration = typename FileTimeT::duration;
	+ using fs_seconds = duration<rep>;
	+ using fs_nanoseconds = duration<rep, nano>;
	+ using fs_microseconds = duration<rep, micro>;
	+
	+ static const rep max_seconds;
	+ static const rep max_nsec;
	+ static const rep min_seconds;
	+ static const rep min_nsec_timespec;
	+};
	+
	+template <class FileTimeT, class TimeT>
	+const typename FileTimeT::rep
	+ time_util_base<FileTimeT, TimeT, true>::max_seconds =
	+ duration_cast<fs_seconds>(FileTimeT::duration::max()).count();
	+
	+template <class FileTimeT, class TimeT>
	+const typename FileTimeT::rep time_util_base<FileTimeT, TimeT, true>::max_nsec =
	+ duration_cast<fs_nanoseconds>(FileTimeT::duration::max() -
	+ fs_seconds(max_seconds))
	+ .count();
	+
	+template <class FileTimeT, class TimeT>
	+const typename FileTimeT::rep
	+ time_util_base<FileTimeT, TimeT, true>::min_seconds =
	+ duration_cast<fs_seconds>(FileTimeT::duration::min()).count();
	+
	+template <class FileTimeT, class TimeT>
	+const typename FileTimeT::rep
	+ time_util_base<FileTimeT, TimeT, true>::min_nsec_timespec =
	+ duration_cast<fs_nanoseconds>((FileTimeT::duration::min() -
	+ fs_seconds(min_seconds)) +
	+ fs_seconds(1))
	+ .count();
	+
	+template <class FileTimeT, class TimeT, class TimeSpecT>
	+struct time_util : time_util_base<FileTimeT, TimeT> {
	+ using Base = time_util_base<FileTimeT, TimeT>;
	+ using Base::max_nsec;
	+ using Base::max_seconds;
	+ using Base::min_nsec_timespec;
	+ using Base::min_seconds;
	+
	+ using typename Base::fs_duration;
	+ using typename Base::fs_microseconds;
	+ using typename Base::fs_nanoseconds;
	+ using typename Base::fs_seconds;
	+
	+public:
	+ template <class CType, class ChronoType>
	+ static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool checked_set(CType* out,
	+ ChronoType time) {
	+ using Lim = numeric_limits<CType>;
	+ if (time > Lim::max() \|\| time < Lim::min())
	+ return false;
	+ *out = static_cast<CType>(time);
	+ return true;
	+ }
	+
	+ static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool is_representable(TimeSpecT tm) {
	+ if (tm.tv_sec >= 0) {
	+ return tm.tv_sec < max_seconds \|\|
	+ (tm.tv_sec == max_seconds && tm.tv_nsec <= max_nsec);
	+ } else if (tm.tv_sec == (min_seconds - 1)) {
	+ return tm.tv_nsec >= min_nsec_timespec;
	+ } else {
	+ return tm.tv_sec >= min_seconds;
	+ }
	+ }
	+
	+ static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool is_representable(FileTimeT tm) {
	+ auto secs = duration_cast<fs_seconds>(tm.time_since_epoch());
	+ auto nsecs = duration_cast<fs_nanoseconds>(tm.time_since_epoch() - secs);
	+ if (nsecs.count() < 0) {
	+ secs = secs + fs_seconds(1);
	+ nsecs = nsecs + fs_seconds(1);
	+ }
	+ using TLim = numeric_limits<TimeT>;
	+ if (secs.count() >= 0)
	+ return secs.count() <= TLim::max();
	+ return secs.count() >= TLim::min();
	+ }
	+
	+ static _LIBCPP_CONSTEXPR_AFTER_CXX11 FileTimeT
	+ convert_from_timespec(TimeSpecT tm) {
	+ if (tm.tv_sec >= 0 \|\| tm.tv_nsec == 0) {
	+ return FileTimeT(fs_seconds(tm.tv_sec) +
	+ duration_cast<fs_duration>(fs_nanoseconds(tm.tv_nsec)));
	+ } else { // tm.tv_sec < 0
	+ auto adj_subsec = duration_cast<fs_duration>(fs_seconds(1) -
	+ fs_nanoseconds(tm.tv_nsec));
	+ auto Dur = fs_seconds(tm.tv_sec + 1) - adj_subsec;
	+ return FileTimeT(Dur);
	+ }
	+ }
	+
	+ template <class SubSecT>
	+ static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool
	+ set_times_checked(TimeT* sec_out, SubSecT* subsec_out, FileTimeT tp) {
	+ auto dur = tp.time_since_epoch();
	+ auto sec_dur = duration_cast<fs_seconds>(dur);
	+ auto subsec_dur = duration_cast<fs_nanoseconds>(dur - sec_dur);
	+ // The tv_nsec and tv_usec fields must not be negative so adjust accordingly
	+ if (subsec_dur.count() < 0) {
	+ if (sec_dur.count() > min_seconds) {
	+ sec_dur = sec_dur - fs_seconds(1);
	+ subsec_dur = subsec_dur + fs_seconds(1);
	+ } else {
	+ subsec_dur = fs_nanoseconds::zero();
	+ }
	+ }
	+ return checked_set(sec_out, sec_dur.count()) &&
	+ checked_set(subsec_out, subsec_dur.count());
	+ }
	+ static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool convert_to_timespec(TimeSpecT& dest,
	+ FileTimeT tp) {
	+ if (!is_representable(tp))
	+ return false;
	+ return set_times_checked(&dest.tv_sec, &dest.tv_nsec, tp);
	+ }
	+};
	+
	+using fs_time = time_util<file_time_type, time_t, TimeSpec>;
	+
	+#if defined(__APPLE__)
	+TimeSpec extract_mtime(StatT const& st) { return st.st_mtimespec; }
	+TimeSpec extract_atime(StatT const& st) { return st.st_atimespec; }
	+#else
	+TimeSpec extract_mtime(StatT const& st) { return st.st_mtim; }
	+TimeSpec extract_atime(StatT const& st) { return st.st_atim; }
	+#endif
	+
	+// allow the utimes implementation to compile even it we're not going
	+// to use it.
	+
	+bool posix_utimes(const path& p, std::array<TimeSpec, 2> const& TS,
	+ error_code& ec) {
	+ using namespace chrono;
	+ auto Convert = [](long nsec) {
	+ using int_type = decltype(std::declval< ::timeval>().tv_usec);
	+ auto dur = duration_cast<microseconds>(nanoseconds(nsec)).count();
	+ return static_cast<int_type>(dur);
	+ };
	+ struct ::timeval ConvertedTS[2] = {{TS[0].tv_sec, Convert(TS[0].tv_nsec)},
	+ {TS[1].tv_sec, Convert(TS[1].tv_nsec)}};
	+ if (::utimes(p.c_str(), ConvertedTS) == -1) {
	+ ec = capture_errno();
	+ return true;
	+ }
	+ return false;
	+}
	+
	+#if defined(_LIBCPP_USE_UTIMENSAT)
	+bool posix_utimensat(const path& p, std::array<TimeSpec, 2> const& TS,
	+ error_code& ec) {
	+ if (::utimensat(AT_FDCWD, p.c_str(), TS.data(), 0) == -1) {
	+ ec = capture_errno();
	+ return true;
	+ }
	+ return false;
	+}
	+#endif
	+
	+bool set_file_times(const path& p, std::array<TimeSpec, 2> const& TS,
	+ error_code& ec) {
	+#if !defined(_LIBCPP_USE_UTIMENSAT)
	+ return posix_utimes(p, TS, ec);
	+#else
	+ return posix_utimensat(p, TS, ec);
	+#endif
	+}
	+
	+} // namespace
	+} // end namespace detail
	+
	+_LIBCPP_END_NAMESPACE_FILESYSTEM
	+
	+#endif // FILESYSTEM_COMMON_H

	Property changes on: projects/clang700-import/contrib/libc++/src/filesystem/filesystem_common.h
	___________________________________________________________________
	Added: svn:eol-style
	## -0,0 +1 ##
	+native
	\ No newline at end of property
	Added: svn:mime-type
	## -0,0 +1 ##
	+text/plain
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/filesystem/int128_builtins.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/filesystem/int128_builtins.cpp (nonexistent)
	+++ projects/clang700-import/contrib/libc++/src/filesystem/int128_builtins.cpp (revision 337135)
	@@ -0,0 +1,55 @@
	+/*===-- int128_builtins.cpp - Implement __muloti4 --------------------------===
	+ *
	+ * The LLVM Compiler Infrastructure
	+ *
	+ * This file is dual licensed under the MIT and the University of Illinois Open
	+ * Source Licenses. See LICENSE.TXT for details.
	+ *
	+ * ===----------------------------------------------------------------------===
	+ *
	+ * This file implements __muloti4, and is stolen from the compiler_rt library.
	+ *
	+ * FIXME: we steal and re-compile it into filesystem, which uses __int128_t,
	+ * and requires this builtin when sanitized. See llvm.org/PR30643
	+ *
	+ * ===----------------------------------------------------------------------===
	+ */
	+#include "__config"
	+#include "climits"
	+
	+#if !defined(_LIBCPP_HAS_NO_INT128)
	+
	+extern "C" __attribute__((no_sanitize("undefined")))
	+__int128_t __muloti4(__int128_t a, __int128_t b, int* overflow) {
	+ const int N = (int)(sizeof(__int128_t) * CHAR_BIT);
	+ const __int128_t MIN = (__int128_t)1 << (N - 1);
	+ const __int128_t MAX = ~MIN;
	+ *overflow = 0;
	+ __int128_t result = a * b;
	+ if (a == MIN) {
	+ if (b != 0 && b != 1)
	+ *overflow = 1;
	+ return result;
	+ }
	+ if (b == MIN) {
	+ if (a != 0 && a != 1)
	+ *overflow = 1;
	+ return result;
	+ }
	+ __int128_t sa = a >> (N - 1);
	+ __int128_t abs_a = (a ^ sa) - sa;
	+ __int128_t sb = b >> (N - 1);
	+ __int128_t abs_b = (b ^ sb) - sb;
	+ if (abs_a < 2 \|\| abs_b < 2)
	+ return result;
	+ if (sa == sb) {
	+ if (abs_a > MAX / abs_b)
	+ *overflow = 1;
	+ } else {
	+ if (abs_a > MIN / -abs_b)
	+ *overflow = 1;
	+ }
	+ return result;
	+}
	+
	+#endif

	Property changes on: projects/clang700-import/contrib/libc++/src/filesystem/int128_builtins.cpp
	___________________________________________________________________
	Added: svn:eol-style
	## -0,0 +1 ##
	+native
	\ No newline at end of property
	Added: svn:mime-type
	## -0,0 +1 ##
	+text/plain
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/filesystem/operations.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/filesystem/operations.cpp (nonexistent)
	+++ projects/clang700-import/contrib/libc++/src/filesystem/operations.cpp (revision 337135)
	@@ -0,0 +1,1686 @@
	+//===--------------------- filesystem/ops.cpp -----------------------------===//
	+//
	+// The LLVM Compiler Infrastructure
	+//
	+// This file is dual licensed under the MIT and the University of Illinois Open
	+// Source Licenses. See LICENSE.TXT for details.
	+//
	+//===----------------------------------------------------------------------===//
	+
	+#include "filesystem"
	+#include "array"
	+#include "iterator"
	+#include "fstream"
	+#include "random" /* for unique_path */
	+#include "string_view"
	+#include "type_traits"
	+#include "vector"
	+#include "cstdlib"
	+#include "climits"
	+
	+#include "filesystem_common.h"
	+
	+#include <unistd.h>
	+#include <sys/stat.h>
	+#include <sys/statvfs.h>
	+#include <time.h>
	+#include <fcntl.h> /* values for fchmodat */
	+
	+#if defined(__linux__)
	+#include <linux/version.h>
	+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 33)
	+#include <sys/sendfile.h>
	+#define _LIBCPP_USE_SENDFILE
	+#endif
	+#elif defined(__APPLE__) \|\| __has_include(<copyfile.h>)
	+#include <copyfile.h>
	+#define _LIBCPP_USE_COPYFILE
	+#endif
	+
	+#if !defined(__APPLE__)
	+#define _LIBCPP_USE_CLOCK_GETTIME
	+#endif
	+
	+#if !defined(CLOCK_REALTIME) \|\| !defined(_LIBCPP_USE_CLOCK_GETTIME)
	+#include <sys/time.h> // for gettimeofday and timeval
	+#endif // !defined(CLOCK_REALTIME)
	+
	+#if defined(_LIBCPP_COMPILER_GCC)
	+#if _GNUC_VER < 500
	+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
	+#endif
	+#endif
	+
	+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
	+
	+namespace {
	+namespace parser {
	+
	+using string_view_t = path::__string_view;
	+using string_view_pair = pair<string_view_t, string_view_t>;
	+using PosPtr = path::value_type const*;
	+
	+struct PathParser {
	+ enum ParserState : unsigned char {
	+ // Zero is a special sentinel value used by default constructed iterators.
	+ PS_BeforeBegin = path::iterator::_BeforeBegin,
	+ PS_InRootName = path::iterator::_InRootName,
	+ PS_InRootDir = path::iterator::_InRootDir,
	+ PS_InFilenames = path::iterator::_InFilenames,
	+ PS_InTrailingSep = path::iterator::_InTrailingSep,
	+ PS_AtEnd = path::iterator::_AtEnd
	+ };
	+
	+ const string_view_t Path;
	+ string_view_t RawEntry;
	+ ParserState State;
	+
	+private:
	+ PathParser(string_view_t P, ParserState State) noexcept : Path(P),
	+ State(State) {}
	+
	+public:
	+ PathParser(string_view_t P, string_view_t E, unsigned char S)
	+ : Path(P), RawEntry(E), State(static_cast<ParserState>(S)) {
	+ // S cannot be '0' or PS_BeforeBegin.
	+ }
	+
	+ static PathParser CreateBegin(string_view_t P) noexcept {
	+ PathParser PP(P, PS_BeforeBegin);
	+ PP.increment();
	+ return PP;
	+ }
	+
	+ static PathParser CreateEnd(string_view_t P) noexcept {
	+ PathParser PP(P, PS_AtEnd);
	+ return PP;
	+ }
	+
	+ PosPtr peek() const noexcept {
	+ auto TkEnd = getNextTokenStartPos();
	+ auto End = getAfterBack();
	+ return TkEnd == End ? nullptr : TkEnd;
	+ }
	+
	+ void increment() noexcept {
	+ const PosPtr End = getAfterBack();
	+ const PosPtr Start = getNextTokenStartPos();
	+ if (Start == End)
	+ return makeState(PS_AtEnd);
	+
	+ switch (State) {
	+ case PS_BeforeBegin: {
	+ PosPtr TkEnd = consumeSeparator(Start, End);
	+ if (TkEnd)
	+ return makeState(PS_InRootDir, Start, TkEnd);
	+ else
	+ return makeState(PS_InFilenames, Start, consumeName(Start, End));
	+ }
	+ case PS_InRootDir:
	+ return makeState(PS_InFilenames, Start, consumeName(Start, End));
	+
	+ case PS_InFilenames: {
	+ PosPtr SepEnd = consumeSeparator(Start, End);
	+ if (SepEnd != End) {
	+ PosPtr TkEnd = consumeName(SepEnd, End);
	+ if (TkEnd)
	+ return makeState(PS_InFilenames, SepEnd, TkEnd);
	+ }
	+ return makeState(PS_InTrailingSep, Start, SepEnd);
	+ }
	+
	+ case PS_InTrailingSep:
	+ return makeState(PS_AtEnd);
	+
	+ case PS_InRootName:
	+ case PS_AtEnd:
	+ _LIBCPP_UNREACHABLE();
	+ }
	+ }
	+
	+ void decrement() noexcept {
	+ const PosPtr REnd = getBeforeFront();
	+ const PosPtr RStart = getCurrentTokenStartPos() - 1;
	+ if (RStart == REnd) // we're decrementing the begin
	+ return makeState(PS_BeforeBegin);
	+
	+ switch (State) {
	+ case PS_AtEnd: {
	+ // Try to consume a trailing separator or root directory first.
	+ if (PosPtr SepEnd = consumeSeparator(RStart, REnd)) {
	+ if (SepEnd == REnd)
	+ return makeState(PS_InRootDir, Path.data(), RStart + 1);
	+ return makeState(PS_InTrailingSep, SepEnd + 1, RStart + 1);
	+ } else {
	+ PosPtr TkStart = consumeName(RStart, REnd);
	+ return makeState(PS_InFilenames, TkStart + 1, RStart + 1);
	+ }
	+ }
	+ case PS_InTrailingSep:
	+ return makeState(PS_InFilenames, consumeName(RStart, REnd) + 1,
	+ RStart + 1);
	+ case PS_InFilenames: {
	+ PosPtr SepEnd = consumeSeparator(RStart, REnd);
	+ if (SepEnd == REnd)
	+ return makeState(PS_InRootDir, Path.data(), RStart + 1);
	+ PosPtr TkEnd = consumeName(SepEnd, REnd);
	+ return makeState(PS_InFilenames, TkEnd + 1, SepEnd + 1);
	+ }
	+ case PS_InRootDir:
	+ // return makeState(PS_InRootName, Path.data(), RStart + 1);
	+ case PS_InRootName:
	+ case PS_BeforeBegin:
	+ _LIBCPP_UNREACHABLE();
	+ }
	+ }
	+
	+ /// \brief Return a view with the "preferred representation" of the current
	+ /// element. For example trailing separators are represented as a '.'
	+ string_view_t operator*() const noexcept {
	+ switch (State) {
	+ case PS_BeforeBegin:
	+ case PS_AtEnd:
	+ return "";
	+ case PS_InRootDir:
	+ return "/";
	+ case PS_InTrailingSep:
	+ return "";
	+ case PS_InRootName:
	+ case PS_InFilenames:
	+ return RawEntry;
	+ }
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ explicit operator bool() const noexcept {
	+ return State != PS_BeforeBegin && State != PS_AtEnd;
	+ }
	+
	+ PathParser& operator++() noexcept {
	+ increment();
	+ return *this;
	+ }
	+
	+ PathParser& operator--() noexcept {
	+ decrement();
	+ return *this;
	+ }
	+
	+ bool inRootPath() const noexcept {
	+ return State == PS_InRootDir \|\| State == PS_InRootName;
	+ }
	+
	+private:
	+ void makeState(ParserState NewState, PosPtr Start, PosPtr End) noexcept {
	+ State = NewState;
	+ RawEntry = string_view_t(Start, End - Start);
	+ }
	+ void makeState(ParserState NewState) noexcept {
	+ State = NewState;
	+ RawEntry = {};
	+ }
	+
	+ PosPtr getAfterBack() const noexcept { return Path.data() + Path.size(); }
	+
	+ PosPtr getBeforeFront() const noexcept { return Path.data() - 1; }
	+
	+ /// \brief Return a pointer to the first character after the currently
	+ /// lexed element.
	+ PosPtr getNextTokenStartPos() const noexcept {
	+ switch (State) {
	+ case PS_BeforeBegin:
	+ return Path.data();
	+ case PS_InRootName:
	+ case PS_InRootDir:
	+ case PS_InFilenames:
	+ return &RawEntry.back() + 1;
	+ case PS_InTrailingSep:
	+ case PS_AtEnd:
	+ return getAfterBack();
	+ }
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ /// \brief Return a pointer to the first character in the currently lexed
	+ /// element.
	+ PosPtr getCurrentTokenStartPos() const noexcept {
	+ switch (State) {
	+ case PS_BeforeBegin:
	+ case PS_InRootName:
	+ return &Path.front();
	+ case PS_InRootDir:
	+ case PS_InFilenames:
	+ case PS_InTrailingSep:
	+ return &RawEntry.front();
	+ case PS_AtEnd:
	+ return &Path.back() + 1;
	+ }
	+ _LIBCPP_UNREACHABLE();
	+ }
	+
	+ PosPtr consumeSeparator(PosPtr P, PosPtr End) const noexcept {
	+ if (P == End \|\| *P != '/')
	+ return nullptr;
	+ const int Inc = P < End ? 1 : -1;
	+ P += Inc;
	+ while (P != End && *P == '/')
	+ P += Inc;
	+ return P;
	+ }
	+
	+ PosPtr consumeName(PosPtr P, PosPtr End) const noexcept {
	+ if (P == End \|\| *P == '/')
	+ return nullptr;
	+ const int Inc = P < End ? 1 : -1;
	+ P += Inc;
	+ while (P != End && *P != '/')
	+ P += Inc;
	+ return P;
	+ }
	+};
	+
	+string_view_pair separate_filename(string_view_t const& s) {
	+ if (s == "." \|\| s == ".." \|\| s.empty())
	+ return string_view_pair{s, ""};
	+ auto pos = s.find_last_of('.');
	+ if (pos == string_view_t::npos \|\| pos == 0)
	+ return string_view_pair{s, string_view_t{}};
	+ return string_view_pair{s.substr(0, pos), s.substr(pos)};
	+}
	+
	+string_view_t createView(PosPtr S, PosPtr E) noexcept {
	+ return {S, static_cast<size_t>(E - S) + 1};
	+}
	+
	+} // namespace parser
	+} // namespace
	+
	+// POSIX HELPERS
	+
	+namespace detail {
	+namespace {
	+
	+using value_type = path::value_type;
	+using string_type = path::string_type;
	+
	+struct FileDescriptor {
	+ const path& name;
	+ int fd = -1;
	+ StatT m_stat;
	+ file_status m_status;
	+
	+ template <class... Args>
	+ static FileDescriptor create(const path* p, error_code& ec, Args... args) {
	+ ec.clear();
	+ int fd;
	+ if ((fd = ::open(p->c_str(), args...)) == -1) {
	+ ec = capture_errno();
	+ return FileDescriptor{p};
	+ }
	+ return FileDescriptor(p, fd);
	+ }
	+
	+ template <class... Args>
	+ static FileDescriptor create_with_status(const path* p, error_code& ec,
	+ Args... args) {
	+ FileDescriptor fd = create(p, ec, args...);
	+ if (!ec)
	+ fd.refresh_status(ec);
	+
	+ return fd;
	+ }
	+
	+ file_status get_status() const { return m_status; }
	+ StatT const& get_stat() const { return m_stat; }
	+
	+ bool status_known() const { return _VSTD_FS::status_known(m_status); }
	+
	+ file_status refresh_status(error_code& ec);
	+
	+ void close() noexcept {
	+ if (fd != -1)
	+ ::close(fd);
	+ fd = -1;
	+ }
	+
	+ FileDescriptor(FileDescriptor&& other)
	+ : name(other.name), fd(other.fd), m_stat(other.m_stat),
	+ m_status(other.m_status) {
	+ other.fd = -1;
	+ other.m_status = file_status{};
	+ }
	+
	+ ~FileDescriptor() { close(); }
	+
	+ FileDescriptor() = default;
	+ FileDescriptor(FileDescriptor const&) = delete;
	+ FileDescriptor& operator=(FileDescriptor const&) = delete;
	+
	+private:
	+ explicit FileDescriptor(const path* p, int fd = -1) : name(*p), fd(fd) {}
	+};
	+
	+perms posix_get_perms(const StatT& st) noexcept {
	+ return static_cast<perms>(st.st_mode) & perms::mask;
	+}
	+
	+::mode_t posix_convert_perms(perms prms) {
	+ return static_cast< ::mode_t>(prms & perms::mask);
	+}
	+
	+file_status create_file_status(error_code& m_ec, path const& p,
	+ const StatT& path_stat, error_code* ec) {
	+ if (ec)
	+ *ec = m_ec;
	+ if (m_ec && (m_ec.value() == ENOENT \|\| m_ec.value() == ENOTDIR)) {
	+ return file_status(file_type::not_found);
	+ } else if (m_ec) {
	+ ErrorHandler<void> err("posix_stat", ec, &p);
	+ err.report(m_ec, "failed to determine attributes for the specified path");
	+ return file_status(file_type::none);
	+ }
	+ // else
	+
	+ file_status fs_tmp;
	+ auto const mode = path_stat.st_mode;
	+ if (S_ISLNK(mode))
	+ fs_tmp.type(file_type::symlink);
	+ else if (S_ISREG(mode))
	+ fs_tmp.type(file_type::regular);
	+ else if (S_ISDIR(mode))
	+ fs_tmp.type(file_type::directory);
	+ else if (S_ISBLK(mode))
	+ fs_tmp.type(file_type::block);
	+ else if (S_ISCHR(mode))
	+ fs_tmp.type(file_type::character);
	+ else if (S_ISFIFO(mode))
	+ fs_tmp.type(file_type::fifo);
	+ else if (S_ISSOCK(mode))
	+ fs_tmp.type(file_type::socket);
	+ else
	+ fs_tmp.type(file_type::unknown);
	+
	+ fs_tmp.permissions(detail::posix_get_perms(path_stat));
	+ return fs_tmp;
	+}
	+
	+file_status posix_stat(path const& p, StatT& path_stat, error_code* ec) {
	+ error_code m_ec;
	+ if (::stat(p.c_str(), &path_stat) == -1)
	+ m_ec = detail::capture_errno();
	+ return create_file_status(m_ec, p, path_stat, ec);
	+}
	+
	+file_status posix_stat(path const& p, error_code* ec) {
	+ StatT path_stat;
	+ return posix_stat(p, path_stat, ec);
	+}
	+
	+file_status posix_lstat(path const& p, StatT& path_stat, error_code* ec) {
	+ error_code m_ec;
	+ if (::lstat(p.c_str(), &path_stat) == -1)
	+ m_ec = detail::capture_errno();
	+ return create_file_status(m_ec, p, path_stat, ec);
	+}
	+
	+file_status posix_lstat(path const& p, error_code* ec) {
	+ StatT path_stat;
	+ return posix_lstat(p, path_stat, ec);
	+}
	+
	+bool posix_ftruncate(const FileDescriptor& fd, size_t to_size, error_code& ec) {
	+ if (::ftruncate(fd.fd, to_size) == -1) {
	+ ec = capture_errno();
	+ return true;
	+ }
	+ ec.clear();
	+ return false;
	+}
	+
	+bool posix_fchmod(const FileDescriptor& fd, const StatT& st, error_code& ec) {
	+ if (::fchmod(fd.fd, st.st_mode) == -1) {
	+ ec = capture_errno();
	+ return true;
	+ }
	+ ec.clear();
	+ return false;
	+}
	+
	+bool stat_equivalent(const StatT& st1, const StatT& st2) {
	+ return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
	+}
	+
	+file_status FileDescriptor::refresh_status(error_code& ec) {
	+ // FD must be open and good.
	+ m_status = file_status{};
	+ m_stat = {};
	+ error_code m_ec;
	+ if (::fstat(fd, &m_stat) == -1)
	+ m_ec = capture_errno();
	+ m_status = create_file_status(m_ec, name, m_stat, &ec);
	+ return m_status;
	+}
	+} // namespace
	+} // end namespace detail
	+
	+using detail::capture_errno;
	+using detail::ErrorHandler;
	+using detail::StatT;
	+using detail::TimeSpec;
	+using parser::createView;
	+using parser::PathParser;
	+using parser::string_view_t;
	+
	+const bool _FilesystemClock::is_steady;
	+
	+_FilesystemClock::time_point _FilesystemClock::now() noexcept {
	+ typedef chrono::duration<rep> __secs;
	+#if defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_REALTIME)
	+ typedef chrono::duration<rep, nano> __nsecs;
	+ struct timespec tp;
	+ if (0 != clock_gettime(CLOCK_REALTIME, &tp))
	+ __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
	+ return time_point(__secs(tp.tv_sec) +
	+ chrono::duration_cast<duration>(__nsecs(tp.tv_nsec)));
	+#else
	+ typedef chrono::duration<rep, micro> __microsecs;
	+ timeval tv;
	+ gettimeofday(&tv, 0);
	+ return time_point(__secs(tv.tv_sec) + __microsecs(tv.tv_usec));
	+#endif // _LIBCPP_USE_CLOCK_GETTIME && CLOCK_REALTIME
	+}
	+
	+filesystem_error::~filesystem_error() {}
	+
	+void filesystem_error::__create_what(int __num_paths) {
	+ const char* derived_what = system_error::what();
	+ __storage_->__what_ = [&]() -> string {
	+ const char* p1 = path1().native().empty() ? "\"\"" : path1().c_str();
	+ const char* p2 = path2().native().empty() ? "\"\"" : path2().c_str();
	+ switch (__num_paths) {
	+ default:
	+ return detail::format_string("filesystem error: %s", derived_what);
	+ case 1:
	+ return detail::format_string("filesystem error: %s [%s]", derived_what,
	+ p1);
	+ case 2:
	+ return detail::format_string("filesystem error: %s [%s] [%s]",
	+ derived_what, p1, p2);
	+ }
	+ }();
	+}
	+
	+static path __do_absolute(const path& p, path* cwd, error_code* ec) {
	+ if (ec)
	+ ec->clear();
	+ if (p.is_absolute())
	+ return p;
	+ *cwd = __current_path(ec);
	+ if (ec && *ec)
	+ return {};
	+ return (*cwd) / p;
	+}
	+
	+path __absolute(const path& p, error_code* ec) {
	+ path cwd;
	+ return __do_absolute(p, &cwd, ec);
	+}
	+
	+path __canonical(path const& orig_p, error_code* ec) {
	+ path cwd;
	+ ErrorHandler<path> err("canonical", ec, &orig_p, &cwd);
	+
	+ path p = __do_absolute(orig_p, &cwd, ec);
	+ char buff[PATH_MAX + 1];
	+ char* ret;
	+ if ((ret = ::realpath(p.c_str(), buff)) == nullptr)
	+ return err.report(capture_errno());
	+ return {ret};
	+}
	+
	+void __copy(const path& from, const path& to, copy_options options,
	+ error_code* ec) {
	+ ErrorHandler<void> err("copy", ec, &from, &to);
	+
	+ const bool sym_status = bool(
	+ options & (copy_options::create_symlinks \| copy_options::skip_symlinks));
	+
	+ const bool sym_status2 = bool(options & copy_options::copy_symlinks);
	+
	+ error_code m_ec1;
	+ StatT f_st = {};
	+ const file_status f = sym_status \|\| sym_status2
	+ ? detail::posix_lstat(from, f_st, &m_ec1)
	+ : detail::posix_stat(from, f_st, &m_ec1);
	+ if (m_ec1)
	+ return err.report(m_ec1);
	+
	+ StatT t_st = {};
	+ 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 err.report(m_ec1);
	+
	+ if (!exists(f) \|\| is_other(f) \|\| is_other(t) \|\|
	+ (is_directory(f) && is_regular_file(t)) \|\|
	+ detail::stat_equivalent(f_st, t_st)) {
	+ return err.report(errc::function_not_supported);
	+ }
	+
	+ if (ec)
	+ ec->clear();
	+
	+ if (is_symlink(f)) {
	+ if (bool(copy_options::skip_symlinks & options)) {
	+ // do nothing
	+ } else if (not exists(t)) {
	+ __copy_symlink(from, to, ec);
	+ } else {
	+ return err.report(errc::file_exists);
	+ }
	+ return;
	+ } else if (is_regular_file(f)) {
	+ if (bool(copy_options::directories_only & options)) {
	+ // do nothing
	+ } else if (bool(copy_options::create_symlinks & options)) {
	+ __create_symlink(from, to, ec);
	+ } else if (bool(copy_options::create_hard_links & options)) {
	+ __create_hard_link(from, to, ec);
	+ } else if (is_directory(t)) {
	+ __copy_file(from, to / from.filename(), options, ec);
	+ } else {
	+ __copy_file(from, to, options, ec);
	+ }
	+ return;
	+ } else if (is_directory(f) && bool(copy_options::create_symlinks & options)) {
	+ return err.report(errc::is_a_directory);
	+ } else if (is_directory(f) && (bool(copy_options::recursive & options) \|\|
	+ copy_options::none == options)) {
	+
	+ if (!exists(t)) {
	+ // create directory to with attributes from 'from'.
	+ __create_directory(to, from, ec);
	+ if (ec && *ec) {
	+ return;
	+ }
	+ }
	+ directory_iterator it =
	+ ec ? directory_iterator(from, *ec) : directory_iterator(from);
	+ if (ec && *ec) {
	+ return;
	+ }
	+ error_code m_ec2;
	+ for (; it != directory_iterator(); it.increment(m_ec2)) {
	+ if (m_ec2) {
	+ return err.report(m_ec2);
	+ }
	+ __copy(it->path(), to / it->path().filename(),
	+ options \| copy_options::__in_recursive_copy, ec);
	+ if (ec && *ec) {
	+ return;
	+ }
	+ }
	+ }
	+}
	+
	+namespace detail {
	+namespace {
	+
	+#ifdef _LIBCPP_USE_SENDFILE
	+bool copy_file_impl_sendfile(FileDescriptor& read_fd, FileDescriptor& write_fd,
	+ error_code& ec) {
	+
	+ size_t count = read_fd.get_stat().st_size;
	+ do {
	+ ssize_t res;
	+ if ((res = ::sendfile(write_fd.fd, read_fd.fd, nullptr, count)) == -1) {
	+ ec = capture_errno();
	+ return false;
	+ }
	+ count -= res;
	+ } while (count > 0);
	+
	+ ec.clear();
	+
	+ return true;
	+}
	+#elif defined(_LIBCPP_USE_COPYFILE)
	+bool copy_file_impl_copyfile(FileDescriptor& read_fd, FileDescriptor& write_fd,
	+ error_code& ec) {
	+ struct CopyFileState {
	+ copyfile_state_t state;
	+ CopyFileState() { state = copyfile_state_alloc(); }
	+ ~CopyFileState() { copyfile_state_free(state); }
	+
	+ private:
	+ CopyFileState(CopyFileState const&) = delete;
	+ CopyFileState& operator=(CopyFileState const&) = delete;
	+ };
	+
	+ CopyFileState cfs;
	+ if (fcopyfile(read_fd.fd, write_fd.fd, cfs.state, COPYFILE_DATA) < 0) {
	+ ec = capture_errno();
	+ return false;
	+ }
	+
	+ ec.clear();
	+ return true;
	+}
	+#endif
	+
	+// Note: This function isn't guarded by ifdef's even though it may be unused
	+// in order to assure it still compiles.
	+__attribute__((unused)) bool copy_file_impl_default(FileDescriptor& read_fd,
	+ FileDescriptor& write_fd,
	+ error_code& ec) {
	+ ifstream in;
	+ in.__open(read_fd.fd, ios::binary);
	+ if (!in.is_open()) {
	+ // This assumes that __open didn't reset the error code.
	+ ec = capture_errno();
	+ return false;
	+ }
	+ ofstream out;
	+ out.__open(write_fd.fd, ios::binary);
	+ if (!out.is_open()) {
	+ ec = capture_errno();
	+ return false;
	+ }
	+
	+ if (in.good() && out.good()) {
	+ using InIt = istreambuf_iterator<char>;
	+ using OutIt = ostreambuf_iterator<char>;
	+ InIt bin(in);
	+ InIt ein;
	+ OutIt bout(out);
	+ copy(bin, ein, bout);
	+ }
	+ if (out.fail() \|\| in.fail()) {
	+ ec = make_error_code(errc::io_error);
	+ return false;
	+ }
	+
	+ ec.clear();
	+ return true;
	+}
	+
	+bool copy_file_impl(FileDescriptor& from, FileDescriptor& to, error_code& ec) {
	+#if defined(_LIBCPP_USE_SENDFILE)
	+ return copy_file_impl_sendfile(from, to, ec);
	+#elif defined(_LIBCPP_USE_COPYFILE)
	+ return copy_file_impl_copyfile(from, to, ec);
	+#else
	+ return copy_file_impl_default(from, to, ec);
	+#endif
	+}
	+
	+} // namespace
	+} // namespace detail
	+
	+bool __copy_file(const path& from, const path& to, copy_options options,
	+ error_code* ec) {
	+ using detail::FileDescriptor;
	+ ErrorHandler<bool> err("copy_file", ec, &to, &from);
	+
	+ error_code m_ec;
	+ FileDescriptor from_fd =
	+ FileDescriptor::create_with_status(&from, m_ec, O_RDONLY \| O_NONBLOCK);
	+ if (m_ec)
	+ return err.report(m_ec);
	+
	+ auto from_st = from_fd.get_status();
	+ StatT const& from_stat = from_fd.get_stat();
	+ if (!is_regular_file(from_st)) {
	+ if (not m_ec)
	+ m_ec = make_error_code(errc::not_supported);
	+ return err.report(m_ec);
	+ }
	+
	+ const bool skip_existing = bool(copy_options::skip_existing & options);
	+ const bool update_existing = bool(copy_options::update_existing & options);
	+ const bool overwrite_existing =
	+ bool(copy_options::overwrite_existing & options);
	+
	+ StatT to_stat_path;
	+ file_status to_st = detail::posix_stat(to, to_stat_path, &m_ec);
	+ if (!status_known(to_st))
	+ return err.report(m_ec);
	+
	+ const bool to_exists = exists(to_st);
	+ if (to_exists && !is_regular_file(to_st))
	+ return err.report(errc::not_supported);
	+
	+ if (to_exists && detail::stat_equivalent(from_stat, to_stat_path))
	+ return err.report(errc::file_exists);
	+
	+ if (to_exists && skip_existing)
	+ return false;
	+
	+ bool ShouldCopy = [&]() {
	+ if (to_exists && update_existing) {
	+ auto from_time = detail::extract_mtime(from_stat);
	+ auto to_time = detail::extract_mtime(to_stat_path);
	+ if (from_time.tv_sec < to_time.tv_sec)
	+ return false;
	+ if (from_time.tv_sec == to_time.tv_sec &&
	+ from_time.tv_nsec <= to_time.tv_nsec)
	+ return false;
	+ return true;
	+ }
	+ if (!to_exists \|\| overwrite_existing)
	+ return true;
	+ return err.report(errc::file_exists);
	+ }();
	+ if (!ShouldCopy)
	+ return false;
	+
	+ // Don't truncate right away. We may not be opening the file we originally
	+ // looked at; we'll check this later.
	+ int to_open_flags = O_WRONLY;
	+ if (!to_exists)
	+ to_open_flags \|= O_CREAT;
	+ FileDescriptor to_fd = FileDescriptor::create_with_status(
	+ &to, m_ec, to_open_flags, from_stat.st_mode);
	+ if (m_ec)
	+ return err.report(m_ec);
	+
	+ if (to_exists) {
	+ // Check that the file we initially stat'ed is equivalent to the one
	+ // we opened.
	+ // FIXME: report this better.
	+ if (!detail::stat_equivalent(to_stat_path, to_fd.get_stat()))
	+ return err.report(errc::bad_file_descriptor);
	+
	+ // Set the permissions and truncate the file we opened.
	+ if (detail::posix_fchmod(to_fd, from_stat, m_ec))
	+ return err.report(m_ec);
	+ if (detail::posix_ftruncate(to_fd, 0, m_ec))
	+ return err.report(m_ec);
	+ }
	+
	+ if (!copy_file_impl(from_fd, to_fd, m_ec)) {
	+ // FIXME: Remove the dest file if we failed, and it didn't exist previously.
	+ return err.report(m_ec);
	+ }
	+
	+ return true;
	+}
	+
	+void __copy_symlink(const path& existing_symlink, const path& new_symlink,
	+ error_code* ec) {
	+ const path real_path(__read_symlink(existing_symlink, ec));
	+ if (ec && *ec) {
	+ return;
	+ }
	+ // NOTE: proposal says you should detect if you should call
	+ // create_symlink or create_directory_symlink. I don't think this
	+ // is needed with POSIX
	+ __create_symlink(real_path, new_symlink, ec);
	+}
	+
	+bool __create_directories(const path& p, error_code* ec) {
	+ ErrorHandler<bool> err("create_directories", ec, &p);
	+
	+ error_code m_ec;
	+ auto const st = detail::posix_stat(p, &m_ec);
	+ if (!status_known(st))
	+ return err.report(m_ec);
	+ else if (is_directory(st))
	+ return false;
	+ else if (exists(st))
	+ return err.report(errc::file_exists);
	+
	+ const path parent = p.parent_path();
	+ if (!parent.empty()) {
	+ const file_status parent_st = status(parent, m_ec);
	+ if (not status_known(parent_st))
	+ return err.report(m_ec);
	+ if (not exists(parent_st)) {
	+ __create_directories(parent, ec);
	+ if (ec && *ec) {
	+ return false;
	+ }
	+ }
	+ }
	+ return __create_directory(p, ec);
	+}
	+
	+bool __create_directory(const path& p, error_code* ec) {
	+ ErrorHandler<bool> err("create_directory", ec, &p);
	+
	+ if (::mkdir(p.c_str(), static_cast<int>(perms::all)) == 0)
	+ return true;
	+ if (errno != EEXIST)
	+ err.report(capture_errno());
	+ return false;
	+}
	+
	+bool __create_directory(path const& p, path const& attributes, error_code* ec) {
	+ ErrorHandler<bool> err("create_directory", ec, &p, &attributes);
	+
	+ StatT attr_stat;
	+ error_code mec;
	+ auto st = detail::posix_stat(attributes, attr_stat, &mec);
	+ if (!status_known(st))
	+ return err.report(mec);
	+ if (!is_directory(st))
	+ return err.report(errc::not_a_directory,
	+ "the specified attribute path is invalid");
	+
	+ if (::mkdir(p.c_str(), attr_stat.st_mode) == 0)
	+ return true;
	+ if (errno != EEXIST)
	+ err.report(capture_errno());
	+ return false;
	+}
	+
	+void __create_directory_symlink(path const& from, path const& to,
	+ error_code* ec) {
	+ ErrorHandler<void> err("create_directory_symlink", ec, &from, &to);
	+ if (::symlink(from.c_str(), to.c_str()) != 0)
	+ return err.report(capture_errno());
	+}
	+
	+void __create_hard_link(const path& from, const path& to, error_code* ec) {
	+ ErrorHandler<void> err("create_hard_link", ec, &from, &to);
	+ if (::link(from.c_str(), to.c_str()) == -1)
	+ return err.report(capture_errno());
	+}
	+
	+void __create_symlink(path const& from, path const& to, error_code* ec) {
	+ ErrorHandler<void> err("create_symlink", ec, &from, &to);
	+ if (::symlink(from.c_str(), to.c_str()) == -1)
	+ return err.report(capture_errno());
	+}
	+
	+path __current_path(error_code* ec) {
	+ ErrorHandler<path> err("current_path", ec);
	+
	+ auto size = ::pathconf(".", _PC_PATH_MAX);
	+ _LIBCPP_ASSERT(size >= 0, "pathconf returned a 0 as max size");
	+
	+ auto buff = unique_ptr<char[]>(new char[size + 1]);
	+ char* ret;
	+ if ((ret = ::getcwd(buff.get(), static_cast<size_t>(size))) == nullptr)
	+ return err.report(capture_errno(), "call to getcwd failed");
	+
	+ return {buff.get()};
	+}
	+
	+void __current_path(const path& p, error_code* ec) {
	+ ErrorHandler<void> err("current_path", ec, &p);
	+ if (::chdir(p.c_str()) == -1)
	+ err.report(capture_errno());
	+}
	+
	+bool __equivalent(const path& p1, const path& p2, error_code* ec) {
	+ ErrorHandler<bool> err("equivalent", ec, &p1, &p2);
	+
	+ error_code ec1, ec2;
	+ StatT st1 = {}, st2 = {};
	+ auto s1 = detail::posix_stat(p1.native(), st1, &ec1);
	+ if (!exists(s1))
	+ return err.report(errc::not_supported);
	+ auto s2 = detail::posix_stat(p2.native(), st2, &ec2);
	+ if (!exists(s2))
	+ return err.report(errc::not_supported);
	+
	+ return detail::stat_equivalent(st1, st2);
	+}
	+
	+uintmax_t __file_size(const path& p, error_code* ec) {
	+ ErrorHandler<uintmax_t> err("file_size", ec, &p);
	+
	+ error_code m_ec;
	+ StatT st;
	+ file_status fst = detail::posix_stat(p, st, &m_ec);
	+ if (!exists(fst) \|\| !is_regular_file(fst)) {
	+ errc error_kind =
	+ is_directory(fst) ? errc::is_a_directory : errc::not_supported;
	+ if (!m_ec)
	+ m_ec = make_error_code(error_kind);
	+ return err.report(m_ec);
	+ }
	+ // is_regular_file(p) == true
	+ return static_cast<uintmax_t>(st.st_size);
	+}
	+
	+uintmax_t __hard_link_count(const path& p, error_code* ec) {
	+ ErrorHandler<uintmax_t> err("hard_link_count", ec, &p);
	+
	+ error_code m_ec;
	+ StatT st;
	+ detail::posix_stat(p, st, &m_ec);
	+ if (m_ec)
	+ return err.report(m_ec);
	+ return static_cast<uintmax_t>(st.st_nlink);
	+}
	+
	+bool __fs_is_empty(const path& p, error_code* ec) {
	+ ErrorHandler<bool> err("is_empty", ec, &p);
	+
	+ error_code m_ec;
	+ StatT pst;
	+ auto st = detail::posix_stat(p, pst, &m_ec);
	+ if (m_ec)
	+ return err.report(m_ec);
	+ else if (!is_directory(st) && !is_regular_file(st))
	+ return err.report(errc::not_supported);
	+ else if (is_directory(st)) {
	+ auto it = ec ? directory_iterator(p, *ec) : directory_iterator(p);
	+ if (ec && *ec)
	+ return false;
	+ return it == directory_iterator{};
	+ } else if (is_regular_file(st))
	+ return static_cast<uintmax_t>(pst.st_size) == 0;
	+
	+ _LIBCPP_UNREACHABLE();
	+}
	+
	+static file_time_type __extract_last_write_time(const path& p, const StatT& st,
	+ error_code* ec) {
	+ using detail::fs_time;
	+ ErrorHandler<file_time_type> err("last_write_time", ec, &p);
	+
	+ auto ts = detail::extract_mtime(st);
	+ if (!fs_time::is_representable(ts))
	+ return err.report(errc::value_too_large);
	+
	+ return fs_time::convert_from_timespec(ts);
	+}
	+
	+file_time_type __last_write_time(const path& p, error_code* ec) {
	+ using namespace chrono;
	+ ErrorHandler<file_time_type> err("last_write_time", ec, &p);
	+
	+ error_code m_ec;
	+ StatT st;
	+ detail::posix_stat(p, st, &m_ec);
	+ if (m_ec)
	+ return err.report(m_ec);
	+ return __extract_last_write_time(p, st, ec);
	+}
	+
	+void __last_write_time(const path& p, file_time_type new_time, error_code* ec) {
	+ using detail::fs_time;
	+ ErrorHandler<void> err("last_write_time", ec, &p);
	+
	+ error_code m_ec;
	+ array<TimeSpec, 2> tbuf;
	+#if !defined(_LIBCPP_USE_UTIMENSAT)
	+ // This implementation has a race condition between determining the
	+ // last access time and attempting to set it to the same value using
	+ // ::utimes
	+ StatT st;
	+ file_status fst = detail::posix_stat(p, st, &m_ec);
	+ if (m_ec)
	+ return err.report(m_ec);
	+ tbuf[0] = detail::extract_atime(st);
	+#else
	+ tbuf[0].tv_sec = 0;
	+ tbuf[0].tv_nsec = UTIME_OMIT;
	+#endif
	+ if (!fs_time::convert_to_timespec(tbuf[1], new_time))
	+ return err.report(errc::value_too_large);
	+
	+ detail::set_file_times(p, tbuf, m_ec);
	+ if (m_ec)
	+ return err.report(m_ec);
	+}
	+
	+void __permissions(const path& p, perms prms, perm_options opts,
	+ error_code* ec) {
	+ ErrorHandler<void> err("permissions", ec, &p);
	+
	+ auto has_opt = [&](perm_options o) { return bool(o & opts); };
	+ const bool resolve_symlinks = !has_opt(perm_options::nofollow);
	+ const bool add_perms = has_opt(perm_options::add);
	+ const bool remove_perms = has_opt(perm_options::remove);
	+ _LIBCPP_ASSERT(
	+ (add_perms + remove_perms + has_opt(perm_options::replace)) == 1,
	+ "One and only one of the perm_options constants replace, add, or remove "
	+ "is present in opts");
	+
	+ bool set_sym_perms = false;
	+ prms &= perms::mask;
	+ if (!resolve_symlinks \|\| (add_perms \|\| remove_perms)) {
	+ error_code m_ec;
	+ file_status st = resolve_symlinks ? detail::posix_stat(p, &m_ec)
	+ : detail::posix_lstat(p, &m_ec);
	+ set_sym_perms = is_symlink(st);
	+ if (m_ec)
	+ return err.report(m_ec);
	+ _LIBCPP_ASSERT(st.permissions() != perms::unknown,
	+ "Permissions unexpectedly unknown");
	+ if (add_perms)
	+ prms \|= st.permissions();
	+ else if (remove_perms)
	+ prms = st.permissions() & ~prms;
	+ }
	+ const auto real_perms = detail::posix_convert_perms(prms);
	+
	+#if defined(AT_SYMLINK_NOFOLLOW) && defined(AT_FDCWD)
	+ const int flags = set_sym_perms ? AT_SYMLINK_NOFOLLOW : 0;
	+ if (::fchmodat(AT_FDCWD, p.c_str(), real_perms, flags) == -1) {
	+ return err.report(capture_errno());
	+ }
	+#else
	+ if (set_sym_perms)
	+ return err.report(errc::operation_not_supported);
	+ if (::chmod(p.c_str(), real_perms) == -1) {
	+ return err.report(capture_errno());
	+ }
	+#endif
	+}
	+
	+path __read_symlink(const path& p, error_code* ec) {
	+ ErrorHandler<path> err("read_symlink", ec, &p);
	+
	+ char buff[PATH_MAX + 1];
	+ error_code m_ec;
	+ ::ssize_t ret;
	+ if ((ret = ::readlink(p.c_str(), buff, PATH_MAX)) == -1) {
	+ return err.report(capture_errno());
	+ }
	+ _LIBCPP_ASSERT(ret <= PATH_MAX, "TODO");
	+ _LIBCPP_ASSERT(ret > 0, "TODO");
	+ buff[ret] = 0;
	+ return {buff};
	+}
	+
	+bool __remove(const path& p, error_code* ec) {
	+ ErrorHandler<bool> err("remove", ec, &p);
	+ if (::remove(p.c_str()) == -1) {
	+ if (errno != ENOENT)
	+ err.report(capture_errno());
	+ return false;
	+ }
	+ return true;
	+}
	+
	+namespace {
	+
	+uintmax_t remove_all_impl(path const& p, error_code& ec) {
	+ const auto npos = static_cast<uintmax_t>(-1);
	+ const file_status st = __symlink_status(p, &ec);
	+ if (ec)
	+ return npos;
	+ uintmax_t count = 1;
	+ if (is_directory(st)) {
	+ for (directory_iterator it(p, ec); !ec && it != directory_iterator();
	+ it.increment(ec)) {
	+ auto other_count = remove_all_impl(it->path(), ec);
	+ if (ec)
	+ return npos;
	+ count += other_count;
	+ }
	+ if (ec)
	+ return npos;
	+ }
	+ if (!__remove(p, &ec))
	+ return npos;
	+ return count;
	+}
	+
	+} // end namespace
	+
	+uintmax_t __remove_all(const path& p, error_code* ec) {
	+ ErrorHandler<uintmax_t> err("remove_all", ec, &p);
	+
	+ error_code mec;
	+ auto count = remove_all_impl(p, mec);
	+ if (mec) {
	+ if (mec == errc::no_such_file_or_directory)
	+ return 0;
	+ return err.report(mec);
	+ }
	+ return count;
	+}
	+
	+void __rename(const path& from, const path& to, error_code* ec) {
	+ ErrorHandler<void> err("rename", ec, &from, &to);
	+ if (::rename(from.c_str(), to.c_str()) == -1)
	+ err.report(capture_errno());
	+}
	+
	+void __resize_file(const path& p, uintmax_t size, error_code* ec) {
	+ ErrorHandler<void> err("resize_file", ec, &p);
	+ if (::truncate(p.c_str(), static_cast< ::off_t>(size)) == -1)
	+ return err.report(capture_errno());
	+}
	+
	+space_info __space(const path& p, error_code* ec) {
	+ ErrorHandler<void> err("space", ec, &p);
	+ space_info si;
	+ struct statvfs m_svfs = {};
	+ if (::statvfs(p.c_str(), &m_svfs) == -1) {
	+ err.report(capture_errno());
	+ si.capacity = si.free = si.available = static_cast<uintmax_t>(-1);
	+ return si;
	+ }
	+ // Multiply with overflow checking.
	+ auto do_mult = [&](uintmax_t& out, uintmax_t other) {
	+ out = other * m_svfs.f_frsize;
	+ if (other == 0 \|\| out / other != m_svfs.f_frsize)
	+ out = static_cast<uintmax_t>(-1);
	+ };
	+ do_mult(si.capacity, m_svfs.f_blocks);
	+ do_mult(si.free, m_svfs.f_bfree);
	+ do_mult(si.available, m_svfs.f_bavail);
	+ return si;
	+}
	+
	+file_status __status(const path& p, error_code* ec) {
	+ return detail::posix_stat(p, ec);
	+}
	+
	+file_status __symlink_status(const path& p, error_code* ec) {
	+ return detail::posix_lstat(p, ec);
	+}
	+
	+path __temp_directory_path(error_code* ec) {
	+ ErrorHandler<path> err("temp_directory_path", ec);
	+
	+ const char* env_paths[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"};
	+ const char* ret = nullptr;
	+
	+ for (auto& ep : env_paths)
	+ if ((ret = getenv(ep)))
	+ break;
	+ if (ret == nullptr)
	+ ret = "/tmp";
	+
	+ path p(ret);
	+ error_code m_ec;
	+ file_status st = detail::posix_stat(p, &m_ec);
	+ if (!status_known(st))
	+ return err.report(m_ec, "cannot access path \"%s\"", p);
	+
	+ if (!exists(st) \|\| !is_directory(st))
	+ return err.report(errc::not_a_directory, "path \"%s\" is not a directory",
	+ p);
	+
	+ return p;
	+}
	+
	+path __weakly_canonical(const path& p, error_code* ec) {
	+ ErrorHandler<path> err("weakly_canonical", ec, &p);
	+
	+ if (p.empty())
	+ return __canonical("", ec);
	+
	+ path result;
	+ path tmp;
	+ tmp.__reserve(p.native().size());
	+ auto PP = PathParser::CreateEnd(p.native());
	+ --PP;
	+ vector<string_view_t> DNEParts;
	+
	+ while (PP.State != PathParser::PS_BeforeBegin) {
	+ tmp.assign(createView(p.native().data(), &PP.RawEntry.back()));
	+ error_code m_ec;
	+ file_status st = __status(tmp, &m_ec);
	+ if (!status_known(st)) {
	+ return err.report(m_ec);
	+ } else if (exists(st)) {
	+ result = __canonical(tmp, ec);
	+ break;
	+ }
	+ DNEParts.push_back(*PP);
	+ --PP;
	+ }
	+ if (PP.State == PathParser::PS_BeforeBegin)
	+ result = __canonical("", ec);
	+ if (ec)
	+ ec->clear();
	+ if (DNEParts.empty())
	+ return result;
	+ for (auto It = DNEParts.rbegin(); It != DNEParts.rend(); ++It)
	+ result /= *It;
	+ return result.lexically_normal();
	+}
	+
	+///////////////////////////////////////////////////////////////////////////////
	+// path definitions
	+///////////////////////////////////////////////////////////////////////////////
	+
	+constexpr path::value_type path::preferred_separator;
	+
	+path& path::replace_extension(path const& replacement) {
	+ path p = extension();
	+ if (not p.empty()) {
	+ __pn_.erase(__pn_.size() - p.native().size());
	+ }
	+ if (!replacement.empty()) {
	+ if (replacement.native()[0] != '.') {
	+ __pn_ += ".";
	+ }
	+ __pn_.append(replacement.__pn_);
	+ }
	+ return *this;
	+}
	+
	+///////////////////////////////////////////////////////////////////////////////
	+// path.decompose
	+
	+string_view_t path::__root_name() const {
	+ auto PP = PathParser::CreateBegin(__pn_);
	+ if (PP.State == PathParser::PS_InRootName)
	+ return *PP;
	+ return {};
	+}
	+
	+string_view_t path::__root_directory() const {
	+ auto PP = PathParser::CreateBegin(__pn_);
	+ if (PP.State == PathParser::PS_InRootName)
	+ ++PP;
	+ if (PP.State == PathParser::PS_InRootDir)
	+ return *PP;
	+ return {};
	+}
	+
	+string_view_t path::__root_path_raw() const {
	+ auto PP = PathParser::CreateBegin(__pn_);
	+ if (PP.State == PathParser::PS_InRootName) {
	+ auto NextCh = PP.peek();
	+ if (NextCh && *NextCh == '/') {
	+ ++PP;
	+ return createView(__pn_.data(), &PP.RawEntry.back());
	+ }
	+ return PP.RawEntry;
	+ }
	+ if (PP.State == PathParser::PS_InRootDir)
	+ return *PP;
	+ return {};
	+}
	+
	+static bool ConsumeRootDir(PathParser* PP) {
	+ while (PP->State <= PathParser::PS_InRootDir)
	+ ++(*PP);
	+ return PP->State == PathParser::PS_AtEnd;
	+}
	+
	+string_view_t path::__relative_path() const {
	+ auto PP = PathParser::CreateBegin(__pn_);
	+ if (ConsumeRootDir(&PP))
	+ return {};
	+ return createView(PP.RawEntry.data(), &__pn_.back());
	+}
	+
	+string_view_t path::__parent_path() const {
	+ if (empty())
	+ return {};
	+ // Determine if we have a root path but not a relative path. In that case
	+ // return *this.
	+ {
	+ auto PP = PathParser::CreateBegin(__pn_);
	+ if (ConsumeRootDir(&PP))
	+ return __pn_;
	+ }
	+ // Otherwise remove a single element from the end of the path, and return
	+ // a string representing that path
	+ {
	+ auto PP = PathParser::CreateEnd(__pn_);
	+ --PP;
	+ if (PP.RawEntry.data() == __pn_.data())
	+ return {};
	+ --PP;
	+ return createView(__pn_.data(), &PP.RawEntry.back());
	+ }
	+}
	+
	+string_view_t path::__filename() const {
	+ if (empty())
	+ return {};
	+ {
	+ PathParser PP = PathParser::CreateBegin(__pn_);
	+ if (ConsumeRootDir(&PP))
	+ return {};
	+ }
	+ return *(--PathParser::CreateEnd(__pn_));
	+}
	+
	+string_view_t path::__stem() const {
	+ return parser::separate_filename(__filename()).first;
	+}
	+
	+string_view_t path::__extension() const {
	+ return parser::separate_filename(__filename()).second;
	+}
	+
	+////////////////////////////////////////////////////////////////////////////
	+// path.gen
	+
	+enum PathPartKind : unsigned char {
	+ PK_None,
	+ PK_RootSep,
	+ PK_Filename,
	+ PK_Dot,
	+ PK_DotDot,
	+ PK_TrailingSep
	+};
	+
	+static PathPartKind ClassifyPathPart(string_view_t Part) {
	+ if (Part.empty())
	+ return PK_TrailingSep;
	+ if (Part == ".")
	+ return PK_Dot;
	+ if (Part == "..")
	+ return PK_DotDot;
	+ if (Part == "/")
	+ return PK_RootSep;
	+ return PK_Filename;
	+}
	+
	+path path::lexically_normal() const {
	+ if (__pn_.empty())
	+ return *this;
	+
	+ using PartKindPair = pair<string_view_t, PathPartKind>;
	+ vector<PartKindPair> Parts;
	+ // Guess as to how many elements the path has to avoid reallocating.
	+ Parts.reserve(32);
	+
	+ // Track the total size of the parts as we collect them. This allows the
	+ // resulting path to reserve the correct amount of memory.
	+ size_t NewPathSize = 0;
	+ auto AddPart = [&](PathPartKind K, string_view_t P) {
	+ NewPathSize += P.size();
	+ Parts.emplace_back(P, K);
	+ };
	+ auto LastPartKind = [&]() {
	+ if (Parts.empty())
	+ return PK_None;
	+ return Parts.back().second;
	+ };
	+
	+ bool MaybeNeedTrailingSep = false;
	+ // Build a stack containing the remaining elements of the path, popping off
	+ // elements which occur before a '..' entry.
	+ for (auto PP = PathParser::CreateBegin(__pn_); PP; ++PP) {
	+ auto Part = *PP;
	+ PathPartKind Kind = ClassifyPathPart(Part);
	+ switch (Kind) {
	+ case PK_Filename:
	+ case PK_RootSep: {
	+ // Add all non-dot and non-dot-dot elements to the stack of elements.
	+ AddPart(Kind, Part);
	+ MaybeNeedTrailingSep = false;
	+ break;
	+ }
	+ case PK_DotDot: {
	+ // Only push a ".." element if there are no elements preceding the "..",
	+ // or if the preceding element is itself "..".
	+ auto LastKind = LastPartKind();
	+ if (LastKind == PK_Filename) {
	+ NewPathSize -= Parts.back().first.size();
	+ Parts.pop_back();
	+ } else if (LastKind != PK_RootSep)
	+ AddPart(PK_DotDot, "..");
	+ MaybeNeedTrailingSep = LastKind == PK_Filename;
	+ break;
	+ }
	+ case PK_Dot:
	+ case PK_TrailingSep: {
	+ MaybeNeedTrailingSep = true;
	+ break;
	+ }
	+ case PK_None:
	+ _LIBCPP_UNREACHABLE();
	+ }
	+ }
	+ // [fs.path.generic]p6.8: If the path is empty, add a dot.
	+ if (Parts.empty())
	+ return ".";
	+
	+ // [fs.path.generic]p6.7: If the last filename is dot-dot, remove any
	+ // trailing directory-separator.
	+ bool NeedTrailingSep = MaybeNeedTrailingSep && LastPartKind() == PK_Filename;
	+
	+ path Result;
	+ Result.__pn_.reserve(Parts.size() + NewPathSize + NeedTrailingSep);
	+ for (auto& PK : Parts)
	+ Result /= PK.first;
	+
	+ if (NeedTrailingSep)
	+ Result /= "";
	+
	+ return Result;
	+}
	+
	+static int DetermineLexicalElementCount(PathParser PP) {
	+ int Count = 0;
	+ for (; PP; ++PP) {
	+ auto Elem = *PP;
	+ if (Elem == "..")
	+ --Count;
	+ else if (Elem != ".")
	+ ++Count;
	+ }
	+ return Count;
	+}
	+
	+path path::lexically_relative(const path& base) const {
	+ { // perform root-name/root-directory mismatch checks
	+ auto PP = PathParser::CreateBegin(__pn_);
	+ auto PPBase = PathParser::CreateBegin(base.__pn_);
	+ auto CheckIterMismatchAtBase = [&]() {
	+ return PP.State != PPBase.State &&
	+ (PP.inRootPath() \|\| PPBase.inRootPath());
	+ };
	+ if (PP.State == PathParser::PS_InRootName &&
	+ PPBase.State == PathParser::PS_InRootName) {
	+ if (PP != PPBase)
	+ return {};
	+ } else if (CheckIterMismatchAtBase())
	+ return {};
	+
	+ if (PP.inRootPath())
	+ ++PP;
	+ if (PPBase.inRootPath())
	+ ++PPBase;
	+ if (CheckIterMismatchAtBase())
	+ return {};
	+ }
	+
	+ // Find the first mismatching element
	+ auto PP = PathParser::CreateBegin(__pn_);
	+ auto PPBase = PathParser::CreateBegin(base.__pn_);
	+ while (PP && PPBase && PP.State == PPBase.State && PP == PPBase) {
	+ ++PP;
	+ ++PPBase;
	+ }
	+
	+ // If there is no mismatch, return ".".
	+ if (!PP && !PPBase)
	+ return ".";
	+
	+ // Otherwise, determine the number of elements, 'n', which are not dot or
	+ // dot-dot minus the number of dot-dot elements.
	+ int ElemCount = DetermineLexicalElementCount(PPBase);
	+ if (ElemCount < 0)
	+ return {};
	+
	+ // return a path constructed with 'n' dot-dot elements, followed by the the
	+ // elements of '*this' after the mismatch.
	+ path Result;
	+ // FIXME: Reserve enough room in Result that it won't have to re-allocate.
	+ while (ElemCount--)
	+ Result /= "..";
	+ for (; PP; ++PP)
	+ Result /= *PP;
	+ return Result;
	+}
	+
	+////////////////////////////////////////////////////////////////////////////
	+// path.comparisons
	+int path::__compare(string_view_t __s) const {
	+ auto PP = PathParser::CreateBegin(__pn_);
	+ auto PP2 = PathParser::CreateBegin(__s);
	+ while (PP && PP2) {
	+ int res = (PP).compare(PP2);
	+ if (res != 0)
	+ return res;
	+ ++PP;
	+ ++PP2;
	+ }
	+ if (PP.State == PP2.State && !PP)
	+ return 0;
	+ if (!PP)
	+ return -1;
	+ return 1;
	+}
	+
	+////////////////////////////////////////////////////////////////////////////
	+// path.nonmembers
	+size_t hash_value(const path& __p) noexcept {
	+ auto PP = PathParser::CreateBegin(__p.native());
	+ size_t hash_value = 0;
	+ hash<string_view_t> hasher;
	+ while (PP) {
	+ hash_value = __hash_combine(hash_value, hasher(*PP));
	+ ++PP;
	+ }
	+ return hash_value;
	+}
	+
	+////////////////////////////////////////////////////////////////////////////
	+// path.itr
	+path::iterator path::begin() const {
	+ auto PP = PathParser::CreateBegin(__pn_);
	+ iterator it;
	+ it.__path_ptr_ = this;
	+ it.__state_ = static_cast<path::iterator::_ParserState>(PP.State);
	+ it.__entry_ = PP.RawEntry;
	+ it.__stashed_elem_.__assign_view(*PP);
	+ return it;
	+}
	+
	+path::iterator path::end() const {
	+ iterator it{};
	+ it.__state_ = path::iterator::_AtEnd;
	+ it.__path_ptr_ = this;
	+ return it;
	+}
	+
	+path::iterator& path::iterator::__increment() {
	+ PathParser PP(__path_ptr_->native(), __entry_, __state_);
	+ ++PP;
	+ __state_ = static_cast<_ParserState>(PP.State);
	+ __entry_ = PP.RawEntry;
	+ __stashed_elem_.__assign_view(*PP);
	+ return *this;
	+}
	+
	+path::iterator& path::iterator::__decrement() {
	+ PathParser PP(__path_ptr_->native(), __entry_, __state_);
	+ --PP;
	+ __state_ = static_cast<_ParserState>(PP.State);
	+ __entry_ = PP.RawEntry;
	+ __stashed_elem_.__assign_view(*PP);
	+ return *this;
	+}
	+
	+///////////////////////////////////////////////////////////////////////////////
	+// directory entry definitions
	+///////////////////////////////////////////////////////////////////////////////
	+
	+#ifndef _LIBCPP_WIN32API
	+error_code directory_entry::__do_refresh() noexcept {
	+ __data_.__reset();
	+ error_code failure_ec;
	+
	+ StatT full_st;
	+ file_status st = detail::posix_lstat(__p_, full_st, &failure_ec);
	+ if (!status_known(st)) {
	+ __data_.__reset();
	+ return failure_ec;
	+ }
	+
	+ if (!_VSTD_FS::exists(st) \|\| !_VSTD_FS::is_symlink(st)) {
	+ __data_.__cache_type_ = directory_entry::_RefreshNonSymlink;
	+ __data_.__type_ = st.type();
	+ __data_.__non_sym_perms_ = st.permissions();
	+ } else { // we have a symlink
	+ __data_.__sym_perms_ = st.permissions();
	+ // Get the information about the linked entity.
	+ // Ignore errors from stat, since we don't want errors regarding symlink
	+ // resolution to be reported to the user.
	+ error_code ignored_ec;
	+ st = detail::posix_stat(__p_, full_st, &ignored_ec);
	+
	+ __data_.__type_ = st.type();
	+ __data_.__non_sym_perms_ = st.permissions();
	+
	+ // If we failed to resolve the link, then only partially populate the
	+ // cache.
	+ if (!status_known(st)) {
	+ __data_.__cache_type_ = directory_entry::_RefreshSymlinkUnresolved;
	+ return error_code{};
	+ }
	+ // Otherwise, we resolved the link, potentially as not existing.
	+ // That's OK.
	+ __data_.__cache_type_ = directory_entry::_RefreshSymlink;
	+ }
	+
	+ if (_VSTD_FS::is_regular_file(st))
	+ __data_.__size_ = static_cast<uintmax_t>(full_st.st_size);
	+
	+ if (_VSTD_FS::exists(st)) {
	+ __data_.__nlink_ = static_cast<uintmax_t>(full_st.st_nlink);
	+
	+ // Attempt to extract the mtime, and fail if it's not representable using
	+ // file_time_type. For now we ignore the error, as we'll report it when
	+ // the value is actually used.
	+ error_code ignored_ec;
	+ __data_.__write_time_ =
	+ __extract_last_write_time(__p_, full_st, &ignored_ec);
	+ }
	+
	+ return failure_ec;
	+}
	+#else
	+error_code directory_entry::__do_refresh() noexcept {
	+ __data_.__reset();
	+ error_code failure_ec;
	+
	+ file_status st = _VSTD_FS::symlink_status(__p_, failure_ec);
	+ if (!status_known(st)) {
	+ __data_.__reset();
	+ return failure_ec;
	+ }
	+
	+ if (!_VSTD_FS::exists(st) \|\| !_VSTD_FS::is_symlink(st)) {
	+ __data_.__cache_type_ = directory_entry::_RefreshNonSymlink;
	+ __data_.__type_ = st.type();
	+ __data_.__non_sym_perms_ = st.permissions();
	+ } else { // we have a symlink
	+ __data_.__sym_perms_ = st.permissions();
	+ // Get the information about the linked entity.
	+ // Ignore errors from stat, since we don't want errors regarding symlink
	+ // resolution to be reported to the user.
	+ error_code ignored_ec;
	+ st = _VSTD_FS::status(__p_, ignored_ec);
	+
	+ __data_.__type_ = st.type();
	+ __data_.__non_sym_perms_ = st.permissions();
	+
	+ // If we failed to resolve the link, then only partially populate the
	+ // cache.
	+ if (!status_known(st)) {
	+ __data_.__cache_type_ = directory_entry::_RefreshSymlinkUnresolved;
	+ return error_code{};
	+ }
	+ __data_.__cache_type_ = directory_entry::_RefreshSymlink;
	+ }
	+
	+ // FIXME: This is currently broken, and the implementation only a placeholder.
	+ // We need to cache last_write_time, file_size, and hard_link_count here before
	+ // the implementation actually works.
	+
	+ return failure_ec;
	+}
	+#endif
	+
	+_LIBCPP_END_NAMESPACE_FILESYSTEM

	Property changes on: projects/clang700-import/contrib/libc++/src/filesystem/operations.cpp
	___________________________________________________________________
	Added: svn:eol-style
	## -0,0 +1 ##
	+native
	\ No newline at end of property
	Added: svn:mime-type
	## -0,0 +1 ##
	+text/plain
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/functional.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/functional.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/functional.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/functional.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/future.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/future.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/future.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/future.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/hash.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/hash.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/hash.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/hash.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/include/apple_availability.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/include/apple_availability.h (nonexistent)
	+++ projects/clang700-import/contrib/libc++/src/include/apple_availability.h (revision 337135)
	@@ -0,0 +1,52 @@
	+//===------------------------ apple_availability.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_SRC_INCLUDE_APPLE_AVAILABILITY_H
	+#define _LIBCPP_SRC_INCLUDE_APPLE_AVAILABILITY_H
	+
	+#if defined(__APPLE__)
	+
	+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
	+#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101300
	+#define _LIBCPP_USE_UTIMENSAT
	+#endif
	+#elif defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
	+#if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 110000
	+#define _LIBCPP_USE_UTIMENSAT
	+#endif
	+#elif defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__)
	+#if __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 110000
	+#define _LIBCPP_USE_UTIMENSAT
	+#endif
	+#elif defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__)
	+#if __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 40000
	+#define _LIBCPP_USE_UTIMENSAT
	+#endif
	+#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__
	+
	+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
	+#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101200
	+#define _LIBCPP_USE_CLOCK_GETTIME
	+#endif
	+#elif defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
	+#if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 100000
	+#define _LIBCPP_USE_CLOCK_GETTIME
	+#endif
	+#elif defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__)
	+#if __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 100000
	+#define _LIBCPP_USE_CLOCK_GETTIME
	+#endif
	+#elif defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__)
	+#if __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 30000
	+#define _LIBCPP_USE_CLOCK_GETTIME
	+#endif
	+#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__
	+
	+#endif // __APPLE__
	+
	+#endif // _LIBCPP_SRC_INCLUDE_APPLE_AVAILABILITY_H

	Property changes on: projects/clang700-import/contrib/libc++/src/include/apple_availability.h
	___________________________________________________________________
	Added: svn:eol-style
	## -0,0 +1 ##
	+native
	\ No newline at end of property
	Added: svn:mime-type
	## -0,0 +1 ##
	+text/plain
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/include/atomic_support.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/include/atomic_support.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/include/atomic_support.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/include/atomic_support.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/include/config_elast.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/include/config_elast.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/include/config_elast.h (revision 337135)
	@@ -1,40 +1,40 @@
	//===----------------------- config_elast.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_CONFIG_ELAST
	#define _LIBCPP_CONFIG_ELAST

	#include <__config>

	-#if defined(_LIBCPP_MSVCRT)
	+#if defined(_LIBCPP_MSVCRT_LIKE)
	#include <stdlib.h>
	#else
	#include <errno.h>
	#endif

	#if defined(ELAST)
	#define _LIBCPP_ELAST ELAST
	#elif defined(_NEWLIB_VERSION)
	#define _LIBCPP_ELAST __ELASTERROR
	#elif defined(__Fuchsia__)
	// No _LIBCPP_ELAST needed on Fuchsia
	#elif defined(__linux__) \|\| defined(_LIBCPP_HAS_MUSL_LIBC)
	#define _LIBCPP_ELAST 4095
	#elif defined(__APPLE__)
	// No _LIBCPP_ELAST needed on Apple
	#elif defined(__sun__)
	#define _LIBCPP_ELAST ESTALE
	-#elif defined(_LIBCPP_MSVCRT)
	+#elif defined(_LIBCPP_MSVCRT_LIKE)
	#define _LIBCPP_ELAST (_sys_nerr - 1)
	#else
	// Warn here so that the person doing the libcxx port has an easier time:
	#warning ELAST for this platform not yet implemented
	#endif

	#endif // _LIBCPP_CONFIG_ELAST

	Property changes on: projects/clang700-import/contrib/libc++/src/include/config_elast.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/include/refstring.h
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/include/refstring.h (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/include/refstring.h (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/include/refstring.h
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/ios.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/ios.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/ios.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/ios.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/iostream.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/iostream.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/iostream.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/iostream.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/locale.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/locale.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/locale.cpp (revision 337135)
	@@ -1,6162 +1,6163 @@
	//===------------------------- locale.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.
	//
	//===----------------------------------------------------------------------===//

	// On Solaris, we need to define something to make the C99 parts of localeconv
	// visible.
	#ifdef __sun__
	#define _LCONV_C99
	#endif

	#include "string"
	#include "locale"
	#include "codecvt"
	#include "vector"
	#include "algorithm"
	#include "typeinfo"
	#ifndef _LIBCPP_NO_EXCEPTIONS
	# include "type_traits"
	#endif
	#include "clocale"
	#include "cstring"
	#if defined(_LIBCPP_MSVCRT)
	#define _CTYPE_DISABLE_MACROS
	#endif
	#include "cwctype"
	#include "__sso_allocator"
	#if defined(_LIBCPP_MSVCRT) \|\| defined(__MINGW32__)
	#include "support/win32/locale_win32.h"
	#elif !defined(__BIONIC__)
	#include <langinfo.h>
	#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
	// lots of noise in the build log, but no bugs that I know of.
	#if defined(__clang__)
	#pragma clang diagnostic ignored "-Wsign-conversion"
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	struct __libcpp_unique_locale {
	__libcpp_unique_locale(const char* nm) : __loc_(newlocale(LC_ALL_MASK, nm, 0)) {}

	~__libcpp_unique_locale() {
	if (__loc_)
	freelocale(__loc_);
	}

	explicit operator bool() const { return __loc_; }

	locale_t& get() { return __loc_; }

	locale_t __loc_;
	private:
	__libcpp_unique_locale(__libcpp_unique_locale const&);
	__libcpp_unique_locale& operator=(__libcpp_unique_locale const&);
	};

	#ifdef __cloc_defined
	locale_t __cloc() {
	// In theory this could create a race condition. In practice
	// the race condition is non-fatal since it will just create
	// a little resource leak. Better approach would be appreciated.
	static locale_t result = newlocale(LC_ALL_MASK, "C", 0);
	return result;
	}
	#endif // __cloc_defined

	namespace {

	struct release
	{
	void operator()(locale::facet* p) {p->__release_shared();}
	};

	template <class T, class A0>
	inline
	T&
	make(A0 a0)
	{
	static typename aligned_storage<sizeof(T)>::type buf;
	auto *obj = ::new (&buf) T(a0);
	return *obj;
	}

	template <class T, class A0, class A1>
	inline
	T&
	make(A0 a0, A1 a1)
	{
	static typename aligned_storage<sizeof(T)>::type buf;
	::new (&buf) T(a0, a1);
	return reinterpret_cast<T>(&buf);
	}

	template <class T, class A0, class A1, class A2>
	inline
	T&
	make(A0 a0, A1 a1, A2 a2)
	{
	static typename aligned_storage<sizeof(T)>::type buf;
	auto *obj = ::new (&buf) T(a0, a1, a2);
	return *obj;
	}

	template <typename T, size_t N>
	inline
	_LIBCPP_CONSTEXPR
	size_t
	countof(const T (&)[N])
	{
	return N;
	}

	template <typename T>
	inline
	_LIBCPP_CONSTEXPR
	size_t
	countof(const T * const begin, const T * const end)
	{
	return static_cast<size_t>(end - begin);
	}

	_LIBCPP_NORETURN static void __throw_runtime_error(const string &msg)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw runtime_error(msg);
	#else
	(void)msg;
	_VSTD::abort();
	#endif
	}

	}

	#if defined(_AIX)
	// Set priority to INT_MIN + 256 + 150
	# pragma priority ( -2147483242 )
	#endif

	const locale::category locale::none;
	const locale::category locale::collate;
	const locale::category locale::ctype;
	const locale::category locale::monetary;
	const locale::category locale::numeric;
	const locale::category locale::time;
	const locale::category locale::messages;
	const locale::category locale::all;

	class _LIBCPP_HIDDEN locale::__imp
	: public facet
	{
	enum {N = 28};
	#if defined(_LIBCPP_COMPILER_MSVC)
	// FIXME: MSVC doesn't support aligned parameters by value.
	// I can't get the __sso_allocator to work here
	// for MSVC I think for this reason.
	vector<facet*> facets_;
	#else
	vector<facet, __sso_allocator<facet, N> > facets_;
	#endif
	string name_;
	public:
	explicit __imp(size_t refs = 0);
	explicit __imp(const string& name, size_t refs = 0);
	__imp(const __imp&);
	__imp(const __imp&, const string&, locale::category c);
	__imp(const __imp& other, const __imp& one, locale::category c);
	__imp(const __imp&, facet* f, long id);
	~__imp();

	const string& name() const {return name_;}
	bool has_facet(long id) const
	{return static_cast<size_t>(id) < facets_.size() && facets_[static_cast<size_t>(id)];}
	const locale::facet* use_facet(long id) const;

	static const locale& make_classic();
	static locale& make_global();
	private:
	void install(facet* f, long id);
	template <class F> void install(F* f) {install(f, f->id.__get());}
	template <class F> void install_from(const __imp& other);
	};

	locale::__imp::__imp(size_t refs)
	: facet(refs),
	facets_(N),
	name_("C")
	{
	facets_.clear();
	install(&make<_VSTD::collate<char> >(1u));
	install(&make<_VSTD::collate<wchar_t> >(1u));
	install(&make<_VSTD::ctype<char> >(nullptr, false, 1u));
	install(&make<_VSTD::ctype<wchar_t> >(1u));
	install(&make<codecvt<char, char, mbstate_t> >(1u));
	install(&make<codecvt<wchar_t, char, mbstate_t> >(1u));
	install(&make<codecvt<char16_t, char, mbstate_t> >(1u));
	install(&make<codecvt<char32_t, char, mbstate_t> >(1u));
	install(&make<numpunct<char> >(1u));
	install(&make<numpunct<wchar_t> >(1u));
	install(&make<num_get<char> >(1u));
	install(&make<num_get<wchar_t> >(1u));
	install(&make<num_put<char> >(1u));
	install(&make<num_put<wchar_t> >(1u));
	install(&make<moneypunct<char, false> >(1u));
	install(&make<moneypunct<char, true> >(1u));
	install(&make<moneypunct<wchar_t, false> >(1u));
	install(&make<moneypunct<wchar_t, true> >(1u));
	install(&make<money_get<char> >(1u));
	install(&make<money_get<wchar_t> >(1u));
	install(&make<money_put<char> >(1u));
	install(&make<money_put<wchar_t> >(1u));
	install(&make<time_get<char> >(1u));
	install(&make<time_get<wchar_t> >(1u));
	install(&make<time_put<char> >(1u));
	install(&make<time_put<wchar_t> >(1u));
	install(&make<_VSTD::messages<char> >(1u));
	install(&make<_VSTD::messages<wchar_t> >(1u));
	}

	locale::__imp::__imp(const string& name, size_t refs)
	: facet(refs),
	facets_(N),
	name_(name)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	facets_ = locale::classic().__locale_->facets_;
	for (unsigned i = 0; i < facets_.size(); ++i)
	if (facets_[i])
	facets_[i]->__add_shared();
	install(new collate_byname<char>(name_));
	install(new collate_byname<wchar_t>(name_));
	install(new ctype_byname<char>(name_));
	install(new ctype_byname<wchar_t>(name_));
	install(new codecvt_byname<char, char, mbstate_t>(name_));
	install(new codecvt_byname<wchar_t, char, mbstate_t>(name_));
	install(new codecvt_byname<char16_t, char, mbstate_t>(name_));
	install(new codecvt_byname<char32_t, char, mbstate_t>(name_));
	install(new numpunct_byname<char>(name_));
	install(new numpunct_byname<wchar_t>(name_));
	install(new moneypunct_byname<char, false>(name_));
	install(new moneypunct_byname<char, true>(name_));
	install(new moneypunct_byname<wchar_t, false>(name_));
	install(new moneypunct_byname<wchar_t, true>(name_));
	install(new time_get_byname<char>(name_));
	install(new time_get_byname<wchar_t>(name_));
	install(new time_put_byname<char>(name_));
	install(new time_put_byname<wchar_t>(name_));
	install(new messages_byname<char>(name_));
	install(new messages_byname<wchar_t>(name_));
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	for (unsigned i = 0; i < facets_.size(); ++i)
	if (facets_[i])
	facets_[i]->__release_shared();
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	// NOTE avoid the `base class should be explicitly initialized in the
	// copy constructor` warning emitted by GCC
	#if defined(__clang__) \|\| _GNUC_VER >= 406
	#pragma GCC diagnostic push
	#pragma GCC diagnostic ignored "-Wextra"
	#endif

	locale::__imp::__imp(const __imp& other)
	: facets_(max<size_t>(N, other.facets_.size())),
	name_(other.name_)
	{
	facets_ = other.facets_;
	for (unsigned i = 0; i < facets_.size(); ++i)
	if (facets_[i])
	facets_[i]->__add_shared();
	}

	#if defined(__clang__) \|\| _GNUC_VER >= 406
	#pragma GCC diagnostic pop
	#endif

	locale::__imp::__imp(const __imp& other, const string& name, locale::category c)
	: facets_(N),
	name_("*")
	{
	facets_ = other.facets_;
	for (unsigned i = 0; i < facets_.size(); ++i)
	if (facets_[i])
	facets_[i]->__add_shared();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	if (c & locale::collate)
	{
	install(new collate_byname<char>(name));
	install(new collate_byname<wchar_t>(name));
	}
	if (c & locale::ctype)
	{
	install(new ctype_byname<char>(name));
	install(new ctype_byname<wchar_t>(name));
	install(new codecvt_byname<char, char, mbstate_t>(name));
	install(new codecvt_byname<wchar_t, char, mbstate_t>(name));
	install(new codecvt_byname<char16_t, char, mbstate_t>(name));
	install(new codecvt_byname<char32_t, char, mbstate_t>(name));
	}
	if (c & locale::monetary)
	{
	install(new moneypunct_byname<char, false>(name));
	install(new moneypunct_byname<char, true>(name));
	install(new moneypunct_byname<wchar_t, false>(name));
	install(new moneypunct_byname<wchar_t, true>(name));
	}
	if (c & locale::numeric)
	{
	install(new numpunct_byname<char>(name));
	install(new numpunct_byname<wchar_t>(name));
	}
	if (c & locale::time)
	{
	install(new time_get_byname<char>(name));
	install(new time_get_byname<wchar_t>(name));
	install(new time_put_byname<char>(name));
	install(new time_put_byname<wchar_t>(name));
	}
	if (c & locale::messages)
	{
	install(new messages_byname<char>(name));
	install(new messages_byname<wchar_t>(name));
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	for (unsigned i = 0; i < facets_.size(); ++i)
	if (facets_[i])
	facets_[i]->__release_shared();
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	template<class F>
	inline
	void
	locale::__imp::install_from(const locale::__imp& one)
	{
	long id = F::id.__get();
	install(const_cast<F>(static_cast<const F>(one.use_facet(id))), id);
	}

	locale::__imp::__imp(const __imp& other, const __imp& one, locale::category c)
	: facets_(N),
	name_("*")
	{
	facets_ = other.facets_;
	for (unsigned i = 0; i < facets_.size(); ++i)
	if (facets_[i])
	facets_[i]->__add_shared();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	if (c & locale::collate)
	{
	install_from<_VSTD::collate<char> >(one);
	install_from<_VSTD::collate<wchar_t> >(one);
	}
	if (c & locale::ctype)
	{
	install_from<_VSTD::ctype<char> >(one);
	install_from<_VSTD::ctype<wchar_t> >(one);
	install_from<_VSTD::codecvt<char, char, mbstate_t> >(one);
	install_from<_VSTD::codecvt<char16_t, char, mbstate_t> >(one);
	install_from<_VSTD::codecvt<char32_t, char, mbstate_t> >(one);
	install_from<_VSTD::codecvt<wchar_t, char, mbstate_t> >(one);
	}
	if (c & locale::monetary)
	{
	install_from<moneypunct<char, false> >(one);
	install_from<moneypunct<char, true> >(one);
	install_from<moneypunct<wchar_t, false> >(one);
	install_from<moneypunct<wchar_t, true> >(one);
	install_from<money_get<char> >(one);
	install_from<money_get<wchar_t> >(one);
	install_from<money_put<char> >(one);
	install_from<money_put<wchar_t> >(one);
	}
	if (c & locale::numeric)
	{
	install_from<numpunct<char> >(one);
	install_from<numpunct<wchar_t> >(one);
	install_from<num_get<char> >(one);
	install_from<num_get<wchar_t> >(one);
	install_from<num_put<char> >(one);
	install_from<num_put<wchar_t> >(one);
	}
	if (c & locale::time)
	{
	install_from<time_get<char> >(one);
	install_from<time_get<wchar_t> >(one);
	install_from<time_put<char> >(one);
	install_from<time_put<wchar_t> >(one);
	}
	if (c & locale::messages)
	{
	install_from<_VSTD::messages<char> >(one);
	install_from<_VSTD::messages<wchar_t> >(one);
	}
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	for (unsigned i = 0; i < facets_.size(); ++i)
	if (facets_[i])
	facets_[i]->__release_shared();
	throw;
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	locale::__imp::__imp(const __imp& other, facet* f, long id)
	: facets_(max<size_t>(N, other.facets_.size()+1)),
	name_("*")
	{
	f->__add_shared();
	unique_ptr<facet, release> hold(f);
	facets_ = other.facets_;
	for (unsigned i = 0; i < other.facets_.size(); ++i)
	if (facets_[i])
	facets_[i]->__add_shared();
	install(hold.get(), id);
	}

	locale::__imp::~__imp()
	{
	for (unsigned i = 0; i < facets_.size(); ++i)
	if (facets_[i])
	facets_[i]->__release_shared();
	}

	void
	locale::__imp::install(facet* f, long id)
	{
	f->__add_shared();
	unique_ptr<facet, release> hold(f);
	if (static_cast<size_t>(id) >= facets_.size())
	facets_.resize(static_cast<size_t>(id+1));
	if (facets_[static_cast<size_t>(id)])
	facets_[static_cast<size_t>(id)]->__release_shared();
	facets_[static_cast<size_t>(id)] = hold.release();
	}

	const locale::facet*
	locale::__imp::use_facet(long id) const
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	if (!has_facet(id))
	throw bad_cast();
	#endif // _LIBCPP_NO_EXCEPTIONS
	return facets_[static_cast<size_t>(id)];
	}

	// locale

	const locale&
	locale::__imp::make_classic()
	{
	// only one thread can get in here and it only gets in once
	static aligned_storage<sizeof(locale)>::type buf;
	locale* c = reinterpret_cast<locale*>(&buf);
	c->__locale_ = &make<__imp>(1u);
	return *c;
	}

	const locale&
	locale::classic()
	{
	static const locale& c = __imp::make_classic();
	return c;
	}

	locale&
	locale::__imp::make_global()
	{
	// only one thread can get in here and it only gets in once
	static aligned_storage<sizeof(locale)>::type buf;
	auto *obj = ::new (&buf) locale(locale::classic());
	return *obj;
	}

	locale&
	locale::__global()
	{
	static locale& g = __imp::make_global();
	return g;
	}

	locale::locale() _NOEXCEPT
	: __locale_(__global().__locale_)
	{
	__locale_->__add_shared();
	}

	locale::locale(const locale& l) _NOEXCEPT
	: __locale_(l.__locale_)
	{
	__locale_->__add_shared();
	}

	locale::~locale()
	{
	__locale_->__release_shared();
	}

	const locale&
	locale::operator=(const locale& other) _NOEXCEPT
	{
	other.__locale_->__add_shared();
	__locale_->__release_shared();
	__locale_ = other.__locale_;
	return *this;
	}

	locale::locale(const char* name)
	#ifndef _LIBCPP_NO_EXCEPTIONS
	: __locale_(name ? new __imp(name)
	: throw runtime_error("locale constructed with null"))
	#else // _LIBCPP_NO_EXCEPTIONS
	: __locale_(new __imp(name))
	#endif
	{
	__locale_->__add_shared();
	}

	locale::locale(const string& name)
	: __locale_(new __imp(name))
	{
	__locale_->__add_shared();
	}

	locale::locale(const locale& other, const char* name, category c)
	#ifndef _LIBCPP_NO_EXCEPTIONS
	: __locale_(name ? new __imp(*other.__locale_, name, c)
	: throw runtime_error("locale constructed with null"))
	#else // _LIBCPP_NO_EXCEPTIONS
	: __locale_(new __imp(*other.__locale_, name, c))
	#endif
	{
	__locale_->__add_shared();
	}

	locale::locale(const locale& other, const string& name, category c)
	: __locale_(new __imp(*other.__locale_, name, c))
	{
	__locale_->__add_shared();
	}

	locale::locale(const locale& other, const locale& one, category c)
	: __locale_(new __imp(other.__locale_, one.__locale_, c))
	{
	__locale_->__add_shared();
	}

	string
	locale::name() const
	{
	return __locale_->name();
	}

	void
	locale::__install_ctor(const locale& other, facet* f, long id)
	{
	if (f)
	__locale_ = new __imp(*other.__locale_, f, id);
	else
	__locale_ = other.__locale_;
	__locale_->__add_shared();
	}

	locale
	locale::global(const locale& loc)
	{
	locale& g = __global();
	locale r = g;
	g = loc;
	if (g.name() != "*")
	setlocale(LC_ALL, g.name().c_str());
	return r;
	}

	bool
	locale::has_facet(id& x) const
	{
	return __locale_->has_facet(x.__get());
	}

	const locale::facet*
	locale::use_facet(id& x) const
	{
	return __locale_->use_facet(x.__get());
	}

	bool
	locale::operator==(const locale& y) const
	{
	return (__locale_ == y.__locale_)
	\|\| (__locale_->name() != "*" && __locale_->name() == y.__locale_->name());
	}

	// locale::facet

	locale::facet::~facet()
	{
	}

	void
	locale::facet::__on_zero_shared() _NOEXCEPT
	{
	delete this;
	}

	// locale::id

	int32_t locale::id::__next_id = 0;

	namespace
	{

	class __fake_bind
	{
	locale::id* id_;
	void (locale::id::* pmf_)();
	public:
	__fake_bind(void (locale::id::* pmf)(), locale::id* id)
	: id_(id), pmf_(pmf) {}

	void operator()() const
	{
	(id_->*pmf_)();
	}
	};

	}

	long
	locale::id::__get()
	{
	call_once(__flag_, __fake_bind(&locale::id::__init, this));
	return __id_ - 1;
	}

	void
	locale::id::__init()
	{
	__id_ = __libcpp_atomic_add(&__next_id, 1);
	}

	// template <> class collate_byname<char>

	collate_byname<char>::collate_byname(const char* n, size_t refs)
	: collate<char>(refs),
	__l(newlocale(LC_ALL_MASK, n, 0))
	{
	if (__l == 0)
	__throw_runtime_error("collate_byname<char>::collate_byname"
	" failed to construct for " + string(n));
	}

	collate_byname<char>::collate_byname(const string& name, size_t refs)
	: collate<char>(refs),
	__l(newlocale(LC_ALL_MASK, name.c_str(), 0))
	{
	if (__l == 0)
	__throw_runtime_error("collate_byname<char>::collate_byname"
	" failed to construct for " + name);
	}

	collate_byname<char>::~collate_byname()
	{
	freelocale(__l);
	}

	int
	collate_byname<char>::do_compare(const char_type* __lo1, const char_type* __hi1,
	const char_type* __lo2, const char_type* __hi2) const
	{
	string_type lhs(__lo1, __hi1);
	string_type rhs(__lo2, __hi2);
	int r = strcoll_l(lhs.c_str(), rhs.c_str(), __l);
	if (r < 0)
	return -1;
	if (r > 0)
	return 1;
	return r;
	}

	collate_byname<char>::string_type
	collate_byname<char>::do_transform(const char_type* lo, const char_type* hi) const
	{
	const string_type in(lo, hi);
	string_type out(strxfrm_l(0, in.c_str(), 0, __l), char());
	strxfrm_l(const_cast<char*>(out.c_str()), in.c_str(), out.size()+1, __l);
	return out;
	}

	// template <> class collate_byname<wchar_t>

	collate_byname<wchar_t>::collate_byname(const char* n, size_t refs)
	: collate<wchar_t>(refs),
	__l(newlocale(LC_ALL_MASK, n, 0))
	{
	if (__l == 0)
	__throw_runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
	" failed to construct for " + string(n));
	}

	collate_byname<wchar_t>::collate_byname(const string& name, size_t refs)
	: collate<wchar_t>(refs),
	__l(newlocale(LC_ALL_MASK, name.c_str(), 0))
	{
	if (__l == 0)
	__throw_runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
	" failed to construct for " + name);
	}

	collate_byname<wchar_t>::~collate_byname()
	{
	freelocale(__l);
	}

	int
	collate_byname<wchar_t>::do_compare(const char_type* __lo1, const char_type* __hi1,
	const char_type* __lo2, const char_type* __hi2) const
	{
	string_type lhs(__lo1, __hi1);
	string_type rhs(__lo2, __hi2);
	int r = wcscoll_l(lhs.c_str(), rhs.c_str(), __l);
	if (r < 0)
	return -1;
	if (r > 0)
	return 1;
	return r;
	}

	collate_byname<wchar_t>::string_type
	collate_byname<wchar_t>::do_transform(const char_type* lo, const char_type* hi) const
	{
	const string_type in(lo, hi);
	string_type out(wcsxfrm_l(0, in.c_str(), 0, __l), wchar_t());
	wcsxfrm_l(const_cast<wchar_t*>(out.c_str()), in.c_str(), out.size()+1, __l);
	return out;
	}

	// template <> class ctype<wchar_t>;

	const ctype_base::mask ctype_base::space;
	const ctype_base::mask ctype_base::print;
	const ctype_base::mask ctype_base::cntrl;
	const ctype_base::mask ctype_base::upper;
	const ctype_base::mask ctype_base::lower;
	const ctype_base::mask ctype_base::alpha;
	const ctype_base::mask ctype_base::digit;
	const ctype_base::mask ctype_base::punct;
	const ctype_base::mask ctype_base::xdigit;
	const ctype_base::mask ctype_base::blank;
	const ctype_base::mask ctype_base::alnum;
	const ctype_base::mask ctype_base::graph;

	locale::id ctype<wchar_t>::id;

	ctype<wchar_t>::~ctype()
	{
	}

	bool
	ctype<wchar_t>::do_is(mask m, char_type c) const
	{
	return isascii(c) ? (ctype<char>::classic_table()[c] & m) != 0 : false;
	}

	const wchar_t*
	ctype<wchar_t>::do_is(const char_type* low, const char_type* high, mask* vec) const
	{
	for (; low != high; ++low, ++vec)
	vec = static_cast<mask>(isascii(low) ?
	ctype<char>::classic_table()[*low] : 0);
	return low;
	}

	const wchar_t*
	ctype<wchar_t>::do_scan_is(mask m, const char_type* low, const char_type* high) const
	{
	for (; low != high; ++low)
	if (isascii(low) && (ctype<char>::classic_table()[low] & m))
	break;
	return low;
	}

	const wchar_t*
	ctype<wchar_t>::do_scan_not(mask m, const char_type* low, const char_type* high) const
	{
	for (; low != high; ++low)
	if (!(isascii(low) && (ctype<char>::classic_table()[low] & m)))
	break;
	return low;
	}

	wchar_t
	ctype<wchar_t>::do_toupper(char_type c) const
	{
	#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
	return isascii(c) ? _DefaultRuneLocale.__mapupper[c] : c;
	#elif defined(__GLIBC__) \|\| defined(__EMSCRIPTEN__) \|\| \
	defined(__NetBSD__)
	return isascii(c) ? ctype<char>::__classic_upper_table()[c] : c;
	#else
	return (isascii(c) && iswlower_l(c, _LIBCPP_GET_C_LOCALE)) ? c-L'a'+L'A' : c;
	#endif
	}

	const wchar_t*
	ctype<wchar_t>::do_toupper(char_type* low, const char_type* high) const
	{
	for (; low != high; ++low)
	#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
	low = isascii(low) ? _DefaultRuneLocale.__mapupper[low] : low;
	#elif defined(__GLIBC__) \|\| defined(__EMSCRIPTEN__) \|\| \
	defined(__NetBSD__)
	low = isascii(low) ? ctype<char>::__classic_upper_table()[*low]
	: *low;
	#else
	low = (isascii(low) && islower_l(low, _LIBCPP_GET_C_LOCALE)) ? (low-L'a'+L'A') : *low;
	#endif
	return low;
	}

	wchar_t
	ctype<wchar_t>::do_tolower(char_type c) const
	{
	#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
	return isascii(c) ? _DefaultRuneLocale.__maplower[c] : c;
	#elif defined(__GLIBC__) \|\| defined(__EMSCRIPTEN__) \|\| \
	defined(__NetBSD__)
	return isascii(c) ? ctype<char>::__classic_lower_table()[c] : c;
	#else
	return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c-L'A'+'a' : c;
	#endif
	}

	const wchar_t*
	ctype<wchar_t>::do_tolower(char_type* low, const char_type* high) const
	{
	for (; low != high; ++low)
	#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
	low = isascii(low) ? _DefaultRuneLocale.__maplower[low] : low;
	#elif defined(__GLIBC__) \|\| defined(__EMSCRIPTEN__) \|\| \
	defined(__NetBSD__)
	low = isascii(low) ? ctype<char>::__classic_lower_table()[*low]
	: *low;
	#else
	low = (isascii(low) && isupper_l(low, _LIBCPP_GET_C_LOCALE)) ? low-L'A'+L'a' : *low;
	#endif
	return low;
	}

	wchar_t
	ctype<wchar_t>::do_widen(char c) const
	{
	return c;
	}

	const char*
	ctype<wchar_t>::do_widen(const char* low, const char* high, char_type* dest) const
	{
	for (; low != high; ++low, ++dest)
	dest = low;
	return low;
	}

	char
	ctype<wchar_t>::do_narrow(char_type c, char dfault) const
	{
	if (isascii(c))
	return static_cast<char>(c);
	return dfault;
	}

	const wchar_t*
	ctype<wchar_t>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const
	{
	for (; low != high; ++low, ++dest)
	if (isascii(*low))
	dest = static_cast<char>(low);
	else
	*dest = dfault;
	return low;
	}

	// template <> class ctype<char>;

	locale::id ctype<char>::id;

	ctype<char>::ctype(const mask* tab, bool del, size_t refs)
	: locale::facet(refs),
	__tab_(tab),
	__del_(del)
	{
	if (__tab_ == 0)
	__tab_ = classic_table();
	}

	ctype<char>::~ctype()
	{
	if (__tab_ && __del_)
	delete [] __tab_;
	}

	char
	ctype<char>::do_toupper(char_type c) const
	{
	#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
	return isascii(c) ?
	static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(c)]) : c;
	#elif defined(__NetBSD__)
	return static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]);
	#elif defined(__GLIBC__) \|\| defined(__EMSCRIPTEN__)
	return isascii(c) ?
	static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]) : c;
	#else
	return (isascii(c) && islower_l(c, _LIBCPP_GET_C_LOCALE)) ? c-'a'+'A' : c;
	#endif
	}

	const char*
	ctype<char>::do_toupper(char_type* low, const char_type* high) const
	{
	for (; low != high; ++low)
	#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
	low = isascii(low) ?
	static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(low)]) : low;
	#elif defined(__NetBSD__)
	low = static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(low)]);
	#elif defined(__GLIBC__) \|\| defined(__EMSCRIPTEN__)
	low = isascii(low) ?
	static_cast<char>(__classic_upper_table()[static_cast<size_t>(low)]) : low;
	#else
	low = (isascii(low) && islower_l(low, _LIBCPP_GET_C_LOCALE)) ? low-'a'+'A' : *low;
	#endif
	return low;
	}

	char
	ctype<char>::do_tolower(char_type c) const
	{
	#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
	return isascii(c) ?
	static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(c)]) : c;
	#elif defined(__NetBSD__)
	return static_cast<char>(__classic_lower_table()[static_cast<unsigned char>(c)]);
	#elif defined(__GLIBC__) \|\| defined(__EMSCRIPTEN__)
	return isascii(c) ?
	static_cast<char>(__classic_lower_table()[static_cast<size_t>(c)]) : c;
	#else
	return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c-'A'+'a' : c;
	#endif
	}

	const char*
	ctype<char>::do_tolower(char_type* low, const char_type* high) const
	{
	for (; low != high; ++low)
	#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
	low = isascii(low) ? static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(low)]) : low;
	#elif defined(__NetBSD__)
	low = static_cast<char>(__classic_lower_table()[static_cast<unsigned char>(low)]);
	#elif defined(__GLIBC__) \|\| defined(__EMSCRIPTEN__)
	low = isascii(low) ? static_cast<char>(__classic_lower_table()[static_cast<size_t>(low)]) : low;
	#else
	low = (isascii(low) && isupper_l(low, _LIBCPP_GET_C_LOCALE)) ? low-'A'+'a' : *low;
	#endif
	return low;
	}

	char
	ctype<char>::do_widen(char c) const
	{
	return c;
	}

	const char*
	ctype<char>::do_widen(const char* low, const char* high, char_type* dest) const
	{
	for (; low != high; ++low, ++dest)
	dest = low;
	return low;
	}

	char
	ctype<char>::do_narrow(char_type c, char dfault) const
	{
	if (isascii(c))
	return static_cast<char>(c);
	return dfault;
	}

	const char*
	ctype<char>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const
	{
	for (; low != high; ++low, ++dest)
	if (isascii(*low))
	dest = low;
	else
	*dest = dfault;
	return low;
	}

	#if defined(__EMSCRIPTEN__)
	extern "C" const unsigned short ** __ctype_b_loc();
	extern "C" const int ** __ctype_tolower_loc();
	extern "C" const int ** __ctype_toupper_loc();
	#endif

	#ifdef _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
	const ctype<char>::mask*
	ctype<char>::classic_table() _NOEXCEPT
	{
	static _LIBCPP_CONSTEXPR const ctype<char>::mask builtin_table[table_size] = {
	cntrl, cntrl,
	cntrl, cntrl,
	cntrl, cntrl,
	cntrl, cntrl,
	cntrl, cntrl \| space \| blank,
	cntrl \| space, cntrl \| space,
	cntrl \| space, cntrl \| space,
	cntrl, cntrl,
	cntrl, cntrl,
	cntrl, cntrl,
	cntrl, cntrl,
	cntrl, cntrl,
	cntrl, cntrl,
	cntrl, cntrl,
	cntrl, cntrl,
	cntrl, cntrl,
	space \| blank \| print, punct \| print,
	punct \| print, punct \| print,
	punct \| print, punct \| print,
	punct \| print, punct \| print,
	punct \| print, punct \| print,
	punct \| print, punct \| print,
	punct \| print, punct \| print,
	punct \| print, punct \| print,
	digit \| print \| xdigit, digit \| print \| xdigit,
	digit \| print \| xdigit, digit \| print \| xdigit,
	digit \| print \| xdigit, digit \| print \| xdigit,
	digit \| print \| xdigit, digit \| print \| xdigit,
	digit \| print \| xdigit, digit \| print \| xdigit,
	punct \| print, punct \| print,
	punct \| print, punct \| print,
	punct \| print, punct \| print,
	punct \| print, upper \| xdigit \| print \| alpha,
	upper \| xdigit \| print \| alpha, upper \| xdigit \| print \| alpha,
	upper \| xdigit \| print \| alpha, upper \| xdigit \| print \| alpha,
	upper \| xdigit \| print \| alpha, upper \| print \| alpha,
	upper \| print \| alpha, upper \| print \| alpha,
	upper \| print \| alpha, upper \| print \| alpha,
	upper \| print \| alpha, upper \| print \| alpha,
	upper \| print \| alpha, upper \| print \| alpha,
	upper \| print \| alpha, upper \| print \| alpha,
	upper \| print \| alpha, upper \| print \| alpha,
	upper \| print \| alpha, upper \| print \| alpha,
	upper \| print \| alpha, upper \| print \| alpha,
	upper \| print \| alpha, upper \| print \| alpha,
	upper \| print \| alpha, punct \| print,
	punct \| print, punct \| print,
	punct \| print, punct \| print,
	punct \| print, lower \| xdigit \| print \| alpha,
	lower \| xdigit \| print \| alpha, lower \| xdigit \| print \| alpha,
	lower \| xdigit \| print \| alpha, lower \| xdigit \| print \| alpha,
	lower \| xdigit \| print \| alpha, lower \| print \| alpha,
	lower \| print \| alpha, lower \| print \| alpha,
	lower \| print \| alpha, lower \| print \| alpha,
	lower \| print \| alpha, lower \| print \| alpha,
	lower \| print \| alpha, lower \| print \| alpha,
	lower \| print \| alpha, lower \| print \| alpha,
	lower \| print \| alpha, lower \| print \| alpha,
	lower \| print \| alpha, lower \| print \| alpha,
	lower \| print \| alpha, lower \| print \| alpha,
	lower \| print \| alpha, lower \| print \| alpha,
	lower \| print \| alpha, punct \| print,
	punct \| print, punct \| print,
	punct \| print, cntrl,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
	};
	return builtin_table;
	}
	#else
	const ctype<char>::mask*
	ctype<char>::classic_table() _NOEXCEPT
	{
	#if defined(__APPLE__) \|\| defined(__FreeBSD__)
	return _DefaultRuneLocale.__runetype;
	#elif defined(__NetBSD__)
	return _C_ctype_tab_ + 1;
	#elif defined(__GLIBC__)
	return _LIBCPP_GET_C_LOCALE->__ctype_b;
	#elif __sun__
	return __ctype_mask;
	#elif defined(_LIBCPP_MSVCRT) \|\| defined(__MINGW32__)
	return __pctype_func();
	#elif defined(__EMSCRIPTEN__)
	return *__ctype_b_loc();
	#elif defined(_NEWLIB_VERSION)
	// Newlib has a 257-entry table in ctype_.c, where (char)0 starts at [1].
	return _ctype_ + 1;
	#elif defined(_AIX)
	return (const unsigned int *)__lc_ctype_ptr->obj->mask;
	#else
	// Platform not supported: abort so the person doing the port knows what to
	// fix
	# warning ctype<char>::classic_table() is not implemented
	printf("ctype<char>::classic_table() is not implemented\n");
	abort();
	return NULL;
	#endif
	}
	#endif

	#if defined(__GLIBC__)
	const int*
	ctype<char>::__classic_lower_table() _NOEXCEPT
	{
	return _LIBCPP_GET_C_LOCALE->__ctype_tolower;
	}

	const int*
	ctype<char>::__classic_upper_table() _NOEXCEPT
	{
	return _LIBCPP_GET_C_LOCALE->__ctype_toupper;
	}
	#elif __NetBSD__
	const short*
	ctype<char>::__classic_lower_table() _NOEXCEPT
	{
	return _C_tolower_tab_ + 1;
	}

	const short*
	ctype<char>::__classic_upper_table() _NOEXCEPT
	{
	return _C_toupper_tab_ + 1;
	}

	#elif defined(__EMSCRIPTEN__)
	const int*
	ctype<char>::__classic_lower_table() _NOEXCEPT
	{
	return *__ctype_tolower_loc();
	}

	const int*
	ctype<char>::__classic_upper_table() _NOEXCEPT
	{
	return *__ctype_toupper_loc();
	}
	#endif // __GLIBC__ \|\| __NETBSD__ \|\| __EMSCRIPTEN__

	// template <> class ctype_byname<char>

	ctype_byname<char>::ctype_byname(const char* name, size_t refs)
	: ctype<char>(0, false, refs),
	__l(newlocale(LC_ALL_MASK, name, 0))
	{
	if (__l == 0)
	__throw_runtime_error("ctype_byname<char>::ctype_byname"
	" failed to construct for " + string(name));
	}

	ctype_byname<char>::ctype_byname(const string& name, size_t refs)
	: ctype<char>(0, false, refs),
	__l(newlocale(LC_ALL_MASK, name.c_str(), 0))
	{
	if (__l == 0)
	__throw_runtime_error("ctype_byname<char>::ctype_byname"
	" failed to construct for " + name);
	}

	ctype_byname<char>::~ctype_byname()
	{
	freelocale(__l);
	}

	char
	ctype_byname<char>::do_toupper(char_type c) const
	{
	return static_cast<char>(toupper_l(static_cast<unsigned char>(c), __l));
	}

	const char*
	ctype_byname<char>::do_toupper(char_type* low, const char_type* high) const
	{
	for (; low != high; ++low)
	low = static_cast<char>(toupper_l(static_cast<unsigned char>(low), __l));
	return low;
	}

	char
	ctype_byname<char>::do_tolower(char_type c) const
	{
	return static_cast<char>(tolower_l(static_cast<unsigned char>(c), __l));
	}

	const char*
	ctype_byname<char>::do_tolower(char_type* low, const char_type* high) const
	{
	for (; low != high; ++low)
	low = static_cast<char>(tolower_l(static_cast<unsigned char>(low), __l));
	return low;
	}

	// template <> class ctype_byname<wchar_t>

	ctype_byname<wchar_t>::ctype_byname(const char* name, size_t refs)
	: ctype<wchar_t>(refs),
	__l(newlocale(LC_ALL_MASK, name, 0))
	{
	if (__l == 0)
	__throw_runtime_error("ctype_byname<wchar_t>::ctype_byname"
	" failed to construct for " + string(name));
	}

	ctype_byname<wchar_t>::ctype_byname(const string& name, size_t refs)
	: ctype<wchar_t>(refs),
	__l(newlocale(LC_ALL_MASK, name.c_str(), 0))
	{
	if (__l == 0)
	__throw_runtime_error("ctype_byname<wchar_t>::ctype_byname"
	" failed to construct for " + name);
	}

	ctype_byname<wchar_t>::~ctype_byname()
	{
	freelocale(__l);
	}

	bool
	ctype_byname<wchar_t>::do_is(mask m, char_type c) const
	{
	#ifdef _LIBCPP_WCTYPE_IS_MASK
	return static_cast<bool>(iswctype_l(c, m, __l));
	#else
	bool result = false;
	wint_t ch = static_cast<wint_t>(c);
	if ((m & space) == space) result \|= (iswspace_l(ch, __l) != 0);
	if ((m & print) == print) result \|= (iswprint_l(ch, __l) != 0);
	if ((m & cntrl) == cntrl) result \|= (iswcntrl_l(ch, __l) != 0);
	if ((m & upper) == upper) result \|= (iswupper_l(ch, __l) != 0);
	if ((m & lower) == lower) result \|= (iswlower_l(ch, __l) != 0);
	if ((m & alpha) == alpha) result \|= (iswalpha_l(ch, __l) != 0);
	if ((m & digit) == digit) result \|= (iswdigit_l(ch, __l) != 0);
	if ((m & punct) == punct) result \|= (iswpunct_l(ch, __l) != 0);
	if ((m & xdigit) == xdigit) result \|= (iswxdigit_l(ch, __l) != 0);
	if ((m & blank) == blank) result \|= (iswblank_l(ch, __l) != 0);
	return result;
	#endif
	}

	const wchar_t*
	ctype_byname<wchar_t>::do_is(const char_type* low, const char_type* high, mask* vec) const
	{
	for (; low != high; ++low, ++vec)
	{
	if (isascii(*low))
	vec = static_cast<mask>(ctype<char>::classic_table()[low]);
	else
	{
	*vec = 0;
	wint_t ch = static_cast<wint_t>(*low);
	if (iswspace_l(ch, __l))
	*vec \|= space;
	#ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT
	if (iswprint_l(ch, __l))
	*vec \|= print;
	#endif
	if (iswcntrl_l(ch, __l))
	*vec \|= cntrl;
	if (iswupper_l(ch, __l))
	*vec \|= upper;
	if (iswlower_l(ch, __l))
	*vec \|= lower;
	#ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA
	if (iswalpha_l(ch, __l))
	*vec \|= alpha;
	#endif
	if (iswdigit_l(ch, __l))
	*vec \|= digit;
	if (iswpunct_l(ch, __l))
	*vec \|= punct;
	#ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_XDIGIT
	if (iswxdigit_l(ch, __l))
	*vec \|= xdigit;
	#endif
	#if !defined(__sun__)
	if (iswblank_l(ch, __l))
	*vec \|= blank;
	#endif
	}
	}
	return low;
	}

	const wchar_t*
	ctype_byname<wchar_t>::do_scan_is(mask m, const char_type* low, const char_type* high) const
	{
	for (; low != high; ++low)
	{
	#ifdef _LIBCPP_WCTYPE_IS_MASK
	if (iswctype_l(*low, m, __l))
	break;
	#else
	wint_t ch = static_cast<wint_t>(*low);
	if ((m & space) == space && iswspace_l(ch, __l)) break;
	if ((m & print) == print && iswprint_l(ch, __l)) break;
	if ((m & cntrl) == cntrl && iswcntrl_l(ch, __l)) break;
	if ((m & upper) == upper && iswupper_l(ch, __l)) break;
	if ((m & lower) == lower && iswlower_l(ch, __l)) break;
	if ((m & alpha) == alpha && iswalpha_l(ch, __l)) break;
	if ((m & digit) == digit && iswdigit_l(ch, __l)) break;
	if ((m & punct) == punct && iswpunct_l(ch, __l)) break;
	if ((m & xdigit) == xdigit && iswxdigit_l(ch, __l)) break;
	if ((m & blank) == blank && iswblank_l(ch, __l)) break;
	#endif
	}
	return low;
	}

	const wchar_t*
	ctype_byname<wchar_t>::do_scan_not(mask m, const char_type* low, const char_type* high) const
	{
	for (; low != high; ++low)
	{
	#ifdef _LIBCPP_WCTYPE_IS_MASK
	if (!iswctype_l(*low, m, __l))
	break;
	#else
	wint_t ch = static_cast<wint_t>(*low);
	if ((m & space) == space && iswspace_l(ch, __l)) continue;
	if ((m & print) == print && iswprint_l(ch, __l)) continue;
	if ((m & cntrl) == cntrl && iswcntrl_l(ch, __l)) continue;
	if ((m & upper) == upper && iswupper_l(ch, __l)) continue;
	if ((m & lower) == lower && iswlower_l(ch, __l)) continue;
	if ((m & alpha) == alpha && iswalpha_l(ch, __l)) continue;
	if ((m & digit) == digit && iswdigit_l(ch, __l)) continue;
	if ((m & punct) == punct && iswpunct_l(ch, __l)) continue;
	if ((m & xdigit) == xdigit && iswxdigit_l(ch, __l)) continue;
	if ((m & blank) == blank && iswblank_l(ch, __l)) continue;
	break;
	#endif
	}
	return low;
	}

	wchar_t
	ctype_byname<wchar_t>::do_toupper(char_type c) const
	{
	return towupper_l(c, __l);
	}

	const wchar_t*
	ctype_byname<wchar_t>::do_toupper(char_type* low, const char_type* high) const
	{
	for (; low != high; ++low)
	low = towupper_l(low, __l);
	return low;
	}

	wchar_t
	ctype_byname<wchar_t>::do_tolower(char_type c) const
	{
	return towlower_l(c, __l);
	}

	const wchar_t*
	ctype_byname<wchar_t>::do_tolower(char_type* low, const char_type* high) const
	{
	for (; low != high; ++low)
	low = towlower_l(low, __l);
	return low;
	}

	wchar_t
	ctype_byname<wchar_t>::do_widen(char c) const
	{
	return __libcpp_btowc_l(c, __l);
	}

	const char*
	ctype_byname<wchar_t>::do_widen(const char* low, const char* high, char_type* dest) const
	{
	for (; low != high; ++low, ++dest)
	dest = __libcpp_btowc_l(low, __l);
	return low;
	}

	char
	ctype_byname<wchar_t>::do_narrow(char_type c, char dfault) const
	{
	int r = __libcpp_wctob_l(c, __l);
	return r != static_cast<int>(WEOF) ? static_cast<char>(r) : dfault;
	}

	const wchar_t*
	ctype_byname<wchar_t>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const
	{
	for (; low != high; ++low, ++dest)
	{
	int r = __libcpp_wctob_l(*low, __l);
	*dest = r != static_cast<int>(WEOF) ? static_cast<char>(r) : dfault;
	}
	return low;
	}

	// template <> class codecvt<char, char, mbstate_t>

	locale::id codecvt<char, char, mbstate_t>::id;

	codecvt<char, char, mbstate_t>::~codecvt()
	{
	}

	codecvt<char, char, mbstate_t>::result
	codecvt<char, char, mbstate_t>::do_out(state_type&,
	const intern_type* frm, const intern_type, const intern_type& frm_nxt,
	extern_type* to, extern_type, extern_type& to_nxt) const
	{
	frm_nxt = frm;
	to_nxt = to;
	return noconv;
	}

	codecvt<char, char, mbstate_t>::result
	codecvt<char, char, mbstate_t>::do_in(state_type&,
	const extern_type* frm, const extern_type, const extern_type& frm_nxt,
	intern_type* to, intern_type, intern_type& to_nxt) const
	{
	frm_nxt = frm;
	to_nxt = to;
	return noconv;
	}

	codecvt<char, char, mbstate_t>::result
	codecvt<char, char, mbstate_t>::do_unshift(state_type&,
	extern_type* to, extern_type, extern_type& to_nxt) const
	{
	to_nxt = to;
	return noconv;
	}

	int
	codecvt<char, char, mbstate_t>::do_encoding() const _NOEXCEPT
	{
	return 1;
	}

	bool
	codecvt<char, char, mbstate_t>::do_always_noconv() const _NOEXCEPT
	{
	return true;
	}

	int
	codecvt<char, char, mbstate_t>::do_length(state_type&,
	const extern_type* frm, const extern_type* end, size_t mx) const
	{
	return static_cast<int>(min<size_t>(mx, static_cast<size_t>(end-frm)));
	}

	int
	codecvt<char, char, mbstate_t>::do_max_length() const _NOEXCEPT
	{
	return 1;
	}

	// template <> class codecvt<wchar_t, char, mbstate_t>

	locale::id codecvt<wchar_t, char, mbstate_t>::id;

	codecvt<wchar_t, char, mbstate_t>::codecvt(size_t refs)
	: locale::facet(refs),
	__l(_LIBCPP_GET_C_LOCALE)
	{
	}

	codecvt<wchar_t, char, mbstate_t>::codecvt(const char* nm, size_t refs)
	: locale::facet(refs),
	__l(newlocale(LC_ALL_MASK, nm, 0))
	{
	if (__l == 0)
	__throw_runtime_error("codecvt_byname<wchar_t, char, mbstate_t>::codecvt_byname"
	" failed to construct for " + string(nm));
	}

	codecvt<wchar_t, char, mbstate_t>::~codecvt()
	{
	if (__l != _LIBCPP_GET_C_LOCALE)
	freelocale(__l);
	}

	codecvt<wchar_t, char, mbstate_t>::result
	codecvt<wchar_t, char, mbstate_t>::do_out(state_type& st,
	const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
	extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
	{
	// look for first internal null in frm
	const intern_type* fend = frm;
	for (; fend != frm_end; ++fend)
	if (*fend == 0)
	break;
	// loop over all null-terminated sequences in frm
	to_nxt = to;
	for (frm_nxt = frm; frm != frm_end && to != to_end; frm = frm_nxt, to = to_nxt)
	{
	// save state in case it is needed to recover to_nxt on error
	mbstate_t save_state = st;
	size_t n = __libcpp_wcsnrtombs_l(to, &frm_nxt, static_cast<size_t>(fend-frm),
	static_cast<size_t>(to_end-to), &st, __l);
	if (n == size_t(-1))
	{
	// need to recover to_nxt
	for (to_nxt = to; frm != frm_nxt; ++frm)
	{
	n = __libcpp_wcrtomb_l(to_nxt, *frm, &save_state, __l);
	if (n == size_t(-1))
	break;
	to_nxt += n;
	}
	frm_nxt = frm;
	return error;
	}
	if (n == 0)
	return partial;
	to_nxt += n;
	if (to_nxt == to_end)
	break;
	if (fend != frm_end) // set up next null terminated sequence
	{
	// Try to write the terminating null
	extern_type tmp[MB_LEN_MAX];
	n = __libcpp_wcrtomb_l(tmp, intern_type(), &st, __l);
	if (n == size_t(-1)) // on error
	return error;
	if (n > static_cast<size_t>(to_end-to_nxt)) // is there room?
	return partial;
	for (extern_type* p = tmp; n; --n) // write it
	to_nxt++ = p++;
	++frm_nxt;
	// look for next null in frm
	for (fend = frm_nxt; fend != frm_end; ++fend)
	if (*fend == 0)
	break;
	}
	}
	return frm_nxt == frm_end ? ok : partial;
	}

	codecvt<wchar_t, char, mbstate_t>::result
	codecvt<wchar_t, char, mbstate_t>::do_in(state_type& st,
	const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
	intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
	{
	// look for first internal null in frm
	const extern_type* fend = frm;
	for (; fend != frm_end; ++fend)
	if (*fend == 0)
	break;
	// loop over all null-terminated sequences in frm
	to_nxt = to;
	for (frm_nxt = frm; frm != frm_end && to != to_end; frm = frm_nxt, to = to_nxt)
	{
	// save state in case it is needed to recover to_nxt on error
	mbstate_t save_state = st;
	size_t n = __libcpp_mbsnrtowcs_l(to, &frm_nxt, static_cast<size_t>(fend-frm),
	static_cast<size_t>(to_end-to), &st, __l);
	if (n == size_t(-1))
	{
	// need to recover to_nxt
	for (to_nxt = to; frm != frm_nxt; ++to_nxt)
	{
	n = __libcpp_mbrtowc_l(to_nxt, frm, static_cast<size_t>(fend-frm),
	&save_state, __l);
	switch (n)
	{
	case 0:
	++frm;
	break;
	case size_t(-1):
	frm_nxt = frm;
	return error;
	case size_t(-2):
	frm_nxt = frm;
	return partial;
	default:
	frm += n;
	break;
	}
	}
	frm_nxt = frm;
	return frm_nxt == frm_end ? ok : partial;
	}
	if (n == size_t(-1))
	return error;
	to_nxt += n;
	if (to_nxt == to_end)
	break;
	if (fend != frm_end) // set up next null terminated sequence
	{
	// Try to write the terminating null
	n = __libcpp_mbrtowc_l(to_nxt, frm_nxt, 1, &st, __l);
	if (n != 0) // on error
	return error;
	++to_nxt;
	++frm_nxt;
	// look for next null in frm
	for (fend = frm_nxt; fend != frm_end; ++fend)
	if (*fend == 0)
	break;
	}
	}
	return frm_nxt == frm_end ? ok : partial;
	}

	codecvt<wchar_t, char, mbstate_t>::result
	codecvt<wchar_t, char, mbstate_t>::do_unshift(state_type& st,
	extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
	{
	to_nxt = to;
	extern_type tmp[MB_LEN_MAX];
	size_t n = __libcpp_wcrtomb_l(tmp, intern_type(), &st, __l);
	if (n == size_t(-1) \|\| n == 0) // on error
	return error;
	--n;
	if (n > static_cast<size_t>(to_end-to_nxt)) // is there room?
	return partial;
	for (extern_type* p = tmp; n; --n) // write it
	to_nxt++ = p++;
	return ok;
	}

	int
	codecvt<wchar_t, char, mbstate_t>::do_encoding() const _NOEXCEPT
	{
	if (__libcpp_mbtowc_l(nullptr, nullptr, MB_LEN_MAX, __l) != 0)
	return -1;

	// stateless encoding
	if (__l == 0 \|\| __libcpp_mb_cur_max_l(__l) == 1) // there are no known constant length encodings
	return 1; // which take more than 1 char to form a wchar_t
	return 0;
	}

	bool
	codecvt<wchar_t, char, mbstate_t>::do_always_noconv() const _NOEXCEPT
	{
	return false;
	}

	int
	codecvt<wchar_t, char, mbstate_t>::do_length(state_type& st,
	const extern_type* frm, const extern_type* frm_end, size_t mx) const
	{
	int nbytes = 0;
	for (size_t nwchar_t = 0; nwchar_t < mx && frm != frm_end; ++nwchar_t)
	{
	size_t n = __libcpp_mbrlen_l(frm, static_cast<size_t>(frm_end-frm), &st, __l);
	switch (n)
	{
	case 0:
	++nbytes;
	++frm;
	break;
	case size_t(-1):
	case size_t(-2):
	return nbytes;
	default:
	nbytes += n;
	frm += n;
	break;
	}
	}
	return nbytes;
	}

	int
	codecvt<wchar_t, char, mbstate_t>::do_max_length() const _NOEXCEPT
	{
	return __l == 0 ? 1 : static_cast<int>(__libcpp_mb_cur_max_l(__l));
	}

	// Valid UTF ranges
	// UTF-32 UTF-16 UTF-8 # of code points
	// first second first second third fourth
	// 000000 - 00007F 0000 - 007F 00 - 7F 127
	// 000080 - 0007FF 0080 - 07FF C2 - DF, 80 - BF 1920
	// 000800 - 000FFF 0800 - 0FFF E0 - E0, A0 - BF, 80 - BF 2048
	// 001000 - 00CFFF 1000 - CFFF E1 - EC, 80 - BF, 80 - BF 49152
	// 00D000 - 00D7FF D000 - D7FF ED - ED, 80 - 9F, 80 - BF 2048
	// 00D800 - 00DFFF invalid
	// 00E000 - 00FFFF E000 - FFFF EE - EF, 80 - BF, 80 - BF 8192
	// 010000 - 03FFFF D800 - D8BF, DC00 - DFFF F0 - F0, 90 - BF, 80 - BF, 80 - BF 196608
	// 040000 - 0FFFFF D8C0 - DBBF, DC00 - DFFF F1 - F3, 80 - BF, 80 - BF, 80 - BF 786432
	// 100000 - 10FFFF DBC0 - DBFF, DC00 - DFFF F4 - F4, 80 - 8F, 80 - BF, 80 - BF 65536

	static
	codecvt_base::result
	utf16_to_utf8(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
	uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
	unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
	{
	frm_nxt = frm;
	to_nxt = to;
	if (mode & generate_header)
	{
	if (to_end-to_nxt < 3)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xEF);
	*to_nxt++ = static_cast<uint8_t>(0xBB);
	*to_nxt++ = static_cast<uint8_t>(0xBF);
	}
	for (; frm_nxt < frm_end; ++frm_nxt)
	{
	uint16_t wc1 = *frm_nxt;
	if (wc1 > Maxcode)
	return codecvt_base::error;
	if (wc1 < 0x0080)
	{
	if (to_end-to_nxt < 1)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(wc1);
	}
	else if (wc1 < 0x0800)
	{
	if (to_end-to_nxt < 2)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xC0 \| (wc1 >> 6));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| (wc1 & 0x03F));
	}
	else if (wc1 < 0xD800)
	{
	if (to_end-to_nxt < 3)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xE0 \| (wc1 >> 12));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| ((wc1 & 0x0FC0) >> 6));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| (wc1 & 0x003F));
	}
	else if (wc1 < 0xDC00)
	{
	if (frm_end-frm_nxt < 2)
	return codecvt_base::partial;
	uint16_t wc2 = frm_nxt[1];
	if ((wc2 & 0xFC00) != 0xDC00)
	return codecvt_base::error;
	if (to_end-to_nxt < 4)
	return codecvt_base::partial;
	if (((((wc1 & 0x03C0UL) >> 6) + 1) << 16) +
	((wc1 & 0x003FUL) << 10) + (wc2 & 0x03FF) > Maxcode)
	return codecvt_base::error;
	++frm_nxt;
	uint8_t z = ((wc1 & 0x03C0) >> 6) + 1;
	*to_nxt++ = static_cast<uint8_t>(0xF0 \| (z >> 2));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| ((z & 0x03) << 4) \| ((wc1 & 0x003C) >> 2));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| ((wc1 & 0x0003) << 4) \| ((wc2 & 0x03C0) >> 6));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| (wc2 & 0x003F));
	}
	else if (wc1 < 0xE000)
	{
	return codecvt_base::error;
	}
	else
	{
	if (to_end-to_nxt < 3)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xE0 \| (wc1 >> 12));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| ((wc1 & 0x0FC0) >> 6));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| (wc1 & 0x003F));
	}
	}
	return codecvt_base::ok;
	}

	static
	codecvt_base::result
	utf16_to_utf8(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
	uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
	unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
	{
	frm_nxt = frm;
	to_nxt = to;
	if (mode & generate_header)
	{
	if (to_end-to_nxt < 3)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xEF);
	*to_nxt++ = static_cast<uint8_t>(0xBB);
	*to_nxt++ = static_cast<uint8_t>(0xBF);
	}
	for (; frm_nxt < frm_end; ++frm_nxt)
	{
	uint16_t wc1 = static_cast<uint16_t>(*frm_nxt);
	if (wc1 > Maxcode)
	return codecvt_base::error;
	if (wc1 < 0x0080)
	{
	if (to_end-to_nxt < 1)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(wc1);
	}
	else if (wc1 < 0x0800)
	{
	if (to_end-to_nxt < 2)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xC0 \| (wc1 >> 6));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| (wc1 & 0x03F));
	}
	else if (wc1 < 0xD800)
	{
	if (to_end-to_nxt < 3)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xE0 \| (wc1 >> 12));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| ((wc1 & 0x0FC0) >> 6));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| (wc1 & 0x003F));
	}
	else if (wc1 < 0xDC00)
	{
	if (frm_end-frm_nxt < 2)
	return codecvt_base::partial;
	uint16_t wc2 = static_cast<uint16_t>(frm_nxt[1]);
	if ((wc2 & 0xFC00) != 0xDC00)
	return codecvt_base::error;
	if (to_end-to_nxt < 4)
	return codecvt_base::partial;
	if (((((wc1 & 0x03C0UL) >> 6) + 1) << 16) +
	((wc1 & 0x003FUL) << 10) + (wc2 & 0x03FF) > Maxcode)
	return codecvt_base::error;
	++frm_nxt;
	uint8_t z = ((wc1 & 0x03C0) >> 6) + 1;
	*to_nxt++ = static_cast<uint8_t>(0xF0 \| (z >> 2));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| ((z & 0x03) << 4) \| ((wc1 & 0x003C) >> 2));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| ((wc1 & 0x0003) << 4) \| ((wc2 & 0x03C0) >> 6));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| (wc2 & 0x003F));
	}
	else if (wc1 < 0xE000)
	{
	return codecvt_base::error;
	}
	else
	{
	if (to_end-to_nxt < 3)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xE0 \| (wc1 >> 12));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| ((wc1 & 0x0FC0) >> 6));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| (wc1 & 0x003F));
	}
	}
	return codecvt_base::ok;
	}

	static
	codecvt_base::result
	utf8_to_utf16(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
	uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
	unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
	{
	frm_nxt = frm;
	to_nxt = to;
	if (mode & consume_header)
	{
	if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
	frm_nxt[2] == 0xBF)
	frm_nxt += 3;
	}
	for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
	{
	uint8_t c1 = *frm_nxt;
	if (c1 > Maxcode)
	return codecvt_base::error;
	if (c1 < 0x80)
	{
	*to_nxt = static_cast<uint16_t>(c1);
	++frm_nxt;
	}
	else if (c1 < 0xC2)
	{
	return codecvt_base::error;
	}
	else if (c1 < 0xE0)
	{
	if (frm_end-frm_nxt < 2)
	return codecvt_base::partial;
	uint8_t c2 = frm_nxt[1];
	if ((c2 & 0xC0) != 0x80)
	return codecvt_base::error;
	uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) \| (c2 & 0x3F));
	if (t > Maxcode)
	return codecvt_base::error;
	*to_nxt = t;
	frm_nxt += 2;
	}
	else if (c1 < 0xF0)
	{
	if (frm_end-frm_nxt < 3)
	return codecvt_base::partial;
	uint8_t c2 = frm_nxt[1];
	uint8_t c3 = frm_nxt[2];
	switch (c1)
	{
	case 0xE0:
	if ((c2 & 0xE0) != 0xA0)
	return codecvt_base::error;
	break;
	case 0xED:
	if ((c2 & 0xE0) != 0x80)
	return codecvt_base::error;
	break;
	default:
	if ((c2 & 0xC0) != 0x80)
	return codecvt_base::error;
	break;
	}
	if ((c3 & 0xC0) != 0x80)
	return codecvt_base::error;
	uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12)
	\| ((c2 & 0x3F) << 6)
	\| (c3 & 0x3F));
	if (t > Maxcode)
	return codecvt_base::error;
	*to_nxt = t;
	frm_nxt += 3;
	}
	else if (c1 < 0xF5)
	{
	if (frm_end-frm_nxt < 4)
	return codecvt_base::partial;
	uint8_t c2 = frm_nxt[1];
	uint8_t c3 = frm_nxt[2];
	uint8_t c4 = frm_nxt[3];
	switch (c1)
	{
	case 0xF0:
	if (!(0x90 <= c2 && c2 <= 0xBF))
	return codecvt_base::error;
	break;
	case 0xF4:
	if ((c2 & 0xF0) != 0x80)
	return codecvt_base::error;
	break;
	default:
	if ((c2 & 0xC0) != 0x80)
	return codecvt_base::error;
	break;
	}
	if ((c3 & 0xC0) != 0x80 \|\| (c4 & 0xC0) != 0x80)
	return codecvt_base::error;
	if (to_end-to_nxt < 2)
	return codecvt_base::partial;
	if ((((c1 & 7UL) << 18) +
	((c2 & 0x3FUL) << 12) +
	((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
	return codecvt_base::error;
	*to_nxt = static_cast<uint16_t>(
	0xD800
	\| (((((c1 & 0x07) << 2) \| ((c2 & 0x30) >> 4)) - 1) << 6)
	\| ((c2 & 0x0F) << 2)
	\| ((c3 & 0x30) >> 4));
	*++to_nxt = static_cast<uint16_t>(
	0xDC00
	\| ((c3 & 0x0F) << 6)
	\| (c4 & 0x3F));
	frm_nxt += 4;
	}
	else
	{
	return codecvt_base::error;
	}
	}
	return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
	}

	static
	codecvt_base::result
	utf8_to_utf16(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
	uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
	unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
	{
	frm_nxt = frm;
	to_nxt = to;
	if (mode & consume_header)
	{
	if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
	frm_nxt[2] == 0xBF)
	frm_nxt += 3;
	}
	for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
	{
	uint8_t c1 = *frm_nxt;
	if (c1 > Maxcode)
	return codecvt_base::error;
	if (c1 < 0x80)
	{
	*to_nxt = static_cast<uint32_t>(c1);
	++frm_nxt;
	}
	else if (c1 < 0xC2)
	{
	return codecvt_base::error;
	}
	else if (c1 < 0xE0)
	{
	if (frm_end-frm_nxt < 2)
	return codecvt_base::partial;
	uint8_t c2 = frm_nxt[1];
	if ((c2 & 0xC0) != 0x80)
	return codecvt_base::error;
	uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) \| (c2 & 0x3F));
	if (t > Maxcode)
	return codecvt_base::error;
	*to_nxt = static_cast<uint32_t>(t);
	frm_nxt += 2;
	}
	else if (c1 < 0xF0)
	{
	if (frm_end-frm_nxt < 3)
	return codecvt_base::partial;
	uint8_t c2 = frm_nxt[1];
	uint8_t c3 = frm_nxt[2];
	switch (c1)
	{
	case 0xE0:
	if ((c2 & 0xE0) != 0xA0)
	return codecvt_base::error;
	break;
	case 0xED:
	if ((c2 & 0xE0) != 0x80)
	return codecvt_base::error;
	break;
	default:
	if ((c2 & 0xC0) != 0x80)
	return codecvt_base::error;
	break;
	}
	if ((c3 & 0xC0) != 0x80)
	return codecvt_base::error;
	uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12)
	\| ((c2 & 0x3F) << 6)
	\| (c3 & 0x3F));
	if (t > Maxcode)
	return codecvt_base::error;
	*to_nxt = static_cast<uint32_t>(t);
	frm_nxt += 3;
	}
	else if (c1 < 0xF5)
	{
	if (frm_end-frm_nxt < 4)
	return codecvt_base::partial;
	uint8_t c2 = frm_nxt[1];
	uint8_t c3 = frm_nxt[2];
	uint8_t c4 = frm_nxt[3];
	switch (c1)
	{
	case 0xF0:
	if (!(0x90 <= c2 && c2 <= 0xBF))
	return codecvt_base::error;
	break;
	case 0xF4:
	if ((c2 & 0xF0) != 0x80)
	return codecvt_base::error;
	break;
	default:
	if ((c2 & 0xC0) != 0x80)
	return codecvt_base::error;
	break;
	}
	if ((c3 & 0xC0) != 0x80 \|\| (c4 & 0xC0) != 0x80)
	return codecvt_base::error;
	if (to_end-to_nxt < 2)
	return codecvt_base::partial;
	if ((((c1 & 7UL) << 18) +
	((c2 & 0x3FUL) << 12) +
	((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
	return codecvt_base::error;
	*to_nxt = static_cast<uint32_t>(
	0xD800
	\| (((((c1 & 0x07) << 2) \| ((c2 & 0x30) >> 4)) - 1) << 6)
	\| ((c2 & 0x0F) << 2)
	\| ((c3 & 0x30) >> 4));
	*++to_nxt = static_cast<uint32_t>(
	0xDC00
	\| ((c3 & 0x0F) << 6)
	\| (c4 & 0x3F));
	frm_nxt += 4;
	}
	else
	{
	return codecvt_base::error;
	}
	}
	return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
	}

	static
	int
	utf8_to_utf16_length(const uint8_t* frm, const uint8_t* frm_end,
	size_t mx, unsigned long Maxcode = 0x10FFFF,
	codecvt_mode mode = codecvt_mode(0))
	{
	const uint8_t* frm_nxt = frm;
	if (mode & consume_header)
	{
	if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
	frm_nxt[2] == 0xBF)
	frm_nxt += 3;
	}
	for (size_t nchar16_t = 0; frm_nxt < frm_end && nchar16_t < mx; ++nchar16_t)
	{
	uint8_t c1 = *frm_nxt;
	if (c1 > Maxcode)
	break;
	if (c1 < 0x80)
	{
	++frm_nxt;
	}
	else if (c1 < 0xC2)
	{
	break;
	}
	else if (c1 < 0xE0)
	{
	if ((frm_end-frm_nxt < 2) \|\| (frm_nxt[1] & 0xC0) != 0x80)
	break;
	uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) \| (frm_nxt[1] & 0x3F));
	if (t > Maxcode)
	break;
	frm_nxt += 2;
	}
	else if (c1 < 0xF0)
	{
	if (frm_end-frm_nxt < 3)
	break;
	uint8_t c2 = frm_nxt[1];
	uint8_t c3 = frm_nxt[2];
	switch (c1)
	{
	case 0xE0:
	if ((c2 & 0xE0) != 0xA0)
	return static_cast<int>(frm_nxt - frm);
	break;
	case 0xED:
	if ((c2 & 0xE0) != 0x80)
	return static_cast<int>(frm_nxt - frm);
	break;
	default:
	if ((c2 & 0xC0) != 0x80)
	return static_cast<int>(frm_nxt - frm);
	break;
	}
	if ((c3 & 0xC0) != 0x80)
	break;
	if ((((c1 & 0x0Fu) << 12) \| ((c2 & 0x3Fu) << 6) \| (c3 & 0x3Fu)) > Maxcode)
	break;
	frm_nxt += 3;
	}
	else if (c1 < 0xF5)
	{
	if (frm_end-frm_nxt < 4 \|\| mx-nchar16_t < 2)
	break;
	uint8_t c2 = frm_nxt[1];
	uint8_t c3 = frm_nxt[2];
	uint8_t c4 = frm_nxt[3];
	switch (c1)
	{
	case 0xF0:
	if (!(0x90 <= c2 && c2 <= 0xBF))
	return static_cast<int>(frm_nxt - frm);
	break;
	case 0xF4:
	if ((c2 & 0xF0) != 0x80)
	return static_cast<int>(frm_nxt - frm);
	break;
	default:
	if ((c2 & 0xC0) != 0x80)
	return static_cast<int>(frm_nxt - frm);
	break;
	}
	if ((c3 & 0xC0) != 0x80 \|\| (c4 & 0xC0) != 0x80)
	break;
	if ((((c1 & 7UL) << 18) +
	((c2 & 0x3FUL) << 12) +
	((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
	break;
	++nchar16_t;
	frm_nxt += 4;
	}
	else
	{
	break;
	}
	}
	return static_cast<int>(frm_nxt - frm);
	}

	static
	codecvt_base::result
	ucs4_to_utf8(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
	uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
	unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
	{
	frm_nxt = frm;
	to_nxt = to;
	if (mode & generate_header)
	{
	if (to_end-to_nxt < 3)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xEF);
	*to_nxt++ = static_cast<uint8_t>(0xBB);
	*to_nxt++ = static_cast<uint8_t>(0xBF);
	}
	for (; frm_nxt < frm_end; ++frm_nxt)
	{
	uint32_t wc = *frm_nxt;
	if ((wc & 0xFFFFF800) == 0x00D800 \|\| wc > Maxcode)
	return codecvt_base::error;
	if (wc < 0x000080)
	{
	if (to_end-to_nxt < 1)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(wc);
	}
	else if (wc < 0x000800)
	{
	if (to_end-to_nxt < 2)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xC0 \| (wc >> 6));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| (wc & 0x03F));
	}
	else if (wc < 0x010000)
	{
	if (to_end-to_nxt < 3)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xE0 \| (wc >> 12));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| ((wc & 0x0FC0) >> 6));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| (wc & 0x003F));
	}
	else // if (wc < 0x110000)
	{
	if (to_end-to_nxt < 4)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xF0 \| (wc >> 18));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| ((wc & 0x03F000) >> 12));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| ((wc & 0x000FC0) >> 6));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| (wc & 0x00003F));
	}
	}
	return codecvt_base::ok;
	}

	static
	codecvt_base::result
	utf8_to_ucs4(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
	uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
	unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
	{
	frm_nxt = frm;
	to_nxt = to;
	if (mode & consume_header)
	{
	if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
	frm_nxt[2] == 0xBF)
	frm_nxt += 3;
	}
	for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
	{
	uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
	if (c1 < 0x80)
	{
	if (c1 > Maxcode)
	return codecvt_base::error;
	*to_nxt = static_cast<uint32_t>(c1);
	++frm_nxt;
	}
	else if (c1 < 0xC2)
	{
	return codecvt_base::error;
	}
	else if (c1 < 0xE0)
	{
	if (frm_end-frm_nxt < 2)
	return codecvt_base::partial;
	uint8_t c2 = frm_nxt[1];
	if ((c2 & 0xC0) != 0x80)
	return codecvt_base::error;
	uint32_t t = static_cast<uint32_t>(((c1 & 0x1F) << 6)
	\| (c2 & 0x3F));
	if (t > Maxcode)
	return codecvt_base::error;
	*to_nxt = t;
	frm_nxt += 2;
	}
	else if (c1 < 0xF0)
	{
	if (frm_end-frm_nxt < 3)
	return codecvt_base::partial;
	uint8_t c2 = frm_nxt[1];
	uint8_t c3 = frm_nxt[2];
	switch (c1)
	{
	case 0xE0:
	if ((c2 & 0xE0) != 0xA0)
	return codecvt_base::error;
	break;
	case 0xED:
	if ((c2 & 0xE0) != 0x80)
	return codecvt_base::error;
	break;
	default:
	if ((c2 & 0xC0) != 0x80)
	return codecvt_base::error;
	break;
	}
	if ((c3 & 0xC0) != 0x80)
	return codecvt_base::error;
	uint32_t t = static_cast<uint32_t>(((c1 & 0x0F) << 12)
	\| ((c2 & 0x3F) << 6)
	\| (c3 & 0x3F));
	if (t > Maxcode)
	return codecvt_base::error;
	*to_nxt = t;
	frm_nxt += 3;
	}
	else if (c1 < 0xF5)
	{
	if (frm_end-frm_nxt < 4)
	return codecvt_base::partial;
	uint8_t c2 = frm_nxt[1];
	uint8_t c3 = frm_nxt[2];
	uint8_t c4 = frm_nxt[3];
	switch (c1)
	{
	case 0xF0:
	if (!(0x90 <= c2 && c2 <= 0xBF))
	return codecvt_base::error;
	break;
	case 0xF4:
	if ((c2 & 0xF0) != 0x80)
	return codecvt_base::error;
	break;
	default:
	if ((c2 & 0xC0) != 0x80)
	return codecvt_base::error;
	break;
	}
	if ((c3 & 0xC0) != 0x80 \|\| (c4 & 0xC0) != 0x80)
	return codecvt_base::error;
	uint32_t t = static_cast<uint32_t>(((c1 & 0x07) << 18)
	\| ((c2 & 0x3F) << 12)
	\| ((c3 & 0x3F) << 6)
	\| (c4 & 0x3F));
	if (t > Maxcode)
	return codecvt_base::error;
	*to_nxt = t;
	frm_nxt += 4;
	}
	else
	{
	return codecvt_base::error;
	}
	}
	return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
	}

	static
	int
	utf8_to_ucs4_length(const uint8_t* frm, const uint8_t* frm_end,
	size_t mx, unsigned long Maxcode = 0x10FFFF,
	codecvt_mode mode = codecvt_mode(0))
	{
	const uint8_t* frm_nxt = frm;
	if (mode & consume_header)
	{
	if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
	frm_nxt[2] == 0xBF)
	frm_nxt += 3;
	}
	for (size_t nchar32_t = 0; frm_nxt < frm_end && nchar32_t < mx; ++nchar32_t)
	{
	uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
	if (c1 < 0x80)
	{
	if (c1 > Maxcode)
	break;
	++frm_nxt;
	}
	else if (c1 < 0xC2)
	{
	break;
	}
	else if (c1 < 0xE0)
	{
	if ((frm_end-frm_nxt < 2) \|\| ((frm_nxt[1] & 0xC0) != 0x80))
	break;
	if ((((c1 & 0x1Fu) << 6) \| (frm_nxt[1] & 0x3Fu)) > Maxcode)
	break;
	frm_nxt += 2;
	}
	else if (c1 < 0xF0)
	{
	if (frm_end-frm_nxt < 3)
	break;
	uint8_t c2 = frm_nxt[1];
	uint8_t c3 = frm_nxt[2];
	switch (c1)
	{
	case 0xE0:
	if ((c2 & 0xE0) != 0xA0)
	return static_cast<int>(frm_nxt - frm);
	break;
	case 0xED:
	if ((c2 & 0xE0) != 0x80)
	return static_cast<int>(frm_nxt - frm);
	break;
	default:
	if ((c2 & 0xC0) != 0x80)
	return static_cast<int>(frm_nxt - frm);
	break;
	}
	if ((c3 & 0xC0) != 0x80)
	break;
	if ((((c1 & 0x0Fu) << 12) \| ((c2 & 0x3Fu) << 6) \| (c3 & 0x3Fu)) > Maxcode)
	break;
	frm_nxt += 3;
	}
	else if (c1 < 0xF5)
	{
	if (frm_end-frm_nxt < 4)
	break;
	uint8_t c2 = frm_nxt[1];
	uint8_t c3 = frm_nxt[2];
	uint8_t c4 = frm_nxt[3];
	switch (c1)
	{
	case 0xF0:
	if (!(0x90 <= c2 && c2 <= 0xBF))
	return static_cast<int>(frm_nxt - frm);
	break;
	case 0xF4:
	if ((c2 & 0xF0) != 0x80)
	return static_cast<int>(frm_nxt - frm);
	break;
	default:
	if ((c2 & 0xC0) != 0x80)
	return static_cast<int>(frm_nxt - frm);
	break;
	}
	if ((c3 & 0xC0) != 0x80 \|\| (c4 & 0xC0) != 0x80)
	break;
	if ((((c1 & 0x07u) << 18) \| ((c2 & 0x3Fu) << 12) \|
	((c3 & 0x3Fu) << 6) \| (c4 & 0x3Fu)) > Maxcode)
	break;
	frm_nxt += 4;
	}
	else
	{
	break;
	}
	}
	return static_cast<int>(frm_nxt - frm);
	}

	static
	codecvt_base::result
	ucs2_to_utf8(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
	uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
	unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
	{
	frm_nxt = frm;
	to_nxt = to;
	if (mode & generate_header)
	{
	if (to_end-to_nxt < 3)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xEF);
	*to_nxt++ = static_cast<uint8_t>(0xBB);
	*to_nxt++ = static_cast<uint8_t>(0xBF);
	}
	for (; frm_nxt < frm_end; ++frm_nxt)
	{
	uint16_t wc = *frm_nxt;
	if ((wc & 0xF800) == 0xD800 \|\| wc > Maxcode)
	return codecvt_base::error;
	if (wc < 0x0080)
	{
	if (to_end-to_nxt < 1)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(wc);
	}
	else if (wc < 0x0800)
	{
	if (to_end-to_nxt < 2)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xC0 \| (wc >> 6));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| (wc & 0x03F));
	}
	else // if (wc <= 0xFFFF)
	{
	if (to_end-to_nxt < 3)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xE0 \| (wc >> 12));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| ((wc & 0x0FC0) >> 6));
	*to_nxt++ = static_cast<uint8_t>(0x80 \| (wc & 0x003F));
	}
	}
	return codecvt_base::ok;
	}

	static
	codecvt_base::result
	utf8_to_ucs2(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
	uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
	unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
	{
	frm_nxt = frm;
	to_nxt = to;
	if (mode & consume_header)
	{
	if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
	frm_nxt[2] == 0xBF)
	frm_nxt += 3;
	}
	for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
	{
	uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
	if (c1 < 0x80)
	{
	if (c1 > Maxcode)
	return codecvt_base::error;
	*to_nxt = static_cast<uint16_t>(c1);
	++frm_nxt;
	}
	else if (c1 < 0xC2)
	{
	return codecvt_base::error;
	}
	else if (c1 < 0xE0)
	{
	if (frm_end-frm_nxt < 2)
	return codecvt_base::partial;
	uint8_t c2 = frm_nxt[1];
	if ((c2 & 0xC0) != 0x80)
	return codecvt_base::error;
	uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6)
	\| (c2 & 0x3F));
	if (t > Maxcode)
	return codecvt_base::error;
	*to_nxt = t;
	frm_nxt += 2;
	}
	else if (c1 < 0xF0)
	{
	if (frm_end-frm_nxt < 3)
	return codecvt_base::partial;
	uint8_t c2 = frm_nxt[1];
	uint8_t c3 = frm_nxt[2];
	switch (c1)
	{
	case 0xE0:
	if ((c2 & 0xE0) != 0xA0)
	return codecvt_base::error;
	break;
	case 0xED:
	if ((c2 & 0xE0) != 0x80)
	return codecvt_base::error;
	break;
	default:
	if ((c2 & 0xC0) != 0x80)
	return codecvt_base::error;
	break;
	}
	if ((c3 & 0xC0) != 0x80)
	return codecvt_base::error;
	uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12)
	\| ((c2 & 0x3F) << 6)
	\| (c3 & 0x3F));
	if (t > Maxcode)
	return codecvt_base::error;
	*to_nxt = t;
	frm_nxt += 3;
	}
	else
	{
	return codecvt_base::error;
	}
	}
	return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
	}

	static
	int
	utf8_to_ucs2_length(const uint8_t* frm, const uint8_t* frm_end,
	size_t mx, unsigned long Maxcode = 0x10FFFF,
	codecvt_mode mode = codecvt_mode(0))
	{
	const uint8_t* frm_nxt = frm;
	if (mode & consume_header)
	{
	if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
	frm_nxt[2] == 0xBF)
	frm_nxt += 3;
	}
	for (size_t nchar32_t = 0; frm_nxt < frm_end && nchar32_t < mx; ++nchar32_t)
	{
	uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
	if (c1 < 0x80)
	{
	if (c1 > Maxcode)
	break;
	++frm_nxt;
	}
	else if (c1 < 0xC2)
	{
	break;
	}
	else if (c1 < 0xE0)
	{
	if ((frm_end-frm_nxt < 2) \|\| ((frm_nxt[1] & 0xC0) != 0x80))
	break;
	if ((((c1 & 0x1Fu) << 6) \| (frm_nxt[1] & 0x3Fu)) > Maxcode)
	break;
	frm_nxt += 2;
	}
	else if (c1 < 0xF0)
	{
	if (frm_end-frm_nxt < 3)
	break;
	uint8_t c2 = frm_nxt[1];
	uint8_t c3 = frm_nxt[2];
	switch (c1)
	{
	case 0xE0:
	if ((c2 & 0xE0) != 0xA0)
	return static_cast<int>(frm_nxt - frm);
	break;
	case 0xED:
	if ((c2 & 0xE0) != 0x80)
	return static_cast<int>(frm_nxt - frm);
	break;
	default:
	if ((c2 & 0xC0) != 0x80)
	return static_cast<int>(frm_nxt - frm);
	break;
	}
	if ((c3 & 0xC0) != 0x80)
	break;
	if ((((c1 & 0x0Fu) << 12) \| ((c2 & 0x3Fu) << 6) \| (c3 & 0x3Fu)) > Maxcode)
	break;
	frm_nxt += 3;
	}
	else
	{
	break;
	}
	}
	return static_cast<int>(frm_nxt - frm);
	}

	static
	codecvt_base::result
	ucs4_to_utf16be(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
	uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
	unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
	{
	frm_nxt = frm;
	to_nxt = to;
	if (mode & generate_header)
	{
	if (to_end-to_nxt < 2)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xFE);
	*to_nxt++ = static_cast<uint8_t>(0xFF);
	}
	for (; frm_nxt < frm_end; ++frm_nxt)
	{
	uint32_t wc = *frm_nxt;
	if ((wc & 0xFFFFF800) == 0x00D800 \|\| wc > Maxcode)
	return codecvt_base::error;
	if (wc < 0x010000)
	{
	if (to_end-to_nxt < 2)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(wc >> 8);
	*to_nxt++ = static_cast<uint8_t>(wc);
	}
	else
	{
	if (to_end-to_nxt < 4)
	return codecvt_base::partial;
	uint16_t t = static_cast<uint16_t>(
	0xD800
	\| ((((wc & 0x1F0000) >> 16) - 1) << 6)
	\| ((wc & 0x00FC00) >> 10));
	*to_nxt++ = static_cast<uint8_t>(t >> 8);
	*to_nxt++ = static_cast<uint8_t>(t);
	t = static_cast<uint16_t>(0xDC00 \| (wc & 0x03FF));
	*to_nxt++ = static_cast<uint8_t>(t >> 8);
	*to_nxt++ = static_cast<uint8_t>(t);
	}
	}
	return codecvt_base::ok;
	}

	static
	codecvt_base::result
	utf16be_to_ucs4(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
	uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
	unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
	{
	frm_nxt = frm;
	to_nxt = to;
	if (mode & consume_header)
	{
	if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
	frm_nxt += 2;
	}
	for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
	{
	uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 \| frm_nxt[1]);
	if ((c1 & 0xFC00) == 0xDC00)
	return codecvt_base::error;
	if ((c1 & 0xFC00) != 0xD800)
	{
	if (c1 > Maxcode)
	return codecvt_base::error;
	*to_nxt = static_cast<uint32_t>(c1);
	frm_nxt += 2;
	}
	else
	{
	if (frm_end-frm_nxt < 4)
	return codecvt_base::partial;
	uint16_t c2 = static_cast<uint16_t>(frm_nxt[2] << 8 \| frm_nxt[3]);
	if ((c2 & 0xFC00) != 0xDC00)
	return codecvt_base::error;
	uint32_t t = static_cast<uint32_t>(
	((((c1 & 0x03C0) >> 6) + 1) << 16)
	\| ((c1 & 0x003F) << 10)
	\| (c2 & 0x03FF));
	if (t > Maxcode)
	return codecvt_base::error;
	*to_nxt = t;
	frm_nxt += 4;
	}
	}
	return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
	}

	static
	int
	utf16be_to_ucs4_length(const uint8_t* frm, const uint8_t* frm_end,
	size_t mx, unsigned long Maxcode = 0x10FFFF,
	codecvt_mode mode = codecvt_mode(0))
	{
	const uint8_t* frm_nxt = frm;
	if (mode & consume_header)
	{
	if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
	frm_nxt += 2;
	}
	for (size_t nchar32_t = 0; frm_nxt < frm_end - 1 && nchar32_t < mx; ++nchar32_t)
	{
	uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 \| frm_nxt[1]);
	if ((c1 & 0xFC00) == 0xDC00)
	break;
	if ((c1 & 0xFC00) != 0xD800)
	{
	if (c1 > Maxcode)
	break;
	frm_nxt += 2;
	}
	else
	{
	if (frm_end-frm_nxt < 4)
	break;
	uint16_t c2 = static_cast<uint16_t>(frm_nxt[2] << 8 \| frm_nxt[3]);
	if ((c2 & 0xFC00) != 0xDC00)
	break;
	uint32_t t = static_cast<uint32_t>(
	((((c1 & 0x03C0) >> 6) + 1) << 16)
	\| ((c1 & 0x003F) << 10)
	\| (c2 & 0x03FF));
	if (t > Maxcode)
	break;
	frm_nxt += 4;
	}
	}
	return static_cast<int>(frm_nxt - frm);
	}

	static
	codecvt_base::result
	ucs4_to_utf16le(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
	uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
	unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
	{
	frm_nxt = frm;
	to_nxt = to;
	if (mode & generate_header)
	{
	if (to_end - to_nxt < 2)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xFF);
	*to_nxt++ = static_cast<uint8_t>(0xFE);
	}
	for (; frm_nxt < frm_end; ++frm_nxt)
	{
	uint32_t wc = *frm_nxt;
	if ((wc & 0xFFFFF800) == 0x00D800 \|\| wc > Maxcode)
	return codecvt_base::error;
	if (wc < 0x010000)
	{
	if (to_end-to_nxt < 2)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(wc);
	*to_nxt++ = static_cast<uint8_t>(wc >> 8);
	}
	else
	{
	if (to_end-to_nxt < 4)
	return codecvt_base::partial;
	uint16_t t = static_cast<uint16_t>(
	0xD800
	\| ((((wc & 0x1F0000) >> 16) - 1) << 6)
	\| ((wc & 0x00FC00) >> 10));
	*to_nxt++ = static_cast<uint8_t>(t);
	*to_nxt++ = static_cast<uint8_t>(t >> 8);
	t = static_cast<uint16_t>(0xDC00 \| (wc & 0x03FF));
	*to_nxt++ = static_cast<uint8_t>(t);
	*to_nxt++ = static_cast<uint8_t>(t >> 8);
	}
	}
	return codecvt_base::ok;
	}

	static
	codecvt_base::result
	utf16le_to_ucs4(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
	uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
	unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
	{
	frm_nxt = frm;
	to_nxt = to;
	if (mode & consume_header)
	{
	if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
	frm_nxt += 2;
	}
	for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
	{
	uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 \| frm_nxt[0]);
	if ((c1 & 0xFC00) == 0xDC00)
	return codecvt_base::error;
	if ((c1 & 0xFC00) != 0xD800)
	{
	if (c1 > Maxcode)
	return codecvt_base::error;
	*to_nxt = static_cast<uint32_t>(c1);
	frm_nxt += 2;
	}
	else
	{
	if (frm_end-frm_nxt < 4)
	return codecvt_base::partial;
	uint16_t c2 = static_cast<uint16_t>(frm_nxt[3] << 8 \| frm_nxt[2]);
	if ((c2 & 0xFC00) != 0xDC00)
	return codecvt_base::error;
	uint32_t t = static_cast<uint32_t>(
	((((c1 & 0x03C0) >> 6) + 1) << 16)
	\| ((c1 & 0x003F) << 10)
	\| (c2 & 0x03FF));
	if (t > Maxcode)
	return codecvt_base::error;
	*to_nxt = t;
	frm_nxt += 4;
	}
	}
	return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
	}

	static
	int
	utf16le_to_ucs4_length(const uint8_t* frm, const uint8_t* frm_end,
	size_t mx, unsigned long Maxcode = 0x10FFFF,
	codecvt_mode mode = codecvt_mode(0))
	{
	const uint8_t* frm_nxt = frm;
	if (mode & consume_header)
	{
	if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
	frm_nxt += 2;
	}
	for (size_t nchar32_t = 0; frm_nxt < frm_end - 1 && nchar32_t < mx; ++nchar32_t)
	{
	uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 \| frm_nxt[0]);
	if ((c1 & 0xFC00) == 0xDC00)
	break;
	if ((c1 & 0xFC00) != 0xD800)
	{
	if (c1 > Maxcode)
	break;
	frm_nxt += 2;
	}
	else
	{
	if (frm_end-frm_nxt < 4)
	break;
	uint16_t c2 = static_cast<uint16_t>(frm_nxt[3] << 8 \| frm_nxt[2]);
	if ((c2 & 0xFC00) != 0xDC00)
	break;
	uint32_t t = static_cast<uint32_t>(
	((((c1 & 0x03C0) >> 6) + 1) << 16)
	\| ((c1 & 0x003F) << 10)
	\| (c2 & 0x03FF));
	if (t > Maxcode)
	break;
	frm_nxt += 4;
	}
	}
	return static_cast<int>(frm_nxt - frm);
	}

	static
	codecvt_base::result
	ucs2_to_utf16be(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
	uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
	unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
	{
	frm_nxt = frm;
	to_nxt = to;
	if (mode & generate_header)
	{
	if (to_end-to_nxt < 2)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xFE);
	*to_nxt++ = static_cast<uint8_t>(0xFF);
	}
	for (; frm_nxt < frm_end; ++frm_nxt)
	{
	uint16_t wc = *frm_nxt;
	if ((wc & 0xF800) == 0xD800 \|\| wc > Maxcode)
	return codecvt_base::error;
	if (to_end-to_nxt < 2)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(wc >> 8);
	*to_nxt++ = static_cast<uint8_t>(wc);
	}
	return codecvt_base::ok;
	}

	static
	codecvt_base::result
	utf16be_to_ucs2(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
	uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
	unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
	{
	frm_nxt = frm;
	to_nxt = to;
	if (mode & consume_header)
	{
	if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
	frm_nxt += 2;
	}
	for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
	{
	uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 \| frm_nxt[1]);
	if ((c1 & 0xF800) == 0xD800 \|\| c1 > Maxcode)
	return codecvt_base::error;
	*to_nxt = c1;
	frm_nxt += 2;
	}
	return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
	}

	static
	int
	utf16be_to_ucs2_length(const uint8_t* frm, const uint8_t* frm_end,
	size_t mx, unsigned long Maxcode = 0x10FFFF,
	codecvt_mode mode = codecvt_mode(0))
	{
	const uint8_t* frm_nxt = frm;
	if (mode & consume_header)
	{
	if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
	frm_nxt += 2;
	}
	for (size_t nchar16_t = 0; frm_nxt < frm_end - 1 && nchar16_t < mx; ++nchar16_t)
	{
	uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 \| frm_nxt[1]);
	if ((c1 & 0xF800) == 0xD800 \|\| c1 > Maxcode)
	break;
	frm_nxt += 2;
	}
	return static_cast<int>(frm_nxt - frm);
	}

	static
	codecvt_base::result
	ucs2_to_utf16le(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
	uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
	unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
	{
	frm_nxt = frm;
	to_nxt = to;
	if (mode & generate_header)
	{
	if (to_end-to_nxt < 2)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(0xFF);
	*to_nxt++ = static_cast<uint8_t>(0xFE);
	}
	for (; frm_nxt < frm_end; ++frm_nxt)
	{
	uint16_t wc = *frm_nxt;
	if ((wc & 0xF800) == 0xD800 \|\| wc > Maxcode)
	return codecvt_base::error;
	if (to_end-to_nxt < 2)
	return codecvt_base::partial;
	*to_nxt++ = static_cast<uint8_t>(wc);
	*to_nxt++ = static_cast<uint8_t>(wc >> 8);
	}
	return codecvt_base::ok;
	}

	static
	codecvt_base::result
	utf16le_to_ucs2(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
	uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
	unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
	{
	frm_nxt = frm;
	to_nxt = to;
	if (mode & consume_header)
	{
	if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
	frm_nxt += 2;
	}
	for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
	{
	uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 \| frm_nxt[0]);
	if ((c1 & 0xF800) == 0xD800 \|\| c1 > Maxcode)
	return codecvt_base::error;
	*to_nxt = c1;
	frm_nxt += 2;
	}
	return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
	}

	static
	int
	utf16le_to_ucs2_length(const uint8_t* frm, const uint8_t* frm_end,
	size_t mx, unsigned long Maxcode = 0x10FFFF,
	codecvt_mode mode = codecvt_mode(0))
	{
	const uint8_t* frm_nxt = frm;
	frm_nxt = frm;
	if (mode & consume_header)
	{
	if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
	frm_nxt += 2;
	}
	for (size_t nchar16_t = 0; frm_nxt < frm_end - 1 && nchar16_t < mx; ++nchar16_t)
	{
	uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 \| frm_nxt[0]);
	if ((c1 & 0xF800) == 0xD800 \|\| c1 > Maxcode)
	break;
	frm_nxt += 2;
	}
	return static_cast<int>(frm_nxt - frm);
	}

	// template <> class codecvt<char16_t, char, mbstate_t>

	locale::id codecvt<char16_t, char, mbstate_t>::id;

	codecvt<char16_t, char, mbstate_t>::~codecvt()
	{
	}

	codecvt<char16_t, char, mbstate_t>::result
	codecvt<char16_t, char, mbstate_t>::do_out(state_type&,
	const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
	extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
	{
	const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
	const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
	const uint16_t* _frm_nxt = _frm;
	uint8_t* _to = reinterpret_cast<uint8_t*>(to);
	uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
	uint8_t* _to_nxt = _to;
	result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	codecvt<char16_t, char, mbstate_t>::result
	codecvt<char16_t, char, mbstate_t>::do_in(state_type&,
	const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
	intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	const uint8_t* _frm_nxt = _frm;
	uint16_t* _to = reinterpret_cast<uint16_t*>(to);
	uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
	uint16_t* _to_nxt = _to;
	result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	codecvt<char16_t, char, mbstate_t>::result
	codecvt<char16_t, char, mbstate_t>::do_unshift(state_type&,
	extern_type* to, extern_type, extern_type& to_nxt) const
	{
	to_nxt = to;
	return noconv;
	}

	int
	codecvt<char16_t, char, mbstate_t>::do_encoding() const _NOEXCEPT
	{
	return 0;
	}

	bool
	codecvt<char16_t, char, mbstate_t>::do_always_noconv() const _NOEXCEPT
	{
	return false;
	}

	int
	codecvt<char16_t, char, mbstate_t>::do_length(state_type&,
	const extern_type* frm, const extern_type* frm_end, size_t mx) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	return utf8_to_utf16_length(_frm, _frm_end, mx);
	}

	int
	codecvt<char16_t, char, mbstate_t>::do_max_length() const _NOEXCEPT
	{
	return 4;
	}

	// template <> class codecvt<char32_t, char, mbstate_t>

	locale::id codecvt<char32_t, char, mbstate_t>::id;

	codecvt<char32_t, char, mbstate_t>::~codecvt()
	{
	}

	codecvt<char32_t, char, mbstate_t>::result
	codecvt<char32_t, char, mbstate_t>::do_out(state_type&,
	const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
	extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
	{
	const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
	const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
	const uint32_t* _frm_nxt = _frm;
	uint8_t* _to = reinterpret_cast<uint8_t*>(to);
	uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
	uint8_t* _to_nxt = _to;
	result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	codecvt<char32_t, char, mbstate_t>::result
	codecvt<char32_t, char, mbstate_t>::do_in(state_type&,
	const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
	intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	const uint8_t* _frm_nxt = _frm;
	uint32_t* _to = reinterpret_cast<uint32_t*>(to);
	uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
	uint32_t* _to_nxt = _to;
	result r = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	codecvt<char32_t, char, mbstate_t>::result
	codecvt<char32_t, char, mbstate_t>::do_unshift(state_type&,
	extern_type* to, extern_type, extern_type& to_nxt) const
	{
	to_nxt = to;
	return noconv;
	}

	int
	codecvt<char32_t, char, mbstate_t>::do_encoding() const _NOEXCEPT
	{
	return 0;
	}

	bool
	codecvt<char32_t, char, mbstate_t>::do_always_noconv() const _NOEXCEPT
	{
	return false;
	}

	int
	codecvt<char32_t, char, mbstate_t>::do_length(state_type&,
	const extern_type* frm, const extern_type* frm_end, size_t mx) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	return utf8_to_ucs4_length(_frm, _frm_end, mx);
	}

	int
	codecvt<char32_t, char, mbstate_t>::do_max_length() const _NOEXCEPT
	{
	return 4;
	}

	// __codecvt_utf8<wchar_t>

	__codecvt_utf8<wchar_t>::result
	__codecvt_utf8<wchar_t>::do_out(state_type&,
	const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
	extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
	{
	#if defined(_LIBCPP_SHORT_WCHAR)
	const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
	const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
	const uint16_t* _frm_nxt = _frm;
	#else
	const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
	const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
	const uint32_t* _frm_nxt = _frm;
	#endif
	uint8_t* _to = reinterpret_cast<uint8_t*>(to);
	uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
	uint8_t* _to_nxt = _to;
	#if defined(_LIBCPP_SHORT_WCHAR)
	result r = ucs2_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	#else
	result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	#endif
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf8<wchar_t>::result
	__codecvt_utf8<wchar_t>::do_in(state_type&,
	const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
	intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	const uint8_t* _frm_nxt = _frm;
	#if defined(_LIBCPP_SHORT_WCHAR)
	uint16_t* _to = reinterpret_cast<uint16_t*>(to);
	uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
	uint16_t* _to_nxt = _to;
	result r = utf8_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	#else
	uint32_t* _to = reinterpret_cast<uint32_t*>(to);
	uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
	uint32_t* _to_nxt = _to;
	result r = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	#endif
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf8<wchar_t>::result
	__codecvt_utf8<wchar_t>::do_unshift(state_type&,
	extern_type* to, extern_type, extern_type& to_nxt) const
	{
	to_nxt = to;
	return noconv;
	}

	int
	__codecvt_utf8<wchar_t>::do_encoding() const _NOEXCEPT
	{
	return 0;
	}

	bool
	__codecvt_utf8<wchar_t>::do_always_noconv() const _NOEXCEPT
	{
	return false;
	}

	int
	__codecvt_utf8<wchar_t>::do_length(state_type&,
	const extern_type* frm, const extern_type* frm_end, size_t mx) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	return utf8_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
	}

	int
	__codecvt_utf8<wchar_t>::do_max_length() const _NOEXCEPT
	{
	if (_Mode_ & consume_header)
	return 7;
	return 4;
	}

	// __codecvt_utf8<char16_t>

	__codecvt_utf8<char16_t>::result
	__codecvt_utf8<char16_t>::do_out(state_type&,
	const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
	extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
	{
	const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
	const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
	const uint16_t* _frm_nxt = _frm;
	uint8_t* _to = reinterpret_cast<uint8_t*>(to);
	uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
	uint8_t* _to_nxt = _to;
	result r = ucs2_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf8<char16_t>::result
	__codecvt_utf8<char16_t>::do_in(state_type&,
	const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
	intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	const uint8_t* _frm_nxt = _frm;
	uint16_t* _to = reinterpret_cast<uint16_t*>(to);
	uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
	uint16_t* _to_nxt = _to;
	result r = utf8_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf8<char16_t>::result
	__codecvt_utf8<char16_t>::do_unshift(state_type&,
	extern_type* to, extern_type, extern_type& to_nxt) const
	{
	to_nxt = to;
	return noconv;
	}

	int
	__codecvt_utf8<char16_t>::do_encoding() const _NOEXCEPT
	{
	return 0;
	}

	bool
	__codecvt_utf8<char16_t>::do_always_noconv() const _NOEXCEPT
	{
	return false;
	}

	int
	__codecvt_utf8<char16_t>::do_length(state_type&,
	const extern_type* frm, const extern_type* frm_end, size_t mx) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	return utf8_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
	}

	int
	__codecvt_utf8<char16_t>::do_max_length() const _NOEXCEPT
	{
	if (_Mode_ & consume_header)
	return 6;
	return 3;
	}

	// __codecvt_utf8<char32_t>

	__codecvt_utf8<char32_t>::result
	__codecvt_utf8<char32_t>::do_out(state_type&,
	const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
	extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
	{
	const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
	const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
	const uint32_t* _frm_nxt = _frm;
	uint8_t* _to = reinterpret_cast<uint8_t*>(to);
	uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
	uint8_t* _to_nxt = _to;
	result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf8<char32_t>::result
	__codecvt_utf8<char32_t>::do_in(state_type&,
	const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
	intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	const uint8_t* _frm_nxt = _frm;
	uint32_t* _to = reinterpret_cast<uint32_t*>(to);
	uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
	uint32_t* _to_nxt = _to;
	result r = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf8<char32_t>::result
	__codecvt_utf8<char32_t>::do_unshift(state_type&,
	extern_type* to, extern_type, extern_type& to_nxt) const
	{
	to_nxt = to;
	return noconv;
	}

	int
	__codecvt_utf8<char32_t>::do_encoding() const _NOEXCEPT
	{
	return 0;
	}

	bool
	__codecvt_utf8<char32_t>::do_always_noconv() const _NOEXCEPT
	{
	return false;
	}

	int
	__codecvt_utf8<char32_t>::do_length(state_type&,
	const extern_type* frm, const extern_type* frm_end, size_t mx) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	return utf8_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
	}

	int
	__codecvt_utf8<char32_t>::do_max_length() const _NOEXCEPT
	{
	if (_Mode_ & consume_header)
	return 7;
	return 4;
	}

	// __codecvt_utf16<wchar_t, false>

	__codecvt_utf16<wchar_t, false>::result
	__codecvt_utf16<wchar_t, false>::do_out(state_type&,
	const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
	extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
	{
	const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
	const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
	const uint32_t* _frm_nxt = _frm;
	uint8_t* _to = reinterpret_cast<uint8_t*>(to);
	uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
	uint8_t* _to_nxt = _to;
	result r = ucs4_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf16<wchar_t, false>::result
	__codecvt_utf16<wchar_t, false>::do_in(state_type&,
	const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
	intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	const uint8_t* _frm_nxt = _frm;
	uint32_t* _to = reinterpret_cast<uint32_t*>(to);
	uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
	uint32_t* _to_nxt = _to;
	result r = utf16be_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf16<wchar_t, false>::result
	__codecvt_utf16<wchar_t, false>::do_unshift(state_type&,
	extern_type* to, extern_type, extern_type& to_nxt) const
	{
	to_nxt = to;
	return noconv;
	}

	int
	__codecvt_utf16<wchar_t, false>::do_encoding() const _NOEXCEPT
	{
	return 0;
	}

	bool
	__codecvt_utf16<wchar_t, false>::do_always_noconv() const _NOEXCEPT
	{
	return false;
	}

	int
	__codecvt_utf16<wchar_t, false>::do_length(state_type&,
	const extern_type* frm, const extern_type* frm_end, size_t mx) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	return utf16be_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
	}

	int
	__codecvt_utf16<wchar_t, false>::do_max_length() const _NOEXCEPT
	{
	if (_Mode_ & consume_header)
	return 6;
	return 4;
	}

	// __codecvt_utf16<wchar_t, true>

	__codecvt_utf16<wchar_t, true>::result
	__codecvt_utf16<wchar_t, true>::do_out(state_type&,
	const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
	extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
	{
	const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
	const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
	const uint32_t* _frm_nxt = _frm;
	uint8_t* _to = reinterpret_cast<uint8_t*>(to);
	uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
	uint8_t* _to_nxt = _to;
	result r = ucs4_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf16<wchar_t, true>::result
	__codecvt_utf16<wchar_t, true>::do_in(state_type&,
	const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
	intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	const uint8_t* _frm_nxt = _frm;
	uint32_t* _to = reinterpret_cast<uint32_t*>(to);
	uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
	uint32_t* _to_nxt = _to;
	result r = utf16le_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf16<wchar_t, true>::result
	__codecvt_utf16<wchar_t, true>::do_unshift(state_type&,
	extern_type* to, extern_type, extern_type& to_nxt) const
	{
	to_nxt = to;
	return noconv;
	}

	int
	__codecvt_utf16<wchar_t, true>::do_encoding() const _NOEXCEPT
	{
	return 0;
	}

	bool
	__codecvt_utf16<wchar_t, true>::do_always_noconv() const _NOEXCEPT
	{
	return false;
	}

	int
	__codecvt_utf16<wchar_t, true>::do_length(state_type&,
	const extern_type* frm, const extern_type* frm_end, size_t mx) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	return utf16le_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
	}

	int
	__codecvt_utf16<wchar_t, true>::do_max_length() const _NOEXCEPT
	{
	if (_Mode_ & consume_header)
	return 6;
	return 4;
	}

	// __codecvt_utf16<char16_t, false>

	__codecvt_utf16<char16_t, false>::result
	__codecvt_utf16<char16_t, false>::do_out(state_type&,
	const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
	extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
	{
	const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
	const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
	const uint16_t* _frm_nxt = _frm;
	uint8_t* _to = reinterpret_cast<uint8_t*>(to);
	uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
	uint8_t* _to_nxt = _to;
	result r = ucs2_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf16<char16_t, false>::result
	__codecvt_utf16<char16_t, false>::do_in(state_type&,
	const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
	intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	const uint8_t* _frm_nxt = _frm;
	uint16_t* _to = reinterpret_cast<uint16_t*>(to);
	uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
	uint16_t* _to_nxt = _to;
	result r = utf16be_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf16<char16_t, false>::result
	__codecvt_utf16<char16_t, false>::do_unshift(state_type&,
	extern_type* to, extern_type, extern_type& to_nxt) const
	{
	to_nxt = to;
	return noconv;
	}

	int
	__codecvt_utf16<char16_t, false>::do_encoding() const _NOEXCEPT
	{
	return 0;
	}

	bool
	__codecvt_utf16<char16_t, false>::do_always_noconv() const _NOEXCEPT
	{
	return false;
	}

	int
	__codecvt_utf16<char16_t, false>::do_length(state_type&,
	const extern_type* frm, const extern_type* frm_end, size_t mx) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	return utf16be_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
	}

	int
	__codecvt_utf16<char16_t, false>::do_max_length() const _NOEXCEPT
	{
	if (_Mode_ & consume_header)
	return 4;
	return 2;
	}

	// __codecvt_utf16<char16_t, true>

	__codecvt_utf16<char16_t, true>::result
	__codecvt_utf16<char16_t, true>::do_out(state_type&,
	const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
	extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
	{
	const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
	const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
	const uint16_t* _frm_nxt = _frm;
	uint8_t* _to = reinterpret_cast<uint8_t*>(to);
	uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
	uint8_t* _to_nxt = _to;
	result r = ucs2_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf16<char16_t, true>::result
	__codecvt_utf16<char16_t, true>::do_in(state_type&,
	const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
	intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	const uint8_t* _frm_nxt = _frm;
	uint16_t* _to = reinterpret_cast<uint16_t*>(to);
	uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
	uint16_t* _to_nxt = _to;
	result r = utf16le_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf16<char16_t, true>::result
	__codecvt_utf16<char16_t, true>::do_unshift(state_type&,
	extern_type* to, extern_type, extern_type& to_nxt) const
	{
	to_nxt = to;
	return noconv;
	}

	int
	__codecvt_utf16<char16_t, true>::do_encoding() const _NOEXCEPT
	{
	return 0;
	}

	bool
	__codecvt_utf16<char16_t, true>::do_always_noconv() const _NOEXCEPT
	{
	return false;
	}

	int
	__codecvt_utf16<char16_t, true>::do_length(state_type&,
	const extern_type* frm, const extern_type* frm_end, size_t mx) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	return utf16le_to_ucs2_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
	}

	int
	__codecvt_utf16<char16_t, true>::do_max_length() const _NOEXCEPT
	{
	if (_Mode_ & consume_header)
	return 4;
	return 2;
	}

	// __codecvt_utf16<char32_t, false>

	__codecvt_utf16<char32_t, false>::result
	__codecvt_utf16<char32_t, false>::do_out(state_type&,
	const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
	extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
	{
	const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
	const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
	const uint32_t* _frm_nxt = _frm;
	uint8_t* _to = reinterpret_cast<uint8_t*>(to);
	uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
	uint8_t* _to_nxt = _to;
	result r = ucs4_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf16<char32_t, false>::result
	__codecvt_utf16<char32_t, false>::do_in(state_type&,
	const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
	intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	const uint8_t* _frm_nxt = _frm;
	uint32_t* _to = reinterpret_cast<uint32_t*>(to);
	uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
	uint32_t* _to_nxt = _to;
	result r = utf16be_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf16<char32_t, false>::result
	__codecvt_utf16<char32_t, false>::do_unshift(state_type&,
	extern_type* to, extern_type, extern_type& to_nxt) const
	{
	to_nxt = to;
	return noconv;
	}

	int
	__codecvt_utf16<char32_t, false>::do_encoding() const _NOEXCEPT
	{
	return 0;
	}

	bool
	__codecvt_utf16<char32_t, false>::do_always_noconv() const _NOEXCEPT
	{
	return false;
	}

	int
	__codecvt_utf16<char32_t, false>::do_length(state_type&,
	const extern_type* frm, const extern_type* frm_end, size_t mx) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	return utf16be_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
	}

	int
	__codecvt_utf16<char32_t, false>::do_max_length() const _NOEXCEPT
	{
	if (_Mode_ & consume_header)
	return 6;
	return 4;
	}

	// __codecvt_utf16<char32_t, true>

	__codecvt_utf16<char32_t, true>::result
	__codecvt_utf16<char32_t, true>::do_out(state_type&,
	const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
	extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
	{
	const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
	const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
	const uint32_t* _frm_nxt = _frm;
	uint8_t* _to = reinterpret_cast<uint8_t*>(to);
	uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
	uint8_t* _to_nxt = _to;
	result r = ucs4_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf16<char32_t, true>::result
	__codecvt_utf16<char32_t, true>::do_in(state_type&,
	const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
	intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	const uint8_t* _frm_nxt = _frm;
	uint32_t* _to = reinterpret_cast<uint32_t*>(to);
	uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
	uint32_t* _to_nxt = _to;
	result r = utf16le_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf16<char32_t, true>::result
	__codecvt_utf16<char32_t, true>::do_unshift(state_type&,
	extern_type* to, extern_type, extern_type& to_nxt) const
	{
	to_nxt = to;
	return noconv;
	}

	int
	__codecvt_utf16<char32_t, true>::do_encoding() const _NOEXCEPT
	{
	return 0;
	}

	bool
	__codecvt_utf16<char32_t, true>::do_always_noconv() const _NOEXCEPT
	{
	return false;
	}

	int
	__codecvt_utf16<char32_t, true>::do_length(state_type&,
	const extern_type* frm, const extern_type* frm_end, size_t mx) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	return utf16le_to_ucs4_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
	}

	int
	__codecvt_utf16<char32_t, true>::do_max_length() const _NOEXCEPT
	{
	if (_Mode_ & consume_header)
	return 6;
	return 4;
	}

	// __codecvt_utf8_utf16<wchar_t>

	__codecvt_utf8_utf16<wchar_t>::result
	__codecvt_utf8_utf16<wchar_t>::do_out(state_type&,
	const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
	extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
	{
	const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
	const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
	const uint32_t* _frm_nxt = _frm;
	uint8_t* _to = reinterpret_cast<uint8_t*>(to);
	uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
	uint8_t* _to_nxt = _to;
	result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf8_utf16<wchar_t>::result
	__codecvt_utf8_utf16<wchar_t>::do_in(state_type&,
	const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
	intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	const uint8_t* _frm_nxt = _frm;
	uint32_t* _to = reinterpret_cast<uint32_t*>(to);
	uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
	uint32_t* _to_nxt = _to;
	result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf8_utf16<wchar_t>::result
	__codecvt_utf8_utf16<wchar_t>::do_unshift(state_type&,
	extern_type* to, extern_type, extern_type& to_nxt) const
	{
	to_nxt = to;
	return noconv;
	}

	int
	__codecvt_utf8_utf16<wchar_t>::do_encoding() const _NOEXCEPT
	{
	return 0;
	}

	bool
	__codecvt_utf8_utf16<wchar_t>::do_always_noconv() const _NOEXCEPT
	{
	return false;
	}

	int
	__codecvt_utf8_utf16<wchar_t>::do_length(state_type&,
	const extern_type* frm, const extern_type* frm_end, size_t mx) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	return utf8_to_utf16_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
	}

	int
	__codecvt_utf8_utf16<wchar_t>::do_max_length() const _NOEXCEPT
	{
	if (_Mode_ & consume_header)
	return 7;
	return 4;
	}

	// __codecvt_utf8_utf16<char16_t>

	__codecvt_utf8_utf16<char16_t>::result
	__codecvt_utf8_utf16<char16_t>::do_out(state_type&,
	const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
	extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
	{
	const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
	const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
	const uint16_t* _frm_nxt = _frm;
	uint8_t* _to = reinterpret_cast<uint8_t*>(to);
	uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
	uint8_t* _to_nxt = _to;
	result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf8_utf16<char16_t>::result
	__codecvt_utf8_utf16<char16_t>::do_in(state_type&,
	const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
	intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	const uint8_t* _frm_nxt = _frm;
	uint16_t* _to = reinterpret_cast<uint16_t*>(to);
	uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
	uint16_t* _to_nxt = _to;
	result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf8_utf16<char16_t>::result
	__codecvt_utf8_utf16<char16_t>::do_unshift(state_type&,
	extern_type* to, extern_type, extern_type& to_nxt) const
	{
	to_nxt = to;
	return noconv;
	}

	int
	__codecvt_utf8_utf16<char16_t>::do_encoding() const _NOEXCEPT
	{
	return 0;
	}

	bool
	__codecvt_utf8_utf16<char16_t>::do_always_noconv() const _NOEXCEPT
	{
	return false;
	}

	int
	__codecvt_utf8_utf16<char16_t>::do_length(state_type&,
	const extern_type* frm, const extern_type* frm_end, size_t mx) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	return utf8_to_utf16_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
	}

	int
	__codecvt_utf8_utf16<char16_t>::do_max_length() const _NOEXCEPT
	{
	if (_Mode_ & consume_header)
	return 7;
	return 4;
	}

	// __codecvt_utf8_utf16<char32_t>

	__codecvt_utf8_utf16<char32_t>::result
	__codecvt_utf8_utf16<char32_t>::do_out(state_type&,
	const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
	extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
	{
	const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
	const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
	const uint32_t* _frm_nxt = _frm;
	uint8_t* _to = reinterpret_cast<uint8_t*>(to);
	uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
	uint8_t* _to_nxt = _to;
	result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf8_utf16<char32_t>::result
	__codecvt_utf8_utf16<char32_t>::do_in(state_type&,
	const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
	intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	const uint8_t* _frm_nxt = _frm;
	uint32_t* _to = reinterpret_cast<uint32_t*>(to);
	uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
	uint32_t* _to_nxt = _to;
	result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
	_Maxcode_, _Mode_);
	frm_nxt = frm + (_frm_nxt - _frm);
	to_nxt = to + (_to_nxt - _to);
	return r;
	}

	__codecvt_utf8_utf16<char32_t>::result
	__codecvt_utf8_utf16<char32_t>::do_unshift(state_type&,
	extern_type* to, extern_type, extern_type& to_nxt) const
	{
	to_nxt = to;
	return noconv;
	}

	int
	__codecvt_utf8_utf16<char32_t>::do_encoding() const _NOEXCEPT
	{
	return 0;
	}

	bool
	__codecvt_utf8_utf16<char32_t>::do_always_noconv() const _NOEXCEPT
	{
	return false;
	}

	int
	__codecvt_utf8_utf16<char32_t>::do_length(state_type&,
	const extern_type* frm, const extern_type* frm_end, size_t mx) const
	{
	const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
	const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
	return utf8_to_utf16_length(_frm, _frm_end, mx, _Maxcode_, _Mode_);
	}

	int
	__codecvt_utf8_utf16<char32_t>::do_max_length() const _NOEXCEPT
	{
	if (_Mode_ & consume_header)
	return 7;
	return 4;
	}

	// __narrow_to_utf8<16>

	__narrow_to_utf8<16>::~__narrow_to_utf8()
	{
	}

	// __narrow_to_utf8<32>

	__narrow_to_utf8<32>::~__narrow_to_utf8()
	{
	}

	// __widen_from_utf8<16>

	__widen_from_utf8<16>::~__widen_from_utf8()
	{
	}

	// __widen_from_utf8<32>

	__widen_from_utf8<32>::~__widen_from_utf8()
	{
	}


	static bool checked_string_to_wchar_convert(wchar_t& dest,
	const char* ptr,
	locale_t loc) {
	if (*ptr == '\0')
	return false;
	mbstate_t mb = {};
	wchar_t out;
	size_t ret = __libcpp_mbrtowc_l(&out, ptr, strlen(ptr), &mb, loc);
	if (ret == static_cast<size_t>(-1) \|\| ret == static_cast<size_t>(-2)) {
	return false;
	}
	dest = out;
	return true;
	}

	static bool checked_string_to_char_convert(char& dest,
	const char* ptr,
	locale_t __loc) {
	if (*ptr == '\0')
	return false;
	if (!ptr[1]) {
	dest = *ptr;
	return true;
	}
	// First convert the MBS into a wide char then attempt to narrow it using
	// wctob_l.
	wchar_t wout;
	if (!checked_string_to_wchar_convert(wout, ptr, __loc))
	return false;
	int res;
	if ((res = __libcpp_wctob_l(wout, __loc)) != char_traits<char>::eof()) {
	dest = res;
	return true;
	}
	// FIXME: Work around specific multibyte sequences that we can reasonable
	// translate into a different single byte.
	switch (wout) {
	+ case L'\u202F': // narrow non-breaking space
	case L'\u00A0': // non-breaking space
	dest = ' ';
	return true;
	default:
	return false;
	}
	_LIBCPP_UNREACHABLE();
	}


	// numpunct<char> && numpunct<wchar_t>

	locale::id numpunct< char >::id;
	locale::id numpunct<wchar_t>::id;

	numpunct<char>::numpunct(size_t refs)
	: locale::facet(refs),
	__decimal_point_('.'),
	__thousands_sep_(',')
	{
	}

	numpunct<wchar_t>::numpunct(size_t refs)
	: locale::facet(refs),
	__decimal_point_(L'.'),
	__thousands_sep_(L',')
	{
	}

	numpunct<char>::~numpunct()
	{
	}

	numpunct<wchar_t>::~numpunct()
	{
	}

	char numpunct< char >::do_decimal_point() const {return __decimal_point_;}
	wchar_t numpunct<wchar_t>::do_decimal_point() const {return __decimal_point_;}

	char numpunct< char >::do_thousands_sep() const {return __thousands_sep_;}
	wchar_t numpunct<wchar_t>::do_thousands_sep() const {return __thousands_sep_;}

	string numpunct< char >::do_grouping() const {return __grouping_;}
	string numpunct<wchar_t>::do_grouping() const {return __grouping_;}

	string numpunct< char >::do_truename() const {return "true";}
	wstring numpunct<wchar_t>::do_truename() const {return L"true";}

	string numpunct< char >::do_falsename() const {return "false";}
	wstring numpunct<wchar_t>::do_falsename() const {return L"false";}

	// numpunct_byname<char>

	numpunct_byname<char>::numpunct_byname(const char* nm, size_t refs)
	: numpunct<char>(refs)
	{
	__init(nm);
	}

	numpunct_byname<char>::numpunct_byname(const string& nm, size_t refs)
	: numpunct<char>(refs)
	{
	__init(nm.c_str());
	}

	numpunct_byname<char>::~numpunct_byname()
	{
	}

	void
	numpunct_byname<char>::__init(const char* nm)
	{
	if (strcmp(nm, "C") != 0)
	{
	__libcpp_unique_locale loc(nm);
	if (!loc)
	__throw_runtime_error("numpunct_byname<char>::numpunct_byname"
	" failed to construct for " + string(nm));

	lconv* lc = __libcpp_localeconv_l(loc.get());
	checked_string_to_char_convert(__decimal_point_, lc->decimal_point,
	loc.get());
	checked_string_to_char_convert(__thousands_sep_, lc->thousands_sep,
	loc.get());
	__grouping_ = lc->grouping;
	// localization for truename and falsename is not available
	}
	}

	// numpunct_byname<wchar_t>

	numpunct_byname<wchar_t>::numpunct_byname(const char* nm, size_t refs)
	: numpunct<wchar_t>(refs)
	{
	__init(nm);
	}

	numpunct_byname<wchar_t>::numpunct_byname(const string& nm, size_t refs)
	: numpunct<wchar_t>(refs)
	{
	__init(nm.c_str());
	}

	numpunct_byname<wchar_t>::~numpunct_byname()
	{
	}

	void
	numpunct_byname<wchar_t>::__init(const char* nm)
	{
	if (strcmp(nm, "C") != 0)
	{
	__libcpp_unique_locale loc(nm);
	if (!loc)
	__throw_runtime_error("numpunct_byname<wchar_t>::numpunct_byname"
	" failed to construct for " + string(nm));

	lconv* lc = __libcpp_localeconv_l(loc.get());
	checked_string_to_wchar_convert(__decimal_point_, lc->decimal_point,
	loc.get());
	checked_string_to_wchar_convert(__thousands_sep_, lc->thousands_sep,
	loc.get());
	__grouping_ = lc->grouping;
	// localization for truename and falsename is not available
	}
	}

	// num_get helpers

	int
	__num_get_base::__get_base(ios_base& iob)
	{
	ios_base::fmtflags __basefield = iob.flags() & ios_base::basefield;
	if (__basefield == ios_base::oct)
	return 8;
	else if (__basefield == ios_base::hex)
	return 16;
	else if (__basefield == 0)
	return 0;
	return 10;
	}

	const char __num_get_base::__src[33] = "0123456789abcdefABCDEFxX+-pPiInN";

	void
	__check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end,
	ios_base::iostate& __err)
	{
	if (__grouping.size() != 0)
	{
	reverse(__g, __g_end);
	const char* __ig = __grouping.data();
	const char* __eg = __ig + __grouping.size();
	for (unsigned* __r = __g; __r < __g_end-1; ++__r)
	{
	if (0 < __ig && __ig < numeric_limits<char>::max())
	{
	if (static_cast<unsigned>(__ig) != __r)
	{
	__err = ios_base::failbit;
	return;
	}
	}
	if (__eg - __ig > 1)
	++__ig;
	}
	if (0 < __ig && __ig < numeric_limits<char>::max())
	{
	if (static_cast<unsigned>(*__ig) < __g_end[-1] \|\| __g_end[-1] == 0)
	__err = ios_base::failbit;
	}
	}
	}

	void
	__num_put_base::__format_int(char* __fmtp, const char* __len, bool __signd,
	ios_base::fmtflags __flags)
	{
	if (__flags & ios_base::showpos)
	*__fmtp++ = '+';
	if (__flags & ios_base::showbase)
	*__fmtp++ = '#';
	while(*__len)
	__fmtp++ = __len++;
	if ((__flags & ios_base::basefield) == ios_base::oct)
	*__fmtp = 'o';
	else if ((__flags & ios_base::basefield) == ios_base::hex)
	{
	if (__flags & ios_base::uppercase)
	*__fmtp = 'X';
	else
	*__fmtp = 'x';
	}
	else if (__signd)
	*__fmtp = 'd';
	else
	*__fmtp = 'u';
	}

	bool
	__num_put_base::__format_float(char* __fmtp, const char* __len,
	ios_base::fmtflags __flags)
	{
	bool specify_precision = true;
	if (__flags & ios_base::showpos)
	*__fmtp++ = '+';
	if (__flags & ios_base::showpoint)
	*__fmtp++ = '#';
	ios_base::fmtflags floatfield = __flags & ios_base::floatfield;
	bool uppercase = (__flags & ios_base::uppercase) != 0;
	if (floatfield == (ios_base::fixed \| ios_base::scientific))
	specify_precision = false;
	else
	{
	*__fmtp++ = '.';
	__fmtp++ = '';
	}
	while(*__len)
	__fmtp++ = __len++;
	if (floatfield == ios_base::fixed)
	{
	if (uppercase)
	*__fmtp = 'F';
	else
	*__fmtp = 'f';
	}
	else if (floatfield == ios_base::scientific)
	{
	if (uppercase)
	*__fmtp = 'E';
	else
	*__fmtp = 'e';
	}
	else if (floatfield == (ios_base::fixed \| ios_base::scientific))
	{
	if (uppercase)
	*__fmtp = 'A';
	else
	*__fmtp = 'a';
	}
	else
	{
	if (uppercase)
	*__fmtp = 'G';
	else
	*__fmtp = 'g';
	}
	return specify_precision;
	}

	char*
	__num_put_base::__identify_padding(char* __nb, char* __ne,
	const ios_base& __iob)
	{
	switch (__iob.flags() & ios_base::adjustfield)
	{
	case ios_base::internal:
	if (__nb[0] == '-' \|\| __nb[0] == '+')
	return __nb+1;
	if (__ne - __nb >= 2 && __nb[0] == '0'
	&& (__nb[1] == 'x' \|\| __nb[1] == 'X'))
	return __nb+2;
	break;
	case ios_base::left:
	return __ne;
	case ios_base::right:
	default:
	break;
	}
	return __nb;
	}

	// time_get

	static
	string*
	init_weeks()
	{
	static string weeks[14];
	weeks[0] = "Sunday";
	weeks[1] = "Monday";
	weeks[2] = "Tuesday";
	weeks[3] = "Wednesday";
	weeks[4] = "Thursday";
	weeks[5] = "Friday";
	weeks[6] = "Saturday";
	weeks[7] = "Sun";
	weeks[8] = "Mon";
	weeks[9] = "Tue";
	weeks[10] = "Wed";
	weeks[11] = "Thu";
	weeks[12] = "Fri";
	weeks[13] = "Sat";
	return weeks;
	}

	static
	wstring*
	init_wweeks()
	{
	static wstring weeks[14];
	weeks[0] = L"Sunday";
	weeks[1] = L"Monday";
	weeks[2] = L"Tuesday";
	weeks[3] = L"Wednesday";
	weeks[4] = L"Thursday";
	weeks[5] = L"Friday";
	weeks[6] = L"Saturday";
	weeks[7] = L"Sun";
	weeks[8] = L"Mon";
	weeks[9] = L"Tue";
	weeks[10] = L"Wed";
	weeks[11] = L"Thu";
	weeks[12] = L"Fri";
	weeks[13] = L"Sat";
	return weeks;
	}

	template <>
	const string*
	__time_get_c_storage<char>::__weeks() const
	{
	static const string* weeks = init_weeks();
	return weeks;
	}

	template <>
	const wstring*
	__time_get_c_storage<wchar_t>::__weeks() const
	{
	static const wstring* weeks = init_wweeks();
	return weeks;
	}

	static
	string*
	init_months()
	{
	static string months[24];
	months[0] = "January";
	months[1] = "February";
	months[2] = "March";
	months[3] = "April";
	months[4] = "May";
	months[5] = "June";
	months[6] = "July";
	months[7] = "August";
	months[8] = "September";
	months[9] = "October";
	months[10] = "November";
	months[11] = "December";
	months[12] = "Jan";
	months[13] = "Feb";
	months[14] = "Mar";
	months[15] = "Apr";
	months[16] = "May";
	months[17] = "Jun";
	months[18] = "Jul";
	months[19] = "Aug";
	months[20] = "Sep";
	months[21] = "Oct";
	months[22] = "Nov";
	months[23] = "Dec";
	return months;
	}

	static
	wstring*
	init_wmonths()
	{
	static wstring months[24];
	months[0] = L"January";
	months[1] = L"February";
	months[2] = L"March";
	months[3] = L"April";
	months[4] = L"May";
	months[5] = L"June";
	months[6] = L"July";
	months[7] = L"August";
	months[8] = L"September";
	months[9] = L"October";
	months[10] = L"November";
	months[11] = L"December";
	months[12] = L"Jan";
	months[13] = L"Feb";
	months[14] = L"Mar";
	months[15] = L"Apr";
	months[16] = L"May";
	months[17] = L"Jun";
	months[18] = L"Jul";
	months[19] = L"Aug";
	months[20] = L"Sep";
	months[21] = L"Oct";
	months[22] = L"Nov";
	months[23] = L"Dec";
	return months;
	}

	template <>
	const string*
	__time_get_c_storage<char>::__months() const
	{
	static const string* months = init_months();
	return months;
	}

	template <>
	const wstring*
	__time_get_c_storage<wchar_t>::__months() const
	{
	static const wstring* months = init_wmonths();
	return months;
	}

	static
	string*
	init_am_pm()
	{
	- static string am_pm[24];
	+ static string am_pm[2];
	am_pm[0] = "AM";
	am_pm[1] = "PM";
	return am_pm;
	}

	static
	wstring*
	init_wam_pm()
	{
	- static wstring am_pm[24];
	+ static wstring am_pm[2];
	am_pm[0] = L"AM";
	am_pm[1] = L"PM";
	return am_pm;
	}

	template <>
	const string*
	__time_get_c_storage<char>::__am_pm() const
	{
	static const string* am_pm = init_am_pm();
	return am_pm;
	}

	template <>
	const wstring*
	__time_get_c_storage<wchar_t>::__am_pm() const
	{
	static const wstring* am_pm = init_wam_pm();
	return am_pm;
	}

	template <>
	const string&
	__time_get_c_storage<char>::__x() const
	{
	static string s("%m/%d/%y");
	return s;
	}

	template <>
	const wstring&
	__time_get_c_storage<wchar_t>::__x() const
	{
	static wstring s(L"%m/%d/%y");
	return s;
	}

	template <>
	const string&
	__time_get_c_storage<char>::__X() const
	{
	static string s("%H:%M:%S");
	return s;
	}

	template <>
	const wstring&
	__time_get_c_storage<wchar_t>::__X() const
	{
	static wstring s(L"%H:%M:%S");
	return s;
	}

	template <>
	const string&
	__time_get_c_storage<char>::__c() const
	{
	static string s("%a %b %d %H:%M:%S %Y");
	return s;
	}

	template <>
	const wstring&
	__time_get_c_storage<wchar_t>::__c() const
	{
	static wstring s(L"%a %b %d %H:%M:%S %Y");
	return s;
	}

	template <>
	const string&
	__time_get_c_storage<char>::__r() const
	{
	static string s("%I:%M:%S %p");
	return s;
	}

	template <>
	const wstring&
	__time_get_c_storage<wchar_t>::__r() const
	{
	static wstring s(L"%I:%M:%S %p");
	return s;
	}

	// time_get_byname

	__time_get::__time_get(const char* nm)
	: __loc_(newlocale(LC_ALL_MASK, nm, 0))
	{
	if (__loc_ == 0)
	__throw_runtime_error("time_get_byname"
	" failed to construct for " + string(nm));
	}

	__time_get::__time_get(const string& nm)
	: __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0))
	{
	if (__loc_ == 0)
	__throw_runtime_error("time_get_byname"
	" failed to construct for " + nm);
	}

	__time_get::~__time_get()
	{
	freelocale(__loc_);
	}
	#if defined(__clang__)
	#pragma clang diagnostic ignored "-Wmissing-field-initializers"
	#endif
	#if defined(__GNUG__)
	#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
	#endif

	template <>
	string
	__time_get_storage<char>::__analyze(char fmt, const ctype<char>& ct)
	{
	tm t = {0};
	t.tm_sec = 59;
	t.tm_min = 55;
	t.tm_hour = 23;
	t.tm_mday = 31;
	t.tm_mon = 11;
	t.tm_year = 161;
	t.tm_wday = 6;
	t.tm_yday = 364;
	t.tm_isdst = -1;
	char buf[100];
	char f[3] = {0};
	f[0] = '%';
	f[1] = fmt;
	size_t n = strftime_l(buf, countof(buf), f, &t, __loc_);
	char* bb = buf;
	char* be = buf + n;
	string result;
	while (bb != be)
	{
	if (ct.is(ctype_base::space, *bb))
	{
	result.push_back(' ');
	for (++bb; bb != be && ct.is(ctype_base::space, *bb); ++bb)
	;
	continue;
	}
	char* w = bb;
	ios_base::iostate err = ios_base::goodbit;
	ptrdiff_t i = __scan_keyword(w, be, this->__weeks_, this->__weeks_+14,
	ct, err, false)
	- this->__weeks_;
	if (i < 14)
	{
	result.push_back('%');
	if (i < 7)
	result.push_back('A');
	else
	result.push_back('a');
	bb = w;
	continue;
	}
	w = bb;
	i = __scan_keyword(w, be, this->__months_, this->__months_+24,
	ct, err, false)
	- this->__months_;
	if (i < 24)
	{
	result.push_back('%');
	if (i < 12)
	result.push_back('B');
	else
	result.push_back('b');
	if (fmt == 'x' && ct.is(ctype_base::digit, this->__months_[i][0]))
	result.back() = 'm';
	bb = w;
	continue;
	}
	if (this->__am_pm_[0].size() + this->__am_pm_[1].size() > 0)
	{
	w = bb;
	i = __scan_keyword(w, be, this->__am_pm_, this->__am_pm_+2,
	ct, err, false) - this->__am_pm_;
	if (i < 2)
	{
	result.push_back('%');
	result.push_back('p');
	bb = w;
	continue;
	}
	}
	w = bb;
	if (ct.is(ctype_base::digit, *bb))
	{
	switch(__get_up_to_n_digits(bb, be, err, ct, 4))
	{
	case 6:
	result.push_back('%');
	result.push_back('w');
	break;
	case 7:
	result.push_back('%');
	result.push_back('u');
	break;
	case 11:
	result.push_back('%');
	result.push_back('I');
	break;
	case 12:
	result.push_back('%');
	result.push_back('m');
	break;
	case 23:
	result.push_back('%');
	result.push_back('H');
	break;
	case 31:
	result.push_back('%');
	result.push_back('d');
	break;
	case 55:
	result.push_back('%');
	result.push_back('M');
	break;
	case 59:
	result.push_back('%');
	result.push_back('S');
	break;
	case 61:
	result.push_back('%');
	result.push_back('y');
	break;
	case 364:
	result.push_back('%');
	result.push_back('j');
	break;
	case 2061:
	result.push_back('%');
	result.push_back('Y');
	break;
	default:
	for (; w != bb; ++w)
	result.push_back(*w);
	break;
	}
	continue;
	}
	if (*bb == '%')
	{
	result.push_back('%');
	result.push_back('%');
	++bb;
	continue;
	}
	result.push_back(*bb);
	++bb;
	}
	return result;
	}

	#if defined(__clang__)
	#pragma clang diagnostic ignored "-Wmissing-braces"
	#endif

	template <>
	wstring
	__time_get_storage<wchar_t>::__analyze(char fmt, const ctype<wchar_t>& ct)
	{
	tm t = {0};
	t.tm_sec = 59;
	t.tm_min = 55;
	t.tm_hour = 23;
	t.tm_mday = 31;
	t.tm_mon = 11;
	t.tm_year = 161;
	t.tm_wday = 6;
	t.tm_yday = 364;
	t.tm_isdst = -1;
	char buf[100];
	char f[3] = {0};
	f[0] = '%';
	f[1] = fmt;
	strftime_l(buf, countof(buf), f, &t, __loc_);
	wchar_t wbuf[100];
	wchar_t* wbb = wbuf;
	mbstate_t mb = {0};
	const char* bb = buf;
	size_t j = __libcpp_mbsrtowcs_l( wbb, &bb, countof(wbuf), &mb, __loc_);
	if (j == size_t(-1))
	__throw_runtime_error("locale not supported");
	wchar_t* wbe = wbb + j;
	wstring result;
	while (wbb != wbe)
	{
	if (ct.is(ctype_base::space, *wbb))
	{
	result.push_back(L' ');
	for (++wbb; wbb != wbe && ct.is(ctype_base::space, *wbb); ++wbb)
	;
	continue;
	}
	wchar_t* w = wbb;
	ios_base::iostate err = ios_base::goodbit;
	ptrdiff_t i = __scan_keyword(w, wbe, this->__weeks_, this->__weeks_+14,
	ct, err, false)
	- this->__weeks_;
	if (i < 14)
	{
	result.push_back(L'%');
	if (i < 7)
	result.push_back(L'A');
	else
	result.push_back(L'a');
	wbb = w;
	continue;
	}
	w = wbb;
	i = __scan_keyword(w, wbe, this->__months_, this->__months_+24,
	ct, err, false)
	- this->__months_;
	if (i < 24)
	{
	result.push_back(L'%');
	if (i < 12)
	result.push_back(L'B');
	else
	result.push_back(L'b');
	if (fmt == 'x' && ct.is(ctype_base::digit, this->__months_[i][0]))
	result.back() = L'm';
	wbb = w;
	continue;
	}
	if (this->__am_pm_[0].size() + this->__am_pm_[1].size() > 0)
	{
	w = wbb;
	i = __scan_keyword(w, wbe, this->__am_pm_, this->__am_pm_+2,
	ct, err, false) - this->__am_pm_;
	if (i < 2)
	{
	result.push_back(L'%');
	result.push_back(L'p');
	wbb = w;
	continue;
	}
	}
	w = wbb;
	if (ct.is(ctype_base::digit, *wbb))
	{
	switch(__get_up_to_n_digits(wbb, wbe, err, ct, 4))
	{
	case 6:
	result.push_back(L'%');
	result.push_back(L'w');
	break;
	case 7:
	result.push_back(L'%');
	result.push_back(L'u');
	break;
	case 11:
	result.push_back(L'%');
	result.push_back(L'I');
	break;
	case 12:
	result.push_back(L'%');
	result.push_back(L'm');
	break;
	case 23:
	result.push_back(L'%');
	result.push_back(L'H');
	break;
	case 31:
	result.push_back(L'%');
	result.push_back(L'd');
	break;
	case 55:
	result.push_back(L'%');
	result.push_back(L'M');
	break;
	case 59:
	result.push_back(L'%');
	result.push_back(L'S');
	break;
	case 61:
	result.push_back(L'%');
	result.push_back(L'y');
	break;
	case 364:
	result.push_back(L'%');
	result.push_back(L'j');
	break;
	case 2061:
	result.push_back(L'%');
	result.push_back(L'Y');
	break;
	default:
	for (; w != wbb; ++w)
	result.push_back(*w);
	break;
	}
	continue;
	}
	if (ct.narrow(*wbb, 0) == '%')
	{
	result.push_back(L'%');
	result.push_back(L'%');
	++wbb;
	continue;
	}
	result.push_back(*wbb);
	++wbb;
	}
	return result;
	}

	template <>
	void
	__time_get_storage<char>::init(const ctype<char>& ct)
	{
	tm t = {0};
	char buf[100];
	// __weeks_
	for (int i = 0; i < 7; ++i)
	{
	t.tm_wday = i;
	strftime_l(buf, countof(buf), "%A", &t, __loc_);
	__weeks_[i] = buf;
	strftime_l(buf, countof(buf), "%a", &t, __loc_);
	__weeks_[i+7] = buf;
	}
	// __months_
	for (int i = 0; i < 12; ++i)
	{
	t.tm_mon = i;
	strftime_l(buf, countof(buf), "%B", &t, __loc_);
	__months_[i] = buf;
	strftime_l(buf, countof(buf), "%b", &t, __loc_);
	__months_[i+12] = buf;
	}
	// __am_pm_
	t.tm_hour = 1;
	strftime_l(buf, countof(buf), "%p", &t, __loc_);
	__am_pm_[0] = buf;
	t.tm_hour = 13;
	strftime_l(buf, countof(buf), "%p", &t, __loc_);
	__am_pm_[1] = buf;
	__c_ = __analyze('c', ct);
	__r_ = __analyze('r', ct);
	__x_ = __analyze('x', ct);
	__X_ = __analyze('X', ct);
	}

	template <>
	void
	__time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
	{
	tm t = {0};
	char buf[100];
	wchar_t wbuf[100];
	wchar_t* wbe;
	mbstate_t mb = {0};
	// __weeks_
	for (int i = 0; i < 7; ++i)
	{
	t.tm_wday = i;
	strftime_l(buf, countof(buf), "%A", &t, __loc_);
	mb = mbstate_t();
	const char* bb = buf;
	size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
	if (j == size_t(-1))
	__throw_runtime_error("locale not supported");
	wbe = wbuf + j;
	__weeks_[i].assign(wbuf, wbe);
	strftime_l(buf, countof(buf), "%a", &t, __loc_);
	mb = mbstate_t();
	bb = buf;
	j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
	if (j == size_t(-1))
	__throw_runtime_error("locale not supported");
	wbe = wbuf + j;
	__weeks_[i+7].assign(wbuf, wbe);
	}
	// __months_
	for (int i = 0; i < 12; ++i)
	{
	t.tm_mon = i;
	strftime_l(buf, countof(buf), "%B", &t, __loc_);
	mb = mbstate_t();
	const char* bb = buf;
	size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
	if (j == size_t(-1))
	__throw_runtime_error("locale not supported");
	wbe = wbuf + j;
	__months_[i].assign(wbuf, wbe);
	strftime_l(buf, countof(buf), "%b", &t, __loc_);
	mb = mbstate_t();
	bb = buf;
	j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
	if (j == size_t(-1))
	__throw_runtime_error("locale not supported");
	wbe = wbuf + j;
	__months_[i+12].assign(wbuf, wbe);
	}
	// __am_pm_
	t.tm_hour = 1;
	strftime_l(buf, countof(buf), "%p", &t, __loc_);
	mb = mbstate_t();
	const char* bb = buf;
	size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
	if (j == size_t(-1))
	__throw_runtime_error("locale not supported");
	wbe = wbuf + j;
	__am_pm_[0].assign(wbuf, wbe);
	t.tm_hour = 13;
	strftime_l(buf, countof(buf), "%p", &t, __loc_);
	mb = mbstate_t();
	bb = buf;
	j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
	if (j == size_t(-1))
	__throw_runtime_error("locale not supported");
	wbe = wbuf + j;
	__am_pm_[1].assign(wbuf, wbe);
	__c_ = __analyze('c', ct);
	__r_ = __analyze('r', ct);
	__x_ = __analyze('x', ct);
	__X_ = __analyze('X', ct);
	}

	template <class CharT>
	struct _LIBCPP_HIDDEN __time_get_temp
	: public ctype_byname<CharT>
	{
	explicit __time_get_temp(const char* nm)
	: ctype_byname<CharT>(nm, 1) {}
	explicit __time_get_temp(const string& nm)
	: ctype_byname<CharT>(nm, 1) {}
	};

	template <>
	__time_get_storage<char>::__time_get_storage(const char* __nm)
	: __time_get(__nm)
	{
	const __time_get_temp<char> ct(__nm);
	init(ct);
	}

	template <>
	__time_get_storage<char>::__time_get_storage(const string& __nm)
	: __time_get(__nm)
	{
	const __time_get_temp<char> ct(__nm);
	init(ct);
	}

	template <>
	__time_get_storage<wchar_t>::__time_get_storage(const char* __nm)
	: __time_get(__nm)
	{
	const __time_get_temp<wchar_t> ct(__nm);
	init(ct);
	}

	template <>
	__time_get_storage<wchar_t>::__time_get_storage(const string& __nm)
	: __time_get(__nm)
	{
	const __time_get_temp<wchar_t> ct(__nm);
	init(ct);
	}

	template <>
	time_base::dateorder
	__time_get_storage<char>::__do_date_order() const
	{
	unsigned i;
	for (i = 0; i < __x_.size(); ++i)
	if (__x_[i] == '%')
	break;
	++i;
	switch (__x_[i])
	{
	case 'y':
	case 'Y':
	for (++i; i < __x_.size(); ++i)
	if (__x_[i] == '%')
	break;
	if (i == __x_.size())
	break;
	++i;
	switch (__x_[i])
	{
	case 'm':
	for (++i; i < __x_.size(); ++i)
	if (__x_[i] == '%')
	break;
	if (i == __x_.size())
	break;
	++i;
	if (__x_[i] == 'd')
	return time_base::ymd;
	break;
	case 'd':
	for (++i; i < __x_.size(); ++i)
	if (__x_[i] == '%')
	break;
	if (i == __x_.size())
	break;
	++i;
	if (__x_[i] == 'm')
	return time_base::ydm;
	break;
	}
	break;
	case 'm':
	for (++i; i < __x_.size(); ++i)
	if (__x_[i] == '%')
	break;
	if (i == __x_.size())
	break;
	++i;
	if (__x_[i] == 'd')
	{
	for (++i; i < __x_.size(); ++i)
	if (__x_[i] == '%')
	break;
	if (i == __x_.size())
	break;
	++i;
	if (__x_[i] == 'y' \|\| __x_[i] == 'Y')
	return time_base::mdy;
	break;
	}
	break;
	case 'd':
	for (++i; i < __x_.size(); ++i)
	if (__x_[i] == '%')
	break;
	if (i == __x_.size())
	break;
	++i;
	if (__x_[i] == 'm')
	{
	for (++i; i < __x_.size(); ++i)
	if (__x_[i] == '%')
	break;
	if (i == __x_.size())
	break;
	++i;
	if (__x_[i] == 'y' \|\| __x_[i] == 'Y')
	return time_base::dmy;
	break;
	}
	break;
	}
	return time_base::no_order;
	}

	template <>
	time_base::dateorder
	__time_get_storage<wchar_t>::__do_date_order() const
	{
	unsigned i;
	for (i = 0; i < __x_.size(); ++i)
	if (__x_[i] == L'%')
	break;
	++i;
	switch (__x_[i])
	{
	case L'y':
	case L'Y':
	for (++i; i < __x_.size(); ++i)
	if (__x_[i] == L'%')
	break;
	if (i == __x_.size())
	break;
	++i;
	switch (__x_[i])
	{
	case L'm':
	for (++i; i < __x_.size(); ++i)
	if (__x_[i] == L'%')
	break;
	if (i == __x_.size())
	break;
	++i;
	if (__x_[i] == L'd')
	return time_base::ymd;
	break;
	case L'd':
	for (++i; i < __x_.size(); ++i)
	if (__x_[i] == L'%')
	break;
	if (i == __x_.size())
	break;
	++i;
	if (__x_[i] == L'm')
	return time_base::ydm;
	break;
	}
	break;
	case L'm':
	for (++i; i < __x_.size(); ++i)
	if (__x_[i] == L'%')
	break;
	if (i == __x_.size())
	break;
	++i;
	if (__x_[i] == L'd')
	{
	for (++i; i < __x_.size(); ++i)
	if (__x_[i] == L'%')
	break;
	if (i == __x_.size())
	break;
	++i;
	if (__x_[i] == L'y' \|\| __x_[i] == L'Y')
	return time_base::mdy;
	break;
	}
	break;
	case L'd':
	for (++i; i < __x_.size(); ++i)
	if (__x_[i] == L'%')
	break;
	if (i == __x_.size())
	break;
	++i;
	if (__x_[i] == L'm')
	{
	for (++i; i < __x_.size(); ++i)
	if (__x_[i] == L'%')
	break;
	if (i == __x_.size())
	break;
	++i;
	if (__x_[i] == L'y' \|\| __x_[i] == L'Y')
	return time_base::dmy;
	break;
	}
	break;
	}
	return time_base::no_order;
	}

	// time_put

	__time_put::__time_put(const char* nm)
	: __loc_(newlocale(LC_ALL_MASK, nm, 0))
	{
	if (__loc_ == 0)
	__throw_runtime_error("time_put_byname"
	" failed to construct for " + string(nm));
	}

	__time_put::__time_put(const string& nm)
	: __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0))
	{
	if (__loc_ == 0)
	__throw_runtime_error("time_put_byname"
	" failed to construct for " + nm);
	}

	__time_put::~__time_put()
	{
	if (__loc_ != _LIBCPP_GET_C_LOCALE)
	freelocale(__loc_);
	}

	void
	__time_put::__do_put(char* __nb, char& __ne, const tm __tm,
	char __fmt, char __mod) const
	{
	char fmt[] = {'%', __fmt, __mod, 0};
	if (__mod != 0)
	swap(fmt[1], fmt[2]);
	size_t n = strftime_l(__nb, countof(__nb, __ne), fmt, __tm, __loc_);
	__ne = __nb + n;
	}

	void
	__time_put::__do_put(wchar_t* __wb, wchar_t& __we, const tm __tm,
	char __fmt, char __mod) const
	{
	char __nar[100];
	char* __ne = __nar + 100;
	__do_put(__nar, __ne, __tm, __fmt, __mod);
	mbstate_t mb = {0};
	const char* __nb = __nar;
	size_t j = __libcpp_mbsrtowcs_l(__wb, &__nb, countof(__wb, __we), &mb, __loc_);
	if (j == size_t(-1))
	__throw_runtime_error("locale not supported");
	__we = __wb + j;
	}

	// moneypunct_byname

	template <class charT>
	static
	void
	__init_pat(money_base::pattern& pat, basic_string<charT>& __curr_symbol_,
	bool intl, char cs_precedes, char sep_by_space, char sign_posn,
	charT space_char)
	{
	const char sign = static_cast<char>(money_base::sign);
	const char space = static_cast<char>(money_base::space);
	const char none = static_cast<char>(money_base::none);
	const char symbol = static_cast<char>(money_base::symbol);
	const char value = static_cast<char>(money_base::value);
	const bool symbol_contains_sep = intl && __curr_symbol_.size() == 4;

	// Comments on case branches reflect 'C11 7.11.2.1 The localeconv
	// function'. "Space between sign and symbol or value" means that
	// if the sign is adjacent to the symbol, there's a space between
	// them, and otherwise there's a space between the sign and value.
	//
	// C11's localeconv specifies that the fourth character of an
	// international curr_symbol is used to separate the sign and
	// value when sep_by_space says to do so. C++ can't represent
	// that, so we just use a space. When sep_by_space says to
	// separate the symbol and value-or-sign with a space, we rearrange the
	// curr_symbol to put its spacing character on the correct side of
	// the symbol.
	//
	// We also need to avoid adding an extra space between the sign
	// and value when the currency symbol is suppressed (by not
	// setting showbase). We match glibc's strfmon by interpreting
	// sep_by_space==1 as "omit the space when the currency symbol is
	// absent".
	//
	// Users who want to get this right should use ICU instead.

	switch (cs_precedes)
	{
	case 0: // value before curr_symbol
	if (symbol_contains_sep) {
	// Move the separator to before the symbol, to place it
	// between the value and symbol.
	rotate(__curr_symbol_.begin(), __curr_symbol_.begin() + 3,
	__curr_symbol_.end());
	}
	switch (sign_posn)
	{
	case 0: // Parentheses surround the quantity and currency symbol.
	pat.field[0] = sign;
	pat.field[1] = value;
	pat.field[2] = none; // Any space appears in the symbol.
	pat.field[3] = symbol;
	switch (sep_by_space)
	{
	case 0: // No space separates the currency symbol and value.
	// This case may have changed between C99 and C11;
	// assume the currency symbol matches the intention.
	case 2: // Space between sign and currency or value.
	// The "sign" is two parentheses, so no space here either.
	return;
	case 1: // Space between currency-and-sign or currency and value.
	if (!symbol_contains_sep) {
	// We insert the space into the symbol instead of
	// setting pat.field[2]=space so that when
	// showbase is not set, the space goes away too.
	__curr_symbol_.insert(0, 1, space_char);
	}
	return;
	default:
	break;
	}
	break;
	case 1: // The sign string precedes the quantity and currency symbol.
	pat.field[0] = sign;
	pat.field[3] = symbol;
	switch (sep_by_space)
	{
	case 0: // No space separates the currency symbol and value.
	pat.field[1] = value;
	pat.field[2] = none;
	return;
	case 1: // Space between currency-and-sign or currency and value.
	pat.field[1] = value;
	pat.field[2] = none;
	if (!symbol_contains_sep) {
	// We insert the space into the symbol instead of
	// setting pat.field[2]=space so that when
	// showbase is not set, the space goes away too.
	__curr_symbol_.insert(0, 1, space_char);
	}
	return;
	case 2: // Space between sign and currency or value.
	pat.field[1] = space;
	pat.field[2] = value;
	if (symbol_contains_sep) {
	// Remove the separator from the symbol, since it
	// has already appeared after the sign.
	__curr_symbol_.erase(__curr_symbol_.begin());
	}
	return;
	default:
	break;
	}
	break;
	case 2: // The sign string succeeds the quantity and currency symbol.
	pat.field[0] = value;
	pat.field[3] = sign;
	switch (sep_by_space)
	{
	case 0: // No space separates the currency symbol and value.
	pat.field[1] = none;
	pat.field[2] = symbol;
	return;
	case 1: // Space between currency-and-sign or currency and value.
	if (!symbol_contains_sep) {
	// We insert the space into the symbol instead of
	// setting pat.field[1]=space so that when
	// showbase is not set, the space goes away too.
	__curr_symbol_.insert(0, 1, space_char);
	}
	pat.field[1] = none;
	pat.field[2] = symbol;
	return;
	case 2: // Space between sign and currency or value.
	pat.field[1] = symbol;
	pat.field[2] = space;
	if (symbol_contains_sep) {
	// Remove the separator from the symbol, since it
	// should not be removed if showbase is absent.
	__curr_symbol_.erase(__curr_symbol_.begin());
	}
	return;
	default:
	break;
	}
	break;
	case 3: // The sign string immediately precedes the currency symbol.
	pat.field[0] = value;
	pat.field[3] = symbol;
	switch (sep_by_space)
	{
	case 0: // No space separates the currency symbol and value.
	pat.field[1] = none;
	pat.field[2] = sign;
	return;
	case 1: // Space between currency-and-sign or currency and value.
	pat.field[1] = space;
	pat.field[2] = sign;
	if (symbol_contains_sep) {
	// Remove the separator from the symbol, since it
	// has already appeared before the sign.
	__curr_symbol_.erase(__curr_symbol_.begin());
	}
	return;
	case 2: // Space between sign and currency or value.
	pat.field[1] = sign;
	pat.field[2] = none;
	if (!symbol_contains_sep) {
	// We insert the space into the symbol instead of
	// setting pat.field[2]=space so that when
	// showbase is not set, the space goes away too.
	__curr_symbol_.insert(0, 1, space_char);
	}
	return;
	default:
	break;
	}
	break;
	case 4: // The sign string immediately succeeds the currency symbol.
	pat.field[0] = value;
	pat.field[3] = sign;
	switch (sep_by_space)
	{
	case 0: // No space separates the currency symbol and value.
	pat.field[1] = none;
	pat.field[2] = symbol;
	return;
	case 1: // Space between currency-and-sign or currency and value.
	pat.field[1] = none;
	pat.field[2] = symbol;
	if (!symbol_contains_sep) {
	// We insert the space into the symbol instead of
	// setting pat.field[1]=space so that when
	// showbase is not set, the space goes away too.
	__curr_symbol_.insert(0, 1, space_char);
	}
	return;
	case 2: // Space between sign and currency or value.
	pat.field[1] = symbol;
	pat.field[2] = space;
	if (symbol_contains_sep) {
	// Remove the separator from the symbol, since it
	// should not disappear when showbase is absent.
	__curr_symbol_.erase(__curr_symbol_.begin());
	}
	return;
	default:
	break;
	}
	break;
	default:
	break;
	}
	break;
	case 1: // curr_symbol before value
	switch (sign_posn)
	{
	case 0: // Parentheses surround the quantity and currency symbol.
	pat.field[0] = sign;
	pat.field[1] = symbol;
	pat.field[2] = none; // Any space appears in the symbol.
	pat.field[3] = value;
	switch (sep_by_space)
	{
	case 0: // No space separates the currency symbol and value.
	// This case may have changed between C99 and C11;
	// assume the currency symbol matches the intention.
	case 2: // Space between sign and currency or value.
	// The "sign" is two parentheses, so no space here either.
	return;
	case 1: // Space between currency-and-sign or currency and value.
	if (!symbol_contains_sep) {
	// We insert the space into the symbol instead of
	// setting pat.field[2]=space so that when
	// showbase is not set, the space goes away too.
	__curr_symbol_.insert(0, 1, space_char);
	}
	return;
	default:
	break;
	}
	break;
	case 1: // The sign string precedes the quantity and currency symbol.
	pat.field[0] = sign;
	pat.field[3] = value;
	switch (sep_by_space)
	{
	case 0: // No space separates the currency symbol and value.
	pat.field[1] = symbol;
	pat.field[2] = none;
	return;
	case 1: // Space between currency-and-sign or currency and value.
	pat.field[1] = symbol;
	pat.field[2] = none;
	if (!symbol_contains_sep) {
	// We insert the space into the symbol instead of
	// setting pat.field[2]=space so that when
	// showbase is not set, the space goes away too.
	__curr_symbol_.push_back(space_char);
	}
	return;
	case 2: // Space between sign and currency or value.
	pat.field[1] = space;
	pat.field[2] = symbol;
	if (symbol_contains_sep) {
	// Remove the separator from the symbol, since it
	// has already appeared after the sign.
	__curr_symbol_.pop_back();
	}
	return;
	default:
	break;
	}
	break;
	case 2: // The sign string succeeds the quantity and currency symbol.
	pat.field[0] = symbol;
	pat.field[3] = sign;
	switch (sep_by_space)
	{
	case 0: // No space separates the currency symbol and value.
	pat.field[1] = none;
	pat.field[2] = value;
	return;
	case 1: // Space between currency-and-sign or currency and value.
	pat.field[1] = none;
	pat.field[2] = value;
	if (!symbol_contains_sep) {
	// We insert the space into the symbol instead of
	// setting pat.field[1]=space so that when
	// showbase is not set, the space goes away too.
	__curr_symbol_.push_back(space_char);
	}
	return;
	case 2: // Space between sign and currency or value.
	pat.field[1] = value;
	pat.field[2] = space;
	if (symbol_contains_sep) {
	// Remove the separator from the symbol, since it
	// will appear before the sign.
	__curr_symbol_.pop_back();
	}
	return;
	default:
	break;
	}
	break;
	case 3: // The sign string immediately precedes the currency symbol.
	pat.field[0] = sign;
	pat.field[3] = value;
	switch (sep_by_space)
	{
	case 0: // No space separates the currency symbol and value.
	pat.field[1] = symbol;
	pat.field[2] = none;
	return;
	case 1: // Space between currency-and-sign or currency and value.
	pat.field[1] = symbol;
	pat.field[2] = none;
	if (!symbol_contains_sep) {
	// We insert the space into the symbol instead of
	// setting pat.field[2]=space so that when
	// showbase is not set, the space goes away too.
	__curr_symbol_.push_back(space_char);
	}
	return;
	case 2: // Space between sign and currency or value.
	pat.field[1] = space;
	pat.field[2] = symbol;
	if (symbol_contains_sep) {
	// Remove the separator from the symbol, since it
	// has already appeared after the sign.
	__curr_symbol_.pop_back();
	}
	return;
	default:
	break;
	}
	break;
	case 4: // The sign string immediately succeeds the currency symbol.
	pat.field[0] = symbol;
	pat.field[3] = value;
	switch (sep_by_space)
	{
	case 0: // No space separates the currency symbol and value.
	pat.field[1] = sign;
	pat.field[2] = none;
	return;
	case 1: // Space between currency-and-sign or currency and value.
	pat.field[1] = sign;
	pat.field[2] = space;
	if (symbol_contains_sep) {
	// Remove the separator from the symbol, since it
	// should not disappear when showbase is absent.
	__curr_symbol_.pop_back();
	}
	return;
	case 2: // Space between sign and currency or value.
	pat.field[1] = none;
	pat.field[2] = sign;
	if (!symbol_contains_sep) {
	// We insert the space into the symbol instead of
	// setting pat.field[1]=space so that when
	// showbase is not set, the space goes away too.
	__curr_symbol_.push_back(space_char);
	}
	return;
	default:
	break;
	}
	break;
	default:
	break;
	}
	break;
	default:
	break;
	}
	pat.field[0] = symbol;
	pat.field[1] = sign;
	pat.field[2] = none;
	pat.field[3] = value;
	}

	template<>
	void
	moneypunct_byname<char, false>::init(const char* nm)
	{
	typedef moneypunct<char, false> base;
	__libcpp_unique_locale loc(nm);
	if (!loc)
	__throw_runtime_error("moneypunct_byname"
	" failed to construct for " + string(nm));

	lconv* lc = __libcpp_localeconv_l(loc.get());
	if (!checked_string_to_char_convert(__decimal_point_,
	lc->mon_decimal_point,
	loc.get()))
	__decimal_point_ = base::do_decimal_point();
	if (!checked_string_to_char_convert(__thousands_sep_,
	lc->mon_thousands_sep,
	loc.get()))
	__thousands_sep_ = base::do_thousands_sep();

	__grouping_ = lc->mon_grouping;
	__curr_symbol_ = lc->currency_symbol;
	if (lc->frac_digits != CHAR_MAX)
	__frac_digits_ = lc->frac_digits;
	else
	__frac_digits_ = base::do_frac_digits();
	if (lc->p_sign_posn == 0)
	__positive_sign_ = "()";
	else
	__positive_sign_ = lc->positive_sign;
	if (lc->n_sign_posn == 0)
	__negative_sign_ = "()";
	else
	__negative_sign_ = lc->negative_sign;
	// Assume the positive and negative formats will want spaces in
	// the same places in curr_symbol since there's no way to
	// represent anything else.
	string_type __dummy_curr_symbol = __curr_symbol_;
	__init_pat(__pos_format_, __dummy_curr_symbol, false,
	lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, ' ');
	__init_pat(__neg_format_, __curr_symbol_, false,
	lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, ' ');
	}

	template<>
	void
	moneypunct_byname<char, true>::init(const char* nm)
	{
	typedef moneypunct<char, true> base;
	__libcpp_unique_locale loc(nm);
	if (!loc)
	__throw_runtime_error("moneypunct_byname"
	" failed to construct for " + string(nm));

	lconv* lc = __libcpp_localeconv_l(loc.get());
	if (!checked_string_to_char_convert(__decimal_point_,
	lc->mon_decimal_point,
	loc.get()))
	__decimal_point_ = base::do_decimal_point();
	if (!checked_string_to_char_convert(__thousands_sep_,
	lc->mon_thousands_sep,
	loc.get()))
	__thousands_sep_ = base::do_thousands_sep();
	__grouping_ = lc->mon_grouping;
	__curr_symbol_ = lc->int_curr_symbol;
	if (lc->int_frac_digits != CHAR_MAX)
	__frac_digits_ = lc->int_frac_digits;
	else
	__frac_digits_ = base::do_frac_digits();
	#if defined(_LIBCPP_MSVCRT) \|\| defined(__MINGW32__)
	if (lc->p_sign_posn == 0)
	#else // _LIBCPP_MSVCRT
	if (lc->int_p_sign_posn == 0)
	#endif // !_LIBCPP_MSVCRT
	__positive_sign_ = "()";
	else
	__positive_sign_ = lc->positive_sign;
	#if defined(_LIBCPP_MSVCRT) \|\| defined(__MINGW32__)
	if(lc->n_sign_posn == 0)
	#else // _LIBCPP_MSVCRT
	if (lc->int_n_sign_posn == 0)
	#endif // !_LIBCPP_MSVCRT
	__negative_sign_ = "()";
	else
	__negative_sign_ = lc->negative_sign;
	// Assume the positive and negative formats will want spaces in
	// the same places in curr_symbol since there's no way to
	// represent anything else.
	string_type __dummy_curr_symbol = __curr_symbol_;
	#if defined(_LIBCPP_MSVCRT) \|\| defined(__MINGW32__)
	__init_pat(__pos_format_, __dummy_curr_symbol, true,
	lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, ' ');
	__init_pat(__neg_format_, __curr_symbol_, true,
	lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, ' ');
	#else // _LIBCPP_MSVCRT
	__init_pat(__pos_format_, __dummy_curr_symbol, true,
	lc->int_p_cs_precedes, lc->int_p_sep_by_space,
	lc->int_p_sign_posn, ' ');
	__init_pat(__neg_format_, __curr_symbol_, true,
	lc->int_n_cs_precedes, lc->int_n_sep_by_space,
	lc->int_n_sign_posn, ' ');
	#endif // !_LIBCPP_MSVCRT
	}

	template<>
	void
	moneypunct_byname<wchar_t, false>::init(const char* nm)
	{
	typedef moneypunct<wchar_t, false> base;
	__libcpp_unique_locale loc(nm);
	if (!loc)
	__throw_runtime_error("moneypunct_byname"
	" failed to construct for " + string(nm));
	lconv* lc = __libcpp_localeconv_l(loc.get());
	if (!checked_string_to_wchar_convert(__decimal_point_,
	lc->mon_decimal_point,
	loc.get()))
	__decimal_point_ = base::do_decimal_point();
	if (!checked_string_to_wchar_convert(__thousands_sep_,
	lc->mon_thousands_sep,
	loc.get()))
	__thousands_sep_ = base::do_thousands_sep();
	__grouping_ = lc->mon_grouping;
	wchar_t wbuf[100];
	mbstate_t mb = {0};
	const char* bb = lc->currency_symbol;
	size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
	if (j == size_t(-1))
	__throw_runtime_error("locale not supported");
	wchar_t* wbe = wbuf + j;
	__curr_symbol_.assign(wbuf, wbe);
	if (lc->frac_digits != CHAR_MAX)
	__frac_digits_ = lc->frac_digits;
	else
	__frac_digits_ = base::do_frac_digits();
	if (lc->p_sign_posn == 0)
	__positive_sign_ = L"()";
	else
	{
	mb = mbstate_t();
	bb = lc->positive_sign;
	j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
	if (j == size_t(-1))
	__throw_runtime_error("locale not supported");
	wbe = wbuf + j;
	__positive_sign_.assign(wbuf, wbe);
	}
	if (lc->n_sign_posn == 0)
	__negative_sign_ = L"()";
	else
	{
	mb = mbstate_t();
	bb = lc->negative_sign;
	j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
	if (j == size_t(-1))
	__throw_runtime_error("locale not supported");
	wbe = wbuf + j;
	__negative_sign_.assign(wbuf, wbe);
	}
	// Assume the positive and negative formats will want spaces in
	// the same places in curr_symbol since there's no way to
	// represent anything else.
	string_type __dummy_curr_symbol = __curr_symbol_;
	__init_pat(__pos_format_, __dummy_curr_symbol, false,
	lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, L' ');
	__init_pat(__neg_format_, __curr_symbol_, false,
	lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, L' ');
	}

	template<>
	void
	moneypunct_byname<wchar_t, true>::init(const char* nm)
	{
	typedef moneypunct<wchar_t, true> base;
	__libcpp_unique_locale loc(nm);
	if (!loc)
	__throw_runtime_error("moneypunct_byname"
	" failed to construct for " + string(nm));

	lconv* lc = __libcpp_localeconv_l(loc.get());
	if (!checked_string_to_wchar_convert(__decimal_point_,
	lc->mon_decimal_point,
	loc.get()))
	__decimal_point_ = base::do_decimal_point();
	if (!checked_string_to_wchar_convert(__thousands_sep_,
	lc->mon_thousands_sep,
	loc.get()))
	__thousands_sep_ = base::do_thousands_sep();
	__grouping_ = lc->mon_grouping;
	wchar_t wbuf[100];
	mbstate_t mb = {0};
	const char* bb = lc->int_curr_symbol;
	size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
	if (j == size_t(-1))
	__throw_runtime_error("locale not supported");
	wchar_t* wbe = wbuf + j;
	__curr_symbol_.assign(wbuf, wbe);
	if (lc->int_frac_digits != CHAR_MAX)
	__frac_digits_ = lc->int_frac_digits;
	else
	__frac_digits_ = base::do_frac_digits();
	#if defined(_LIBCPP_MSVCRT) \|\| defined(__MINGW32__)
	if (lc->p_sign_posn == 0)
	#else // _LIBCPP_MSVCRT
	if (lc->int_p_sign_posn == 0)
	#endif // !_LIBCPP_MSVCRT
	__positive_sign_ = L"()";
	else
	{
	mb = mbstate_t();
	bb = lc->positive_sign;
	j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
	if (j == size_t(-1))
	__throw_runtime_error("locale not supported");
	wbe = wbuf + j;
	__positive_sign_.assign(wbuf, wbe);
	}
	#if defined(_LIBCPP_MSVCRT) \|\| defined(__MINGW32__)
	if (lc->n_sign_posn == 0)
	#else // _LIBCPP_MSVCRT
	if (lc->int_n_sign_posn == 0)
	#endif // !_LIBCPP_MSVCRT
	__negative_sign_ = L"()";
	else
	{
	mb = mbstate_t();
	bb = lc->negative_sign;
	j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
	if (j == size_t(-1))
	__throw_runtime_error("locale not supported");
	wbe = wbuf + j;
	__negative_sign_.assign(wbuf, wbe);
	}
	// Assume the positive and negative formats will want spaces in
	// the same places in curr_symbol since there's no way to
	// represent anything else.
	string_type __dummy_curr_symbol = __curr_symbol_;
	#if defined(_LIBCPP_MSVCRT) \|\| defined(__MINGW32__)
	__init_pat(__pos_format_, __dummy_curr_symbol, true,
	lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, L' ');
	__init_pat(__neg_format_, __curr_symbol_, true,
	lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, L' ');
	#else // _LIBCPP_MSVCRT
	__init_pat(__pos_format_, __dummy_curr_symbol, true,
	lc->int_p_cs_precedes, lc->int_p_sep_by_space,
	lc->int_p_sign_posn, L' ');
	__init_pat(__neg_format_, __curr_symbol_, true,
	lc->int_n_cs_precedes, lc->int_n_sep_by_space,
	lc->int_n_sign_posn, L' ');
	#endif // !_LIBCPP_MSVCRT
	}

	void __do_nothing(void*) {}

	void __throw_runtime_error(const char* msg)
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	throw runtime_error(msg);
	#else
	(void)msg;
	_VSTD::abort();
	#endif
	}

	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<char>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<wchar_t>;

	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<char>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<wchar_t>;

	template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<char>;
	template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<wchar_t>;

	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<char>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<wchar_t>;

	template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_put<char>;
	template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_put<wchar_t>;

	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get<char>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get<wchar_t>;

	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get_byname<char>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get_byname<wchar_t>;

	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put<char>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put<wchar_t>;

	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put_byname<char>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put_byname<wchar_t>;

	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<char, false>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<char, true>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<wchar_t, false>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<wchar_t, true>;

	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<char, false>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<char, true>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<wchar_t, false>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<wchar_t, true>;

	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_get<char>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_get<wchar_t>;

	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_get<char>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_get<wchar_t>;

	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_put<char>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_put<wchar_t>;

	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_put<char>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_put<wchar_t>;

	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<char>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<wchar_t>;

	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<char>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<wchar_t>;

	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char, char, mbstate_t>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<wchar_t, char, mbstate_t>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char, mbstate_t>;
	template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char, mbstate_t>;

	_LIBCPP_END_NAMESPACE_STD

	Property changes on: projects/clang700-import/contrib/libc++/src/locale.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/memory.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/memory.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/memory.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/memory.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/mutex.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/mutex.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/mutex.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/mutex.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/new.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/new.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/new.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/new.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/optional.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/optional.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/optional.cpp (revision 337135)
	@@ -1,28 +1,42 @@
	//===------------------------ optional.cpp --------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is dual licensed under the MIT and the University of Illinois Open
	// Source Licenses. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include "optional"
	-#include "experimental/optional"

	namespace std
	{

	bad_optional_access::~bad_optional_access() _NOEXCEPT = default;

	const char* bad_optional_access::what() const _NOEXCEPT {
	return "bad_optional_access";
	}

	} // std

	+
	+#include <experimental/__config>
	+
	+// Preserve std::experimental::bad_optional_access for ABI compatibility
	+// Even though it no longer exists in a header file
	_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
	+
	+class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access
	+ : public std::logic_error
	+{
	+public:
	+ bad_optional_access() : std::logic_error("Bad optional Access") {}
	+
	+// Get the key function ~bad_optional_access() into the dylib
	+ virtual ~bad_optional_access() _NOEXCEPT;
	+};

	bad_optional_access::~bad_optional_access() _NOEXCEPT = default;

	_LIBCPP_END_NAMESPACE_EXPERIMENTAL

	Property changes on: projects/clang700-import/contrib/libc++/src/optional.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/random.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/random.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/random.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/random.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/regex.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/regex.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/regex.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/regex.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/shared_mutex.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/shared_mutex.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/shared_mutex.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/shared_mutex.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/stdexcept.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/stdexcept.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/stdexcept.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/stdexcept.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/string.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/string.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/string.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/string.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/strstream.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/strstream.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/strstream.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/strstream.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/support/runtime/exception_msvc.ipp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/support/runtime/exception_msvc.ipp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/support/runtime/exception_msvc.ipp (revision 337135)
	@@ -1,190 +1,178 @@
	// -- 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.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP_ABI_MICROSOFT
	#error this header can only be used when targeting the MSVC ABI
	#endif

	#include <stdio.h>
	#include <stdlib.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(
	+typedef void (__cdecl* terminate_handler)();
	+_LIBCPP_CRT_FUNC terminate_handler __cdecl set_terminate(
	terminate_handler _NewTerminateHandler) throw();
	-_ACRTIMP terminate_handler __cdecl _get_terminate();
	+_LIBCPP_CRT_FUNC terminate_handler __cdecl _get_terminate();

	-typedef void (__CRTDECL* unexpected_handler)();
	-_VCRTIMP unexpected_handler __cdecl set_unexpected(
	+typedef void (__cdecl* unexpected_handler)();
	+unexpected_handler __cdecl set_unexpected(
	unexpected_handler _NewUnexpectedHandler) throw();
	-_VCRTIMP unexpected_handler __cdecl _get_unexpected();
	+unexpected_handler __cdecl _get_unexpected();

	-_VCRTIMP int __cdecl __uncaught_exceptions();
	+int __cdecl __uncaught_exceptions();
	}

	namespace std {

	unexpected_handler
	set_unexpected(unexpected_handler func) _NOEXCEPT {
	return ::set_unexpected(func);
	}

	unexpected_handler get_unexpected() _NOEXCEPT {
	return ::_get_unexpected();
	}

	_LIBCPP_NORETURN
	void unexpected() {
	(*get_unexpected())();
	// unexpected handler should not return
	terminate();
	}

	terminate_handler set_terminate(terminate_handler func) _NOEXCEPT {
	return ::set_terminate(func);
	}

	terminate_handler get_terminate() _NOEXCEPT {
	return ::_get_terminate();
	}

	_LIBCPP_NORETURN
	void terminate() _NOEXCEPT
	{
	#ifndef _LIBCPP_NO_EXCEPTIONS
	try
	{
	#endif // _LIBCPP_NO_EXCEPTIONS
	(*get_terminate())();
	// handler should not return
	fprintf(stderr, "terminate_handler unexpectedly returned\n");
	::abort();
	#ifndef _LIBCPP_NO_EXCEPTIONS
	}
	catch (...)
	{
	// handler should not throw exception
	fprintf(stderr, "terminate_handler unexpectedly threw an exception\n");
	::abort();
	}
	#endif // _LIBCPP_NO_EXCEPTIONS
	}

	bool uncaught_exception() _NOEXCEPT { return uncaught_exceptions() > 0; }

	int uncaught_exceptions() _NOEXCEPT {
	return __uncaught_exceptions();
	}

	bad_array_length::bad_array_length() _NOEXCEPT
	{
	}

	bad_array_length::~bad_array_length() _NOEXCEPT
	{
	}

	const char*
	bad_array_length::what() const _NOEXCEPT
	{
	return "bad_array_length";
	}

	+#if defined(_LIBCPP_NO_VCRUNTIME)
	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
	Index: projects/clang700-import/contrib/libc++/src/support/runtime/exception_pointer_msvc.ipp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/support/runtime/exception_pointer_msvc.ipp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/support/runtime/exception_pointer_msvc.ipp (revision 337135)
	@@ -1,101 +1,87 @@
	// -- 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.
	//
	//===----------------------------------------------------------------------===//

	#include <stdio.h>
	#include <stdlib.h>

	-#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(void, const void);
	-_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL
	-__ExceptionPtrCompare(const void, const void);
	-_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL
	-__ExceptionPtrToBool(const void*);
	-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL __ExceptionPtrSwap(void, void);
	-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
	-__ExceptionPtrCurrentException(void*);
	-[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
	-__ExceptionPtrRethrow(const void*);
	-_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL
	+_LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrCreate(void*);
	+_LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrDestroy(void*);
	+_LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrCopy(void, const void);
	+_LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrAssign(void, const void);
	+_LIBCPP_CRT_FUNC bool __cdecl __ExceptionPtrCompare(const void, const void);
	+_LIBCPP_CRT_FUNC bool __cdecl __ExceptionPtrToBool(const void*);
	+_LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrSwap(void, void);
	+_LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrCurrentException(void*);
	+[[noreturn]] _LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrRethrow(const void*);
	+_LIBCPP_CRT_FUNC void __cdecl
	__ExceptionPtrCopyException(void, const void, const void*);

	namespace std {

	exception_ptr::exception_ptr() _NOEXCEPT { __ExceptionPtrCreate(this); }
	exception_ptr::exception_ptr(nullptr_t) _NOEXCEPT { __ExceptionPtrCreate(this); }

	exception_ptr::exception_ptr(const exception_ptr& __other) _NOEXCEPT {
	__ExceptionPtrCopy(this, &__other);
	}
	exception_ptr& exception_ptr::operator=(const exception_ptr& __other) _NOEXCEPT {
	__ExceptionPtrAssign(this, &__other);
	return *this;
	}

	exception_ptr& exception_ptr::operator=(nullptr_t) _NOEXCEPT {
	exception_ptr dummy;
	__ExceptionPtrAssign(this, &dummy);
	return *this;
	}

	exception_ptr::~exception_ptr() _NOEXCEPT { __ExceptionPtrDestroy(this); }

	exception_ptr::operator bool() const _NOEXCEPT {
	return __ExceptionPtrToBool(this);
	}

	bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT {
	return __ExceptionPtrCompare(&__x, &__y);
	}


	void swap(exception_ptr& lhs, exception_ptr& rhs) _NOEXCEPT {
	__ExceptionPtrSwap(&rhs, &lhs);
	}

	exception_ptr __copy_exception_ptr(void* __except, const void* __ptr) {
	exception_ptr __ret = nullptr;
	if (__ptr)
	__ExceptionPtrCopyException(&__ret, __except, __ptr);
	return __ret;
	}

	exception_ptr current_exception() _NOEXCEPT {
	exception_ptr __ret;
	__ExceptionPtrCurrentException(&__ret);
	return __ret;
	}

	_LIBCPP_NORETURN
	void rethrow_exception(exception_ptr p) { __ExceptionPtrRethrow(&p); }

	nested_exception::nested_exception() _NOEXCEPT : __ptr_(current_exception()) {}

	nested_exception::~nested_exception() _NOEXCEPT {}

	_LIBCPP_NORETURN
	void nested_exception::rethrow_nested() const {
	if (__ptr_ == nullptr)
	terminate();
	rethrow_exception(__ptr_);
	}

	} // namespace std
	Index: projects/clang700-import/contrib/libc++/src/system_error.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/system_error.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/system_error.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/system_error.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/thread.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/thread.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/thread.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/thread.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/typeinfo.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/typeinfo.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/typeinfo.cpp (revision 337135)
	@@ -1,57 +1,58 @@
	//===------------------------- typeinfo.cpp -------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is dual licensed under the MIT and the University of Illinois Open
	// Source Licenses. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include "typeinfo"

	-#if defined(_LIBCPP_ABI_MICROSOFT)
	+#if defined(_LIBCPP_ABI_MICROSOFT) && defined(_LIBCPP_NO_VCRUNTIME)
	#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.
	// FIXME: Remove the _LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY configuration.
	#if (!defined(LIBCXX_BUILDING_LIBCXXABI) && !defined(LIBCXXRT) && \
	- !defined(__GLIBCXX__) && !defined(__APPLE__)) \|\| \
	+ !defined(__GLIBCXX__) && !defined(__APPLE__) && \
	+ !(defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_NO_VCRUNTIME))) \|\| \
	defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY)
	std::type_info::~type_info()
	{
	}
	#endif

	Property changes on: projects/clang700-import/contrib/libc++/src/typeinfo.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/utility.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/utility.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/utility.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/utility.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/valarray.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/valarray.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/valarray.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/valarray.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/variant.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/variant.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/variant.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/variant.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++/src/vector.cpp
	===================================================================
	--- projects/clang700-import/contrib/libc++/src/vector.cpp (revision 337134)
	+++ projects/clang700-import/contrib/libc++/src/vector.cpp (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++/src/vector.cpp
	___________________________________________________________________
	Deleted: svn:keywords
	## -1 +0,0 ##
	-FreeBSD=%H
	\ No newline at end of property
	Index: projects/clang700-import/contrib/libc++
	===================================================================
	--- projects/clang700-import/contrib/libc++ (revision 337134)
	+++ projects/clang700-import/contrib/libc++ (revision 337135)

	Property changes on: projects/clang700-import/contrib/libc++
	___________________________________________________________________
	Modified: svn:mergeinfo
	## -0,0 +0,1 ##
	Merged /vendor/libc++/dist:r327630-337131

File Metadata

Mime Type: application/octet-stream
Expires: Sat, Jul 6, 3:00 PM (1 d, 23 h)
Storage Engine: chunks
Storage Format: Chunks
Storage Handle: VS3yF12cR3ul
Default Alt Text: (4 MB)

Offset	End	Complete
0	4194304	Yes
4194304	4539875	Yes

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions