Index: vendor/libc++/dist/include/__mutex_base
===================================================================
--- vendor/libc++/dist/include/__mutex_base	(revision 319785)
+++ vendor/libc++/dist/include/__mutex_base	(revision 319786)
@@ -1,437 +1,440 @@
 // -*- 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___MUTEX_BASE
 #define _LIBCPP___MUTEX_BASE
 
 #include <__config>
 #include <chrono>
 #include <system_error>
 #include <__threading_support>
 
 
 #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_HAS_NO_THREADS
 
 #ifndef _LIBCPP_THREAD_SAFETY_ANNOTATION
 #  ifdef _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS
 #    define _LIBCPP_THREAD_SAFETY_ANNOTATION(x) __attribute__((x))
 #  else
 #    define _LIBCPP_THREAD_SAFETY_ANNOTATION(x)
 #  endif
 #endif  // _LIBCPP_THREAD_SAFETY_ANNOTATION
 
 class _LIBCPP_TYPE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(capability("mutex")) mutex
 {
 #ifndef _LIBCPP_CXX03_LANG
     __libcpp_mutex_t __m_ = _LIBCPP_MUTEX_INITIALIZER;
 #else
     __libcpp_mutex_t __m_;
 #endif
 
 public:
     _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_CXX03_LANG
-    constexpr mutex() _NOEXCEPT = default;
+    constexpr mutex() = default;
 #else
     mutex() _NOEXCEPT {__m_ = (__libcpp_mutex_t)_LIBCPP_MUTEX_INITIALIZER;}
 #endif
     ~mutex();
 
 private:
     mutex(const mutex&);// = delete;
     mutex& operator=(const mutex&);// = delete;
 
 public:
     void lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability());
     bool try_lock() _NOEXCEPT _LIBCPP_THREAD_SAFETY_ANNOTATION(try_acquire_capability(true));
     void unlock() _NOEXCEPT _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability());
 
     typedef __libcpp_mutex_t* native_handle_type;
     _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;}
 };
+
+static_assert(is_nothrow_default_constructible<mutex>::value,
+              "the default constructor for std::mutex must be nothrow");
 
 struct _LIBCPP_TYPE_VIS defer_lock_t {};
 struct _LIBCPP_TYPE_VIS try_to_lock_t {};
 struct _LIBCPP_TYPE_VIS adopt_lock_t {};
 
 #if defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_MUTEX)
 
 extern const defer_lock_t  defer_lock;
 extern const try_to_lock_t try_to_lock;
 extern const adopt_lock_t  adopt_lock;
 
 #else
 
 constexpr defer_lock_t  defer_lock  = defer_lock_t();
 constexpr try_to_lock_t try_to_lock = try_to_lock_t();
 constexpr adopt_lock_t  adopt_lock  = adopt_lock_t();
 
 #endif
 
 template <class _Mutex>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable)
 lock_guard
 {
 public:
     typedef _Mutex mutex_type;
 
 private:
     mutex_type& __m_;
 public:
 
     _LIBCPP_INLINE_VISIBILITY
     explicit lock_guard(mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
         : __m_(__m) {__m_.lock();}
     _LIBCPP_INLINE_VISIBILITY
     lock_guard(mutex_type& __m, adopt_lock_t) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
         : __m_(__m) {}
     _LIBCPP_INLINE_VISIBILITY
     ~lock_guard() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();}
 
 private:
     lock_guard(lock_guard const&) _LIBCPP_EQUAL_DELETE;
     lock_guard& operator=(lock_guard const&) _LIBCPP_EQUAL_DELETE;
 };
 
 template <class _Mutex>
 class _LIBCPP_TEMPLATE_VIS unique_lock
 {
 public:
     typedef _Mutex mutex_type;
 
 private:
     mutex_type* __m_;
     bool __owns_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     unique_lock() _NOEXCEPT : __m_(nullptr), __owns_(false) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit unique_lock(mutex_type& __m)
         : __m_(_VSTD::addressof(__m)), __owns_(true) {__m_->lock();}
     _LIBCPP_INLINE_VISIBILITY
     unique_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
         : __m_(_VSTD::addressof(__m)), __owns_(false) {}
     _LIBCPP_INLINE_VISIBILITY
     unique_lock(mutex_type& __m, try_to_lock_t)
         : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock()) {}
     _LIBCPP_INLINE_VISIBILITY
     unique_lock(mutex_type& __m, adopt_lock_t)
         : __m_(_VSTD::addressof(__m)), __owns_(true) {}
     template <class _Clock, class _Duration>
     _LIBCPP_INLINE_VISIBILITY
         unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t)
             : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock_until(__t)) {}
     template <class _Rep, class _Period>
     _LIBCPP_INLINE_VISIBILITY
         unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d)
             : __m_(_VSTD::addressof(__m)), __owns_(__m.try_lock_for(__d)) {}
     _LIBCPP_INLINE_VISIBILITY
     ~unique_lock()
     {
         if (__owns_)
             __m_->unlock();
     }
 
 private:
     unique_lock(unique_lock const&); // = delete;
     unique_lock& operator=(unique_lock const&); // = delete;
 
 public:
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     unique_lock(unique_lock&& __u) _NOEXCEPT
         : __m_(__u.__m_), __owns_(__u.__owns_)
         {__u.__m_ = nullptr; __u.__owns_ = false;}
     _LIBCPP_INLINE_VISIBILITY
     unique_lock& operator=(unique_lock&& __u) _NOEXCEPT
         {
             if (__owns_)
                 __m_->unlock();
             __m_ = __u.__m_;
             __owns_ = __u.__owns_;
             __u.__m_ = nullptr;
             __u.__owns_ = false;
             return *this;
         }
 
 #endif  // _LIBCPP_CXX03_LANG
 
     void lock();
     bool try_lock();
 
     template <class _Rep, class _Period>
         bool try_lock_for(const chrono::duration<_Rep, _Period>& __d);
     template <class _Clock, class _Duration>
         bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
 
     void unlock();
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(unique_lock& __u) _NOEXCEPT
     {
         _VSTD::swap(__m_, __u.__m_);
         _VSTD::swap(__owns_, __u.__owns_);
     }
     _LIBCPP_INLINE_VISIBILITY
     mutex_type* release() _NOEXCEPT
     {
         mutex_type* __m = __m_;
         __m_ = nullptr;
         __owns_ = false;
         return __m;
     }
 
     _LIBCPP_INLINE_VISIBILITY
     bool owns_lock() const _NOEXCEPT {return __owns_;}
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_EXPLICIT
         operator bool () const _NOEXCEPT {return __owns_;}
     _LIBCPP_INLINE_VISIBILITY
     mutex_type* mutex() const _NOEXCEPT {return __m_;}
 };
 
 template <class _Mutex>
 void
 unique_lock<_Mutex>::lock()
 {
     if (__m_ == nullptr)
         __throw_system_error(EPERM, "unique_lock::lock: references null mutex");
     if (__owns_)
         __throw_system_error(EDEADLK, "unique_lock::lock: already locked");
     __m_->lock();
     __owns_ = true;
 }
 
 template <class _Mutex>
 bool
 unique_lock<_Mutex>::try_lock()
 {
     if (__m_ == nullptr)
         __throw_system_error(EPERM, "unique_lock::try_lock: references null mutex");
     if (__owns_)
         __throw_system_error(EDEADLK, "unique_lock::try_lock: already locked");
     __owns_ = __m_->try_lock();
     return __owns_;
 }
 
 template <class _Mutex>
 template <class _Rep, class _Period>
 bool
 unique_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d)
 {
     if (__m_ == nullptr)
         __throw_system_error(EPERM, "unique_lock::try_lock_for: references null mutex");
     if (__owns_)
         __throw_system_error(EDEADLK, "unique_lock::try_lock_for: already locked");
     __owns_ = __m_->try_lock_for(__d);
     return __owns_;
 }
 
 template <class _Mutex>
 template <class _Clock, class _Duration>
 bool
 unique_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
 {
     if (__m_ == nullptr)
         __throw_system_error(EPERM, "unique_lock::try_lock_until: references null mutex");
     if (__owns_)
         __throw_system_error(EDEADLK, "unique_lock::try_lock_until: already locked");
     __owns_ = __m_->try_lock_until(__t);
     return __owns_;
 }
 
 template <class _Mutex>
 void
 unique_lock<_Mutex>::unlock()
 {
     if (!__owns_)
         __throw_system_error(EPERM, "unique_lock::unlock: not locked");
     __m_->unlock();
     __owns_ = false;
 }
 
 template <class _Mutex>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) _NOEXCEPT
     {__x.swap(__y);}
 
 //enum class cv_status
 _LIBCPP_DECLARE_STRONG_ENUM(cv_status)
 {
     no_timeout,
     timeout
 };
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(cv_status)
 
 class _LIBCPP_TYPE_VIS condition_variable
 {
 #ifndef _LIBCPP_CXX03_LANG
     __libcpp_condvar_t __cv_ = _LIBCPP_CONDVAR_INITIALIZER;
 #else
     __libcpp_condvar_t __cv_;
 #endif
 
 public:
     _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_CXX03_LANG
     constexpr condition_variable() _NOEXCEPT = default;
 #else
     condition_variable() _NOEXCEPT {__cv_ = (__libcpp_condvar_t)_LIBCPP_CONDVAR_INITIALIZER;}
 #endif
     ~condition_variable();
 
 private:
     condition_variable(const condition_variable&); // = delete;
     condition_variable& operator=(const condition_variable&); // = delete;
 
 public:
     void notify_one() _NOEXCEPT;
     void notify_all() _NOEXCEPT;
 
     void wait(unique_lock<mutex>& __lk) _NOEXCEPT;
     template <class _Predicate>
         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         void wait(unique_lock<mutex>& __lk, _Predicate __pred);
 
     template <class _Clock, class _Duration>
         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         cv_status
         wait_until(unique_lock<mutex>& __lk,
                    const chrono::time_point<_Clock, _Duration>& __t);
 
     template <class _Clock, class _Duration, class _Predicate>
         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         bool
         wait_until(unique_lock<mutex>& __lk,
                    const chrono::time_point<_Clock, _Duration>& __t,
                    _Predicate __pred);
 
     template <class _Rep, class _Period>
         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         cv_status
         wait_for(unique_lock<mutex>& __lk,
                  const chrono::duration<_Rep, _Period>& __d);
 
     template <class _Rep, class _Period, class _Predicate>
         bool
         _LIBCPP_INLINE_VISIBILITY
         wait_for(unique_lock<mutex>& __lk,
                  const chrono::duration<_Rep, _Period>& __d,
                  _Predicate __pred);
 
     typedef __libcpp_condvar_t* native_handle_type;
     _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__cv_;}
 
 private:
     void __do_timed_wait(unique_lock<mutex>& __lk,
        chrono::time_point<chrono::system_clock, chrono::nanoseconds>) _NOEXCEPT;
 };
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 template <class _To, class _Rep, class _Period>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     chrono::__is_duration<_To>::value,
     _To
 >::type
 __ceil(chrono::duration<_Rep, _Period> __d)
 {
     using namespace chrono;
     _To __r = duration_cast<_To>(__d);
     if (__r < __d)
         ++__r;
     return __r;
 }
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 template <class _Predicate>
 void
 condition_variable::wait(unique_lock<mutex>& __lk, _Predicate __pred)
 {
     while (!__pred())
         wait(__lk);
 }
 
 template <class _Clock, class _Duration>
 cv_status
 condition_variable::wait_until(unique_lock<mutex>& __lk,
                                const chrono::time_point<_Clock, _Duration>& __t)
 {
     using namespace chrono;
     wait_for(__lk, __t - _Clock::now());
     return _Clock::now() < __t ? cv_status::no_timeout : cv_status::timeout;
 }
 
 template <class _Clock, class _Duration, class _Predicate>
 bool
 condition_variable::wait_until(unique_lock<mutex>& __lk,
                    const chrono::time_point<_Clock, _Duration>& __t,
                    _Predicate __pred)
 {
     while (!__pred())
     {
         if (wait_until(__lk, __t) == cv_status::timeout)
             return __pred();
     }
     return true;
 }
 
 template <class _Rep, class _Period>
 cv_status
 condition_variable::wait_for(unique_lock<mutex>& __lk,
                              const chrono::duration<_Rep, _Period>& __d)
 {
     using namespace chrono;
     if (__d <= __d.zero())
         return cv_status::timeout;
     typedef time_point<system_clock, duration<long double, nano> > __sys_tpf;
     typedef time_point<system_clock, nanoseconds> __sys_tpi;
     __sys_tpf _Max = __sys_tpi::max();
     steady_clock::time_point __c_now = steady_clock::now();
     system_clock::time_point __s_now = system_clock::now();
     if (_Max - __d > __s_now)
         __do_timed_wait(__lk, __s_now + __ceil<nanoseconds>(__d));
     else
         __do_timed_wait(__lk, __sys_tpi::max());
     return steady_clock::now() - __c_now < __d ? cv_status::no_timeout :
                                                  cv_status::timeout;
 }
 
 template <class _Rep, class _Period, class _Predicate>
 inline
 bool
 condition_variable::wait_for(unique_lock<mutex>& __lk,
                              const chrono::duration<_Rep, _Period>& __d,
                              _Predicate __pred)
 {
     return wait_until(__lk, chrono::steady_clock::now() + __d,
                       _VSTD::move(__pred));
 }
 
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP___MUTEX_BASE
Index: vendor/libc++/dist/include/mutex
===================================================================
--- vendor/libc++/dist/include/mutex	(revision 319785)
+++ vendor/libc++/dist/include/mutex	(revision 319786)
@@ -1,703 +1,702 @@
 // -*- C++ -*-
 //===--------------------------- mutex ------------------------------------===//
 //
 //                     The 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_MUTEX
 #define _LIBCPP_MUTEX
 
 /*
     mutex synopsis
 
 namespace std
 {
 
 class mutex
 {
 public:
      constexpr mutex() noexcept;
      ~mutex();
 
     mutex(const mutex&) = delete;
     mutex& operator=(const mutex&) = delete;
 
     void lock();
     bool try_lock();
     void unlock();
 
     typedef pthread_mutex_t* native_handle_type;
     native_handle_type native_handle();
 };
 
 class recursive_mutex
 {
 public:
      recursive_mutex();
      ~recursive_mutex();
 
     recursive_mutex(const recursive_mutex&) = delete;
     recursive_mutex& operator=(const recursive_mutex&) = delete;
 
     void lock();
     bool try_lock() noexcept;
     void unlock();
 
     typedef pthread_mutex_t* native_handle_type;
     native_handle_type native_handle();
 };
 
 class timed_mutex
 {
 public:
      timed_mutex();
      ~timed_mutex();
 
     timed_mutex(const timed_mutex&) = delete;
     timed_mutex& operator=(const timed_mutex&) = delete;
 
     void lock();
     bool try_lock();
     template <class Rep, class Period>
         bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
     template <class Clock, class Duration>
         bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
     void unlock();
 };
 
 class recursive_timed_mutex
 {
 public:
      recursive_timed_mutex();
      ~recursive_timed_mutex();
 
     recursive_timed_mutex(const recursive_timed_mutex&) = delete;
     recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
 
     void lock();
     bool try_lock() noexcept;
     template <class Rep, class Period>
         bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
     template <class Clock, class Duration>
         bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
     void unlock();
 };
 
 struct defer_lock_t {};
 struct try_to_lock_t {};
 struct adopt_lock_t {};
 
 constexpr defer_lock_t  defer_lock{};
 constexpr try_to_lock_t try_to_lock{};
 constexpr adopt_lock_t  adopt_lock{};
 
 template <class Mutex>
 class lock_guard
 {
 public:
     typedef Mutex mutex_type;
 
     explicit lock_guard(mutex_type& m);
     lock_guard(mutex_type& m, adopt_lock_t);
     ~lock_guard();
 
     lock_guard(lock_guard const&) = delete;
     lock_guard& operator=(lock_guard const&) = delete;
 };
 
 template <class... MutexTypes>
 class scoped_lock // C++17
 {
 public:
     using mutex_type = Mutex;  // If MutexTypes... consists of the single type Mutex
 
     explicit scoped_lock(MutexTypes&... m);
     scoped_lock(MutexTypes&... m, adopt_lock_t);
     ~scoped_lock();
     scoped_lock(scoped_lock const&) = delete;
     scoped_lock& operator=(scoped_lock const&) = delete;
 private:
     tuple<MutexTypes&...> pm; // exposition only
 };
 
 template <class Mutex>
 class unique_lock
 {
 public:
     typedef Mutex mutex_type;
     unique_lock() noexcept;
     explicit unique_lock(mutex_type& m);
     unique_lock(mutex_type& m, defer_lock_t) noexcept;
     unique_lock(mutex_type& m, try_to_lock_t);
     unique_lock(mutex_type& m, adopt_lock_t);
     template <class Clock, class Duration>
         unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
     template <class Rep, class Period>
         unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
     ~unique_lock();
 
     unique_lock(unique_lock const&) = delete;
     unique_lock& operator=(unique_lock const&) = delete;
 
     unique_lock(unique_lock&& u) noexcept;
     unique_lock& operator=(unique_lock&& u) noexcept;
 
     void lock();
     bool try_lock();
 
     template <class Rep, class Period>
         bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
     template <class Clock, class Duration>
         bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 
     void unlock();
 
     void swap(unique_lock& u) noexcept;
     mutex_type* release() noexcept;
 
     bool owns_lock() const noexcept;
     explicit operator bool () const noexcept;
     mutex_type* mutex() const noexcept;
 };
 
 template <class Mutex>
   void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 
 template <class L1, class L2, class... L3>
   int try_lock(L1&, L2&, L3&...);
 template <class L1, class L2, class... L3>
   void lock(L1&, L2&, L3&...);
 
 struct once_flag
 {
     constexpr once_flag() noexcept;
 
     once_flag(const once_flag&) = delete;
     once_flag& operator=(const once_flag&) = delete;
 };
 
 template<class Callable, class ...Args>
   void call_once(once_flag& flag, Callable&& func, Args&&... args);
 
 }  // std
 
 */
 
 #include <__config>
 #include <__mutex_base>
 #include <functional>
 #include <memory>
 #ifndef _LIBCPP_CXX03_LANG
 #include <tuple>
 #endif
 #include <__threading_support>
 
 #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_HAS_NO_THREADS
 
 class _LIBCPP_TYPE_VIS recursive_mutex
 {
     __libcpp_recursive_mutex_t __m_;
 
 public:
      recursive_mutex();
      ~recursive_mutex();
 
 private:
     recursive_mutex(const recursive_mutex&); // = delete;
     recursive_mutex& operator=(const recursive_mutex&); // = delete;
 
 public:
     void lock();
     bool try_lock() _NOEXCEPT;
     void unlock()  _NOEXCEPT;
 
     typedef __libcpp_recursive_mutex_t* native_handle_type;
 
     _LIBCPP_INLINE_VISIBILITY
     native_handle_type native_handle() {return &__m_;}
 };
 
 class _LIBCPP_TYPE_VIS timed_mutex
 {
     mutex              __m_;
     condition_variable __cv_;
     bool               __locked_;
 public:
      timed_mutex();
      ~timed_mutex();
 
 private:
     timed_mutex(const timed_mutex&); // = delete;
     timed_mutex& operator=(const timed_mutex&); // = delete;
 
 public:
     void lock();
     bool try_lock() _NOEXCEPT;
     template <class _Rep, class _Period>
         _LIBCPP_INLINE_VISIBILITY
         bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
             {return try_lock_until(chrono::steady_clock::now() + __d);}
     template <class _Clock, class _Duration>
         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
     void unlock() _NOEXCEPT;
 };
 
 template <class _Clock, class _Duration>
 bool
 timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
 {
     using namespace chrono;
     unique_lock<mutex> __lk(__m_);
     bool no_timeout = _Clock::now() < __t;
     while (no_timeout && __locked_)
         no_timeout = __cv_.wait_until(__lk, __t) == cv_status::no_timeout;
     if (!__locked_)
     {
         __locked_ = true;
         return true;
     }
     return false;
 }
 
 class _LIBCPP_TYPE_VIS recursive_timed_mutex
 {
     mutex              __m_;
     condition_variable __cv_;
     size_t             __count_;
     __libcpp_thread_id __id_;
 public:
      recursive_timed_mutex();
      ~recursive_timed_mutex();
 
 private:
     recursive_timed_mutex(const recursive_timed_mutex&); // = delete;
     recursive_timed_mutex& operator=(const recursive_timed_mutex&); // = delete;
 
 public:
     void lock();
     bool try_lock() _NOEXCEPT;
     template <class _Rep, class _Period>
         _LIBCPP_INLINE_VISIBILITY
         bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
             {return try_lock_until(chrono::steady_clock::now() + __d);}
     template <class _Clock, class _Duration>
         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
     void unlock() _NOEXCEPT;
 };
 
 template <class _Clock, class _Duration>
 bool
 recursive_timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
 {
     using namespace chrono;
     __libcpp_thread_id __id = __libcpp_thread_get_current_id();
     unique_lock<mutex> lk(__m_);
     if (__libcpp_thread_id_equal(__id, __id_))
     {
         if (__count_ == numeric_limits<size_t>::max())
             return false;
         ++__count_;
         return true;
     }
     bool no_timeout = _Clock::now() < __t;
     while (no_timeout && __count_ != 0)
         no_timeout = __cv_.wait_until(lk, __t) == cv_status::no_timeout;
     if (__count_ == 0)
     {
         __count_ = 1;
         __id_ = __id;
         return true;
     }
     return false;
 }
 
 template <class _L0, class _L1>
 int
 try_lock(_L0& __l0, _L1& __l1)
 {
     unique_lock<_L0> __u0(__l0, try_to_lock);
     if (__u0.owns_lock())
     {
         if (__l1.try_lock())
         {
             __u0.release();
             return -1;
         }
         else
             return 1;
     }
     return 0;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _L0, class _L1, class _L2, class... _L3>
 int
 try_lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3)
 {
     int __r = 0;
     unique_lock<_L0> __u0(__l0, try_to_lock);
     if (__u0.owns_lock())
     {
         __r = try_lock(__l1, __l2, __l3...);
         if (__r == -1)
             __u0.release();
         else
             ++__r;
     }
     return __r;
 }
 
 #endif  // _LIBCPP_CXX03_LANG
 
 template <class _L0, class _L1>
 void
 lock(_L0& __l0, _L1& __l1)
 {
     while (true)
     {
         {
             unique_lock<_L0> __u0(__l0);
             if (__l1.try_lock())
             {
                 __u0.release();
                 break;
             }
         }
         __libcpp_thread_yield();
         {
             unique_lock<_L1> __u1(__l1);
             if (__l0.try_lock())
             {
                 __u1.release();
                 break;
             }
         }
         __libcpp_thread_yield();
     }
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _L0, class _L1, class _L2, class ..._L3>
 void
 __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
 {
     while (true)
     {
         switch (__i)
         {
         case 0:
             {
                 unique_lock<_L0> __u0(__l0);
                 __i = try_lock(__l1, __l2, __l3...);
                 if (__i == -1)
                 {
                     __u0.release();
                     return;
                 }
             }
             ++__i;
             __libcpp_thread_yield();
             break;
         case 1:
             {
                 unique_lock<_L1> __u1(__l1);
                 __i = try_lock(__l2, __l3..., __l0);
                 if (__i == -1)
                 {
                     __u1.release();
                     return;
                 }
             }
             if (__i == sizeof...(_L3) + 1)
                 __i = 0;
             else
                 __i += 2;
             __libcpp_thread_yield();
             break;
         default:
             __lock_first(__i - 2, __l2, __l3..., __l0, __l1);
             return;
         }
     }
 }
 
 template <class _L0, class _L1, class _L2, class ..._L3>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
 {
     __lock_first(0, __l0, __l1, __l2, __l3...);
 }
 
 template <class _L0>
 inline _LIBCPP_INLINE_VISIBILITY
 void __unlock(_L0& __l0) {
     __l0.unlock();
 }
 
 template <class _L0, class _L1>
 inline _LIBCPP_INLINE_VISIBILITY
 void __unlock(_L0& __l0, _L1& __l1) {
     __l0.unlock();
     __l1.unlock();
 }
 
 template <class _L0, class _L1, class _L2, class ..._L3>
 inline _LIBCPP_INLINE_VISIBILITY
 void __unlock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
     __l0.unlock();
     __l1.unlock();
     _VSTD::__unlock(__l2, __l3...);
 }
 
 #endif  // _LIBCPP_CXX03_LANG
 
 #if _LIBCPP_STD_VER > 14
 template <class ..._Mutexes>
 class _LIBCPP_TEMPLATE_VIS scoped_lock;
 
 template <>
 class _LIBCPP_TEMPLATE_VIS scoped_lock<> {
 public:
     explicit scoped_lock() {}
     ~scoped_lock() = default;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit scoped_lock(adopt_lock_t) {}
 
     scoped_lock(scoped_lock const&) = delete;
     scoped_lock& operator=(scoped_lock const&) = delete;
 };
 
 template <class _Mutex>
 class _LIBCPP_TEMPLATE_VIS scoped_lock<_Mutex> {
 public:
     typedef _Mutex  mutex_type;
 private:
     mutex_type& __m_;
 public:
     explicit scoped_lock(mutex_type & __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
         : __m_(__m) {__m_.lock();}
 
     ~scoped_lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();}
 
     _LIBCPP_INLINE_VISIBILITY
     explicit scoped_lock(mutex_type& __m, adopt_lock_t) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
         : __m_(__m) {}
-    
 
     scoped_lock(scoped_lock const&) = delete;
     scoped_lock& operator=(scoped_lock const&) = delete;
 };
 
 template <class ..._MArgs>
 class _LIBCPP_TEMPLATE_VIS scoped_lock
 {
     static_assert(sizeof...(_MArgs) > 1, "At least 2 lock types required");
     typedef tuple<_MArgs&...> _MutexTuple;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit scoped_lock(_MArgs&... __margs)
       : __t_(__margs...)
     {
         _VSTD::lock(__margs...);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     scoped_lock(_MArgs&... __margs, adopt_lock_t)
         : __t_(__margs...)
     {
     }
 
     _LIBCPP_INLINE_VISIBILITY
     ~scoped_lock() {
         typedef typename __make_tuple_indices<sizeof...(_MArgs)>::type _Indices;
         __unlock_unpack(_Indices{}, __t_);
     }
 
     scoped_lock(scoped_lock const&) = delete;
     scoped_lock& operator=(scoped_lock const&) = delete;
 
 private:
     template <size_t ..._Indx>
     _LIBCPP_INLINE_VISIBILITY
     static void __unlock_unpack(__tuple_indices<_Indx...>, _MutexTuple& __mt) {
         _VSTD::__unlock(_VSTD::get<_Indx>(__mt)...);
     }
 
     _MutexTuple __t_;
 };
 
 #endif // _LIBCPP_STD_VER > 14
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 struct _LIBCPP_TEMPLATE_VIS once_flag;
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template<class _Callable, class... _Args>
 _LIBCPP_INLINE_VISIBILITY
 void call_once(once_flag&, _Callable&&, _Args&&...);
 
 #else  // _LIBCPP_CXX03_LANG
 
 template<class _Callable>
 _LIBCPP_INLINE_VISIBILITY
 void call_once(once_flag&, _Callable&);
 
 template<class _Callable>
 _LIBCPP_INLINE_VISIBILITY
 void call_once(once_flag&, const _Callable&);
 
 #endif  // _LIBCPP_CXX03_LANG
 
 struct _LIBCPP_TEMPLATE_VIS once_flag
 {
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR
         once_flag() _NOEXCEPT : __state_(0) {}
 
 private:
     once_flag(const once_flag&); // = delete;
     once_flag& operator=(const once_flag&); // = delete;
 
     unsigned long __state_;
 
 #ifndef _LIBCPP_CXX03_LANG
     template<class _Callable, class... _Args>
     friend
     void call_once(once_flag&, _Callable&&, _Args&&...);
 #else  // _LIBCPP_CXX03_LANG
     template<class _Callable>
     friend
     void call_once(once_flag&, _Callable&);
 
     template<class _Callable>
     friend
     void call_once(once_flag&, const _Callable&);
 #endif  // _LIBCPP_CXX03_LANG
 };
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Fp>
 class __call_once_param
 {
     _Fp& __f_;
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __call_once_param(_Fp& __f) : __f_(__f) {}
 
     _LIBCPP_INLINE_VISIBILITY
     void operator()()
     {
         typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index;
         __execute(_Index());
     }
 
 private:
     template <size_t ..._Indices>
     _LIBCPP_INLINE_VISIBILITY
     void __execute(__tuple_indices<_Indices...>)
     {
         __invoke(_VSTD::get<0>(_VSTD::move(__f_)), _VSTD::get<_Indices>(_VSTD::move(__f_))...);
     }
 };
 
 #else
 
 template <class _Fp>
 class __call_once_param
 {
     _Fp& __f_;
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __call_once_param(_Fp& __f) : __f_(__f) {}
 
     _LIBCPP_INLINE_VISIBILITY
     void operator()()
     {
         __f_();
     }
 };
 
 #endif
 
 template <class _Fp>
 void
 __call_once_proxy(void* __vp)
 {
     __call_once_param<_Fp>* __p = static_cast<__call_once_param<_Fp>*>(__vp);
     (*__p)();
 }
 
 _LIBCPP_FUNC_VIS void __call_once(volatile unsigned long&, void*, void(*)(void*));
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template<class _Callable, class... _Args>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 call_once(once_flag& __flag, _Callable&& __func, _Args&&... __args)
 {
     if (__libcpp_acquire_load(&__flag.__state_) != ~0ul)
     {
         typedef tuple<_Callable&&, _Args&&...> _Gp;
         _Gp __f(_VSTD::forward<_Callable>(__func), _VSTD::forward<_Args>(__args)...);
         __call_once_param<_Gp> __p(__f);
         __call_once(__flag.__state_, &__p, &__call_once_proxy<_Gp>);
     }
 }
 
 #else  // _LIBCPP_CXX03_LANG
 
 template<class _Callable>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 call_once(once_flag& __flag, _Callable& __func)
 {
     if (__libcpp_acquire_load(&__flag.__state_) != ~0ul)
     {
         __call_once_param<_Callable> __p(__func);
         __call_once(__flag.__state_, &__p, &__call_once_proxy<_Callable>);
     }
 }
 
 template<class _Callable>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 call_once(once_flag& __flag, const _Callable& __func)
 {
     if (__libcpp_acquire_load(&__flag.__state_) != ~0ul)
     {
         __call_once_param<const _Callable> __p(__func);
         __call_once(__flag.__state_, &__p, &__call_once_proxy<const _Callable>);
     }
 }
 
 #endif  // _LIBCPP_CXX03_LANG
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP_MUTEX
Index: vendor/libc++/dist/include/numeric
===================================================================
--- vendor/libc++/dist/include/numeric	(revision 319785)
+++ vendor/libc++/dist/include/numeric	(revision 319786)
@@ -1,275 +1,346 @@
 // -*- 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 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 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, 
+                   OutputIterator result, T init, BinaryOperation binary_op); // 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>
     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;
 }
 
 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;
 }
 
 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, 
+               _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, 
+               _OutputIterator __result, _Tp __init)
+{
+    return _VSTD::exclusive_scan(__first, __last, __result, __init, _VSTD::plus<>());
+}
+
+template <class _InputIterator, class _OutputIterator, class _Tp, 
+          class _BinaryOp, class _UnaryOp>
+inline _LIBCPP_INLINE_VISIBILITY
+_OutputIterator
+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;
+}
+#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: vendor/libc++/dist/include/optional
===================================================================
--- vendor/libc++/dist/include/optional	(revision 319785)
+++ vendor/libc++/dist/include/optional	(revision 319786)
@@ -1,1323 +1,1323 @@
 // -*- 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 };
   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 U&, const optional<T>&);
   template <class T, class U> constexpr bool operator!=(const optional<T>&, const U&);
   template <class T, class U> constexpr bool operator!=(const U&, const optional<T>&);
   template <class T, class U> constexpr bool operator<(const optional<T>&, const U&);
   template <class T, class U> constexpr bool operator<(const U&, const optional<T>&);
   template <class T, class U> constexpr bool operator<=(const optional<T>&, const U&);
   template <class T, class U> constexpr bool operator<=(const U&, const optional<T>&);
   template <class T, class U> constexpr bool operator>(const optional<T>&, const U&);
   template <class T, class U> constexpr bool operator>(const U&, const optional<T>&);
   template <class T, class U> constexpr bool operator>=(const optional<T>&, const U&);
   template <class T, class U> constexpr bool operator>=(const U&, const optional<T>&);
 
   // 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
   };
 } // 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 {}
 };
 
 /* inline */ 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_copyable<_Tp>::value>
 struct __optional_storage;
 
 template <class _Tp>
 struct __optional_storage<_Tp, true> : __optional_storage_base<_Tp>
 {
     using __optional_storage_base<_Tp>::__optional_storage_base;
 };
 
 template <class _Tp>
 struct __optional_storage<_Tp, false> : __optional_storage_base<_Tp>
 {
     using value_type = _Tp;
     using __optional_storage_base<_Tp>::__optional_storage_base;
 
     _LIBCPP_INLINE_VISIBILITY
     __optional_storage() = default;
 
     _LIBCPP_INLINE_VISIBILITY
     __optional_storage(const __optional_storage& __opt)
     {
         this->__construct_from(__opt);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __optional_storage(__optional_storage&& __opt)
         noexcept(is_nothrow_move_constructible_v<value_type>)
     {
         this->__construct_from(_VSTD::move(__opt));
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __optional_storage& operator=(const __optional_storage& __opt)
     {
         this->__assign_from(__opt);
         return *this;
     }
 
     _LIBCPP_INLINE_VISIBILITY
     __optional_storage& operator=(__optional_storage&& __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_storage<_Tp>
     , private __optional_sfinae_ctor_base_t<_Tp>
     , private __optional_sfinae_assign_base_t<_Tp>
 {
     using __base = __optional_storage<_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>,
         _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<_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
-    value_type value_or(_Up&& __v) &&
+    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;
     }
 };
 
 // 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: vendor/libc++/dist/include/tuple
===================================================================
--- vendor/libc++/dist/include/tuple	(revision 319785)
+++ vendor/libc++/dist/include/tuple	(revision 319786)
@@ -1,1407 +1,1417 @@
 // -*- 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&>())...));
 };
 
 const 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>
  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);
     }
 
     __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>>
                     , 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");}
 
     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");}
 
     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>>
                       , 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 {}
 };
 
+#ifdef __cpp_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[] = {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 {
   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>
 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{})
 )
 
 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{})
 )
 
 #undef _LIBCPP_NOEXCEPT_RETURN
 
 #endif // _LIBCPP_STD_VER > 14
 
 #endif // !defined(_LIBCPP_CXX03_LANG)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_TUPLE
Index: vendor/libc++/dist/include/variant
===================================================================
--- vendor/libc++/dist/include/variant	(revision 319785)
+++ vendor/libc++/dist/include/variant	(revision 319786)
@@ -1,1567 +1,1562 @@
 // -*- 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>
   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...>>;
 
   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>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 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>
 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));
   using type = __type_pack_element<_Ip, _Types...>;
 };
 
 constexpr size_t variant_npos = static_cast<size_t>(-1);
 constexpr unsigned int __variant_npos = static_cast<unsigned int>(-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,
-       __move_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)>;
     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);
     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()>{}...);
   }
 };
 
 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_callable_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:
   inline _LIBCPP_INLINE_VISIBILITY
   explicit constexpr __base(__valueless_t tag) noexcept
       : __data(tag), __index(__variant_npos) {}
 
   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 ? 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;
   unsigned int __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...>;                 \
                                                                                \
   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; });
 
 _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)>;
               __alt.~__alt_type();
             },
             *this);
       }
       this->__index = __variant_npos;
     });
 
 _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 <bool _CopyAssign, size_t _Ip, class _Tp, class _Arg>
+  template <size_t _Ip, class _Tp, class _Arg>
   inline _LIBCPP_INLINE_VISIBILITY
-  void __assign_alt(__alt<_Ip, _Tp>& __a,
-                    _Arg&& __arg,
-                    bool_constant<_CopyAssign> __tag) {
+  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>(_Tp(_VSTD::forward<_Arg>(__arg)));
+          __this->__emplace<_Ip>(_VSTD::forward<_Arg>(__arg));
         }
         void operator()(false_type) const {
-          __this->__emplace<_Ip>(_VSTD::forward<_Arg>(__arg));
+          __this->__emplace<_Ip>(_Tp(_VSTD::forward<_Arg>(__arg)));
         }
         __assignment* __this;
         _Arg&& __arg;
       } __impl{this, _VSTD::forward<_Arg>(__arg)};
-      __impl(__tag);
+      __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,
-                is_lvalue_reference<_That>{});
+                _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),
-                       false_type{});
+                       _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_move_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,
       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,
       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 __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
 
 #endif  // _LIBCPP_VARIANT
Index: vendor/libc++/dist/test/libcxx/utilities/variant/variant.variant/variant.assign/move.pass.cpp
===================================================================
--- vendor/libc++/dist/test/libcxx/utilities/variant/variant.variant/variant.assign/move.pass.cpp	(revision 319785)
+++ vendor/libc++/dist/test/libcxx/utilities/variant/variant.variant/variant.assign/move.pass.cpp	(nonexistent)
@@ -1,197 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11, c++14
-
-// The following compilers don't generate constexpr special members correctly.
-// XFAIL: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// XFAIL: apple-clang-6, apple-clang-7, apple-clang-8.0
-
-// <variant>
-
-// template <class ...Types> class variant;
-
-// variant& operator=(variant&&) noexcept(see below);
-
-#include <type_traits>
-#include <variant>
-
-#include "test_macros.h"
-
-struct NTMoveAssign {
-  constexpr NTMoveAssign(int v) : value(v) {}
-  NTMoveAssign(const NTMoveAssign &) = default;
-  NTMoveAssign(NTMoveAssign &&) = default;
-  NTMoveAssign &operator=(const NTMoveAssign &that) = default;
-  NTMoveAssign &operator=(NTMoveAssign &&that) {
-    value = that.value;
-    that.value = -1;
-    return *this;
-  };
-  int value;
-};
-
-static_assert(!std::is_trivially_move_assignable<NTMoveAssign>::value, "");
-static_assert(std::is_move_assignable<NTMoveAssign>::value, "");
-
-struct TMoveAssign {
-  constexpr TMoveAssign(int v) : value(v) {}
-  TMoveAssign(const TMoveAssign &) = delete;
-  TMoveAssign(TMoveAssign &&) = default;
-  TMoveAssign &operator=(const TMoveAssign &) = delete;
-  TMoveAssign &operator=(TMoveAssign &&) = default;
-  int value;
-};
-
-static_assert(std::is_trivially_move_assignable<TMoveAssign>::value, "");
-
-struct TMoveAssignNTCopyAssign {
-  constexpr TMoveAssignNTCopyAssign(int v) : value(v) {}
-  TMoveAssignNTCopyAssign(const TMoveAssignNTCopyAssign &) = default;
-  TMoveAssignNTCopyAssign(TMoveAssignNTCopyAssign &&) = default;
-  TMoveAssignNTCopyAssign &operator=(const TMoveAssignNTCopyAssign &that) {
-    value = that.value;
-    return *this;
-  }
-  TMoveAssignNTCopyAssign &operator=(TMoveAssignNTCopyAssign &&) = default;
-  int value;
-};
-
-static_assert(std::is_trivially_move_assignable_v<TMoveAssignNTCopyAssign>, "");
-
-void test_move_assignment_sfinae() {
-  {
-    using V = std::variant<int, long>;
-    static_assert(std::is_trivially_move_assignable<V>::value, "");
-  }
-  {
-    using V = std::variant<int, NTMoveAssign>;
-    static_assert(!std::is_trivially_move_assignable<V>::value, "");
-    static_assert(std::is_move_assignable<V>::value, "");
-  }
-  {
-    using V = std::variant<int, TMoveAssign>;
-    static_assert(std::is_trivially_move_assignable<V>::value, "");
-  }
-  {
-    using V = std::variant<int, TMoveAssignNTCopyAssign>;
-    static_assert(std::is_trivially_move_assignable<V>::value, "");
-  }
-}
-
-template <typename T> struct Result { size_t index; T value; };
-
-void test_move_assignment_same_index() {
-  {
-    struct {
-      constexpr Result<int> operator()() const {
-        using V = std::variant<int>;
-        V v(43);
-        V v2(42);
-        v = std::move(v2);
-        return {v.index(), std::get<0>(v)};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 0, "");
-    static_assert(result.value == 42, "");
-  }
-  {
-    struct {
-      constexpr Result<long> operator()() const {
-        using V = std::variant<int, long, unsigned>;
-        V v(43l);
-        V v2(42l);
-        v = std::move(v2);
-        return {v.index(), std::get<1>(v)};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 1, "");
-    static_assert(result.value == 42l, "");
-  }
-  {
-    struct {
-      constexpr Result<int> operator()() const {
-        using V = std::variant<int, TMoveAssign, unsigned>;
-        V v(std::in_place_type<TMoveAssign>, 43);
-        V v2(std::in_place_type<TMoveAssign>, 42);
-        v = std::move(v2);
-        return {v.index(), std::get<1>(v).value};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 1, "");
-    static_assert(result.value == 42, "");
-  }
-}
-
-void test_move_assignment_different_index() {
-  {
-    struct {
-      constexpr Result<long> operator()() const {
-        using V = std::variant<int, long, unsigned>;
-        V v(43);
-        V v2(42l);
-        v = std::move(v2);
-        return {v.index(), std::get<1>(v)};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 1, "");
-    static_assert(result.value == 42l, "");
-  }
-  {
-    struct {
-      constexpr Result<long> operator()() const {
-        using V = std::variant<int, TMoveAssign, unsigned>;
-        V v(std::in_place_type<unsigned>, 43);
-        V v2(std::in_place_type<TMoveAssign>, 42);
-        v = std::move(v2);
-        return {v.index(), std::get<1>(v).value};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 1, "");
-    static_assert(result.value == 42, "");
-  }
-}
-
-
-template <size_t NewIdx, class ValueType>
-constexpr bool test_constexpr_assign_extension_imp(
-    std::variant<long, void*, int>&& v, ValueType&& new_value)
-{
-  std::variant<long, void*, int> v2(
-      std::forward<ValueType>(new_value));
-  const auto cp = v2;
-  v = std::move(v2);
-  return v.index() == NewIdx &&
-        std::get<NewIdx>(v) == std::get<NewIdx>(cp);
-}
-
-void test_constexpr_move_assignment_extension() {
-#ifdef _LIBCPP_VERSION
-  using V = std::variant<long, void*, int>;
-  static_assert(std::is_trivially_copyable<V>::value, "");
-  static_assert(std::is_trivially_move_assignable<V>::value, "");
-  static_assert(test_constexpr_assign_extension_imp<0>(V(42l), 101l), "");
-  static_assert(test_constexpr_assign_extension_imp<0>(V(nullptr), 101l), "");
-  static_assert(test_constexpr_assign_extension_imp<1>(V(42l), nullptr), "");
-  static_assert(test_constexpr_assign_extension_imp<2>(V(42l), 101), "");
-#endif
-}
-
-int main() {
-  test_move_assignment_same_index();
-  test_move_assignment_different_index();
-  test_move_assignment_sfinae();
-  test_constexpr_move_assignment_extension();
-}

Property changes on: vendor/libc++/dist/test/libcxx/utilities/variant/variant.variant/variant.assign/move.pass.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: vendor/libc++/dist/test/libcxx/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
===================================================================
--- vendor/libc++/dist/test/libcxx/utilities/variant/variant.variant/variant.assign/copy.pass.cpp	(revision 319785)
+++ vendor/libc++/dist/test/libcxx/utilities/variant/variant.variant/variant.assign/copy.pass.cpp	(nonexistent)
@@ -1,209 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11, c++14
-
-// The following compilers don't generate constexpr special members correctly.
-// XFAIL: clang-3.5, clang-3.6, clang-3.7, clang-3.8
-// XFAIL: apple-clang-6, apple-clang-7, apple-clang-8.0
-
-// <variant>
-
-// template <class ...Types> class variant;
-
-// variant& operator=(variant const&);
-
-#include <type_traits>
-#include <variant>
-
-#include "test_macros.h"
-
-struct NTCopyAssign {
-  constexpr NTCopyAssign(int v) : value(v) {}
-  NTCopyAssign(const NTCopyAssign &) = default;
-  NTCopyAssign(NTCopyAssign &&) = default;
-  NTCopyAssign &operator=(const NTCopyAssign &that) {
-    value = that.value;
-    return *this;
-  };
-  NTCopyAssign &operator=(NTCopyAssign &&) = delete;
-  int value;
-};
-
-static_assert(!std::is_trivially_copy_assignable<NTCopyAssign>::value, "");
-static_assert(std::is_copy_assignable<NTCopyAssign>::value, "");
-
-struct TCopyAssign {
-  constexpr TCopyAssign(int v) : value(v) {}
-  TCopyAssign(const TCopyAssign &) = default;
-  TCopyAssign(TCopyAssign &&) = default;
-  TCopyAssign &operator=(const TCopyAssign &) = default;
-  TCopyAssign &operator=(TCopyAssign &&) = delete;
-  int value;
-};
-
-static_assert(std::is_trivially_copy_assignable<TCopyAssign>::value, "");
-
-struct TCopyAssignNTMoveAssign {
-  constexpr TCopyAssignNTMoveAssign(int v) : value(v) {}
-  TCopyAssignNTMoveAssign(const TCopyAssignNTMoveAssign &) = default;
-  TCopyAssignNTMoveAssign(TCopyAssignNTMoveAssign &&) = default;
-  TCopyAssignNTMoveAssign &operator=(const TCopyAssignNTMoveAssign &) = default;
-  TCopyAssignNTMoveAssign &operator=(TCopyAssignNTMoveAssign &&that) {
-    value = that.value;
-    that.value = -1;
-    return *this;
-  }
-  int value;
-};
-
-static_assert(std::is_trivially_copy_assignable_v<TCopyAssignNTMoveAssign>, "");
-
-void test_copy_assignment_sfinae() {
-  {
-    using V = std::variant<int, long>;
-    static_assert(std::is_trivially_copy_assignable<V>::value, "");
-  }
-  {
-    using V = std::variant<int, NTCopyAssign>;
-    static_assert(!std::is_trivially_copy_assignable<V>::value, "");
-    static_assert(std::is_copy_assignable<V>::value, "");
-  }
-  {
-    using V = std::variant<int, TCopyAssign>;
-    static_assert(std::is_trivially_copy_assignable<V>::value, "");
-  }
-  {
-    using V = std::variant<int, TCopyAssignNTMoveAssign>;
-    static_assert(std::is_trivially_copy_assignable<V>::value, "");
-  }
-}
-
-template <typename T> struct Result { size_t index; T value; };
-
-void test_copy_assignment_same_index() {
-  {
-    struct {
-      constexpr Result<int> operator()() const {
-        using V = std::variant<int>;
-        V v(43);
-        V v2(42);
-        v = v2;
-        return {v.index(), std::get<0>(v)};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 0, "");
-    static_assert(result.value == 42, "");
-  }
-  {
-    struct {
-      constexpr Result<long> operator()() const {
-        using V = std::variant<int, long, unsigned>;
-        V v(43l);
-        V v2(42l);
-        v = v2;
-        return {v.index(), std::get<1>(v)};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 1, "");
-    static_assert(result.value == 42l, "");
-  }
-  {
-    struct {
-      constexpr Result<int> operator()() const {
-        using V = std::variant<int, TCopyAssign, unsigned>;
-        V v(std::in_place_type<TCopyAssign>, 43);
-        V v2(std::in_place_type<TCopyAssign>, 42);
-        v = v2;
-        return {v.index(), std::get<1>(v).value};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 1, "");
-    static_assert(result.value == 42, "");
-  }
-  {
-    struct {
-      constexpr Result<int> operator()() const {
-        using V = std::variant<int, TCopyAssignNTMoveAssign, unsigned>;
-        V v(std::in_place_type<TCopyAssignNTMoveAssign>, 43);
-        V v2(std::in_place_type<TCopyAssignNTMoveAssign>, 42);
-        v = v2;
-        return {v.index(), std::get<1>(v).value};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 1, "");
-    static_assert(result.value == 42, "");
-  }
-}
-
-void test_copy_assignment_different_index() {
-  {
-    struct {
-      constexpr Result<long> operator()() const {
-        using V = std::variant<int, long, unsigned>;
-        V v(43);
-        V v2(42l);
-        v = v2;
-        return {v.index(), std::get<1>(v)};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 1, "");
-    static_assert(result.value == 42l, "");
-  }
-  {
-    struct {
-      constexpr Result<int> operator()() const {
-        using V = std::variant<int, TCopyAssign, unsigned>;
-        V v(std::in_place_type<unsigned>, 43);
-        V v2(std::in_place_type<TCopyAssign>, 42);
-        v = v2;
-        return {v.index(), std::get<1>(v).value};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 1, "");
-    static_assert(result.value == 42, "");
-  }
-}
-
-template <size_t NewIdx, class ValueType>
-constexpr bool test_constexpr_assign_extension_imp(
-    std::variant<long, void*, int>&& v, ValueType&& new_value)
-{
-  const std::variant<long, void*, int> cp(
-      std::forward<ValueType>(new_value));
-  v = cp;
-  return v.index() == NewIdx &&
-        std::get<NewIdx>(v) == std::get<NewIdx>(cp);
-}
-
-void test_constexpr_copy_assignment_extension() {
-#ifdef _LIBCPP_VERSION
-  using V = std::variant<long, void*, int>;
-  static_assert(std::is_trivially_copyable<V>::value, "");
-  static_assert(std::is_trivially_copy_assignable<V>::value, "");
-  static_assert(test_constexpr_assign_extension_imp<0>(V(42l), 101l), "");
-  static_assert(test_constexpr_assign_extension_imp<0>(V(nullptr), 101l), "");
-  static_assert(test_constexpr_assign_extension_imp<1>(V(42l), nullptr), "");
-  static_assert(test_constexpr_assign_extension_imp<2>(V(42l), 101), "");
-#endif
-}
-
-int main() {
-  test_copy_assignment_same_index();
-  test_copy_assignment_different_index();
-  test_copy_assignment_sfinae();
-  test_constexpr_copy_assignment_extension();
-}

Property changes on: vendor/libc++/dist/test/libcxx/utilities/variant/variant.variant/variant.assign/copy.pass.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: vendor/libc++/dist/test/libcxx/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
===================================================================
--- vendor/libc++/dist/test/libcxx/utilities/variant/variant.variant/variant.ctor/move.pass.cpp	(revision 319785)
+++ vendor/libc++/dist/test/libcxx/utilities/variant/variant.variant/variant.ctor/move.pass.cpp	(nonexistent)
@@ -1,153 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11, c++14
-
-// <variant>
-
-// template <class ...Types> class variant;
-
-// variant(variant&&) noexcept(see below);
-
-#include <type_traits>
-#include <variant>
-
-#include "test_macros.h"
-
-struct NTMove {
-  constexpr NTMove(int v) : value(v) {}
-  NTMove(const NTMove &) = delete;
-  NTMove(NTMove &&that) : value(that.value) { that.value = -1; }
-  int value;
-};
-
-static_assert(!std::is_trivially_move_constructible<NTMove>::value, "");
-static_assert(std::is_move_constructible<NTMove>::value, "");
-
-struct TMove {
-  constexpr TMove(int v) : value(v) {}
-  TMove(const TMove &) = delete;
-  TMove(TMove &&) = default;
-  int value;
-};
-
-static_assert(std::is_trivially_move_constructible<TMove>::value, "");
-
-struct TMoveNTCopy {
-  constexpr TMoveNTCopy(int v) : value(v) {}
-  TMoveNTCopy(const TMoveNTCopy& that) : value(that.value) {}
-  TMoveNTCopy(TMoveNTCopy&&) = default;
-  int value;
-};
-
-static_assert(std::is_trivially_move_constructible<TMoveNTCopy>::value, "");
-
-void test_move_ctor_sfinae() {
-  {
-    using V = std::variant<int, long>;
-    static_assert(std::is_trivially_move_constructible<V>::value, "");
-  }
-  {
-    using V = std::variant<int, NTMove>;
-    static_assert(!std::is_trivially_move_constructible<V>::value, "");
-    static_assert(std::is_move_constructible<V>::value, "");
-  }
-  {
-    using V = std::variant<int, TMove>;
-    static_assert(std::is_trivially_move_constructible<V>::value, "");
-  }
-  {
-    using V = std::variant<int, TMoveNTCopy>;
-    static_assert(std::is_trivially_move_constructible<V>::value, "");
-  }
-}
-
-template <typename T>
-struct Result { size_t index; T value; };
-
-void test_move_ctor_basic() {
-  {
-    struct {
-      constexpr Result<int> operator()() const {
-        std::variant<int> v(std::in_place_index<0>, 42);
-        std::variant<int> v2 = std::move(v);
-        return {v2.index(), std::get<0>(std::move(v2))};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 0, "");
-    static_assert(result.value == 42, "");
-  }
-  {
-    struct {
-      constexpr Result<long> operator()() const {
-        std::variant<int, long> v(std::in_place_index<1>, 42);
-        std::variant<int, long> v2 = std::move(v);
-        return {v2.index(), std::get<1>(std::move(v2))};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 1, "");
-    static_assert(result.value == 42, "");
-  }
-  {
-    struct {
-      constexpr Result<TMove> operator()() const {
-        std::variant<TMove> v(std::in_place_index<0>, 42);
-        std::variant<TMove> v2(std::move(v));
-        return {v2.index(), std::get<0>(std::move(v2))};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 0, "");
-    static_assert(result.value.value == 42, "");
-  }
-  {
-    struct {
-      constexpr Result<TMove> operator()() const {
-        std::variant<int, TMove> v(std::in_place_index<1>, 42);
-        std::variant<int, TMove> v2(std::move(v));
-        return {v2.index(), std::get<1>(std::move(v2))};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 1, "");
-    static_assert(result.value.value == 42, "");
-  }
-  {
-    struct {
-      constexpr Result<TMoveNTCopy> operator()() const {
-        std::variant<TMoveNTCopy> v(std::in_place_index<0>, 42);
-        std::variant<TMoveNTCopy> v2(std::move(v));
-        return {v2.index(), std::get<0>(std::move(v2))};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 0, "");
-    static_assert(result.value.value == 42, "");
-  }
-  {
-    struct {
-      constexpr Result<TMoveNTCopy> operator()() const {
-        std::variant<int, TMoveNTCopy> v(std::in_place_index<1>, 42);
-        std::variant<int, TMoveNTCopy> v2(std::move(v));
-        return {v2.index(), std::get<1>(std::move(v2))};
-      }
-    } test;
-    constexpr auto result = test();
-    static_assert(result.index == 1, "");
-    static_assert(result.value.value == 42, "");
-  }
-}
-
-int main() {
-  test_move_ctor_basic();
-  test_move_ctor_sfinae();
-}

Property changes on: vendor/libc++/dist/test/libcxx/utilities/variant/variant.variant/variant.ctor/move.pass.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: vendor/libc++/dist/test/libcxx/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
===================================================================
--- vendor/libc++/dist/test/libcxx/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp	(revision 319785)
+++ vendor/libc++/dist/test/libcxx/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp	(nonexistent)
@@ -1,120 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11, c++14
-
-// <variant>
-
-// template <class ...Types> class variant;
-
-// variant(variant const&);
-
-#include <type_traits>
-#include <variant>
-
-#include "test_macros.h"
-
-struct NTCopy {
-  constexpr NTCopy(int v) : value(v) {}
-  NTCopy(const NTCopy &that) : value(that.value) {}
-  NTCopy(NTCopy &&) = delete;
-  int value;
-};
-
-static_assert(!std::is_trivially_copy_constructible<NTCopy>::value, "");
-static_assert(std::is_copy_constructible<NTCopy>::value, "");
-
-struct TCopy {
-  constexpr TCopy(int v) : value(v) {}
-  TCopy(TCopy const &) = default;
-  TCopy(TCopy &&) = delete;
-  int value;
-};
-
-static_assert(std::is_trivially_copy_constructible<TCopy>::value, "");
-
-struct TCopyNTMove {
-  constexpr TCopyNTMove(int v) : value(v) {}
-  TCopyNTMove(const TCopyNTMove&) = default;
-  TCopyNTMove(TCopyNTMove&& that) : value(that.value) { that.value = -1; }
-  int value;
-};
-
-static_assert(std::is_trivially_copy_constructible<TCopyNTMove>::value, "");
-
-void test_copy_ctor_sfinae() {
-  {
-    using V = std::variant<int, long>;
-    static_assert(std::is_trivially_copy_constructible<V>::value, "");
-  }
-  {
-    using V = std::variant<int, NTCopy>;
-    static_assert(!std::is_trivially_copy_constructible<V>::value, "");
-    static_assert(std::is_copy_constructible<V>::value, "");
-  }
-  {
-    using V = std::variant<int, TCopy>;
-    static_assert(std::is_trivially_copy_constructible<V>::value, "");
-  }
-  {
-    using V = std::variant<int, TCopyNTMove>;
-    static_assert(std::is_trivially_copy_constructible<V>::value, "");
-  }
-}
-
-void test_copy_ctor_basic() {
-  {
-    constexpr std::variant<int> v(std::in_place_index<0>, 42);
-    static_assert(v.index() == 0, "");
-    constexpr std::variant<int> v2 = v;
-    static_assert(v2.index() == 0, "");
-    static_assert(std::get<0>(v2) == 42, "");
-  }
-  {
-    constexpr std::variant<int, long> v(std::in_place_index<1>, 42);
-    static_assert(v.index() == 1, "");
-    constexpr std::variant<int, long> v2 = v;
-    static_assert(v2.index() == 1, "");
-    static_assert(std::get<1>(v2) == 42, "");
-  }
-  {
-    constexpr std::variant<TCopy> v(std::in_place_index<0>, 42);
-    static_assert(v.index() == 0, "");
-    constexpr std::variant<TCopy> v2(v);
-    static_assert(v2.index() == 0, "");
-    static_assert(std::get<0>(v2).value == 42, "");
-  }
-  {
-    constexpr std::variant<int, TCopy> v(std::in_place_index<1>, 42);
-    static_assert(v.index() == 1, "");
-    constexpr std::variant<int, TCopy> v2(v);
-    static_assert(v2.index() == 1, "");
-    static_assert(std::get<1>(v2).value == 42, "");
-  }
-  {
-    constexpr std::variant<TCopyNTMove> v(std::in_place_index<0>, 42);
-    static_assert(v.index() == 0, "");
-    constexpr std::variant<TCopyNTMove> v2(v);
-    static_assert(v2.index() == 0, "");
-    static_assert(std::get<0>(v2).value == 42, "");
-  }
-  {
-    constexpr std::variant<int, TCopyNTMove> v(std::in_place_index<1>, 42);
-    static_assert(v.index() == 1, "");
-    constexpr std::variant<int, TCopyNTMove> v2(v);
-    static_assert(v2.index() == 1, "");
-    static_assert(std::get<1>(v2).value == 42, "");
-  }
-}
-
-int main() {
-  test_copy_ctor_basic();
-  test_copy_ctor_sfinae();
-}

Property changes on: vendor/libc++/dist/test/libcxx/utilities/variant/variant.variant/variant.ctor/copy.pass.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: vendor/libc++/dist/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char.pass.cpp
===================================================================
--- vendor/libc++/dist/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char.pass.cpp	(revision 319785)
+++ vendor/libc++/dist/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char.pass.cpp	(revision 319786)
@@ -1,70 +1,72 @@
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt_byname<char, char, mbstate_t>
 
 // explicit codecvt_byname(const char* nm, size_t refs = 0);
 // explicit codecvt_byname(const string& nm, size_t refs = 0);
 
 #include <locale>
 #include <cassert>
 
+#include "platform_support.h"
+
 typedef std::codecvt_byname<char, char, std::mbstate_t> F;
 
 class my_facet
     : public F
 {
 public:
     static int count;
 
     explicit my_facet(const char* nm, std::size_t refs = 0)
         : F(nm, refs) {++count;}
     explicit my_facet(const std::string& nm, std::size_t refs = 0)
         : F(nm, refs) {++count;}
 
     ~my_facet() {--count;}
 };
 
 int my_facet::count = 0;
 
 int main()
 {
     {
-        std::locale l(std::locale::classic(), new my_facet("en_US"));
+        std::locale l(std::locale::classic(), new my_facet(LOCALE_en_US));
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
     {
-        my_facet f("en_US", 1);
+        my_facet f(LOCALE_en_US, 1);
         assert(my_facet::count == 1);
         {
             std::locale l(std::locale::classic(), &f);
             assert(my_facet::count == 1);
         }
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
     {
-        std::locale l(std::locale::classic(), new my_facet(std::string("en_US")));
+        std::locale l(std::locale::classic(), new my_facet(std::string(LOCALE_en_US)));
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
     {
-        my_facet f(std::string("en_US"), 1);
+        my_facet f(std::string(LOCALE_en_US), 1);
         assert(my_facet::count == 1);
         {
             std::locale l(std::locale::classic(), &f);
             assert(my_facet::count == 1);
         }
         assert(my_facet::count == 1);
     }
     assert(my_facet::count == 0);
 }
Index: vendor/libc++/dist/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_iter_iter_iter.pass.cpp
===================================================================
--- vendor/libc++/dist/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_iter_iter_iter.pass.cpp	(nonexistent)
+++ vendor/libc++/dist/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_iter_iter_iter.pass.cpp	(revision 319786)
@@ -0,0 +1,97 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <numeric>
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// template<class InputIterator, class OutputIterator, class T>
+//     OutputIterator exclusive_scan(InputIterator first, InputIterator last,
+//                                   OutputIterator result, T init);
+// 
+
+#include <numeric>
+#include <vector>
+#include <cassert>
+
+#include "test_iterators.h"
+
+template <class Iter1, class T, class Iter2>
+void
+test(Iter1 first, Iter1 last, T init, Iter2 rFirst, Iter2 rLast)
+{
+    std::vector<typename std::iterator_traits<Iter1>::value_type> v;
+    
+//  Not in place
+    std::exclusive_scan(first, last, std::back_inserter(v), init);
+    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+
+//  In place
+    v.clear();
+    v.assign(first, last);
+    std::exclusive_scan(v.begin(), v.end(), v.begin(), init);
+    assert(std::equal(v.begin(), v.end(), rFirst, rLast));  
+}
+
+
+template <class Iter>
+void
+test()
+{
+          int ia[]   = {1, 3, 5, 7,  9};
+    const int pRes[] = {0, 1, 4, 9, 16};
+    const unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    static_assert(sa == sizeof(pRes) / sizeof(pRes[0]));       // just to be sure
+
+    for (unsigned int i = 0; i < sa; ++i )
+        test(Iter(ia), Iter(ia + i), 0, pRes, pRes + i);
+}
+
+int triangle(int n) { return n*(n+1)/2; }
+
+//  Basic sanity
+void basic_tests()
+{
+    {
+    std::vector<int> v(10);
+    std::fill(v.begin(), v.end(), 3);
+    std::exclusive_scan(v.begin(), v.end(), v.begin(), 50);
+    for (size_t i = 0; i < v.size(); ++i)
+        assert(v[i] == 50 + (int) i * 3);
+    }
+
+    {
+    std::vector<int> v(10);
+    std::iota(v.begin(), v.end(), 0);
+    std::exclusive_scan(v.begin(), v.end(), v.begin(), 30);
+    for (size_t i = 0; i < v.size(); ++i)
+        assert(v[i] == 30 + triangle(i-1));
+    }
+
+    {
+    std::vector<int> v(10);
+    std::iota(v.begin(), v.end(), 1);
+    std::exclusive_scan(v.begin(), v.end(), v.begin(), 40);
+    for (size_t i = 0; i < v.size(); ++i)
+        assert(v[i] == 40 + triangle(i));
+    }
+
+}
+
+int main()
+{
+    basic_tests();
+
+//  All the iterator categories
+    test<input_iterator        <const int*> >();
+    test<forward_iterator      <const int*> >();
+    test<bidirectional_iterator<const int*> >();
+    test<random_access_iterator<const int*> >();
+    test<const int*>();
+    test<      int*>();
+}

Property changes on: vendor/libc++/dist/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_iter_iter_iter.pass.cpp
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: vendor/libc++/dist/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_iter_iter_iter_init_op.pass.cpp
===================================================================
--- vendor/libc++/dist/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_iter_iter_iter_init_op.pass.cpp	(nonexistent)
+++ vendor/libc++/dist/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_iter_iter_iter_init_op.pass.cpp	(revision 319786)
@@ -0,0 +1,87 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <numeric>
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
+//     OutputIterator
+//     exclusive_scan(InputIterator first, InputIterator last,
+//                    OutputIterator result, 
+//                    T init, BinaryOperation binary_op); // C++17
+
+#include <numeric>
+#include <vector>
+#include <cassert>
+
+#include "test_iterators.h"
+
+template <class Iter1, class T, class Op, class Iter2>
+void
+test(Iter1 first, Iter1 last, T init, Op op, Iter2 rFirst, Iter2 rLast)
+{
+    std::vector<typename std::iterator_traits<Iter1>::value_type> v;
+
+//  Not in place
+    std::exclusive_scan(first, last, std::back_inserter(v), init, op);
+    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+
+//  In place
+    v.clear();
+    v.assign(first, last);
+    std::exclusive_scan(v.begin(), v.end(), v.begin(), init, op);
+    assert(std::equal(v.begin(), v.end(), rFirst, rLast));  
+}
+
+
+template <class Iter>
+void
+test()
+{
+          int ia[]   = {1, 3, 5,  7,   9};
+    const int pRes[] = {0, 1, 4,  9,  16};
+    const int mRes[] = {1, 1, 3, 15, 105};
+    const unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    static_assert(sa == sizeof(pRes) / sizeof(pRes[0]));       // just to be sure
+    static_assert(sa == sizeof(mRes) / sizeof(mRes[0]));       // just to be sure
+
+    for (unsigned int i = 0; i < sa; ++i ) {
+        test(Iter(ia), Iter(ia + i), 0, std::plus<>(),       pRes, pRes + i);
+        test(Iter(ia), Iter(ia + i), 1, std::multiplies<>(), mRes, mRes + i);
+        }
+}
+
+int main()
+{
+//  All the iterator categories
+    test<input_iterator        <const int*> >();
+    test<forward_iterator      <const int*> >();
+    test<bidirectional_iterator<const int*> >();
+    test<random_access_iterator<const int*> >();
+    test<const int*>();
+    test<      int*>();
+
+//  Make sure that the calculations are done using the init typedef
+    {
+    std::vector<unsigned char> v(10);
+    std::iota(v.begin(), v.end(), 1);
+    std::vector<int> res;
+    std::exclusive_scan(v.begin(), v.end(), std::back_inserter(res), 1, std::multiplies<>());
+
+    assert(res.size() == 10);
+    int j = 1;
+    assert(res[0] == 1);
+    for (size_t i = 1; i < v.size(); ++i)
+    {
+        j *= i;
+        assert(res[i] == j);
+    }
+    }
+}
+ 
\ No newline at end of file

Property changes on: vendor/libc++/dist/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_iter_iter_iter_init_op.pass.cpp
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: vendor/libc++/dist/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_iter_iter_iter_init_bop_uop.pass.cpp
===================================================================
--- vendor/libc++/dist/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_iter_iter_iter_init_bop_uop.pass.cpp	(nonexistent)
+++ vendor/libc++/dist/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_iter_iter_iter_init_bop_uop.pass.cpp	(revision 319786)
@@ -0,0 +1,154 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <numeric>
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// 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);
+
+
+#include <numeric>
+#include <vector>
+#include <cassert>
+#include <iostream>
+
+#include "test_iterators.h"
+
+template <class _Tp = void>
+struct identity : std::unary_function<_Tp, _Tp>
+{
+    constexpr const _Tp& operator()(const _Tp& __x) const { return __x;}
+};
+
+template <>
+struct identity<void>
+{
+    template <class _Tp>
+    constexpr auto operator()(_Tp&& __x) const
+    _NOEXCEPT_(noexcept(_VSTD::forward<_Tp>(__x)))
+    -> decltype        (_VSTD::forward<_Tp>(__x))
+        { return        _VSTD::forward<_Tp>(__x); }
+};
+
+template <class Iter1, class BOp, class UOp, class T, class Iter2>
+void
+test(Iter1 first, Iter1 last, BOp bop, UOp uop, T init, Iter2 rFirst, Iter2 rLast)
+{
+    std::vector<typename std::iterator_traits<Iter1>::value_type> v;
+//  Test not in-place
+    std::transform_exclusive_scan(first, last, std::back_inserter(v), init, bop, uop);
+    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+
+//  Test in-place
+    v.clear();
+    v.assign(first, last);
+    std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), init, bop, uop);
+    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+}
+
+
+template <class Iter>
+void
+test()
+{
+          int ia[]     = { 1,  3,  5,   7,   9};
+    const int pResI0[] = { 0,  1,  4,   9,  16};        // with identity
+    const int mResI0[] = { 0,  0,  0,   0,   0};        
+    const int pResN0[] = { 0, -1, -4,  -9, -16};        // with negate
+    const int mResN0[] = { 0,  0,  0,   0,   0};
+    const int pResI2[] = { 2,  3,  6,  11,  18};        // with identity
+    const int mResI2[] = { 2,  2,  6,  30, 210};        
+    const int pResN2[] = { 2,  1, -2,  -7, -14};        // with negate
+    const int mResN2[] = { 2, -2,  6, -30, 210};
+    const unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    static_assert(sa == sizeof(pResI0) / sizeof(pResI0[0]));       // just to be sure
+    static_assert(sa == sizeof(mResI0) / sizeof(mResI0[0]));       // just to be sure
+    static_assert(sa == sizeof(pResN0) / sizeof(pResN0[0]));       // just to be sure
+    static_assert(sa == sizeof(mResN0) / sizeof(mResN0[0]));       // just to be sure
+    static_assert(sa == sizeof(pResI2) / sizeof(pResI2[0]));       // just to be sure
+    static_assert(sa == sizeof(mResI2) / sizeof(mResI2[0]));       // just to be sure
+    static_assert(sa == sizeof(pResN2) / sizeof(pResN2[0]));       // just to be sure
+    static_assert(sa == sizeof(mResN2) / sizeof(mResN2[0]));       // just to be sure
+
+    for (unsigned int i = 0; i < sa; ++i ) {
+        test(Iter(ia), Iter(ia + i), std::plus<>(),       identity<>(),    0, pResI0, pResI0 + i);
+        test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(),    0, mResI0, mResI0 + i);
+        test(Iter(ia), Iter(ia + i), std::plus<>(),       std::negate<>(), 0, pResN0, pResN0 + i);
+        test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 0, mResN0, mResN0 + i);
+        test(Iter(ia), Iter(ia + i), std::plus<>(),       identity<>(),    2, pResI2, pResI2 + i);
+        test(Iter(ia), Iter(ia + i), std::multiplies<>(), identity<>(),    2, mResI2, mResI2 + i);
+        test(Iter(ia), Iter(ia + i), std::plus<>(),       std::negate<>(), 2, pResN2, pResN2 + i);
+        test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 2, mResN2, mResN2 + i);
+        }
+}
+
+int triangle(int n) { return n*(n+1)/2; }
+
+//  Basic sanity
+void basic_tests()
+{
+    {
+    std::vector<int> v(10);
+    std::fill(v.begin(), v.end(), 3);
+    std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 50, std::plus<>(), identity<>());
+    for (size_t i = 0; i < v.size(); ++i)
+        assert(v[i] == 50 + (int) i * 3);
+    }
+
+    {
+    std::vector<int> v(10);
+    std::iota(v.begin(), v.end(), 0);
+    std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 30, std::plus<>(), identity<>());
+    for (size_t i = 0; i < v.size(); ++i)
+        assert(v[i] == 30 + triangle(i-1));
+    }
+
+    {
+    std::vector<int> v(10);
+    std::iota(v.begin(), v.end(), 1);
+    std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 40, std::plus<>(), identity<>());
+    for (size_t i = 0; i < v.size(); ++i)
+        assert(v[i] == 40 + triangle(i));
+    }
+
+//  Make sure that the calculations are done using the init typedef
+    {
+    std::vector<unsigned char> v(10);
+    std::iota(v.begin(), v.end(), 1);
+    std::vector<int> res;
+    std::transform_exclusive_scan(v.begin(), v.end(), std::back_inserter(res), 1, std::multiplies<>(), identity<>());
+
+    assert(res.size() == 10);
+    int j = 1;
+    assert(res[0] == 1);
+    for (size_t i = 1; i < res.size(); ++i)
+    {
+        j *= i;
+        assert(res[i] == j);
+    }
+    }
+}
+
+int main()
+{
+    basic_tests();
+    
+//  All the iterator categories
+    test<input_iterator        <const int*> >();
+    test<forward_iterator      <const int*> >();
+    test<bidirectional_iterator<const int*> >();
+    test<random_access_iterator<const int*> >();
+    test<const int*>();
+    test<      int*>();
+}

Property changes on: vendor/libc++/dist/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_iter_iter_iter_init_bop_uop.pass.cpp
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: vendor/libc++/dist/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/default.pass.cpp
===================================================================
--- vendor/libc++/dist/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/default.pass.cpp	(revision 319785)
+++ vendor/libc++/dist/test/std/thread/thread.mutex/thread.mutex.requirements/thread.mutex.requirements.mutex/thread.mutex.class/default.pass.cpp	(revision 319786)
@@ -1,23 +1,25 @@
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <mutex>
 
 // class mutex;
 
 // mutex();
 
 #include <mutex>
+#include <type_traits>
 
 int main()
 {
+    static_assert(std::is_nothrow_default_constructible<std::mutex>::value, "");
     std::mutex m;
 }
Index: vendor/libc++/dist/test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp
===================================================================
--- vendor/libc++/dist/test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp	(revision 319785)
+++ vendor/libc++/dist/test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp	(revision 319786)
@@ -1,61 +1,59 @@
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // <optional>
 
 // void reset() noexcept;
 
 #include <optional>
 #include <type_traits>
 #include <cassert>
 
 using std::optional;
 
 struct X
 {
     static bool dtor_called;
     ~X() {dtor_called = true;}
 };
 
 bool X::dtor_called = false;
 
 int main()
 {
     {
         optional<int> opt;
         static_assert(noexcept(opt.reset()) == true, "");
         opt.reset();
         assert(static_cast<bool>(opt) == false);
     }
     {
         optional<int> opt(3);
         opt.reset();
         assert(static_cast<bool>(opt) == false);
     }
     {
         optional<X> opt;
         static_assert(noexcept(opt.reset()) == true, "");
         assert(X::dtor_called == false);
         opt.reset();
         assert(X::dtor_called == false);
         assert(static_cast<bool>(opt) == false);
     }
-    assert(X::dtor_called == false); // TRANSITION, Clang/C2 VSO#239997
     {
         optional<X> opt(X{});
         X::dtor_called = false;
         opt.reset();
         assert(X::dtor_called == true);
         assert(static_cast<bool>(opt) == false);
         X::dtor_called = false;
     }
-    assert(X::dtor_called == false); // TRANSITION, Clang/C2 VSO#239997
 }
Index: vendor/libc++/dist/test/std/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp
===================================================================
--- vendor/libc++/dist/test/std/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp	(revision 319785)
+++ vendor/libc++/dist/test/std/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp	(revision 319786)
@@ -1,68 +1,74 @@
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // <optional>
 
-// template <class U> T optional<T>::value_or(U&& v) &&;
+// template <class U> constexpr T optional<T>::value_or(U&& v) &&;
 
 #include <optional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 using std::optional;
 using std::in_place_t;
 using std::in_place;
 
 struct Y
 {
     int i_;
 
-    Y(int i) : i_(i) {}
+    constexpr Y(int i) : i_(i) {}
 };
 
 struct X
 {
     int i_;
 
-    X(int i) : i_(i) {}
-    X(X&& x) : i_(x.i_) {x.i_ = 0;}
-    X(const Y& y) : i_(y.i_) {}
-    X(Y&& y) : i_(y.i_+1) {}
+    constexpr X(int i) : i_(i) {}
+    constexpr X(X&& x) : i_(x.i_) {x.i_ = 0;}
+    constexpr X(const Y& y) : i_(y.i_) {}
+    constexpr X(Y&& y) : i_(y.i_+1) {}
     friend constexpr bool operator==(const X& x, const X& y)
         {return x.i_ == y.i_;}
 };
 
-int main()
+constexpr int test()
 {
     {
         optional<X> opt(in_place, 2);
         Y y(3);
         assert(std::move(opt).value_or(y) == 2);
         assert(*opt == 0);
     }
     {
         optional<X> opt(in_place, 2);
         assert(std::move(opt).value_or(Y(3)) == 2);
         assert(*opt == 0);
     }
     {
         optional<X> opt;
         Y y(3);
         assert(std::move(opt).value_or(y) == 3);
         assert(!opt);
     }
     {
         optional<X> opt;
         assert(std::move(opt).value_or(Y(3)) == 4);
         assert(!opt);
     }
+    return 0;
+}
+
+int main()
+{
+    static_assert(test() == 0);
 }
Index: vendor/libc++/dist/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
===================================================================
--- vendor/libc++/dist/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp	(nonexistent)
+++ vendor/libc++/dist/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp	(revision 319786)
@@ -0,0 +1,155 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// UNSUPPORTED: libcpp-no-deduction-guides
+
+// GCC's implementation of class template deduction is still immature and runs
+// into issues with libc++. However GCC accepts this code when compiling
+// against libstdc++.
+// XFAIL: gcc
+
+// <string>
+
+// Test that the constructors offered by std::basic_string are formulated
+// so they're compatible with implicit deduction guides.
+
+#include <tuple>
+#include <memory>
+#include <cassert>
+
+#include "test_macros.h"
+#include "archetypes.hpp"
+
+
+// Overloads
+//  using A = Allocator
+//  using AT = std::allocator_arg_t
+// ---------------
+// (1)  tuple(const Types&...) -> tuple<Types...>
+// (2)  explicit tuple(const Types&...) -> tuple<Types...>
+// (3)  tuple(AT, A const&, Types const&...) -> tuple<Types...>
+// (4)  explicit tuple(AT, A const&, Types const&...) -> tuple<Types...>
+// (5)  tuple(tuple const& t) -> decltype(t)
+// (6)  tuple(tuple&& t) -> decltype(t)
+// (7)  tuple(AT, A const&, tuple const& t) -> decltype(t)
+// (8)  tuple(AT, A const&, tuple&& t) -> decltype(t)
+void test_primary_template()
+{
+  const std::allocator<int> A;
+  const auto AT = std::allocator_arg;
+  { // Testing (1)
+    int x = 101;
+    std::tuple t1(42);
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<int>);
+    std::tuple t2(x, 0.0, nullptr);
+    ASSERT_SAME_TYPE(decltype(t2), std::tuple<int, double, decltype(nullptr)>);
+  }
+  { // Testing (2)
+    using T = ExplicitTestTypes::TestType;
+    static_assert(!std::is_convertible<T const&, T>::value, "");
+
+    std::tuple t1(T{});
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<T>);
+
+    const T v{};
+    std::tuple t2(T{}, 101l, v);
+    ASSERT_SAME_TYPE(decltype(t2), std::tuple<T, long, T>);
+  }
+  { // Testing (3)
+    int x = 101;
+    std::tuple t1(AT, A, 42);
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<int>);
+
+    std::tuple t2(AT, A, 42, 0.0, x);
+    ASSERT_SAME_TYPE(decltype(t2), std::tuple<int, double, int>);
+  }
+  { // Testing (4)
+    using T = ExplicitTestTypes::TestType;
+    static_assert(!std::is_convertible<T const&, T>::value, "");
+
+    std::tuple t1(AT, A, T{});
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<T>);
+
+    const T v{};
+    std::tuple t2(AT, A, T{}, 101l, v);
+    ASSERT_SAME_TYPE(decltype(t2), std::tuple<T, long, T>);
+  }
+  { // Testing (5)
+    using Tup = std::tuple<int, decltype(nullptr)>;
+    const Tup t(42, nullptr);
+
+    std::tuple t1(t);
+    ASSERT_SAME_TYPE(decltype(t1), Tup);
+  }
+  { // Testing (6)
+    using Tup = std::tuple<void*, unsigned, char>;
+    std::tuple t1(Tup(nullptr, 42, 'a'));
+    ASSERT_SAME_TYPE(decltype(t1), Tup);
+  }
+  { // Testing (7)
+    using Tup = std::tuple<int, decltype(nullptr)>;
+    const Tup t(42, nullptr);
+
+    std::tuple t1(AT, A, t);
+    ASSERT_SAME_TYPE(decltype(t1), Tup);
+  }
+  { // Testing (8)
+    using Tup = std::tuple<void*, unsigned, char>;
+    std::tuple t1(AT, A, Tup(nullptr, 42, 'a'));
+    ASSERT_SAME_TYPE(decltype(t1), Tup);
+  }
+}
+
+// Overloads
+//  using A = Allocator
+//  using AT = std::allocator_arg_t
+// ---------------
+// (1)  tuple() -> tuple<>
+// (2)  tuple(AT, A const&) -> tuple<>
+// (3)  tuple(tuple const&) -> tuple<>
+// (4)  tuple(tuple&&) -> tuple<>
+// (5)  tuple(AT, A const&, tuple const&) -> tuple<>
+// (6)  tuple(AT, A const&, tuple&&) -> tuple<>
+void test_empty_specialization()
+{
+  std::allocator<int> A;
+  const auto AT = std::allocator_arg;
+  { // Testing (1)
+    std::tuple t1{};
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
+  }
+  { // Testing (2)
+    std::tuple t1{AT, A};
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
+  }
+  { // Testing (3)
+    const std::tuple<> t{};
+    std::tuple t1(t);
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
+  }
+  { // Testing (4)
+    std::tuple t1(std::tuple<>{});
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
+  }
+  { // Testing (5)
+    const std::tuple<> t{};
+    std::tuple t1(AT, A, t);
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
+  }
+  { // Testing (6)
+    std::tuple t1(AT, A, std::tuple<>{});
+    ASSERT_SAME_TYPE(decltype(t1), std::tuple<>);
+  }
+}
+
+int main() {
+  test_primary_template();
+  test_empty_specialization();
+}

Property changes on: vendor/libc++/dist/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/implicit_deduction_guides.pass.cpp
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: vendor/libc++/dist/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp
===================================================================
--- vendor/libc++/dist/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp	(revision 319785)
+++ vendor/libc++/dist/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp	(revision 319786)
@@ -1,239 +1,263 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // XFAIL: with_system_cxx_lib=macosx10.12
 // XFAIL: with_system_cxx_lib=macosx10.11
 // XFAIL: with_system_cxx_lib=macosx10.10
 // XFAIL: with_system_cxx_lib=macosx10.9
 // XFAIL: with_system_cxx_lib=macosx10.7
 // XFAIL: with_system_cxx_lib=macosx10.8
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // template <class T>
 // variant& operator=(T&&) noexcept(see below);
 
 #include <cassert>
 #include <string>
 #include <type_traits>
 #include <variant>
 
 #include "test_macros.h"
 #include "variant_test_helpers.hpp"
 
 namespace MetaHelpers {
 
 struct Dummy {
   Dummy() = default;
 };
 
 struct ThrowsCtorT {
   ThrowsCtorT(int) noexcept(false) {}
   ThrowsCtorT &operator=(int) noexcept { return *this; }
 };
 
 struct ThrowsAssignT {
   ThrowsAssignT(int) noexcept {}
   ThrowsAssignT &operator=(int) noexcept(false) { return *this; }
 };
 
 struct NoThrowT {
   NoThrowT(int) noexcept {}
   NoThrowT &operator=(int) noexcept { return *this; }
 };
 
 } // namespace MetaHelpers
 
 namespace RuntimeHelpers {
 #ifndef TEST_HAS_NO_EXCEPTIONS
 
 struct ThrowsCtorT {
   int value;
   ThrowsCtorT() : value(0) {}
   ThrowsCtorT(int) noexcept(false) { throw 42; }
   ThrowsCtorT &operator=(int v) noexcept {
     value = v;
     return *this;
   }
 };
 
+struct MoveCrashes {
+  int value;
+  MoveCrashes(int v = 0) noexcept : value{v} {}
+  MoveCrashes(MoveCrashes &&) noexcept { assert(false); }
+  MoveCrashes &operator=(MoveCrashes &&) noexcept { assert(false); return *this; }
+  MoveCrashes &operator=(int v) noexcept {
+    value = v;
+    return *this;
+  }
+};
+
+struct ThrowsCtorTandMove {
+  int value;
+  ThrowsCtorTandMove() : value(0) {}
+  ThrowsCtorTandMove(int) noexcept(false) { throw 42; }
+  ThrowsCtorTandMove(ThrowsCtorTandMove &&) noexcept(false) { assert(false); }
+  ThrowsCtorTandMove &operator=(int v) noexcept {
+    value = v;
+    return *this;
+  }
+};
+
 struct ThrowsAssignT {
   int value;
   ThrowsAssignT() : value(0) {}
   ThrowsAssignT(int v) noexcept : value(v) {}
   ThrowsAssignT &operator=(int) noexcept(false) { throw 42; }
 };
 
 struct NoThrowT {
   int value;
   NoThrowT() : value(0) {}
   NoThrowT(int v) noexcept : value(v) {}
   NoThrowT &operator=(int v) noexcept {
     value = v;
     return *this;
   }
 };
 
 #endif // !defined(TEST_HAS_NO_EXCEPTIONS)
 } // namespace RuntimeHelpers
 
 void test_T_assignment_noexcept() {
   using namespace MetaHelpers;
   {
     using V = std::variant<Dummy, NoThrowT>;
     static_assert(std::is_nothrow_assignable<V, int>::value, "");
   }
   {
     using V = std::variant<Dummy, ThrowsCtorT>;
     static_assert(!std::is_nothrow_assignable<V, int>::value, "");
   }
   {
     using V = std::variant<Dummy, ThrowsAssignT>;
     static_assert(!std::is_nothrow_assignable<V, int>::value, "");
   }
 }
 
 void test_T_assignment_sfinae() {
   {
     using V = std::variant<long, unsigned>;
     static_assert(!std::is_assignable<V, int>::value, "ambiguous");
   }
   {
     using V = std::variant<std::string, std::string>;
     static_assert(!std::is_assignable<V, const char *>::value, "ambiguous");
   }
   {
     using V = std::variant<std::string, void *>;
     static_assert(!std::is_assignable<V, int>::value, "no matching operator=");
   }
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int, int &&>;
     static_assert(!std::is_assignable<V, int>::value, "ambiguous");
   }
   {
     using V = std::variant<int, const int &>;
     static_assert(!std::is_assignable<V, int>::value, "ambiguous");
   }
-#endif
+#endif // TEST_VARIANT_HAS_NO_REFERENCES
 }
 
 void test_T_assignment_basic() {
   {
     std::variant<int> v(43);
     v = 42;
     assert(v.index() == 0);
     assert(std::get<0>(v) == 42);
   }
   {
     std::variant<int, long> v(43l);
     v = 42;
     assert(v.index() == 0);
     assert(std::get<0>(v) == 42);
     v = 43l;
     assert(v.index() == 1);
     assert(std::get<1>(v) == 43);
   }
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int &, int &&, long>;
     int x = 42;
     V v(43l);
     v = x;
     assert(v.index() == 0);
     assert(&std::get<0>(v) == &x);
     v = std::move(x);
     assert(v.index() == 1);
     assert(&std::get<1>(v) == &x);
     // 'long' is selected by FUN(const int &) since 'const int &' cannot bind
     // to 'int&'.
     const int &cx = x;
     v = cx;
     assert(v.index() == 2);
     assert(std::get<2>(v) == 42);
   }
-#endif
+#endif // TEST_VARIANT_HAS_NO_REFERENCES
 }
 
 void test_T_assignment_performs_construction() {
   using namespace RuntimeHelpers;
 #ifndef TEST_HAS_NO_EXCEPTIONS
   {
     using V = std::variant<std::string, ThrowsCtorT>;
     V v(std::in_place_type<std::string>, "hello");
     try {
       v = 42;
+      assert(false);
     } catch (...) { /* ... */
     }
-    assert(v.valueless_by_exception());
+    assert(v.index() == 0);
+    assert(std::get<0>(v) == "hello");
   }
   {
     using V = std::variant<ThrowsAssignT, std::string>;
     V v(std::in_place_type<std::string>, "hello");
     v = 42;
     assert(v.index() == 0);
     assert(std::get<0>(v).value == 42);
   }
-#endif
+#endif // TEST_HAS_NO_EXCEPTIONS
 }
 
 void test_T_assignment_performs_assignment() {
   using namespace RuntimeHelpers;
 #ifndef TEST_HAS_NO_EXCEPTIONS
   {
     using V = std::variant<ThrowsCtorT>;
     V v;
     v = 42;
     assert(v.index() == 0);
     assert(std::get<0>(v).value == 42);
   }
   {
     using V = std::variant<ThrowsCtorT, std::string>;
     V v;
     v = 42;
     assert(v.index() == 0);
     assert(std::get<0>(v).value == 42);
   }
   {
     using V = std::variant<ThrowsAssignT>;
     V v(100);
     try {
       v = 42;
       assert(false);
     } catch (...) { /* ... */
     }
     assert(v.index() == 0);
     assert(std::get<0>(v).value == 100);
   }
   {
     using V = std::variant<std::string, ThrowsAssignT>;
     V v(100);
     try {
       v = 42;
       assert(false);
     } catch (...) { /* ... */
     }
     assert(v.index() == 1);
     assert(std::get<1>(v).value == 100);
   }
-#endif
+#endif // TEST_HAS_NO_EXCEPTIONS
 }
 
 int main() {
   test_T_assignment_basic();
   test_T_assignment_performs_construction();
   test_T_assignment_performs_assignment();
   test_T_assignment_noexcept();
   test_T_assignment_sfinae();
 }
Index: vendor/libc++/dist/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
===================================================================
--- vendor/libc++/dist/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp	(revision 319785)
+++ vendor/libc++/dist/test/std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp	(revision 319786)
@@ -1,404 +1,594 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+// The following compilers don't generate constexpr special members correctly.
+// XFAIL: clang-3.5, clang-3.6, clang-3.7, clang-3.8
+// XFAIL: apple-clang-6, apple-clang-7, apple-clang-8.0
+
 // XFAIL: with_system_cxx_lib=macosx10.12
 // XFAIL: with_system_cxx_lib=macosx10.11
 // XFAIL: with_system_cxx_lib=macosx10.10
 // XFAIL: with_system_cxx_lib=macosx10.9
 // XFAIL: with_system_cxx_lib=macosx10.7
 // XFAIL: with_system_cxx_lib=macosx10.8
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // variant& operator=(variant const&);
 
 #include <cassert>
 #include <string>
 #include <type_traits>
 #include <variant>
 
 #include "test_macros.h"
 
 struct NoCopy {
   NoCopy(const NoCopy &) = delete;
   NoCopy &operator=(const NoCopy &) = default;
 };
 
-struct NothrowCopy {
-  NothrowCopy(const NothrowCopy &) noexcept = default;
-  NothrowCopy &operator=(const NothrowCopy &) noexcept = default;
-};
-
 struct CopyOnly {
   CopyOnly(const CopyOnly &) = default;
   CopyOnly(CopyOnly &&) = delete;
   CopyOnly &operator=(const CopyOnly &) = default;
   CopyOnly &operator=(CopyOnly &&) = delete;
 };
 
 struct MoveOnly {
   MoveOnly(const MoveOnly &) = delete;
   MoveOnly(MoveOnly &&) = default;
   MoveOnly &operator=(const MoveOnly &) = default;
 };
 
 struct MoveOnlyNT {
   MoveOnlyNT(const MoveOnlyNT &) = delete;
   MoveOnlyNT(MoveOnlyNT &&) {}
   MoveOnlyNT &operator=(const MoveOnlyNT &) = default;
 };
 
 struct CopyAssign {
   static int alive;
   static int copy_construct;
   static int copy_assign;
   static int move_construct;
   static int move_assign;
   static void reset() {
     copy_construct = copy_assign = move_construct = move_assign = alive = 0;
   }
   CopyAssign(int v) : value(v) { ++alive; }
   CopyAssign(const CopyAssign &o) : value(o.value) {
     ++alive;
     ++copy_construct;
   }
-  CopyAssign(CopyAssign &&o) : value(o.value) {
+  CopyAssign(CopyAssign &&o) noexcept : value(o.value) {
     o.value = -1;
     ++alive;
     ++move_construct;
   }
   CopyAssign &operator=(const CopyAssign &o) {
     value = o.value;
     ++copy_assign;
     return *this;
   }
-  CopyAssign &operator=(CopyAssign &&o) {
+  CopyAssign &operator=(CopyAssign &&o) noexcept {
     value = o.value;
     o.value = -1;
     ++move_assign;
     return *this;
   }
   ~CopyAssign() { --alive; }
   int value;
 };
 
 int CopyAssign::alive = 0;
 int CopyAssign::copy_construct = 0;
 int CopyAssign::copy_assign = 0;
 int CopyAssign::move_construct = 0;
 int CopyAssign::move_assign = 0;
 
 struct CopyMaybeThrows {
   CopyMaybeThrows(const CopyMaybeThrows &);
   CopyMaybeThrows &operator=(const CopyMaybeThrows &);
 };
 struct CopyDoesThrow {
   CopyDoesThrow(const CopyDoesThrow &) noexcept(false);
   CopyDoesThrow &operator=(const CopyDoesThrow &) noexcept(false);
 };
 
+
+struct NTCopyAssign {
+  constexpr NTCopyAssign(int v) : value(v) {}
+  NTCopyAssign(const NTCopyAssign &) = default;
+  NTCopyAssign(NTCopyAssign &&) = default;
+  NTCopyAssign &operator=(const NTCopyAssign &that) {
+    value = that.value;
+    return *this;
+  };
+  NTCopyAssign &operator=(NTCopyAssign &&) = delete;
+  int value;
+};
+
+static_assert(!std::is_trivially_copy_assignable<NTCopyAssign>::value, "");
+static_assert(std::is_copy_assignable<NTCopyAssign>::value, "");
+
+struct TCopyAssign {
+  constexpr TCopyAssign(int v) : value(v) {}
+  TCopyAssign(const TCopyAssign &) = default;
+  TCopyAssign(TCopyAssign &&) = default;
+  TCopyAssign &operator=(const TCopyAssign &) = default;
+  TCopyAssign &operator=(TCopyAssign &&) = delete;
+  int value;
+};
+
+static_assert(std::is_trivially_copy_assignable<TCopyAssign>::value, "");
+
+struct TCopyAssignNTMoveAssign {
+  constexpr TCopyAssignNTMoveAssign(int v) : value(v) {}
+  TCopyAssignNTMoveAssign(const TCopyAssignNTMoveAssign &) = default;
+  TCopyAssignNTMoveAssign(TCopyAssignNTMoveAssign &&) = default;
+  TCopyAssignNTMoveAssign &operator=(const TCopyAssignNTMoveAssign &) = default;
+  TCopyAssignNTMoveAssign &operator=(TCopyAssignNTMoveAssign &&that) {
+    value = that.value;
+    that.value = -1;
+    return *this;
+  }
+  int value;
+};
+
+static_assert(std::is_trivially_copy_assignable_v<TCopyAssignNTMoveAssign>, "");
+
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct CopyThrows {
   CopyThrows() = default;
   CopyThrows(const CopyThrows &) { throw 42; }
   CopyThrows &operator=(const CopyThrows &) { throw 42; }
 };
 
+struct CopyCannotThrow {
+  static int alive;
+  CopyCannotThrow() { ++alive; }
+  CopyCannotThrow(const CopyCannotThrow &) noexcept { ++alive; }
+  CopyCannotThrow(CopyCannotThrow &&) noexcept { assert(false); }
+  CopyCannotThrow &operator=(const CopyCannotThrow &) noexcept = default;
+  CopyCannotThrow &operator=(CopyCannotThrow &&) noexcept { assert(false); return *this; }
+};
+
+int CopyCannotThrow::alive = 0;
+
 struct MoveThrows {
   static int alive;
   MoveThrows() { ++alive; }
   MoveThrows(const MoveThrows &) { ++alive; }
   MoveThrows(MoveThrows &&) { throw 42; }
   MoveThrows &operator=(const MoveThrows &) { return *this; }
   MoveThrows &operator=(MoveThrows &&) { throw 42; }
   ~MoveThrows() { --alive; }
 };
 
 int MoveThrows::alive = 0;
 
 struct MakeEmptyT {
   static int alive;
   MakeEmptyT() { ++alive; }
   MakeEmptyT(const MakeEmptyT &) {
     ++alive;
     // Don't throw from the copy constructor since variant's assignment
     // operator performs a copy before committing to the assignment.
   }
   MakeEmptyT(MakeEmptyT &&) { throw 42; }
   MakeEmptyT &operator=(const MakeEmptyT &) { throw 42; }
   MakeEmptyT &operator=(MakeEmptyT &&) { throw 42; }
   ~MakeEmptyT() { --alive; }
 };
 
 int MakeEmptyT::alive = 0;
 
 template <class Variant> void makeEmpty(Variant &v) {
   Variant v2(std::in_place_type<MakeEmptyT>);
   try {
-    v = v2;
+    v = std::move(v2);
     assert(false);
   } catch (...) {
     assert(v.valueless_by_exception());
   }
 }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
 void test_copy_assignment_not_noexcept() {
   {
     using V = std::variant<CopyMaybeThrows>;
     static_assert(!std::is_nothrow_copy_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, CopyDoesThrow>;
     static_assert(!std::is_nothrow_copy_assignable<V>::value, "");
   }
 }
 
 void test_copy_assignment_sfinae() {
   {
     using V = std::variant<int, long>;
     static_assert(std::is_copy_assignable<V>::value, "");
   }
   {
-    // variant only provides copy assignment when both the copy and move
-    // constructors are well formed
     using V = std::variant<int, CopyOnly>;
-    static_assert(!std::is_copy_assignable<V>::value, "");
+    static_assert(std::is_copy_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, NoCopy>;
     static_assert(!std::is_copy_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, MoveOnly>;
     static_assert(!std::is_copy_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, MoveOnlyNT>;
     static_assert(!std::is_copy_assignable<V>::value, "");
   }
+
+  // The following tests are for not-yet-standardized behavior (P0602):
+  {
+    using V = std::variant<int, long>;
+    static_assert(std::is_trivially_copy_assignable<V>::value, "");
+  }
+  {
+    using V = std::variant<int, NTCopyAssign>;
+    static_assert(!std::is_trivially_copy_assignable<V>::value, "");
+    static_assert(std::is_copy_assignable<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TCopyAssign>;
+    static_assert(std::is_trivially_copy_assignable<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TCopyAssignNTMoveAssign>;
+    static_assert(std::is_trivially_copy_assignable<V>::value, "");
+  }
+  {
+    using V = std::variant<int, CopyOnly>;
+    static_assert(std::is_trivially_copy_assignable<V>::value, "");
+  }
 }
 
 void test_copy_assignment_empty_empty() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using MET = MakeEmptyT;
   {
     using V = std::variant<int, long, MET>;
     V v1(std::in_place_index<0>);
     makeEmpty(v1);
     V v2(std::in_place_index<0>);
     makeEmpty(v2);
     V &vref = (v1 = v2);
     assert(&vref == &v1);
     assert(v1.valueless_by_exception());
     assert(v1.index() == std::variant_npos);
   }
-#endif
+#endif // TEST_HAS_NO_EXCEPTIONS
 }
 
 void test_copy_assignment_non_empty_empty() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using MET = MakeEmptyT;
   {
     using V = std::variant<int, MET>;
     V v1(std::in_place_index<0>, 42);
     V v2(std::in_place_index<0>);
     makeEmpty(v2);
     V &vref = (v1 = v2);
     assert(&vref == &v1);
     assert(v1.valueless_by_exception());
     assert(v1.index() == std::variant_npos);
   }
   {
     using V = std::variant<int, MET, std::string>;
     V v1(std::in_place_index<2>, "hello");
     V v2(std::in_place_index<0>);
     makeEmpty(v2);
     V &vref = (v1 = v2);
     assert(&vref == &v1);
     assert(v1.valueless_by_exception());
     assert(v1.index() == std::variant_npos);
   }
-#endif
+#endif // TEST_HAS_NO_EXCEPTIONS
 }
 
 void test_copy_assignment_empty_non_empty() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using MET = MakeEmptyT;
   {
     using V = std::variant<int, MET>;
     V v1(std::in_place_index<0>);
     makeEmpty(v1);
     V v2(std::in_place_index<0>, 42);
     V &vref = (v1 = v2);
     assert(&vref == &v1);
     assert(v1.index() == 0);
     assert(std::get<0>(v1) == 42);
   }
   {
     using V = std::variant<int, MET, std::string>;
     V v1(std::in_place_index<0>);
     makeEmpty(v1);
     V v2(std::in_place_type<std::string>, "hello");
     V &vref = (v1 = v2);
     assert(&vref == &v1);
     assert(v1.index() == 2);
     assert(std::get<2>(v1) == "hello");
   }
-#endif
+#endif // TEST_HAS_NO_EXCEPTIONS
 }
 
+template <typename T> struct Result { size_t index; T value; };
+
 void test_copy_assignment_same_index() {
   {
     using V = std::variant<int>;
     V v1(43);
     V v2(42);
     V &vref = (v1 = v2);
     assert(&vref == &v1);
     assert(v1.index() == 0);
     assert(std::get<0>(v1) == 42);
   }
   {
     using V = std::variant<int, long, unsigned>;
     V v1(43l);
     V v2(42l);
     V &vref = (v1 = v2);
     assert(&vref == &v1);
     assert(v1.index() == 1);
     assert(std::get<1>(v1) == 42);
   }
   {
     using V = std::variant<int, CopyAssign, unsigned>;
     V v1(std::in_place_type<CopyAssign>, 43);
     V v2(std::in_place_type<CopyAssign>, 42);
     CopyAssign::reset();
     V &vref = (v1 = v2);
     assert(&vref == &v1);
     assert(v1.index() == 1);
     assert(std::get<1>(v1).value == 42);
     assert(CopyAssign::copy_construct == 0);
     assert(CopyAssign::move_construct == 0);
     assert(CopyAssign::copy_assign == 1);
   }
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using MET = MakeEmptyT;
   {
     using V = std::variant<int, MET, std::string>;
     V v1(std::in_place_type<MET>);
     MET &mref = std::get<1>(v1);
     V v2(std::in_place_type<MET>);
     try {
       v1 = v2;
       assert(false);
     } catch (...) {
     }
     assert(v1.index() == 1);
     assert(&std::get<1>(v1) == &mref);
   }
-#endif
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+  // The following tests are for not-yet-standardized behavior (P0602):
+  {
+    struct {
+      constexpr Result<int> operator()() const {
+        using V = std::variant<int>;
+        V v(43);
+        V v2(42);
+        v = v2;
+        return {v.index(), std::get<0>(v)};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 0, "");
+    static_assert(result.value == 42, "");
+  }
+  {
+    struct {
+      constexpr Result<long> operator()() const {
+        using V = std::variant<int, long, unsigned>;
+        V v(43l);
+        V v2(42l);
+        v = v2;
+        return {v.index(), std::get<1>(v)};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1, "");
+    static_assert(result.value == 42l, "");
+  }
+  {
+    struct {
+      constexpr Result<int> operator()() const {
+        using V = std::variant<int, TCopyAssign, unsigned>;
+        V v(std::in_place_type<TCopyAssign>, 43);
+        V v2(std::in_place_type<TCopyAssign>, 42);
+        v = v2;
+        return {v.index(), std::get<1>(v).value};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1, "");
+    static_assert(result.value == 42, "");
+  }
+  {
+    struct {
+      constexpr Result<int> operator()() const {
+        using V = std::variant<int, TCopyAssignNTMoveAssign, unsigned>;
+        V v(std::in_place_type<TCopyAssignNTMoveAssign>, 43);
+        V v2(std::in_place_type<TCopyAssignNTMoveAssign>, 42);
+        v = v2;
+        return {v.index(), std::get<1>(v).value};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1, "");
+    static_assert(result.value == 42, "");
+  }
 }
 
 void test_copy_assignment_different_index() {
   {
     using V = std::variant<int, long, unsigned>;
     V v1(43);
     V v2(42l);
     V &vref = (v1 = v2);
     assert(&vref == &v1);
     assert(v1.index() == 1);
     assert(std::get<1>(v1) == 42);
   }
   {
     using V = std::variant<int, CopyAssign, unsigned>;
     CopyAssign::reset();
     V v1(std::in_place_type<unsigned>, 43);
     V v2(std::in_place_type<CopyAssign>, 42);
     assert(CopyAssign::copy_construct == 0);
     assert(CopyAssign::move_construct == 0);
     assert(CopyAssign::alive == 1);
     V &vref = (v1 = v2);
     assert(&vref == &v1);
     assert(v1.index() == 1);
     assert(std::get<1>(v1).value == 42);
     assert(CopyAssign::alive == 2);
     assert(CopyAssign::copy_construct == 1);
     assert(CopyAssign::move_construct == 1);
     assert(CopyAssign::copy_assign == 0);
   }
 #ifndef TEST_HAS_NO_EXCEPTIONS
   {
-    // Test that if copy construction throws then original value is
-    // unchanged.
     using V = std::variant<int, CopyThrows, std::string>;
     V v1(std::in_place_type<std::string>, "hello");
     V v2(std::in_place_type<CopyThrows>);
     try {
       v1 = v2;
       assert(false);
     } catch (...) { /* ... */
     }
-    assert(v1.index() == 2);
-    assert(std::get<2>(v1) == "hello");
+    // Test that copy construction is used directly if move construction may throw,
+    // resulting in a valueless variant if copy throws.
+    assert(v1.valueless_by_exception());
   }
   {
-    // Test that if move construction throws then the variant is left
-    // valueless by exception.
     using V = std::variant<int, MoveThrows, std::string>;
     V v1(std::in_place_type<std::string>, "hello");
     V v2(std::in_place_type<MoveThrows>);
     assert(MoveThrows::alive == 1);
-    try {
-      v1 = v2;
-      assert(false);
-    } catch (...) { /* ... */
-    }
-    assert(v1.valueless_by_exception());
+    // Test that copy construction is used directly if move construction may throw.
+    v1 = v2;
+    assert(v1.index() == 1);
     assert(v2.index() == 1);
-    assert(MoveThrows::alive == 1);
+    assert(MoveThrows::alive == 2);
   }
   {
+    // Test that direct copy construction is preferred when it cannot throw.
+    using V = std::variant<int, CopyCannotThrow, std::string>;
+    V v1(std::in_place_type<std::string>, "hello");
+    V v2(std::in_place_type<CopyCannotThrow>);
+    assert(CopyCannotThrow::alive == 1);
+    v1 = v2;
+    assert(v1.index() == 1);
+    assert(v2.index() == 1);
+    assert(CopyCannotThrow::alive == 2);
+  }
+  {
     using V = std::variant<int, CopyThrows, std::string>;
     V v1(std::in_place_type<CopyThrows>);
     V v2(std::in_place_type<std::string>, "hello");
     V &vref = (v1 = v2);
     assert(&vref == &v1);
     assert(v1.index() == 2);
     assert(std::get<2>(v1) == "hello");
     assert(v2.index() == 2);
     assert(std::get<2>(v2) == "hello");
   }
   {
     using V = std::variant<int, MoveThrows, std::string>;
     V v1(std::in_place_type<MoveThrows>);
     V v2(std::in_place_type<std::string>, "hello");
     V &vref = (v1 = v2);
     assert(&vref == &v1);
     assert(v1.index() == 2);
     assert(std::get<2>(v1) == "hello");
     assert(v2.index() == 2);
     assert(std::get<2>(v2) == "hello");
   }
-#endif
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+  // The following tests are for not-yet-standardized behavior (P0602):
+  {
+    struct {
+      constexpr Result<long> operator()() const {
+        using V = std::variant<int, long, unsigned>;
+        V v(43);
+        V v2(42l);
+        v = v2;
+        return {v.index(), std::get<1>(v)};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1, "");
+    static_assert(result.value == 42l, "");
+  }
+  {
+    struct {
+      constexpr Result<int> operator()() const {
+        using V = std::variant<int, TCopyAssign, unsigned>;
+        V v(std::in_place_type<unsigned>, 43);
+        V v2(std::in_place_type<TCopyAssign>, 42);
+        v = v2;
+        return {v.index(), std::get<1>(v).value};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1, "");
+    static_assert(result.value == 42, "");
+  }
 }
 
+template <size_t NewIdx, class ValueType>
+constexpr bool test_constexpr_assign_extension_imp(
+    std::variant<long, void*, int>&& v, ValueType&& new_value)
+{
+  const std::variant<long, void*, int> cp(
+      std::forward<ValueType>(new_value));
+  v = cp;
+  return v.index() == NewIdx &&
+        std::get<NewIdx>(v) == std::get<NewIdx>(cp);
+}
 
+void test_constexpr_copy_assignment_extension() {
+  // The following tests are for not-yet-standardized behavior (P0602):
+  using V = std::variant<long, void*, int>;
+  static_assert(std::is_trivially_copyable<V>::value, "");
+  static_assert(std::is_trivially_copy_assignable<V>::value, "");
+  static_assert(test_constexpr_assign_extension_imp<0>(V(42l), 101l), "");
+  static_assert(test_constexpr_assign_extension_imp<0>(V(nullptr), 101l), "");
+  static_assert(test_constexpr_assign_extension_imp<1>(V(42l), nullptr), "");
+  static_assert(test_constexpr_assign_extension_imp<2>(V(42l), 101), "");
+}
+
 int main() {
   test_copy_assignment_empty_empty();
   test_copy_assignment_non_empty_empty();
   test_copy_assignment_empty_non_empty();
   test_copy_assignment_same_index();
   test_copy_assignment_different_index();
   test_copy_assignment_sfinae();
   test_copy_assignment_not_noexcept();
+  test_constexpr_copy_assignment_extension();
 }
Index: vendor/libc++/dist/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
===================================================================
--- vendor/libc++/dist/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp	(revision 319785)
+++ vendor/libc++/dist/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp	(revision 319786)
@@ -1,326 +1,509 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
+// The following compilers don't generate constexpr special members correctly.
+// XFAIL: clang-3.5, clang-3.6, clang-3.7, clang-3.8
+// XFAIL: apple-clang-6, apple-clang-7, apple-clang-8.0
+
 // XFAIL: with_system_cxx_lib=macosx10.12
 // XFAIL: with_system_cxx_lib=macosx10.11
 // XFAIL: with_system_cxx_lib=macosx10.10
 // XFAIL: with_system_cxx_lib=macosx10.9
 // XFAIL: with_system_cxx_lib=macosx10.7
 // XFAIL: with_system_cxx_lib=macosx10.8
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // variant& operator=(variant&&) noexcept(see below);
 
 #include <cassert>
 #include <string>
 #include <type_traits>
 #include <utility>
 #include <variant>
 
 #include "test_macros.h"
 #include "variant_test_helpers.hpp"
 
 struct NoCopy {
   NoCopy(const NoCopy &) = delete;
   NoCopy &operator=(const NoCopy &) = default;
 };
 
 struct CopyOnly {
   CopyOnly(const CopyOnly &) = default;
   CopyOnly(CopyOnly &&) = delete;
   CopyOnly &operator=(const CopyOnly &) = default;
   CopyOnly &operator=(CopyOnly &&) = delete;
 };
 
 struct MoveOnly {
   MoveOnly(const MoveOnly &) = delete;
   MoveOnly(MoveOnly &&) = default;
   MoveOnly &operator=(const MoveOnly &) = delete;
   MoveOnly &operator=(MoveOnly &&) = default;
 };
 
 struct MoveOnlyNT {
   MoveOnlyNT(const MoveOnlyNT &) = delete;
   MoveOnlyNT(MoveOnlyNT &&) {}
   MoveOnlyNT &operator=(const MoveOnlyNT &) = delete;
   MoveOnlyNT &operator=(MoveOnlyNT &&) = default;
 };
 
 struct MoveOnlyOddNothrow {
   MoveOnlyOddNothrow(MoveOnlyOddNothrow &&) noexcept(false) {}
   MoveOnlyOddNothrow(const MoveOnlyOddNothrow &) = delete;
   MoveOnlyOddNothrow &operator=(MoveOnlyOddNothrow &&) noexcept = default;
   MoveOnlyOddNothrow &operator=(const MoveOnlyOddNothrow &) = delete;
 };
 
 struct MoveAssignOnly {
   MoveAssignOnly(MoveAssignOnly &&) = delete;
   MoveAssignOnly &operator=(MoveAssignOnly &&) = default;
 };
 
 struct MoveAssign {
   static int move_construct;
   static int move_assign;
   static void reset() { move_construct = move_assign = 0; }
   MoveAssign(int v) : value(v) {}
   MoveAssign(MoveAssign &&o) : value(o.value) {
     ++move_construct;
     o.value = -1;
   }
   MoveAssign &operator=(MoveAssign &&o) {
     value = o.value;
     ++move_assign;
     o.value = -1;
     return *this;
   }
   int value;
 };
 
 int MoveAssign::move_construct = 0;
 int MoveAssign::move_assign = 0;
 
+struct NTMoveAssign {
+  constexpr NTMoveAssign(int v) : value(v) {}
+  NTMoveAssign(const NTMoveAssign &) = default;
+  NTMoveAssign(NTMoveAssign &&) = default;
+  NTMoveAssign &operator=(const NTMoveAssign &that) = default;
+  NTMoveAssign &operator=(NTMoveAssign &&that) {
+    value = that.value;
+    that.value = -1;
+    return *this;
+  };
+  int value;
+};
+
+static_assert(!std::is_trivially_move_assignable<NTMoveAssign>::value, "");
+static_assert(std::is_move_assignable<NTMoveAssign>::value, "");
+
+struct TMoveAssign {
+  constexpr TMoveAssign(int v) : value(v) {}
+  TMoveAssign(const TMoveAssign &) = delete;
+  TMoveAssign(TMoveAssign &&) = default;
+  TMoveAssign &operator=(const TMoveAssign &) = delete;
+  TMoveAssign &operator=(TMoveAssign &&) = default;
+  int value;
+};
+
+static_assert(std::is_trivially_move_assignable<TMoveAssign>::value, "");
+
+struct TMoveAssignNTCopyAssign {
+  constexpr TMoveAssignNTCopyAssign(int v) : value(v) {}
+  TMoveAssignNTCopyAssign(const TMoveAssignNTCopyAssign &) = default;
+  TMoveAssignNTCopyAssign(TMoveAssignNTCopyAssign &&) = default;
+  TMoveAssignNTCopyAssign &operator=(const TMoveAssignNTCopyAssign &that) {
+    value = that.value;
+    return *this;
+  }
+  TMoveAssignNTCopyAssign &operator=(TMoveAssignNTCopyAssign &&) = default;
+  int value;
+};
+
+static_assert(std::is_trivially_move_assignable_v<TMoveAssignNTCopyAssign>, "");
+
+struct TrivialCopyNontrivialMove {
+  TrivialCopyNontrivialMove(TrivialCopyNontrivialMove const&) = default;
+  TrivialCopyNontrivialMove(TrivialCopyNontrivialMove&&) noexcept {}
+  TrivialCopyNontrivialMove& operator=(TrivialCopyNontrivialMove const&) = default;
+  TrivialCopyNontrivialMove& operator=(TrivialCopyNontrivialMove&&) noexcept {
+    return *this;
+  }
+};
+
+static_assert(std::is_trivially_copy_assignable_v<TrivialCopyNontrivialMove>, "");
+static_assert(!std::is_trivially_move_assignable_v<TrivialCopyNontrivialMove>, "");
+
+
 void test_move_assignment_noexcept() {
   {
     using V = std::variant<int>;
     static_assert(std::is_nothrow_move_assignable<V>::value, "");
   }
   {
     using V = std::variant<MoveOnly>;
     static_assert(std::is_nothrow_move_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, long>;
     static_assert(std::is_nothrow_move_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, MoveOnly>;
     static_assert(std::is_nothrow_move_assignable<V>::value, "");
   }
   {
     using V = std::variant<MoveOnlyNT>;
     static_assert(!std::is_nothrow_move_assignable<V>::value, "");
   }
   {
     using V = std::variant<MoveOnlyOddNothrow>;
     static_assert(!std::is_nothrow_move_assignable<V>::value, "");
   }
 }
 
 void test_move_assignment_sfinae() {
   {
     using V = std::variant<int, long>;
     static_assert(std::is_move_assignable<V>::value, "");
   }
   {
-    // variant only provides move assignment when both the move constructor
-    // and move assignment operator are well formed.
     using V = std::variant<int, CopyOnly>;
-    static_assert(!std::is_move_assignable<V>::value, "");
+    static_assert(std::is_move_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, NoCopy>;
     static_assert(!std::is_move_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, MoveOnly>;
     static_assert(std::is_move_assignable<V>::value, "");
   }
   {
     using V = std::variant<int, MoveOnlyNT>;
     static_assert(std::is_move_assignable<V>::value, "");
   }
   {
     // variant only provides move assignment when the types also provide
     // a move constructor.
     using V = std::variant<int, MoveAssignOnly>;
     static_assert(!std::is_move_assignable<V>::value, "");
   }
+
+  // The following tests are for not-yet-standardized behavior (P0602):
+  {
+    using V = std::variant<int, long>;
+    static_assert(std::is_trivially_move_assignable<V>::value, "");
+  }
+  {
+    using V = std::variant<int, NTMoveAssign>;
+    static_assert(!std::is_trivially_move_assignable<V>::value, "");
+    static_assert(std::is_move_assignable<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TMoveAssign>;
+    static_assert(std::is_trivially_move_assignable<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TMoveAssignNTCopyAssign>;
+    static_assert(std::is_trivially_move_assignable<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TrivialCopyNontrivialMove>;
+    static_assert(!std::is_trivially_move_assignable<V>::value, "");
+  }
+  {
+    using V = std::variant<int, CopyOnly>;
+    static_assert(std::is_trivially_move_assignable<V>::value, "");
+  }
 }
 
 void test_move_assignment_empty_empty() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using MET = MakeEmptyT;
   {
     using V = std::variant<int, long, MET>;
     V v1(std::in_place_index<0>);
     makeEmpty(v1);
     V v2(std::in_place_index<0>);
     makeEmpty(v2);
     V &vref = (v1 = std::move(v2));
     assert(&vref == &v1);
     assert(v1.valueless_by_exception());
     assert(v1.index() == std::variant_npos);
   }
-#endif
+#endif // TEST_HAS_NO_EXCEPTIONS
 }
 
 void test_move_assignment_non_empty_empty() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using MET = MakeEmptyT;
   {
     using V = std::variant<int, MET>;
     V v1(std::in_place_index<0>, 42);
     V v2(std::in_place_index<0>);
     makeEmpty(v2);
     V &vref = (v1 = std::move(v2));
     assert(&vref == &v1);
     assert(v1.valueless_by_exception());
     assert(v1.index() == std::variant_npos);
   }
   {
     using V = std::variant<int, MET, std::string>;
     V v1(std::in_place_index<2>, "hello");
     V v2(std::in_place_index<0>);
     makeEmpty(v2);
     V &vref = (v1 = std::move(v2));
     assert(&vref == &v1);
     assert(v1.valueless_by_exception());
     assert(v1.index() == std::variant_npos);
   }
-#endif
+#endif // TEST_HAS_NO_EXCEPTIONS
 }
 
 void test_move_assignment_empty_non_empty() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using MET = MakeEmptyT;
   {
     using V = std::variant<int, MET>;
     V v1(std::in_place_index<0>);
     makeEmpty(v1);
     V v2(std::in_place_index<0>, 42);
     V &vref = (v1 = std::move(v2));
     assert(&vref == &v1);
     assert(v1.index() == 0);
     assert(std::get<0>(v1) == 42);
   }
   {
     using V = std::variant<int, MET, std::string>;
     V v1(std::in_place_index<0>);
     makeEmpty(v1);
     V v2(std::in_place_type<std::string>, "hello");
     V &vref = (v1 = std::move(v2));
     assert(&vref == &v1);
     assert(v1.index() == 2);
     assert(std::get<2>(v1) == "hello");
   }
-#endif
+#endif // TEST_HAS_NO_EXCEPTIONS
 }
 
+template <typename T> struct Result { size_t index; T value; };
+
 void test_move_assignment_same_index() {
   {
     using V = std::variant<int>;
     V v1(43);
     V v2(42);
     V &vref = (v1 = std::move(v2));
     assert(&vref == &v1);
     assert(v1.index() == 0);
     assert(std::get<0>(v1) == 42);
   }
   {
     using V = std::variant<int, long, unsigned>;
     V v1(43l);
     V v2(42l);
     V &vref = (v1 = std::move(v2));
     assert(&vref == &v1);
     assert(v1.index() == 1);
     assert(std::get<1>(v1) == 42);
   }
   {
     using V = std::variant<int, MoveAssign, unsigned>;
     V v1(std::in_place_type<MoveAssign>, 43);
     V v2(std::in_place_type<MoveAssign>, 42);
     MoveAssign::reset();
     V &vref = (v1 = std::move(v2));
     assert(&vref == &v1);
     assert(v1.index() == 1);
     assert(std::get<1>(v1).value == 42);
     assert(MoveAssign::move_construct == 0);
     assert(MoveAssign::move_assign == 1);
   }
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using MET = MakeEmptyT;
   {
     using V = std::variant<int, MET, std::string>;
     V v1(std::in_place_type<MET>);
     MET &mref = std::get<1>(v1);
     V v2(std::in_place_type<MET>);
     try {
       v1 = std::move(v2);
       assert(false);
     } catch (...) {
     }
     assert(v1.index() == 1);
     assert(&std::get<1>(v1) == &mref);
   }
-#endif
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+  // The following tests are for not-yet-standardized behavior (P0602):
+  {
+    struct {
+      constexpr Result<int> operator()() const {
+        using V = std::variant<int>;
+        V v(43);
+        V v2(42);
+        v = std::move(v2);
+        return {v.index(), std::get<0>(v)};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 0, "");
+    static_assert(result.value == 42, "");
+  }
+  {
+    struct {
+      constexpr Result<long> operator()() const {
+        using V = std::variant<int, long, unsigned>;
+        V v(43l);
+        V v2(42l);
+        v = std::move(v2);
+        return {v.index(), std::get<1>(v)};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1, "");
+    static_assert(result.value == 42l, "");
+  }
+  {
+    struct {
+      constexpr Result<int> operator()() const {
+        using V = std::variant<int, TMoveAssign, unsigned>;
+        V v(std::in_place_type<TMoveAssign>, 43);
+        V v2(std::in_place_type<TMoveAssign>, 42);
+        v = std::move(v2);
+        return {v.index(), std::get<1>(v).value};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1, "");
+    static_assert(result.value == 42, "");
+  }
 }
 
 void test_move_assignment_different_index() {
   {
     using V = std::variant<int, long, unsigned>;
     V v1(43);
     V v2(42l);
     V &vref = (v1 = std::move(v2));
     assert(&vref == &v1);
     assert(v1.index() == 1);
     assert(std::get<1>(v1) == 42);
   }
   {
     using V = std::variant<int, MoveAssign, unsigned>;
     V v1(std::in_place_type<unsigned>, 43);
     V v2(std::in_place_type<MoveAssign>, 42);
     MoveAssign::reset();
     V &vref = (v1 = std::move(v2));
     assert(&vref == &v1);
     assert(v1.index() == 1);
     assert(std::get<1>(v1).value == 42);
     assert(MoveAssign::move_construct == 1);
     assert(MoveAssign::move_assign == 0);
   }
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using MET = MakeEmptyT;
   {
     using V = std::variant<int, MET, std::string>;
     V v1(std::in_place_type<int>);
     V v2(std::in_place_type<MET>);
     try {
       v1 = std::move(v2);
       assert(false);
     } catch (...) {
     }
     assert(v1.valueless_by_exception());
     assert(v1.index() == std::variant_npos);
   }
   {
     using V = std::variant<int, MET, std::string>;
     V v1(std::in_place_type<MET>);
     V v2(std::in_place_type<std::string>, "hello");
     V &vref = (v1 = std::move(v2));
     assert(&vref == &v1);
     assert(v1.index() == 2);
     assert(std::get<2>(v1) == "hello");
   }
-#endif
+#endif // TEST_HAS_NO_EXCEPTIONS
+
+  // The following tests are for not-yet-standardized behavior (P0602):
+  {
+    struct {
+      constexpr Result<long> operator()() const {
+        using V = std::variant<int, long, unsigned>;
+        V v(43);
+        V v2(42l);
+        v = std::move(v2);
+        return {v.index(), std::get<1>(v)};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1, "");
+    static_assert(result.value == 42l, "");
+  }
+  {
+    struct {
+      constexpr Result<long> operator()() const {
+        using V = std::variant<int, TMoveAssign, unsigned>;
+        V v(std::in_place_type<unsigned>, 43);
+        V v2(std::in_place_type<TMoveAssign>, 42);
+        v = std::move(v2);
+        return {v.index(), std::get<1>(v).value};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1, "");
+    static_assert(result.value == 42, "");
+  }
 }
 
+template <size_t NewIdx, class ValueType>
+constexpr bool test_constexpr_assign_extension_imp(
+    std::variant<long, void*, int>&& v, ValueType&& new_value)
+{
+  std::variant<long, void*, int> v2(
+      std::forward<ValueType>(new_value));
+  const auto cp = v2;
+  v = std::move(v2);
+  return v.index() == NewIdx &&
+        std::get<NewIdx>(v) == std::get<NewIdx>(cp);
+}
+
+void test_constexpr_move_assignment_extension() {
+  // The following tests are for not-yet-standardized behavior (P0602):
+  using V = std::variant<long, void*, int>;
+  static_assert(std::is_trivially_copyable<V>::value, "");
+  static_assert(std::is_trivially_move_assignable<V>::value, "");
+  static_assert(test_constexpr_assign_extension_imp<0>(V(42l), 101l), "");
+  static_assert(test_constexpr_assign_extension_imp<0>(V(nullptr), 101l), "");
+  static_assert(test_constexpr_assign_extension_imp<1>(V(42l), nullptr), "");
+  static_assert(test_constexpr_assign_extension_imp<2>(V(42l), 101), "");
+}
+
 int main() {
   test_move_assignment_empty_empty();
   test_move_assignment_non_empty_empty();
   test_move_assignment_empty_non_empty();
   test_move_assignment_same_index();
   test_move_assignment_different_index();
   test_move_assignment_sfinae();
   test_move_assignment_noexcept();
+  test_constexpr_move_assignment_extension();
 }
Index: vendor/libc++/dist/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
===================================================================
--- vendor/libc++/dist/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp	(revision 319785)
+++ vendor/libc++/dist/test/std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp	(revision 319786)
@@ -1,173 +1,264 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // XFAIL: with_system_cxx_lib=macosx10.12
 // XFAIL: with_system_cxx_lib=macosx10.11
 // XFAIL: with_system_cxx_lib=macosx10.10
 // XFAIL: with_system_cxx_lib=macosx10.9
 // XFAIL: with_system_cxx_lib=macosx10.7
 // XFAIL: with_system_cxx_lib=macosx10.8
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // variant(variant const&);
 
 #include <cassert>
 #include <type_traits>
 #include <variant>
 
 #include "test_macros.h"
 #include "test_workarounds.h"
 
 struct NonT {
   NonT(int v) : value(v) {}
   NonT(const NonT &o) : value(o.value) {}
   int value;
 };
 static_assert(!std::is_trivially_copy_constructible<NonT>::value, "");
 
 struct NoCopy {
   NoCopy(const NoCopy &) = delete;
 };
 
 struct MoveOnly {
   MoveOnly(const MoveOnly &) = delete;
   MoveOnly(MoveOnly &&) = default;
 };
 
 struct MoveOnlyNT {
   MoveOnlyNT(const MoveOnlyNT &) = delete;
   MoveOnlyNT(MoveOnlyNT &&) {}
 };
 
+struct NTCopy {
+  constexpr NTCopy(int v) : value(v) {}
+  NTCopy(const NTCopy &that) : value(that.value) {}
+  NTCopy(NTCopy &&) = delete;
+  int value;
+};
+
+static_assert(!std::is_trivially_copy_constructible<NTCopy>::value, "");
+static_assert(std::is_copy_constructible<NTCopy>::value, "");
+
+struct TCopy {
+  constexpr TCopy(int v) : value(v) {}
+  TCopy(TCopy const &) = default;
+  TCopy(TCopy &&) = delete;
+  int value;
+};
+
+static_assert(std::is_trivially_copy_constructible<TCopy>::value, "");
+
+struct TCopyNTMove {
+  constexpr TCopyNTMove(int v) : value(v) {}
+  TCopyNTMove(const TCopyNTMove&) = default;
+  TCopyNTMove(TCopyNTMove&& that) : value(that.value) { that.value = -1; }
+  int value;
+};
+
+static_assert(std::is_trivially_copy_constructible<TCopyNTMove>::value, "");
+
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct MakeEmptyT {
   static int alive;
   MakeEmptyT() { ++alive; }
   MakeEmptyT(const MakeEmptyT &) {
     ++alive;
     // Don't throw from the copy constructor since variant's assignment
     // operator performs a copy before committing to the assignment.
   }
   MakeEmptyT(MakeEmptyT &&) { throw 42; }
   MakeEmptyT &operator=(const MakeEmptyT &) { throw 42; }
   MakeEmptyT &operator=(MakeEmptyT &&) { throw 42; }
   ~MakeEmptyT() { --alive; }
 };
 
 int MakeEmptyT::alive = 0;
 
 template <class Variant> void makeEmpty(Variant &v) {
   Variant v2(std::in_place_type<MakeEmptyT>);
   try {
-    v = v2;
+    v = std::move(v2);
     assert(false);
   } catch (...) {
     assert(v.valueless_by_exception());
   }
 }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
 void test_copy_ctor_sfinae() {
   {
     using V = std::variant<int, long>;
     static_assert(std::is_copy_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, NoCopy>;
     static_assert(!std::is_copy_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, MoveOnly>;
     static_assert(!std::is_copy_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, MoveOnlyNT>;
     static_assert(!std::is_copy_constructible<V>::value, "");
   }
+
+  // The following tests are for not-yet-standardized behavior (P0602):
+  {
+    using V = std::variant<int, long>;
+    static_assert(std::is_trivially_copy_constructible<V>::value, "");
+  }
+  {
+    using V = std::variant<int, NTCopy>;
+    static_assert(!std::is_trivially_copy_constructible<V>::value, "");
+    static_assert(std::is_copy_constructible<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TCopy>;
+    static_assert(std::is_trivially_copy_constructible<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TCopyNTMove>;
+    static_assert(std::is_trivially_copy_constructible<V>::value, "");
+  }
 }
 
 void test_copy_ctor_basic() {
   {
     std::variant<int> v(std::in_place_index<0>, 42);
     std::variant<int> v2 = v;
     assert(v2.index() == 0);
     assert(std::get<0>(v2) == 42);
   }
   {
     std::variant<int, long> v(std::in_place_index<1>, 42);
     std::variant<int, long> v2 = v;
     assert(v2.index() == 1);
     assert(std::get<1>(v2) == 42);
   }
   {
     std::variant<NonT> v(std::in_place_index<0>, 42);
     assert(v.index() == 0);
     std::variant<NonT> v2(v);
     assert(v2.index() == 0);
     assert(std::get<0>(v2).value == 42);
   }
   {
     std::variant<int, NonT> v(std::in_place_index<1>, 42);
     assert(v.index() == 1);
     std::variant<int, NonT> v2(v);
     assert(v2.index() == 1);
     assert(std::get<1>(v2).value == 42);
   }
+
+  // The following tests are for not-yet-standardized behavior (P0602):
+  {
+    constexpr std::variant<int> v(std::in_place_index<0>, 42);
+    static_assert(v.index() == 0, "");
+    constexpr std::variant<int> v2 = v;
+    static_assert(v2.index() == 0, "");
+    static_assert(std::get<0>(v2) == 42, "");
+  }
+  {
+    constexpr std::variant<int, long> v(std::in_place_index<1>, 42);
+    static_assert(v.index() == 1, "");
+    constexpr std::variant<int, long> v2 = v;
+    static_assert(v2.index() == 1, "");
+    static_assert(std::get<1>(v2) == 42, "");
+  }
+  {
+    constexpr std::variant<TCopy> v(std::in_place_index<0>, 42);
+    static_assert(v.index() == 0, "");
+    constexpr std::variant<TCopy> v2(v);
+    static_assert(v2.index() == 0, "");
+    static_assert(std::get<0>(v2).value == 42, "");
+  }
+  {
+    constexpr std::variant<int, TCopy> v(std::in_place_index<1>, 42);
+    static_assert(v.index() == 1, "");
+    constexpr std::variant<int, TCopy> v2(v);
+    static_assert(v2.index() == 1, "");
+    static_assert(std::get<1>(v2).value == 42, "");
+  }
+  {
+    constexpr std::variant<TCopyNTMove> v(std::in_place_index<0>, 42);
+    static_assert(v.index() == 0, "");
+    constexpr std::variant<TCopyNTMove> v2(v);
+    static_assert(v2.index() == 0, "");
+    static_assert(std::get<0>(v2).value == 42, "");
+  }
+  {
+    constexpr std::variant<int, TCopyNTMove> v(std::in_place_index<1>, 42);
+    static_assert(v.index() == 1, "");
+    constexpr std::variant<int, TCopyNTMove> v2(v);
+    static_assert(v2.index() == 1, "");
+    static_assert(std::get<1>(v2).value == 42, "");
+  }
 }
 
 void test_copy_ctor_valueless_by_exception() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using V = std::variant<int, MakeEmptyT>;
   V v1;
   makeEmpty(v1);
   const V &cv1 = v1;
   V v(cv1);
   assert(v.valueless_by_exception());
-#endif
+#endif // TEST_HAS_NO_EXCEPTIONS
 }
 
 template <size_t Idx>
 constexpr bool test_constexpr_copy_ctor_extension_imp(
     std::variant<long, void*, const int> const& v)
 {
   auto v2 = v;
   return v2.index() == v.index() &&
          v2.index() == Idx &&
          std::get<Idx>(v2) == std::get<Idx>(v);
 }
 
 void test_constexpr_copy_ctor_extension() {
-  // NOTE: This test is for not yet standardized behavior.
+  // NOTE: This test is for not yet standardized behavior. (P0602)
   using V = std::variant<long, void*, const int>;
 #ifdef TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_destructible<V>::value, "");
   static_assert(std::is_trivially_copy_constructible<V>::value, "");
   static_assert(std::is_trivially_move_constructible<V>::value, "");
   static_assert(!std::is_copy_assignable<V>::value, "");
   static_assert(!std::is_move_assignable<V>::value, "");
-#else
+#else // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_copyable<V>::value, "");
-#endif
+#endif // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(test_constexpr_copy_ctor_extension_imp<0>(V(42l)), "");
   static_assert(test_constexpr_copy_ctor_extension_imp<1>(V(nullptr)), "");
   static_assert(test_constexpr_copy_ctor_extension_imp<2>(V(101)), "");
 }
 
 int main() {
   test_copy_ctor_basic();
   test_copy_ctor_valueless_by_exception();
   test_copy_ctor_sfinae();
   test_constexpr_copy_ctor_extension();
 }
Index: vendor/libc++/dist/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
===================================================================
--- vendor/libc++/dist/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp	(revision 319785)
+++ vendor/libc++/dist/test/std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp	(revision 319786)
@@ -1,212 +1,336 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 
 // XFAIL: with_system_cxx_lib=macosx10.12
 // XFAIL: with_system_cxx_lib=macosx10.11
 // XFAIL: with_system_cxx_lib=macosx10.10
 // XFAIL: with_system_cxx_lib=macosx10.9
 // XFAIL: with_system_cxx_lib=macosx10.7
 // XFAIL: with_system_cxx_lib=macosx10.8
 
 // <variant>
 
 // template <class ...Types> class variant;
 
 // variant(variant&&) noexcept(see below);
 
 #include <cassert>
 #include <string>
 #include <type_traits>
 #include <variant>
 
 #include "test_macros.h"
 #include "test_workarounds.h"
 
 struct ThrowsMove {
   ThrowsMove(ThrowsMove &&) noexcept(false) {}
 };
 
 struct NoCopy {
   NoCopy(const NoCopy &) = delete;
 };
 
 struct MoveOnly {
   int value;
   MoveOnly(int v) : value(v) {}
   MoveOnly(const MoveOnly &) = delete;
   MoveOnly(MoveOnly &&) = default;
 };
 
 struct MoveOnlyNT {
   int value;
   MoveOnlyNT(int v) : value(v) {}
   MoveOnlyNT(const MoveOnlyNT &) = delete;
   MoveOnlyNT(MoveOnlyNT &&other) : value(other.value) { other.value = -1; }
 };
 
+struct NTMove {
+  constexpr NTMove(int v) : value(v) {}
+  NTMove(const NTMove &) = delete;
+  NTMove(NTMove &&that) : value(that.value) { that.value = -1; }
+  int value;
+};
+
+static_assert(!std::is_trivially_move_constructible<NTMove>::value, "");
+static_assert(std::is_move_constructible<NTMove>::value, "");
+
+struct TMove {
+  constexpr TMove(int v) : value(v) {}
+  TMove(const TMove &) = delete;
+  TMove(TMove &&) = default;
+  int value;
+};
+
+static_assert(std::is_trivially_move_constructible<TMove>::value, "");
+
+struct TMoveNTCopy {
+  constexpr TMoveNTCopy(int v) : value(v) {}
+  TMoveNTCopy(const TMoveNTCopy& that) : value(that.value) {}
+  TMoveNTCopy(TMoveNTCopy&&) = default;
+  int value;
+};
+
+static_assert(std::is_trivially_move_constructible<TMoveNTCopy>::value, "");
+
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct MakeEmptyT {
   static int alive;
   MakeEmptyT() { ++alive; }
   MakeEmptyT(const MakeEmptyT &) {
     ++alive;
     // Don't throw from the copy constructor since variant's assignment
     // operator performs a copy before committing to the assignment.
   }
   MakeEmptyT(MakeEmptyT &&) { throw 42; }
   MakeEmptyT &operator=(const MakeEmptyT &) { throw 42; }
   MakeEmptyT &operator=(MakeEmptyT &&) { throw 42; }
   ~MakeEmptyT() { --alive; }
 };
 
 int MakeEmptyT::alive = 0;
 
 template <class Variant> void makeEmpty(Variant &v) {
   Variant v2(std::in_place_type<MakeEmptyT>);
   try {
-    v = v2;
+    v = std::move(v2);
     assert(false);
   } catch (...) {
     assert(v.valueless_by_exception());
   }
 }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
 void test_move_noexcept() {
   {
     using V = std::variant<int, long>;
     static_assert(std::is_nothrow_move_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, MoveOnly>;
     static_assert(std::is_nothrow_move_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, MoveOnlyNT>;
     static_assert(!std::is_nothrow_move_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, ThrowsMove>;
     static_assert(!std::is_nothrow_move_constructible<V>::value, "");
   }
 }
 
 void test_move_ctor_sfinae() {
   {
     using V = std::variant<int, long>;
     static_assert(std::is_move_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, MoveOnly>;
     static_assert(std::is_move_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, MoveOnlyNT>;
     static_assert(std::is_move_constructible<V>::value, "");
   }
   {
     using V = std::variant<int, NoCopy>;
     static_assert(!std::is_move_constructible<V>::value, "");
   }
+
+  // The following tests are for not-yet-standardized behavior (P0602):
+  {
+    using V = std::variant<int, long>;
+    static_assert(std::is_trivially_move_constructible<V>::value, "");
+  }
+  {
+    using V = std::variant<int, NTMove>;
+    static_assert(!std::is_trivially_move_constructible<V>::value, "");
+    static_assert(std::is_move_constructible<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TMove>;
+    static_assert(std::is_trivially_move_constructible<V>::value, "");
+  }
+  {
+    using V = std::variant<int, TMoveNTCopy>;
+    static_assert(std::is_trivially_move_constructible<V>::value, "");
+  }
 }
 
+template <typename T>
+struct Result { size_t index; T value; };
+
 void test_move_ctor_basic() {
   {
     std::variant<int> v(std::in_place_index<0>, 42);
     std::variant<int> v2 = std::move(v);
     assert(v2.index() == 0);
     assert(std::get<0>(v2) == 42);
   }
   {
     std::variant<int, long> v(std::in_place_index<1>, 42);
     std::variant<int, long> v2 = std::move(v);
     assert(v2.index() == 1);
     assert(std::get<1>(v2) == 42);
   }
   {
     std::variant<MoveOnly> v(std::in_place_index<0>, 42);
     assert(v.index() == 0);
     std::variant<MoveOnly> v2(std::move(v));
     assert(v2.index() == 0);
     assert(std::get<0>(v2).value == 42);
   }
   {
     std::variant<int, MoveOnly> v(std::in_place_index<1>, 42);
     assert(v.index() == 1);
     std::variant<int, MoveOnly> v2(std::move(v));
     assert(v2.index() == 1);
     assert(std::get<1>(v2).value == 42);
   }
   {
     std::variant<MoveOnlyNT> v(std::in_place_index<0>, 42);
     assert(v.index() == 0);
     std::variant<MoveOnlyNT> v2(std::move(v));
     assert(v2.index() == 0);
     assert(std::get<0>(v).value == -1);
     assert(std::get<0>(v2).value == 42);
   }
   {
     std::variant<int, MoveOnlyNT> v(std::in_place_index<1>, 42);
     assert(v.index() == 1);
     std::variant<int, MoveOnlyNT> v2(std::move(v));
     assert(v2.index() == 1);
     assert(std::get<1>(v).value == -1);
     assert(std::get<1>(v2).value == 42);
   }
+
+  // The following tests are for not-yet-standardized behavior (P0602):
+  {
+    struct {
+      constexpr Result<int> operator()() const {
+        std::variant<int> v(std::in_place_index<0>, 42);
+        std::variant<int> v2 = std::move(v);
+        return {v2.index(), std::get<0>(std::move(v2))};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 0, "");
+    static_assert(result.value == 42, "");
+  }
+  {
+    struct {
+      constexpr Result<long> operator()() const {
+        std::variant<int, long> v(std::in_place_index<1>, 42);
+        std::variant<int, long> v2 = std::move(v);
+        return {v2.index(), std::get<1>(std::move(v2))};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1, "");
+    static_assert(result.value == 42, "");
+  }
+  {
+    struct {
+      constexpr Result<TMove> operator()() const {
+        std::variant<TMove> v(std::in_place_index<0>, 42);
+        std::variant<TMove> v2(std::move(v));
+        return {v2.index(), std::get<0>(std::move(v2))};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 0, "");
+    static_assert(result.value.value == 42, "");
+  }
+  {
+    struct {
+      constexpr Result<TMove> operator()() const {
+        std::variant<int, TMove> v(std::in_place_index<1>, 42);
+        std::variant<int, TMove> v2(std::move(v));
+        return {v2.index(), std::get<1>(std::move(v2))};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1, "");
+    static_assert(result.value.value == 42, "");
+  }
+  {
+    struct {
+      constexpr Result<TMoveNTCopy> operator()() const {
+        std::variant<TMoveNTCopy> v(std::in_place_index<0>, 42);
+        std::variant<TMoveNTCopy> v2(std::move(v));
+        return {v2.index(), std::get<0>(std::move(v2))};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 0, "");
+    static_assert(result.value.value == 42, "");
+  }
+  {
+    struct {
+      constexpr Result<TMoveNTCopy> operator()() const {
+        std::variant<int, TMoveNTCopy> v(std::in_place_index<1>, 42);
+        std::variant<int, TMoveNTCopy> v2(std::move(v));
+        return {v2.index(), std::get<1>(std::move(v2))};
+      }
+    } test;
+    constexpr auto result = test();
+    static_assert(result.index == 1, "");
+    static_assert(result.value.value == 42, "");
+  }
 }
 
 void test_move_ctor_valueless_by_exception() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   using V = std::variant<int, MakeEmptyT>;
   V v1;
   makeEmpty(v1);
   V v(std::move(v1));
   assert(v.valueless_by_exception());
-#endif
+#endif // TEST_HAS_NO_EXCEPTIONS
 }
 
 template <size_t Idx>
 constexpr bool test_constexpr_ctor_extension_imp(
     std::variant<long, void*, const int> const& v)
 {
   auto copy = v;
   auto v2 = std::move(copy);
   return v2.index() == v.index() &&
          v2.index() == Idx &&
         std::get<Idx>(v2) == std::get<Idx>(v);
 }
 
 void test_constexpr_move_ctor_extension() {
-  // NOTE: This test is for not yet standardized behavior.
+  // NOTE: This test is for not yet standardized behavior. (P0602)
   using V = std::variant<long, void*, const int>;
 #ifdef TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_destructible<V>::value, "");
   static_assert(std::is_trivially_copy_constructible<V>::value, "");
   static_assert(std::is_trivially_move_constructible<V>::value, "");
   static_assert(!std::is_copy_assignable<V>::value, "");
   static_assert(!std::is_move_assignable<V>::value, "");
-#else
+#else // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_copyable<V>::value, "");
-#endif
+#endif // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_move_constructible<V>::value, "");
   static_assert(test_constexpr_ctor_extension_imp<0>(V(42l)), "");
   static_assert(test_constexpr_ctor_extension_imp<1>(V(nullptr)), "");
   static_assert(test_constexpr_ctor_extension_imp<2>(V(101)), "");
 }
 
 int main() {
   test_move_ctor_basic();
   test_move_ctor_valueless_by_exception();
   test_move_noexcept();
   test_move_ctor_sfinae();
   test_constexpr_move_ctor_extension();
 }
Index: vendor/libc++/dist/test/support/msvc_stdlib_force_include.hpp
===================================================================
--- vendor/libc++/dist/test/support/msvc_stdlib_force_include.hpp	(revision 319785)
+++ vendor/libc++/dist/test/support/msvc_stdlib_force_include.hpp	(revision 319786)
@@ -1,94 +1,92 @@
 //===----------------------------------------------------------------------===//
 //
 //                     The 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 SUPPORT_MSVC_STDLIB_FORCE_INCLUDE_HPP
 #define SUPPORT_MSVC_STDLIB_FORCE_INCLUDE_HPP
 
 // This header is force-included when running the libc++ tests against the
 // MSVC standard library.
 
 #ifndef _LIBCXX_IN_DEVCRT
     // Silence warnings about CRT machinery.
     #define _CRT_SECURE_NO_WARNINGS
 
     // Avoid assertion dialogs.
     #define _CRT_SECURE_INVALID_PARAMETER(EXPR) ::abort()
 #endif // _LIBCXX_IN_DEVCRT
 
 #include <crtdbg.h>
 #include <stdlib.h>
 
 #if defined(_LIBCPP_VERSION)
     #error This header may not be used when targeting libc++
 #endif
 
-// Indicates that we are using the MSVC standard library.
-#ifndef _MSVC_STL_VER
-    #define _MSVC_STL_VER 42
-#endif
-
 #ifndef _LIBCXX_IN_DEVCRT
 struct AssertionDialogAvoider {
     AssertionDialogAvoider() {
         _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
         _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
 
         _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
         _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
     }
 };
 
 const AssertionDialogAvoider assertion_dialog_avoider{};
 #endif // _LIBCXX_IN_DEVCRT
 
 // MSVC frontend only configurations
 #if !defined(__clang__)
     // Simulate feature-test macros.
     #define __has_feature(X) _MSVC_HAS_FEATURE_ ## X
     #define _MSVC_HAS_FEATURE_cxx_exceptions    1
     #define _MSVC_HAS_FEATURE_cxx_rtti          1
     #define _MSVC_HAS_FEATURE_address_sanitizer 0
     #define _MSVC_HAS_FEATURE_memory_sanitizer  0
     #define _MSVC_HAS_FEATURE_thread_sanitizer  0
 
     // Silence compiler warnings.
     #pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored
     #pragma warning(disable: 4521) // multiple copy constructors specified
     #pragma warning(disable: 4702) // unreachable code
     #pragma warning(disable: 28251) // Inconsistent annotation for 'new': this instance has no annotations.
 #endif // !defined(__clang__)
 
 // MSVC doesn't have __int128_t.
 #define _LIBCPP_HAS_NO_INT128
 
 // MSVC has quick_exit() and at_quick_exit().
 #define _LIBCPP_HAS_QUICK_EXIT
 
 #ifndef _LIBCXX_IN_DEVCRT
     // atomic_is_lock_free.pass.cpp needs this VS 2015 Update 2 fix.
     #define _ENABLE_ATOMIC_ALIGNMENT_FIX
 
     // Enable features that /std:c++latest removes by default.
     #define _HAS_AUTO_PTR_ETC          1
     #define _HAS_FUNCTION_ASSIGN       1
     #define _HAS_OLD_IOSTREAMS_MEMBERS 1
 
     // Silence warnings about raw pointers and other unchecked iterators.
     #define _SCL_SECURE_NO_WARNINGS
+
+    // Silence warnings about features that are deprecated in C++17.
+    #define _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
 #endif // _LIBCXX_IN_DEVCRT
 
 #include <ciso646>
 
 #if _HAS_CXX17
     #define TEST_STD_VER 17
 #else // _HAS_CXX17
     #define TEST_STD_VER 14
 #endif // _HAS_CXX17
 
 #endif // SUPPORT_MSVC_STDLIB_FORCE_INCLUDE_HPP
Index: vendor/libc++/dist/test/support/platform_support.h
===================================================================
--- vendor/libc++/dist/test/support/platform_support.h	(revision 319785)
+++ vendor/libc++/dist/test/support/platform_support.h	(revision 319786)
@@ -1,99 +1,102 @@
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Define a bunch of macros that can be used in the tests instead of
 //  implementation defined assumptions:
 //   - locale names
 //   - floating point number string output
 
 #ifndef PLATFORM_SUPPORT_H
 #define PLATFORM_SUPPORT_H
 
 // locale names
 #ifdef _WIN32
 // WARNING: Windows does not support UTF-8 codepages.
 // Locales are "converted" using http://docs.moodle.org/dev/Table_of_locales
-#define LOCALE_en_US_UTF_8     "English_United States.1252"
-#define LOCALE_cs_CZ_ISO8859_2 "Czech_Czech Republic.1250"
-#define LOCALE_fr_FR_UTF_8     "French_France.1252"
-#define LOCALE_fr_CA_ISO8859_1 "French_Canada.1252"
-#define LOCALE_ru_RU_UTF_8     "Russian_Russia.1251"
-#define LOCALE_zh_CN_UTF_8     "Chinese_China.936"
+#define LOCALE_en_US           "en-US"
+#define LOCALE_en_US_UTF_8     "en-US"
+#define LOCALE_cs_CZ_ISO8859_2 "cs-CZ"
+#define LOCALE_fr_FR_UTF_8     "fr-FR"
+#define LOCALE_fr_CA_ISO8859_1 "fr-CA"
+#define LOCALE_ru_RU_UTF_8     "ru-RU"
+#define LOCALE_zh_CN_UTF_8     "zh-CN"
 #elif defined(__CloudABI__)
 // Timezones are integrated into locales through LC_TIMEZONE_MASK on
 // CloudABI. LC_ALL_MASK can only be used if a timezone has also been
 // provided. UTC should be all right.
+#define LOCALE_en_US           "en_US"
 #define LOCALE_en_US_UTF_8     "en_US.UTF-8@UTC"
 #define LOCALE_fr_FR_UTF_8     "fr_FR.UTF-8@UTC"
 #define LOCALE_fr_CA_ISO8859_1 "fr_CA.ISO-8859-1@UTC"
 #define LOCALE_cs_CZ_ISO8859_2 "cs_CZ.ISO-8859-2@UTC"
 #define LOCALE_ru_RU_UTF_8     "ru_RU.UTF-8@UTC"
 #define LOCALE_zh_CN_UTF_8     "zh_CN.UTF-8@UTC"
 #else
+#define LOCALE_en_US           "en_US"
 #define LOCALE_en_US_UTF_8     "en_US.UTF-8"
 #define LOCALE_fr_FR_UTF_8     "fr_FR.UTF-8"
 #ifdef __linux__
 #define LOCALE_fr_CA_ISO8859_1 "fr_CA.ISO-8859-1"
 #define LOCALE_cs_CZ_ISO8859_2 "cs_CZ.ISO-8859-2"
 #else
 #define LOCALE_fr_CA_ISO8859_1 "fr_CA.ISO8859-1"
 #define LOCALE_cs_CZ_ISO8859_2 "cs_CZ.ISO8859-2"
 #endif
 #define LOCALE_ru_RU_UTF_8     "ru_RU.UTF-8"
 #define LOCALE_zh_CN_UTF_8     "zh_CN.UTF-8"
 #endif
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string>
 #if defined(_WIN32) || defined(__MINGW32__)
 #include <io.h> // _mktemp_s
 #else
 #include <unistd.h> // close
 #endif
 
 #if defined(_NEWLIB_VERSION) && defined(__STRICT_ANSI__)
 // Newlib provides this, but in the header it's under __STRICT_ANSI__
 extern "C" {
   int mkstemp(char*);
 }
 #endif
 
 #ifndef __CloudABI__
 inline
 std::string get_temp_file_name()
 {
 #if defined(__MINGW32__)
     char Path[MAX_PATH + 1];
     char FN[MAX_PATH + 1];
     do { } while (0 == GetTempPath(MAX_PATH+1, Path));
     do { } while (0 == GetTempFileName(Path, "libcxx", 0, FN));
     return FN;
 #elif defined(_WIN32)
     char Name[] = "libcxx.XXXXXX";
     if (_mktemp_s(Name, sizeof(Name)) != 0) abort();
     return Name;
 #else
     std::string Name;
     int FD = -1;
     do {
         Name = "libcxx.XXXXXX";
         FD = mkstemp(&Name[0]);
         if (FD == -1 && errno == EINVAL) {
             perror("mkstemp");
             abort();
         }
     } while (FD == -1);
     close(FD);
     return Name;
 #endif
 }
 #endif // __CloudABI__
 
 #endif // PLATFORM_SUPPORT_H
Index: vendor/libc++/dist/test/support/test.workarounds/c1xx_empty_parameter_pack_expansion.pass.cpp
===================================================================
--- vendor/libc++/dist/test/support/test.workarounds/c1xx_empty_parameter_pack_expansion.pass.cpp	(revision 319785)
+++ vendor/libc++/dist/test/support/test.workarounds/c1xx_empty_parameter_pack_expansion.pass.cpp	(nonexistent)
@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03
-
-// Verify TEST_WORKAROUND_C1XX_EMPTY_PARAMETER_PACK_EXPANSION.
-
-#include <type_traits>
-
-#include "test_workarounds.h"
-
-template<class T>
-struct identity {
-    using type = T;
-};
-
-template<class...> struct list {};
-
-// C1XX believes this function template is not viable when LArgs is an empty
-// parameter pack.
-template <class ...LArgs>
-int f2(typename identity<LArgs>::type..., int i) {
-    return i;
-}
-
-#ifdef TEST_WORKAROUND_C1XX_EMPTY_PARAMETER_PACK_EXPANSION
-// C1XX believes this function template *is* viable when LArgs is an empty
-// parameter pack. Conforming compilers believe the two overloads are
-// ambiguous when LArgs is an empty pack.
-template <class ...LArgs>
-int f2(int i) {
-    return i;
-}
-#endif
-
-template <class ...LArgs, class ...Args>
-int f1(list<LArgs...>, Args&&... args) {
-    return f2<LArgs const&...>(args...);
-}
-
-int main() {
-    f1(list<>{}, 42);
-}

Property changes on: vendor/libc++/dist/test/support/test.workarounds/c1xx_empty_parameter_pack_expansion.pass.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: vendor/libc++/dist/test/support/test_workarounds.h
===================================================================
--- vendor/libc++/dist/test/support/test_workarounds.h	(revision 319785)
+++ vendor/libc++/dist/test/support/test_workarounds.h	(revision 319786)
@@ -1,28 +1,27 @@
 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SUPPORT_TEST_WORKAROUNDS_H
 #define SUPPORT_TEST_WORKAROUNDS_H
 
 #include "test_macros.h"
 
 #if defined(TEST_COMPILER_EDG)
 # define TEST_WORKAROUND_EDG_EXPLICIT_CONSTEXPR // VSO#424280
 #endif
 
 #if defined(TEST_COMPILER_C1XX)
 # define TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE // VSO#117743
-# define TEST_WORKAROUND_C1XX_EMPTY_PARAMETER_PACK_EXPANSION // VSO#109062
 # ifndef _MSC_EXTENSIONS
 #  define TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK // VSO#119998
 # endif
 #endif
 
 #endif // SUPPORT_TEST_WORKAROUNDS_H
Index: vendor/libc++/dist/test/support/uses_alloc_types.hpp
===================================================================
--- vendor/libc++/dist/test/support/uses_alloc_types.hpp	(revision 319785)
+++ vendor/libc++/dist/test/support/uses_alloc_types.hpp	(revision 319786)
@@ -1,398 +1,391 @@
 //===----------------------------------------------------------------------===//
 //
 //                     The 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 USES_ALLOC_TYPES_HPP
 #define USES_ALLOC_TYPES_HPP
 
 # include <memory>
 # include <cassert>
 #include <cstdlib>
 
 #include "test_macros.h"
 #include "test_workarounds.h"
 #include "type_id.h"
 
 // There are two forms of uses-allocator construction:
 //   (1) UA_AllocArg: 'T(allocator_arg_t, Alloc const&, Args&&...)'
 //   (2) UA_AllocLast: 'T(Args&&..., Alloc const&)'
 // 'UA_None' represents non-uses allocator construction.
 enum class UsesAllocatorType {
   UA_None = 0,
   UA_AllocArg = 2,
   UA_AllocLast = 4
 };
 constexpr UsesAllocatorType UA_None = UsesAllocatorType::UA_None;
 constexpr UsesAllocatorType UA_AllocArg = UsesAllocatorType::UA_AllocArg;
 constexpr UsesAllocatorType UA_AllocLast = UsesAllocatorType::UA_AllocLast;
 
 inline const char* toString(UsesAllocatorType UA) {
     switch (UA) {
     case UA_None:
         return "UA_None";
     case UA_AllocArg:
         return "UA_AllocArg";
     case UA_AllocLast:
         return "UA_AllocLast";
     default:
     std::abort();
     }
 }
 
 #define COMPARE_ALLOC_TYPE(LHS, RHS) CompareVerbose(#LHS, LHS, #RHS, RHS)
 
 inline bool CompareVerbose(const char* LHSString, UsesAllocatorType LHS,
                            const char* RHSString, UsesAllocatorType RHS) {
     if (LHS == RHS)
         return true;
     std::printf("UsesAllocatorType's don't match:\n%s %s\n----------\n%s %s\n",
                 LHSString, toString(LHS), RHSString, toString(RHS));
     return false;
 }
 
 template <class Alloc, std::size_t N>
 class UsesAllocatorV1;
     // Implements form (1) of uses-allocator construction from the specified
     // 'Alloc' type and exactly 'N' additional arguments. It also provides
     // non-uses allocator construction from 'N' arguments. This test type
     // blows up when form (2) of uses-allocator is even considered.
 
 template <class Alloc, std::size_t N>
 class UsesAllocatorV2;
     // Implements form (2) of uses-allocator construction from the specified
     // 'Alloc' type and exactly 'N' additional arguments. It also provides
     // non-uses allocator construction from 'N' arguments.
 
 template <class Alloc, std::size_t N>
 class UsesAllocatorV3;
     // Implements both form (1) and (2) of uses-allocator construction from
     // the specified 'Alloc' type and exactly 'N' additional arguments. It also
     // provides non-uses allocator construction from 'N' arguments.
 
 template <class Alloc, std::size_t>
 class NotUsesAllocator;
     // Implements both form (1) and (2) of uses-allocator construction from
     // the specified 'Alloc' type and exactly 'N' additional arguments. It also
     // provides non-uses allocator construction from 'N' arguments. However
     // 'NotUsesAllocator' never provides a 'allocator_type' typedef so it is
     // never automatically uses-allocator constructed.
 
 
 template <class ...ArgTypes, class TestType>
 bool checkConstruct(TestType& value, UsesAllocatorType form,
                     typename TestType::CtorAlloc const& alloc)
     // Check that 'value' was constructed using the specified 'form' of
     // construction and with the specified 'ArgTypes...'. Additionally
     // check that 'value' was constructed using the specified 'alloc'.
 {
     if (form == UA_None) {
         return value.template checkConstruct<ArgTypes&&...>(form);
     } else {
         return value.template checkConstruct<ArgTypes&&...>(form, alloc);
     }
 }
 
 
 template <class ...ArgTypes, class TestType>
 bool checkConstruct(TestType& value, UsesAllocatorType form) {
     return value.template checkConstruct<ArgTypes&&...>(form);
 }
 
 template <class TestType>
 bool checkConstructionEquiv(TestType& T, TestType& U)
     // check that 'T' and 'U' where initialized in the exact same manner.
 {
     return T.checkConstructEquiv(U);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 namespace detail {
 
 template <bool IsZero, size_t N, class ArgList, class ...Args>
 struct TakeNImp;
 
 template <class ArgList, class ...Args>
 struct TakeNImp<true, 0, ArgList, Args...> {
   typedef ArgList type;
 };
 
 template <size_t N, class ...A1, class F, class ...R>
 struct TakeNImp<false, N, ArgumentListID<A1...>, F, R...>
     : TakeNImp<N-1 == 0, N - 1, ArgumentListID<A1..., F>, R...> {};
 
 template <size_t N, class ...Args>
 struct TakeNArgs : TakeNImp<N == 0, N, ArgumentListID<>, Args...> {};
 
 template <class T>
 struct Identity { typedef T type; };
 
 template <class T>
 using IdentityT = typename Identity<T>::type;
 
 template <bool Value>
 using EnableIfB = typename std::enable_if<Value, bool>::type;
 
 } // end namespace detail
 
 // FIXME: UsesAllocatorTestBase needs some special logic to deal with
 // polymorphic allocators. However we don't want to include
 // <experimental/memory_resource> in this header. Therefore in order
 // to inject this behavior later we use a trait.
 // See test_memory_resource.hpp for more info.
 template <class Alloc>
 struct TransformErasedTypeAlloc {
   using type = Alloc;
 };
 
 using detail::EnableIfB;
 
 struct AllocLastTag {};
 
 template <class Alloc, bool = std::is_default_constructible<Alloc>::value>
 struct UsesAllocatorTestBaseStorage {
     Alloc allocator;
     UsesAllocatorTestBaseStorage() = default;
     UsesAllocatorTestBaseStorage(Alloc const& a) : allocator(a) {}
     const Alloc* get_allocator() const { return &allocator; }
 };
 
 template <class Alloc>
 struct UsesAllocatorTestBaseStorage<Alloc, false> {
   union {
     char dummy;
     Alloc alloc;
   };
   bool has_alloc = false;
 
   UsesAllocatorTestBaseStorage() : dummy(), has_alloc(false) {}
   UsesAllocatorTestBaseStorage(Alloc const& a) : alloc(a), has_alloc(true) {}
   ~UsesAllocatorTestBaseStorage() {
       if (has_alloc)
           alloc.~Alloc();
   }
 
   Alloc const* get_allocator() const {
       if (!has_alloc)
           return nullptr;
       return &alloc;
   }
 };
 
 template <class Self, class Alloc>
 struct UsesAllocatorTestBase {
 public:
     using CtorAlloc = typename TransformErasedTypeAlloc<Alloc>::type;
 
     template <class ...ArgTypes>
     bool checkConstruct(UsesAllocatorType expectType) const {
         auto expectArgs = &makeArgumentID<ArgTypes...>();
         return COMPARE_ALLOC_TYPE(expectType, constructor_called) &&
                COMPARE_TYPEID(args_id, expectArgs);
     }
 
     template <class ...ArgTypes>
     bool checkConstruct(UsesAllocatorType expectType,
                         CtorAlloc const& expectAlloc) const {
         auto ExpectID = &makeArgumentID<ArgTypes...>() ;
         return COMPARE_ALLOC_TYPE(expectType, constructor_called) &&
                COMPARE_TYPEID(args_id, ExpectID) &&
                has_alloc() && expectAlloc == *get_alloc();
 
     }
 
     bool checkConstructEquiv(UsesAllocatorTestBase& O) const {
         if (has_alloc() != O.has_alloc())
             return false;
         return COMPARE_ALLOC_TYPE(constructor_called, O.constructor_called)
             && COMPARE_TYPEID(args_id, O.args_id)
             && (!has_alloc() || *get_alloc() == *O.get_alloc());
     }
 
 protected:
     explicit UsesAllocatorTestBase(const TypeID* aid)
         : args_id(aid), constructor_called(UA_None), alloc_store()
     {}
 
     UsesAllocatorTestBase(UsesAllocatorTestBase const&)
         : args_id(&makeArgumentID<Self const&>()), constructor_called(UA_None),
           alloc_store()
     {}
 
     UsesAllocatorTestBase(UsesAllocatorTestBase&&)
         : args_id(&makeArgumentID<Self&&>()), constructor_called(UA_None),
           alloc_store()
     {}
 
     template <class ...Args>
     UsesAllocatorTestBase(std::allocator_arg_t, CtorAlloc const& a, Args&&...)
         : args_id(&makeArgumentID<Args&&...>()),
           constructor_called(UA_AllocArg),
           alloc_store(a)
     {}
 
     template <class ...Args, class ArgsIDL = detail::TakeNArgs<sizeof...(Args) - 1, Args&&...>>
     UsesAllocatorTestBase(AllocLastTag, Args&&... args)
         : args_id(&makeTypeIDImp<typename ArgsIDL::type>()),
           constructor_called(UA_AllocLast),
           alloc_store(UsesAllocatorTestBase::getAllocatorFromPack(
             typename ArgsIDL::type{},
             std::forward<Args>(args)...))
     {
     }
 
 private:
     template <class ...LArgs, class ...Args>
     static CtorAlloc getAllocatorFromPack(ArgumentListID<LArgs...>, Args&&... args) {
         return UsesAllocatorTestBase::getAllocatorFromPackImp<LArgs const&...>(args...);
     }
 
     template <class ...LArgs>
     static CtorAlloc getAllocatorFromPackImp(
         typename detail::Identity<LArgs>::type..., CtorAlloc const& alloc) {
         return alloc;
     }
 
-#ifdef TEST_WORKAROUND_C1XX_EMPTY_PARAMETER_PACK_EXPANSION
-    template <class ...LArgs>
-    static CtorAlloc getAllocatorFromPackImp(CtorAlloc const& alloc) {
-        return alloc;
-    }
-#endif
-
     bool has_alloc() const { return alloc_store.get_allocator() != nullptr; }
     const CtorAlloc *get_alloc() const { return alloc_store.get_allocator(); }
 public:
     const TypeID* args_id;
     UsesAllocatorType constructor_called = UA_None;
     UsesAllocatorTestBaseStorage<CtorAlloc> alloc_store;
 };
 
 template <class Alloc, size_t Arity>
 class UsesAllocatorV1 : public UsesAllocatorTestBase<UsesAllocatorV1<Alloc, Arity>, Alloc>
 {
 public:
     typedef Alloc allocator_type;
 
     using Base = UsesAllocatorTestBase<UsesAllocatorV1, Alloc>;
     using CtorAlloc = typename Base::CtorAlloc;
 
     UsesAllocatorV1() : Base(&makeArgumentID<>()) {}
 
     UsesAllocatorV1(UsesAllocatorV1 const&)
         : Base(&makeArgumentID<UsesAllocatorV1 const&>()) {}
     UsesAllocatorV1(UsesAllocatorV1 &&)
         : Base(&makeArgumentID<UsesAllocatorV1 &&>()) {}
     // Non-Uses Allocator Ctor
     template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
     UsesAllocatorV1(Args&&...) : Base(&makeArgumentID<Args&&...>()) {}
 
     // Uses Allocator Arg Ctor
     template <class ...Args>
     UsesAllocatorV1(std::allocator_arg_t tag, CtorAlloc const & a, Args&&... args)
         : Base(tag, a, std::forward<Args>(args)...)
     { }
 
     // BLOWS UP: Uses Allocator Last Ctor
     template <class First, class ...Args, EnableIfB<sizeof...(Args) == Arity> Dummy = false>
     constexpr UsesAllocatorV1(First&&, Args&&...)
     {
         static_assert(!std::is_same<First, First>::value, "");
     }
 };
 
 
 template <class Alloc, size_t Arity>
 class UsesAllocatorV2 : public UsesAllocatorTestBase<UsesAllocatorV2<Alloc, Arity>, Alloc>
 {
 public:
     typedef Alloc allocator_type;
 
     using Base = UsesAllocatorTestBase<UsesAllocatorV2, Alloc>;
     using CtorAlloc = typename Base::CtorAlloc;
 
     UsesAllocatorV2() : Base(&makeArgumentID<>()) {}
     UsesAllocatorV2(UsesAllocatorV2 const&)
         : Base(&makeArgumentID<UsesAllocatorV2 const&>()) {}
     UsesAllocatorV2(UsesAllocatorV2 &&)
         : Base(&makeArgumentID<UsesAllocatorV2 &&>()) {}
 
     // Non-Uses Allocator Ctor
     template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
     UsesAllocatorV2(Args&&...) : Base(&makeArgumentID<Args&&...>()) {}
 
     // Uses Allocator Last Ctor
     template <class ...Args, EnableIfB<sizeof...(Args) == Arity + 1> = false>
     UsesAllocatorV2(Args&&... args)
         : Base(AllocLastTag{}, std::forward<Args>(args)...)
     {}
 };
 
 template <class Alloc, size_t Arity>
 class UsesAllocatorV3 : public UsesAllocatorTestBase<UsesAllocatorV3<Alloc, Arity>, Alloc>
 {
 public:
     typedef Alloc allocator_type;
 
     using Base = UsesAllocatorTestBase<UsesAllocatorV3, Alloc>;
     using CtorAlloc = typename Base::CtorAlloc;
 
     UsesAllocatorV3() : Base(&makeArgumentID<>()) {}
     UsesAllocatorV3(UsesAllocatorV3 const&)
         : Base(&makeArgumentID<UsesAllocatorV3 const&>()) {}
     UsesAllocatorV3(UsesAllocatorV3 &&)
         : Base(&makeArgumentID<UsesAllocatorV3 &&>()) {}
 
     // Non-Uses Allocator Ctor
     template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
     UsesAllocatorV3(Args&&...) : Base(&makeArgumentID<Args&&...>()) {}
 
     // Uses Allocator Arg Ctor
     template <class ...Args>
     UsesAllocatorV3(std::allocator_arg_t tag, CtorAlloc const& alloc, Args&&... args)
         : Base(tag, alloc, std::forward<Args>(args)...)
     {}
 
     // Uses Allocator Last Ctor
     template <class ...Args, EnableIfB<sizeof...(Args) == Arity + 1> = false>
     UsesAllocatorV3(Args&&... args)
         : Base(AllocLastTag{}, std::forward<Args>(args)...)
     {}
 };
 
 template <class Alloc, size_t Arity>
 class NotUsesAllocator : public UsesAllocatorTestBase<NotUsesAllocator<Alloc, Arity>, Alloc>
 {
 public:
     // no allocator_type typedef provided
 
     using Base = UsesAllocatorTestBase<NotUsesAllocator, Alloc>;
     using CtorAlloc = typename Base::CtorAlloc;
 
     NotUsesAllocator() : Base(&makeArgumentID<>()) {}
     NotUsesAllocator(NotUsesAllocator const&)
         : Base(&makeArgumentID<NotUsesAllocator const&>()) {}
     NotUsesAllocator(NotUsesAllocator &&)
         : Base(&makeArgumentID<NotUsesAllocator &&>()) {}
     // Non-Uses Allocator Ctor
     template <class ...Args, EnableIfB<sizeof...(Args) == Arity> = false>
     NotUsesAllocator(Args&&...) : Base(&makeArgumentID<Args&&...>()) {}
 
     // Uses Allocator Arg Ctor
     template <class ...Args>
     NotUsesAllocator(std::allocator_arg_t tag, CtorAlloc const& alloc, Args&&... args)
         : Base(tag, alloc, std::forward<Args>(args)...)
     {}
 
     // Uses Allocator Last Ctor
     template <class ...Args, EnableIfB<sizeof...(Args) == Arity + 1> = false>
     NotUsesAllocator(Args&&... args)
         : Base(AllocLastTag{}, std::forward<Args>(args)...)
     {}
 };
 
 #endif /* USES_ALLOC_TYPES_HPP */
Index: vendor/libc++/dist/test/support/variant_test_helpers.hpp
===================================================================
--- vendor/libc++/dist/test/support/variant_test_helpers.hpp	(revision 319785)
+++ vendor/libc++/dist/test/support/variant_test_helpers.hpp	(revision 319786)
@@ -1,81 +1,81 @@
 // -*- 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 SUPPORT_VARIANT_TEST_HELPERS_HPP
 #define SUPPORT_VARIANT_TEST_HELPERS_HPP
 
 #include <type_traits>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 
 #if TEST_STD_VER <= 14
 #error This file requires C++17
 #endif
 
 // FIXME: Currently the variant<T&> tests are disabled using this macro.
 #define TEST_VARIANT_HAS_NO_REFERENCES
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 struct CopyThrows {
   CopyThrows() = default;
   CopyThrows(CopyThrows const&) { throw 42; }
   CopyThrows& operator=(CopyThrows const&) { throw 42; }
 };
 
 struct MoveThrows {
   static int alive;
   MoveThrows() { ++alive; }
   MoveThrows(MoveThrows const&) {++alive;}
   MoveThrows(MoveThrows&&) {  throw 42; }
   MoveThrows& operator=(MoveThrows const&) { return *this; }
   MoveThrows& operator=(MoveThrows&&) { throw 42; }
   ~MoveThrows() { --alive; }
 };
 
 int MoveThrows::alive = 0;
 
 struct MakeEmptyT {
   static int alive;
   MakeEmptyT() { ++alive; }
   MakeEmptyT(MakeEmptyT const&) {
       ++alive;
       // Don't throw from the copy constructor since variant's assignment
       // operator performs a copy before committing to the assignment.
   }
   MakeEmptyT(MakeEmptyT &&) {
       throw 42;
   }
   MakeEmptyT& operator=(MakeEmptyT const&) {
       throw 42;
   }
   MakeEmptyT& operator=(MakeEmptyT&&) {
       throw 42;
   }
    ~MakeEmptyT() { --alive; }
 };
 static_assert(std::is_swappable_v<MakeEmptyT>, ""); // required for test
 
 int MakeEmptyT::alive = 0;
 
 template <class Variant>
 void makeEmpty(Variant& v) {
     Variant v2(std::in_place_type<MakeEmptyT>);
     try {
-        v = v2;
+        v = std::move(v2);
         assert(false);
-    }  catch (...) {
+    } catch (...) {
         assert(v.valueless_by_exception());
     }
 }
 #endif // TEST_HAS_NO_EXCEPTIONS
 
 
 #endif // SUPPORT_VARIANT_TEST_HELPERS_HPP
Index: vendor/libc++/dist/www/cxx1z_status.html
===================================================================
--- vendor/libc++/dist/www/cxx1z_status.html	(revision 319785)
+++ vendor/libc++/dist/www/cxx1z_status.html	(revision 319786)
@@ -1,495 +1,495 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
           "http://www.w3.org/TR/html4/strict.dtd">
 <!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
 <html>
 <head>
   <meta http-equiv="content-type" content="text/html; charset=utf-8">
   <title>libc++ C++1Z Status</title>
   <link type="text/css" rel="stylesheet" href="menu.css">
   <link type="text/css" rel="stylesheet" href="content.css">
 </head>
 
 <body>
 <div id="menu">
   <div>
     <a href="http://llvm.org/">LLVM Home</a>
   </div>
 
   <div class="submenu">
     <label>libc++ Info</label>
     <a href="/index.html">About</a>
   </div>
 
   <div class="submenu">
     <label>Quick Links</label>
     <a href="http://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
     <a href="http://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
     <a href="https://bugs.llvm.org/">Bug Reports</a>
     <a href="http://llvm.org/svn/llvm-project/libcxx/trunk/">Browse SVN</a>
     <a href="http://llvm.org/viewvc/llvm-project/libcxx/trunk/">Browse ViewVC</a>
   </div>
 </div>
 
 <div id="content">
   <!--*********************************************************************-->
   <h1>libc++ C++1z Status</h1>
   <!--*********************************************************************-->
 
   <p>In November 2014, the C++ standard committee created a draft for the next version of the C++ standard, known here as "C++1z" (probably to be C++17).</p>
   <p>In February 2017, the C++ standard committee approved this draft, and sent it to ISO for approval as C++17</p>
   <p>This page shows the status of libc++; the status of clang's support of the language features is <a href="http://clang.llvm.org/cxx_status.html#cxx17">here</a>.</p>
 
   <p>The groups that have contributed papers:
   <ul>
     <li>LWG - Library working group</li>
     <li>CWG - Core Language Working group</li>
     <li>SG1 - Study group #1 (Concurrency working group)</li>
   </ul>
   </p>
-  
+
   <h3>Paper Status</h3>
   <table id="papers" border="1">
 	<tr><th>Paper #</th><th>Group</th><th>Paper Name</th><th>Meeting</th><th>Status</th><th>First released version</th></tr>
 <!--
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3346.pdf">3346</a></td><td>LWG</td><td>Terminology for Container Element Requirements - Rev 1</td><td>Kona</td><td>Complete</td><td>3.4</td></tr>
 -->
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3911">N3911</a></td><td>LWG</td></td><td>TransformationTrait Alias <code>void_t</code>.</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4089">N4089</a></td><td>LWG</td></td><td>Safe conversions in <code>unique_ptr&lt;T[]&gt;</code>.</td><td>Urbana</td><td>In progress</td><td>3.9</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4169">N4169</a></td><td>LWG</td></td><td>A proposal to add invoke function template</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4190">N4190</a></td></td><td>LWG</td><td>Removing auto_ptr, random_shuffle(), And Old <functional> Stuff.</td><td>Urbana</td><td>In progress</td><td></td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4258">N4258</a></td><td>LWG</td></td><td>Cleaning-up noexcept in the Library.</td><td>Urbana</td><td>In progress</td><td>3.7</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4259">N4259</a></td><td>CWG</td></td><td>Wording for std::uncaught_exceptions</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4277">N4277</a></td><td>LWG</td></td><td>TriviallyCopyable <code>reference_wrapper</code>.</td><td>Urbana</td><td>Complete</td><td>3.2</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4279">N4279</a></td><td>LWG</td></td><td>Improved insertion interface for unique-key maps.</td><td>Urbana</td><td>Complete</td><td>3.7</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4280">N4280</a></td><td>LWG</td></td><td>Non-member size() and more</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4284">N4284</a></td><td>LWG</td></td><td>Contiguous Iterators.</td><td>Urbana</td><td>Complete</td><td>3.6</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4285">N4285</a></td><td>CWG</td></td><td>Cleanup for exception-specification and throw-expression.</td><td>Urbana</td><td>Complete</td><td>4.0</td></tr>
   	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4387">N4387</a></td><td>LWG</td></td><td>improving pair and tuple</td><td>Lenexa</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4389">N4389</a></td><td>LWG</td></td><td>bool_constant</td><td>Lenexa</td><td>Complete</td><td>3.7</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4508">N4508</a></td><td>LWG</td></td><td>shared_mutex for C++17</td><td>Lenexa</td><td>Complete</td><td>3.7</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4366">N4366</a></td><td>LWG</td></td><td>LWG 2228 missing SFINAE rule</td><td>Lenexa</td><td>Complete</td><td>3.1</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4510">N4510</a></td><td>LWG</td></td><td>Minimal incomplete type support for standard containers, revision 4</td><td>Lenexa</td><td>Complete</td><td>3.6</td></tr>
   	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0004r1.html">P0004R1</a></td><td>LWG</td><td>Remove Deprecated iostreams aliases.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0006r0.html">P0006R0</a></td><td>LWG</td><td>Adopt Type Traits Variable Templates for C++17.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0092r1.html">P0092R1</a></td><td>LWG</td><td>Polishing &lt;chrono&gt;</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0007r1.html">P0007R1</a></td><td>LWG</td><td>Constant View: A proposal for a <tt>std::as_const</tt> helper function template.</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0156r0.html" >P0156R0</a></td><td>LWG</td><td>Variadic lock_guard(rev 3).</td><td>Kona</td><td><I>Reverted in Kona</I></td><td>3.9</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0074r0.html">P0074R0</a></td><td>LWG</td><td>Making <tt>std::owner_less</tt> more flexible</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
 	<tr><td><a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0013r1.html">P0013R1</a></td><td>LWG</td><td>Logical type traits rev 2</td><td>Kona</td><td>Complete</td><td>3.8</td></tr>
   	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0024R2">P0024R2</a></td><td>LWG</td><td>The Parallelism TS Should be Standardized</td><td>Jacksonville</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0226R1">P0226R1</a></td><td>LWG</td><td>Mathematical Special Functions for C++17</td><td>Jacksonville</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0220R1">P0220R1</a></td><td>LWG</td><td>Adopt Library Fundamentals V1 TS Components for C++17</td><td>Jacksonville</td><td>In Progress</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0218R1">P0218R1</a></td><td>LWG</td><td>Adopt the File System TS for C++17</td><td>Jacksonville</td><td>In Progress</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0033R1">P0033R1</a></td><td>LWG</td><td>Re-enabling shared_from_this</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
 	<tr><td><a href="http://wg21.link/P0005R4">P0005R4</a></td><td>LWG</td><td>Adopt not_fn from Library Fundamentals 2 for C++17</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
 	<tr><td><a href="http://wg21.link/P0152R1">P0152R1</a></td><td>LWG</td><td>constexpr atomic::is_always_lock_free</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
 	<tr><td><a href="http://wg21.link/P0185R1">P0185R1</a></td><td>LWG</td><td>Adding [nothrow-]swappable traits</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
 	<tr><td><a href="http://wg21.link/P0253R1">P0253R1</a></td><td>LWG</td><td>Fixing a design mistake in the searchers interface</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
 	<tr><td><a href="http://wg21.link/P0025R0">P0025R0</a></td><td>LWG</td><td>An algorithm to "clamp" a value between a pair of boundary values</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
 	<tr><td><a href="http://wg21.link/P0154R1">P0154R1</a></td><td>LWG</td><td>constexpr std::hardware_{constructive,destructive}_interference_size</td><td>Jacksonville</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0030R1">P0030R1</a></td><td>LWG</td><td>Proposal to Introduce a 3-Argument Overload to std::hypot</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
 	<tr><td><a href="http://wg21.link/P0031R0">P0031R0</a></td><td>LWG</td><td>A Proposal to Add Constexpr Modifiers to reverse_iterator, move_iterator, array and Range Access</td><td>Jacksonville</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0272R1">P0272R1</a></td><td>LWG</td><td>Give <tt>std::string</tt> a non-const <tt>.data()</tt> member function</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
 	<tr><td><a href="http://wg21.link/P0077R2">P0077R2</a></td><td>LWG</td><td><tt>is_callable</tt>, the missing INVOKE related trait</td><td>Jacksonville</td><td>Complete</td><td>3.9</td></tr>
   	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/p0032r3">p0032r3</a></td><td>LWG</td><td>Homogeneous interface for variant, any and optional</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/p0040r3">p0040r3</a></td><td>LWG</td><td>Extending memory management tools</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/p0063r3">p0063r3</a></td><td>LWG</td><td>C++17 should refer to C11 instead of C99</td><td>Oulu</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
 	<tr><td><a href="http://wg21.link/p0067r3">p0067r3</a></td><td>LWG</td><td>Elementary string conversions</td><td>Oulu</td><td>Now <a href="http://wg21.link/P0067R5">P0067R5</a></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/p0083r3">p0083r3</a></td><td>LWG</td><td>Splicing Maps and Sets</td><td>Oulu</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/p0084r2">p0084r2</a></td><td>LWG</td><td>Emplace Return Type</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/p0088r3">p0088r3</a></td><td>LWG</td><td>Variant: a type-safe union for C++17</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/p0163r0">p0163r0</a></td><td>LWG</td><td>shared_ptr::weak_type</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
 	<tr><td><a href="http://wg21.link/p0174r2">p0174r2</a></td><td>LWG</td><td>Deprecating Vestigial Library Parts in C++17</td><td>Oulu</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/p0175r1">p0175r1</a></td><td>LWG</td><td>Synopses for the C library</td><td>Oulu</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/p0180r2">p0180r2</a></td><td>LWG</td><td>Reserve a New Library Namespace for Future Standardization</td><td>Oulu</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
 	<tr><td><a href="http://wg21.link/p0181r1">p0181r1</a></td><td>LWG</td><td>Ordered by Default</td><td>Oulu</td><td><i>Removed in Kona</i></td><td>n/a</td></tr>
 	<tr><td><a href="http://wg21.link/p0209r2">p0209r2</a></td><td>LWG</td><td>make_from_tuple: apply for construction</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
 	<tr><td><a href="http://wg21.link/p0219r1">p0219r1</a></td><td>LWG</td><td>Relative Paths for Filesystem</td><td>Oulu</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/p0254r2">p0254r2</a></td><td>LWG</td><td>Integrating std::string_view and std::string</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/p0258r2">p0258r2</a></td><td>LWG</td><td>has_unique_object_representations</td><td>Oulu</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/p0295r0">p0295r0</a></td><td>LWG</td><td>Adopt Selected Library Fundamentals V2 Components for C++17</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/p0302r1">p0302r1</a></td><td>LWG</td><td>Removing Allocator Support in std::function</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/p0307r2">p0307r2</a></td><td>LWG</td><td>Making Optional Greater Equal Again</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/p0336r1">p0336r1</a></td><td>LWG</td><td>Better Names for Parallel Execution Policies in C++17</td><td>Oulu</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/p0337r0">p0337r0</a></td><td>LWG</td><td>Delete operator= for polymorphic_allocator</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
 	<tr><td><a href="http://wg21.link/p0346r1">p0346r1</a></td><td>LWG</td><td>A &lt;random&gt; Nomenclature Tweak</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
 	<tr><td><a href="http://wg21.link/p0358r1">p0358r1</a></td><td>LWG</td><td>Fixes for not_fn</td><td>Oulu</td><td>Complete</td><td>3.9</td></tr>
 	<tr><td><a href="http://wg21.link/p0371r1">p0371r1</a></td><td>LWG</td><td>Temporarily discourage memory_order_consume</td><td>Oulu</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
 	<tr><td><a href="http://wg21.link/p0392r0">p0392r0</a></td><td>LWG</td><td>Adapting string_view by filesystem paths</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/p0393r3">p0393r3</a></td><td>LWG</td><td>Making Variant Greater Equal</td><td>Oulu</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0394r4">P0394r4</a></td><td>LWG</td><td>Hotel Parallelifornia: terminate() for Parallel Algorithms Exception Handling</td><td>Oulu</td><td></td><td></td></tr>
   	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0003R5">P0003R5</a></td><td>LWG</td><td>Removing Deprecated Exception Specifications from C++17</td><td>Issaquah</td><td>Complete</td><td>5.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0067R5">P0067R5</a></td><td>LWG</td><td>Elementary string conversions, revision 5</td><td>Issaquah</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0403R1">P0403R1</a></td><td>LWG</td><td>Literal suffixes for <tt>basic_string_view</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0414R2">P0414R2</a></td><td>LWG</td><td>Merging shared_ptr changes from Library Fundamentals to C++17</td><td>Issaquah</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0418R2">P0418R2</a></td><td>LWG</td><td>Fail or succeed: there is no atomic lattice</td><td>Issaquah</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0426R1">P0426R1</a></td><td>LWG</td><td>Constexpr for <tt>std::char_traits</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0435R1">P0435R1</a></td><td>LWG</td><td>Resolving LWG Issues re <tt>common_type</tt></td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0502R0">P0502R0</a></td><td>LWG</td><td>Throwing out of a parallel algorithm terminates - but how?</td><td>Issaquah</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0503R0">P0503R0</a></td><td>LWG</td><td>Correcting library usage of "literal type"</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0504R0">P0504R0</a></td><td>LWG</td><td>Revisiting in-place tag types for any/optional/variant</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0505R0">P0505R0</a></td><td>LWG</td><td>Wording for GB 50 - constexpr for chrono</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0508R0">P0508R0</a></td><td>LWG</td><td>Wording for GB 58 - structured bindings for node_handles</td><td>Issaquah</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0509R1">P0509R1</a></td><td>LWG</td><td>Updating “Restrictions on exception handling”</td><td>Issaquah</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
 	<tr><td><a href="http://wg21.link/P0510R0">P0510R0</a></td><td>LWG</td><td>Disallowing references, incomplete types, arrays, and empty variants</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0513R0">P0513R0</a></td><td>LWG</td><td>Poisoning the Hash</td><td>Issaquah</td><td>Complete</td><td>5.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0516R0">P0516R0</a></td><td>LWG</td><td>Clarify That shared_future’s Copy Operations have Wide Contracts</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0517R0">P0517R0</a></td><td>LWG</td><td>Make future_error Constructible</td><td>Issaquah</td><td>Complete</td><td>4.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0521R0">P0521R0</a></td><td>LWG</td><td>Proposed Resolution for CA 14 (shared_ptr use_count/unique)</td><td>Issaquah</td><td><i>Nothing to do</i></td><td>n/a</td></tr>
   	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0156R2">P0156R2</a></td><td>LWG</td><td>Variadic Lock guard(rev 5)</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0270R3">P0270R3</a></td><td>CWG</td><td>Removing C dependencies from signal handler wording</td><td>Kona</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0298R3">P0298R3</a></td><td>CWG</td><td>A byte type definition</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0317R1">P0317R1</a></td><td>LWG</td><td>Directory Entry Caching for Filesystem</td><td>Kona</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0430R2">P0430R2</a></td><td>LWG</td><td>File system library on non-POSIX-like operating systems</td><td>Kona</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0433R2">P0433R2</a></td><td>LWG</td><td>Toward a resolution of US7 and US14: Integrating template deduction for class templates into the standard library</td><td>Kona</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0452R1">P0452R1</a></td><td>LWG</td><td>Unifying &lt;numeric&gt; Parallel Algorithms</td><td>Kona</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0467R2">P0467R2</a></td><td>LWG</td><td>Iterator Concerns for Parallel Algorithms</td><td>Kona</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0492R2">P0492R2</a></td><td>LWG</td><td>Proposed Resolution of C++17 National Body Comments for Filesystems</td><td>Kona</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0518R1">P0518R1</a></td><td>LWG</td><td>Allowing copies as arguments to function objects given to parallel algorithms in response to CH11</td><td>Kona</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0523R1">P0523R1</a></td><td>LWG</td><td>Wording for CH 10: Complexity of parallel algorithms</td><td>Kona</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0548R1">P0548R1</a></td><td>LWG</td><td>common_type and duration</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0558R1">P0558R1</a></td><td>LWG</td><td>Resolving atomic&lt;T&gt; named base class inconsistencies</td><td>Kona</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0574R1">P0574R1</a></td><td>LWG</td><td>Algorithm Complexity Constraints and Parallel Overloads</td><td>Kona</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0599R1">P0599R1</a></td><td>LWG</td><td>noexcept for hash functions</td><td>Kona</td><td>Complete</td><td>5.0</td></tr>
 	<tr><td><a href="http://wg21.link/P0604R0">P0604R0</a></td><td>LWG</td><td>Resolving GB 55, US 84, US 85, US 86</td><td>Kona</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0607R0">P0607R0</a></td><td>LWG</td><td>Inline Variables for the Standard Library</td><td>Kona</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0618R0">P0618R0</a></td><td>LWG</td><td>Deprecating &lt;codecvt&gt;</td><td>Kona</td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/P0623R0">P0623R0</a></td><td>LWG</td><td>Final C++17 Parallel Algorithms Fixes</td><td>Kona</td><td></td><td></td></tr>
 
 <!--  	<tr><td></td><td></td><td></td><td></td><td></td><td></td></tr> -->
   </table>
 
 <p><i>[ Note: "Nothing to do" means that no library changes were needed to implement this change -- end note]</i></p>
 
   <h3>Library Working group Issues Status</h3>
 <!--   <I>Note: "NAD" means that the issue was deemed "Not a defect"</I> -->
   <table id="issues" border="1">
 	<tr><th>Issue #</th><th>Issue Name</th><th>Meeting</th><th>Status</th></tr>
 	<tr><td><a href="http://wg21.link/LWG2016">2016</a></td><td>Allocators must be no-throw swappable</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2376">2118</td><td><code>unique_ptr</code> for array does not support cv qualification conversion of actual argument</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2170">2170</a></td><td>Aggregates cannot be <code>DefaultConstructible</code></td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2308">2308</td><td>Clarify container destructor requirements w.r.t. <code>std::array</code></td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2340">2340</a></td><td>Replacement allocation functions declared as inline</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2354">2354</a></td><td>Unnecessary copying when inserting into maps with braced-init syntax</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2377">2377</a></td><td><code>std::align</code> requirements overly strict</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2396">2396</a></td><td><code>underlying_type</code> doesn't say what to do for an incomplete enumeration type</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2399">2399</a></td><td><code>shared_ptr</code>'s constructor from <code>unique_ptr</code> should be constrained</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2400">2400</a></td><td><code>shared_ptr</code>'s <code>get_deleter()</code> should use <code>addressof()</code></td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2401">2401</a></td><td><code>std::function</code> needs more noexcept</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2404">2404</a></td><td><code>mismatch()</code>'s complexity needs to be updated</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2408">2408</a></td><td>SFINAE-friendly <code>common_type</code> / <code>iterator_traits</code> is missing in C++14</td><td>Urbana</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2106">2106</td><td><code>move_iterator</code> wrapping iterators returning prvalues</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2129">2129</td><td>User specializations of <code>std::initializer_list</code></td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2212">2212</td><td><code>tuple_size</code> for <code>const pair</code> request <tuple> header</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2217">2217</td><td><code>operator==(sub_match, string)</code> slices on embedded '\0's</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2230">2230</td><td>"see below" for <code>initializer_list</code> constructors of unordered containers</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2233">2233</td><td><code>bad_function_call::what()</code> unhelpful</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2266">2266</td><td><code>vector</code> and <code>deque</code> have incorrect insert requirements</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2325">2325</td><td><code>minmax_element()</code>'s behavior differing from <code>max_element()</code>'s should be noted</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2361">2361</td><td>Apply 2299 resolution throughout library</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2365">2365</td><td>Missing noexcept in <code>shared_ptr::shared_ptr(nullptr_t)</code></td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2376">2376</td><td><code>bad_weak_ptr::what()</code> overspecified</td><td>Urbana</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2387">2387</td><td>More nested types that must be accessible and unambiguous</td><td>Urbana</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2059">2059</td><td>C++0x ambiguity problem with map::erase</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2063">2063</td><td>Contradictory requirements for string move assignment</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2076">2076</td><td>Bad CopyConstructible requirement in set constructors</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2160">2160</td><td>Unintended destruction ordering-specification of resize</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2168">2168</td><td>Inconsistent specification of uniform_real_distribution constructor</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2239">2239</td><td>min/max/minmax requirements</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2364">2364</td><td>deque and vector pop_back don't specify iterator invalidation requirements</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2369">2369</td><td>constexpr max(initializer_list) vs max_element</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2378">2378</td><td>Behaviour of standard exception types</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2403">2403</td><td>stof() should call strtof() and wcstof()</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2406">2406</td><td>negative_binomial_distribution should reject p == 1</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2407">2407</td><td>packaged_task(allocator_arg_t, const Allocator&, F&&) should neither be constrained nor explicit</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2411">2411</td><td>shared_ptr is only contextually convertible to bool</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2415">2415</td><td>Inconsistency between unique_ptr and shared_ptr</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2420">2420</td><td>function<void(ArgTypes...)> does not discard the return value of the target object</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2425">2425</td><td>operator delete(void*, size_t) doesn't invalidate pointers sufficiently</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2427">2427</td><td>Container adaptors as sequence containers, redux</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2428">2428</td><td>"External declaration" used without being defined</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2433">2433</td><td>uninitialized_copy()/etc. should tolerate overloaded operator&</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2434">2434</td><td>shared_ptr::use_count() is efficient</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2437">2437</td><td>iterator_traits::reference can and can't be void</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2438">2438</td><td>std::iterator inheritance shouldn't be mandated</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2439">2439</td><td>unique_copy() sometimes can't fall back to reading its output</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2440">2440</td><td>seed_seq::size() should be noexcept</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2442">2442</td><td>call_once() shouldn't DECAY_COPY()</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2448">2448</td><td>Non-normative Container destructor specification</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2454">2454</td><td>Add raw_storage_iterator::base() member</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2455">2455</td><td>Allocator default construction should be allowed to throw</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2458">2458</td><td>N3778 and new library deallocation signatures</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2459">2459</td><td>std::polar should require a non-negative rho</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2464">2464</td><td>try_emplace and insert_or_assign misspecified</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2467">2467</td><td>is_always_equal has slightly inconsistent default</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2470">2470</td><td>Allocator's destroy function should be allowed to fail to instantiate</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2482">2482</td><td>[c.strings] Table 73 mentions nonexistent functions</td><td>Lenexa</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2488">2488</td><td>Placeholders should be allowed and encouraged to be constexpr</td><td>Lenexa</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG1169">1169</a></td><td><tt>num_get</tt> not fully compatible with <tt>strto*</tt></td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2072">2072</a></td><td>Unclear wording about capacity of temporary buffers</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2101">2101</a></td><td>Some transformation types can produce impossible types</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2111">2111</a></td><td>Which <tt>unexpected</tt>&#47;<tt>terminate</tt> handler is called from the exception handling runtime?</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2119">2119</a></td><td>Missing <tt>hash</tt> specializations for extended integer types</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2127">2127</a></td><td>Move-construction with <tt>raw_storage_iterator</tt></td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2133">2133</a></td><td>Attitude to overloaded comma for iterators</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2156">2156</a></td><td>Unordered containers' <tt>reserve(n)</tt> reserves for <tt>n-1</tt> elements</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2218">2218</a></td><td>Unclear how containers use <tt>allocator_traits::construct()</tt></td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2219">2219</a></td><td><tt><i>INVOKE</i></tt>-ing a pointer to member with a <tt>reference_wrapper</tt> as the object expression</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2224">2224</a></td><td>Ambiguous status of access to non-live objects</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2234">2234</a></td><td><tt>assert()</tt> should allow usage in constant expressions</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2244">2244</a></td><td>Issue on <tt>basic_istream::seekg</tt></td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2250">2250</a></td><td>Follow-up On Library Issue 2207</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2259">2259</a></td><td>Issues in 17.6.5.5 rules for member functions</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2273">2273</a></td><td><tt>regex_match</tt> ambiguity</td><td>Kona</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2336">2336</a></td><td><tt>is_trivially_constructible/is_trivially_assignable</tt> traits are always false</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2353">2353</a></td><td><tt>std::next</tt> is over-constrained</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2367">2367</a></td><td><tt>pair</tt> and <tt>tuple</tt> are not correctly implemented for <tt>is_constructible</tt> with no args</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2380">2380</a></td><td>May <tt>&lt;cstdlib&gt;</tt> provide <tt>long ::abs(long)</tt> and <tt>long long ::abs(long long)</tt>?</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2384">2384</a></td><td>Allocator's <tt>deallocate</tt> function needs better specification</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2385">2385</a></td><td><tt>function::assign</tt> allocator argument doesn't make sense</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2435">2435</a></td><td><tt>reference_wrapper::operator()</tt>'s Remark should be deleted</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2447">2447</a></td><td>Allocators and <tt>volatile</tt>-qualified value types</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2462">2462</a></td><td><tt>std::ios_base::failure</tt> is overspecified</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2466">2466</a></td><td><tt>allocator_traits::max_size()</tt> default behavior is incorrect</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2469">2469</a></td><td>Wrong specification of Requires clause of <tt>operator[]</tt> for <tt>map</tt> and <tt>unordered_map</tt></td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2473">2473</a></td><td><tt>basic_filebuf</tt>'s relation to C <tt>FILE</tt> semantics</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2476">2476</a></td><td><tt>scoped_allocator_adaptor</tt> is not assignable</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2477">2477</a></td><td>Inconsistency of wordings in <tt>std::vector::erase()</tt> and <tt>std::deque::erase()</tt></td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2483">2483</a></td><td><tt>throw_with_nested()</tt> should use <tt>is_final</tt></td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2484">2484</a></td><td><tt>rethrow_if_nested()</tt> is doubly unimplementable</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2485">2485</a></td><td><tt>get()</tt> should be overloaded for <tt>const tuple&amp;&amp;</tt></td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2486">2486</a></td><td><tt>mem_fn()</tt> should be required to use perfect forwarding</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2487">2487</a></td><td><tt>bind()</tt> should be <tt>const</tt>-overloaded, not <i>cv</i>-overloaded</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2489">2489</a></td><td><tt>mem_fn()</tt> should be <tt>noexcept</tt></td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2492">2492</a></td><td>Clarify requirements for <tt>comp</tt></td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2495">2495</a></td><td>There is no such thing as an Exception Safety element</td><td>Kona</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2192">2192</a></td><td>Validity and return type of <tt>std::abs(0u)</tt> is unclear</td><td>Jacksonville</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2276">2276</a></td><td>Missing requirement on <tt>std::promise::set_exception</tt></td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2296">2296</a></td><td><tt>std::addressof</tt> should be <tt>constexpr</td><td>Jacksonville</td><td>Complete (Clang Only)</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2450">2450</a></td><td><tt>(greater|less|greater_equal|less_equal)&lt;void&gt;</tt> do not yield a total order for pointers</td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2520">2520</a></td><td>N4089 broke initializing <tt>unique_ptr&lt;T[]&gt;</tt> from a <tt>nullptr</tt></td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2522">2522</a></td><td>[fund.ts.v2] Contradiction in <tt>set_default_resource</tt> specification</td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2523">2523</a></td><td><tt>std::promise</tt> synopsis shows two <tt>set_value_at_thread_exit()</tt>'s for no apparent reason</td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2537">2537</a></td><td>Constructors for <code>priority_queue</code> taking allocators should call <code>make_heap</code></td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2539">2539</a></td><td>[fund.ts.v2] <tt>invocation_trait</tt> definition definition doesn't work for surrogate call functions</td><td>Jacksonville</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2545">2545</a></td><td>Simplify wording for <tt>bind</tt> without explicitly specified return type</td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2557">2557</a></td><td>Logical operator traits are broken in the zero-argument case</td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2558">2558</a></td><td>[fund.ts.v2] Logical operator traits are broken in the zero-argument case</td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2559">2559</a></td><td>Error in LWG 2234's resolution</td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2560">2560</a></td><td><tt>is_constructible</tt> underspecified when applied to a function type</td><td>Jacksonville</td><td>Broken in 3.6; See r261653.</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2565">2565</a></td><td><tt>std::function</tt>'s move constructor should guarantee nothrow for <tt>reference_wrapper</tt>s and function pointers</td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2566">2566</a></td><td>Requirements on the first template parameter of container adaptors</td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2571">2571</a></td><td>&sect;[map.modifiers]/2 imposes nonsensical requirement on <tt>insert(InputIterator, InputIterator)</tt></td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2572">2572</a></td><td>The remarks for <tt>shared_ptr::operator*</tt> should apply to <i>cv</i>-qualified <tt>void</tt> as well</td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2574">2574</a></td><td>[fund.ts.v2] <tt>std::experimental::function::operator=(F&amp;&amp;)</tt> should be constrained</td><td>Jacksonville</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2575">2575</a></td><td>[fund.ts.v2] <tt>experimental::function::assign</tt> should be removed</td><td>Jacksonville</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2576">2576</a></td><td><tt>istream_iterator</tt> and <tt>ostream_iterator</tt> should use <tt>std::addressof</tt></td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2577">2577</a></td><td><tt>{shared,unique}_lock</tt> should use <tt>std::addressof</tt></td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2579">2579</a></td><td>Inconsistency wrt Allocators in <tt>basic_string</tt> assignment vs. <tt>basic_string::assign</tt></td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2581">2581</a></td><td>Specialization of <tt>&lt;type_traits&gt;</tt> variable templates should be prohibited</td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2582">2582</a></td><td>&sect;[res.on.functions]/2's prohibition against incomplete types shouldn't apply to type traits</td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2583">2583</a></td><td>There is no way to supply an allocator for <tt>basic_string(str, pos)</tt></td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2585">2585</a></td><td><tt>forward_list::resize(size_type, const value_type&amp;)</tt> effects incorrect</td><td>Jacksonville</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2586">2586</a></td><td>Wrong value category used in <tt>scoped_allocator_adaptor::construct()</tt></td><td>Jacksonville</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2590">2590</a></td><td>Aggregate initialization for <tt>std::array</tt></td><td>Jacksonville</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2181">2181</a></td><td>Exceptions from seed sequence operations</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2309">2309</a></td><td>mutex::lock() should not throw device_or_resource_busy</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2310">2310</a></td><td>Public exposition only member in std::array</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2312">2312</a></td><td>tuple's constructor constraints need to be phrased more precisely</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2328">2328</a></td><td>Rvalue stream extraction should use perfect forwarding</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2393">2393</a></td><td>std::function's Callable definition is broken</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2422">2422</a></td><td>std::numeric_limits&lt;T&gt;::is_modulo description: "most machines" errata</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2426">2426</a></td><td>Issue about compare_exchange</td><td>Oulu</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2436">2436</a></td><td>Comparators for associative containers should always be CopyConstructible</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2441">2441</a></td><td>Exact-width atomic typedefs should be provided</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2451">2451</a></td><td>[fund.ts.v2] optional should 'forward' T's implicit conversions</td><td>Oulu</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2509">2509</a></td><td>[fund.ts.v2] any_cast doesn't work with rvalue reference targets and cannot move with a value target</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2516">2516</a></td><td>[fund.ts.v2] Public "exposition only" members in observer_ptr</td><td>Oulu</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2542">2542</a></td><td>Missing const requirements for associative containers</td><td>Oulu</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2549">2549</a></td><td>Tuple EXPLICIT constructor templates that take tuple parameters end up taking references to temporaries and will create dangling references</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2550">2550</a></td><td>Wording of unordered container's clear() method complexity</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2551">2551</a></td><td>[fund.ts.v2] "Exception safety" cleanup in library fundamentals required</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2555">2555</a></td><td>[fund.ts.v2] No handling for over-aligned types in optional</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2573">2573</a></td><td>[fund.ts.v2] std::hash&lt;std::experimental::shared_ptr&gt; does not work for arrays</td><td>Oulu</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2596">2596</a></td><td>vector::data() should use addressof</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2667">2667</a></td><td>path::root_directory() description is confusing</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2669">2669</a></td><td>recursive_directory_iterator effects refers to non-existent functions</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2670">2670</a></td><td>system_complete refers to undefined variable 'base'</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2671">2671</a></td><td>Errors in Copy</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2673">2673</a></td><td>status() effects cannot be implemented as specified</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2674">2674</a></td><td>Bidirectional iterator requirement on path::iterator is very expensive</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2683">2683</a></td><td>filesystem::copy() says "no effects"</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2684">2684</a></td><td>priority_queue lacking comparator typedef</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2685">2685</a></td><td>shared_ptr deleters must not throw on move construction</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2687">2687</a></td><td>{inclusive,exclusive}_scan misspecified</td><td>Oulu</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2688">2688</a></td><td>clamp misses preconditions and has extraneous condition on result</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2689">2689</a></td><td>Parallel versions of std::copy and std::move shouldn't be in order</td><td>Oulu</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2698">2698</a></td><td>Effect of assign() on iterators/pointers/references</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2704">2704</a></td><td>recursive_directory_iterator's members should require '*this is dereferenceable'</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2706">2706</a></td><td>Error reporting for recursive_directory_iterator::pop() is under-specified</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2707">2707</a></td><td>path construction and assignment should have "string_type&&" overloads</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2709">2709</a></td><td>offsetof is unnecessarily imprecise</td><td>Oulu</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2710">2710</a></td><td>"Effects: Equivalent to ..." doesn't count "Synchronization:" as determined semantics</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2711">2711</a></td><td>path is convertible from approximately everything under the sun</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2716">2716</a></td><td>Specification of shuffle and sample disallows lvalue URNGs</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2718">2718</a></td><td>Parallelism bug in [algorithms.parallel.exec] p2</td><td>Oulu</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2719">2719</a></td><td>permissions function should not be noexcept due to narrow contract</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2720">2720</a></td><td>permissions function incorrectly specified for symlinks</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2721">2721</a></td><td>remove_all has incorrect post conditions</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2723">2723</a></td><td>Do directory_iterator and recursive_directory_iterator become the end iterator upon error?</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2724">2724</a></td><td>The protected virtual member functions of memory_resource should be private</td><td>Oulu</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2725">2725</a></td><td>filesystem::exists(const path&, error_code&) error reporting</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2726">2726</a></td><td>[recursive_]directory_iterator::increment(error_code&) is underspecified</td><td>Oulu</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2727">2727</a></td><td>Parallel algorithms with constexpr specifier</td><td>Oulu</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2728">2728</a></td><td>status(p).permissions() and symlink_status(p).permissions() are not specified</td><td>Oulu</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2062">2062</a></td><td>Effect contradictions w/o no-throw guarantee of std::function swaps</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2166">2166</a></td><td>Heap property underspecified?</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2221">2221</a></td><td>No formatted output operator for nullptr</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2223">2223</a></td><td>shrink_to_fit effect on iterator validity</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2261">2261</a></td><td>Are containers required to use their 'pointer' type internally?</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2394">2394</a></td><td>locale::name specification unclear - what is implementation-defined?</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2460">2460</a></td><td>LWG issue 2408 and value categories</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2468">2468</a></td><td>Self-move-assignment of library types</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2475">2475</a></td><td>Allow overwriting of std::basic_string terminator with charT() to allow cleaner interoperation with legacy APIs</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2503">2503</a></td><td>multiline option should be added to syntax_option_type</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2510">2510</a></td><td>Tag types should not be DefaultConstructible</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2514">2514</a></td><td>Type traits must not be final</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2518">2518</a></td><td>[fund.ts.v2] Non-member swap for propagate_const should call member swap</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2519">2519</a></td><td>Iterator operator-= has gratuitous undefined behaviour</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2521">2521</a></td><td>[fund.ts.v2] weak_ptr's converting move constructor should be modified as well for array support</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2525">2525</a></td><td>[fund.ts.v2] get_memory_resource should be const and noexcept</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2527">2527</a></td><td>[fund.ts.v2] ALLOCATOR_OF for function::operator= has incorrect default</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2531">2531</a></td><td>future::get should explicitly state that the shared state is released</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2534">2534</a></td><td>Constrain rvalue stream operators</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2536">2536</a></td><td>What should &lt;complex.h&gt; do?</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2540">2540</a></td><td>unordered_multimap::insert hint iterator</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2543">2543</a></td><td>LWG 2148 (hash support for enum types) seems under-specified</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2544">2544</a></td><td>istreambuf_iterator(basic_streambuf<charT, traits>* s) effects unclear when s is 0</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2556">2556</a></td><td>Wide contract for future::share()</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2562">2562</a></td><td>Consistent total ordering of pointers by comparison functors</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2567">2567</a></td><td>Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2568">2568</a></td><td>[fund.ts.v2] Specification of logical operator traits uses BaseCharacteristic, which is defined only for UnaryTypeTraits and BinaryTypeTraits</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2569">2569</a></td><td>conjunction and disjunction requirements are too strict</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2570">2570</a></td><td>[fund.ts.v2] conjunction and disjunction requirements are too strict</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2578">2578</a></td><td>Iterator requirements should reference iterator traits</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2584">2584</a></td><td><regex> ECMAScript IdentityEscape is ambiguous</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2588">2588</a></td><td>[fund.ts.v2] "Convertible to bool" requirement in conjunction and disjunction</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2589">2589</a></td><td>match_results can't satisfy the requirements of a container</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2591">2591</a></td><td>std::function's member template target() should not lead to undefined behaviour</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2598">2598</a></td><td>addressof works on temporaries</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2664">2664</a></td><td>operator/ (and other append) semantics not useful if argument has root</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2665">2665</a></td><td>remove_filename() post condition is incorrect</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2672">2672</a></td><td>Should is_empty use error_code in its specification?</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2678">2678</a></td><td>std::filesystem enum classes overspecified</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2679">2679</a></td><td>Inconsistent Use of Effects and Equivalent To</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2680">2680</a></td><td>Add "Equivalent to" to filesystem</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2681">2681</a></td><td>filesystem::copy() cannot copy symlinks</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2682">2682</a></td><td>filesystem::copy() won't create a symlink to a directory</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2686">2686</a></td><td>Why is std::hash specialized for error_code, but not error_condition?</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2694">2694</a></td><td>Application of LWG 436 accidentally deleted definition of "facet"</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2696">2696</a></td><td>Interaction between make_shared and enable_shared_from_this is underspecified</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2699">2699</a></td><td>Missing restriction in [numeric.requirements]</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2712">2712</a></td><td>copy_file(from, to, ...) has a number of unspecified error conditions</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2722">2722</a></td><td>equivalent incorrectly specifies throws clause</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2729">2729</a></td><td>Missing SFINAE on std::pair::operator=</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2732">2732</a></td><td>Questionable specification of path::operator/= and path::append</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2733">2733</a></td><td>[fund.ts.v2] gcd / lcm and bool</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2735">2735</a></td><td>std::abs(short), std::abs(signed char) and others should return int instead of double in order to be compatible with C++98 and C</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2736">2736</a></td><td>nullopt_t insufficiently constrained</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2738">2738</a></td><td>is_constructible with void types</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2739">2739</a></td><td>Issue with time_point non-member subtraction with an unsigned duration</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2740">2740</a></td><td>constexpr optional<T>::operator-></td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2742">2742</a></td><td>Inconsistent string interface taking string_view</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2744">2744</a></td><td>any's in_place constructors</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2745">2745</a></td><td>[fund.ts.v2] Implementability of LWG 2451</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2747">2747</a></td><td>Possibly redundant std::move in [alg.foreach]</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2748">2748</a></td><td>swappable traits for optionals</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2749">2749</a></td><td>swappable traits for variants</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2750">2750</a></td><td>[fund.ts.v2] LWG 2451 conversion constructor constraint</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2752">2752</a></td><td>"Throws:" clauses of async and packaged_task are unimplementable</td><td>Issaquah</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2755">2755</a></td><td>[string.view.io] uses non-existent basic_string_view::to_string function</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2756">2756</a></td><td>C++ WP optional<T> should 'forward' T's implicit conversions</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2758">2758</a></td><td>std::string{}.assign("ABCDE", 0, 1) is ambiguous</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2759">2759</a></td><td>gcd / lcm and bool for the WP</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2760">2760</a></td><td>non-const basic_string::data should not invalidate iterators</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2765">2765</a></td><td>Did LWG 1123 go too far?</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2767">2767</a></td><td>not_fn call_wrapper can form invalid types</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2769">2769</a></td><td>Redundant const in the return type of any_cast(const any&)</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2771">2771</a></td><td>Broken Effects of some basic_string::compare functions in terms of basic_string_view</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2773">2773</a></td><td>Making std::ignore constexpr</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2777">2777</a></td><td>basic_string_view::copy should use char_traits::copy</td><td>Issaquah</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2778">2778</a></td><td>basic_string_view is missing constexpr</td><td>Issaquah</td><td>Complete</td></tr>
  	<tr><td></td><td></td><td></td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2260">2260</a></td><td>Missing requirement for Allocator::pointer</td><td>Kona</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2676">2676</a></td><td>Provide filesystem::path overloads for File-based streams</td><td>Kona</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2768">2768</a></td><td>any_cast and move semantics</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2769">2769</a></td><td>Redundant const in the return type of any_cast(const any&amp;)</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2781">2781</a></td><td>Contradictory requirements for std::function and std::reference_wrapper</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2782">2782</a></td><td>scoped_allocator_adaptor constructors must be constrained</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2784">2784</a></td><td>Resolution to LWG 2484 is missing "otherwise, no effects" and is hard to parse</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2785">2785</a></td><td>quoted should work with basic_string_view</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2786">2786</a></td><td>Annex C should mention shared_ptr changes for array support</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2787">2787</a></td><td>&sect;[file_status.cons] doesn't match class definition</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2788">2788</a></td><td>basic_string range mutators unintentionally require a default constructible allocator</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2789">2789</a></td><td>Equivalence of contained objects</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2790">2790</a></td><td>Missing specification of istreambuf_iterator::operator-&gt;</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2794">2794</a></td><td>Missing requirements for allocator pointers</td><td>Kona</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2795">2795</a></td><td>&sect;[global.functions] provides incorrect example of ADL use</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2796">2796</a></td><td>tuple should be a literal type</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2801">2801</a></td><td>Default-constructibility of unique_ptr</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2802">2802</a></td><td>shared_ptr constructor requirements for a deleter</td><td>Kona</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2804">2804</a></td><td>Unconditional constexpr default constructor for istream_iterator</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2806">2806</a></td><td>Base class of bad_optional_access</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2807">2807</a></td><td>std::invoke should use std::is_nothrow_callable</td><td>Kona</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2812">2812</a></td><td>Range access is available with &lt;string_view&gt;</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2824">2824</a></td><td>list::sort should say that the order of elements is unspecified if an exception is thrown</td><td>Kona</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2826">2826</a></td><td>string_view iterators use old wording</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2834">2834</a></td><td>Resolution LWG 2223 is missing wording about end iterators</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2835">2835</a></td><td>LWG 2536 seems to misspecify &lt;tgmath.h&gt;</td><td>Kona</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2837">2837</a></td><td>gcd and lcm should support a wider range of input values</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2838">2838</a></td><td>is_literal_type specification needs a little cleanup</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2842">2842</a></td><td>in_place_t check for optional::optional(U&amp;&amp;) should decay U</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2850">2850</a></td><td>std::function move constructor does unnecessary work</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2853">2853</a></td><td>Possible inconsistency in specification of erase in [vector.modifiers]</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2855">2855</a></td><td>std::throw_with_nested("string_literal")</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2857">2857</a></td><td>{variant,optional,any}::emplace should return the constructed value</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2861">2861</a></td><td>basic_string should require that charT match traits::char_type</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2866">2866</a></td><td>Incorrect derived classes constraints</td><td>Kona</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2868">2868</a></td><td>Missing specification of bad_any_cast::what()</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2872">2872</a></td><td>Add definition for direct-non-list-initialization</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2873">2873</a></td><td>Add noexcept to several shared_ptr related functions</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2874">2874</a></td><td>Constructor shared_ptr::shared_ptr(Y*) should be constrained</td><td>Kona</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2875">2875</a></td><td>shared_ptr::shared_ptr(Y*, D, [&hellip;]) constructors should be constrained</td><td>Kona</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2876">2876</a></td><td>shared_ptr::shared_ptr(const weak_ptr&lt;Y&gt;&amp;) constructor should be constrained</td><td>Kona</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2878">2878</a></td><td>Missing DefaultConstructible requirement for istream_iterator default constructor</td><td>Kona</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2890">2890</a></td><td>The definition of 'object state' applies only to class types</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2900">2900</a></td><td>The copy and move constructors of optional are not constexpr</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2903">2903</a></td><td>The form of initialization for the emplace-constructors is not specified</td><td>Kona</td><td></td></tr>
-	<tr><td><a href="http://wg21.link/LWG2904">2904</a></td><td>Make variant move-assignment more exception safe</td><td>Kona</td><td></td></tr>
+	<tr><td><a href="http://wg21.link/LWG2904">2904</a></td><td>Make variant move-assignment more exception safe</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2905">2905</a></td><td>is_constructible_v&lt;unique_ptr&lt;P, D&gt;, P, D const &amp;&gt; should be false when D is not copy constructible</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2908">2908</a></td><td>The less-than operator for shared pointers could do more</td><td>Kona</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2911">2911</a></td><td>An is_aggregate type trait is needed</td><td>Kona</td><td>Complete</td></tr>
 	<tr><td><a href="http://wg21.link/LWG2921">2921</a></td><td>packaged_task and type-erased allocators</td><td>Kona</td><td></td></tr>
 	<tr><td><a href="http://wg21.link/LWG2934">2934</a></td><td>optional&lt;const T&gt; doesn't compare with T</td><td>Kona</td><td>Complete</td></tr>
 <!--
 	<tr><td><a href="http://wg21.link/LWG1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Urbana</td><td></td></tr>
 -->
 <!-- 	<tr><td></td><td></td><td></td><td></td></tr> -->
   </table>
 
   <p>Last Updated: 25-May-2017</p>
 </div>
 </body>
 </html>