Index: head/contrib/llvm-project/libcxx/include/codecvt
===================================================================
--- head/contrib/llvm-project/libcxx/include/codecvt	(revision 359086)
+++ head/contrib/llvm-project/libcxx/include/codecvt	(revision 359087)
@@ -1,549 +1,549 @@
 // -*- C++ -*-
 //===-------------------------- codecvt -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_CODECVT
 #define _LIBCPP_CODECVT
 
 /*
     codecvt synopsis
 
 namespace std
 {
 
 enum codecvt_mode
 {
     consume_header = 4,
     generate_header = 2,
     little_endian = 1
 };
 
 template <class Elem, unsigned long Maxcode = 0x10ffff,
           codecvt_mode Mode = (codecvt_mode)0>
 class codecvt_utf8
     : public codecvt<Elem, char, mbstate_t>
 {
     explicit codecvt_utf8(size_t refs = 0);
     ~codecvt_utf8();
 };
 
 template <class Elem, unsigned long Maxcode = 0x10ffff,
           codecvt_mode Mode = (codecvt_mode)0>
 class codecvt_utf16
     : public codecvt<Elem, char, mbstate_t>
 {
     explicit codecvt_utf16(size_t refs = 0);
     ~codecvt_utf16();
 };
 
 template <class Elem, unsigned long Maxcode = 0x10ffff,
           codecvt_mode Mode = (codecvt_mode)0>
 class codecvt_utf8_utf16
     : public codecvt<Elem, char, mbstate_t>
 {
     explicit codecvt_utf8_utf16(size_t refs = 0);
     ~codecvt_utf8_utf16();
 };
 
 }  // std
 
 */
 
 #include <__config>
 #include <__locale>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 enum codecvt_mode
 {
     consume_header = 4,
     generate_header = 2,
     little_endian = 1
 };
 
 // codecvt_utf8
 
 template <class _Elem> class __codecvt_utf8;
 
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf8<wchar_t>
     : public codecvt<wchar_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef wchar_t   intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result
         do_unshift(state_type& __st,
                    extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const throw();
-    virtual bool do_always_noconv() const throw();
+    virtual int do_encoding() const _NOEXCEPT;
+    virtual bool do_always_noconv() const _NOEXCEPT;
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
                           size_t __mx) const;
-    virtual int do_max_length() const throw();
+    virtual int do_max_length() const _NOEXCEPT;
 };
 
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf8<char16_t>
     : public codecvt<char16_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result
         do_unshift(state_type& __st,
                    extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const throw();
-    virtual bool do_always_noconv() const throw();
+    virtual int do_encoding() const _NOEXCEPT;
+    virtual bool do_always_noconv() const _NOEXCEPT;
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
                           size_t __mx) const;
-    virtual int do_max_length() const throw();
+    virtual int do_max_length() const _NOEXCEPT;
 };
 
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf8<char32_t>
     : public codecvt<char32_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result
         do_unshift(state_type& __st,
                    extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const throw();
-    virtual bool do_always_noconv() const throw();
+    virtual int do_encoding() const _NOEXCEPT;
+    virtual bool do_always_noconv() const _NOEXCEPT;
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
                           size_t __mx) const;
-    virtual int do_max_length() const throw();
+    virtual int do_max_length() const _NOEXCEPT;
 };
 
 template <class _Elem, unsigned long _Maxcode = 0x10ffff,
           codecvt_mode _Mode = (codecvt_mode)0>
 class _LIBCPP_TEMPLATE_VIS codecvt_utf8
     : public __codecvt_utf8<_Elem>
 {
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit codecvt_utf8(size_t __refs = 0)
         : __codecvt_utf8<_Elem>(__refs, _Maxcode, _Mode) {}
 
     _LIBCPP_INLINE_VISIBILITY
     ~codecvt_utf8() {}
 };
 
 // codecvt_utf16
 
 template <class _Elem, bool _LittleEndian> class __codecvt_utf16;
 
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf16<wchar_t, false>
     : public codecvt<wchar_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef wchar_t   intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result
         do_unshift(state_type& __st,
                    extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const throw();
-    virtual bool do_always_noconv() const throw();
+    virtual int do_encoding() const _NOEXCEPT;
+    virtual bool do_always_noconv() const _NOEXCEPT;
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
                           size_t __mx) const;
-    virtual int do_max_length() const throw();
+    virtual int do_max_length() const _NOEXCEPT;
 };
 
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf16<wchar_t, true>
     : public codecvt<wchar_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef wchar_t   intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result
         do_unshift(state_type& __st,
                    extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const throw();
-    virtual bool do_always_noconv() const throw();
+    virtual int do_encoding() const _NOEXCEPT;
+    virtual bool do_always_noconv() const _NOEXCEPT;
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
                           size_t __mx) const;
-    virtual int do_max_length() const throw();
+    virtual int do_max_length() const _NOEXCEPT;
 };
 
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf16<char16_t, false>
     : public codecvt<char16_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result
         do_unshift(state_type& __st,
                    extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const throw();
-    virtual bool do_always_noconv() const throw();
+    virtual int do_encoding() const _NOEXCEPT;
+    virtual bool do_always_noconv() const _NOEXCEPT;
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
                           size_t __mx) const;
-    virtual int do_max_length() const throw();
+    virtual int do_max_length() const _NOEXCEPT;
 };
 
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf16<char16_t, true>
     : public codecvt<char16_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result
         do_unshift(state_type& __st,
                    extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const throw();
-    virtual bool do_always_noconv() const throw();
+    virtual int do_encoding() const _NOEXCEPT;
+    virtual bool do_always_noconv() const _NOEXCEPT;
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
                           size_t __mx) const;
-    virtual int do_max_length() const throw();
+    virtual int do_max_length() const _NOEXCEPT;
 };
 
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf16<char32_t, false>
     : public codecvt<char32_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result
         do_unshift(state_type& __st,
                    extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const throw();
-    virtual bool do_always_noconv() const throw();
+    virtual int do_encoding() const _NOEXCEPT;
+    virtual bool do_always_noconv() const _NOEXCEPT;
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
                           size_t __mx) const;
-    virtual int do_max_length() const throw();
+    virtual int do_max_length() const _NOEXCEPT;
 };
 
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf16<char32_t, true>
     : public codecvt<char32_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result
         do_unshift(state_type& __st,
                    extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const throw();
-    virtual bool do_always_noconv() const throw();
+    virtual int do_encoding() const _NOEXCEPT;
+    virtual bool do_always_noconv() const _NOEXCEPT;
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
                           size_t __mx) const;
-    virtual int do_max_length() const throw();
+    virtual int do_max_length() const _NOEXCEPT;
 };
 
 template <class _Elem, unsigned long _Maxcode = 0x10ffff,
           codecvt_mode _Mode = (codecvt_mode)0>
 class _LIBCPP_TEMPLATE_VIS codecvt_utf16
     : public __codecvt_utf16<_Elem, _Mode & little_endian>
 {
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit codecvt_utf16(size_t __refs = 0)
         : __codecvt_utf16<_Elem, _Mode & little_endian>(__refs, _Maxcode, _Mode) {}
 
     _LIBCPP_INLINE_VISIBILITY
     ~codecvt_utf16() {}
 };
 
 // codecvt_utf8_utf16
 
 template <class _Elem> class __codecvt_utf8_utf16;
 
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<wchar_t>
     : public codecvt<wchar_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef wchar_t   intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result
         do_unshift(state_type& __st,
                    extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const throw();
-    virtual bool do_always_noconv() const throw();
+    virtual int do_encoding() const _NOEXCEPT;
+    virtual bool do_always_noconv() const _NOEXCEPT;
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
                           size_t __mx) const;
-    virtual int do_max_length() const throw();
+    virtual int do_max_length() const _NOEXCEPT;
 };
 
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<char32_t>
     : public codecvt<char32_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result
         do_unshift(state_type& __st,
                    extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const throw();
-    virtual bool do_always_noconv() const throw();
+    virtual int do_encoding() const _NOEXCEPT;
+    virtual bool do_always_noconv() const _NOEXCEPT;
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
                           size_t __mx) const;
-    virtual int do_max_length() const throw();
+    virtual int do_max_length() const _NOEXCEPT;
 };
 
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<char16_t>
     : public codecvt<char16_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     virtual result
         do_unshift(state_type& __st,
                    extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const throw();
-    virtual bool do_always_noconv() const throw();
+    virtual int do_encoding() const _NOEXCEPT;
+    virtual bool do_always_noconv() const _NOEXCEPT;
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
                           size_t __mx) const;
-    virtual int do_max_length() const throw();
+    virtual int do_max_length() const _NOEXCEPT;
 };
 
 template <class _Elem, unsigned long _Maxcode = 0x10ffff,
           codecvt_mode _Mode = (codecvt_mode)0>
 class _LIBCPP_TEMPLATE_VIS codecvt_utf8_utf16
     : public __codecvt_utf8_utf16<_Elem>
 {
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit codecvt_utf8_utf16(size_t __refs = 0)
         : __codecvt_utf8_utf16<_Elem>(__refs, _Maxcode, _Mode) {}
 
     _LIBCPP_INLINE_VISIBILITY
     ~codecvt_utf8_utf16() {}
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CODECVT
Index: head/contrib/llvm-project/libcxx/include/exception
===================================================================
--- head/contrib/llvm-project/libcxx/include/exception	(revision 359086)
+++ head/contrib/llvm-project/libcxx/include/exception	(revision 359087)
@@ -1,329 +1,331 @@
 // -*- C++ -*-
 //===-------------------------- exception ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_EXCEPTION
 #define _LIBCPP_EXCEPTION
 
 /*
     exception synopsis
 
 namespace std
 {
 
 class exception
 {
 public:
     exception() noexcept;
     exception(const exception&) noexcept;
     exception& operator=(const exception&) noexcept;
     virtual ~exception() noexcept;
     virtual const char* what() const noexcept;
 };
 
 class bad_exception
     : public exception
 {
 public:
     bad_exception() noexcept;
     bad_exception(const bad_exception&) noexcept;
     bad_exception& operator=(const bad_exception&) noexcept;
     virtual ~bad_exception() noexcept;
     virtual const char* what() const noexcept;
 };
 
 typedef void (*unexpected_handler)();
 unexpected_handler set_unexpected(unexpected_handler  f ) noexcept;
 unexpected_handler get_unexpected() noexcept;
 [[noreturn]] void unexpected();
 
 typedef void (*terminate_handler)();
 terminate_handler set_terminate(terminate_handler  f ) noexcept;
 terminate_handler get_terminate() noexcept;
 [[noreturn]] void terminate() noexcept;
 
 bool uncaught_exception()  noexcept;
 int  uncaught_exceptions() noexcept;  // C++17
 
 typedef unspecified exception_ptr;
 
 exception_ptr current_exception() noexcept;
 void rethrow_exception [[noreturn]] (exception_ptr p);
 template<class E> exception_ptr make_exception_ptr(E e) noexcept;
 
 class nested_exception
 {
 public:
     nested_exception() noexcept;
     nested_exception(const nested_exception&) noexcept = default;
     nested_exception& operator=(const nested_exception&) noexcept = default;
     virtual ~nested_exception() = default;
 
     // access functions
     [[noreturn]] void rethrow_nested() const;
     exception_ptr nested_ptr() const noexcept;
 };
 
 template <class T> [[noreturn]] void throw_with_nested(T&& t);
 template <class E> void rethrow_if_nested(const E& e);
 
 }  // std
 
 */
 
 #include <__config>
 #include <cstddef>
 #include <cstdlib>
 #include <type_traits>
 #include <version>
 
 #if defined(_LIBCPP_ABI_VCRUNTIME)
 #include <vcruntime_exception.h>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 namespace std  // purposefully not using versioning namespace
 {
 
 #if !defined(_LIBCPP_ABI_VCRUNTIME)
 class _LIBCPP_EXCEPTION_ABI exception
 {
 public:
     _LIBCPP_INLINE_VISIBILITY exception() _NOEXCEPT {}
+    _LIBCPP_INLINE_VISIBILITY exception(const exception&) _NOEXCEPT = default;
+
     virtual ~exception() _NOEXCEPT;
     virtual const char* what() const _NOEXCEPT;
 };
 
 class _LIBCPP_EXCEPTION_ABI bad_exception
     : public exception
 {
 public:
     _LIBCPP_INLINE_VISIBILITY bad_exception() _NOEXCEPT {}
     virtual ~bad_exception() _NOEXCEPT;
     virtual const char* what() const _NOEXCEPT;
 };
 #endif // !_LIBCPP_ABI_VCRUNTIME
 
 #if _LIBCPP_STD_VER <= 14 \
     || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS) \
     || defined(_LIBCPP_BUILDING_LIBRARY)
 typedef void (*unexpected_handler)();
 _LIBCPP_FUNC_VIS unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT;
 _LIBCPP_FUNC_VIS unexpected_handler get_unexpected() _NOEXCEPT;
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void unexpected();
 #endif
 
 typedef void (*terminate_handler)();
 _LIBCPP_FUNC_VIS terminate_handler set_terminate(terminate_handler) _NOEXCEPT;
 _LIBCPP_FUNC_VIS terminate_handler get_terminate() _NOEXCEPT;
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void terminate() _NOEXCEPT;
 
 _LIBCPP_FUNC_VIS bool uncaught_exception() _NOEXCEPT;
 _LIBCPP_FUNC_VIS _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS int uncaught_exceptions() _NOEXCEPT;
 
 class _LIBCPP_TYPE_VIS exception_ptr;
 
 _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
 
 #ifndef _LIBCPP_ABI_MICROSOFT
 
 class _LIBCPP_TYPE_VIS exception_ptr
 {
     void* __ptr_;
 public:
     _LIBCPP_INLINE_VISIBILITY exception_ptr() _NOEXCEPT : __ptr_() {}
     _LIBCPP_INLINE_VISIBILITY exception_ptr(nullptr_t) _NOEXCEPT : __ptr_() {}
 
     exception_ptr(const exception_ptr&) _NOEXCEPT;
     exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
     ~exception_ptr() _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT
     {return __ptr_ != nullptr;}
 
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
         {return __x.__ptr_ == __y.__ptr_;}
 
     friend _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
         {return !(__x == __y);}
 
     friend _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
     friend _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
 };
 
 template<class _Ep>
 _LIBCPP_INLINE_VISIBILITY exception_ptr
 make_exception_ptr(_Ep __e) _NOEXCEPT
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
         throw __e;
     }
     catch (...)
     {
         return current_exception();
     }
 #else
     ((void)__e);
     _VSTD::abort();
 #endif
 }
 
 #else // _LIBCPP_ABI_MICROSOFT
 
 class _LIBCPP_TYPE_VIS exception_ptr
 {
 #if defined(__clang__)
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-private-field"
 #endif
     void* __ptr1_;
     void* __ptr2_;
 #if defined(__clang__)
 #pragma clang diagnostic pop
 #endif
 public:
     exception_ptr() _NOEXCEPT;
     exception_ptr(nullptr_t) _NOEXCEPT;
     exception_ptr(const exception_ptr& __other) _NOEXCEPT;
     exception_ptr& operator=(const exception_ptr& __other) _NOEXCEPT;
     exception_ptr& operator=(nullptr_t) _NOEXCEPT;
     ~exception_ptr() _NOEXCEPT;
     _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT;
 };
 
 _LIBCPP_FUNC_VIS
 bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT;
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
     {return !(__x == __y);}
 
 _LIBCPP_FUNC_VIS void swap(exception_ptr&, exception_ptr&) _NOEXCEPT;
 
 _LIBCPP_FUNC_VIS exception_ptr __copy_exception_ptr(void *__except, const void* __ptr);
 _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr p);
 
 // This is a built-in template function which automagically extracts the required
 // information.
 template <class _E> void *__GetExceptionInfo(_E);
 
 template<class _Ep>
 _LIBCPP_INLINE_VISIBILITY exception_ptr
 make_exception_ptr(_Ep __e) _NOEXCEPT
 {
   return __copy_exception_ptr(_VSTD::addressof(__e), __GetExceptionInfo(__e));
 }
 
 #endif // _LIBCPP_ABI_MICROSOFT
 // nested_exception
 
 class _LIBCPP_EXCEPTION_ABI nested_exception
 {
     exception_ptr __ptr_;
 public:
     nested_exception() _NOEXCEPT;
 //     nested_exception(const nested_exception&) noexcept = default;
 //     nested_exception& operator=(const nested_exception&) noexcept = default;
     virtual ~nested_exception() _NOEXCEPT;
 
     // access functions
     _LIBCPP_NORETURN void rethrow_nested() const;
     _LIBCPP_INLINE_VISIBILITY exception_ptr nested_ptr() const _NOEXCEPT {return __ptr_;}
 };
 
 template <class _Tp>
 struct __nested
     : public _Tp,
       public nested_exception
 {
     _LIBCPP_INLINE_VISIBILITY explicit __nested(const _Tp& __t) : _Tp(__t) {}
 };
 
 #ifndef _LIBCPP_NO_EXCEPTIONS
 template <class _Tp, class _Up, bool>
 struct __throw_with_nested;
 
 template <class _Tp, class _Up>
 struct __throw_with_nested<_Tp, _Up, true> {
     _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void
     __do_throw(_Tp&& __t)
     {
         throw __nested<_Up>(_VSTD::forward<_Tp>(__t));
     }
 };
 
 template <class _Tp, class _Up>
 struct __throw_with_nested<_Tp, _Up, false> {
     _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void
 #ifndef _LIBCPP_CXX03_LANG
     __do_throw(_Tp&& __t)
 #else
     __do_throw (_Tp& __t)
 #endif  // _LIBCPP_CXX03_LANG
     {
         throw _VSTD::forward<_Tp>(__t);
     }
 };
 #endif
 
 template <class _Tp>
 _LIBCPP_NORETURN
 void
 throw_with_nested(_Tp&& __t)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     typedef typename decay<_Tp>::type _Up;
     static_assert( is_copy_constructible<_Up>::value, "type thrown must be CopyConstructible");
     __throw_with_nested<_Tp, _Up,
         is_class<_Up>::value &&
         !is_base_of<nested_exception, _Up>::value &&
         !__libcpp_is_final<_Up>::value>::
             __do_throw(_VSTD::forward<_Tp>(__t));
 #else
     ((void)__t);
     // FIXME: Make this abort
 #endif
 }
 
 template <class _From, class _To>
 struct __can_dynamic_cast : public _LIBCPP_BOOL_CONSTANT(
               is_polymorphic<_From>::value &&
                  (!is_base_of<_To, _From>::value ||
                    is_convertible<const _From*, const _To*>::value)) {};
 
 template <class _Ep>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 rethrow_if_nested(const _Ep& __e,
                   typename enable_if< __can_dynamic_cast<_Ep, nested_exception>::value>::type* = 0)
 {
     const nested_exception* __nep = dynamic_cast<const nested_exception*>(_VSTD::addressof(__e));
     if (__nep)
         __nep->rethrow_nested();
 }
 
 template <class _Ep>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 rethrow_if_nested(const _Ep&,
                   typename enable_if<!__can_dynamic_cast<_Ep, nested_exception>::value>::type* = 0)
 {
 }
 
 }  // std
 
 #endif  // _LIBCPP_EXCEPTION
Index: head/contrib/llvm-project/libcxx/include/filesystem
===================================================================
--- head/contrib/llvm-project/libcxx/include/filesystem	(revision 359086)
+++ head/contrib/llvm-project/libcxx/include/filesystem	(revision 359087)
@@ -1,2644 +1,2645 @@
 // -*- C++ -*-
 //===--------------------------- filesystem -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef _LIBCPP_FILESYSTEM
 #define _LIBCPP_FILESYSTEM
 /*
     filesystem synopsis
 
     namespace std { namespace filesystem {
 
     class path;
 
     void swap(path& lhs, path& rhs) noexcept;
     size_t hash_value(const path& p) noexcept;
 
     bool operator==(const path& lhs, const path& rhs) noexcept;
     bool operator!=(const path& lhs, const path& rhs) noexcept;
     bool operator< (const path& lhs, const path& rhs) noexcept;
     bool operator<=(const path& lhs, const path& rhs) noexcept;
     bool operator> (const path& lhs, const path& rhs) noexcept;
     bool operator>=(const path& lhs, const path& rhs) noexcept;
 
     path operator/ (const path& lhs, const path& rhs);
 
     // fs.path.io operators are friends of path.
     template <class charT, class traits>
     friend basic_ostream<charT, traits>&
     operator<<(basic_ostream<charT, traits>& os, const path& p);
 
     template <class charT, class traits>
     friend basic_istream<charT, traits>&
     operator>>(basic_istream<charT, traits>& is, path& p);
 
     template <class Source>
       path u8path(const Source& source);
     template <class InputIterator>
       path u8path(InputIterator first, InputIterator last);
 
     class filesystem_error;
     class directory_entry;
 
     class directory_iterator;
 
     // enable directory_iterator range-based for statements
     directory_iterator begin(directory_iterator iter) noexcept;
     directory_iterator end(const directory_iterator&) noexcept;
 
     class recursive_directory_iterator;
 
     // enable recursive_directory_iterator range-based for statements
     recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
     recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;
 
     class file_status;
 
     struct space_info
     {
       uintmax_t capacity;
       uintmax_t free;
       uintmax_t available;
     };
 
     enum class file_type;
     enum class perms;
     enum class perm_options;
     enum class copy_options;
     enum class directory_options;
 
     typedef chrono::time_point<trivial-clock>  file_time_type;
 
     // operational functions
 
     path absolute(const path& p);
     path absolute(const path& p, error_code &ec);
 
     path canonical(const path& p);
     path canonical(const path& p, error_code& ec);
 
     void copy(const path& from, const path& to);
     void copy(const path& from, const path& to, error_code& ec);
     void copy(const path& from, const path& to, copy_options options);
     void copy(const path& from, const path& to, copy_options options,
                    error_code& ec);
 
     bool copy_file(const path& from, const path& to);
     bool copy_file(const path& from, const path& to, error_code& ec);
     bool copy_file(const path& from, const path& to, copy_options option);
     bool copy_file(const path& from, const path& to, copy_options option,
                            error_code& ec);
 
     void copy_symlink(const path& existing_symlink, const path& new_symlink);
     void copy_symlink(const path& existing_symlink, const path& new_symlink,
                               error_code& ec) noexcept;
 
     bool create_directories(const path& p);
     bool create_directories(const path& p, error_code& ec);
 
     bool create_directory(const path& p);
     bool create_directory(const path& p, error_code& ec) noexcept;
 
     bool create_directory(const path& p, const path& attributes);
     bool create_directory(const path& p, const path& attributes,
                                   error_code& ec) noexcept;
 
     void create_directory_symlink(const path& to, const path& new_symlink);
     void create_directory_symlink(const path& to, const path& new_symlink,
                                           error_code& ec) noexcept;
 
     void create_hard_link(const path& to, const path& new_hard_link);
     void create_hard_link(const path& to, const path& new_hard_link,
                                   error_code& ec) noexcept;
 
     void create_symlink(const path& to, const path& new_symlink);
     void create_symlink(const path& to, const path& new_symlink,
                                 error_code& ec) noexcept;
 
     path current_path();
     path current_path(error_code& ec);
     void current_path(const path& p);
     void current_path(const path& p, error_code& ec) noexcept;
 
     bool exists(file_status s) noexcept;
     bool exists(const path& p);
     bool exists(const path& p, error_code& ec) noexcept;
 
     bool equivalent(const path& p1, const path& p2);
     bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept;
 
     uintmax_t    file_size(const path& p);
     uintmax_t    file_size(const path& p, error_code& ec) noexcept;
 
     uintmax_t    hard_link_count(const path& p);
     uintmax_t    hard_link_count(const path& p, error_code& ec) noexcept;
 
     bool is_block_file(file_status s) noexcept;
     bool is_block_file(const path& p);
     bool is_block_file(const path& p, error_code& ec) noexcept;
 
     bool is_character_file(file_status s) noexcept;
     bool is_character_file(const path& p);
     bool is_character_file(const path& p, error_code& ec) noexcept;
 
     bool is_directory(file_status s) noexcept;
     bool is_directory(const path& p);
     bool is_directory(const path& p, error_code& ec) noexcept;
 
     bool is_empty(const path& p);
     bool is_empty(const path& p, error_code& ec) noexcept;
 
     bool is_fifo(file_status s) noexcept;
     bool is_fifo(const path& p);
     bool is_fifo(const path& p, error_code& ec) noexcept;
 
     bool is_other(file_status s) noexcept;
     bool is_other(const path& p);
     bool is_other(const path& p, error_code& ec) noexcept;
 
     bool is_regular_file(file_status s) noexcept;
     bool is_regular_file(const path& p);
     bool is_regular_file(const path& p, error_code& ec) noexcept;
 
     bool is_socket(file_status s) noexcept;
     bool is_socket(const path& p);
     bool is_socket(const path& p, error_code& ec) noexcept;
 
     bool is_symlink(file_status s) noexcept;
     bool is_symlink(const path& p);
     bool is_symlink(const path& p, error_code& ec) noexcept;
 
     file_time_type  last_write_time(const path& p);
     file_time_type  last_write_time(const path& p, error_code& ec) noexcept;
     void last_write_time(const path& p, file_time_type new_time);
     void last_write_time(const path& p, file_time_type new_time,
                                  error_code& ec) noexcept;
 
     void permissions(const path& p, perms prms,
                      perm_options opts=perm_options::replace);
     void permissions(const path& p, perms prms, error_code& ec) noexcept;
     void permissions(const path& p, perms prms, perm_options opts,
                      error_code& ec);
 
     path proximate(const path& p, error_code& ec);
     path proximate(const path& p, const path& base = current_path());
     path proximate(const path& p, const path& base, error_code &ec);
 
     path read_symlink(const path& p);
     path read_symlink(const path& p, error_code& ec);
 
     path relative(const path& p, error_code& ec);
     path relative(const path& p, const path& base=current_path());
     path relative(const path& p, const path& base, error_code& ec);
 
     bool remove(const path& p);
     bool remove(const path& p, error_code& ec) noexcept;
 
     uintmax_t    remove_all(const path& p);
     uintmax_t    remove_all(const path& p, error_code& ec);
 
     void rename(const path& from, const path& to);
     void rename(const path& from, const path& to, error_code& ec) noexcept;
 
     void resize_file(const path& p, uintmax_t size);
     void resize_file(const path& p, uintmax_t size, error_code& ec) noexcept;
 
     space_info   space(const path& p);
     space_info   space(const path& p, error_code& ec) noexcept;
 
     file_status  status(const path& p);
     file_status  status(const path& p, error_code& ec) noexcept;
 
     bool status_known(file_status s) noexcept;
 
     file_status  symlink_status(const path& p);
     file_status  symlink_status(const path& p, error_code& ec) noexcept;
 
     path temp_directory_path();
     path temp_directory_path(error_code& ec);
 
     path weakly_canonical(path const& p);
     path weakly_canonical(path const& p, error_code& ec);
 
 
 } }  // namespaces std::filesystem
 
 */
 
 #include <__config>
 #include <cstddef>
 #include <cstdlib>
 #include <chrono>
 #include <iterator>
 #include <iosfwd>
 #include <locale>
 #include <memory>
 #include <stack>
 #include <string>
 #include <system_error>
 #include <utility>
 #include <iomanip> // for quoted
 #include <string_view>
 #include <version>
 
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 
 typedef chrono::time_point<_FilesystemClock> file_time_type;
 
 struct _LIBCPP_TYPE_VIS space_info {
   uintmax_t capacity;
   uintmax_t free;
   uintmax_t available;
 };
 
 enum class _LIBCPP_ENUM_VIS file_type : signed char {
   none = 0,
   not_found = -1,
   regular = 1,
   directory = 2,
   symlink = 3,
   block = 4,
   character = 5,
   fifo = 6,
   socket = 7,
   unknown = 8
 };
 
 enum class _LIBCPP_ENUM_VIS perms : unsigned {
   none = 0,
 
   owner_read = 0400,
   owner_write = 0200,
   owner_exec = 0100,
   owner_all = 0700,
 
   group_read = 040,
   group_write = 020,
   group_exec = 010,
   group_all = 070,
 
   others_read = 04,
   others_write = 02,
   others_exec = 01,
   others_all = 07,
 
   all = 0777,
 
   set_uid = 04000,
   set_gid = 02000,
   sticky_bit = 01000,
   mask = 07777,
   unknown = 0xFFFF,
 };
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr perms operator&(perms _LHS, perms _RHS) {
   return static_cast<perms>(static_cast<unsigned>(_LHS) &
                             static_cast<unsigned>(_RHS));
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr perms operator|(perms _LHS, perms _RHS) {
   return static_cast<perms>(static_cast<unsigned>(_LHS) |
                             static_cast<unsigned>(_RHS));
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr perms operator^(perms _LHS, perms _RHS) {
   return static_cast<perms>(static_cast<unsigned>(_LHS) ^
                             static_cast<unsigned>(_RHS));
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr perms operator~(perms _LHS) {
   return static_cast<perms>(~static_cast<unsigned>(_LHS));
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline perms& operator&=(perms& _LHS, perms _RHS) { return _LHS = _LHS & _RHS; }
 
 _LIBCPP_INLINE_VISIBILITY
 inline perms& operator|=(perms& _LHS, perms _RHS) { return _LHS = _LHS | _RHS; }
 
 _LIBCPP_INLINE_VISIBILITY
 inline perms& operator^=(perms& _LHS, perms _RHS) { return _LHS = _LHS ^ _RHS; }
 
 enum class _LIBCPP_ENUM_VIS perm_options : unsigned char {
   replace = 1,
   add = 2,
   remove = 4,
   nofollow = 8
 };
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr perm_options operator&(perm_options _LHS, perm_options _RHS) {
   return static_cast<perm_options>(static_cast<unsigned>(_LHS) &
                                    static_cast<unsigned>(_RHS));
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr perm_options operator|(perm_options _LHS, perm_options _RHS) {
   return static_cast<perm_options>(static_cast<unsigned>(_LHS) |
                                    static_cast<unsigned>(_RHS));
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr perm_options operator^(perm_options _LHS, perm_options _RHS) {
   return static_cast<perm_options>(static_cast<unsigned>(_LHS) ^
                                    static_cast<unsigned>(_RHS));
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr perm_options operator~(perm_options _LHS) {
   return static_cast<perm_options>(~static_cast<unsigned>(_LHS));
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline perm_options& operator&=(perm_options& _LHS, perm_options _RHS) {
   return _LHS = _LHS & _RHS;
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline perm_options& operator|=(perm_options& _LHS, perm_options _RHS) {
   return _LHS = _LHS | _RHS;
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline perm_options& operator^=(perm_options& _LHS, perm_options _RHS) {
   return _LHS = _LHS ^ _RHS;
 }
 
 enum class _LIBCPP_ENUM_VIS copy_options : unsigned short {
   none = 0,
   skip_existing = 1,
   overwrite_existing = 2,
   update_existing = 4,
   recursive = 8,
   copy_symlinks = 16,
   skip_symlinks = 32,
   directories_only = 64,
   create_symlinks = 128,
   create_hard_links = 256,
   __in_recursive_copy = 512,
 };
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr copy_options operator&(copy_options _LHS, copy_options _RHS) {
   return static_cast<copy_options>(static_cast<unsigned short>(_LHS) &
                                    static_cast<unsigned short>(_RHS));
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr copy_options operator|(copy_options _LHS, copy_options _RHS) {
   return static_cast<copy_options>(static_cast<unsigned short>(_LHS) |
                                    static_cast<unsigned short>(_RHS));
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr copy_options operator^(copy_options _LHS, copy_options _RHS) {
   return static_cast<copy_options>(static_cast<unsigned short>(_LHS) ^
                                    static_cast<unsigned short>(_RHS));
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr copy_options operator~(copy_options _LHS) {
   return static_cast<copy_options>(~static_cast<unsigned short>(_LHS));
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline copy_options& operator&=(copy_options& _LHS, copy_options _RHS) {
   return _LHS = _LHS & _RHS;
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline copy_options& operator|=(copy_options& _LHS, copy_options _RHS) {
   return _LHS = _LHS | _RHS;
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline copy_options& operator^=(copy_options& _LHS, copy_options _RHS) {
   return _LHS = _LHS ^ _RHS;
 }
 
 enum class _LIBCPP_ENUM_VIS directory_options : unsigned char {
   none = 0,
   follow_directory_symlink = 1,
   skip_permission_denied = 2
 };
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr directory_options operator&(directory_options _LHS,
                                              directory_options _RHS) {
   return static_cast<directory_options>(static_cast<unsigned char>(_LHS) &
                                         static_cast<unsigned char>(_RHS));
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr directory_options operator|(directory_options _LHS,
                                              directory_options _RHS) {
   return static_cast<directory_options>(static_cast<unsigned char>(_LHS) |
                                         static_cast<unsigned char>(_RHS));
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr directory_options operator^(directory_options _LHS,
                                              directory_options _RHS) {
   return static_cast<directory_options>(static_cast<unsigned char>(_LHS) ^
                                         static_cast<unsigned char>(_RHS));
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr directory_options operator~(directory_options _LHS) {
   return static_cast<directory_options>(~static_cast<unsigned char>(_LHS));
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline directory_options& operator&=(directory_options& _LHS,
                                      directory_options _RHS) {
   return _LHS = _LHS & _RHS;
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline directory_options& operator|=(directory_options& _LHS,
                                      directory_options _RHS) {
   return _LHS = _LHS | _RHS;
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline directory_options& operator^=(directory_options& _LHS,
                                      directory_options _RHS) {
   return _LHS = _LHS ^ _RHS;
 }
 
 class _LIBCPP_TYPE_VIS file_status {
 public:
   // constructors
   _LIBCPP_INLINE_VISIBILITY
   file_status() noexcept : file_status(file_type::none) {}
   _LIBCPP_INLINE_VISIBILITY
   explicit file_status(file_type __ft, perms __prms = perms::unknown) noexcept
       : __ft_(__ft),
         __prms_(__prms) {}
 
   file_status(const file_status&) noexcept = default;
   file_status(file_status&&) noexcept = default;
 
   _LIBCPP_INLINE_VISIBILITY
   ~file_status() {}
 
   file_status& operator=(const file_status&) noexcept = default;
   file_status& operator=(file_status&&) noexcept = default;
 
   // observers
   _LIBCPP_INLINE_VISIBILITY
   file_type type() const noexcept { return __ft_; }
 
   _LIBCPP_INLINE_VISIBILITY
   perms permissions() const noexcept { return __prms_; }
 
   // modifiers
   _LIBCPP_INLINE_VISIBILITY
   void type(file_type __ft) noexcept { __ft_ = __ft; }
 
   _LIBCPP_INLINE_VISIBILITY
   void permissions(perms __p) noexcept { __prms_ = __p; }
 
 private:
   file_type __ft_;
   perms __prms_;
 };
 
 class _LIBCPP_TYPE_VIS directory_entry;
 
 template <class _Tp>
 struct __can_convert_char {
   static const bool value = false;
 };
 template <class _Tp>
 struct __can_convert_char<const _Tp> : public __can_convert_char<_Tp> {};
 template <>
 struct __can_convert_char<char> {
   static const bool value = true;
   using __char_type = char;
 };
 template <>
 struct __can_convert_char<wchar_t> {
   static const bool value = true;
   using __char_type = wchar_t;
 };
 template <>
 struct __can_convert_char<char16_t> {
   static const bool value = true;
   using __char_type = char16_t;
 };
 template <>
 struct __can_convert_char<char32_t> {
   static const bool value = true;
   using __char_type = char32_t;
 };
 
 template <class _ECharT>
 typename enable_if<__can_convert_char<_ECharT>::value, bool>::type
 __is_separator(_ECharT __e) {
   return __e == _ECharT('/');
 }
 
 struct _NullSentinal {};
 
 template <class _Tp>
 using _Void = void;
 
 template <class _Tp, class = void>
 struct __is_pathable_string : public false_type {};
 
 template <class _ECharT, class _Traits, class _Alloc>
 struct __is_pathable_string<
     basic_string<_ECharT, _Traits, _Alloc>,
     _Void<typename __can_convert_char<_ECharT>::__char_type> >
     : public __can_convert_char<_ECharT> {
   using _Str = basic_string<_ECharT, _Traits, _Alloc>;
   using _Base = __can_convert_char<_ECharT>;
   static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
   static _ECharT const* __range_end(_Str const& __s) {
     return __s.data() + __s.length();
   }
   static _ECharT __first_or_null(_Str const& __s) {
     return __s.empty() ? _ECharT{} : __s[0];
   }
 };
 
 template <class _ECharT, class _Traits>
 struct __is_pathable_string<
     basic_string_view<_ECharT, _Traits>,
     _Void<typename __can_convert_char<_ECharT>::__char_type> >
     : public __can_convert_char<_ECharT> {
   using _Str = basic_string_view<_ECharT, _Traits>;
   using _Base = __can_convert_char<_ECharT>;
   static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
   static _ECharT const* __range_end(_Str const& __s) {
     return __s.data() + __s.length();
   }
   static _ECharT __first_or_null(_Str const& __s) {
     return __s.empty() ? _ECharT{} : __s[0];
   }
 };
 
 template <class _Source, class _DS = typename decay<_Source>::type,
           class _UnqualPtrType =
               typename remove_const<typename remove_pointer<_DS>::type>::type,
           bool _IsCharPtr = is_pointer<_DS>::value&&
               __can_convert_char<_UnqualPtrType>::value>
 struct __is_pathable_char_array : false_type {};
 
 template <class _Source, class _ECharT, class _UPtr>
 struct __is_pathable_char_array<_Source, _ECharT*, _UPtr, true>
     : __can_convert_char<typename remove_const<_ECharT>::type> {
   using _Base = __can_convert_char<typename remove_const<_ECharT>::type>;
 
   static _ECharT const* __range_begin(const _ECharT* __b) { return __b; }
   static _ECharT const* __range_end(const _ECharT* __b) {
     using _Iter = const _ECharT*;
     const _ECharT __sentinal = _ECharT{};
     _Iter __e = __b;
     for (; *__e != __sentinal; ++__e)
       ;
     return __e;
   }
 
   static _ECharT __first_or_null(const _ECharT* __b) { return *__b; }
 };
 
 template <class _Iter, bool _IsIt = __is_cpp17_input_iterator<_Iter>::value,
           class = void>
 struct __is_pathable_iter : false_type {};
 
 template <class _Iter>
 struct __is_pathable_iter<
     _Iter, true,
     _Void<typename __can_convert_char<
         typename iterator_traits<_Iter>::value_type>::__char_type> >
     : __can_convert_char<typename iterator_traits<_Iter>::value_type> {
   using _ECharT = typename iterator_traits<_Iter>::value_type;
   using _Base = __can_convert_char<_ECharT>;
 
   static _Iter __range_begin(_Iter __b) { return __b; }
   static _NullSentinal __range_end(_Iter) { return _NullSentinal{}; }
 
   static _ECharT __first_or_null(_Iter __b) { return *__b; }
 };
 
 template <class _Tp, bool _IsStringT = __is_pathable_string<_Tp>::value,
           bool _IsCharIterT = __is_pathable_char_array<_Tp>::value,
           bool _IsIterT = !_IsCharIterT && __is_pathable_iter<_Tp>::value>
 struct __is_pathable : false_type {
   static_assert(!_IsStringT && !_IsCharIterT && !_IsIterT, "Must all be false");
 };
 
 template <class _Tp>
 struct __is_pathable<_Tp, true, false, false> : __is_pathable_string<_Tp> {};
 
 template <class _Tp>
 struct __is_pathable<_Tp, false, true, false> : __is_pathable_char_array<_Tp> {
 };
 
 template <class _Tp>
 struct __is_pathable<_Tp, false, false, true> : __is_pathable_iter<_Tp> {};
 
 template <class _ECharT>
 struct _PathCVT {
   static_assert(__can_convert_char<_ECharT>::value,
                 "Char type not convertible");
 
   typedef __narrow_to_utf8<sizeof(_ECharT) * __CHAR_BIT__> _Narrower;
 
   static void __append_range(string& __dest, _ECharT const* __b,
                              _ECharT const* __e) {
     _Narrower()(back_inserter(__dest), __b, __e);
   }
 
   template <class _Iter>
   static void __append_range(string& __dest, _Iter __b, _Iter __e) {
     static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
     if (__b == __e)
       return;
     basic_string<_ECharT> __tmp(__b, __e);
     _Narrower()(back_inserter(__dest), __tmp.data(),
                 __tmp.data() + __tmp.length());
   }
 
   template <class _Iter>
   static void __append_range(string& __dest, _Iter __b, _NullSentinal) {
     static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
     const _ECharT __sentinal = _ECharT{};
     if (*__b == __sentinal)
       return;
     basic_string<_ECharT> __tmp;
     for (; *__b != __sentinal; ++__b)
       __tmp.push_back(*__b);
     _Narrower()(back_inserter(__dest), __tmp.data(),
                 __tmp.data() + __tmp.length());
   }
 
   template <class _Source>
   static void __append_source(string& __dest, _Source const& __s) {
     using _Traits = __is_pathable<_Source>;
     __append_range(__dest, _Traits::__range_begin(__s),
                    _Traits::__range_end(__s));
   }
 };
 
 template <>
 struct _PathCVT<char> {
 
   template <class _Iter>
   static typename enable_if<__is_exactly_cpp17_input_iterator<_Iter>::value>::type
   __append_range(string& __dest, _Iter __b, _Iter __e) {
     for (; __b != __e; ++__b)
       __dest.push_back(*__b);
   }
 
   template <class _Iter>
   static typename enable_if<__is_cpp17_forward_iterator<_Iter>::value>::type
   __append_range(string& __dest, _Iter __b, _Iter __e) {
     __dest.__append_forward_unsafe(__b, __e);
   }
 
   template <class _Iter>
   static void __append_range(string& __dest, _Iter __b, _NullSentinal) {
     const char __sentinal = char{};
     for (; *__b != __sentinal; ++__b)
       __dest.push_back(*__b);
   }
 
   template <class _Source>
   static void __append_source(string& __dest, _Source const& __s) {
     using _Traits = __is_pathable<_Source>;
     __append_range(__dest, _Traits::__range_begin(__s),
                    _Traits::__range_end(__s));
   }
 };
 
 class _LIBCPP_TYPE_VIS path {
   template <class _SourceOrIter, class _Tp = path&>
   using _EnableIfPathable =
       typename enable_if<__is_pathable<_SourceOrIter>::value, _Tp>::type;
 
   template <class _Tp>
   using _SourceChar = typename __is_pathable<_Tp>::__char_type;
 
   template <class _Tp>
   using _SourceCVT = _PathCVT<_SourceChar<_Tp> >;
 
 public:
   typedef char value_type;
   typedef basic_string<value_type> string_type;
   typedef _VSTD::string_view __string_view;
   static constexpr value_type preferred_separator = '/';
 
   enum class _LIBCPP_ENUM_VIS format : unsigned char {
     auto_format,
     native_format,
     generic_format
   };
 
   // constructors and destructor
   _LIBCPP_INLINE_VISIBILITY path() noexcept {}
   _LIBCPP_INLINE_VISIBILITY path(const path& __p) : __pn_(__p.__pn_) {}
   _LIBCPP_INLINE_VISIBILITY path(path&& __p) noexcept
       : __pn_(_VSTD::move(__p.__pn_)) {}
 
   _LIBCPP_INLINE_VISIBILITY
   path(string_type&& __s, format = format::auto_format) noexcept
       : __pn_(_VSTD::move(__s)) {}
 
   template <class _Source, class = _EnableIfPathable<_Source, void> >
   path(const _Source& __src, format = format::auto_format) {
     _SourceCVT<_Source>::__append_source(__pn_, __src);
   }
 
   template <class _InputIt>
   path(_InputIt __first, _InputIt __last, format = format::auto_format) {
     typedef typename iterator_traits<_InputIt>::value_type _ItVal;
     _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
   }
 
   // TODO Implement locale conversions.
   template <class _Source, class = _EnableIfPathable<_Source, void> >
   path(const _Source& __src, const locale& __loc, format = format::auto_format);
   template <class _InputIt>
   path(_InputIt __first, _InputIt _last, const locale& __loc,
        format = format::auto_format);
 
   _LIBCPP_INLINE_VISIBILITY
   ~path() = default;
 
   // assignments
   _LIBCPP_INLINE_VISIBILITY
   path& operator=(const path& __p) {
     __pn_ = __p.__pn_;
     return *this;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   path& operator=(path&& __p) noexcept {
     __pn_ = _VSTD::move(__p.__pn_);
     return *this;
   }
 
   template <class = void>
   _LIBCPP_INLINE_VISIBILITY path& operator=(string_type&& __s) noexcept {
     __pn_ = _VSTD::move(__s);
     return *this;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   path& assign(string_type&& __s) noexcept {
     __pn_ = _VSTD::move(__s);
     return *this;
   }
 
   template <class _Source>
   _LIBCPP_INLINE_VISIBILITY _EnableIfPathable<_Source>
   operator=(const _Source& __src) {
     return this->assign(__src);
   }
 
   template <class _Source>
   _EnableIfPathable<_Source> assign(const _Source& __src) {
     __pn_.clear();
     _SourceCVT<_Source>::__append_source(__pn_, __src);
     return *this;
   }
 
   template <class _InputIt>
   path& assign(_InputIt __first, _InputIt __last) {
     typedef typename iterator_traits<_InputIt>::value_type _ItVal;
     __pn_.clear();
     _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
     return *this;
   }
 
 private:
   template <class _ECharT>
   static bool __source_is_absolute(_ECharT __first_or_null) {
     return __is_separator(__first_or_null);
   }
 
 public:
   // appends
   path& operator/=(const path& __p) {
     if (__p.is_absolute()) {
       __pn_ = __p.__pn_;
       return *this;
     }
     if (has_filename())
       __pn_ += preferred_separator;
     __pn_ += __p.native();
     return *this;
   }
 
   // FIXME: Use _LIBCPP_DIAGNOSE_WARNING to produce a diagnostic when __src
   // is known at compile time to be "/' since the user almost certainly intended
   // to append a separator instead of overwriting the path with "/"
   template <class _Source>
   _LIBCPP_INLINE_VISIBILITY _EnableIfPathable<_Source>
   operator/=(const _Source& __src) {
     return this->append(__src);
   }
 
   template <class _Source>
   _EnableIfPathable<_Source> append(const _Source& __src) {
     using _Traits = __is_pathable<_Source>;
     using _CVT = _PathCVT<_SourceChar<_Source> >;
     if (__source_is_absolute(_Traits::__first_or_null(__src)))
       __pn_.clear();
     else if (has_filename())
       __pn_ += preferred_separator;
     _CVT::__append_source(__pn_, __src);
     return *this;
   }
 
   template <class _InputIt>
   path& append(_InputIt __first, _InputIt __last) {
     typedef typename iterator_traits<_InputIt>::value_type _ItVal;
     static_assert(__can_convert_char<_ItVal>::value, "Must convertible");
     using _CVT = _PathCVT<_ItVal>;
     if (__first != __last && __source_is_absolute(*__first))
       __pn_.clear();
     else if (has_filename())
       __pn_ += preferred_separator;
     _CVT::__append_range(__pn_, __first, __last);
     return *this;
   }
 
   // concatenation
   _LIBCPP_INLINE_VISIBILITY
   path& operator+=(const path& __x) {
     __pn_ += __x.__pn_;
     return *this;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   path& operator+=(const string_type& __x) {
     __pn_ += __x;
     return *this;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   path& operator+=(__string_view __x) {
     __pn_ += __x;
     return *this;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   path& operator+=(const value_type* __x) {
     __pn_ += __x;
     return *this;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   path& operator+=(value_type __x) {
     __pn_ += __x;
     return *this;
   }
 
   template <class _ECharT>
   typename enable_if<__can_convert_char<_ECharT>::value, path&>::type
   operator+=(_ECharT __x) {
     basic_string<_ECharT> __tmp;
     __tmp += __x;
     _PathCVT<_ECharT>::__append_source(__pn_, __tmp);
     return *this;
   }
 
   template <class _Source>
   _EnableIfPathable<_Source> operator+=(const _Source& __x) {
     return this->concat(__x);
   }
 
   template <class _Source>
   _EnableIfPathable<_Source> concat(const _Source& __x) {
     _SourceCVT<_Source>::__append_source(__pn_, __x);
     return *this;
   }
 
   template <class _InputIt>
   path& concat(_InputIt __first, _InputIt __last) {
     typedef typename iterator_traits<_InputIt>::value_type _ItVal;
     _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
     return *this;
   }
 
   // modifiers
   _LIBCPP_INLINE_VISIBILITY
   void clear() noexcept { __pn_.clear(); }
 
   path& make_preferred() { return *this; }
 
   _LIBCPP_INLINE_VISIBILITY
   path& remove_filename() {
     auto __fname = __filename();
     if (!__fname.empty())
       __pn_.erase(__fname.data() - __pn_.data());
     return *this;
   }
 
   path& replace_filename(const path& __replacement) {
     remove_filename();
     return (*this /= __replacement);
   }
 
   path& replace_extension(const path& __replacement = path());
 
   _LIBCPP_INLINE_VISIBILITY
   void swap(path& __rhs) noexcept { __pn_.swap(__rhs.__pn_); }
 
   // private helper to allow reserving memory in the path
   _LIBCPP_INLINE_VISIBILITY
   void __reserve(size_t __s) { __pn_.reserve(__s); }
 
   // native format observers
   _LIBCPP_INLINE_VISIBILITY
   const string_type& native() const noexcept { return __pn_; }
 
   _LIBCPP_INLINE_VISIBILITY
   const value_type* c_str() const noexcept { return __pn_.c_str(); }
 
   _LIBCPP_INLINE_VISIBILITY operator string_type() const { return __pn_; }
 
   template <class _ECharT, class _Traits = char_traits<_ECharT>,
             class _Allocator = allocator<_ECharT> >
   basic_string<_ECharT, _Traits, _Allocator>
   string(const _Allocator& __a = _Allocator()) const {
     using _CVT = __widen_from_utf8<sizeof(_ECharT) * __CHAR_BIT__>;
     using _Str = basic_string<_ECharT, _Traits, _Allocator>;
     _Str __s(__a);
     __s.reserve(__pn_.size());
     _CVT()(back_inserter(__s), __pn_.data(), __pn_.data() + __pn_.size());
     return __s;
   }
 
   _LIBCPP_INLINE_VISIBILITY std::string string() const { return __pn_; }
   _LIBCPP_INLINE_VISIBILITY std::wstring wstring() const {
     return string<wchar_t>();
   }
   _LIBCPP_INLINE_VISIBILITY std::string u8string() const { return __pn_; }
   _LIBCPP_INLINE_VISIBILITY std::u16string u16string() const {
     return string<char16_t>();
   }
   _LIBCPP_INLINE_VISIBILITY std::u32string u32string() const {
     return string<char32_t>();
   }
 
   // generic format observers
   template <class _ECharT, class _Traits = char_traits<_ECharT>,
             class _Allocator = allocator<_ECharT> >
   basic_string<_ECharT, _Traits, _Allocator>
   generic_string(const _Allocator& __a = _Allocator()) const {
     return string<_ECharT, _Traits, _Allocator>(__a);
   }
 
   std::string generic_string() const { return __pn_; }
   std::wstring generic_wstring() const { return string<wchar_t>(); }
   std::string generic_u8string() const { return __pn_; }
   std::u16string generic_u16string() const { return string<char16_t>(); }
   std::u32string generic_u32string() const { return string<char32_t>(); }
 
 private:
   int __compare(__string_view) const;
   __string_view __root_name() const;
   __string_view __root_directory() const;
   __string_view __root_path_raw() const;
   __string_view __relative_path() const;
   __string_view __parent_path() const;
   __string_view __filename() const;
   __string_view __stem() const;
   __string_view __extension() const;
 
 public:
   // compare
   _LIBCPP_INLINE_VISIBILITY int compare(const path& __p) const noexcept {
     return __compare(__p.__pn_);
   }
   _LIBCPP_INLINE_VISIBILITY int compare(const string_type& __s) const {
     return __compare(__s);
   }
   _LIBCPP_INLINE_VISIBILITY int compare(__string_view __s) const {
     return __compare(__s);
   }
   _LIBCPP_INLINE_VISIBILITY int compare(const value_type* __s) const {
     return __compare(__s);
   }
 
   // decomposition
   _LIBCPP_INLINE_VISIBILITY path root_name() const {
     return string_type(__root_name());
   }
   _LIBCPP_INLINE_VISIBILITY path root_directory() const {
     return string_type(__root_directory());
   }
   _LIBCPP_INLINE_VISIBILITY path root_path() const {
     return root_name().append(string_type(__root_directory()));
   }
   _LIBCPP_INLINE_VISIBILITY path relative_path() const {
     return string_type(__relative_path());
   }
   _LIBCPP_INLINE_VISIBILITY path parent_path() const {
     return string_type(__parent_path());
   }
   _LIBCPP_INLINE_VISIBILITY path filename() const {
     return string_type(__filename());
   }
   _LIBCPP_INLINE_VISIBILITY path stem() const { return string_type(__stem()); }
   _LIBCPP_INLINE_VISIBILITY path extension() const {
     return string_type(__extension());
   }
 
   // query
   _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY bool
   empty() const noexcept {
     return __pn_.empty();
   }
 
   _LIBCPP_INLINE_VISIBILITY bool has_root_name() const {
     return !__root_name().empty();
   }
   _LIBCPP_INLINE_VISIBILITY bool has_root_directory() const {
     return !__root_directory().empty();
   }
   _LIBCPP_INLINE_VISIBILITY bool has_root_path() const {
     return !__root_path_raw().empty();
   }
   _LIBCPP_INLINE_VISIBILITY bool has_relative_path() const {
     return !__relative_path().empty();
   }
   _LIBCPP_INLINE_VISIBILITY bool has_parent_path() const {
     return !__parent_path().empty();
   }
   _LIBCPP_INLINE_VISIBILITY bool has_filename() const {
     return !__filename().empty();
   }
   _LIBCPP_INLINE_VISIBILITY bool has_stem() const { return !__stem().empty(); }
   _LIBCPP_INLINE_VISIBILITY bool has_extension() const {
     return !__extension().empty();
   }
 
   _LIBCPP_INLINE_VISIBILITY bool is_absolute() const {
     return has_root_directory();
   }
   _LIBCPP_INLINE_VISIBILITY bool is_relative() const { return !is_absolute(); }
 
   // relative paths
   path lexically_normal() const;
   path lexically_relative(const path& __base) const;
 
   _LIBCPP_INLINE_VISIBILITY path lexically_proximate(const path& __base) const {
     path __result = this->lexically_relative(__base);
     if (__result.native().empty())
       return *this;
     return __result;
   }
 
   // iterators
   class _LIBCPP_TYPE_VIS iterator;
   typedef iterator const_iterator;
 
   iterator begin() const;
   iterator end() const;
 
   template <class _CharT, class _Traits>
   _LIBCPP_INLINE_VISIBILITY friend
       typename enable_if<is_same<_CharT, char>::value &&
                              is_same<_Traits, char_traits<char> >::value,
                          basic_ostream<_CharT, _Traits>&>::type
       operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
     __os << std::__quoted(__p.native());
     return __os;
   }
 
   template <class _CharT, class _Traits>
   _LIBCPP_INLINE_VISIBILITY friend
       typename enable_if<!is_same<_CharT, char>::value ||
                              !is_same<_Traits, char_traits<char> >::value,
                          basic_ostream<_CharT, _Traits>&>::type
       operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
     __os << std::__quoted(__p.string<_CharT, _Traits>());
     return __os;
   }
 
   template <class _CharT, class _Traits>
   _LIBCPP_INLINE_VISIBILITY friend basic_istream<_CharT, _Traits>&
   operator>>(basic_istream<_CharT, _Traits>& __is, path& __p) {
     basic_string<_CharT, _Traits> __tmp;
     __is >> __quoted(__tmp);
     __p = __tmp;
     return __is;
   }
 
   friend _LIBCPP_INLINE_VISIBILITY bool operator==(const path& __lhs, const path& __rhs) noexcept {
     return __lhs.compare(__rhs) == 0;
   }
   friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const path& __lhs, const path& __rhs) noexcept {
     return __lhs.compare(__rhs) != 0;
   }
   friend _LIBCPP_INLINE_VISIBILITY bool operator<(const path& __lhs, const path& __rhs) noexcept {
     return __lhs.compare(__rhs) < 0;
   }
   friend _LIBCPP_INLINE_VISIBILITY bool operator<=(const path& __lhs, const path& __rhs) noexcept {
     return __lhs.compare(__rhs) <= 0;
   }
   friend _LIBCPP_INLINE_VISIBILITY bool operator>(const path& __lhs, const path& __rhs) noexcept {
     return __lhs.compare(__rhs) > 0;
   }
   friend _LIBCPP_INLINE_VISIBILITY bool operator>=(const path& __lhs, const path& __rhs) noexcept {
     return __lhs.compare(__rhs) >= 0;
   }
 
   friend _LIBCPP_INLINE_VISIBILITY path operator/(const path& __lhs,
                                                   const path& __rhs) {
     path __result(__lhs);
     __result /= __rhs;
     return __result;
   }
 private:
   inline _LIBCPP_INLINE_VISIBILITY path&
   __assign_view(__string_view const& __s) noexcept {
     __pn_ = string_type(__s);
     return *this;
   }
   string_type __pn_;
 };
 
 inline _LIBCPP_INLINE_VISIBILITY void swap(path& __lhs, path& __rhs) noexcept {
   __lhs.swap(__rhs);
 }
 
 _LIBCPP_FUNC_VIS
 size_t hash_value(const path& __p) noexcept;
 
 template <class _Source>
 _LIBCPP_INLINE_VISIBILITY
     typename enable_if<__is_pathable<_Source>::value, path>::type
     u8path(const _Source& __s) {
   static_assert(
       is_same<typename __is_pathable<_Source>::__char_type, char>::value,
       "u8path(Source const&) requires Source have a character type of type "
       "'char'");
   return path(__s);
 }
 
 template <class _InputIt>
 _LIBCPP_INLINE_VISIBILITY
     typename enable_if<__is_pathable<_InputIt>::value, path>::type
     u8path(_InputIt __f, _InputIt __l) {
   static_assert(
       is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
       "u8path(Iter, Iter) requires Iter have a value_type of type 'char'");
   return path(__f, __l);
 }
 
 class _LIBCPP_TYPE_VIS path::iterator {
 public:
   enum _ParserState : unsigned char {
     _Singular,
     _BeforeBegin,
     _InRootName,
     _InRootDir,
     _InFilenames,
     _InTrailingSep,
     _AtEnd
   };
 
 public:
   typedef bidirectional_iterator_tag iterator_category;
 
   typedef path value_type;
   typedef std::ptrdiff_t difference_type;
   typedef const path* pointer;
   typedef const path& reference;
 
   typedef void
       __stashing_iterator_tag; // See reverse_iterator and __is_stashing_iterator
 
 public:
   _LIBCPP_INLINE_VISIBILITY
   iterator()
       : __stashed_elem_(), __path_ptr_(nullptr), __entry_(),
         __state_(_Singular) {}
 
   iterator(const iterator&) = default;
   ~iterator() = default;
 
   iterator& operator=(const iterator&) = default;
 
   _LIBCPP_INLINE_VISIBILITY
   reference operator*() const { return __stashed_elem_; }
 
   _LIBCPP_INLINE_VISIBILITY
   pointer operator->() const { return &__stashed_elem_; }
 
   _LIBCPP_INLINE_VISIBILITY
   iterator& operator++() {
     _LIBCPP_ASSERT(__state_ != _Singular,
                    "attempting to increment a singular iterator");
     _LIBCPP_ASSERT(__state_ != _AtEnd,
                    "attempting to increment the end iterator");
     return __increment();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   iterator operator++(int) {
     iterator __it(*this);
     this->operator++();
     return __it;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   iterator& operator--() {
     _LIBCPP_ASSERT(__state_ != _Singular,
                    "attempting to decrement a singular iterator");
     _LIBCPP_ASSERT(__entry_.data() != __path_ptr_->native().data(),
                    "attempting to decrement the begin iterator");
     return __decrement();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   iterator operator--(int) {
     iterator __it(*this);
     this->operator--();
     return __it;
   }
 
 private:
   friend class path;
 
   inline _LIBCPP_INLINE_VISIBILITY friend bool operator==(const iterator&,
                                                           const iterator&);
 
   iterator& __increment();
   iterator& __decrement();
 
   path __stashed_elem_;
   const path* __path_ptr_;
   path::__string_view __entry_;
   _ParserState __state_;
 };
 
 inline _LIBCPP_INLINE_VISIBILITY bool operator==(const path::iterator& __lhs,
                                                  const path::iterator& __rhs) {
   return __lhs.__path_ptr_ == __rhs.__path_ptr_ &&
          __lhs.__entry_.data() == __rhs.__entry_.data();
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const path::iterator& __lhs,
                                                  const path::iterator& __rhs) {
   return !(__lhs == __rhs);
 }
 
 // TODO(ldionne): We need to pop the pragma and push it again after
 //                filesystem_error to work around PR41078.
 _LIBCPP_AVAILABILITY_FILESYSTEM_POP
 
 class _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error {
 public:
   _LIBCPP_INLINE_VISIBILITY
   filesystem_error(const string& __what, error_code __ec)
       : system_error(__ec, __what),
         __storage_(make_shared<_Storage>(path(), path())) {
     __create_what(0);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   filesystem_error(const string& __what, const path& __p1, error_code __ec)
       : system_error(__ec, __what),
         __storage_(make_shared<_Storage>(__p1, path())) {
     __create_what(1);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   filesystem_error(const string& __what, const path& __p1, const path& __p2,
                    error_code __ec)
       : system_error(__ec, __what),
         __storage_(make_shared<_Storage>(__p1, __p2)) {
     __create_what(2);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   const path& path1() const noexcept { return __storage_->__p1_; }
 
   _LIBCPP_INLINE_VISIBILITY
   const path& path2() const noexcept { return __storage_->__p2_; }
 
+  filesystem_error(const filesystem_error&) = default;
   ~filesystem_error() override; // key function
 
   _LIBCPP_INLINE_VISIBILITY
   const char* what() const noexcept override {
     return __storage_->__what_.c_str();
   }
 
   void __create_what(int __num_paths);
 
 private:
   struct _LIBCPP_HIDDEN _Storage {
     _LIBCPP_INLINE_VISIBILITY
     _Storage(const path& __p1, const path& __p2) : __p1_(__p1), __p2_(__p2) {}
 
     path __p1_;
     path __p2_;
     string __what_;
   };
   shared_ptr<_Storage> __storage_;
 };
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
 
 template <class... _Args>
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_NO_EXCEPTIONS
 void __throw_filesystem_error(_Args&&... __args) {
   throw filesystem_error(std::forward<_Args>(__args)...);
 }
 #else
 void __throw_filesystem_error(_Args&&...) {
   _VSTD::abort();
 }
 #endif
 
 // operational functions
 
 _LIBCPP_FUNC_VIS
 path __absolute(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 path __canonical(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 void __copy(const path& __from, const path& __to, copy_options __opt,
             error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 bool __copy_file(const path& __from, const path& __to, copy_options __opt,
                  error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 void __copy_symlink(const path& __existing_symlink, const path& __new_symlink,
                     error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 bool __create_directories(const path& p, error_code* ec = nullptr);
 _LIBCPP_FUNC_VIS
 bool __create_directory(const path& p, error_code* ec = nullptr);
 _LIBCPP_FUNC_VIS
 bool __create_directory(const path& p, const path& attributes,
                         error_code* ec = nullptr);
 _LIBCPP_FUNC_VIS
 void __create_directory_symlink(const path& __to, const path& __new_symlink,
                                 error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 void __create_hard_link(const path& __to, const path& __new_hard_link,
                         error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 void __create_symlink(const path& __to, const path& __new_symlink,
                       error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 path __current_path(error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 void __current_path(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 bool __equivalent(const path&, const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 uintmax_t __file_size(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 uintmax_t __hard_link_count(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 bool __fs_is_empty(const path& p, error_code* ec = nullptr);
 _LIBCPP_FUNC_VIS
 file_time_type __last_write_time(const path& p, error_code* ec = nullptr);
 _LIBCPP_FUNC_VIS
 void __last_write_time(const path& p, file_time_type new_time,
                        error_code* ec = nullptr);
 _LIBCPP_FUNC_VIS
 void __permissions(const path&, perms, perm_options, error_code* = nullptr);
 _LIBCPP_FUNC_VIS
 path __read_symlink(const path& p, error_code* ec = nullptr);
 _LIBCPP_FUNC_VIS
 bool __remove(const path& p, error_code* ec = nullptr);
 _LIBCPP_FUNC_VIS
 uintmax_t __remove_all(const path& p, error_code* ec = nullptr);
 _LIBCPP_FUNC_VIS
 void __rename(const path& from, const path& to, error_code* ec = nullptr);
 _LIBCPP_FUNC_VIS
 void __resize_file(const path& p, uintmax_t size, error_code* ec = nullptr);
 _LIBCPP_FUNC_VIS
 space_info __space(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 file_status __status(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 file_status __symlink_status(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 path __system_complete(const path&, error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 path __temp_directory_path(error_code* __ec = nullptr);
 _LIBCPP_FUNC_VIS
 path __weakly_canonical(path const& __p, error_code* __ec = nullptr);
 
 inline _LIBCPP_INLINE_VISIBILITY path current_path() {
   return __current_path();
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path current_path(error_code& __ec) {
   return __current_path(&__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void current_path(const path& __p) {
   __current_path(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void current_path(const path& __p,
                                                    error_code& __ec) noexcept {
   __current_path(__p, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path absolute(const path& __p) {
   return __absolute(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path absolute(const path& __p,
                                                error_code& __ec) {
   return __absolute(__p, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path canonical(const path& __p) {
   return __canonical(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path canonical(const path& __p,
                                                 error_code& __ec) {
   return __canonical(__p, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from,
                                            const path& __to) {
   __copy(__from, __to, copy_options::none);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
                                            error_code& __ec) {
   __copy(__from, __to, copy_options::none, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
                                            copy_options __opt) {
   __copy(__from, __to, __opt);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void copy(const path& __from, const path& __to,
                                            copy_options __opt,
                                            error_code& __ec) {
   __copy(__from, __to, __opt, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool copy_file(const path& __from,
                                                 const path& __to) {
   return __copy_file(__from, __to, copy_options::none);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool
 copy_file(const path& __from, const path& __to, error_code& __ec) {
   return __copy_file(__from, __to, copy_options::none, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool
 copy_file(const path& __from, const path& __to, copy_options __opt) {
   return __copy_file(__from, __to, __opt);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool copy_file(const path& __from,
                                                 const path& __to,
                                                 copy_options __opt,
                                                 error_code& __ec) {
   return __copy_file(__from, __to, __opt, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void copy_symlink(const path& __existing,
                                                    const path& __new) {
   __copy_symlink(__existing, __new);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void
 copy_symlink(const path& __ext, const path& __new, error_code& __ec) noexcept {
   __copy_symlink(__ext, __new, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool create_directories(const path& __p) {
   return __create_directories(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool create_directories(const path& __p,
                                                          error_code& __ec) {
   return __create_directories(__p, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool create_directory(const path& __p) {
   return __create_directory(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool
 create_directory(const path& __p, error_code& __ec) noexcept {
   return __create_directory(__p, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool create_directory(const path& __p,
                                                        const path& __attrs) {
   return __create_directory(__p, __attrs);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool
 create_directory(const path& __p, const path& __attrs,
                  error_code& __ec) noexcept {
   return __create_directory(__p, __attrs, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void
 create_directory_symlink(const path& __to, const path& __new) {
   __create_directory_symlink(__to, __new);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void
 create_directory_symlink(const path& __to, const path& __new,
                          error_code& __ec) noexcept {
   __create_directory_symlink(__to, __new, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void create_hard_link(const path& __to,
                                                        const path& __new) {
   __create_hard_link(__to, __new);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void
 create_hard_link(const path& __to, const path& __new,
                  error_code& __ec) noexcept {
   __create_hard_link(__to, __new, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void create_symlink(const path& __to,
                                                      const path& __new) {
   __create_symlink(__to, __new);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void
 create_symlink(const path& __to, const path& __new, error_code& __ec) noexcept {
   return __create_symlink(__to, __new, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool status_known(file_status __s) noexcept {
   return __s.type() != file_type::none;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool exists(file_status __s) noexcept {
   return status_known(__s) && __s.type() != file_type::not_found;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool exists(const path& __p) {
   return exists(__status(__p));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool exists(const path& __p,
                                              error_code& __ec) noexcept {
   auto __s = __status(__p, &__ec);
   if (status_known(__s))
     __ec.clear();
   return exists(__s);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool equivalent(const path& __p1,
                                                  const path& __p2) {
   return __equivalent(__p1, __p2);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool
 equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept {
   return __equivalent(__p1, __p2, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY uintmax_t file_size(const path& __p) {
   return __file_size(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY uintmax_t
 file_size(const path& __p, error_code& __ec) noexcept {
   return __file_size(__p, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY uintmax_t hard_link_count(const path& __p) {
   return __hard_link_count(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY uintmax_t
 hard_link_count(const path& __p, error_code& __ec) noexcept {
   return __hard_link_count(__p, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(file_status __s) noexcept {
   return __s.type() == file_type::block;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(const path& __p) {
   return is_block_file(__status(__p));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_block_file(const path& __p,
                                                     error_code& __ec) noexcept {
   return is_block_file(__status(__p, &__ec));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool
 is_character_file(file_status __s) noexcept {
   return __s.type() == file_type::character;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_character_file(const path& __p) {
   return is_character_file(__status(__p));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool
 is_character_file(const path& __p, error_code& __ec) noexcept {
   return is_character_file(__status(__p, &__ec));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_directory(file_status __s) noexcept {
   return __s.type() == file_type::directory;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_directory(const path& __p) {
   return is_directory(__status(__p));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_directory(const path& __p,
                                                    error_code& __ec) noexcept {
   return is_directory(__status(__p, &__ec));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_empty(const path& __p) {
   return __fs_is_empty(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_empty(const path& __p,
                                                error_code& __ec) {
   return __fs_is_empty(__p, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(file_status __s) noexcept {
   return __s.type() == file_type::fifo;
 }
 inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(const path& __p) {
   return is_fifo(__status(__p));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_fifo(const path& __p,
                                               error_code& __ec) noexcept {
   return is_fifo(__status(__p, &__ec));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool
 is_regular_file(file_status __s) noexcept {
   return __s.type() == file_type::regular;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_regular_file(const path& __p) {
   return is_regular_file(__status(__p));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool
 is_regular_file(const path& __p, error_code& __ec) noexcept {
   return is_regular_file(__status(__p, &__ec));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_socket(file_status __s) noexcept {
   return __s.type() == file_type::socket;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_socket(const path& __p) {
   return is_socket(__status(__p));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_socket(const path& __p,
                                                 error_code& __ec) noexcept {
   return is_socket(__status(__p, &__ec));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(file_status __s) noexcept {
   return __s.type() == file_type::symlink;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(const path& __p) {
   return is_symlink(__symlink_status(__p));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_symlink(const path& __p,
                                                  error_code& __ec) noexcept {
   return is_symlink(__symlink_status(__p, &__ec));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_other(file_status __s) noexcept {
   return exists(__s) && !is_regular_file(__s) && !is_directory(__s) &&
          !is_symlink(__s);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_other(const path& __p) {
   return is_other(__status(__p));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool is_other(const path& __p,
                                                error_code& __ec) noexcept {
   return is_other(__status(__p, &__ec));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY file_time_type
 last_write_time(const path& __p) {
   return __last_write_time(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY file_time_type
 last_write_time(const path& __p, error_code& __ec) noexcept {
   return __last_write_time(__p, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void last_write_time(const path& __p,
                                                       file_time_type __t) {
   __last_write_time(__p, __t);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void
 last_write_time(const path& __p, file_time_type __t,
                 error_code& __ec) noexcept {
   __last_write_time(__p, __t, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void
 permissions(const path& __p, perms __prms,
             perm_options __opts = perm_options::replace) {
   __permissions(__p, __prms, __opts);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void permissions(const path& __p, perms __prms,
                                                   error_code& __ec) noexcept {
   __permissions(__p, __prms, perm_options::replace, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void permissions(const path& __p, perms __prms,
                                                   perm_options __opts,
                                                   error_code& __ec) {
   __permissions(__p, __prms, __opts, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p,
                                                 const path& __base,
                                                 error_code& __ec) {
   path __tmp = __weakly_canonical(__p, &__ec);
   if (__ec)
     return {};
   path __tmp_base = __weakly_canonical(__base, &__ec);
   if (__ec)
     return {};
   return __tmp.lexically_proximate(__tmp_base);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p,
                                                 error_code& __ec) {
   return proximate(__p, current_path(), __ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path
 proximate(const path& __p, const path& __base = current_path()) {
   return __weakly_canonical(__p).lexically_proximate(
       __weakly_canonical(__base));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path read_symlink(const path& __p) {
   return __read_symlink(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path read_symlink(const path& __p,
                                                    error_code& __ec) {
   return __read_symlink(__p, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p,
                                                const path& __base,
                                                error_code& __ec) {
   path __tmp = __weakly_canonical(__p, &__ec);
   if (__ec)
     return path();
   path __tmpbase = __weakly_canonical(__base, &__ec);
   if (__ec)
     return path();
   return __tmp.lexically_relative(__tmpbase);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p,
                                                error_code& __ec) {
   return relative(__p, current_path(), __ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path
 relative(const path& __p, const path& __base = current_path()) {
   return __weakly_canonical(__p).lexically_relative(__weakly_canonical(__base));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool remove(const path& __p) {
   return __remove(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool remove(const path& __p,
                                              error_code& __ec) noexcept {
   return __remove(__p, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY uintmax_t remove_all(const path& __p) {
   return __remove_all(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY uintmax_t remove_all(const path& __p,
                                                       error_code& __ec) {
   return __remove_all(__p, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void rename(const path& __from,
                                              const path& __to) {
   return __rename(__from, __to);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void
 rename(const path& __from, const path& __to, error_code& __ec) noexcept {
   return __rename(__from, __to, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void resize_file(const path& __p,
                                                   uintmax_t __ns) {
   return __resize_file(__p, __ns);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY void
 resize_file(const path& __p, uintmax_t __ns, error_code& __ec) noexcept {
   return __resize_file(__p, __ns, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY space_info space(const path& __p) {
   return __space(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY space_info space(const path& __p,
                                                   error_code& __ec) noexcept {
   return __space(__p, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY file_status status(const path& __p) {
   return __status(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY file_status status(const path& __p,
                                                     error_code& __ec) noexcept {
   return __status(__p, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY file_status symlink_status(const path& __p) {
   return __symlink_status(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY file_status
 symlink_status(const path& __p, error_code& __ec) noexcept {
   return __symlink_status(__p, &__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path temp_directory_path() {
   return __temp_directory_path();
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path temp_directory_path(error_code& __ec) {
   return __temp_directory_path(&__ec);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p) {
   return __weakly_canonical(__p);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY path weakly_canonical(path const& __p,
                                                        error_code& __ec) {
   return __weakly_canonical(__p, &__ec);
 }
 
 class directory_iterator;
 class recursive_directory_iterator;
 class _LIBCPP_HIDDEN __dir_stream;
 
 class directory_entry {
   typedef _VSTD_FS::path _Path;
 
 public:
   // constructors and destructors
   directory_entry() noexcept = default;
   directory_entry(directory_entry const&) = default;
   directory_entry(directory_entry&&) noexcept = default;
 
   _LIBCPP_INLINE_VISIBILITY
   explicit directory_entry(_Path const& __p) : __p_(__p) {
     error_code __ec;
     __refresh(&__ec);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   directory_entry(_Path const& __p, error_code& __ec) : __p_(__p) {
     __refresh(&__ec);
   }
 
   ~directory_entry() {}
 
   directory_entry& operator=(directory_entry const&) = default;
   directory_entry& operator=(directory_entry&&) noexcept = default;
 
   _LIBCPP_INLINE_VISIBILITY
   void assign(_Path const& __p) {
     __p_ = __p;
     error_code __ec;
     __refresh(&__ec);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void assign(_Path const& __p, error_code& __ec) {
     __p_ = __p;
     __refresh(&__ec);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void replace_filename(_Path const& __p) {
     __p_.replace_filename(__p);
     error_code __ec;
     __refresh(&__ec);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void replace_filename(_Path const& __p, error_code& __ec) {
     __p_ = __p_.parent_path() / __p;
     __refresh(&__ec);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void refresh() { __refresh(); }
 
   _LIBCPP_INLINE_VISIBILITY
   void refresh(error_code& __ec) noexcept { __refresh(&__ec); }
 
   _LIBCPP_INLINE_VISIBILITY
   _Path const& path() const noexcept { return __p_; }
 
   _LIBCPP_INLINE_VISIBILITY
   operator const _Path&() const noexcept { return __p_; }
 
   _LIBCPP_INLINE_VISIBILITY
   bool exists() const { return _VSTD_FS::exists(file_status{__get_ft()}); }
 
   _LIBCPP_INLINE_VISIBILITY
   bool exists(error_code& __ec) const noexcept {
     return _VSTD_FS::exists(file_status{__get_ft(&__ec)});
   }
 
   _LIBCPP_INLINE_VISIBILITY
   bool is_block_file() const { return __get_ft() == file_type::block; }
 
   _LIBCPP_INLINE_VISIBILITY
   bool is_block_file(error_code& __ec) const noexcept {
     return __get_ft(&__ec) == file_type::block;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   bool is_character_file() const { return __get_ft() == file_type::character; }
 
   _LIBCPP_INLINE_VISIBILITY
   bool is_character_file(error_code& __ec) const noexcept {
     return __get_ft(&__ec) == file_type::character;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   bool is_directory() const { return __get_ft() == file_type::directory; }
 
   _LIBCPP_INLINE_VISIBILITY
   bool is_directory(error_code& __ec) const noexcept {
     return __get_ft(&__ec) == file_type::directory;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   bool is_fifo() const { return __get_ft() == file_type::fifo; }
 
   _LIBCPP_INLINE_VISIBILITY
   bool is_fifo(error_code& __ec) const noexcept {
     return __get_ft(&__ec) == file_type::fifo;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   bool is_other() const { return _VSTD_FS::is_other(file_status{__get_ft()}); }
 
   _LIBCPP_INLINE_VISIBILITY
   bool is_other(error_code& __ec) const noexcept {
     return _VSTD_FS::is_other(file_status{__get_ft(&__ec)});
   }
 
   _LIBCPP_INLINE_VISIBILITY
   bool is_regular_file() const { return __get_ft() == file_type::regular; }
 
   _LIBCPP_INLINE_VISIBILITY
   bool is_regular_file(error_code& __ec) const noexcept {
     return __get_ft(&__ec) == file_type::regular;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   bool is_socket() const { return __get_ft() == file_type::socket; }
 
   _LIBCPP_INLINE_VISIBILITY
   bool is_socket(error_code& __ec) const noexcept {
     return __get_ft(&__ec) == file_type::socket;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   bool is_symlink() const { return __get_sym_ft() == file_type::symlink; }
 
   _LIBCPP_INLINE_VISIBILITY
   bool is_symlink(error_code& __ec) const noexcept {
     return __get_sym_ft(&__ec) == file_type::symlink;
   }
   _LIBCPP_INLINE_VISIBILITY
   uintmax_t file_size() const { return __get_size(); }
 
   _LIBCPP_INLINE_VISIBILITY
   uintmax_t file_size(error_code& __ec) const noexcept {
     return __get_size(&__ec);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   uintmax_t hard_link_count() const { return __get_nlink(); }
 
   _LIBCPP_INLINE_VISIBILITY
   uintmax_t hard_link_count(error_code& __ec) const noexcept {
     return __get_nlink(&__ec);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   file_time_type last_write_time() const { return __get_write_time(); }
 
   _LIBCPP_INLINE_VISIBILITY
   file_time_type last_write_time(error_code& __ec) const noexcept {
     return __get_write_time(&__ec);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   file_status status() const { return __get_status(); }
 
   _LIBCPP_INLINE_VISIBILITY
   file_status status(error_code& __ec) const noexcept {
     return __get_status(&__ec);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   file_status symlink_status() const { return __get_symlink_status(); }
 
   _LIBCPP_INLINE_VISIBILITY
   file_status symlink_status(error_code& __ec) const noexcept {
     return __get_symlink_status(&__ec);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   bool operator<(directory_entry const& __rhs) const noexcept {
     return __p_ < __rhs.__p_;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   bool operator==(directory_entry const& __rhs) const noexcept {
     return __p_ == __rhs.__p_;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   bool operator!=(directory_entry const& __rhs) const noexcept {
     return __p_ != __rhs.__p_;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   bool operator<=(directory_entry const& __rhs) const noexcept {
     return __p_ <= __rhs.__p_;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   bool operator>(directory_entry const& __rhs) const noexcept {
     return __p_ > __rhs.__p_;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   bool operator>=(directory_entry const& __rhs) const noexcept {
     return __p_ >= __rhs.__p_;
   }
 
 private:
   friend class directory_iterator;
   friend class recursive_directory_iterator;
   friend class __dir_stream;
 
   enum _CacheType : unsigned char {
     _Empty,
     _IterSymlink,
     _IterNonSymlink,
     _RefreshSymlink,
     _RefreshSymlinkUnresolved,
     _RefreshNonSymlink
   };
 
   struct __cached_data {
     uintmax_t __size_;
     uintmax_t __nlink_;
     file_time_type __write_time_;
     perms __sym_perms_;
     perms __non_sym_perms_;
     file_type __type_;
     _CacheType __cache_type_;
 
     _LIBCPP_INLINE_VISIBILITY
     __cached_data() noexcept { __reset(); }
 
     _LIBCPP_INLINE_VISIBILITY
     void __reset() {
       __cache_type_ = _Empty;
       __type_ = file_type::none;
       __sym_perms_ = __non_sym_perms_ = perms::unknown;
       __size_ = __nlink_ = uintmax_t(-1);
       __write_time_ = file_time_type::min();
     }
   };
 
   _LIBCPP_INLINE_VISIBILITY
   static __cached_data __create_iter_result(file_type __ft) {
     __cached_data __data;
     __data.__type_ = __ft;
     __data.__cache_type_ = [&]() {
       switch (__ft) {
       case file_type::none:
         return _Empty;
       case file_type::symlink:
         return _IterSymlink;
       default:
         return _IterNonSymlink;
       }
     }();
     return __data;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void __assign_iter_entry(_Path&& __p, __cached_data __dt) {
     __p_ = std::move(__p);
     __data_ = __dt;
   }
 
   _LIBCPP_FUNC_VIS
   error_code __do_refresh() noexcept;
 
   _LIBCPP_INLINE_VISIBILITY
   static bool __is_dne_error(error_code const& __ec) {
     if (!__ec)
       return true;
     switch (static_cast<errc>(__ec.value())) {
     case errc::no_such_file_or_directory:
     case errc::not_a_directory:
       return true;
     default:
       return false;
     }
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void __handle_error(const char* __msg, error_code* __dest_ec,
                       error_code const& __ec, bool __allow_dne = false) const {
     if (__dest_ec) {
       *__dest_ec = __ec;
       return;
     }
     if (__ec && (!__allow_dne || !__is_dne_error(__ec)))
       __throw_filesystem_error(__msg, __p_, __ec);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void __refresh(error_code* __ec = nullptr) {
     __handle_error("in directory_entry::refresh", __ec, __do_refresh(),
                    /*allow_dne*/ true);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   file_type __get_sym_ft(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
       return __symlink_status(__p_, __ec).type();
     case _IterSymlink:
     case _RefreshSymlink:
     case _RefreshSymlinkUnresolved:
       if (__ec)
         __ec->clear();
       return file_type::symlink;
     case _IterNonSymlink:
     case _RefreshNonSymlink:
       file_status __st(__data_.__type_);
       if (__ec && !_VSTD_FS::exists(__st))
         *__ec = make_error_code(errc::no_such_file_or_directory);
       else if (__ec)
         __ec->clear();
       return __data_.__type_;
     }
     _LIBCPP_UNREACHABLE();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   file_type __get_ft(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterSymlink:
     case _RefreshSymlinkUnresolved:
       return __status(__p_, __ec).type();
     case _IterNonSymlink:
     case _RefreshNonSymlink:
     case _RefreshSymlink: {
       file_status __st(__data_.__type_);
       if (__ec && !_VSTD_FS::exists(__st))
         *__ec = make_error_code(errc::no_such_file_or_directory);
       else if (__ec)
         __ec->clear();
       return __data_.__type_;
     }
     }
     _LIBCPP_UNREACHABLE();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   file_status __get_status(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterNonSymlink:
     case _IterSymlink:
     case _RefreshSymlinkUnresolved:
       return __status(__p_, __ec);
     case _RefreshNonSymlink:
     case _RefreshSymlink:
       return file_status(__get_ft(__ec), __data_.__non_sym_perms_);
     }
     _LIBCPP_UNREACHABLE();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   file_status __get_symlink_status(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterNonSymlink:
     case _IterSymlink:
       return __symlink_status(__p_, __ec);
     case _RefreshNonSymlink:
       return file_status(__get_sym_ft(__ec), __data_.__non_sym_perms_);
     case _RefreshSymlink:
     case _RefreshSymlinkUnresolved:
       return file_status(__get_sym_ft(__ec), __data_.__sym_perms_);
     }
     _LIBCPP_UNREACHABLE();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   uintmax_t __get_size(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterNonSymlink:
     case _IterSymlink:
     case _RefreshSymlinkUnresolved:
       return _VSTD_FS::__file_size(__p_, __ec);
     case _RefreshSymlink:
     case _RefreshNonSymlink: {
       error_code __m_ec;
       file_status __st(__get_ft(&__m_ec));
       __handle_error("in directory_entry::file_size", __ec, __m_ec);
       if (_VSTD_FS::exists(__st) && !_VSTD_FS::is_regular_file(__st)) {
         errc __err_kind = _VSTD_FS::is_directory(__st) ? errc::is_a_directory
                                                        : errc::not_supported;
         __handle_error("in directory_entry::file_size", __ec,
                        make_error_code(__err_kind));
       }
       return __data_.__size_;
     }
     }
     _LIBCPP_UNREACHABLE();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   uintmax_t __get_nlink(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterNonSymlink:
     case _IterSymlink:
     case _RefreshSymlinkUnresolved:
       return _VSTD_FS::__hard_link_count(__p_, __ec);
     case _RefreshSymlink:
     case _RefreshNonSymlink: {
       error_code __m_ec;
       (void)__get_ft(&__m_ec);
       __handle_error("in directory_entry::hard_link_count", __ec, __m_ec);
       return __data_.__nlink_;
     }
     }
     _LIBCPP_UNREACHABLE();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   file_time_type __get_write_time(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterNonSymlink:
     case _IterSymlink:
     case _RefreshSymlinkUnresolved:
       return _VSTD_FS::__last_write_time(__p_, __ec);
     case _RefreshSymlink:
     case _RefreshNonSymlink: {
       error_code __m_ec;
       file_status __st(__get_ft(&__m_ec));
       __handle_error("in directory_entry::last_write_time", __ec, __m_ec);
       if (_VSTD_FS::exists(__st) &&
           __data_.__write_time_ == file_time_type::min())
         __handle_error("in directory_entry::last_write_time", __ec,
                        make_error_code(errc::value_too_large));
       return __data_.__write_time_;
     }
     }
     _LIBCPP_UNREACHABLE();
   }
 
 private:
   _Path __p_;
   __cached_data __data_;
 };
 
 class __dir_element_proxy {
 public:
   inline _LIBCPP_INLINE_VISIBILITY directory_entry operator*() {
     return _VSTD::move(__elem_);
   }
 
 private:
   friend class directory_iterator;
   friend class recursive_directory_iterator;
   explicit __dir_element_proxy(directory_entry const& __e) : __elem_(__e) {}
   __dir_element_proxy(__dir_element_proxy&& __o)
       : __elem_(_VSTD::move(__o.__elem_)) {}
   directory_entry __elem_;
 };
 
 class directory_iterator {
 public:
   typedef directory_entry value_type;
   typedef ptrdiff_t difference_type;
   typedef value_type const* pointer;
   typedef value_type const& reference;
   typedef input_iterator_tag iterator_category;
 
 public:
   //ctor & dtor
   directory_iterator() noexcept {}
 
   explicit directory_iterator(const path& __p)
       : directory_iterator(__p, nullptr) {}
 
   directory_iterator(const path& __p, directory_options __opts)
       : directory_iterator(__p, nullptr, __opts) {}
 
   directory_iterator(const path& __p, error_code& __ec)
       : directory_iterator(__p, &__ec) {}
 
   directory_iterator(const path& __p, directory_options __opts,
                      error_code& __ec)
       : directory_iterator(__p, &__ec, __opts) {}
 
   directory_iterator(const directory_iterator&) = default;
   directory_iterator(directory_iterator&&) = default;
   directory_iterator& operator=(const directory_iterator&) = default;
 
   directory_iterator& operator=(directory_iterator&& __o) noexcept {
     // non-default implementation provided to support self-move assign.
     if (this != &__o) {
       __imp_ = _VSTD::move(__o.__imp_);
     }
     return *this;
   }
 
   ~directory_iterator() = default;
 
   const directory_entry& operator*() const {
     _LIBCPP_ASSERT(__imp_, "The end iterator cannot be dereferenced");
     return __dereference();
   }
 
   const directory_entry* operator->() const { return &**this; }
 
   directory_iterator& operator++() { return __increment(); }
 
   __dir_element_proxy operator++(int) {
     __dir_element_proxy __p(**this);
     __increment();
     return __p;
   }
 
   directory_iterator& increment(error_code& __ec) { return __increment(&__ec); }
 
 private:
   inline _LIBCPP_INLINE_VISIBILITY friend bool
   operator==(const directory_iterator& __lhs,
              const directory_iterator& __rhs) noexcept;
 
   // construct the dir_stream
   _LIBCPP_FUNC_VIS
   directory_iterator(const path&, error_code*,
                      directory_options = directory_options::none);
 
   _LIBCPP_FUNC_VIS
   directory_iterator& __increment(error_code* __ec = nullptr);
 
   _LIBCPP_FUNC_VIS
   const directory_entry& __dereference() const;
 
 private:
   shared_ptr<__dir_stream> __imp_;
 };
 
 inline _LIBCPP_INLINE_VISIBILITY bool
 operator==(const directory_iterator& __lhs,
            const directory_iterator& __rhs) noexcept {
   return __lhs.__imp_ == __rhs.__imp_;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY bool
 operator!=(const directory_iterator& __lhs,
            const directory_iterator& __rhs) noexcept {
   return !(__lhs == __rhs);
 }
 
 // enable directory_iterator range-based for statements
 inline _LIBCPP_INLINE_VISIBILITY directory_iterator
 begin(directory_iterator __iter) noexcept {
   return __iter;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY directory_iterator
 end(const directory_iterator&) noexcept {
   return directory_iterator();
 }
 
 class recursive_directory_iterator {
 public:
   using value_type = directory_entry;
   using difference_type = std::ptrdiff_t;
   using pointer = directory_entry const*;
   using reference = directory_entry const&;
   using iterator_category = std::input_iterator_tag;
 
 public:
   // constructors and destructor
   _LIBCPP_INLINE_VISIBILITY
   recursive_directory_iterator() noexcept : __rec_(false) {}
 
   _LIBCPP_INLINE_VISIBILITY
   explicit recursive_directory_iterator(
       const path& __p, directory_options __xoptions = directory_options::none)
       : recursive_directory_iterator(__p, __xoptions, nullptr) {}
 
   _LIBCPP_INLINE_VISIBILITY
   recursive_directory_iterator(const path& __p, directory_options __xoptions,
                                error_code& __ec)
       : recursive_directory_iterator(__p, __xoptions, &__ec) {}
 
   _LIBCPP_INLINE_VISIBILITY
   recursive_directory_iterator(const path& __p, error_code& __ec)
       : recursive_directory_iterator(__p, directory_options::none, &__ec) {}
 
   recursive_directory_iterator(const recursive_directory_iterator&) = default;
   recursive_directory_iterator(recursive_directory_iterator&&) = default;
 
   recursive_directory_iterator&
   operator=(const recursive_directory_iterator&) = default;
 
   _LIBCPP_INLINE_VISIBILITY
   recursive_directory_iterator&
   operator=(recursive_directory_iterator&& __o) noexcept {
     // non-default implementation provided to support self-move assign.
     if (this != &__o) {
       __imp_ = _VSTD::move(__o.__imp_);
       __rec_ = __o.__rec_;
     }
     return *this;
   }
 
   ~recursive_directory_iterator() = default;
 
   _LIBCPP_INLINE_VISIBILITY
   const directory_entry& operator*() const { return __dereference(); }
 
   _LIBCPP_INLINE_VISIBILITY
   const directory_entry* operator->() const { return &__dereference(); }
 
   recursive_directory_iterator& operator++() { return __increment(); }
 
   _LIBCPP_INLINE_VISIBILITY
   __dir_element_proxy operator++(int) {
     __dir_element_proxy __p(**this);
     __increment();
     return __p;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   recursive_directory_iterator& increment(error_code& __ec) {
     return __increment(&__ec);
   }
 
   _LIBCPP_FUNC_VIS directory_options options() const;
   _LIBCPP_FUNC_VIS int depth() const;
 
   _LIBCPP_INLINE_VISIBILITY
   void pop() { __pop(); }
 
   _LIBCPP_INLINE_VISIBILITY
   void pop(error_code& __ec) { __pop(&__ec); }
 
   _LIBCPP_INLINE_VISIBILITY
   bool recursion_pending() const { return __rec_; }
 
   _LIBCPP_INLINE_VISIBILITY
   void disable_recursion_pending() { __rec_ = false; }
 
 private:
   _LIBCPP_FUNC_VIS
   recursive_directory_iterator(const path& __p, directory_options __opt,
                                error_code* __ec);
 
   _LIBCPP_FUNC_VIS
   const directory_entry& __dereference() const;
 
   _LIBCPP_FUNC_VIS
   bool __try_recursion(error_code* __ec);
 
   _LIBCPP_FUNC_VIS
   void __advance(error_code* __ec = nullptr);
 
   _LIBCPP_FUNC_VIS
   recursive_directory_iterator& __increment(error_code* __ec = nullptr);
 
   _LIBCPP_FUNC_VIS
   void __pop(error_code* __ec = nullptr);
 
   inline _LIBCPP_INLINE_VISIBILITY friend bool
   operator==(const recursive_directory_iterator&,
              const recursive_directory_iterator&) noexcept;
 
   struct _LIBCPP_HIDDEN __shared_imp;
   shared_ptr<__shared_imp> __imp_;
   bool __rec_;
 }; // class recursive_directory_iterator
 
 inline _LIBCPP_INLINE_VISIBILITY bool
 operator==(const recursive_directory_iterator& __lhs,
            const recursive_directory_iterator& __rhs) noexcept {
   return __lhs.__imp_ == __rhs.__imp_;
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline bool operator!=(const recursive_directory_iterator& __lhs,
                        const recursive_directory_iterator& __rhs) noexcept {
   return !(__lhs == __rhs);
 }
 // enable recursive_directory_iterator range-based for statements
 inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator
 begin(recursive_directory_iterator __iter) noexcept {
   return __iter;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator
 end(const recursive_directory_iterator&) noexcept {
   return recursive_directory_iterator();
 }
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // !_LIBCPP_CXX03_LANG
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_FILESYSTEM
Index: head/contrib/llvm-project/libcxx/include/future
===================================================================
--- head/contrib/llvm-project/libcxx/include/future	(revision 359086)
+++ head/contrib/llvm-project/libcxx/include/future	(revision 359087)
@@ -1,2608 +1,2609 @@
 // -*- C++ -*-
 //===--------------------------- future -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_FUTURE
 #define _LIBCPP_FUTURE
 
 /*
     future synopsis
 
 namespace std
 {
 
 enum class future_errc
 {
     future_already_retrieved = 1,
     promise_already_satisfied,
     no_state,
     broken_promise
 };
 
 enum class launch
 {
     async = 1,
     deferred = 2,
     any = async | deferred
 };
 
 enum class future_status
 {
     ready,
     timeout,
     deferred
 };
 
 template <> struct is_error_code_enum<future_errc> : public true_type { };
 error_code make_error_code(future_errc e) noexcept;
 error_condition make_error_condition(future_errc e) noexcept;
 
 const error_category& future_category() noexcept;
 
 class future_error
     : public logic_error
 {
 public:
     future_error(error_code ec);  // exposition only
     explicit future_error(future_errc); // C++17
     const error_code& code() const noexcept;
     const char*       what() const noexcept;
 };
 
 template <class R>
 class promise
 {
 public:
     promise();
     template <class Allocator>
         promise(allocator_arg_t, const Allocator& a);
     promise(promise&& rhs) noexcept;
     promise(const promise& rhs) = delete;
     ~promise();
 
     // assignment
     promise& operator=(promise&& rhs) noexcept;
     promise& operator=(const promise& rhs) = delete;
     void swap(promise& other) noexcept;
 
     // retrieving the result
     future<R> get_future();
 
     // setting the result
     void set_value(const R& r);
     void set_value(R&& r);
     void set_exception(exception_ptr p);
 
     // setting the result with deferred notification
     void set_value_at_thread_exit(const R& r);
     void set_value_at_thread_exit(R&& r);
     void set_exception_at_thread_exit(exception_ptr p);
 };
 
 template <class R>
 class promise<R&>
 {
 public:
     promise();
     template <class Allocator>
         promise(allocator_arg_t, const Allocator& a);
     promise(promise&& rhs) noexcept;
     promise(const promise& rhs) = delete;
     ~promise();
 
     // assignment
     promise& operator=(promise&& rhs) noexcept;
     promise& operator=(const promise& rhs) = delete;
     void swap(promise& other) noexcept;
 
     // retrieving the result
     future<R&> get_future();
 
     // setting the result
     void set_value(R& r);
     void set_exception(exception_ptr p);
 
     // setting the result with deferred notification
     void set_value_at_thread_exit(R&);
     void set_exception_at_thread_exit(exception_ptr p);
 };
 
 template <>
 class promise<void>
 {
 public:
     promise();
     template <class Allocator>
         promise(allocator_arg_t, const Allocator& a);
     promise(promise&& rhs) noexcept;
     promise(const promise& rhs) = delete;
     ~promise();
 
     // assignment
     promise& operator=(promise&& rhs) noexcept;
     promise& operator=(const promise& rhs) = delete;
     void swap(promise& other) noexcept;
 
     // retrieving the result
     future<void> get_future();
 
     // setting the result
     void set_value();
     void set_exception(exception_ptr p);
 
     // setting the result with deferred notification
     void set_value_at_thread_exit();
     void set_exception_at_thread_exit(exception_ptr p);
 };
 
 template <class R> void swap(promise<R>& x, promise<R>& y) noexcept;
 
 template <class R, class Alloc>
     struct uses_allocator<promise<R>, Alloc> : public true_type {};
 
 template <class R>
 class future
 {
 public:
     future() noexcept;
     future(future&&) noexcept;
     future(const future& rhs) = delete;
     ~future();
     future& operator=(const future& rhs) = delete;
     future& operator=(future&&) noexcept;
     shared_future<R> share() noexcept;
 
     // retrieving the value
     R get();
 
     // functions to check state
     bool valid() const noexcept;
 
     void wait() const;
     template <class Rep, class Period>
         future_status
         wait_for(const chrono::duration<Rep, Period>& rel_time) const;
     template <class Clock, class Duration>
         future_status
         wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 };
 
 template <class R>
 class future<R&>
 {
 public:
     future() noexcept;
     future(future&&) noexcept;
     future(const future& rhs) = delete;
     ~future();
     future& operator=(const future& rhs) = delete;
     future& operator=(future&&) noexcept;
     shared_future<R&> share() noexcept;
 
     // retrieving the value
     R& get();
 
     // functions to check state
     bool valid() const noexcept;
 
     void wait() const;
     template <class Rep, class Period>
         future_status
         wait_for(const chrono::duration<Rep, Period>& rel_time) const;
     template <class Clock, class Duration>
         future_status
         wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 };
 
 template <>
 class future<void>
 {
 public:
     future() noexcept;
     future(future&&) noexcept;
     future(const future& rhs) = delete;
     ~future();
     future& operator=(const future& rhs) = delete;
     future& operator=(future&&) noexcept;
     shared_future<void> share() noexcept;
 
     // retrieving the value
     void get();
 
     // functions to check state
     bool valid() const noexcept;
 
     void wait() const;
     template <class Rep, class Period>
         future_status
         wait_for(const chrono::duration<Rep, Period>& rel_time) const;
     template <class Clock, class Duration>
         future_status
         wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 };
 
 template <class R>
 class shared_future
 {
 public:
     shared_future() noexcept;
     shared_future(const shared_future& rhs);
     shared_future(future<R>&&) noexcept;
     shared_future(shared_future&& rhs) noexcept;
     ~shared_future();
     shared_future& operator=(const shared_future& rhs);
     shared_future& operator=(shared_future&& rhs) noexcept;
 
     // retrieving the value
     const R& get() const;
 
     // functions to check state
     bool valid() const noexcept;
 
     void wait() const;
     template <class Rep, class Period>
         future_status
         wait_for(const chrono::duration<Rep, Period>& rel_time) const;
     template <class Clock, class Duration>
         future_status
         wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 };
 
 template <class R>
 class shared_future<R&>
 {
 public:
     shared_future() noexcept;
     shared_future(const shared_future& rhs);
     shared_future(future<R&>&&) noexcept;
     shared_future(shared_future&& rhs) noexcept;
     ~shared_future();
     shared_future& operator=(const shared_future& rhs);
     shared_future& operator=(shared_future&& rhs) noexcept;
 
     // retrieving the value
     R& get() const;
 
     // functions to check state
     bool valid() const noexcept;
 
     void wait() const;
     template <class Rep, class Period>
         future_status
         wait_for(const chrono::duration<Rep, Period>& rel_time) const;
     template <class Clock, class Duration>
         future_status
         wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 };
 
 template <>
 class shared_future<void>
 {
 public:
     shared_future() noexcept;
     shared_future(const shared_future& rhs);
     shared_future(future<void>&&) noexcept;
     shared_future(shared_future&& rhs) noexcept;
     ~shared_future();
     shared_future& operator=(const shared_future& rhs);
     shared_future& operator=(shared_future&& rhs) noexcept;
 
     // retrieving the value
     void get() const;
 
     // functions to check state
     bool valid() const noexcept;
 
     void wait() const;
     template <class Rep, class Period>
         future_status
         wait_for(const chrono::duration<Rep, Period>& rel_time) const;
     template <class Clock, class Duration>
         future_status
         wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 };
 
 template <class F, class... Args>
   future<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type>
   async(F&& f, Args&&... args);
 
 template <class F, class... Args>
   future<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type>
   async(launch policy, F&& f, Args&&... args);
 
 template <class> class packaged_task; // undefined
 
 template <class R, class... ArgTypes>
 class packaged_task<R(ArgTypes...)>
 {
 public:
     typedef R result_type; // extension
 
     // construction and destruction
     packaged_task() noexcept;
     template <class F>
         explicit packaged_task(F&& f);
     template <class F, class Allocator>
         packaged_task(allocator_arg_t, const Allocator& a, F&& f);
     ~packaged_task();
 
     // no copy
     packaged_task(const packaged_task&) = delete;
     packaged_task& operator=(const packaged_task&) = delete;
 
     // move support
     packaged_task(packaged_task&& other) noexcept;
     packaged_task& operator=(packaged_task&& other) noexcept;
     void swap(packaged_task& other) noexcept;
 
     bool valid() const noexcept;
 
     // result retrieval
     future<R> get_future();
 
     // execution
     void operator()(ArgTypes... );
     void make_ready_at_thread_exit(ArgTypes...);
 
     void reset();
 };
 
 template <class R>
   void swap(packaged_task<R(ArgTypes...)&, packaged_task<R(ArgTypes...)>&) noexcept;
 
 template <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>;
 
 }  // std
 
 */
 
 #include <__config>
 #include <system_error>
 #include <memory>
 #include <chrono>
 #include <exception>
 #include <mutex>
 #include <thread>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #ifdef _LIBCPP_HAS_NO_THREADS
 #error <future> is not supported on this single threaded system
 #else // !_LIBCPP_HAS_NO_THREADS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 //enum class future_errc
 _LIBCPP_DECLARE_STRONG_ENUM(future_errc)
 {
     future_already_retrieved = 1,
     promise_already_satisfied,
     no_state,
     broken_promise
 };
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc)
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc> : public true_type {};
 
 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
 template <>
 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc::__lx> : public true_type { };
 #endif
 
 //enum class launch
 _LIBCPP_DECLARE_STRONG_ENUM(launch)
 {
     async = 1,
     deferred = 2,
     any = async | deferred
 };
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(launch)
 
 #ifndef _LIBCPP_HAS_NO_STRONG_ENUMS
 
 typedef underlying_type<launch>::type __launch_underlying_type;
 
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
 launch
 operator&(launch __x, launch __y)
 {
     return static_cast<launch>(static_cast<__launch_underlying_type>(__x) &
                                static_cast<__launch_underlying_type>(__y));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
 launch
 operator|(launch __x, launch __y)
 {
     return static_cast<launch>(static_cast<__launch_underlying_type>(__x) |
                                static_cast<__launch_underlying_type>(__y));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
 launch
 operator^(launch __x, launch __y)
 {
     return static_cast<launch>(static_cast<__launch_underlying_type>(__x) ^
                                static_cast<__launch_underlying_type>(__y));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
 launch
 operator~(launch __x)
 {
     return static_cast<launch>(~static_cast<__launch_underlying_type>(__x) & 3);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 launch&
 operator&=(launch& __x, launch __y)
 {
     __x = __x & __y; return __x;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 launch&
 operator|=(launch& __x, launch __y)
 {
     __x = __x | __y; return __x;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 launch&
 operator^=(launch& __x, launch __y)
 {
     __x = __x ^ __y; return __x;
 }
 
 #endif  // !_LIBCPP_HAS_NO_STRONG_ENUMS
 
 //enum class future_status
 _LIBCPP_DECLARE_STRONG_ENUM(future_status)
 {
     ready,
     timeout,
     deferred
 };
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_status)
 
 _LIBCPP_FUNC_VIS
 const error_category& future_category() _NOEXCEPT;
 
 inline _LIBCPP_INLINE_VISIBILITY
 error_code
 make_error_code(future_errc __e) _NOEXCEPT
 {
     return error_code(static_cast<int>(__e), future_category());
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 error_condition
 make_error_condition(future_errc __e) _NOEXCEPT
 {
     return error_condition(static_cast<int>(__e), future_category());
 }
 
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_FUTURE_ERROR future_error
     : public logic_error
 {
     error_code __ec_;
 public:
     future_error(error_code __ec);
 #if _LIBCPP_STD_VERS > 14
     explicit future_error(future_errc _Ev) : logic_error(), __ec_(make_error_code(_Ev)) {}
 #endif
     _LIBCPP_INLINE_VISIBILITY
     const error_code& code() const _NOEXCEPT {return __ec_;}
 
+    future_error(const future_error&) _NOEXCEPT = default;
     virtual ~future_error() _NOEXCEPT;
 };
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_NO_EXCEPTIONS
 _LIBCPP_AVAILABILITY_FUTURE_ERROR
 #endif
 void __throw_future_error(future_errc _Ev)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw future_error(make_error_code(_Ev));
 #else
     ((void)_Ev);
     _VSTD::abort();
 #endif
 }
 
 class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state
     : public __shared_count
 {
 protected:
     exception_ptr __exception_;
     mutable mutex __mut_;
     mutable condition_variable __cv_;
     unsigned __state_;
 
     virtual void __on_zero_shared() _NOEXCEPT;
     void __sub_wait(unique_lock<mutex>& __lk);
 public:
     enum
     {
         __constructed = 1,
         __future_attached = 2,
         ready = 4,
         deferred = 8
     };
 
     _LIBCPP_INLINE_VISIBILITY
     __assoc_sub_state() : __state_(0) {}
 
     _LIBCPP_INLINE_VISIBILITY
     bool __has_value() const
         {return (__state_ & __constructed) || (__exception_ != nullptr);}
 
     _LIBCPP_INLINE_VISIBILITY
     void __attach_future() {
         lock_guard<mutex> __lk(__mut_);
         bool __has_future_attached = (__state_ & __future_attached) != 0;
         if (__has_future_attached)
             __throw_future_error(future_errc::future_already_retrieved);
         this->__add_shared();
         __state_ |= __future_attached;
     }
 
     _LIBCPP_INLINE_VISIBILITY
     void __set_deferred() {__state_ |= deferred;}
 
     void __make_ready();
     _LIBCPP_INLINE_VISIBILITY
     bool __is_ready() const {return (__state_ & ready) != 0;}
 
     void set_value();
     void set_value_at_thread_exit();
 
     void set_exception(exception_ptr __p);
     void set_exception_at_thread_exit(exception_ptr __p);
 
     void copy();
 
     void wait();
     template <class _Rep, class _Period>
         future_status
         _LIBCPP_INLINE_VISIBILITY
         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const;
     template <class _Clock, class _Duration>
         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         future_status
         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const;
 
     virtual void __execute();
 };
 
 template <class _Clock, class _Duration>
 future_status
 __assoc_sub_state::wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
 {
     unique_lock<mutex> __lk(__mut_);
     if (__state_ & deferred)
         return future_status::deferred;
     while (!(__state_ & ready) && _Clock::now() < __abs_time)
         __cv_.wait_until(__lk, __abs_time);
     if (__state_ & ready)
         return future_status::ready;
     return future_status::timeout;
 }
 
 template <class _Rep, class _Period>
 inline
 future_status
 __assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
 {
     return wait_until(chrono::steady_clock::now() + __rel_time);
 }
 
 template <class _Rp>
 class _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_HIDDEN __assoc_state
     : public __assoc_sub_state
 {
     typedef __assoc_sub_state base;
     typedef typename aligned_storage<sizeof(_Rp), alignment_of<_Rp>::value>::type _Up;
 protected:
     _Up __value_;
 
     virtual void __on_zero_shared() _NOEXCEPT;
 public:
 
     template <class _Arg>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         void set_value(_Arg&& __arg);
 #else
         void set_value(_Arg& __arg);
 #endif
 
     template <class _Arg>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         void set_value_at_thread_exit(_Arg&& __arg);
 #else
         void set_value_at_thread_exit(_Arg& __arg);
 #endif
 
     _Rp move();
     typename add_lvalue_reference<_Rp>::type copy();
 };
 
 template <class _Rp>
 void
 __assoc_state<_Rp>::__on_zero_shared() _NOEXCEPT
 {
     if (this->__state_ & base::__constructed)
         reinterpret_cast<_Rp*>(&__value_)->~_Rp();
     delete this;
 }
 
 template <class _Rp>
 template <class _Arg>
 _LIBCPP_AVAILABILITY_FUTURE
 void
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 __assoc_state<_Rp>::set_value(_Arg&& __arg)
 #else
 __assoc_state<_Rp>::set_value(_Arg& __arg)
 #endif
 {
     unique_lock<mutex> __lk(this->__mut_);
     if (this->__has_value())
         __throw_future_error(future_errc::promise_already_satisfied);
     ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg));
     this->__state_ |= base::__constructed | base::ready;
     __cv_.notify_all();
 }
 
 template <class _Rp>
 template <class _Arg>
 void
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 __assoc_state<_Rp>::set_value_at_thread_exit(_Arg&& __arg)
 #else
 __assoc_state<_Rp>::set_value_at_thread_exit(_Arg& __arg)
 #endif
 {
     unique_lock<mutex> __lk(this->__mut_);
     if (this->__has_value())
         __throw_future_error(future_errc::promise_already_satisfied);
     ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg));
     this->__state_ |= base::__constructed;
     __thread_local_data()->__make_ready_at_thread_exit(this);
 }
 
 template <class _Rp>
 _Rp
 __assoc_state<_Rp>::move()
 {
     unique_lock<mutex> __lk(this->__mut_);
     this->__sub_wait(__lk);
     if (this->__exception_ != nullptr)
         rethrow_exception(this->__exception_);
     return _VSTD::move(*reinterpret_cast<_Rp*>(&__value_));
 }
 
 template <class _Rp>
 typename add_lvalue_reference<_Rp>::type
 __assoc_state<_Rp>::copy()
 {
     unique_lock<mutex> __lk(this->__mut_);
     this->__sub_wait(__lk);
     if (this->__exception_ != nullptr)
         rethrow_exception(this->__exception_);
     return *reinterpret_cast<_Rp*>(&__value_);
 }
 
 template <class _Rp>
 class _LIBCPP_AVAILABILITY_FUTURE __assoc_state<_Rp&>
     : public __assoc_sub_state
 {
     typedef __assoc_sub_state base;
     typedef _Rp* _Up;
 protected:
     _Up __value_;
 
     virtual void __on_zero_shared() _NOEXCEPT;
 public:
 
     void set_value(_Rp& __arg);
     void set_value_at_thread_exit(_Rp& __arg);
 
     _Rp& copy();
 };
 
 template <class _Rp>
 void
 __assoc_state<_Rp&>::__on_zero_shared() _NOEXCEPT
 {
     delete this;
 }
 
 template <class _Rp>
 void
 __assoc_state<_Rp&>::set_value(_Rp& __arg)
 {
     unique_lock<mutex> __lk(this->__mut_);
     if (this->__has_value())
         __throw_future_error(future_errc::promise_already_satisfied);
     __value_ = _VSTD::addressof(__arg);
     this->__state_ |= base::__constructed | base::ready;
     __cv_.notify_all();
 }
 
 template <class _Rp>
 void
 __assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg)
 {
     unique_lock<mutex> __lk(this->__mut_);
     if (this->__has_value())
         __throw_future_error(future_errc::promise_already_satisfied);
     __value_ = _VSTD::addressof(__arg);
     this->__state_ |= base::__constructed;
     __thread_local_data()->__make_ready_at_thread_exit(this);
 }
 
 template <class _Rp>
 _Rp&
 __assoc_state<_Rp&>::copy()
 {
     unique_lock<mutex> __lk(this->__mut_);
     this->__sub_wait(__lk);
     if (this->__exception_ != nullptr)
         rethrow_exception(this->__exception_);
     return *__value_;
 }
 
 template <class _Rp, class _Alloc>
 class _LIBCPP_AVAILABILITY_FUTURE __assoc_state_alloc
     : public __assoc_state<_Rp>
 {
     typedef __assoc_state<_Rp> base;
     _Alloc __alloc_;
 
     virtual void __on_zero_shared() _NOEXCEPT;
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __assoc_state_alloc(const _Alloc& __a)
         : __alloc_(__a) {}
 };
 
 template <class _Rp, class _Alloc>
 void
 __assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT
 {
     if (this->__state_ & base::__constructed)
         reinterpret_cast<_Rp*>(_VSTD::addressof(this->__value_))->~_Rp();
     typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al;
     typedef allocator_traits<_Al> _ATraits;
     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
     _Al __a(__alloc_);
     this->~__assoc_state_alloc();
     __a.deallocate(_PTraits::pointer_to(*this), 1);
 }
 
 template <class _Rp, class _Alloc>
 class _LIBCPP_AVAILABILITY_FUTURE __assoc_state_alloc<_Rp&, _Alloc>
     : public __assoc_state<_Rp&>
 {
     typedef __assoc_state<_Rp&> base;
     _Alloc __alloc_;
 
     virtual void __on_zero_shared() _NOEXCEPT;
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __assoc_state_alloc(const _Alloc& __a)
         : __alloc_(__a) {}
 };
 
 template <class _Rp, class _Alloc>
 void
 __assoc_state_alloc<_Rp&, _Alloc>::__on_zero_shared() _NOEXCEPT
 {
     typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al;
     typedef allocator_traits<_Al> _ATraits;
     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
     _Al __a(__alloc_);
     this->~__assoc_state_alloc();
     __a.deallocate(_PTraits::pointer_to(*this), 1);
 }
 
 template <class _Alloc>
 class _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state_alloc
     : public __assoc_sub_state
 {
     typedef __assoc_sub_state base;
     _Alloc __alloc_;
 
     virtual void __on_zero_shared() _NOEXCEPT;
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __assoc_sub_state_alloc(const _Alloc& __a)
         : __alloc_(__a) {}
 };
 
 template <class _Alloc>
 void
 __assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT
 {
     typedef typename __allocator_traits_rebind<_Alloc, __assoc_sub_state_alloc>::type _Al;
     typedef allocator_traits<_Al> _ATraits;
     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
     _Al __a(__alloc_);
     this->~__assoc_sub_state_alloc();
     __a.deallocate(_PTraits::pointer_to(*this), 1);
 }
 
 template <class _Rp, class _Fp>
 class _LIBCPP_AVAILABILITY_FUTURE __deferred_assoc_state
     : public __assoc_state<_Rp>
 {
     typedef __assoc_state<_Rp> base;
 
     _Fp __func_;
 
 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     explicit __deferred_assoc_state(_Fp&& __f);
 #endif
 
     virtual void __execute();
 };
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Rp, class _Fp>
 inline
 __deferred_assoc_state<_Rp, _Fp>::__deferred_assoc_state(_Fp&& __f)
     : __func_(_VSTD::forward<_Fp>(__f))
 {
     this->__set_deferred();
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Rp, class _Fp>
 void
 __deferred_assoc_state<_Rp, _Fp>::__execute()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         this->set_value(__func_());
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         this->set_exception(current_exception());
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 template <class _Fp>
 class _LIBCPP_AVAILABILITY_FUTURE __deferred_assoc_state<void, _Fp>
     : public __assoc_sub_state
 {
     typedef __assoc_sub_state base;
 
     _Fp __func_;
 
 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     explicit __deferred_assoc_state(_Fp&& __f);
 #endif
 
     virtual void __execute();
 };
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Fp>
 inline
 __deferred_assoc_state<void, _Fp>::__deferred_assoc_state(_Fp&& __f)
     : __func_(_VSTD::forward<_Fp>(__f))
 {
     this->__set_deferred();
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Fp>
 void
 __deferred_assoc_state<void, _Fp>::__execute()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         __func_();
         this->set_value();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         this->set_exception(current_exception());
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 template <class _Rp, class _Fp>
 class _LIBCPP_AVAILABILITY_FUTURE __async_assoc_state
     : public __assoc_state<_Rp>
 {
     typedef __assoc_state<_Rp> base;
 
     _Fp __func_;
 
     virtual void __on_zero_shared() _NOEXCEPT;
 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     explicit __async_assoc_state(_Fp&& __f);
 #endif
 
     virtual void __execute();
 };
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Rp, class _Fp>
 inline
 __async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f)
     : __func_(_VSTD::forward<_Fp>(__f))
 {
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Rp, class _Fp>
 void
 __async_assoc_state<_Rp, _Fp>::__execute()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         this->set_value(__func_());
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         this->set_exception(current_exception());
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 template <class _Rp, class _Fp>
 void
 __async_assoc_state<_Rp, _Fp>::__on_zero_shared() _NOEXCEPT
 {
     this->wait();
     base::__on_zero_shared();
 }
 
 template <class _Fp>
 class _LIBCPP_AVAILABILITY_FUTURE __async_assoc_state<void, _Fp>
     : public __assoc_sub_state
 {
     typedef __assoc_sub_state base;
 
     _Fp __func_;
 
     virtual void __on_zero_shared() _NOEXCEPT;
 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     explicit __async_assoc_state(_Fp&& __f);
 #endif
 
     virtual void __execute();
 };
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Fp>
 inline
 __async_assoc_state<void, _Fp>::__async_assoc_state(_Fp&& __f)
     : __func_(_VSTD::forward<_Fp>(__f))
 {
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Fp>
 void
 __async_assoc_state<void, _Fp>::__execute()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         __func_();
         this->set_value();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         this->set_exception(current_exception());
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 template <class _Fp>
 void
 __async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT
 {
     this->wait();
     base::__on_zero_shared();
 }
 
 template <class _Rp> class _LIBCPP_TEMPLATE_VIS promise;
 template <class _Rp> class _LIBCPP_TEMPLATE_VIS shared_future;
 
 // future
 
 template <class _Rp> class _LIBCPP_TEMPLATE_VIS future;
 
 template <class _Rp, class _Fp>
 _LIBCPP_INLINE_VISIBILITY future<_Rp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 __make_deferred_assoc_state(_Fp&& __f);
 #else
 __make_deferred_assoc_state(_Fp __f);
 #endif
 
 template <class _Rp, class _Fp>
 _LIBCPP_INLINE_VISIBILITY future<_Rp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 __make_async_assoc_state(_Fp&& __f);
 #else
 __make_async_assoc_state(_Fp __f);
 #endif
 
 template <class _Rp>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE future
 {
     __assoc_state<_Rp>* __state_;
 
     explicit future(__assoc_state<_Rp>* __state);
 
     template <class> friend class promise;
     template <class> friend class shared_future;
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _R1, class _Fp>
         friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
     template <class _R1, class _Fp>
         friend future<_R1> __make_async_assoc_state(_Fp&& __f);
 #else
     template <class _R1, class _Fp>
         friend future<_R1> __make_deferred_assoc_state(_Fp __f);
     template <class _R1, class _Fp>
         friend future<_R1> __make_async_assoc_state(_Fp __f);
 #endif
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     future() _NOEXCEPT : __state_(nullptr) {}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     future(future&& __rhs) _NOEXCEPT
         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
     future(const future&) = delete;
     future& operator=(const future&) = delete;
     _LIBCPP_INLINE_VISIBILITY
     future& operator=(future&& __rhs) _NOEXCEPT
         {
             future(std::move(__rhs)).swap(*this);
             return *this;
         }
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 private:
     future(const future&);
     future& operator=(const future&);
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~future();
     _LIBCPP_INLINE_VISIBILITY
     shared_future<_Rp> share() _NOEXCEPT;
 
     // retrieving the value
     _Rp get();
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
 
     _LIBCPP_INLINE_VISIBILITY
     void wait() const {__state_->wait();}
     template <class _Rep, class _Period>
         _LIBCPP_INLINE_VISIBILITY
         future_status
         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
             {return __state_->wait_for(__rel_time);}
     template <class _Clock, class _Duration>
         _LIBCPP_INLINE_VISIBILITY
         future_status
         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
             {return __state_->wait_until(__abs_time);}
 };
 
 template <class _Rp>
 future<_Rp>::future(__assoc_state<_Rp>* __state)
     : __state_(__state)
 {
     __state_->__attach_future();
 }
 
 struct __release_shared_count
 {
     void operator()(__shared_count* p) {p->__release_shared();}
 };
 
 template <class _Rp>
 future<_Rp>::~future()
 {
     if (__state_)
         __state_->__release_shared();
 }
 
 template <class _Rp>
 _Rp
 future<_Rp>::get()
 {
     unique_ptr<__shared_count, __release_shared_count> __(__state_);
     __assoc_state<_Rp>* __s = __state_;
     __state_ = nullptr;
     return __s->move();
 }
 
 template <class _Rp>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE future<_Rp&>
 {
     __assoc_state<_Rp&>* __state_;
 
     explicit future(__assoc_state<_Rp&>* __state);
 
     template <class> friend class promise;
     template <class> friend class shared_future;
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _R1, class _Fp>
         friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
     template <class _R1, class _Fp>
         friend future<_R1> __make_async_assoc_state(_Fp&& __f);
 #else
     template <class _R1, class _Fp>
         friend future<_R1> __make_deferred_assoc_state(_Fp __f);
     template <class _R1, class _Fp>
         friend future<_R1> __make_async_assoc_state(_Fp __f);
 #endif
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     future() _NOEXCEPT : __state_(nullptr) {}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     future(future&& __rhs) _NOEXCEPT
         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
     future(const future&) = delete;
     future& operator=(const future&) = delete;
     _LIBCPP_INLINE_VISIBILITY
     future& operator=(future&& __rhs) _NOEXCEPT
         {
             future(std::move(__rhs)).swap(*this);
             return *this;
         }
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 private:
     future(const future&);
     future& operator=(const future&);
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~future();
     _LIBCPP_INLINE_VISIBILITY
     shared_future<_Rp&> share() _NOEXCEPT;
 
     // retrieving the value
     _Rp& get();
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
 
     _LIBCPP_INLINE_VISIBILITY
     void wait() const {__state_->wait();}
     template <class _Rep, class _Period>
         _LIBCPP_INLINE_VISIBILITY
         future_status
         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
             {return __state_->wait_for(__rel_time);}
     template <class _Clock, class _Duration>
         _LIBCPP_INLINE_VISIBILITY
         future_status
         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
             {return __state_->wait_until(__abs_time);}
 };
 
 template <class _Rp>
 future<_Rp&>::future(__assoc_state<_Rp&>* __state)
     : __state_(__state)
 {
     __state_->__attach_future();
 }
 
 template <class _Rp>
 future<_Rp&>::~future()
 {
     if (__state_)
         __state_->__release_shared();
 }
 
 template <class _Rp>
 _Rp&
 future<_Rp&>::get()
 {
     unique_ptr<__shared_count, __release_shared_count> __(__state_);
     __assoc_state<_Rp&>* __s = __state_;
     __state_ = nullptr;
     return __s->copy();
 }
 
 template <>
 class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE future<void>
 {
     __assoc_sub_state* __state_;
 
     explicit future(__assoc_sub_state* __state);
 
     template <class> friend class promise;
     template <class> friend class shared_future;
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _R1, class _Fp>
         friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
     template <class _R1, class _Fp>
         friend future<_R1> __make_async_assoc_state(_Fp&& __f);
 #else
     template <class _R1, class _Fp>
         friend future<_R1> __make_deferred_assoc_state(_Fp __f);
     template <class _R1, class _Fp>
         friend future<_R1> __make_async_assoc_state(_Fp __f);
 #endif
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     future() _NOEXCEPT : __state_(nullptr) {}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     future(future&& __rhs) _NOEXCEPT
         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
     future(const future&) = delete;
     future& operator=(const future&) = delete;
     _LIBCPP_INLINE_VISIBILITY
     future& operator=(future&& __rhs) _NOEXCEPT
         {
             future(std::move(__rhs)).swap(*this);
             return *this;
         }
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 private:
     future(const future&);
     future& operator=(const future&);
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~future();
     _LIBCPP_INLINE_VISIBILITY
     shared_future<void> share() _NOEXCEPT;
 
     // retrieving the value
     void get();
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
 
     _LIBCPP_INLINE_VISIBILITY
     void wait() const {__state_->wait();}
     template <class _Rep, class _Period>
         _LIBCPP_INLINE_VISIBILITY
         future_status
         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
             {return __state_->wait_for(__rel_time);}
     template <class _Clock, class _Duration>
         _LIBCPP_INLINE_VISIBILITY
         future_status
         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
             {return __state_->wait_until(__abs_time);}
 };
 
 template <class _Rp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(future<_Rp>& __x, future<_Rp>& __y) _NOEXCEPT
 {
     __x.swap(__y);
 }
 
 // promise<R>
 
 template <class _Callable> class packaged_task;
 
 template <class _Rp>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE promise
 {
     __assoc_state<_Rp>* __state_;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
 
     template <class> friend class packaged_task;
 public:
     promise();
     template <class _Alloc>
         promise(allocator_arg_t, const _Alloc& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     promise(promise&& __rhs) _NOEXCEPT
         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
     promise(const promise& __rhs) = delete;
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 private:
     promise(const promise& __rhs);
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~promise();
 
     // assignment
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     promise& operator=(promise&& __rhs) _NOEXCEPT
         {
             promise(std::move(__rhs)).swap(*this);
             return *this;
         }
     promise& operator=(const promise& __rhs) = delete;
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 private:
     promise& operator=(const promise& __rhs);
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // retrieving the result
     future<_Rp> get_future();
 
     // setting the result
     void set_value(const _Rp& __r);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     void set_value(_Rp&& __r);
 #endif
     void set_exception(exception_ptr __p);
 
     // setting the result with deferred notification
     void set_value_at_thread_exit(const _Rp& __r);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     void set_value_at_thread_exit(_Rp&& __r);
 #endif
     void set_exception_at_thread_exit(exception_ptr __p);
 };
 
 template <class _Rp>
 promise<_Rp>::promise()
     : __state_(new __assoc_state<_Rp>)
 {
 }
 
 template <class _Rp>
 template <class _Alloc>
 promise<_Rp>::promise(allocator_arg_t, const _Alloc& __a0)
 {
     typedef __assoc_state_alloc<_Rp, _Alloc> _State;
     typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
     typedef __allocator_destructor<_A2> _D2;
     _A2 __a(__a0);
     unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
     ::new(static_cast<void*>(_VSTD::addressof(*__hold.get()))) _State(__a0);
     __state_ = _VSTD::addressof(*__hold.release());
 }
 
 template <class _Rp>
 promise<_Rp>::~promise()
 {
     if (__state_)
     {
         if (!__state_->__has_value() && __state_->use_count() > 1)
             __state_->set_exception(make_exception_ptr(
                       future_error(make_error_code(future_errc::broken_promise))
                                                       ));
         __state_->__release_shared();
     }
 }
 
 template <class _Rp>
 future<_Rp>
 promise<_Rp>::get_future()
 {
     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     return future<_Rp>(__state_);
 }
 
 template <class _Rp>
 void
 promise<_Rp>::set_value(const _Rp& __r)
 {
     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     __state_->set_value(__r);
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Rp>
 void
 promise<_Rp>::set_value(_Rp&& __r)
 {
     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     __state_->set_value(_VSTD::move(__r));
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Rp>
 void
 promise<_Rp>::set_exception(exception_ptr __p)
 {
     _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception: received nullptr" );
     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     __state_->set_exception(__p);
 }
 
 template <class _Rp>
 void
 promise<_Rp>::set_value_at_thread_exit(const _Rp& __r)
 {
     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     __state_->set_value_at_thread_exit(__r);
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Rp>
 void
 promise<_Rp>::set_value_at_thread_exit(_Rp&& __r)
 {
     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     __state_->set_value_at_thread_exit(_VSTD::move(__r));
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template <class _Rp>
 void
 promise<_Rp>::set_exception_at_thread_exit(exception_ptr __p)
 {
     _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception_at_thread_exit: received nullptr" );
     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     __state_->set_exception_at_thread_exit(__p);
 }
 
 // promise<R&>
 
 template <class _Rp>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE promise<_Rp&>
 {
     __assoc_state<_Rp&>* __state_;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
 
     template <class> friend class packaged_task;
 
 public:
     promise();
     template <class _Allocator>
         promise(allocator_arg_t, const _Allocator& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     promise(promise&& __rhs) _NOEXCEPT
         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
     promise(const promise& __rhs) = delete;
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 private:
     promise(const promise& __rhs);
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~promise();
 
     // assignment
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     promise& operator=(promise&& __rhs) _NOEXCEPT
         {
             promise(std::move(__rhs)).swap(*this);
             return *this;
         }
     promise& operator=(const promise& __rhs) = delete;
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 private:
     promise& operator=(const promise& __rhs);
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // retrieving the result
     future<_Rp&> get_future();
 
     // setting the result
     void set_value(_Rp& __r);
     void set_exception(exception_ptr __p);
 
     // setting the result with deferred notification
     void set_value_at_thread_exit(_Rp&);
     void set_exception_at_thread_exit(exception_ptr __p);
 };
 
 template <class _Rp>
 promise<_Rp&>::promise()
     : __state_(new __assoc_state<_Rp&>)
 {
 }
 
 template <class _Rp>
 template <class _Alloc>
 promise<_Rp&>::promise(allocator_arg_t, const _Alloc& __a0)
 {
     typedef __assoc_state_alloc<_Rp&, _Alloc> _State;
     typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
     typedef __allocator_destructor<_A2> _D2;
     _A2 __a(__a0);
     unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
     ::new(static_cast<void*>(_VSTD::addressof(*__hold.get()))) _State(__a0);
     __state_ = _VSTD::addressof(*__hold.release());
 }
 
 template <class _Rp>
 promise<_Rp&>::~promise()
 {
     if (__state_)
     {
         if (!__state_->__has_value() && __state_->use_count() > 1)
             __state_->set_exception(make_exception_ptr(
                       future_error(make_error_code(future_errc::broken_promise))
                                                       ));
         __state_->__release_shared();
     }
 }
 
 template <class _Rp>
 future<_Rp&>
 promise<_Rp&>::get_future()
 {
     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     return future<_Rp&>(__state_);
 }
 
 template <class _Rp>
 void
 promise<_Rp&>::set_value(_Rp& __r)
 {
     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     __state_->set_value(__r);
 }
 
 template <class _Rp>
 void
 promise<_Rp&>::set_exception(exception_ptr __p)
 {
     _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception: received nullptr" );
     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     __state_->set_exception(__p);
 }
 
 template <class _Rp>
 void
 promise<_Rp&>::set_value_at_thread_exit(_Rp& __r)
 {
     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     __state_->set_value_at_thread_exit(__r);
 }
 
 template <class _Rp>
 void
 promise<_Rp&>::set_exception_at_thread_exit(exception_ptr __p)
 {
     _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception_at_thread_exit: received nullptr" );
     if (__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     __state_->set_exception_at_thread_exit(__p);
 }
 
 // promise<void>
 
 template <>
 class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE promise<void>
 {
     __assoc_sub_state* __state_;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
 
     template <class> friend class packaged_task;
 
 public:
     promise();
     template <class _Allocator>
         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
         promise(allocator_arg_t, const _Allocator& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     promise(promise&& __rhs) _NOEXCEPT
         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
     promise(const promise& __rhs) = delete;
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 private:
     promise(const promise& __rhs);
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~promise();
 
     // assignment
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     promise& operator=(promise&& __rhs) _NOEXCEPT
         {
             promise(std::move(__rhs)).swap(*this);
             return *this;
         }
     promise& operator=(const promise& __rhs) = delete;
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 private:
     promise& operator=(const promise& __rhs);
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // retrieving the result
     future<void> get_future();
 
     // setting the result
     void set_value();
     void set_exception(exception_ptr __p);
 
     // setting the result with deferred notification
     void set_value_at_thread_exit();
     void set_exception_at_thread_exit(exception_ptr __p);
 };
 
 template <class _Alloc>
 promise<void>::promise(allocator_arg_t, const _Alloc& __a0)
 {
     typedef __assoc_sub_state_alloc<_Alloc> _State;
     typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
     typedef __allocator_destructor<_A2> _D2;
     _A2 __a(__a0);
     unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
     ::new(static_cast<void*>(_VSTD::addressof(*__hold.get()))) _State(__a0);
     __state_ = _VSTD::addressof(*__hold.release());
 }
 
 template <class _Rp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(promise<_Rp>& __x, promise<_Rp>& __y) _NOEXCEPT
 {
     __x.swap(__y);
 }
 
 template <class _Rp, class _Alloc>
     struct _LIBCPP_TEMPLATE_VIS uses_allocator<promise<_Rp>, _Alloc>
         : public true_type {};
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 // packaged_task
 
 template<class _Fp> class __packaged_task_base;
 
 template<class _Rp, class ..._ArgTypes>
 class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_base<_Rp(_ArgTypes...)>
 {
     __packaged_task_base(const __packaged_task_base&);
     __packaged_task_base& operator=(const __packaged_task_base&);
 public:
     _LIBCPP_INLINE_VISIBILITY
     __packaged_task_base() {}
     _LIBCPP_INLINE_VISIBILITY
     virtual ~__packaged_task_base() {}
     virtual void __move_to(__packaged_task_base*) _NOEXCEPT = 0;
     virtual void destroy() = 0;
     virtual void destroy_deallocate() = 0;
     virtual _Rp operator()(_ArgTypes&& ...) = 0;
 };
 
 template<class _FD, class _Alloc, class _FB> class __packaged_task_func;
 
 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>
     : public  __packaged_task_base<_Rp(_ArgTypes...)>
 {
     __compressed_pair<_Fp, _Alloc> __f_;
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __packaged_task_func(const _Fp& __f) : __f_(__f, __default_init_tag()) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit __packaged_task_func(_Fp&& __f) : __f_(_VSTD::move(__f), __default_init_tag()) {}
     _LIBCPP_INLINE_VISIBILITY
     __packaged_task_func(const _Fp& __f, const _Alloc& __a)
         : __f_(__f, __a) {}
     _LIBCPP_INLINE_VISIBILITY
     __packaged_task_func(_Fp&& __f, const _Alloc& __a)
         : __f_(_VSTD::move(__f), __a) {}
     virtual void __move_to(__packaged_task_base<_Rp(_ArgTypes...)>*) _NOEXCEPT;
     virtual void destroy();
     virtual void destroy_deallocate();
     virtual _Rp operator()(_ArgTypes&& ... __args);
 };
 
 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 void
 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__move_to(
                               __packaged_task_base<_Rp(_ArgTypes...)>* __p) _NOEXCEPT
 {
     ::new (__p) __packaged_task_func(_VSTD::move(__f_.first()), _VSTD::move(__f_.second()));
 }
 
 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 void
 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy()
 {
     __f_.~__compressed_pair<_Fp, _Alloc>();
 }
 
 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 void
 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate()
 {
     typedef typename __allocator_traits_rebind<_Alloc, __packaged_task_func>::type _Ap;
     typedef allocator_traits<_Ap> _ATraits;
     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
     _Ap __a(__f_.second());
     __f_.~__compressed_pair<_Fp, _Alloc>();
     __a.deallocate(_PTraits::pointer_to(*this), 1);
 }
 
 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
 _Rp
 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
 {
     return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
 }
 
 template <class _Callable> class __packaged_task_function;
 
 template<class _Rp, class ..._ArgTypes>
 class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_function<_Rp(_ArgTypes...)>
 {
     typedef __packaged_task_base<_Rp(_ArgTypes...)> __base;
     typename aligned_storage<3*sizeof(void*)>::type __buf_;
     __base* __f_;
 
 public:
     typedef _Rp result_type;
 
     // construct/copy/destroy:
     _LIBCPP_INLINE_VISIBILITY
     __packaged_task_function() _NOEXCEPT : __f_(nullptr) {}
     template<class _Fp>
       __packaged_task_function(_Fp&& __f);
     template<class _Fp, class _Alloc>
       __packaged_task_function(allocator_arg_t, const _Alloc& __a, _Fp&& __f);
 
     __packaged_task_function(__packaged_task_function&&) _NOEXCEPT;
     __packaged_task_function& operator=(__packaged_task_function&&) _NOEXCEPT;
 
     __packaged_task_function(const __packaged_task_function&) =  delete;
     __packaged_task_function& operator=(const __packaged_task_function&) =  delete;
 
     ~__packaged_task_function();
 
     void swap(__packaged_task_function&) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     _Rp operator()(_ArgTypes...) const;
 };
 
 template<class _Rp, class ..._ArgTypes>
 __packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f) _NOEXCEPT
 {
     if (__f.__f_ == nullptr)
         __f_ = nullptr;
     else if (__f.__f_ == (__base*)&__f.__buf_)
     {
         __f_ = (__base*)&__buf_;
         __f.__f_->__move_to(__f_);
     }
     else
     {
         __f_ = __f.__f_;
         __f.__f_ = nullptr;
     }
 }
 
 template<class _Rp, class ..._ArgTypes>
 template <class _Fp>
 __packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(_Fp&& __f)
     : __f_(nullptr)
 {
     typedef typename remove_reference<typename decay<_Fp>::type>::type _FR;
     typedef __packaged_task_func<_FR, allocator<_FR>, _Rp(_ArgTypes...)> _FF;
     if (sizeof(_FF) <= sizeof(__buf_))
     {
         __f_ = (__base*)&__buf_;
         ::new (__f_) _FF(_VSTD::forward<_Fp>(__f));
     }
     else
     {
         typedef allocator<_FF> _Ap;
         _Ap __a;
         typedef __allocator_destructor<_Ap> _Dp;
         unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
         ::new (__hold.get()) _FF(_VSTD::forward<_Fp>(__f), allocator<_FR>(__a));
         __f_ = __hold.release();
     }
 }
 
 template<class _Rp, class ..._ArgTypes>
 template <class _Fp, class _Alloc>
 __packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(
                                   allocator_arg_t, const _Alloc& __a0, _Fp&& __f)
     : __f_(nullptr)
 {
     typedef typename remove_reference<typename decay<_Fp>::type>::type _FR;
     typedef __packaged_task_func<_FR, _Alloc, _Rp(_ArgTypes...)> _FF;
     if (sizeof(_FF) <= sizeof(__buf_))
     {
         __f_ = (__base*)&__buf_;
         ::new (__f_) _FF(_VSTD::forward<_Fp>(__f));
     }
     else
     {
         typedef typename __allocator_traits_rebind<_Alloc, _FF>::type _Ap;
         _Ap __a(__a0);
         typedef __allocator_destructor<_Ap> _Dp;
         unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
         ::new (static_cast<void*>(_VSTD::addressof(*__hold.get())))
             _FF(_VSTD::forward<_Fp>(__f), _Alloc(__a));
         __f_ = _VSTD::addressof(*__hold.release());
     }
 }
 
 template<class _Rp, class ..._ArgTypes>
 __packaged_task_function<_Rp(_ArgTypes...)>&
 __packaged_task_function<_Rp(_ArgTypes...)>::operator=(__packaged_task_function&& __f) _NOEXCEPT
 {
     if (__f_ == (__base*)&__buf_)
         __f_->destroy();
     else if (__f_)
         __f_->destroy_deallocate();
     __f_ = nullptr;
     if (__f.__f_ == nullptr)
         __f_ = nullptr;
     else if (__f.__f_ == (__base*)&__f.__buf_)
     {
         __f_ = (__base*)&__buf_;
         __f.__f_->__move_to(__f_);
     }
     else
     {
         __f_ = __f.__f_;
         __f.__f_ = nullptr;
     }
     return *this;
 }
 
 template<class _Rp, class ..._ArgTypes>
 __packaged_task_function<_Rp(_ArgTypes...)>::~__packaged_task_function()
 {
     if (__f_ == (__base*)&__buf_)
         __f_->destroy();
     else if (__f_)
         __f_->destroy_deallocate();
 }
 
 template<class _Rp, class ..._ArgTypes>
 void
 __packaged_task_function<_Rp(_ArgTypes...)>::swap(__packaged_task_function& __f) _NOEXCEPT
 {
     if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_)
     {
         typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
         __base* __t = (__base*)&__tempbuf;
         __f_->__move_to(__t);
         __f_->destroy();
         __f_ = nullptr;
         __f.__f_->__move_to((__base*)&__buf_);
         __f.__f_->destroy();
         __f.__f_ = nullptr;
         __f_ = (__base*)&__buf_;
         __t->__move_to((__base*)&__f.__buf_);
         __t->destroy();
         __f.__f_ = (__base*)&__f.__buf_;
     }
     else if (__f_ == (__base*)&__buf_)
     {
         __f_->__move_to((__base*)&__f.__buf_);
         __f_->destroy();
         __f_ = __f.__f_;
         __f.__f_ = (__base*)&__f.__buf_;
     }
     else if (__f.__f_ == (__base*)&__f.__buf_)
     {
         __f.__f_->__move_to((__base*)&__buf_);
         __f.__f_->destroy();
         __f.__f_ = __f_;
         __f_ = (__base*)&__buf_;
     }
     else
         _VSTD::swap(__f_, __f.__f_);
 }
 
 template<class _Rp, class ..._ArgTypes>
 inline
 _Rp
 __packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
 {
     return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
 }
 
 template<class _Rp, class ..._ArgTypes>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE packaged_task<_Rp(_ArgTypes...)>
 {
 public:
     typedef _Rp result_type; // extension
 
 private:
     __packaged_task_function<result_type(_ArgTypes...)> __f_;
     promise<result_type>                                __p_;
 
 public:
     // construction and destruction
     _LIBCPP_INLINE_VISIBILITY
     packaged_task() _NOEXCEPT : __p_(nullptr) {}
     template <class _Fp,
               class = typename enable_if
               <
                   !is_same<
                       typename __uncvref<_Fp>::type,
                       packaged_task
                       >::value
                   >::type
              >
         _LIBCPP_INLINE_VISIBILITY
         explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
     template <class _Fp, class _Allocator,
               class = typename enable_if
               <
                   !is_same<
                       typename __uncvref<_Fp>::type,
                       packaged_task
                       >::value
                   >::type
               >
         _LIBCPP_INLINE_VISIBILITY
         packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
              : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)),
                __p_(allocator_arg, __a) {}
     // ~packaged_task() = default;
 
     // no copy
     packaged_task(const packaged_task&) = delete;
     packaged_task& operator=(const packaged_task&) = delete;
 
     // move support
     _LIBCPP_INLINE_VISIBILITY
     packaged_task(packaged_task&& __other) _NOEXCEPT
         : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
     _LIBCPP_INLINE_VISIBILITY
     packaged_task& operator=(packaged_task&& __other) _NOEXCEPT
     {
         __f_ = _VSTD::move(__other.__f_);
         __p_ = _VSTD::move(__other.__p_);
         return *this;
     }
     _LIBCPP_INLINE_VISIBILITY
     void swap(packaged_task& __other) _NOEXCEPT
     {
         __f_.swap(__other.__f_);
         __p_.swap(__other.__p_);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     bool valid() const _NOEXCEPT {return __p_.__state_ != nullptr;}
 
     // result retrieval
     _LIBCPP_INLINE_VISIBILITY
     future<result_type> get_future() {return __p_.get_future();}
 
     // execution
     void operator()(_ArgTypes... __args);
     void make_ready_at_thread_exit(_ArgTypes... __args);
 
     void reset();
 };
 
 template<class _Rp, class ..._ArgTypes>
 void
 packaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args)
 {
     if (__p_.__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     if (__p_.__state_->__has_value())
         __throw_future_error(future_errc::promise_already_satisfied);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         __p_.set_value(__f_(_VSTD::forward<_ArgTypes>(__args)...));
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __p_.set_exception(current_exception());
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 template<class _Rp, class ..._ArgTypes>
 void
 packaged_task<_Rp(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
 {
     if (__p_.__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     if (__p_.__state_->__has_value())
         __throw_future_error(future_errc::promise_already_satisfied);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         __p_.set_value_at_thread_exit(__f_(_VSTD::forward<_ArgTypes>(__args)...));
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __p_.set_exception_at_thread_exit(current_exception());
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 template<class _Rp, class ..._ArgTypes>
 void
 packaged_task<_Rp(_ArgTypes...)>::reset()
 {
     if (!valid())
         __throw_future_error(future_errc::no_state);
     __p_ = promise<result_type>();
 }
 
 template<class ..._ArgTypes>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE packaged_task<void(_ArgTypes...)>
 {
 public:
     typedef void result_type; // extension
 
 private:
     __packaged_task_function<result_type(_ArgTypes...)> __f_;
     promise<result_type>                                __p_;
 
 public:
     // construction and destruction
     _LIBCPP_INLINE_VISIBILITY
     packaged_task() _NOEXCEPT : __p_(nullptr) {}
     template <class _Fp,
               class = typename enable_if
               <
                   !is_same<
                       typename __uncvref<_Fp>::type,
                       packaged_task
                       >::value
                   >::type
               >
         _LIBCPP_INLINE_VISIBILITY
         explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
     template <class _Fp, class _Allocator,
               class = typename enable_if
               <
                   !is_same<
                       typename __uncvref<_Fp>::type,
                       packaged_task
                       >::value
                   >::type
               >
         _LIBCPP_INLINE_VISIBILITY
         packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
              : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)),
                __p_(allocator_arg, __a) {}
     // ~packaged_task() = default;
 
     // no copy
     packaged_task(const packaged_task&) = delete;
     packaged_task& operator=(const packaged_task&) = delete;
 
     // move support
     _LIBCPP_INLINE_VISIBILITY
     packaged_task(packaged_task&& __other) _NOEXCEPT
         : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
     _LIBCPP_INLINE_VISIBILITY
     packaged_task& operator=(packaged_task&& __other) _NOEXCEPT
     {
         __f_ = _VSTD::move(__other.__f_);
         __p_ = _VSTD::move(__other.__p_);
         return *this;
     }
     _LIBCPP_INLINE_VISIBILITY
     void swap(packaged_task& __other) _NOEXCEPT
     {
         __f_.swap(__other.__f_);
         __p_.swap(__other.__p_);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     bool valid() const _NOEXCEPT {return __p_.__state_ != nullptr;}
 
     // result retrieval
     _LIBCPP_INLINE_VISIBILITY
     future<result_type> get_future() {return __p_.get_future();}
 
     // execution
     void operator()(_ArgTypes... __args);
     void make_ready_at_thread_exit(_ArgTypes... __args);
 
     void reset();
 };
 
 template<class ..._ArgTypes>
 void
 packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args)
 {
     if (__p_.__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     if (__p_.__state_->__has_value())
         __throw_future_error(future_errc::promise_already_satisfied);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         __f_(_VSTD::forward<_ArgTypes>(__args)...);
         __p_.set_value();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __p_.set_exception(current_exception());
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 template<class ..._ArgTypes>
 void
 packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
 {
     if (__p_.__state_ == nullptr)
         __throw_future_error(future_errc::no_state);
     if (__p_.__state_->__has_value())
         __throw_future_error(future_errc::promise_already_satisfied);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         __f_(_VSTD::forward<_ArgTypes>(__args)...);
         __p_.set_value_at_thread_exit();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __p_.set_exception_at_thread_exit(current_exception());
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 template<class ..._ArgTypes>
 void
 packaged_task<void(_ArgTypes...)>::reset()
 {
     if (!valid())
         __throw_future_error(future_errc::no_state);
     __p_ = promise<result_type>();
 }
 
 template <class _Callable>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(packaged_task<_Callable>& __x, packaged_task<_Callable>& __y) _NOEXCEPT
 {
     __x.swap(__y);
 }
 
 template <class _Callable, class _Alloc>
 struct _LIBCPP_TEMPLATE_VIS uses_allocator<packaged_task<_Callable>, _Alloc>
     : public true_type {};
 
 template <class _Rp, class _Fp>
 _LIBCPP_INLINE_VISIBILITY future<_Rp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 __make_deferred_assoc_state(_Fp&& __f)
 #else
 __make_deferred_assoc_state(_Fp __f)
 #endif
 {
     unique_ptr<__deferred_assoc_state<_Rp, _Fp>, __release_shared_count>
         __h(new __deferred_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f)));
     return future<_Rp>(__h.get());
 }
 
 template <class _Rp, class _Fp>
 _LIBCPP_INLINE_VISIBILITY future<_Rp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 __make_async_assoc_state(_Fp&& __f)
 #else
 __make_async_assoc_state(_Fp __f)
 #endif
 {
     unique_ptr<__async_assoc_state<_Rp, _Fp>, __release_shared_count>
         __h(new __async_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f)));
     _VSTD::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach();
     return future<_Rp>(__h.get());
 }
 
 template <class _Fp, class... _Args>
 class _LIBCPP_HIDDEN __async_func
 {
     tuple<_Fp, _Args...> __f_;
 
 public:
     typedef typename __invoke_of<_Fp, _Args...>::type _Rp;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __async_func(_Fp&& __f, _Args&&... __args)
         : __f_(_VSTD::move(__f), _VSTD::move(__args)...) {}
 
     _LIBCPP_INLINE_VISIBILITY
     __async_func(__async_func&& __f) : __f_(_VSTD::move(__f.__f_)) {}
 
     _Rp operator()()
     {
         typedef typename __make_tuple_indices<1+sizeof...(_Args), 1>::type _Index;
         return __execute(_Index());
     }
 private:
     template <size_t ..._Indices>
     _Rp
     __execute(__tuple_indices<_Indices...>)
     {
         return __invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...);
     }
 };
 
 inline _LIBCPP_INLINE_VISIBILITY bool __does_policy_contain(launch __policy, launch __value )
 { return (int(__policy) & int(__value)) != 0; }
 
 template <class _Fp, class... _Args>
 _LIBCPP_NODISCARD_AFTER_CXX17
 future<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type>
 async(launch __policy, _Fp&& __f, _Args&&... __args)
 {
     typedef __async_func<typename decay<_Fp>::type, typename decay<_Args>::type...> _BF;
     typedef typename _BF::_Rp _Rp;
 
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif
         if (__does_policy_contain(__policy, launch::async))
         return _VSTD::__make_async_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)),
                                                      __decay_copy(_VSTD::forward<_Args>(__args))...));
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch ( ... ) { if (__policy == launch::async) throw ; }
 #endif
 
     if (__does_policy_contain(__policy, launch::deferred))
         return _VSTD::__make_deferred_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)),
                                                         __decay_copy(_VSTD::forward<_Args>(__args))...));
     return future<_Rp>{};
 }
 
 template <class _Fp, class... _Args>
 _LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY
 future<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type>
 async(_Fp&& __f, _Args&&... __args)
 {
     return _VSTD::async(launch::any, _VSTD::forward<_Fp>(__f),
                                     _VSTD::forward<_Args>(__args)...);
 }
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 // shared_future
 
 template <class _Rp>
 class _LIBCPP_TEMPLATE_VIS shared_future
 {
     __assoc_state<_Rp>* __state_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     shared_future() _NOEXCEPT : __state_(nullptr) {}
     _LIBCPP_INLINE_VISIBILITY
     shared_future(const shared_future& __rhs)  _NOEXCEPT : __state_(__rhs.__state_)
         {if (__state_) __state_->__add_shared();}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     shared_future(future<_Rp>&& __f) _NOEXCEPT : __state_(__f.__state_)
         {__f.__state_ = nullptr;}
     _LIBCPP_INLINE_VISIBILITY
     shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
         {__rhs.__state_ = nullptr;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~shared_future();
     shared_future& operator=(const shared_future& __rhs) _NOEXCEPT;
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
         {
             shared_future(std::move(__rhs)).swap(*this);
             return *this;
         }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     // retrieving the value
     _LIBCPP_INLINE_VISIBILITY
     const _Rp& get() const {return __state_->copy();}
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
 
     _LIBCPP_INLINE_VISIBILITY
     void wait() const {__state_->wait();}
     template <class _Rep, class _Period>
         _LIBCPP_INLINE_VISIBILITY
         future_status
         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
             {return __state_->wait_for(__rel_time);}
     template <class _Clock, class _Duration>
         _LIBCPP_INLINE_VISIBILITY
         future_status
         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
             {return __state_->wait_until(__abs_time);}
 };
 
 template <class _Rp>
 shared_future<_Rp>::~shared_future()
 {
     if (__state_)
         __state_->__release_shared();
 }
 
 template <class _Rp>
 shared_future<_Rp>&
 shared_future<_Rp>::operator=(const shared_future& __rhs) _NOEXCEPT
 {
     if (__rhs.__state_)
         __rhs.__state_->__add_shared();
     if (__state_)
         __state_->__release_shared();
     __state_ = __rhs.__state_;
     return *this;
 }
 
 template <class _Rp>
 class _LIBCPP_TEMPLATE_VIS shared_future<_Rp&>
 {
     __assoc_state<_Rp&>* __state_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     shared_future() _NOEXCEPT : __state_(nullptr) {}
     _LIBCPP_INLINE_VISIBILITY
     shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
         {if (__state_) __state_->__add_shared();}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     shared_future(future<_Rp&>&& __f) _NOEXCEPT : __state_(__f.__state_)
         {__f.__state_ = nullptr;}
     _LIBCPP_INLINE_VISIBILITY
     shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
         {__rhs.__state_ = nullptr;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~shared_future();
     shared_future& operator=(const shared_future& __rhs);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
         {
             shared_future(std::move(__rhs)).swap(*this);
             return *this;
         }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     // retrieving the value
     _LIBCPP_INLINE_VISIBILITY
     _Rp& get() const {return __state_->copy();}
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
 
     _LIBCPP_INLINE_VISIBILITY
     void wait() const {__state_->wait();}
     template <class _Rep, class _Period>
         _LIBCPP_INLINE_VISIBILITY
         future_status
         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
             {return __state_->wait_for(__rel_time);}
     template <class _Clock, class _Duration>
         _LIBCPP_INLINE_VISIBILITY
         future_status
         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
             {return __state_->wait_until(__abs_time);}
 };
 
 template <class _Rp>
 shared_future<_Rp&>::~shared_future()
 {
     if (__state_)
         __state_->__release_shared();
 }
 
 template <class _Rp>
 shared_future<_Rp&>&
 shared_future<_Rp&>::operator=(const shared_future& __rhs)
 {
     if (__rhs.__state_)
         __rhs.__state_->__add_shared();
     if (__state_)
         __state_->__release_shared();
     __state_ = __rhs.__state_;
     return *this;
 }
 
 template <>
 class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE shared_future<void>
 {
     __assoc_sub_state* __state_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     shared_future() _NOEXCEPT : __state_(nullptr) {}
     _LIBCPP_INLINE_VISIBILITY
     shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
         {if (__state_) __state_->__add_shared();}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     shared_future(future<void>&& __f) _NOEXCEPT : __state_(__f.__state_)
         {__f.__state_ = nullptr;}
     _LIBCPP_INLINE_VISIBILITY
     shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
         {__rhs.__state_ = nullptr;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~shared_future();
     shared_future& operator=(const shared_future& __rhs);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
         {
             shared_future(std::move(__rhs)).swap(*this);
             return *this;
         }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     // retrieving the value
     _LIBCPP_INLINE_VISIBILITY
     void get() const {__state_->copy();}
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
 
     _LIBCPP_INLINE_VISIBILITY
     void wait() const {__state_->wait();}
     template <class _Rep, class _Period>
         _LIBCPP_INLINE_VISIBILITY
         future_status
         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
             {return __state_->wait_for(__rel_time);}
     template <class _Clock, class _Duration>
         _LIBCPP_INLINE_VISIBILITY
         future_status
         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
             {return __state_->wait_until(__abs_time);}
 };
 
 template <class _Rp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(shared_future<_Rp>& __x, shared_future<_Rp>& __y) _NOEXCEPT
 {
     __x.swap(__y);
 }
 
 template <class _Rp>
 inline
 shared_future<_Rp>
 future<_Rp>::share() _NOEXCEPT
 {
     return shared_future<_Rp>(_VSTD::move(*this));
 }
 
 template <class _Rp>
 inline
 shared_future<_Rp&>
 future<_Rp&>::share() _NOEXCEPT
 {
     return shared_future<_Rp&>(_VSTD::move(*this));
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 inline
 shared_future<void>
 future<void>::share() _NOEXCEPT
 {
     return shared_future<void>(_VSTD::move(*this));
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // !_LIBCPP_HAS_NO_THREADS
 
 #endif  // _LIBCPP_FUTURE
Index: head/contrib/llvm-project/libcxx/include/ios
===================================================================
--- head/contrib/llvm-project/libcxx/include/ios	(revision 359086)
+++ head/contrib/llvm-project/libcxx/include/ios	(revision 359087)
@@ -1,1066 +1,1067 @@
 // -*- C++ -*-
 //===---------------------------- ios -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_IOS
 #define _LIBCPP_IOS
 
 /*
     ios synopsis
 
 #include <iosfwd>
 
 namespace std
 {
 
 typedef OFF_T streamoff;
 typedef SZ_T streamsize;
 template <class stateT> class fpos;
 
 class ios_base
 {
 public:
     class failure;
 
     typedef T1 fmtflags;
     static constexpr fmtflags boolalpha;
     static constexpr fmtflags dec;
     static constexpr fmtflags fixed;
     static constexpr fmtflags hex;
     static constexpr fmtflags internal;
     static constexpr fmtflags left;
     static constexpr fmtflags oct;
     static constexpr fmtflags right;
     static constexpr fmtflags scientific;
     static constexpr fmtflags showbase;
     static constexpr fmtflags showpoint;
     static constexpr fmtflags showpos;
     static constexpr fmtflags skipws;
     static constexpr fmtflags unitbuf;
     static constexpr fmtflags uppercase;
     static constexpr fmtflags adjustfield;
     static constexpr fmtflags basefield;
     static constexpr fmtflags floatfield;
 
     typedef T2 iostate;
     static constexpr iostate badbit;
     static constexpr iostate eofbit;
     static constexpr iostate failbit;
     static constexpr iostate goodbit;
 
     typedef T3 openmode;
     static constexpr openmode app;
     static constexpr openmode ate;
     static constexpr openmode binary;
     static constexpr openmode in;
     static constexpr openmode out;
     static constexpr openmode trunc;
 
     typedef T4 seekdir;
     static constexpr seekdir beg;
     static constexpr seekdir cur;
     static constexpr seekdir end;
 
     class Init;
 
     // 27.5.2.2 fmtflags state:
     fmtflags flags() const;
     fmtflags flags(fmtflags fmtfl);
     fmtflags setf(fmtflags fmtfl);
     fmtflags setf(fmtflags fmtfl, fmtflags mask);
     void unsetf(fmtflags mask);
 
     streamsize precision() const;
     streamsize precision(streamsize prec);
     streamsize width() const;
     streamsize width(streamsize wide);
 
     // 27.5.2.3 locales:
     locale imbue(const locale& loc);
     locale getloc() const;
 
     // 27.5.2.5 storage:
     static int xalloc();
     long& iword(int index);
     void*& pword(int index);
 
     // destructor
     virtual ~ios_base();
 
     // 27.5.2.6 callbacks;
     enum event { erase_event, imbue_event, copyfmt_event };
     typedef void (*event_callback)(event, ios_base&, int index);
     void register_callback(event_callback fn, int index);
 
     ios_base(const ios_base&) = delete;
     ios_base& operator=(const ios_base&) = delete;
 
     static bool sync_with_stdio(bool sync = true);
 
 protected:
     ios_base();
 };
 
 template <class charT, class traits = char_traits<charT> >
 class basic_ios
     : public ios_base
 {
 public:
     // types:
     typedef charT char_type;
     typedef typename traits::int_type int_type;  // removed in C++17
     typedef typename traits::pos_type pos_type;  // removed in C++17
     typedef typename traits::off_type off_type;  // removed in C++17
     typedef traits traits_type;
 
     operator unspecified-bool-type() const;
     bool operator!() const;
     iostate rdstate() const;
     void clear(iostate state = goodbit);
     void setstate(iostate state);
     bool good() const;
     bool eof() const;
     bool fail() const;
     bool bad() const;
 
     iostate exceptions() const;
     void exceptions(iostate except);
 
     // 27.5.4.1 Constructor/destructor:
     explicit basic_ios(basic_streambuf<charT,traits>* sb);
     virtual ~basic_ios();
 
     // 27.5.4.2 Members:
     basic_ostream<charT,traits>* tie() const;
     basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr);
 
     basic_streambuf<charT,traits>* rdbuf() const;
     basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb);
 
     basic_ios& copyfmt(const basic_ios& rhs);
 
     char_type fill() const;
     char_type fill(char_type ch);
 
     locale imbue(const locale& loc);
 
     char narrow(char_type c, char dfault) const;
     char_type widen(char c) const;
 
     basic_ios(const basic_ios& ) = delete;
     basic_ios& operator=(const basic_ios&) = delete;
 
 protected:
     basic_ios();
     void init(basic_streambuf<charT,traits>* sb);
     void move(basic_ios& rhs);
     void swap(basic_ios& rhs) noexcept;
     void set_rdbuf(basic_streambuf<charT, traits>* sb);
 };
 
 // 27.5.5, manipulators:
 ios_base& boolalpha (ios_base& str);
 ios_base& noboolalpha(ios_base& str);
 ios_base& showbase (ios_base& str);
 ios_base& noshowbase (ios_base& str);
 ios_base& showpoint (ios_base& str);
 ios_base& noshowpoint(ios_base& str);
 ios_base& showpos (ios_base& str);
 ios_base& noshowpos (ios_base& str);
 ios_base& skipws (ios_base& str);
 ios_base& noskipws (ios_base& str);
 ios_base& uppercase (ios_base& str);
 ios_base& nouppercase(ios_base& str);
 ios_base& unitbuf (ios_base& str);
 ios_base& nounitbuf (ios_base& str);
 
 // 27.5.5.2 adjustfield:
 ios_base& internal (ios_base& str);
 ios_base& left (ios_base& str);
 ios_base& right (ios_base& str);
 
 // 27.5.5.3 basefield:
 ios_base& dec (ios_base& str);
 ios_base& hex (ios_base& str);
 ios_base& oct (ios_base& str);
 
 // 27.5.5.4 floatfield:
 ios_base& fixed (ios_base& str);
 ios_base& scientific (ios_base& str);
 ios_base& hexfloat (ios_base& str);
 ios_base& defaultfloat(ios_base& str);
 
 // 27.5.5.5 error reporting:
 enum class io_errc
 {
     stream = 1
 };
 
 concept_map ErrorCodeEnum<io_errc> { };
 error_code make_error_code(io_errc e) noexcept;
 error_condition make_error_condition(io_errc e) noexcept;
 storage-class-specifier const error_category& iostream_category() noexcept;
 
 }  // std
 
 */
 
 #include <__config>
 #include <iosfwd>
 #include <__locale>
 #include <system_error>
 
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #include <atomic>     // for __xindex_
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 typedef ptrdiff_t streamsize;
 
 class _LIBCPP_TYPE_VIS ios_base
 {
 public:
     class _LIBCPP_EXCEPTION_ABI failure;
 
     typedef unsigned int fmtflags;
     static const fmtflags boolalpha   = 0x0001;
     static const fmtflags dec         = 0x0002;
     static const fmtflags fixed       = 0x0004;
     static const fmtflags hex         = 0x0008;
     static const fmtflags internal    = 0x0010;
     static const fmtflags left        = 0x0020;
     static const fmtflags oct         = 0x0040;
     static const fmtflags right       = 0x0080;
     static const fmtflags scientific  = 0x0100;
     static const fmtflags showbase    = 0x0200;
     static const fmtflags showpoint   = 0x0400;
     static const fmtflags showpos     = 0x0800;
     static const fmtflags skipws      = 0x1000;
     static const fmtflags unitbuf     = 0x2000;
     static const fmtflags uppercase   = 0x4000;
     static const fmtflags adjustfield = left | right | internal;
     static const fmtflags basefield   = dec | oct | hex;
     static const fmtflags floatfield  = scientific | fixed;
 
     typedef unsigned int iostate;
     static const iostate badbit  = 0x1;
     static const iostate eofbit  = 0x2;
     static const iostate failbit = 0x4;
     static const iostate goodbit = 0x0;
 
     typedef unsigned int openmode;
     static const openmode app    = 0x01;
     static const openmode ate    = 0x02;
     static const openmode binary = 0x04;
     static const openmode in     = 0x08;
     static const openmode out    = 0x10;
     static const openmode trunc  = 0x20;
 
     enum seekdir {beg, cur, end};
 
 #if _LIBCPP_STD_VER <= 14
     typedef iostate      io_state;
     typedef openmode     open_mode;
     typedef seekdir      seek_dir;
 
     typedef _VSTD::streamoff streamoff;
     typedef _VSTD::streampos streampos;
 #endif
 
     class _LIBCPP_TYPE_VIS Init;
 
     // 27.5.2.2 fmtflags state:
     _LIBCPP_INLINE_VISIBILITY fmtflags flags() const;
     _LIBCPP_INLINE_VISIBILITY fmtflags flags(fmtflags __fmtfl);
     _LIBCPP_INLINE_VISIBILITY fmtflags setf(fmtflags __fmtfl);
     _LIBCPP_INLINE_VISIBILITY fmtflags setf(fmtflags __fmtfl, fmtflags __mask);
     _LIBCPP_INLINE_VISIBILITY void unsetf(fmtflags __mask);
 
     _LIBCPP_INLINE_VISIBILITY streamsize precision() const;
     _LIBCPP_INLINE_VISIBILITY streamsize precision(streamsize __prec);
     _LIBCPP_INLINE_VISIBILITY streamsize width() const;
     _LIBCPP_INLINE_VISIBILITY streamsize width(streamsize __wide);
 
     // 27.5.2.3 locales:
     locale imbue(const locale& __loc);
     locale getloc() const;
 
     // 27.5.2.5 storage:
     static int xalloc();
     long& iword(int __index);
     void*& pword(int __index);
 
     // destructor
     virtual ~ios_base();
 
     // 27.5.2.6 callbacks;
     enum event { erase_event, imbue_event, copyfmt_event };
     typedef void (*event_callback)(event, ios_base&, int __index);
     void register_callback(event_callback __fn, int __index);
 
 private:
     ios_base(const ios_base&); // = delete;
     ios_base& operator=(const ios_base&); // = delete;
 
 public:
     static bool sync_with_stdio(bool __sync = true);
 
     _LIBCPP_INLINE_VISIBILITY iostate rdstate() const;
     void clear(iostate __state = goodbit);
     _LIBCPP_INLINE_VISIBILITY void setstate(iostate __state);
 
     _LIBCPP_INLINE_VISIBILITY bool good() const;
     _LIBCPP_INLINE_VISIBILITY bool eof() const;
     _LIBCPP_INLINE_VISIBILITY bool fail() const;
     _LIBCPP_INLINE_VISIBILITY bool bad() const;
 
     _LIBCPP_INLINE_VISIBILITY iostate exceptions() const;
     _LIBCPP_INLINE_VISIBILITY void exceptions(iostate __iostate);
 
     void __set_badbit_and_consider_rethrow();
     void __set_failbit_and_consider_rethrow();
 
     _LIBCPP_INLINE_VISIBILITY
     void __setstate_nothrow(iostate __state)
     {
         if (__rdbuf_)
             __rdstate_ |= __state;
         else
             __rdstate_ |= __state | ios_base::badbit;
     }
 
 protected:
     _LIBCPP_INLINE_VISIBILITY
     ios_base() {// purposefully does no initialization
                }
 
     void init(void* __sb);
     _LIBCPP_INLINE_VISIBILITY void* rdbuf() const {return __rdbuf_;}
 
     _LIBCPP_INLINE_VISIBILITY
     void rdbuf(void* __sb)
     {
         __rdbuf_ = __sb;
         clear();
     }
 
     void __call_callbacks(event);
     void copyfmt(const ios_base&);
     void move(ios_base&);
     void swap(ios_base&) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     void set_rdbuf(void* __sb)
     {
         __rdbuf_ = __sb;
     }
 
 private:
     // All data members must be scalars
     fmtflags        __fmtflags_;
     streamsize      __precision_;
     streamsize      __width_;
     iostate         __rdstate_;
     iostate         __exceptions_;
     void*           __rdbuf_;
     void*           __loc_;
     event_callback* __fn_;
     int*            __index_;
     size_t          __event_size_;
     size_t          __event_cap_;
 // TODO(EricWF): Enable this for both Clang and GCC. Currently it is only
 // enabled with clang.
 #if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
     static atomic<int> __xindex_;
 #else
     static int      __xindex_;
 #endif
     long*           __iarray_;
     size_t          __iarray_size_;
     size_t          __iarray_cap_;
     void**          __parray_;
     size_t          __parray_size_;
     size_t          __parray_cap_;
 };
 
 //enum class io_errc
 _LIBCPP_DECLARE_STRONG_ENUM(io_errc)
 {
     stream = 1
 };
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc)
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc> : public true_type { };
 
 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
 template <>
 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc::__lx> : public true_type { };
 #endif
 
 _LIBCPP_FUNC_VIS
 const error_category& iostream_category() _NOEXCEPT;
 
 inline _LIBCPP_INLINE_VISIBILITY
 error_code
 make_error_code(io_errc __e) _NOEXCEPT
 {
     return error_code(static_cast<int>(__e), iostream_category());
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 error_condition
 make_error_condition(io_errc __e) _NOEXCEPT
 {
     return error_condition(static_cast<int>(__e), iostream_category());
 }
 
 class _LIBCPP_EXCEPTION_ABI ios_base::failure
     : public system_error
 {
 public:
     explicit failure(const string& __msg, const error_code& __ec = io_errc::stream);
     explicit failure(const char* __msg, const error_code& __ec = io_errc::stream);
-    virtual ~failure() throw();
+    failure(const failure&) _NOEXCEPT = default;
+    virtual ~failure() _NOEXCEPT;
 };
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_failure(char const* __msg) {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw ios_base::failure(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
 class _LIBCPP_TYPE_VIS ios_base::Init
 {
 public:
     Init();
     ~Init();
 };
 
 // fmtflags
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base::fmtflags
 ios_base::flags() const
 {
     return __fmtflags_;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base::fmtflags
 ios_base::flags(fmtflags __fmtfl)
 {
     fmtflags __r = __fmtflags_;
     __fmtflags_ = __fmtfl;
     return __r;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base::fmtflags
 ios_base::setf(fmtflags __fmtfl)
 {
     fmtflags __r = __fmtflags_;
     __fmtflags_ |= __fmtfl;
     return __r;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 void
 ios_base::unsetf(fmtflags __mask)
 {
     __fmtflags_ &= ~__mask;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base::fmtflags
 ios_base::setf(fmtflags __fmtfl, fmtflags __mask)
 {
     fmtflags __r = __fmtflags_;
     unsetf(__mask);
     __fmtflags_ |= __fmtfl & __mask;
     return __r;
 }
 
 // precision
 
 inline _LIBCPP_INLINE_VISIBILITY
 streamsize
 ios_base::precision() const
 {
     return __precision_;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 streamsize
 ios_base::precision(streamsize __prec)
 {
     streamsize __r = __precision_;
     __precision_ = __prec;
     return __r;
 }
 
 // width
 
 inline _LIBCPP_INLINE_VISIBILITY
 streamsize
 ios_base::width() const
 {
     return __width_;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 streamsize
 ios_base::width(streamsize __wide)
 {
     streamsize __r = __width_;
     __width_ = __wide;
     return __r;
 }
 
 // iostate
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base::iostate
 ios_base::rdstate() const
 {
     return __rdstate_;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 void
 ios_base::setstate(iostate __state)
 {
     clear(__rdstate_ | __state);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 ios_base::good() const
 {
     return __rdstate_ == 0;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 ios_base::eof() const
 {
     return (__rdstate_ & eofbit) != 0;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 ios_base::fail() const
 {
     return (__rdstate_ & (failbit | badbit)) != 0;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 ios_base::bad() const
 {
     return (__rdstate_ & badbit) != 0;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base::iostate
 ios_base::exceptions() const
 {
     return __exceptions_;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 void
 ios_base::exceptions(iostate __iostate)
 {
     __exceptions_ = __iostate;
     clear(__rdstate_);
 }
 
 #if defined(_LIBCPP_CXX03_LANG)
 struct _LIBCPP_TYPE_VIS __cxx03_bool {
   typedef void (__cxx03_bool::*__bool_type)();
   void __true_value() {}
 };
 #endif
 
 template <class _CharT, class _Traits>
 class _LIBCPP_TEMPLATE_VIS basic_ios
     : public ios_base
 {
 public:
     // types:
     typedef _CharT char_type;
     typedef _Traits traits_type;
 
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
     static_assert((is_same<_CharT, typename traits_type::char_type>::value),
                   "traits_type::char_type must be the same type as CharT");
 
   // __true_value will generate undefined references when linking unless
   // we give it internal linkage.
 
 #if defined(_LIBCPP_CXX03_LANG)
     _LIBCPP_INLINE_VISIBILITY
     operator __cxx03_bool::__bool_type() const {
         return !fail() ? &__cxx03_bool::__true_value : nullptr;
     }
 #else
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_EXPLICIT operator bool() const {return !fail();}
 #endif
 
     _LIBCPP_INLINE_VISIBILITY bool operator!() const    {return  fail();}
     _LIBCPP_INLINE_VISIBILITY iostate rdstate() const   {return ios_base::rdstate();}
     _LIBCPP_INLINE_VISIBILITY void clear(iostate __state = goodbit) {ios_base::clear(__state);}
     _LIBCPP_INLINE_VISIBILITY void setstate(iostate __state) {ios_base::setstate(__state);}
     _LIBCPP_INLINE_VISIBILITY bool good() const {return ios_base::good();}
     _LIBCPP_INLINE_VISIBILITY bool eof() const  {return ios_base::eof();}
     _LIBCPP_INLINE_VISIBILITY bool fail() const {return ios_base::fail();}
     _LIBCPP_INLINE_VISIBILITY bool bad() const  {return ios_base::bad();}
 
     _LIBCPP_INLINE_VISIBILITY iostate exceptions() const {return ios_base::exceptions();}
     _LIBCPP_INLINE_VISIBILITY void exceptions(iostate __iostate) {ios_base::exceptions(__iostate);}
 
     // 27.5.4.1 Constructor/destructor:
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_ios(basic_streambuf<char_type,traits_type>* __sb);
     virtual ~basic_ios();
 
     // 27.5.4.2 Members:
     _LIBCPP_INLINE_VISIBILITY
     basic_ostream<char_type, traits_type>* tie() const;
     _LIBCPP_INLINE_VISIBILITY
     basic_ostream<char_type, traits_type>* tie(basic_ostream<char_type, traits_type>* __tiestr);
 
     _LIBCPP_INLINE_VISIBILITY
     basic_streambuf<char_type, traits_type>* rdbuf() const;
     _LIBCPP_INLINE_VISIBILITY
     basic_streambuf<char_type, traits_type>* rdbuf(basic_streambuf<char_type, traits_type>* __sb);
 
     basic_ios& copyfmt(const basic_ios& __rhs);
 
     _LIBCPP_INLINE_VISIBILITY
     char_type fill() const;
     _LIBCPP_INLINE_VISIBILITY
     char_type fill(char_type __ch);
 
     _LIBCPP_INLINE_VISIBILITY
     locale imbue(const locale& __loc);
 
     _LIBCPP_INLINE_VISIBILITY
     char narrow(char_type __c, char __dfault) const;
     _LIBCPP_INLINE_VISIBILITY
     char_type widen(char __c) const;
 
 protected:
     _LIBCPP_INLINE_VISIBILITY
     basic_ios() {// purposefully does no initialization
                 }
     _LIBCPP_INLINE_VISIBILITY
     void init(basic_streambuf<char_type, traits_type>* __sb);
 
     _LIBCPP_INLINE_VISIBILITY
     void move(basic_ios& __rhs);
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     void move(basic_ios&& __rhs) {move(__rhs);}
 #endif
     _LIBCPP_INLINE_VISIBILITY
     void swap(basic_ios& __rhs) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     void set_rdbuf(basic_streambuf<char_type, traits_type>* __sb);
 private:
     basic_ostream<char_type, traits_type>* __tie_;
     mutable int_type __fill_;
 };
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_ios<_CharT, _Traits>::basic_ios(basic_streambuf<char_type,traits_type>* __sb)
 {
     init(__sb);
 }
 
 template <class _CharT, class _Traits>
 basic_ios<_CharT, _Traits>::~basic_ios()
 {
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_ios<_CharT, _Traits>::init(basic_streambuf<char_type, traits_type>* __sb)
 {
     ios_base::init(__sb);
     __tie_ = 0;
     __fill_ = traits_type::eof();
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>*
 basic_ios<_CharT, _Traits>::tie() const
 {
     return __tie_;
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>*
 basic_ios<_CharT, _Traits>::tie(basic_ostream<char_type, traits_type>* __tiestr)
 {
     basic_ostream<char_type, traits_type>* __r = __tie_;
     __tie_ = __tiestr;
     return __r;
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_streambuf<_CharT, _Traits>*
 basic_ios<_CharT, _Traits>::rdbuf() const
 {
     return static_cast<basic_streambuf<char_type, traits_type>*>(ios_base::rdbuf());
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_streambuf<_CharT, _Traits>*
 basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<char_type, traits_type>* __sb)
 {
     basic_streambuf<char_type, traits_type>* __r = rdbuf();
     ios_base::rdbuf(__sb);
     return __r;
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 locale
 basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
 {
     locale __r = getloc();
     ios_base::imbue(__loc);
     if (rdbuf())
         rdbuf()->pubimbue(__loc);
     return __r;
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 char
 basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const
 {
     return use_facet<ctype<char_type> >(getloc()).narrow(__c, __dfault);
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 _CharT
 basic_ios<_CharT, _Traits>::widen(char __c) const
 {
     return use_facet<ctype<char_type> >(getloc()).widen(__c);
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 _CharT
 basic_ios<_CharT, _Traits>::fill() const
 {
     if (traits_type::eq_int_type(traits_type::eof(), __fill_))
         __fill_ = widen(' ');
     return __fill_;
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 _CharT
 basic_ios<_CharT, _Traits>::fill(char_type __ch)
 {
     char_type __r = __fill_;
     __fill_ = __ch;
     return __r;
 }
 
 template <class _CharT, class _Traits>
 basic_ios<_CharT, _Traits>&
 basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
 {
     if (this != &__rhs)
     {
         __call_callbacks(erase_event);
         ios_base::copyfmt(__rhs);
         __tie_ = __rhs.__tie_;
         __fill_ = __rhs.__fill_;
         __call_callbacks(copyfmt_event);
         exceptions(__rhs.exceptions());
     }
     return *this;
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_ios<_CharT, _Traits>::move(basic_ios& __rhs)
 {
     ios_base::move(__rhs);
     __tie_ = __rhs.__tie_;
     __rhs.__tie_ = 0;
     __fill_ = __rhs.__fill_;
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_ios<_CharT, _Traits>::swap(basic_ios& __rhs) _NOEXCEPT
 {
     ios_base::swap(__rhs);
     _VSTD::swap(__tie_, __rhs.__tie_);
     _VSTD::swap(__fill_, __rhs.__fill_);
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_ios<_CharT, _Traits>::set_rdbuf(basic_streambuf<char_type, traits_type>* __sb)
 {
     ios_base::set_rdbuf(__sb);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 boolalpha(ios_base& __str)
 {
     __str.setf(ios_base::boolalpha);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 noboolalpha(ios_base& __str)
 {
     __str.unsetf(ios_base::boolalpha);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 showbase(ios_base& __str)
 {
     __str.setf(ios_base::showbase);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 noshowbase(ios_base& __str)
 {
     __str.unsetf(ios_base::showbase);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 showpoint(ios_base& __str)
 {
     __str.setf(ios_base::showpoint);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 noshowpoint(ios_base& __str)
 {
     __str.unsetf(ios_base::showpoint);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 showpos(ios_base& __str)
 {
     __str.setf(ios_base::showpos);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 noshowpos(ios_base& __str)
 {
     __str.unsetf(ios_base::showpos);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 skipws(ios_base& __str)
 {
     __str.setf(ios_base::skipws);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 noskipws(ios_base& __str)
 {
     __str.unsetf(ios_base::skipws);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 uppercase(ios_base& __str)
 {
     __str.setf(ios_base::uppercase);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 nouppercase(ios_base& __str)
 {
     __str.unsetf(ios_base::uppercase);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 unitbuf(ios_base& __str)
 {
     __str.setf(ios_base::unitbuf);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 nounitbuf(ios_base& __str)
 {
     __str.unsetf(ios_base::unitbuf);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 internal(ios_base& __str)
 {
     __str.setf(ios_base::internal, ios_base::adjustfield);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 left(ios_base& __str)
 {
     __str.setf(ios_base::left, ios_base::adjustfield);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 right(ios_base& __str)
 {
     __str.setf(ios_base::right, ios_base::adjustfield);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 dec(ios_base& __str)
 {
     __str.setf(ios_base::dec, ios_base::basefield);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 hex(ios_base& __str)
 {
     __str.setf(ios_base::hex, ios_base::basefield);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 oct(ios_base& __str)
 {
     __str.setf(ios_base::oct, ios_base::basefield);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 fixed(ios_base& __str)
 {
     __str.setf(ios_base::fixed, ios_base::floatfield);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 scientific(ios_base& __str)
 {
     __str.setf(ios_base::scientific, ios_base::floatfield);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 hexfloat(ios_base& __str)
 {
     __str.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield);
     return __str;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 defaultfloat(ios_base& __str)
 {
     __str.unsetf(ios_base::floatfield);
     return __str;
 }
 
 template <class _CharT, class _Traits>
 class __save_flags
 {
     typedef basic_ios<_CharT, _Traits> __stream_type;
     typedef typename __stream_type::fmtflags fmtflags;
 
     __stream_type& __stream_;
     fmtflags       __fmtflags_;
     _CharT         __fill_;
 
     __save_flags(const __save_flags&);
     __save_flags& operator=(const __save_flags&);
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __save_flags(__stream_type& __stream)
         : __stream_(__stream),
           __fmtflags_(__stream.flags()),
           __fill_(__stream.fill())
         {}
     _LIBCPP_INLINE_VISIBILITY
     ~__save_flags()
     {
         __stream_.flags(__fmtflags_);
         __stream_.fill(__fill_);
     }
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_IOS
Index: head/contrib/llvm-project/libcxx/include/memory
===================================================================
--- head/contrib/llvm-project/libcxx/include/memory	(revision 359086)
+++ head/contrib/llvm-project/libcxx/include/memory	(revision 359087)
@@ -1,5351 +1,5353 @@
 // -*- C++ -*-
 //===-------------------------- memory ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_MEMORY
 #define _LIBCPP_MEMORY
 
 /*
     memory synopsis
 
 namespace std
 {
 
 struct allocator_arg_t { };
 inline constexpr allocator_arg_t allocator_arg = allocator_arg_t();
 
 template <class T, class Alloc> struct uses_allocator;
 
 template <class Ptr>
 struct pointer_traits
 {
     typedef Ptr pointer;
     typedef <details> element_type;
     typedef <details> difference_type;
 
     template <class U> using rebind = <details>;
 
     static pointer pointer_to(<details>);
 };
 
 template <class T>
 struct pointer_traits<T*>
 {
     typedef T* pointer;
     typedef T element_type;
     typedef ptrdiff_t difference_type;
 
     template <class U> using rebind = U*;
 
     static pointer pointer_to(<details>) noexcept; // constexpr in C++20
 };
 
 template <class T> constexpr T* to_address(T* p) noexcept; // C++20
 template <class Ptr> auto to_address(const Ptr& p) noexcept; // C++20
 
 template <class Alloc>
 struct allocator_traits
 {
     typedef Alloc                        allocator_type;
     typedef typename allocator_type::value_type
                                          value_type;
 
     typedef Alloc::pointer | value_type* pointer;
     typedef Alloc::const_pointer
           | pointer_traits<pointer>::rebind<const value_type>
                                          const_pointer;
     typedef Alloc::void_pointer
           | pointer_traits<pointer>::rebind<void>
                                          void_pointer;
     typedef Alloc::const_void_pointer
           | pointer_traits<pointer>::rebind<const void>
                                          const_void_pointer;
     typedef Alloc::difference_type
           | pointer_traits<pointer>::difference_type
                                          difference_type;
     typedef Alloc::size_type
           | make_unsigned<difference_type>::type
                                          size_type;
     typedef Alloc::propagate_on_container_copy_assignment
           | false_type                   propagate_on_container_copy_assignment;
     typedef Alloc::propagate_on_container_move_assignment
           | false_type                   propagate_on_container_move_assignment;
     typedef Alloc::propagate_on_container_swap
           | false_type                   propagate_on_container_swap;
     typedef Alloc::is_always_equal
           | is_empty                     is_always_equal;
 
     template <class T> using rebind_alloc  = Alloc::rebind<U>::other | Alloc<T, Args...>;
     template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
 
     static pointer allocate(allocator_type& a, size_type n);                          // [[nodiscard]] in C++20
     static pointer allocate(allocator_type& a, size_type n, const_void_pointer hint); // [[nodiscard]] in C++20
 
     static void deallocate(allocator_type& a, pointer p, size_type n) noexcept;
 
     template <class T, class... Args>
         static void construct(allocator_type& a, T* p, Args&&... args);
 
     template <class T>
         static void destroy(allocator_type& a, T* p);
 
     static size_type max_size(const allocator_type& a); // noexcept in C++14
 
     static allocator_type
         select_on_container_copy_construction(const allocator_type& a);
 };
 
 template <>
 class allocator<void>
 {
 public:
     typedef void*                                 pointer;
     typedef const void*                           const_pointer;
     typedef void                                  value_type;
 
     template <class _Up> struct rebind {typedef allocator<_Up> other;};
 };
 
 template <class T>
 class allocator
 {
 public:
     typedef size_t                                size_type;
     typedef ptrdiff_t                             difference_type;
     typedef T*                                    pointer;
     typedef const T*                              const_pointer;
     typedef typename add_lvalue_reference<T>::type       reference;
     typedef typename add_lvalue_reference<const T>::type const_reference;
     typedef T                                     value_type;
 
     template <class U> struct rebind {typedef allocator<U> other;};
 
     constexpr allocator() noexcept;                      // constexpr in C++20
     constexpr allocator(const allocator&) noexcept;      // constexpr in C++20
     template <class U>
       constexpr allocator(const allocator<U>&) noexcept; // constexpr in C++20
     ~allocator();
     pointer address(reference x) const noexcept;
     const_pointer address(const_reference x) const noexcept;
     pointer allocate(size_type, allocator<void>::const_pointer hint = 0);
     void deallocate(pointer p, size_type n) noexcept;
     size_type max_size() const noexcept;
     template<class U, class... Args>
         void construct(U* p, Args&&... args);
     template <class U>
         void destroy(U* p);
 };
 
 template <class T, class U>
 bool operator==(const allocator<T>&, const allocator<U>&) noexcept;
 
 template <class T, class U>
 bool operator!=(const allocator<T>&, const allocator<U>&) noexcept;
 
 template <class OutputIterator, class T>
 class raw_storage_iterator
     : public iterator<output_iterator_tag,
                       T,                               // purposefully not C++03
                       ptrdiff_t,                       // purposefully not C++03
                       T*,                              // purposefully not C++03
                       raw_storage_iterator&>           // purposefully not C++03
 {
 public:
     explicit raw_storage_iterator(OutputIterator x);
     raw_storage_iterator& operator*();
     raw_storage_iterator& operator=(const T& element);
     raw_storage_iterator& operator++();
     raw_storage_iterator  operator++(int);
 };
 
 template <class T> pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n) noexcept;
 template <class T> void               return_temporary_buffer(T* p) noexcept;
 
 template <class T> T* addressof(T& r) noexcept;
 template <class T> T* addressof(const T&& r) noexcept = delete;
 
 template <class InputIterator, class ForwardIterator>
 ForwardIterator
 uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result);
 
 template <class InputIterator, class Size, class ForwardIterator>
 ForwardIterator
 uninitialized_copy_n(InputIterator first, Size n, ForwardIterator result);
 
 template <class ForwardIterator, class T>
 void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x);
 
 template <class ForwardIterator, class Size, class T>
 ForwardIterator
 uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
 
 template <class T>
 void destroy_at(T* location);
 
 template <class ForwardIterator>
  void destroy(ForwardIterator first, ForwardIterator last);
 
 template <class ForwardIterator, class Size>
  ForwardIterator destroy_n(ForwardIterator first, Size n);
 
 template <class InputIterator, class ForwardIterator>
  ForwardIterator uninitialized_move(InputIterator first, InputIterator last, ForwardIterator result);
 
 template <class InputIterator, class Size, class ForwardIterator>
  pair<InputIterator,ForwardIterator> uninitialized_move_n(InputIterator first, Size n, ForwardIterator result);
 
 template <class ForwardIterator>
  void uninitialized_value_construct(ForwardIterator first, ForwardIterator last);
 
 template <class ForwardIterator, class Size>
  ForwardIterator uninitialized_value_construct_n(ForwardIterator first, Size n);
 
 template <class ForwardIterator>
  void uninitialized_default_construct(ForwardIterator first, ForwardIterator last);
 
 template <class ForwardIterator, class Size>
  ForwardIterator uninitialized_default_construct_n(ForwardIterator first, Size n);
 
 template <class Y> struct auto_ptr_ref {};      // deprecated in C++11, removed in C++17
 
 template<class X>
 class auto_ptr                                  // deprecated in C++11, removed in C++17
 {
 public:
     typedef X element_type;
 
     explicit auto_ptr(X* p =0) throw();
     auto_ptr(auto_ptr&) throw();
     template<class Y> auto_ptr(auto_ptr<Y>&) throw();
     auto_ptr& operator=(auto_ptr&) throw();
     template<class Y> auto_ptr& operator=(auto_ptr<Y>&) throw();
     auto_ptr& operator=(auto_ptr_ref<X> r) throw();
     ~auto_ptr() throw();
 
     typename add_lvalue_reference<X>::type operator*() const throw();
     X* operator->() const throw();
     X* get() const throw();
     X* release() throw();
     void reset(X* p =0) throw();
 
     auto_ptr(auto_ptr_ref<X>) throw();
     template<class Y> operator auto_ptr_ref<Y>() throw();
     template<class Y> operator auto_ptr<Y>() throw();
 };
 
 template <class T>
 struct default_delete
 {
     constexpr default_delete() noexcept = default;
     template <class U> default_delete(const default_delete<U>&) noexcept;
 
     void operator()(T*) const noexcept;
 };
 
 template <class T>
 struct default_delete<T[]>
 {
     constexpr default_delete() noexcept = default;
     void operator()(T*) const noexcept;
     template <class U> void operator()(U*) const = delete;
 };
 
 template <class T, class D = default_delete<T>>
 class unique_ptr
 {
 public:
     typedef see below pointer;
     typedef T element_type;
     typedef D deleter_type;
 
     // constructors
     constexpr unique_ptr() noexcept;
     explicit unique_ptr(pointer p) noexcept;
     unique_ptr(pointer p, see below d1) noexcept;
     unique_ptr(pointer p, see below d2) noexcept;
     unique_ptr(unique_ptr&& u) noexcept;
     unique_ptr(nullptr_t) noexcept : unique_ptr() { }
     template <class U, class E>
         unique_ptr(unique_ptr<U, E>&& u) noexcept;
     template <class U>
         unique_ptr(auto_ptr<U>&& u) noexcept;       // removed in C++17
 
     // destructor
     ~unique_ptr();
 
     // assignment
     unique_ptr& operator=(unique_ptr&& u) noexcept;
     template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
     unique_ptr& operator=(nullptr_t) noexcept;
 
     // observers
     typename add_lvalue_reference<T>::type operator*() const;
     pointer operator->() const noexcept;
     pointer get() const noexcept;
     deleter_type& get_deleter() noexcept;
     const deleter_type& get_deleter() const noexcept;
     explicit operator bool() const noexcept;
 
     // modifiers
     pointer release() noexcept;
     void reset(pointer p = pointer()) noexcept;
     void swap(unique_ptr& u) noexcept;
 };
 
 template <class T, class D>
 class unique_ptr<T[], D>
 {
 public:
     typedef implementation-defined pointer;
     typedef T element_type;
     typedef D deleter_type;
 
     // constructors
     constexpr unique_ptr() noexcept;
     explicit unique_ptr(pointer p) noexcept;
     unique_ptr(pointer p, see below d) noexcept;
     unique_ptr(pointer p, see below d) noexcept;
     unique_ptr(unique_ptr&& u) noexcept;
     unique_ptr(nullptr_t) noexcept : unique_ptr() { }
 
     // destructor
     ~unique_ptr();
 
     // assignment
     unique_ptr& operator=(unique_ptr&& u) noexcept;
     unique_ptr& operator=(nullptr_t) noexcept;
 
     // observers
     T& operator[](size_t i) const;
     pointer get() const noexcept;
     deleter_type& get_deleter() noexcept;
     const deleter_type& get_deleter() const noexcept;
     explicit operator bool() const noexcept;
 
     // modifiers
     pointer release() noexcept;
     void reset(pointer p = pointer()) noexcept;
     void reset(nullptr_t) noexcept;
     template <class U> void reset(U) = delete;
     void swap(unique_ptr& u) noexcept;
 };
 
 template <class T, class D>
     void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
 
 template <class T1, class D1, class T2, class D2>
     bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 template <class T1, class D1, class T2, class D2>
     bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 template <class T1, class D1, class T2, class D2>
     bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 template <class T1, class D1, class T2, class D2>
     bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 template <class T1, class D1, class T2, class D2>
     bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 template <class T1, class D1, class T2, class D2>
     bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
 
 template <class T, class D>
     bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;
 template <class T, class D>
     bool operator==(nullptr_t, const unique_ptr<T, D>& y) noexcept;
 template <class T, class D>
     bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept;
 template <class T, class D>
     bool operator!=(nullptr_t, const unique_ptr<T, D>& y) noexcept;
 
 template <class T, class D>
     bool operator<(const unique_ptr<T, D>& x, nullptr_t);
 template <class T, class D>
     bool operator<(nullptr_t, const unique_ptr<T, D>& y);
 template <class T, class D>
     bool operator<=(const unique_ptr<T, D>& x, nullptr_t);
 template <class T, class D>
     bool operator<=(nullptr_t, const unique_ptr<T, D>& y);
 template <class T, class D>
     bool operator>(const unique_ptr<T, D>& x, nullptr_t);
 template <class T, class D>
     bool operator>(nullptr_t, const unique_ptr<T, D>& y);
 template <class T, class D>
     bool operator>=(const unique_ptr<T, D>& x, nullptr_t);
 template <class T, class D>
     bool operator>=(nullptr_t, const unique_ptr<T, D>& y);
 
 class bad_weak_ptr
     : public std::exception
 {
     bad_weak_ptr() noexcept;
 };
 
 template<class T, class... Args> unique_ptr<T> make_unique(Args&&... args);     // C++14
 template<class T>                unique_ptr<T> make_unique(size_t n);           // C++14
 template<class T, class... Args> unspecified   make_unique(Args&&...) = delete; // C++14, T == U[N]
 
 template<class E, class T, class Y, class D>
     basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, unique_ptr<Y, D> const& p);
 
 template<class T>
 class shared_ptr
 {
 public:
     typedef T element_type;
     typedef weak_ptr<T> weak_type; // C++17
 
     // constructors:
     constexpr shared_ptr() noexcept;
     template<class Y> explicit shared_ptr(Y* p);
     template<class Y, class D> shared_ptr(Y* p, D d);
     template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
     template <class D> shared_ptr(nullptr_t p, D d);
     template <class D, class A> shared_ptr(nullptr_t p, D d, A a);
     template<class Y> shared_ptr(const shared_ptr<Y>& r, T *p) noexcept;
     shared_ptr(const shared_ptr& r) noexcept;
     template<class Y> shared_ptr(const shared_ptr<Y>& r) noexcept;
     shared_ptr(shared_ptr&& r) noexcept;
     template<class Y> shared_ptr(shared_ptr<Y>&& r) noexcept;
     template<class Y> explicit shared_ptr(const weak_ptr<Y>& r);
     template<class Y> shared_ptr(auto_ptr<Y>&& r);          // removed in C++17
     template <class Y, class D> shared_ptr(unique_ptr<Y, D>&& r);
     shared_ptr(nullptr_t) : shared_ptr() { }
 
     // destructor:
     ~shared_ptr();
 
     // assignment:
     shared_ptr& operator=(const shared_ptr& r) noexcept;
     template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
     shared_ptr& operator=(shared_ptr&& r) noexcept;
     template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r);
     template<class Y> shared_ptr& operator=(auto_ptr<Y>&& r); // removed in C++17
     template <class Y, class D> shared_ptr& operator=(unique_ptr<Y, D>&& r);
 
     // modifiers:
     void swap(shared_ptr& r) noexcept;
     void reset() noexcept;
     template<class Y> void reset(Y* p);
     template<class Y, class D> void reset(Y* p, D d);
     template<class Y, class D, class A> void reset(Y* p, D d, A a);
 
     // observers:
     T* get() const noexcept;
     T& operator*() const noexcept;
     T* operator->() const noexcept;
     long use_count() const noexcept;
     bool unique() const noexcept;
     explicit operator bool() const noexcept;
     template<class U> bool owner_before(shared_ptr<U> const& b) const noexcept;
     template<class U> bool owner_before(weak_ptr<U> const& b) const noexcept;
 };
 
 // shared_ptr comparisons:
 template<class T, class U>
     bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
 template<class T, class U>
     bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
 template<class T, class U>
     bool operator<(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
 template<class T, class U>
     bool operator>(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
 template<class T, class U>
     bool operator<=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
 template<class T, class U>
     bool operator>=(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;
 
 template <class T>
     bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept;
 template <class T>
     bool operator==(nullptr_t, const shared_ptr<T>& y) noexcept;
 template <class T>
     bool operator!=(const shared_ptr<T>& x, nullptr_t) noexcept;
 template <class T>
     bool operator!=(nullptr_t, const shared_ptr<T>& y) noexcept;
 template <class T>
     bool operator<(const shared_ptr<T>& x, nullptr_t) noexcept;
 template <class T>
 bool operator<(nullptr_t, const shared_ptr<T>& y) noexcept;
 template <class T>
     bool operator<=(const shared_ptr<T>& x, nullptr_t) noexcept;
 template <class T>
     bool operator<=(nullptr_t, const shared_ptr<T>& y) noexcept;
 template <class T>
     bool operator>(const shared_ptr<T>& x, nullptr_t) noexcept;
 template <class T>
     bool operator>(nullptr_t, const shared_ptr<T>& y) noexcept;
 template <class T>
     bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept;
 template <class T>
     bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept;
 
 // shared_ptr specialized algorithms:
 template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
 
 // shared_ptr casts:
 template<class T, class U>
     shared_ptr<T> static_pointer_cast(shared_ptr<U> const& r) noexcept;
 template<class T, class U>
     shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const& r) noexcept;
 template<class T, class U>
     shared_ptr<T> const_pointer_cast(shared_ptr<U> const& r) noexcept;
 
 // shared_ptr I/O:
 template<class E, class T, class Y>
     basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, shared_ptr<Y> const& p);
 
 // shared_ptr get_deleter:
 template<class D, class T> D* get_deleter(shared_ptr<T> const& p) noexcept;
 
 template<class T, class... Args>
     shared_ptr<T> make_shared(Args&&... args);
 template<class T, class A, class... Args>
     shared_ptr<T> allocate_shared(const A& a, Args&&... args);
 
 template<class T>
 class weak_ptr
 {
 public:
     typedef T element_type;
 
     // constructors
     constexpr weak_ptr() noexcept;
     template<class Y> weak_ptr(shared_ptr<Y> const& r) noexcept;
     weak_ptr(weak_ptr const& r) noexcept;
     template<class Y> weak_ptr(weak_ptr<Y> const& r) noexcept;
     weak_ptr(weak_ptr&& r) noexcept;                      // C++14
     template<class Y> weak_ptr(weak_ptr<Y>&& r) noexcept; // C++14
 
     // destructor
     ~weak_ptr();
 
     // assignment
     weak_ptr& operator=(weak_ptr const& r) noexcept;
     template<class Y> weak_ptr& operator=(weak_ptr<Y> const& r) noexcept;
     template<class Y> weak_ptr& operator=(shared_ptr<Y> const& r) noexcept;
     weak_ptr& operator=(weak_ptr&& r) noexcept;                      // C++14
     template<class Y> weak_ptr& operator=(weak_ptr<Y>&& r) noexcept; // C++14
 
     // modifiers
     void swap(weak_ptr& r) noexcept;
     void reset() noexcept;
 
     // observers
     long use_count() const noexcept;
     bool expired() const noexcept;
     shared_ptr<T> lock() const noexcept;
     template<class U> bool owner_before(shared_ptr<U> const& b) const noexcept;
     template<class U> bool owner_before(weak_ptr<U> const& b) const noexcept;
 };
 
 // weak_ptr specialized algorithms:
 template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
 
 // class owner_less:
 template<class T> struct owner_less;
 
 template<class T>
 struct owner_less<shared_ptr<T> >
     : binary_function<shared_ptr<T>, shared_ptr<T>, bool>
 {
     typedef bool result_type;
     bool operator()(shared_ptr<T> const&, shared_ptr<T> const&) const noexcept;
     bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const noexcept;
     bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const noexcept;
 };
 
 template<class T>
 struct owner_less<weak_ptr<T> >
     : binary_function<weak_ptr<T>, weak_ptr<T>, bool>
 {
     typedef bool result_type;
     bool operator()(weak_ptr<T> const&, weak_ptr<T> const&) const noexcept;
     bool operator()(shared_ptr<T> const&, weak_ptr<T> const&) const noexcept;
     bool operator()(weak_ptr<T> const&, shared_ptr<T> const&) const noexcept;
 };
 
 template <>  // Added in C++14
 struct owner_less<void>
 {
     template <class _Tp, class _Up>
     bool operator()( shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const noexcept;
     template <class _Tp, class _Up>
     bool operator()( shared_ptr<_Tp> const& __x,   weak_ptr<_Up> const& __y) const noexcept;
     template <class _Tp, class _Up>
     bool operator()(   weak_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const noexcept;
     template <class _Tp, class _Up>
     bool operator()(   weak_ptr<_Tp> const& __x,   weak_ptr<_Up> const& __y) const noexcept;
 
     typedef void is_transparent;
 };
 
 template<class T>
 class enable_shared_from_this
 {
 protected:
     constexpr enable_shared_from_this() noexcept;
     enable_shared_from_this(enable_shared_from_this const&) noexcept;
     enable_shared_from_this& operator=(enable_shared_from_this const&) noexcept;
     ~enable_shared_from_this();
 public:
     shared_ptr<T> shared_from_this();
     shared_ptr<T const> shared_from_this() const;
 };
 
 template<class T>
     bool atomic_is_lock_free(const shared_ptr<T>* p);
 template<class T>
     shared_ptr<T> atomic_load(const shared_ptr<T>* p);
 template<class T>
     shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo);
 template<class T>
     void atomic_store(shared_ptr<T>* p, shared_ptr<T> r);
 template<class T>
     void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
 template<class T>
     shared_ptr<T> atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r);
 template<class T>
     shared_ptr<T>
     atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
 template<class T>
     bool
     atomic_compare_exchange_weak(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
 template<class T>
     bool
     atomic_compare_exchange_strong( shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
 template<class T>
     bool
     atomic_compare_exchange_weak_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
                                           shared_ptr<T> w, memory_order success,
                                           memory_order failure);
 template<class T>
     bool
     atomic_compare_exchange_strong_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
                                             shared_ptr<T> w, memory_order success,
                                             memory_order failure);
 // Hash support
 template <class T> struct hash;
 template <class T, class D> struct hash<unique_ptr<T, D> >;
 template <class T> struct hash<shared_ptr<T> >;
 
 template <class T, class Alloc>
   inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;
 
 // Pointer safety
 enum class pointer_safety { relaxed, preferred, strict };
 void declare_reachable(void *p);
 template <class T> T *undeclare_reachable(T *p);
 void declare_no_pointers(char *p, size_t n);
 void undeclare_no_pointers(char *p, size_t n);
 pointer_safety get_pointer_safety() noexcept;
 
 void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
 
 }  // std
 
 */
 
 #include <__config>
 #include <type_traits>
 #include <typeinfo>
 #include <cstddef>
 #include <cstdint>
 #include <new>
 #include <utility>
 #include <limits>
 #include <iterator>
 #include <__functional_base>
 #include <iosfwd>
 #include <tuple>
 #include <stdexcept>
 #include <cstring>
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #  include <atomic>
 #endif
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ValueType>
 inline _LIBCPP_INLINE_VISIBILITY
 _ValueType __libcpp_relaxed_load(_ValueType const* __value) {
 #if !defined(_LIBCPP_HAS_NO_THREADS) && \
     defined(__ATOMIC_RELAXED) &&        \
     (__has_builtin(__atomic_load_n) || defined(_LIBCPP_COMPILER_GCC))
     return __atomic_load_n(__value, __ATOMIC_RELAXED);
 #else
     return *__value;
 #endif
 }
 
 template <class _ValueType>
 inline _LIBCPP_INLINE_VISIBILITY
 _ValueType __libcpp_acquire_load(_ValueType const* __value) {
 #if !defined(_LIBCPP_HAS_NO_THREADS) && \
     defined(__ATOMIC_ACQUIRE) &&        \
     (__has_builtin(__atomic_load_n) || defined(_LIBCPP_COMPILER_GCC))
     return __atomic_load_n(__value, __ATOMIC_ACQUIRE);
 #else
     return *__value;
 #endif
 }
 
 // addressof moved to <type_traits>
 
 template <class _Tp> class allocator;
 
 template <>
 class _LIBCPP_TEMPLATE_VIS allocator<void>
 {
 public:
     typedef void*             pointer;
     typedef const void*       const_pointer;
     typedef void              value_type;
 
     template <class _Up> struct rebind {typedef allocator<_Up> other;};
 };
 
 template <>
 class _LIBCPP_TEMPLATE_VIS allocator<const void>
 {
 public:
     typedef const void*       pointer;
     typedef const void*       const_pointer;
     typedef const void        value_type;
 
     template <class _Up> struct rebind {typedef allocator<_Up> other;};
 };
 
 // pointer_traits
 
 template <class _Tp, class = void>
 struct __has_element_type : false_type {};
 
 template <class _Tp>
 struct __has_element_type<_Tp,
               typename __void_t<typename _Tp::element_type>::type> : true_type {};
 
 template <class _Ptr, bool = __has_element_type<_Ptr>::value>
 struct __pointer_traits_element_type;
 
 template <class _Ptr>
 struct __pointer_traits_element_type<_Ptr, true>
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _Ptr::element_type type;
 };
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 template <template <class, class...> class _Sp, class _Tp, class ..._Args>
 struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, true>
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _Sp<_Tp, _Args...>::element_type type;
 };
 
 template <template <class, class...> class _Sp, class _Tp, class ..._Args>
 struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, false>
 {
     typedef _LIBCPP_NODEBUG_TYPE _Tp type;
 };
 
 #else  // _LIBCPP_HAS_NO_VARIADICS
 
 template <template <class> class _Sp, class _Tp>
 struct __pointer_traits_element_type<_Sp<_Tp>, true>
 {
     typedef typename _Sp<_Tp>::element_type type;
 };
 
 template <template <class> class _Sp, class _Tp>
 struct __pointer_traits_element_type<_Sp<_Tp>, false>
 {
     typedef _Tp type;
 };
 
 template <template <class, class> class _Sp, class _Tp, class _A0>
 struct __pointer_traits_element_type<_Sp<_Tp, _A0>, true>
 {
     typedef typename _Sp<_Tp, _A0>::element_type type;
 };
 
 template <template <class, class> class _Sp, class _Tp, class _A0>
 struct __pointer_traits_element_type<_Sp<_Tp, _A0>, false>
 {
     typedef _Tp type;
 };
 
 template <template <class, class, class> class _Sp, class _Tp, class _A0, class _A1>
 struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1>, true>
 {
     typedef typename _Sp<_Tp, _A0, _A1>::element_type type;
 };
 
 template <template <class, class, class> class _Sp, class _Tp, class _A0, class _A1>
 struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1>, false>
 {
     typedef _Tp type;
 };
 
 template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
                                                            class _A1, class _A2>
 struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1, _A2>, true>
 {
     typedef typename _Sp<_Tp, _A0, _A1, _A2>::element_type type;
 };
 
 template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
                                                            class _A1, class _A2>
 struct __pointer_traits_element_type<_Sp<_Tp, _A0, _A1, _A2>, false>
 {
     typedef _Tp type;
 };
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 template <class _Tp, class = void>
 struct __has_difference_type : false_type {};
 
 template <class _Tp>
 struct __has_difference_type<_Tp,
             typename __void_t<typename _Tp::difference_type>::type> : true_type {};
 
 template <class _Ptr, bool = __has_difference_type<_Ptr>::value>
 struct __pointer_traits_difference_type
 {
     typedef _LIBCPP_NODEBUG_TYPE ptrdiff_t type;
 };
 
 template <class _Ptr>
 struct __pointer_traits_difference_type<_Ptr, true>
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _Ptr::difference_type type;
 };
 
 template <class _Tp, class _Up>
 struct __has_rebind
 {
 private:
     struct __two {char __lx; char __lxx;};
     template <class _Xp> static __two __test(...);
     template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0);
 public:
     static const bool value = sizeof(__test<_Tp>(0)) == 1;
 };
 
 template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
 struct __pointer_traits_rebind
 {
 #ifndef _LIBCPP_CXX03_LANG
     typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up> type;
 #else
     typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up>::other type;
 #endif
 };
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, true>
 {
 #ifndef _LIBCPP_CXX03_LANG
     typedef _LIBCPP_NODEBUG_TYPE typename _Sp<_Tp, _Args...>::template rebind<_Up> type;
 #else
     typedef _LIBCPP_NODEBUG_TYPE typename _Sp<_Tp, _Args...>::template rebind<_Up>::other type;
 #endif
 };
 
 template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, false>
 {
     typedef _Sp<_Up, _Args...> type;
 };
 
 #else  // _LIBCPP_HAS_NO_VARIADICS
 
 template <template <class> class _Sp, class _Tp, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp>, _Up, true>
 {
 #ifndef _LIBCPP_CXX03_LANG
     typedef typename _Sp<_Tp>::template rebind<_Up> type;
 #else
     typedef typename _Sp<_Tp>::template rebind<_Up>::other type;
 #endif
 };
 
 template <template <class> class _Sp, class _Tp, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp>, _Up, false>
 {
     typedef _Sp<_Up> type;
 };
 
 template <template <class, class> class _Sp, class _Tp, class _A0, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp, _A0>, _Up, true>
 {
 #ifndef _LIBCPP_CXX03_LANG
     typedef typename _Sp<_Tp, _A0>::template rebind<_Up> type;
 #else
     typedef typename _Sp<_Tp, _A0>::template rebind<_Up>::other type;
 #endif
 };
 
 template <template <class, class> class _Sp, class _Tp, class _A0, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp, _A0>, _Up, false>
 {
     typedef _Sp<_Up, _A0> type;
 };
 
 template <template <class, class, class> class _Sp, class _Tp, class _A0,
                                          class _A1, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1>, _Up, true>
 {
 #ifndef _LIBCPP_CXX03_LANG
     typedef typename _Sp<_Tp, _A0, _A1>::template rebind<_Up> type;
 #else
     typedef typename _Sp<_Tp, _A0, _A1>::template rebind<_Up>::other type;
 #endif
 };
 
 template <template <class, class, class> class _Sp, class _Tp, class _A0,
                                          class _A1, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1>, _Up, false>
 {
     typedef _Sp<_Up, _A0, _A1> type;
 };
 
 template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
                                                 class _A1, class _A2, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, true>
 {
 #ifndef _LIBCPP_CXX03_LANG
     typedef typename _Sp<_Tp, _A0, _A1, _A2>::template rebind<_Up> type;
 #else
     typedef typename _Sp<_Tp, _A0, _A1, _A2>::template rebind<_Up>::other type;
 #endif
 };
 
 template <template <class, class, class, class> class _Sp, class _Tp, class _A0,
                                                 class _A1, class _A2, class _Up>
 struct __pointer_traits_rebind<_Sp<_Tp, _A0, _A1, _A2>, _Up, false>
 {
     typedef _Sp<_Up, _A0, _A1, _A2> type;
 };
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 template <class _Ptr>
 struct _LIBCPP_TEMPLATE_VIS pointer_traits
 {
     typedef _Ptr                                                     pointer;
     typedef typename __pointer_traits_element_type<pointer>::type    element_type;
     typedef typename __pointer_traits_difference_type<pointer>::type difference_type;
 
 #ifndef _LIBCPP_CXX03_LANG
     template <class _Up> using rebind = typename __pointer_traits_rebind<pointer, _Up>::type;
 #else
     template <class _Up> struct rebind
         {typedef typename __pointer_traits_rebind<pointer, _Up>::type other;};
 #endif  // _LIBCPP_CXX03_LANG
 
 private:
     struct __nat {};
 public:
     _LIBCPP_INLINE_VISIBILITY
     static pointer pointer_to(typename conditional<is_void<element_type>::value,
                                            __nat, element_type>::type& __r)
         {return pointer::pointer_to(__r);}
 };
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS pointer_traits<_Tp*>
 {
     typedef _Tp*      pointer;
     typedef _Tp       element_type;
     typedef ptrdiff_t difference_type;
 
 #ifndef _LIBCPP_CXX03_LANG
     template <class _Up> using rebind = _Up*;
 #else
     template <class _Up> struct rebind {typedef _Up* other;};
 #endif
 
 private:
     struct __nat {};
 public:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     static pointer pointer_to(typename conditional<is_void<element_type>::value,
                                       __nat, element_type>::type& __r) _NOEXCEPT
         {return _VSTD::addressof(__r);}
 };
 
 template <class _From, class _To>
 struct __rebind_pointer {
 #ifndef _LIBCPP_CXX03_LANG
     typedef typename pointer_traits<_From>::template rebind<_To>        type;
 #else
     typedef typename pointer_traits<_From>::template rebind<_To>::other type;
 #endif
 };
 
 // allocator_traits
 
 template <class _Tp, class = void>
 struct __has_pointer_type : false_type {};
 
 template <class _Tp>
 struct __has_pointer_type<_Tp,
           typename __void_t<typename _Tp::pointer>::type> : true_type {};
 
 namespace __pointer_type_imp
 {
 
 template <class _Tp, class _Dp, bool = __has_pointer_type<_Dp>::value>
 struct __pointer_type
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _Dp::pointer type;
 };
 
 template <class _Tp, class _Dp>
 struct __pointer_type<_Tp, _Dp, false>
 {
     typedef _LIBCPP_NODEBUG_TYPE _Tp* type;
 };
 
 }  // __pointer_type_imp
 
 template <class _Tp, class _Dp>
 struct __pointer_type
 {
     typedef _LIBCPP_NODEBUG_TYPE typename __pointer_type_imp::__pointer_type<_Tp, typename remove_reference<_Dp>::type>::type type;
 };
 
 template <class _Tp, class = void>
 struct __has_const_pointer : false_type {};
 
 template <class _Tp>
 struct __has_const_pointer<_Tp,
             typename __void_t<typename _Tp::const_pointer>::type> : true_type {};
 
 template <class _Tp, class _Ptr, class _Alloc, bool = __has_const_pointer<_Alloc>::value>
 struct __const_pointer
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::const_pointer type;
 };
 
 template <class _Tp, class _Ptr, class _Alloc>
 struct __const_pointer<_Tp, _Ptr, _Alloc, false>
 {
 #ifndef _LIBCPP_CXX03_LANG
     typedef _LIBCPP_NODEBUG_TYPE typename pointer_traits<_Ptr>::template rebind<const _Tp> type;
 #else
     typedef typename pointer_traits<_Ptr>::template rebind<const _Tp>::other type;
 #endif
 };
 
 template <class _Tp, class = void>
 struct __has_void_pointer : false_type {};
 
 template <class _Tp>
 struct __has_void_pointer<_Tp,
                typename __void_t<typename _Tp::void_pointer>::type> : true_type {};
 
 template <class _Ptr, class _Alloc, bool = __has_void_pointer<_Alloc>::value>
 struct __void_pointer
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::void_pointer type;
 };
 
 template <class _Ptr, class _Alloc>
 struct __void_pointer<_Ptr, _Alloc, false>
 {
 #ifndef _LIBCPP_CXX03_LANG
     typedef _LIBCPP_NODEBUG_TYPE typename pointer_traits<_Ptr>::template rebind<void> type;
 #else
     typedef _LIBCPP_NODEBUG_TYPE typename pointer_traits<_Ptr>::template rebind<void>::other type;
 #endif
 };
 
 template <class _Tp, class = void>
 struct __has_const_void_pointer : false_type {};
 
 template <class _Tp>
 struct __has_const_void_pointer<_Tp,
             typename __void_t<typename _Tp::const_void_pointer>::type> : true_type {};
 
 template <class _Ptr, class _Alloc, bool = __has_const_void_pointer<_Alloc>::value>
 struct __const_void_pointer
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::const_void_pointer type;
 };
 
 template <class _Ptr, class _Alloc>
 struct __const_void_pointer<_Ptr, _Alloc, false>
 {
 #ifndef _LIBCPP_CXX03_LANG
     typedef _LIBCPP_NODEBUG_TYPE typename pointer_traits<_Ptr>::template rebind<const void> type;
 #else
     typedef _LIBCPP_NODEBUG_TYPE typename pointer_traits<_Ptr>::template rebind<const void>::other type;
 #endif
 };
 
 
 template <bool _UsePointerTraits> struct __to_address_helper;
 
 template <> struct __to_address_helper<true> {
     template <class _Pointer>
     using __return_type = decltype(pointer_traits<_Pointer>::to_address(std::declval<const _Pointer&>()));
 
     template <class _Pointer>
     _LIBCPP_CONSTEXPR
     static __return_type<_Pointer>
     __do_it(const _Pointer &__p) _NOEXCEPT { return pointer_traits<_Pointer>::to_address(__p); }
 };
 
 template <class _Pointer, bool _Dummy = true>
 using __choose_to_address = __to_address_helper<_IsValidExpansion<__to_address_helper<_Dummy>::template __return_type, _Pointer>::value>;
 
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 _Tp*
 __to_address(_Tp* __p) _NOEXCEPT
 {
     static_assert(!is_function<_Tp>::value, "_Tp is a function type");
     return __p;
 }
 
 template <class _Pointer>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename __choose_to_address<_Pointer>::template __return_type<_Pointer>
 __to_address(const _Pointer& __p) _NOEXCEPT {
   return __choose_to_address<_Pointer>::__do_it(__p);
 }
 
 template <> struct __to_address_helper<false> {
     template <class _Pointer>
     using __return_type = typename pointer_traits<_Pointer>::element_type*;
 
     template <class _Pointer>
     _LIBCPP_CONSTEXPR
     static __return_type<_Pointer>
     __do_it(const _Pointer &__p) _NOEXCEPT { return std::__to_address(__p.operator->()); }
 };
 
 
 #if _LIBCPP_STD_VER > 17
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY constexpr
 _Tp*
 to_address(_Tp* __p) _NOEXCEPT
 {
     static_assert(!is_function_v<_Tp>, "_Tp is a function type");
     return __p;
 }
 
 template <class _Pointer>
 inline _LIBCPP_INLINE_VISIBILITY
 auto
 to_address(const _Pointer& __p) _NOEXCEPT
 {
     return _VSTD::__to_address(__p);
 }
 #endif
 
 template <class _Tp, class = void>
 struct __has_size_type : false_type {};
 
 template <class _Tp>
 struct __has_size_type<_Tp,
                typename __void_t<typename _Tp::size_type>::type> : true_type {};
 
 template <class _Alloc, class _DiffType, bool = __has_size_type<_Alloc>::value>
 struct __size_type
 {
     typedef _LIBCPP_NODEBUG_TYPE typename make_unsigned<_DiffType>::type type;
 };
 
 template <class _Alloc, class _DiffType>
 struct __size_type<_Alloc, _DiffType, true>
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::size_type type;
 };
 
 template <class _Tp, class = void>
 struct __has_propagate_on_container_copy_assignment : false_type {};
 
 template <class _Tp>
 struct __has_propagate_on_container_copy_assignment<_Tp,
     typename __void_t<typename _Tp::propagate_on_container_copy_assignment>::type>
         : true_type {};
 
 template <class _Alloc, bool = __has_propagate_on_container_copy_assignment<_Alloc>::value>
 struct __propagate_on_container_copy_assignment
 {
     typedef _LIBCPP_NODEBUG_TYPE false_type type;
 };
 
 template <class _Alloc>
 struct __propagate_on_container_copy_assignment<_Alloc, true>
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::propagate_on_container_copy_assignment type;
 };
 
 template <class _Tp, class = void>
 struct __has_propagate_on_container_move_assignment : false_type {};
 
 template <class _Tp>
 struct __has_propagate_on_container_move_assignment<_Tp,
            typename __void_t<typename _Tp::propagate_on_container_move_assignment>::type>
                : true_type {};
 
 template <class _Alloc, bool = __has_propagate_on_container_move_assignment<_Alloc>::value>
 struct __propagate_on_container_move_assignment
 {
     typedef false_type type;
 };
 
 template <class _Alloc>
 struct __propagate_on_container_move_assignment<_Alloc, true>
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::propagate_on_container_move_assignment type;
 };
 
 template <class _Tp, class = void>
 struct __has_propagate_on_container_swap : false_type {};
 
 template <class _Tp>
 struct __has_propagate_on_container_swap<_Tp,
            typename __void_t<typename _Tp::propagate_on_container_swap>::type>
                : true_type {};
 
 template <class _Alloc, bool = __has_propagate_on_container_swap<_Alloc>::value>
 struct __propagate_on_container_swap
 {
     typedef false_type type;
 };
 
 template <class _Alloc>
 struct __propagate_on_container_swap<_Alloc, true>
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::propagate_on_container_swap type;
 };
 
 template <class _Tp, class = void>
 struct __has_is_always_equal : false_type {};
 
 template <class _Tp>
 struct __has_is_always_equal<_Tp,
            typename __void_t<typename _Tp::is_always_equal>::type>
                : true_type {};
 
 template <class _Alloc, bool = __has_is_always_equal<_Alloc>::value>
 struct __is_always_equal
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _VSTD::is_empty<_Alloc>::type type;
 };
 
 template <class _Alloc>
 struct __is_always_equal<_Alloc, true>
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::is_always_equal type;
 };
 
 template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
 struct __has_rebind_other
 {
 private:
     struct __two {char __lx; char __lxx;};
     template <class _Xp> static __two __test(...);
     template <class _Xp> static char __test(typename _Xp::template rebind<_Up>::other* = 0);
 public:
     static const bool value = sizeof(__test<_Tp>(0)) == 1;
 };
 
 template <class _Tp, class _Up>
 struct __has_rebind_other<_Tp, _Up, false>
 {
     static const bool value = false;
 };
 
 template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value>
 struct __allocator_traits_rebind
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up>::other type;
 };
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
 struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true>
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other type;
 };
 
 template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
 struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false>
 {
     typedef _LIBCPP_NODEBUG_TYPE _Alloc<_Up, _Args...> type;
 };
 
 #else  // _LIBCPP_HAS_NO_VARIADICS
 
 template <template <class> class _Alloc, class _Tp, class _Up>
 struct __allocator_traits_rebind<_Alloc<_Tp>, _Up, true>
 {
     typedef typename _Alloc<_Tp>::template rebind<_Up>::other type;
 };
 
 template <template <class> class _Alloc, class _Tp, class _Up>
 struct __allocator_traits_rebind<_Alloc<_Tp>, _Up, false>
 {
     typedef _Alloc<_Up> type;
 };
 
 template <template <class, class> class _Alloc, class _Tp, class _A0, class _Up>
 struct __allocator_traits_rebind<_Alloc<_Tp, _A0>, _Up, true>
 {
     typedef typename _Alloc<_Tp, _A0>::template rebind<_Up>::other type;
 };
 
 template <template <class, class> class _Alloc, class _Tp, class _A0, class _Up>
 struct __allocator_traits_rebind<_Alloc<_Tp, _A0>, _Up, false>
 {
     typedef _Alloc<_Up, _A0> type;
 };
 
 template <template <class, class, class> class _Alloc, class _Tp, class _A0,
                                          class _A1, class _Up>
 struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1>, _Up, true>
 {
     typedef typename _Alloc<_Tp, _A0, _A1>::template rebind<_Up>::other type;
 };
 
 template <template <class, class, class> class _Alloc, class _Tp, class _A0,
                                          class _A1, class _Up>
 struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1>, _Up, false>
 {
     typedef _Alloc<_Up, _A0, _A1> type;
 };
 
 template <template <class, class, class, class> class _Alloc, class _Tp, class _A0,
                                                 class _A1, class _A2, class _Up>
 struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1, _A2>, _Up, true>
 {
     typedef typename _Alloc<_Tp, _A0, _A1, _A2>::template rebind<_Up>::other type;
 };
 
 template <template <class, class, class, class> class _Alloc, class _Tp, class _A0,
                                                 class _A1, class _A2, class _Up>
 struct __allocator_traits_rebind<_Alloc<_Tp, _A0, _A1, _A2>, _Up, false>
 {
     typedef _Alloc<_Up, _A0, _A1, _A2> type;
 };
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Alloc, class _SizeType, class _ConstVoidPtr>
 auto
 __has_allocate_hint_test(_Alloc&& __a, _SizeType&& __sz, _ConstVoidPtr&& __p)
     -> decltype((void)__a.allocate(__sz, __p), true_type());
 
 template <class _Alloc, class _SizeType, class _ConstVoidPtr>
 auto
 __has_allocate_hint_test(const _Alloc& __a, _SizeType&& __sz, _ConstVoidPtr&& __p)
     -> false_type;
 
 template <class _Alloc, class _SizeType, class _ConstVoidPtr>
 struct __has_allocate_hint
     : integral_constant<bool,
         is_same<
             decltype(_VSTD::__has_allocate_hint_test(declval<_Alloc>(),
                                           declval<_SizeType>(),
                                           declval<_ConstVoidPtr>())),
             true_type>::value>
 {
 };
 
 #else  // _LIBCPP_CXX03_LANG
 
 template <class _Alloc, class _SizeType, class _ConstVoidPtr>
 struct __has_allocate_hint
     : true_type
 {
 };
 
 #endif  // _LIBCPP_CXX03_LANG
 
 #if !defined(_LIBCPP_CXX03_LANG)
 
 template <class _Alloc, class _Tp, class ..._Args>
 decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Tp*>(),
                                            _VSTD::declval<_Args>()...),
                                            true_type())
 __has_construct_test(_Alloc&& __a, _Tp* __p, _Args&& ...__args);
 
 template <class _Alloc, class _Pointer, class ..._Args>
 false_type
 __has_construct_test(const _Alloc& __a, _Pointer&& __p, _Args&& ...__args);
 
 template <class _Alloc, class _Pointer, class ..._Args>
 struct __has_construct
     : integral_constant<bool,
         is_same<
             decltype(_VSTD::__has_construct_test(declval<_Alloc>(),
                                           declval<_Pointer>(),
                                           declval<_Args>()...)),
             true_type>::value>
 {
 };
 
 template <class _Alloc, class _Pointer>
 auto
 __has_destroy_test(_Alloc&& __a, _Pointer&& __p)
     -> decltype(__a.destroy(__p), true_type());
 
 template <class _Alloc, class _Pointer>
 auto
 __has_destroy_test(const _Alloc& __a, _Pointer&& __p)
     -> false_type;
 
 template <class _Alloc, class _Pointer>
 struct __has_destroy
     : integral_constant<bool,
         is_same<
             decltype(_VSTD::__has_destroy_test(declval<_Alloc>(),
                                         declval<_Pointer>())),
             true_type>::value>
 {
 };
 
 template <class _Alloc>
 auto
 __has_max_size_test(_Alloc&& __a)
     -> decltype(__a.max_size(), true_type());
 
 template <class _Alloc>
 auto
 __has_max_size_test(const volatile _Alloc& __a)
     -> false_type;
 
 template <class _Alloc>
 struct __has_max_size
     : integral_constant<bool,
         is_same<
             decltype(_VSTD::__has_max_size_test(declval<_Alloc&>())),
             true_type>::value>
 {
 };
 
 template <class _Alloc>
 auto
 __has_select_on_container_copy_construction_test(_Alloc&& __a)
     -> decltype(__a.select_on_container_copy_construction(), true_type());
 
 template <class _Alloc>
 auto
 __has_select_on_container_copy_construction_test(const volatile _Alloc& __a)
     -> false_type;
 
 template <class _Alloc>
 struct __has_select_on_container_copy_construction
     : integral_constant<bool,
         is_same<
             decltype(_VSTD::__has_select_on_container_copy_construction_test(declval<_Alloc&>())),
             true_type>::value>
 {
 };
 
 #else  // _LIBCPP_CXX03_LANG
 
 template <class _Alloc, class _Pointer, class _Tp, class = void>
 struct __has_construct : std::false_type {};
 
 template <class _Alloc, class _Pointer, class _Tp>
 struct __has_construct<_Alloc, _Pointer, _Tp, typename __void_t<
     decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Pointer>(), _VSTD::declval<_Tp>()))
 >::type> : std::true_type {};
 
 template <class _Alloc, class _Pointer, class = void>
 struct __has_destroy : false_type {};
 
 template <class _Alloc, class _Pointer>
 struct __has_destroy<_Alloc, _Pointer, typename __void_t<
     decltype(_VSTD::declval<_Alloc>().destroy(_VSTD::declval<_Pointer>()))
 >::type> : std::true_type {};
 
 template <class _Alloc>
 struct __has_max_size
     : true_type
 {
 };
 
 template <class _Alloc>
 struct __has_select_on_container_copy_construction
     : false_type
 {
 };
 
 #endif  // _LIBCPP_CXX03_LANG
 
 template <class _Alloc, class _Ptr, bool = __has_difference_type<_Alloc>::value>
 struct __alloc_traits_difference_type
 {
     typedef _LIBCPP_NODEBUG_TYPE typename pointer_traits<_Ptr>::difference_type type;
 };
 
 template <class _Alloc, class _Ptr>
 struct __alloc_traits_difference_type<_Alloc, _Ptr, true>
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::difference_type type;
 };
 
 template <class _Tp>
 struct __is_default_allocator : false_type {};
 
 template <class _Tp>
 struct __is_default_allocator<_VSTD::allocator<_Tp> > : true_type {};
 
 
 
 template <class _Alloc,
     bool = __has_construct<_Alloc, typename _Alloc::value_type*,  typename _Alloc::value_type&&>::value && !__is_default_allocator<_Alloc>::value
     >
 struct __is_cpp17_move_insertable;
 template <class _Alloc>
 struct __is_cpp17_move_insertable<_Alloc, true> : std::true_type {};
 template <class _Alloc>
 struct __is_cpp17_move_insertable<_Alloc, false> : std::is_move_constructible<typename _Alloc::value_type> {};
 
 template <class _Alloc,
     bool = __has_construct<_Alloc, typename _Alloc::value_type*, const typename _Alloc::value_type&>::value && !__is_default_allocator<_Alloc>::value
     >
 struct __is_cpp17_copy_insertable;
 template <class _Alloc>
 struct __is_cpp17_copy_insertable<_Alloc, true> : __is_cpp17_move_insertable<_Alloc> {};
 template <class _Alloc>
 struct __is_cpp17_copy_insertable<_Alloc, false> : integral_constant<bool,
     std::is_copy_constructible<typename _Alloc::value_type>::value &&
     __is_cpp17_move_insertable<_Alloc>::value>
   {};
 
 
 
 template <class _Alloc>
 struct _LIBCPP_TEMPLATE_VIS allocator_traits
 {
     typedef _Alloc                              allocator_type;
     typedef typename allocator_type::value_type value_type;
 
     typedef typename __pointer_type<value_type, allocator_type>::type pointer;
     typedef typename __const_pointer<value_type, pointer, allocator_type>::type const_pointer;
     typedef typename __void_pointer<pointer, allocator_type>::type void_pointer;
     typedef typename __const_void_pointer<pointer, allocator_type>::type const_void_pointer;
 
     typedef typename __alloc_traits_difference_type<allocator_type, pointer>::type difference_type;
     typedef typename __size_type<allocator_type, difference_type>::type size_type;
 
     typedef typename __propagate_on_container_copy_assignment<allocator_type>::type
                      propagate_on_container_copy_assignment;
     typedef typename __propagate_on_container_move_assignment<allocator_type>::type
                      propagate_on_container_move_assignment;
     typedef typename __propagate_on_container_swap<allocator_type>::type
                      propagate_on_container_swap;
     typedef typename __is_always_equal<allocator_type>::type
                      is_always_equal;
 
 #ifndef _LIBCPP_CXX03_LANG
     template <class _Tp> using rebind_alloc =
                   typename __allocator_traits_rebind<allocator_type, _Tp>::type;
     template <class _Tp> using rebind_traits = allocator_traits<rebind_alloc<_Tp> >;
 #else  // _LIBCPP_CXX03_LANG
     template <class _Tp> struct rebind_alloc
         {typedef typename __allocator_traits_rebind<allocator_type, _Tp>::type other;};
     template <class _Tp> struct rebind_traits
         {typedef allocator_traits<typename rebind_alloc<_Tp>::other> other;};
 #endif  // _LIBCPP_CXX03_LANG
 
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     static pointer allocate(allocator_type& __a, size_type __n)
         {return __a.allocate(__n);}
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
         {return __allocate(__a, __n, __hint,
             __has_allocate_hint<allocator_type, size_type, const_void_pointer>());}
 
     _LIBCPP_INLINE_VISIBILITY
     static void deallocate(allocator_type& __a, pointer __p, size_type __n) _NOEXCEPT
         {__a.deallocate(__p, __n);}
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class _Tp, class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args)
             {__construct(__has_construct<allocator_type, _Tp*, _Args...>(),
                          __a, __p, _VSTD::forward<_Args>(__args)...);}
 #else  // _LIBCPP_HAS_NO_VARIADICS
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
         static void construct(allocator_type&, _Tp* __p)
             {
                 ::new ((void*)__p) _Tp();
             }
     template <class _Tp, class _A0>
         _LIBCPP_INLINE_VISIBILITY
         static void construct(allocator_type& __a, _Tp* __p, const _A0& __a0)
             {
                 __construct(__has_construct<allocator_type, _Tp*, const _A0&>(),
                             __a, __p, __a0);
             }
     template <class _Tp, class _A0, class _A1>
         _LIBCPP_INLINE_VISIBILITY
         static void construct(allocator_type&, _Tp* __p, const _A0& __a0,
                               const _A1& __a1)
             {
                 ::new ((void*)__p) _Tp(__a0, __a1);
             }
     template <class _Tp, class _A0, class _A1, class _A2>
         _LIBCPP_INLINE_VISIBILITY
         static void construct(allocator_type&, _Tp* __p, const _A0& __a0,
                               const _A1& __a1, const _A2& __a2)
             {
                 ::new ((void*)__p) _Tp(__a0, __a1, __a2);
             }
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
         static void destroy(allocator_type& __a, _Tp* __p)
             {__destroy(__has_destroy<allocator_type, _Tp*>(), __a, __p);}
 
     _LIBCPP_INLINE_VISIBILITY
     static size_type max_size(const allocator_type& __a) _NOEXCEPT
         {return __max_size(__has_max_size<const allocator_type>(), __a);}
 
     _LIBCPP_INLINE_VISIBILITY
     static allocator_type
         select_on_container_copy_construction(const allocator_type& __a)
             {return __select_on_container_copy_construction(
                 __has_select_on_container_copy_construction<const allocator_type>(),
                 __a);}
 
     template <class _Ptr>
         _LIBCPP_INLINE_VISIBILITY
         static
         void
         __construct_forward_with_exception_guarantees(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __begin2)
         {
             static_assert(__is_cpp17_move_insertable<allocator_type>::value,
               "The specified type does not meet the requirements of Cpp17MoveInsertible");
             for (; __begin1 != __end1; ++__begin1, (void) ++__begin2)
               construct(__a, _VSTD::__to_address(__begin2),
 #ifdef _LIBCPP_NO_EXCEPTIONS
                         _VSTD::move(*__begin1)
 #else
                         _VSTD::move_if_noexcept(*__begin1)
 #endif
                         );
         }
 
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
         static
         typename enable_if
         <
             (__is_default_allocator<allocator_type>::value
                 || !__has_construct<allocator_type, _Tp*, _Tp>::value) &&
              is_trivially_move_constructible<_Tp>::value,
             void
         >::type
         __construct_forward_with_exception_guarantees(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2)
         {
             ptrdiff_t _Np = __end1 - __begin1;
             if (_Np > 0)
             {
                 _VSTD::memcpy(__begin2, __begin1, _Np * sizeof(_Tp));
                 __begin2 += _Np;
             }
         }
 
     template <class _Iter, class _Ptr>
         _LIBCPP_INLINE_VISIBILITY
         static
         void
         __construct_range_forward(allocator_type& __a, _Iter __begin1, _Iter __end1, _Ptr& __begin2)
         {
             for (; __begin1 != __end1; ++__begin1, (void) ++__begin2)
                 construct(__a, _VSTD::__to_address(__begin2), *__begin1);
         }
 
     template <class _SourceTp, class _DestTp,
               class _RawSourceTp = typename remove_const<_SourceTp>::type,
               class _RawDestTp = typename remove_const<_DestTp>::type>
         _LIBCPP_INLINE_VISIBILITY
         static
         typename enable_if
         <
             is_trivially_move_constructible<_DestTp>::value &&
             is_same<_RawSourceTp, _RawDestTp>::value &&
             (__is_default_allocator<allocator_type>::value ||
              !__has_construct<allocator_type, _DestTp*, _SourceTp&>::value),
             void
         >::type
         __construct_range_forward(allocator_type&, _SourceTp* __begin1, _SourceTp* __end1, _DestTp*& __begin2)
         {
             ptrdiff_t _Np = __end1 - __begin1;
             if (_Np > 0)
             {
                 _VSTD::memcpy(const_cast<_RawDestTp*>(__begin2), __begin1, _Np * sizeof(_DestTp));
                 __begin2 += _Np;
             }
         }
 
     template <class _Ptr>
         _LIBCPP_INLINE_VISIBILITY
         static
         void
         __construct_backward_with_exception_guarantees(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __end2)
         {
             static_assert(__is_cpp17_move_insertable<allocator_type>::value,
               "The specified type does not meet the requirements of Cpp17MoveInsertable");
             while (__end1 != __begin1)
             {
               construct(__a, _VSTD::__to_address(__end2 - 1),
 #ifdef _LIBCPP_NO_EXCEPTIONS
                         _VSTD::move(*--__end1)
 #else
                         _VSTD::move_if_noexcept(*--__end1)
 #endif
                         );
               --__end2;
             }
         }
 
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
         static
         typename enable_if
         <
             (__is_default_allocator<allocator_type>::value
                 || !__has_construct<allocator_type, _Tp*, _Tp>::value) &&
              is_trivially_move_constructible<_Tp>::value,
             void
         >::type
         __construct_backward_with_exception_guarantees(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __end2)
         {
             ptrdiff_t _Np = __end1 - __begin1;
             __end2 -= _Np;
             if (_Np > 0)
                 _VSTD::memcpy(__end2, __begin1, _Np * sizeof(_Tp));
         }
 
 private:
 
     _LIBCPP_INLINE_VISIBILITY
     static pointer __allocate(allocator_type& __a, size_type __n,
         const_void_pointer __hint, true_type)
         {return __a.allocate(__n, __hint);}
     _LIBCPP_INLINE_VISIBILITY
     static pointer __allocate(allocator_type& __a, size_type __n,
         const_void_pointer, false_type)
         {return __a.allocate(__n);}
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class _Tp, class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         static void __construct(true_type, allocator_type& __a, _Tp* __p, _Args&&... __args)
             {__a.construct(__p, _VSTD::forward<_Args>(__args)...);}
     template <class _Tp, class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         static void __construct(false_type, allocator_type&, _Tp* __p, _Args&&... __args)
             {
                 ::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...);
             }
 #else  // _LIBCPP_HAS_NO_VARIADICS
     template <class _Tp, class _A0>
         _LIBCPP_INLINE_VISIBILITY
         static void __construct(true_type, allocator_type& __a, _Tp* __p,
                                 const _A0& __a0)
             {__a.construct(__p, __a0);}
     template <class _Tp, class _A0>
         _LIBCPP_INLINE_VISIBILITY
         static void __construct(false_type, allocator_type&, _Tp* __p,
                                 const _A0& __a0)
             {
                 ::new ((void*)__p) _Tp(__a0);
             }
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
         static void __destroy(true_type, allocator_type& __a, _Tp* __p)
             {__a.destroy(__p);}
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
         static void __destroy(false_type, allocator_type&, _Tp* __p)
             {
                 __p->~_Tp();
             }
 
     _LIBCPP_INLINE_VISIBILITY
     static size_type __max_size(true_type, const allocator_type& __a) _NOEXCEPT
             {return __a.max_size();}
     _LIBCPP_INLINE_VISIBILITY
     static size_type __max_size(false_type, const allocator_type&) _NOEXCEPT
             {return numeric_limits<size_type>::max() / sizeof(value_type);}
 
     _LIBCPP_INLINE_VISIBILITY
     static allocator_type
         __select_on_container_copy_construction(true_type, const allocator_type& __a)
             {return __a.select_on_container_copy_construction();}
     _LIBCPP_INLINE_VISIBILITY
     static allocator_type
         __select_on_container_copy_construction(false_type, const allocator_type& __a)
             {return __a;}
 };
 
 template <class _Traits, class _Tp>
 struct __rebind_alloc_helper
 {
 #ifndef _LIBCPP_CXX03_LANG
     typedef _LIBCPP_NODEBUG_TYPE typename _Traits::template rebind_alloc<_Tp>        type;
 #else
     typedef typename _Traits::template rebind_alloc<_Tp>::other type;
 #endif
 };
 
 // allocator
 
 template <class _Tp>
 class _LIBCPP_TEMPLATE_VIS allocator
 {
 public:
     typedef size_t            size_type;
     typedef ptrdiff_t         difference_type;
     typedef _Tp*              pointer;
     typedef const _Tp*        const_pointer;
     typedef _Tp&              reference;
     typedef const _Tp&        const_reference;
     typedef _Tp               value_type;
 
     typedef true_type propagate_on_container_move_assignment;
     typedef true_type is_always_equal;
 
     template <class _Up> struct rebind {typedef allocator<_Up> other;};
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator() _NOEXCEPT {}
 
     template <class _Up>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator(const allocator<_Up>&) _NOEXCEPT {}
 
     _LIBCPP_INLINE_VISIBILITY pointer address(reference __x) const _NOEXCEPT
         {return _VSTD::addressof(__x);}
     _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT
         {return _VSTD::addressof(__x);}
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
         {
         if (__n > max_size())
             __throw_length_error("allocator<T>::allocate(size_t n)"
                                  " 'n' exceeds maximum supported size");
         return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
         }
     _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) _NOEXCEPT
         {_VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));}
     _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
         {return size_type(~0) / sizeof(_Tp);}
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     template <class _Up, class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(_Up* __p, _Args&&... __args)
         {
             ::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);
         }
 #else  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(pointer __p)
         {
             ::new((void*)__p) _Tp();
         }
 # if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
 
     template <class _A0>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(pointer __p, _A0& __a0)
         {
             ::new((void*)__p) _Tp(__a0);
         }
     template <class _A0>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(pointer __p, const _A0& __a0)
         {
             ::new((void*)__p) _Tp(__a0);
         }
 # endif  // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
     template <class _A0, class _A1>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(pointer __p, _A0& __a0, _A1& __a1)
         {
             ::new((void*)__p) _Tp(__a0, __a1);
         }
     template <class _A0, class _A1>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(pointer __p, const _A0& __a0, _A1& __a1)
         {
             ::new((void*)__p) _Tp(__a0, __a1);
         }
     template <class _A0, class _A1>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(pointer __p, _A0& __a0, const _A1& __a1)
         {
             ::new((void*)__p) _Tp(__a0, __a1);
         }
     template <class _A0, class _A1>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(pointer __p, const _A0& __a0, const _A1& __a1)
         {
             ::new((void*)__p) _Tp(__a0, __a1);
         }
 #endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     _LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();}
 };
 
 template <class _Tp>
 class _LIBCPP_TEMPLATE_VIS allocator<const _Tp>
 {
 public:
     typedef size_t            size_type;
     typedef ptrdiff_t         difference_type;
     typedef const _Tp*        pointer;
     typedef const _Tp*        const_pointer;
     typedef const _Tp&        reference;
     typedef const _Tp&        const_reference;
     typedef const _Tp         value_type;
 
     typedef true_type propagate_on_container_move_assignment;
     typedef true_type is_always_equal;
 
     template <class _Up> struct rebind {typedef allocator<_Up> other;};
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator() _NOEXCEPT {}
 
     template <class _Up>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator(const allocator<_Up>&) _NOEXCEPT {}
 
     _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT
         {return _VSTD::addressof(__x);}
     _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
     {
         if (__n > max_size())
             __throw_length_error("allocator<const T>::allocate(size_t n)"
                                  " 'n' exceeds maximum supported size");
         return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
     }
     _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) _NOEXCEPT
         {_VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));}
     _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
         {return size_type(~0) / sizeof(_Tp);}
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     template <class _Up, class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(_Up* __p, _Args&&... __args)
         {
             ::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);
         }
 #else  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(pointer __p)
         {
             ::new((void*) const_cast<_Tp *>(__p)) _Tp();
         }
 # if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
 
     template <class _A0>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(pointer __p, _A0& __a0)
         {
             ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0);
         }
     template <class _A0>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(pointer __p, const _A0& __a0)
         {
             ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0);
         }
 # endif  // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
     template <class _A0, class _A1>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(pointer __p, _A0& __a0, _A1& __a1)
         {
             ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1);
         }
     template <class _A0, class _A1>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(pointer __p, const _A0& __a0, _A1& __a1)
         {
             ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1);
         }
     template <class _A0, class _A1>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(pointer __p, _A0& __a0, const _A1& __a1)
         {
             ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1);
         }
     template <class _A0, class _A1>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(pointer __p, const _A0& __a0, const _A1& __a1)
         {
             ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1);
         }
 #endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     _LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();}
 };
 
 template <class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 bool operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return true;}
 
 template <class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return false;}
 
 template <class _OutputIterator, class _Tp>
 class _LIBCPP_TEMPLATE_VIS raw_storage_iterator
     : public iterator<output_iterator_tag,
                       _Tp,                                         // purposefully not C++03
                       ptrdiff_t,                                   // purposefully not C++03
                       _Tp*,                                        // purposefully not C++03
                       raw_storage_iterator<_OutputIterator, _Tp>&> // purposefully not C++03
 {
 private:
     _OutputIterator __x_;
 public:
     _LIBCPP_INLINE_VISIBILITY explicit raw_storage_iterator(_OutputIterator __x) : __x_(__x) {}
     _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator*() {return *this;}
     _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(const _Tp& __element)
         {::new(_VSTD::addressof(*__x_)) _Tp(__element); return *this;}
 #if _LIBCPP_STD_VER >= 14
     _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(_Tp&& __element)
         {::new(_VSTD::addressof(*__x_)) _Tp(_VSTD::move(__element)); return *this;}
 #endif
     _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator++() {++__x_; return *this;}
     _LIBCPP_INLINE_VISIBILITY raw_storage_iterator  operator++(int)
         {raw_storage_iterator __t(*this); ++__x_; return __t;}
 #if _LIBCPP_STD_VER >= 14
     _LIBCPP_INLINE_VISIBILITY _OutputIterator base() const { return __x_; }
 #endif
 };
 
 template <class _Tp>
 _LIBCPP_NODISCARD_EXT _LIBCPP_NO_CFI
 pair<_Tp*, ptrdiff_t>
 get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT
 {
     pair<_Tp*, ptrdiff_t> __r(0, 0);
     const ptrdiff_t __m = (~ptrdiff_t(0) ^
                            ptrdiff_t(ptrdiff_t(1) << (sizeof(ptrdiff_t) * __CHAR_BIT__ - 1)))
                            / sizeof(_Tp);
     if (__n > __m)
         __n = __m;
     while (__n > 0)
     {
 #if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
     if (__is_overaligned_for_new(_LIBCPP_ALIGNOF(_Tp)))
         {
             std::align_val_t __al =
                 std::align_val_t(std::alignment_of<_Tp>::value);
             __r.first = static_cast<_Tp*>(::operator new(
                 __n * sizeof(_Tp), __al, nothrow));
         } else {
             __r.first = static_cast<_Tp*>(::operator new(
                 __n * sizeof(_Tp), nothrow));
         }
 #else
     if (__is_overaligned_for_new(_LIBCPP_ALIGNOF(_Tp)))
         {
             // Since aligned operator new is unavailable, return an empty
             // buffer rather than one with invalid alignment.
             return __r;
         }
 
         __r.first = static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), nothrow));
 #endif
 
         if (__r.first)
         {
             __r.second = __n;
             break;
         }
         __n /= 2;
     }
     return __r;
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 void return_temporary_buffer(_Tp* __p) _NOEXCEPT
 {
   _VSTD::__libcpp_deallocate_unsized((void*)__p, _LIBCPP_ALIGNOF(_Tp));
 }
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
 template <class _Tp>
 struct _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr_ref
 {
     _Tp* __ptr_;
 };
 
 template<class _Tp>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr
 {
 private:
     _Tp* __ptr_;
 public:
     typedef _Tp element_type;
 
-    _LIBCPP_INLINE_VISIBILITY explicit auto_ptr(_Tp* __p = 0) throw() : __ptr_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr& __p) throw() : __ptr_(__p.release()) {}
-    template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr<_Up>& __p) throw()
+    _LIBCPP_INLINE_VISIBILITY explicit auto_ptr(_Tp* __p = 0) _NOEXCEPT : __ptr_(__p) {}
+    _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr& __p) _NOEXCEPT : __ptr_(__p.release()) {}
+    template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr<_Up>& __p) _NOEXCEPT
         : __ptr_(__p.release()) {}
-    _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr& __p) throw()
+    _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr& __p) _NOEXCEPT
         {reset(__p.release()); return *this;}
-    template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr<_Up>& __p) throw()
+    template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr<_Up>& __p) _NOEXCEPT
         {reset(__p.release()); return *this;}
-    _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr_ref<_Tp> __p) throw()
+    _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr_ref<_Tp> __p) _NOEXCEPT
         {reset(__p.__ptr_); return *this;}
-    _LIBCPP_INLINE_VISIBILITY ~auto_ptr() throw() {delete __ptr_;}
+    _LIBCPP_INLINE_VISIBILITY ~auto_ptr() _NOEXCEPT {delete __ptr_;}
 
-    _LIBCPP_INLINE_VISIBILITY _Tp& operator*() const throw()
+    _LIBCPP_INLINE_VISIBILITY _Tp& operator*() const _NOEXCEPT
         {return *__ptr_;}
-    _LIBCPP_INLINE_VISIBILITY _Tp* operator->() const throw() {return __ptr_;}
-    _LIBCPP_INLINE_VISIBILITY _Tp* get() const throw() {return __ptr_;}
-    _LIBCPP_INLINE_VISIBILITY _Tp* release() throw()
+    _LIBCPP_INLINE_VISIBILITY _Tp* operator->() const _NOEXCEPT {return __ptr_;}
+    _LIBCPP_INLINE_VISIBILITY _Tp* get() const _NOEXCEPT {return __ptr_;}
+    _LIBCPP_INLINE_VISIBILITY _Tp* release() _NOEXCEPT
     {
         _Tp* __t = __ptr_;
         __ptr_ = 0;
         return __t;
     }
-    _LIBCPP_INLINE_VISIBILITY void reset(_Tp* __p = 0) throw()
+    _LIBCPP_INLINE_VISIBILITY void reset(_Tp* __p = 0) _NOEXCEPT
     {
         if (__ptr_ != __p)
             delete __ptr_;
         __ptr_ = __p;
     }
 
-    _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr_ref<_Tp> __p) throw() : __ptr_(__p.__ptr_) {}
-    template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr_ref<_Up>() throw()
+    _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr_ref<_Tp> __p) _NOEXCEPT : __ptr_(__p.__ptr_) {}
+    template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr_ref<_Up>() _NOEXCEPT
         {auto_ptr_ref<_Up> __t; __t.__ptr_ = release(); return __t;}
-    template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr<_Up>() throw()
+    template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr<_Up>() _NOEXCEPT
         {return auto_ptr<_Up>(release());}
 };
 
 template <>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr<void>
 {
 public:
     typedef void element_type;
 };
 #endif
 
 // Tag used to default initialize one or both of the pair's elements.
 struct __default_init_tag {};
 struct __value_init_tag {};
 
 template <class _Tp, int _Idx,
           bool _CanBeEmptyBase =
               is_empty<_Tp>::value && !__libcpp_is_final<_Tp>::value>
 struct __compressed_pair_elem {
   typedef _Tp _ParamT;
   typedef _Tp& reference;
   typedef const _Tp& const_reference;
 
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
   __compressed_pair_elem(__default_init_tag) {}
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
   __compressed_pair_elem(__value_init_tag) : __value_() {}
 
   template <class _Up, class = typename enable_if<
       !is_same<__compressed_pair_elem, typename decay<_Up>::type>::value
   >::type>
   _LIBCPP_INLINE_VISIBILITY
   _LIBCPP_CONSTEXPR explicit
   __compressed_pair_elem(_Up&& __u)
       : __value_(_VSTD::forward<_Up>(__u))
     {
     }
 
 
 #ifndef _LIBCPP_CXX03_LANG
   template <class... _Args, size_t... _Indexes>
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
   __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args,
                          __tuple_indices<_Indexes...>)
       : __value_(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {}
 #endif
 
 
   _LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return __value_; }
   _LIBCPP_INLINE_VISIBILITY
   const_reference __get() const _NOEXCEPT { return __value_; }
 
 private:
   _Tp __value_;
 };
 
 template <class _Tp, int _Idx>
 struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp {
   typedef _Tp _ParamT;
   typedef _Tp& reference;
   typedef const _Tp& const_reference;
   typedef _Tp __value_type;
 
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __compressed_pair_elem() = default;
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
   __compressed_pair_elem(__default_init_tag) {}
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
   __compressed_pair_elem(__value_init_tag) : __value_type() {}
 
   template <class _Up, class = typename enable_if<
         !is_same<__compressed_pair_elem, typename decay<_Up>::type>::value
   >::type>
   _LIBCPP_INLINE_VISIBILITY
   _LIBCPP_CONSTEXPR explicit
   __compressed_pair_elem(_Up&& __u)
       : __value_type(_VSTD::forward<_Up>(__u))
   {}
 
 #ifndef _LIBCPP_CXX03_LANG
   template <class... _Args, size_t... _Indexes>
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
   __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args,
                          __tuple_indices<_Indexes...>)
       : __value_type(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {}
 #endif
 
   _LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return *this; }
   _LIBCPP_INLINE_VISIBILITY
   const_reference __get() const _NOEXCEPT { return *this; }
 };
 
 template <class _T1, class _T2>
 class __compressed_pair : private __compressed_pair_elem<_T1, 0>,
                           private __compressed_pair_elem<_T2, 1> {
   typedef _LIBCPP_NODEBUG_TYPE __compressed_pair_elem<_T1, 0> _Base1;
   typedef _LIBCPP_NODEBUG_TYPE __compressed_pair_elem<_T2, 1> _Base2;
 
   // NOTE: This static assert should never fire because __compressed_pair
   // is *almost never* used in a scenario where it's possible for T1 == T2.
   // (The exception is std::function where it is possible that the function
   //  object and the allocator have the same type).
   static_assert((!is_same<_T1, _T2>::value),
     "__compressed_pair cannot be instantated when T1 and T2 are the same type; "
     "The current implementation is NOT ABI-compatible with the previous "
     "implementation for this configuration");
 
 public:
     template <bool _Dummy = true,
       class = typename enable_if<
           __dependent_type<is_default_constructible<_T1>, _Dummy>::value &&
           __dependent_type<is_default_constructible<_T2>, _Dummy>::value
       >::type
   >
   _LIBCPP_INLINE_VISIBILITY
   _LIBCPP_CONSTEXPR __compressed_pair() : _Base1(__value_init_tag()), _Base2(__value_init_tag()) {}
 
   template <class _U1, class _U2>
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
   __compressed_pair(_U1&& __t1, _U2&& __t2)
       : _Base1(std::forward<_U1>(__t1)), _Base2(std::forward<_U2>(__t2)) {}
 
 #ifndef _LIBCPP_CXX03_LANG
   template <class... _Args1, class... _Args2>
   _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
   __compressed_pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,
                     tuple<_Args2...> __second_args)
       : _Base1(__pc, _VSTD::move(__first_args),
                typename __make_tuple_indices<sizeof...(_Args1)>::type()),
         _Base2(__pc, _VSTD::move(__second_args),
                typename __make_tuple_indices<sizeof...(_Args2)>::type()) {}
 #endif
 
   _LIBCPP_INLINE_VISIBILITY
   typename _Base1::reference first() _NOEXCEPT {
     return static_cast<_Base1&>(*this).__get();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   typename _Base1::const_reference first() const _NOEXCEPT {
     return static_cast<_Base1 const&>(*this).__get();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   typename _Base2::reference second() _NOEXCEPT {
     return static_cast<_Base2&>(*this).__get();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   typename _Base2::const_reference second() const _NOEXCEPT {
     return static_cast<_Base2 const&>(*this).__get();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void swap(__compressed_pair& __x)
     _NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
                __is_nothrow_swappable<_T2>::value)
   {
     using std::swap;
     swap(first(), __x.first());
     swap(second(), __x.second());
   }
 };
 
 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY
 void swap(__compressed_pair<_T1, _T2>& __x, __compressed_pair<_T1, _T2>& __y)
     _NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
                __is_nothrow_swappable<_T2>::value) {
   __x.swap(__y);
 }
 
 // default_delete
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS default_delete {
     static_assert(!is_function<_Tp>::value,
                   "default_delete cannot be instantiated for function types");
 #ifndef _LIBCPP_CXX03_LANG
   _LIBCPP_INLINE_VISIBILITY constexpr default_delete() _NOEXCEPT = default;
 #else
   _LIBCPP_INLINE_VISIBILITY default_delete() {}
 #endif
   template <class _Up>
   _LIBCPP_INLINE_VISIBILITY
   default_delete(const default_delete<_Up>&,
                  typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* =
                      0) _NOEXCEPT {}
 
   _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __ptr) const _NOEXCEPT {
     static_assert(sizeof(_Tp) > 0,
                   "default_delete can not delete incomplete type");
     static_assert(!is_void<_Tp>::value,
                   "default_delete can not delete incomplete type");
     delete __ptr;
   }
 };
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS default_delete<_Tp[]> {
 private:
   template <class _Up>
   struct _EnableIfConvertible
       : enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value> {};
 
 public:
 #ifndef _LIBCPP_CXX03_LANG
   _LIBCPP_INLINE_VISIBILITY constexpr default_delete() _NOEXCEPT = default;
 #else
   _LIBCPP_INLINE_VISIBILITY default_delete() {}
 #endif
 
   template <class _Up>
   _LIBCPP_INLINE_VISIBILITY
   default_delete(const default_delete<_Up[]>&,
                  typename _EnableIfConvertible<_Up>::type* = 0) _NOEXCEPT {}
 
   template <class _Up>
   _LIBCPP_INLINE_VISIBILITY
   typename _EnableIfConvertible<_Up>::type
   operator()(_Up* __ptr) const _NOEXCEPT {
     static_assert(sizeof(_Tp) > 0,
                   "default_delete can not delete incomplete type");
     static_assert(!is_void<_Tp>::value,
                   "default_delete can not delete void type");
     delete[] __ptr;
   }
 };
 
 template <class _Deleter>
 struct __unique_ptr_deleter_sfinae {
   static_assert(!is_reference<_Deleter>::value, "incorrect specialization");
   typedef const _Deleter& __lval_ref_type;
   typedef _Deleter&& __good_rval_ref_type;
   typedef true_type __enable_rval_overload;
 };
 
 template <class _Deleter>
 struct __unique_ptr_deleter_sfinae<_Deleter const&> {
   typedef const _Deleter& __lval_ref_type;
   typedef const _Deleter&& __bad_rval_ref_type;
   typedef false_type __enable_rval_overload;
 };
 
 template <class _Deleter>
 struct __unique_ptr_deleter_sfinae<_Deleter&> {
   typedef _Deleter& __lval_ref_type;
   typedef _Deleter&& __bad_rval_ref_type;
   typedef false_type __enable_rval_overload;
 };
 
 template <class _Tp, class _Dp = default_delete<_Tp> >
 class _LIBCPP_TEMPLATE_VIS unique_ptr {
 public:
   typedef _Tp element_type;
   typedef _Dp deleter_type;
   typedef _LIBCPP_NODEBUG_TYPE typename __pointer_type<_Tp, deleter_type>::type pointer;
 
   static_assert(!is_rvalue_reference<deleter_type>::value,
                 "the specified deleter type cannot be an rvalue reference");
 
 private:
   __compressed_pair<pointer, deleter_type> __ptr_;
 
   struct __nat { int __for_bool_; };
 
   typedef _LIBCPP_NODEBUG_TYPE __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE;
 
   template <bool _Dummy>
   using _LValRefType _LIBCPP_NODEBUG_TYPE =
       typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type;
 
   template <bool _Dummy>
   using _GoodRValRefType _LIBCPP_NODEBUG_TYPE =
       typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type;
 
   template <bool _Dummy>
   using _BadRValRefType _LIBCPP_NODEBUG_TYPE  =
       typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type;
 
   template <bool _Dummy, class _Deleter = typename __dependent_type<
                              __identity<deleter_type>, _Dummy>::type>
   using _EnableIfDeleterDefaultConstructible _LIBCPP_NODEBUG_TYPE =
       typename enable_if<is_default_constructible<_Deleter>::value &&
                          !is_pointer<_Deleter>::value>::type;
 
   template <class _ArgType>
   using _EnableIfDeleterConstructible _LIBCPP_NODEBUG_TYPE  =
       typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type;
 
   template <class _UPtr, class _Up>
   using _EnableIfMoveConvertible _LIBCPP_NODEBUG_TYPE  = typename enable_if<
       is_convertible<typename _UPtr::pointer, pointer>::value &&
       !is_array<_Up>::value
   >::type;
 
   template <class _UDel>
   using _EnableIfDeleterConvertible _LIBCPP_NODEBUG_TYPE  = typename enable_if<
       (is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) ||
       (!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value)
     >::type;
 
   template <class _UDel>
   using _EnableIfDeleterAssignable = typename enable_if<
       is_assignable<_Dp&, _UDel&&>::value
     >::type;
 
 public:
   template <bool _Dummy = true,
             class = _EnableIfDeleterDefaultConstructible<_Dummy> >
   _LIBCPP_INLINE_VISIBILITY
   _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(pointer(), __default_init_tag()) {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterDefaultConstructible<_Dummy> >
   _LIBCPP_INLINE_VISIBILITY
   _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(pointer(), __default_init_tag()) {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterDefaultConstructible<_Dummy> >
   _LIBCPP_INLINE_VISIBILITY
   explicit unique_ptr(pointer __p) _NOEXCEPT : __ptr_(__p, __default_init_tag()) {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(pointer __p, _LValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(__p, __d) {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> > >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(pointer __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(__p, _VSTD::move(__d)) {
     static_assert(!is_reference<deleter_type>::value,
                   "rvalue deleter bound to reference");
   }
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> > >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(pointer __p, _BadRValRefType<_Dummy> __d) = delete;
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(unique_ptr&& __u) _NOEXCEPT
       : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterConvertible<_Ep>
   >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
       : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {}
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
   template <class _Up>
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(auto_ptr<_Up>&& __p,
              typename enable_if<is_convertible<_Up*, _Tp*>::value &&
                                     is_same<_Dp, default_delete<_Tp> >::value,
                                 __nat>::type = __nat()) _NOEXCEPT
       : __ptr_(__p.release(), __default_init_tag()) {}
 #endif
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
     reset(__u.release());
     __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
     return *this;
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterAssignable<_Ep>
   >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
     reset(__u.release());
     __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
     return *this;
   }
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
   template <class _Up>
   _LIBCPP_INLINE_VISIBILITY
       typename enable_if<is_convertible<_Up*, _Tp*>::value &&
                              is_same<_Dp, default_delete<_Tp> >::value,
                          unique_ptr&>::type
       operator=(auto_ptr<_Up> __p) {
     reset(__p.release());
     return *this;
   }
 #endif
 
 #ifdef _LIBCPP_CXX03_LANG
   unique_ptr(unique_ptr const&) = delete;
   unique_ptr& operator=(unique_ptr const&) = delete;
 #endif
 
 
   _LIBCPP_INLINE_VISIBILITY
   ~unique_ptr() { reset(); }
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(nullptr_t) _NOEXCEPT {
     reset();
     return *this;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   typename add_lvalue_reference<_Tp>::type
   operator*() const {
     return *__ptr_.first();
   }
   _LIBCPP_INLINE_VISIBILITY
   pointer operator->() const _NOEXCEPT {
     return __ptr_.first();
   }
   _LIBCPP_INLINE_VISIBILITY
   pointer get() const _NOEXCEPT {
     return __ptr_.first();
   }
   _LIBCPP_INLINE_VISIBILITY
   deleter_type& get_deleter() _NOEXCEPT {
     return __ptr_.second();
   }
   _LIBCPP_INLINE_VISIBILITY
   const deleter_type& get_deleter() const _NOEXCEPT {
     return __ptr_.second();
   }
   _LIBCPP_INLINE_VISIBILITY
   _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {
     return __ptr_.first() != nullptr;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   pointer release() _NOEXCEPT {
     pointer __t = __ptr_.first();
     __ptr_.first() = pointer();
     return __t;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void reset(pointer __p = pointer()) _NOEXCEPT {
     pointer __tmp = __ptr_.first();
     __ptr_.first() = __p;
     if (__tmp)
       __ptr_.second()(__tmp);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void swap(unique_ptr& __u) _NOEXCEPT {
     __ptr_.swap(__u.__ptr_);
   }
 };
 
 
 template <class _Tp, class _Dp>
 class _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp> {
 public:
   typedef _Tp element_type;
   typedef _Dp deleter_type;
   typedef typename __pointer_type<_Tp, deleter_type>::type pointer;
 
 private:
   __compressed_pair<pointer, deleter_type> __ptr_;
 
   template <class _From>
   struct _CheckArrayPointerConversion : is_same<_From, pointer> {};
 
   template <class _FromElem>
   struct _CheckArrayPointerConversion<_FromElem*>
       : integral_constant<bool,
           is_same<_FromElem*, pointer>::value ||
             (is_same<pointer, element_type*>::value &&
              is_convertible<_FromElem(*)[], element_type(*)[]>::value)
       >
   {};
 
   typedef __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE;
 
   template <bool _Dummy>
   using _LValRefType _LIBCPP_NODEBUG_TYPE =
       typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type;
 
   template <bool _Dummy>
   using _GoodRValRefType _LIBCPP_NODEBUG_TYPE =
       typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type;
 
   template <bool _Dummy>
   using _BadRValRefType _LIBCPP_NODEBUG_TYPE =
       typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type;
 
   template <bool _Dummy, class _Deleter = typename __dependent_type<
                              __identity<deleter_type>, _Dummy>::type>
   using _EnableIfDeleterDefaultConstructible _LIBCPP_NODEBUG_TYPE  =
       typename enable_if<is_default_constructible<_Deleter>::value &&
                          !is_pointer<_Deleter>::value>::type;
 
   template <class _ArgType>
   using _EnableIfDeleterConstructible _LIBCPP_NODEBUG_TYPE  =
       typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type;
 
   template <class _Pp>
   using _EnableIfPointerConvertible _LIBCPP_NODEBUG_TYPE  = typename enable_if<
       _CheckArrayPointerConversion<_Pp>::value
   >::type;
 
   template <class _UPtr, class _Up,
         class _ElemT = typename _UPtr::element_type>
   using _EnableIfMoveConvertible _LIBCPP_NODEBUG_TYPE  = typename enable_if<
       is_array<_Up>::value &&
       is_same<pointer, element_type*>::value &&
       is_same<typename _UPtr::pointer, _ElemT*>::value &&
       is_convertible<_ElemT(*)[], element_type(*)[]>::value
     >::type;
 
   template <class _UDel>
   using _EnableIfDeleterConvertible _LIBCPP_NODEBUG_TYPE  = typename enable_if<
       (is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) ||
       (!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value)
     >::type;
 
   template <class _UDel>
   using _EnableIfDeleterAssignable _LIBCPP_NODEBUG_TYPE  = typename enable_if<
       is_assignable<_Dp&, _UDel&&>::value
     >::type;
 
 public:
   template <bool _Dummy = true,
             class = _EnableIfDeleterDefaultConstructible<_Dummy> >
   _LIBCPP_INLINE_VISIBILITY
   _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(pointer(), __default_init_tag()) {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterDefaultConstructible<_Dummy> >
   _LIBCPP_INLINE_VISIBILITY
   _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(pointer(), __default_init_tag()) {}
 
   template <class _Pp, bool _Dummy = true,
             class = _EnableIfDeleterDefaultConstructible<_Dummy>,
             class = _EnableIfPointerConvertible<_Pp> >
   _LIBCPP_INLINE_VISIBILITY
   explicit unique_ptr(_Pp __p) _NOEXCEPT
       : __ptr_(__p, __default_init_tag()) {}
 
   template <class _Pp, bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> >,
             class = _EnableIfPointerConvertible<_Pp> >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(_Pp __p, _LValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(__p, __d) {}
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(nullptr_t, _LValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(nullptr, __d) {}
 
   template <class _Pp, bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> >,
             class = _EnableIfPointerConvertible<_Pp> >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(_Pp __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(__p, _VSTD::move(__d)) {
     static_assert(!is_reference<deleter_type>::value,
                   "rvalue deleter bound to reference");
   }
 
   template <bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> > >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(nullptr_t, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(nullptr, _VSTD::move(__d)) {
     static_assert(!is_reference<deleter_type>::value,
                   "rvalue deleter bound to reference");
   }
 
   template <class _Pp, bool _Dummy = true,
             class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> >,
             class = _EnableIfPointerConvertible<_Pp> >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(_Pp __p, _BadRValRefType<_Dummy> __d) = delete;
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(unique_ptr&& __u) _NOEXCEPT
       : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {
   }
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
     reset(__u.release());
     __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
     return *this;
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterConvertible<_Ep>
   >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
       : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {
   }
 
   template <class _Up, class _Ep,
       class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
       class = _EnableIfDeleterAssignable<_Ep>
   >
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr&
   operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
     reset(__u.release());
     __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
     return *this;
   }
 
 #ifdef _LIBCPP_CXX03_LANG
   unique_ptr(unique_ptr const&) = delete;
   unique_ptr& operator=(unique_ptr const&) = delete;
 #endif
 
 public:
   _LIBCPP_INLINE_VISIBILITY
   ~unique_ptr() { reset(); }
 
   _LIBCPP_INLINE_VISIBILITY
   unique_ptr& operator=(nullptr_t) _NOEXCEPT {
     reset();
     return *this;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   typename add_lvalue_reference<_Tp>::type
   operator[](size_t __i) const {
     return __ptr_.first()[__i];
   }
   _LIBCPP_INLINE_VISIBILITY
   pointer get() const _NOEXCEPT {
     return __ptr_.first();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   deleter_type& get_deleter() _NOEXCEPT {
     return __ptr_.second();
   }
 
   _LIBCPP_INLINE_VISIBILITY
   const deleter_type& get_deleter() const _NOEXCEPT {
     return __ptr_.second();
   }
   _LIBCPP_INLINE_VISIBILITY
   _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {
     return __ptr_.first() != nullptr;
   }
 
   _LIBCPP_INLINE_VISIBILITY
   pointer release() _NOEXCEPT {
     pointer __t = __ptr_.first();
     __ptr_.first() = pointer();
     return __t;
   }
 
   template <class _Pp>
   _LIBCPP_INLINE_VISIBILITY
   typename enable_if<
       _CheckArrayPointerConversion<_Pp>::value
   >::type
   reset(_Pp __p) _NOEXCEPT {
     pointer __tmp = __ptr_.first();
     __ptr_.first() = __p;
     if (__tmp)
       __ptr_.second()(__tmp);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void reset(nullptr_t = nullptr) _NOEXCEPT {
     pointer __tmp = __ptr_.first();
     __ptr_.first() = nullptr;
     if (__tmp)
       __ptr_.second()(__tmp);
   }
 
   _LIBCPP_INLINE_VISIBILITY
   void swap(unique_ptr& __u) _NOEXCEPT {
     __ptr_.swap(__u.__ptr_);
   }
 
 };
 
 template <class _Tp, class _Dp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if<
     __is_swappable<_Dp>::value,
     void
 >::type
 swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) _NOEXCEPT {__x.swap(__y);}
 
 template <class _T1, class _D1, class _T2, class _D2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __x.get() == __y.get();}
 
 template <class _T1, class _D1, class _T2, class _D2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x == __y);}
 
 template <class _T1, class _D1, class _T2, class _D2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator< (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y)
 {
     typedef typename unique_ptr<_T1, _D1>::pointer _P1;
     typedef typename unique_ptr<_T2, _D2>::pointer _P2;
     typedef typename common_type<_P1, _P2>::type _Vp;
     return less<_Vp>()(__x.get(), __y.get());
 }
 
 template <class _T1, class _D1, class _T2, class _D2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator> (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __y < __x;}
 
 template <class _T1, class _D1, class _T2, class _D2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__y < __x);}
 
 template <class _T1, class _D1, class _T2, class _D2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x < __y);}
 
 template <class _T1, class _D1>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT
 {
     return !__x;
 }
 
 template <class _T1, class _D1>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT
 {
     return !__x;
 }
 
 template <class _T1, class _D1>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT
 {
     return static_cast<bool>(__x);
 }
 
 template <class _T1, class _D1>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT
 {
     return static_cast<bool>(__x);
 }
 
 template <class _T1, class _D1>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<(const unique_ptr<_T1, _D1>& __x, nullptr_t)
 {
     typedef typename unique_ptr<_T1, _D1>::pointer _P1;
     return less<_P1>()(__x.get(), nullptr);
 }
 
 template <class _T1, class _D1>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<(nullptr_t, const unique_ptr<_T1, _D1>& __x)
 {
     typedef typename unique_ptr<_T1, _D1>::pointer _P1;
     return less<_P1>()(nullptr, __x.get());
 }
 
 template <class _T1, class _D1>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>(const unique_ptr<_T1, _D1>& __x, nullptr_t)
 {
     return nullptr < __x;
 }
 
 template <class _T1, class _D1>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>(nullptr_t, const unique_ptr<_T1, _D1>& __x)
 {
     return __x < nullptr;
 }
 
 template <class _T1, class _D1>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const unique_ptr<_T1, _D1>& __x, nullptr_t)
 {
     return !(nullptr < __x);
 }
 
 template <class _T1, class _D1>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(nullptr_t, const unique_ptr<_T1, _D1>& __x)
 {
     return !(__x < nullptr);
 }
 
 template <class _T1, class _D1>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const unique_ptr<_T1, _D1>& __x, nullptr_t)
 {
     return !(__x < nullptr);
 }
 
 template <class _T1, class _D1>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __x)
 {
     return !(nullptr < __x);
 }
 
 #if _LIBCPP_STD_VER > 11
 
 template<class _Tp>
 struct __unique_if
 {
     typedef unique_ptr<_Tp> __unique_single;
 };
 
 template<class _Tp>
 struct __unique_if<_Tp[]>
 {
     typedef unique_ptr<_Tp[]> __unique_array_unknown_bound;
 };
 
 template<class _Tp, size_t _Np>
 struct __unique_if<_Tp[_Np]>
 {
     typedef void __unique_array_known_bound;
 };
 
 template<class _Tp, class... _Args>
 inline _LIBCPP_INLINE_VISIBILITY
 typename __unique_if<_Tp>::__unique_single
 make_unique(_Args&&... __args)
 {
     return unique_ptr<_Tp>(new _Tp(_VSTD::forward<_Args>(__args)...));
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename __unique_if<_Tp>::__unique_array_unknown_bound
 make_unique(size_t __n)
 {
     typedef typename remove_extent<_Tp>::type _Up;
     return unique_ptr<_Tp>(new _Up[__n]());
 }
 
 template<class _Tp, class... _Args>
     typename __unique_if<_Tp>::__unique_array_known_bound
     make_unique(_Args&&...) = delete;
 
 #endif  // _LIBCPP_STD_VER > 11
 
 template <class _Tp, class _Dp>
 #ifdef _LIBCPP_CXX03_LANG
 struct _LIBCPP_TEMPLATE_VIS hash<unique_ptr<_Tp, _Dp> >
 #else
 struct _LIBCPP_TEMPLATE_VIS hash<__enable_hash_helper<
     unique_ptr<_Tp, _Dp>, typename unique_ptr<_Tp, _Dp>::pointer> >
 #endif
 {
     typedef unique_ptr<_Tp, _Dp> argument_type;
     typedef size_t               result_type;
     _LIBCPP_INLINE_VISIBILITY
     result_type operator()(const argument_type& __ptr) const
     {
         typedef typename argument_type::pointer pointer;
         return hash<pointer>()(__ptr.get());
     }
 };
 
 struct __destruct_n
 {
 private:
     size_t __size_;
 
     template <class _Tp>
     _LIBCPP_INLINE_VISIBILITY void __process(_Tp* __p, false_type) _NOEXCEPT
         {for (size_t __i = 0; __i < __size_; ++__i, ++__p) __p->~_Tp();}
 
     template <class _Tp>
     _LIBCPP_INLINE_VISIBILITY void __process(_Tp*, true_type) _NOEXCEPT
         {}
 
     _LIBCPP_INLINE_VISIBILITY void __incr(false_type) _NOEXCEPT
         {++__size_;}
     _LIBCPP_INLINE_VISIBILITY void __incr(true_type) _NOEXCEPT
         {}
 
     _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, false_type) _NOEXCEPT
         {__size_ = __s;}
     _LIBCPP_INLINE_VISIBILITY void __set(size_t, true_type) _NOEXCEPT
         {}
 public:
     _LIBCPP_INLINE_VISIBILITY explicit __destruct_n(size_t __s) _NOEXCEPT
         : __size_(__s) {}
 
     template <class _Tp>
     _LIBCPP_INLINE_VISIBILITY void __incr(_Tp*) _NOEXCEPT
         {__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
 
     template <class _Tp>
     _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*) _NOEXCEPT
         {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
 
     template <class _Tp>
     _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) _NOEXCEPT
         {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
 };
 
 template <class _Alloc>
 class __allocator_destructor
 {
     typedef _LIBCPP_NODEBUG_TYPE allocator_traits<_Alloc> __alloc_traits;
 public:
     typedef _LIBCPP_NODEBUG_TYPE typename __alloc_traits::pointer pointer;
     typedef _LIBCPP_NODEBUG_TYPE typename __alloc_traits::size_type size_type;
 private:
     _Alloc& __alloc_;
     size_type __s_;
 public:
     _LIBCPP_INLINE_VISIBILITY __allocator_destructor(_Alloc& __a, size_type __s)
              _NOEXCEPT
         : __alloc_(__a), __s_(__s) {}
     _LIBCPP_INLINE_VISIBILITY
     void operator()(pointer __p) _NOEXCEPT
         {__alloc_traits::deallocate(__alloc_, __p, __s_);}
 };
 
 template <class _InputIterator, class _ForwardIterator>
 _ForwardIterator
 uninitialized_copy(_InputIterator __f, _InputIterator __l, _ForwardIterator __r)
 {
     typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     _ForwardIterator __s = __r;
     try
     {
 #endif
         for (; __f != __l; ++__f, (void) ++__r)
             ::new (static_cast<void*>(_VSTD::addressof(*__r))) value_type(*__f);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         for (; __s != __r; ++__s)
             __s->~value_type();
         throw;
     }
 #endif
     return __r;
 }
 
 template <class _InputIterator, class _Size, class _ForwardIterator>
 _ForwardIterator
 uninitialized_copy_n(_InputIterator __f, _Size __n, _ForwardIterator __r)
 {
     typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     _ForwardIterator __s = __r;
     try
     {
 #endif
         for (; __n > 0; ++__f, (void) ++__r, (void) --__n)
             ::new (static_cast<void*>(_VSTD::addressof(*__r))) value_type(*__f);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         for (; __s != __r; ++__s)
             __s->~value_type();
         throw;
     }
 #endif
     return __r;
 }
 
 template <class _ForwardIterator, class _Tp>
 void
 uninitialized_fill(_ForwardIterator __f, _ForwardIterator __l, const _Tp& __x)
 {
     typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     _ForwardIterator __s = __f;
     try
     {
 #endif
         for (; __f != __l; ++__f)
             ::new (static_cast<void*>(_VSTD::addressof(*__f))) value_type(__x);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         for (; __s != __f; ++__s)
             __s->~value_type();
         throw;
     }
 #endif
 }
 
 template <class _ForwardIterator, class _Size, class _Tp>
 _ForwardIterator
 uninitialized_fill_n(_ForwardIterator __f, _Size __n, const _Tp& __x)
 {
     typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     _ForwardIterator __s = __f;
     try
     {
 #endif
         for (; __n > 0; ++__f, (void) --__n)
             ::new (static_cast<void*>(_VSTD::addressof(*__f))) value_type(__x);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         for (; __s != __f; ++__s)
             __s->~value_type();
         throw;
     }
 #endif
     return __f;
 }
 
 #if _LIBCPP_STD_VER > 14
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 void destroy_at(_Tp* __loc) {
     _LIBCPP_ASSERT(__loc, "null pointer given to destroy_at");
     __loc->~_Tp();
 }
 
 template <class _ForwardIterator>
 inline _LIBCPP_INLINE_VISIBILITY
 void destroy(_ForwardIterator __first, _ForwardIterator __last) {
     for (; __first != __last; ++__first)
         _VSTD::destroy_at(_VSTD::addressof(*__first));
 }
 
 template <class _ForwardIterator, class _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator destroy_n(_ForwardIterator __first, _Size __n) {
     for (; __n > 0; (void)++__first, --__n)
         _VSTD::destroy_at(_VSTD::addressof(*__first));
     return __first;
 }
 
 template <class _ForwardIterator>
 inline _LIBCPP_INLINE_VISIBILITY
 void uninitialized_default_construct(_ForwardIterator __first, _ForwardIterator __last) {
     using _Vt = typename iterator_traits<_ForwardIterator>::value_type;
     auto __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
     for (; __idx != __last; ++__idx)
         ::new((void*)_VSTD::addressof(*__idx)) _Vt;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
         _VSTD::destroy(__first, __idx);
         throw;
     }
 #endif
 }
 
 template <class _ForwardIterator, class _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) {
     using _Vt = typename iterator_traits<_ForwardIterator>::value_type;
     auto __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
     for (; __n > 0; (void)++__idx, --__n)
         ::new((void*)_VSTD::addressof(*__idx)) _Vt;
     return __idx;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
         _VSTD::destroy(__first, __idx);
         throw;
     }
 #endif
 }
 
 
 template <class _ForwardIterator>
 inline _LIBCPP_INLINE_VISIBILITY
 void uninitialized_value_construct(_ForwardIterator __first, _ForwardIterator __last) {
     using _Vt = typename iterator_traits<_ForwardIterator>::value_type;
     auto __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
     for (; __idx != __last; ++__idx)
         ::new((void*)_VSTD::addressof(*__idx)) _Vt();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
         _VSTD::destroy(__first, __idx);
         throw;
     }
 #endif
 }
 
 template <class _ForwardIterator, class _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) {
     using _Vt = typename iterator_traits<_ForwardIterator>::value_type;
     auto __idx = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
     for (; __n > 0; (void)++__idx, --__n)
         ::new((void*)_VSTD::addressof(*__idx)) _Vt();
     return __idx;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
         _VSTD::destroy(__first, __idx);
         throw;
     }
 #endif
 }
 
 
 template <class _InputIt, class _ForwardIt>
 inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIt uninitialized_move(_InputIt __first, _InputIt __last, _ForwardIt __first_res) {
     using _Vt = typename iterator_traits<_ForwardIt>::value_type;
     auto __idx = __first_res;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
     for (; __first != __last; (void)++__idx, ++__first)
         ::new((void*)_VSTD::addressof(*__idx)) _Vt(std::move(*__first));
     return __idx;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
         _VSTD::destroy(__first_res, __idx);
         throw;
     }
 #endif
 }
 
 template <class _InputIt, class _Size, class _ForwardIt>
 inline _LIBCPP_INLINE_VISIBILITY
 pair<_InputIt, _ForwardIt>
 uninitialized_move_n(_InputIt __first, _Size __n, _ForwardIt __first_res) {
     using _Vt = typename iterator_traits<_ForwardIt>::value_type;
     auto __idx = __first_res;
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try {
 #endif
     for (; __n > 0; ++__idx, (void)++__first, --__n)
         ::new((void*)_VSTD::addressof(*__idx)) _Vt(std::move(*__first));
     return {__first, __idx};
 #ifndef _LIBCPP_NO_EXCEPTIONS
     } catch (...) {
         _VSTD::destroy(__first_res, __idx);
         throw;
     }
 #endif
 }
 
 
 #endif // _LIBCPP_STD_VER > 14
 
 // NOTE: Relaxed and acq/rel atomics (for increment and decrement respectively)
 // should be sufficient for thread safety.
 // See https://bugs.llvm.org/show_bug.cgi?id=22803
 #if defined(__clang__) && __has_builtin(__atomic_add_fetch)          \
                        && defined(__ATOMIC_RELAXED)                  \
                        && defined(__ATOMIC_ACQ_REL)
 #   define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT
 #elif defined(_LIBCPP_COMPILER_GCC)
 #   define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT
 #endif
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _Tp
 __libcpp_atomic_refcount_increment(_Tp& __t) _NOEXCEPT
 {
 #if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS)
     return __atomic_add_fetch(&__t, 1, __ATOMIC_RELAXED);
 #else
     return __t += 1;
 #endif
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY _Tp
 __libcpp_atomic_refcount_decrement(_Tp& __t) _NOEXCEPT
 {
 #if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS)
     return __atomic_add_fetch(&__t, -1, __ATOMIC_ACQ_REL);
 #else
     return __t -= 1;
 #endif
 }
 
 class _LIBCPP_EXCEPTION_ABI bad_weak_ptr
     : public std::exception
 {
 public:
+    bad_weak_ptr() _NOEXCEPT = default;
+    bad_weak_ptr(const bad_weak_ptr&) _NOEXCEPT = default;
     virtual ~bad_weak_ptr() _NOEXCEPT;
     virtual const char* what() const  _NOEXCEPT;
 };
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_bad_weak_ptr()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw bad_weak_ptr();
 #else
     _VSTD::abort();
 #endif
 }
 
 template<class _Tp> class _LIBCPP_TEMPLATE_VIS weak_ptr;
 
 class _LIBCPP_TYPE_VIS __shared_count
 {
     __shared_count(const __shared_count&);
     __shared_count& operator=(const __shared_count&);
 
 protected:
     long __shared_owners_;
     virtual ~__shared_count();
 private:
     virtual void __on_zero_shared() _NOEXCEPT = 0;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __shared_count(long __refs = 0) _NOEXCEPT
         : __shared_owners_(__refs) {}
 
 #if defined(_LIBCPP_BUILDING_LIBRARY) && \
     defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
     void __add_shared() _NOEXCEPT;
     bool __release_shared() _NOEXCEPT;
 #else
     _LIBCPP_INLINE_VISIBILITY
     void __add_shared() _NOEXCEPT {
       __libcpp_atomic_refcount_increment(__shared_owners_);
     }
     _LIBCPP_INLINE_VISIBILITY
     bool __release_shared() _NOEXCEPT {
       if (__libcpp_atomic_refcount_decrement(__shared_owners_) == -1) {
         __on_zero_shared();
         return true;
       }
       return false;
     }
 #endif
     _LIBCPP_INLINE_VISIBILITY
     long use_count() const _NOEXCEPT {
         return __libcpp_relaxed_load(&__shared_owners_) + 1;
     }
 };
 
 class _LIBCPP_TYPE_VIS __shared_weak_count
     : private __shared_count
 {
     long __shared_weak_owners_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __shared_weak_count(long __refs = 0) _NOEXCEPT
         : __shared_count(__refs),
           __shared_weak_owners_(__refs) {}
 protected:
     virtual ~__shared_weak_count();
 
 public:
 #if defined(_LIBCPP_BUILDING_LIBRARY) && \
     defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
     void __add_shared() _NOEXCEPT;
     void __add_weak() _NOEXCEPT;
     void __release_shared() _NOEXCEPT;
 #else
     _LIBCPP_INLINE_VISIBILITY
     void __add_shared() _NOEXCEPT {
       __shared_count::__add_shared();
     }
     _LIBCPP_INLINE_VISIBILITY
     void __add_weak() _NOEXCEPT {
       __libcpp_atomic_refcount_increment(__shared_weak_owners_);
     }
     _LIBCPP_INLINE_VISIBILITY
     void __release_shared() _NOEXCEPT {
       if (__shared_count::__release_shared())
         __release_weak();
     }
 #endif
     void __release_weak() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     long use_count() const _NOEXCEPT {return __shared_count::use_count();}
     __shared_weak_count* lock() _NOEXCEPT;
 
     // Define the function out only if we build static libc++ without RTTI.
     // Otherwise we may break clients who need to compile their projects with
     // -fno-rtti and yet link against a libc++.dylib compiled
     // without -fno-rtti.
 #if !defined(_LIBCPP_NO_RTTI) || !defined(_LIBCPP_BUILD_STATIC)
     virtual const void* __get_deleter(const type_info&) const _NOEXCEPT;
 #endif
 private:
     virtual void __on_zero_shared_weak() _NOEXCEPT = 0;
 };
 
 template <class _Tp, class _Dp, class _Alloc>
 class __shared_ptr_pointer
     : public __shared_weak_count
 {
     __compressed_pair<__compressed_pair<_Tp, _Dp>, _Alloc> __data_;
 public:
     _LIBCPP_INLINE_VISIBILITY
     __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a)
         :  __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTD::move(__d)), _VSTD::move(__a)) {}
 
 #ifndef _LIBCPP_NO_RTTI
     virtual const void* __get_deleter(const type_info&) const _NOEXCEPT;
 #endif
 
 private:
     virtual void __on_zero_shared() _NOEXCEPT;
     virtual void __on_zero_shared_weak() _NOEXCEPT;
 };
 
 #ifndef _LIBCPP_NO_RTTI
 
 template <class _Tp, class _Dp, class _Alloc>
 const void*
 __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const _NOEXCEPT
 {
     return __t == typeid(_Dp) ? _VSTD::addressof(__data_.first().second()) : nullptr;
 }
 
 #endif  // _LIBCPP_NO_RTTI
 
 template <class _Tp, class _Dp, class _Alloc>
 void
 __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPT
 {
     __data_.first().second()(__data_.first().first());
     __data_.first().second().~_Dp();
 }
 
 template <class _Tp, class _Dp, class _Alloc>
 void
 __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT
 {
     typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_pointer>::type _Al;
     typedef allocator_traits<_Al> _ATraits;
     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
 
     _Al __a(__data_.second());
     __data_.second().~_Alloc();
     __a.deallocate(_PTraits::pointer_to(*this), 1);
 }
 
 template <class _Tp, class _Alloc>
 class __shared_ptr_emplace
     : public __shared_weak_count
 {
     __compressed_pair<_Alloc, _Tp> __data_;
 public:
 
     _LIBCPP_INLINE_VISIBILITY
     __shared_ptr_emplace(_Alloc __a)
         :  __data_(_VSTD::move(__a), __value_init_tag()) {}
 
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class ..._Args>
         _LIBCPP_INLINE_VISIBILITY
         __shared_ptr_emplace(_Alloc __a, _Args&& ...__args)
             :  __data_(piecewise_construct, _VSTD::forward_as_tuple(__a),
                    _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)) {}
 #else  // _LIBCPP_HAS_NO_VARIADICS
 
     template <class _A0>
         _LIBCPP_INLINE_VISIBILITY
         __shared_ptr_emplace(_Alloc __a, _A0& __a0)
             :  __data_(__a, _Tp(__a0)) {}
 
     template <class _A0, class _A1>
         _LIBCPP_INLINE_VISIBILITY
         __shared_ptr_emplace(_Alloc __a, _A0& __a0, _A1& __a1)
             :  __data_(__a, _Tp(__a0, __a1)) {}
 
     template <class _A0, class _A1, class _A2>
         _LIBCPP_INLINE_VISIBILITY
         __shared_ptr_emplace(_Alloc __a, _A0& __a0, _A1& __a1, _A2& __a2)
             :  __data_(__a, _Tp(__a0, __a1, __a2)) {}
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 private:
     virtual void __on_zero_shared() _NOEXCEPT;
     virtual void __on_zero_shared_weak() _NOEXCEPT;
 public:
     _LIBCPP_INLINE_VISIBILITY
     _Tp* get() _NOEXCEPT {return _VSTD::addressof(__data_.second());}
 };
 
 template <class _Tp, class _Alloc>
 void
 __shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared() _NOEXCEPT
 {
     __data_.second().~_Tp();
 }
 
 template <class _Tp, class _Alloc>
 void
 __shared_ptr_emplace<_Tp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT
 {
     typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_emplace>::type _Al;
     typedef allocator_traits<_Al> _ATraits;
     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
     _Al __a(__data_.first());
     __data_.first().~_Alloc();
     __a.deallocate(_PTraits::pointer_to(*this), 1);
 }
 
 struct __shared_ptr_dummy_rebind_allocator_type;
 template <>
 class _LIBCPP_TEMPLATE_VIS allocator<__shared_ptr_dummy_rebind_allocator_type>
 {
 public:
     template <class _Other>
     struct rebind
     {
         typedef allocator<_Other> other;
     };
 };
 
 template<class _Tp> class _LIBCPP_TEMPLATE_VIS enable_shared_from_this;
 
 template<class _Tp>
 class _LIBCPP_TEMPLATE_VIS shared_ptr
 {
 public:
     typedef _Tp element_type;
 
 #if _LIBCPP_STD_VER > 14
     typedef weak_ptr<_Tp> weak_type;
 #endif
 private:
     element_type*      __ptr_;
     __shared_weak_count* __cntrl_;
 
     struct __nat {int __for_bool_;};
 public:
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR shared_ptr() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR shared_ptr(nullptr_t) _NOEXCEPT;
     template<class _Yp>
         explicit shared_ptr(_Yp* __p,
                             typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat());
     template<class _Yp, class _Dp>
         shared_ptr(_Yp* __p, _Dp __d,
                    typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat());
     template<class _Yp, class _Dp, class _Alloc>
         shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,
                    typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat());
     template <class _Dp> shared_ptr(nullptr_t __p, _Dp __d);
     template <class _Dp, class _Alloc> shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a);
     template<class _Yp> _LIBCPP_INLINE_VISIBILITY shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     shared_ptr(const shared_ptr& __r) _NOEXCEPT;
     template<class _Yp>
         _LIBCPP_INLINE_VISIBILITY
         shared_ptr(const shared_ptr<_Yp>& __r,
                    typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat())
                        _NOEXCEPT;
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     shared_ptr(shared_ptr&& __r) _NOEXCEPT;
     template<class _Yp> _LIBCPP_INLINE_VISIBILITY  shared_ptr(shared_ptr<_Yp>&& __r,
                    typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat())
                        _NOEXCEPT;
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template<class _Yp> explicit shared_ptr(const weak_ptr<_Yp>& __r,
                    typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type= __nat());
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template<class _Yp>
         shared_ptr(auto_ptr<_Yp>&& __r,
                    typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat());
 #else
     template<class _Yp>
         shared_ptr(auto_ptr<_Yp> __r,
                    typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat());
 #endif
 #endif
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _Yp, class _Dp>
         shared_ptr(unique_ptr<_Yp, _Dp>&&,
                    typename enable_if
                    <
                        !is_lvalue_reference<_Dp>::value &&
                        !is_array<_Yp>::value &&
                        is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
                        __nat
                    >::type = __nat());
     template <class _Yp, class _Dp>
         shared_ptr(unique_ptr<_Yp, _Dp>&&,
                    typename enable_if
                    <
                        is_lvalue_reference<_Dp>::value &&
                        !is_array<_Yp>::value &&
                        is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
                        __nat
                    >::type = __nat());
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _Yp, class _Dp>
         shared_ptr(unique_ptr<_Yp, _Dp>,
                    typename enable_if
                    <
                        !is_lvalue_reference<_Dp>::value &&
                        !is_array<_Yp>::value &&
                        is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
                        __nat
                    >::type = __nat());
     template <class _Yp, class _Dp>
         shared_ptr(unique_ptr<_Yp, _Dp>,
                    typename enable_if
                    <
                        is_lvalue_reference<_Dp>::value &&
                        !is_array<_Yp>::value &&
                        is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
                        __nat
                    >::type = __nat());
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     ~shared_ptr();
 
     _LIBCPP_INLINE_VISIBILITY
     shared_ptr& operator=(const shared_ptr& __r) _NOEXCEPT;
     template<class _Yp>
         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             shared_ptr&
         >::type
         _LIBCPP_INLINE_VISIBILITY
         operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT;
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     shared_ptr& operator=(shared_ptr&& __r) _NOEXCEPT;
     template<class _Yp>
         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             shared_ptr<_Tp>&
         >::type
         _LIBCPP_INLINE_VISIBILITY
         operator=(shared_ptr<_Yp>&& __r);
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
     template<class _Yp>
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
             !is_array<_Yp>::value &&
             is_convertible<_Yp*, element_type*>::value,
             shared_ptr
         >::type&
         operator=(auto_ptr<_Yp>&& __r);
 #endif
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
     template<class _Yp>
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
             !is_array<_Yp>::value &&
             is_convertible<_Yp*, element_type*>::value,
             shared_ptr&
         >::type
         operator=(auto_ptr<_Yp> __r);
 #endif
 #endif
     template <class _Yp, class _Dp>
         typename enable_if
         <
             !is_array<_Yp>::value &&
             is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
             shared_ptr&
         >::type
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         _LIBCPP_INLINE_VISIBILITY
         operator=(unique_ptr<_Yp, _Dp>&& __r);
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
         _LIBCPP_INLINE_VISIBILITY
         operator=(unique_ptr<_Yp, _Dp> __r);
 #endif
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(shared_ptr& __r) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     void reset() _NOEXCEPT;
     template<class _Yp>
         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             void
         >::type
         _LIBCPP_INLINE_VISIBILITY
         reset(_Yp* __p);
     template<class _Yp, class _Dp>
         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             void
         >::type
         _LIBCPP_INLINE_VISIBILITY
         reset(_Yp* __p, _Dp __d);
     template<class _Yp, class _Dp, class _Alloc>
         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             void
         >::type
         _LIBCPP_INLINE_VISIBILITY
         reset(_Yp* __p, _Dp __d, _Alloc __a);
 
     _LIBCPP_INLINE_VISIBILITY
     element_type* get() const _NOEXCEPT {return __ptr_;}
     _LIBCPP_INLINE_VISIBILITY
     typename add_lvalue_reference<element_type>::type operator*() const _NOEXCEPT
         {return *__ptr_;}
     _LIBCPP_INLINE_VISIBILITY
     element_type* operator->() const _NOEXCEPT {return __ptr_;}
     _LIBCPP_INLINE_VISIBILITY
     long use_count() const _NOEXCEPT {return __cntrl_ ? __cntrl_->use_count() : 0;}
     _LIBCPP_INLINE_VISIBILITY
     bool unique() const _NOEXCEPT {return use_count() == 1;}
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return get() != 0;}
     template <class _Up>
         _LIBCPP_INLINE_VISIBILITY
         bool owner_before(shared_ptr<_Up> const& __p) const _NOEXCEPT
         {return __cntrl_ < __p.__cntrl_;}
     template <class _Up>
         _LIBCPP_INLINE_VISIBILITY
         bool owner_before(weak_ptr<_Up> const& __p) const _NOEXCEPT
         {return __cntrl_ < __p.__cntrl_;}
     _LIBCPP_INLINE_VISIBILITY
     bool
     __owner_equivalent(const shared_ptr& __p) const
         {return __cntrl_ == __p.__cntrl_;}
 
 #ifndef _LIBCPP_NO_RTTI
     template <class _Dp>
         _LIBCPP_INLINE_VISIBILITY
         _Dp* __get_deleter() const _NOEXCEPT
             {return static_cast<_Dp*>(__cntrl_
                     ? const_cast<void *>(__cntrl_->__get_deleter(typeid(_Dp)))
                       : nullptr);}
 #endif  // _LIBCPP_NO_RTTI
 
     template<class _Yp, class _CntrlBlk>
     static shared_ptr<_Tp>
     __create_with_control_block(_Yp* __p, _CntrlBlk* __cntrl)
     {
         shared_ptr<_Tp> __r;
         __r.__ptr_ = __p;
         __r.__cntrl_ = __cntrl;
         __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
         return __r;
     }
 
     template<class _Alloc, class ..._Args>
         static
         shared_ptr<_Tp>
         allocate_shared(const _Alloc& __a, _Args&& ...__args);
 
 private:
     template <class _Yp, bool = is_function<_Yp>::value>
         struct __shared_ptr_default_allocator
         {
             typedef allocator<_Yp> type;
         };
 
     template <class _Yp>
         struct __shared_ptr_default_allocator<_Yp, true>
         {
             typedef allocator<__shared_ptr_dummy_rebind_allocator_type> type;
         };
 
     template <class _Yp, class _OrigPtr>
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if<is_convertible<_OrigPtr*,
                                           const enable_shared_from_this<_Yp>*
         >::value,
             void>::type
         __enable_weak_this(const enable_shared_from_this<_Yp>* __e,
                            _OrigPtr* __ptr) _NOEXCEPT
         {
             typedef typename remove_cv<_Yp>::type _RawYp;
             if (__e && __e->__weak_this_.expired())
             {
                 __e->__weak_this_ = shared_ptr<_RawYp>(*this,
                     const_cast<_RawYp*>(static_cast<const _Yp*>(__ptr)));
             }
         }
 
     _LIBCPP_INLINE_VISIBILITY void __enable_weak_this(...) _NOEXCEPT {}
 
     template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
     template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
 };
 
 
 template<class _Tp>
 inline
 _LIBCPP_CONSTEXPR
 shared_ptr<_Tp>::shared_ptr() _NOEXCEPT
     : __ptr_(0),
       __cntrl_(0)
 {
 }
 
 template<class _Tp>
 inline
 _LIBCPP_CONSTEXPR
 shared_ptr<_Tp>::shared_ptr(nullptr_t) _NOEXCEPT
     : __ptr_(0),
       __cntrl_(0)
 {
 }
 
 template<class _Tp>
 template<class _Yp>
 shared_ptr<_Tp>::shared_ptr(_Yp* __p,
                             typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
     : __ptr_(__p)
 {
     unique_ptr<_Yp> __hold(__p);
     typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
     typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, _AllocT > _CntrlBlk;
     __cntrl_ = new _CntrlBlk(__p, default_delete<_Yp>(), _AllocT());
     __hold.release();
     __enable_weak_this(__p, __p);
 }
 
 template<class _Tp>
 template<class _Yp, class _Dp>
 shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d,
                             typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
     : __ptr_(__p)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
         typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT > _CntrlBlk;
         __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
         __enable_weak_this(__p, __p);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __d(__p);
         throw;
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 template<class _Tp>
 template<class _Dp>
 shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d)
     : __ptr_(0)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         typedef typename __shared_ptr_default_allocator<_Tp>::type _AllocT;
         typedef __shared_ptr_pointer<nullptr_t, _Dp, _AllocT > _CntrlBlk;
         __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __d(__p);
         throw;
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 template<class _Tp>
 template<class _Yp, class _Dp, class _Alloc>
 shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,
                             typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
     : __ptr_(__p)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk;
         typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
         typedef __allocator_destructor<_A2> _D2;
         _A2 __a2(__a);
         unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
         ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get())))
             _CntrlBlk(__p, __d, __a);
         __cntrl_ = _VSTD::addressof(*__hold2.release());
         __enable_weak_this(__p, __p);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __d(__p);
         throw;
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 template<class _Tp>
 template<class _Dp, class _Alloc>
 shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a)
     : __ptr_(0)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
         typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk;
         typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
         typedef __allocator_destructor<_A2> _D2;
         _A2 __a2(__a);
         unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
         ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get())))
             _CntrlBlk(__p, __d, __a);
         __cntrl_ = _VSTD::addressof(*__hold2.release());
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
     {
         __d(__p);
         throw;
     }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r, element_type *__p) _NOEXCEPT
     : __ptr_(__p),
       __cntrl_(__r.__cntrl_)
 {
     if (__cntrl_)
         __cntrl_->__add_shared();
 }
 
 template<class _Tp>
 inline
 shared_ptr<_Tp>::shared_ptr(const shared_ptr& __r) _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     if (__cntrl_)
         __cntrl_->__add_shared();
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r,
                             typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
          _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     if (__cntrl_)
         __cntrl_->__add_shared();
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _Tp>
 inline
 shared_ptr<_Tp>::shared_ptr(shared_ptr&& __r) _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     __r.__ptr_ = 0;
     __r.__cntrl_ = 0;
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 shared_ptr<_Tp>::shared_ptr(shared_ptr<_Yp>&& __r,
                             typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
          _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     __r.__ptr_ = 0;
     __r.__cntrl_ = 0;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
 template<class _Tp>
 template<class _Yp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp>&& __r,
 #else
 shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp> __r,
 #endif
                             typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
     : __ptr_(__r.get())
 {
     typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk;
     __cntrl_ = new _CntrlBlk(__r.get(), default_delete<_Yp>(), allocator<_Yp>());
     __enable_weak_this(__r.get(), __r.get());
     __r.release();
 }
 #endif
 
 template<class _Tp>
 template <class _Yp, class _Dp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r,
 #else
 shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r,
 #endif
                             typename enable_if
                             <
                                 !is_lvalue_reference<_Dp>::value &&
                                 !is_array<_Yp>::value &&
                                 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
                                 __nat
                             >::type)
     : __ptr_(__r.get())
 {
 #if _LIBCPP_STD_VER > 11
     if (__ptr_ == nullptr)
         __cntrl_ = nullptr;
     else
 #endif
     {
         typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
         typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT > _CntrlBlk;
         __cntrl_ = new _CntrlBlk(__r.get(), __r.get_deleter(), _AllocT());
         __enable_weak_this(__r.get(), __r.get());
     }
     __r.release();
 }
 
 template<class _Tp>
 template <class _Yp, class _Dp>
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r,
 #else
 shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp> __r,
 #endif
                             typename enable_if
                             <
                                 is_lvalue_reference<_Dp>::value &&
                                 !is_array<_Yp>::value &&
                                 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
                                 __nat
                             >::type)
     : __ptr_(__r.get())
 {
 #if _LIBCPP_STD_VER > 11
     if (__ptr_ == nullptr)
         __cntrl_ = nullptr;
     else
 #endif
     {
         typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
         typedef __shared_ptr_pointer<_Yp*,
                                      reference_wrapper<typename remove_reference<_Dp>::type>,
                                      _AllocT > _CntrlBlk;
         __cntrl_ = new _CntrlBlk(__r.get(), ref(__r.get_deleter()), _AllocT());
         __enable_weak_this(__r.get(), __r.get());
     }
     __r.release();
 }
 
 template<class _Tp>
 template<class _Alloc, class ..._Args>
 shared_ptr<_Tp>
 shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _Args&& ...__args)
 {
     static_assert( is_constructible<_Tp, _Args...>::value, "Can't construct object in allocate_shared" );
     typedef __shared_ptr_emplace<_Tp, _Alloc> _CntrlBlk;
     typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
     typedef __allocator_destructor<_A2> _D2;
     _A2 __a2(__a);
     unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
     ::new(static_cast<void*>(_VSTD::addressof(*__hold2.get())))
         _CntrlBlk(__a, _VSTD::forward<_Args>(__args)...);
     shared_ptr<_Tp> __r;
     __r.__ptr_ = __hold2.get()->get();
     __r.__cntrl_ = _VSTD::addressof(*__hold2.release());
     __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
     return __r;
 }
 
 template<class _Tp>
 shared_ptr<_Tp>::~shared_ptr()
 {
     if (__cntrl_)
         __cntrl_->__release_shared();
 }
 
 template<class _Tp>
 inline
 shared_ptr<_Tp>&
 shared_ptr<_Tp>::operator=(const shared_ptr& __r) _NOEXCEPT
 {
     shared_ptr(__r).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 typename enable_if
 <
     is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value,
     shared_ptr<_Tp>&
 >::type
 shared_ptr<_Tp>::operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT
 {
     shared_ptr(__r).swap(*this);
     return *this;
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _Tp>
 inline
 shared_ptr<_Tp>&
 shared_ptr<_Tp>::operator=(shared_ptr&& __r) _NOEXCEPT
 {
     shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 typename enable_if
 <
     is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value,
     shared_ptr<_Tp>&
 >::type
 shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r)
 {
     shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
 template<class _Tp>
 template<class _Yp>
 inline
 typename enable_if
 <
     !is_array<_Yp>::value &&
     is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value,
     shared_ptr<_Tp>
 >::type&
 shared_ptr<_Tp>::operator=(auto_ptr<_Yp>&& __r)
 {
     shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 #endif
 
 template<class _Tp>
 template <class _Yp, class _Dp>
 inline
 typename enable_if
 <
     !is_array<_Yp>::value &&
     is_convertible<typename unique_ptr<_Yp, _Dp>::pointer,
                    typename shared_ptr<_Tp>::element_type*>::value,
     shared_ptr<_Tp>&
 >::type
 shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp>&& __r)
 {
     shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
 template<class _Tp>
 template<class _Yp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     !is_array<_Yp>::value &&
     is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value,
     shared_ptr<_Tp>&
 >::type
 shared_ptr<_Tp>::operator=(auto_ptr<_Yp> __r)
 {
     shared_ptr(__r).swap(*this);
     return *this;
 }
 #endif
 
 template<class _Tp>
 template <class _Yp, class _Dp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     !is_array<_Yp>::value &&
     is_convertible<typename unique_ptr<_Yp, _Dp>::pointer,
                    typename shared_ptr<_Tp>::element_type*>::value,
     shared_ptr<_Tp>&
 >::type
 shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp> __r)
 {
     shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _Tp>
 inline
 void
 shared_ptr<_Tp>::swap(shared_ptr& __r) _NOEXCEPT
 {
     _VSTD::swap(__ptr_, __r.__ptr_);
     _VSTD::swap(__cntrl_, __r.__cntrl_);
 }
 
 template<class _Tp>
 inline
 void
 shared_ptr<_Tp>::reset() _NOEXCEPT
 {
     shared_ptr().swap(*this);
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 typename enable_if
 <
     is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value,
     void
 >::type
 shared_ptr<_Tp>::reset(_Yp* __p)
 {
     shared_ptr(__p).swap(*this);
 }
 
 template<class _Tp>
 template<class _Yp, class _Dp>
 inline
 typename enable_if
 <
     is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value,
     void
 >::type
 shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d)
 {
     shared_ptr(__p, __d).swap(*this);
 }
 
 template<class _Tp>
 template<class _Yp, class _Dp, class _Alloc>
 inline
 typename enable_if
 <
     is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value,
     void
 >::type
 shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d, _Alloc __a)
 {
     shared_ptr(__p, __d, __a).swap(*this);
 }
 
 template<class _Tp, class ..._Args>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     !is_array<_Tp>::value,
     shared_ptr<_Tp>
 >::type
 make_shared(_Args&& ...__args)
 {
     static_assert(is_constructible<_Tp, _Args...>::value, "Can't construct object in make_shared");
     typedef __shared_ptr_emplace<_Tp, allocator<_Tp> > _CntrlBlk;
     typedef allocator<_CntrlBlk> _A2;
     typedef __allocator_destructor<_A2> _D2;
 
     _A2 __a2;
     unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
     ::new(__hold2.get()) _CntrlBlk(__a2, _VSTD::forward<_Args>(__args)...);
 
     _Tp *__ptr = __hold2.get()->get();
     return shared_ptr<_Tp>::__create_with_control_block(__ptr, __hold2.release());
 }
 
 template<class _Tp, class _Alloc, class ..._Args>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     !is_array<_Tp>::value,
     shared_ptr<_Tp>
 >::type
 allocate_shared(const _Alloc& __a, _Args&& ...__args)
 {
     return shared_ptr<_Tp>::allocate_shared(__a, _VSTD::forward<_Args>(__args)...);
 }
 
 template<class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
 {
     return __x.get() == __y.get();
 }
 
 template<class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
 {
     return !(__x == __y);
 }
 
 template<class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
 {
 #if _LIBCPP_STD_VER <= 11
     typedef typename common_type<_Tp*, _Up*>::type _Vp;
     return less<_Vp>()(__x.get(), __y.get());
 #else
     return less<>()(__x.get(), __y.get());
 #endif
 
 }
 
 template<class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
 {
     return __y < __x;
 }
 
 template<class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
 {
     return !(__y < __x);
 }
 
 template<class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
 {
     return !(__x < __y);
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
 {
     return !__x;
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
 {
     return !__x;
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
 {
     return static_cast<bool>(__x);
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
 {
     return static_cast<bool>(__x);
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
 {
     return less<_Tp*>()(__x.get(), nullptr);
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
 {
     return less<_Tp*>()(nullptr, __x.get());
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
 {
     return nullptr < __x;
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
 {
     return __x < nullptr;
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
 {
     return !(nullptr < __x);
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
 {
     return !(__x < nullptr);
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
 {
     return !(__x < nullptr);
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
 {
     return !(nullptr < __x);
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) _NOEXCEPT
 {
     __x.swap(__y);
 }
 
 template<class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     !is_array<_Tp>::value && !is_array<_Up>::value,
     shared_ptr<_Tp>
 >::type
 static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT
 {
     return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get()));
 }
 
 template<class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
     !is_array<_Tp>::value && !is_array<_Up>::value,
     shared_ptr<_Tp>
 >::type
 dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT
 {
     _Tp* __p = dynamic_cast<_Tp*>(__r.get());
     return __p ? shared_ptr<_Tp>(__r, __p) : shared_ptr<_Tp>();
 }
 
 template<class _Tp, class _Up>
 typename enable_if
 <
     is_array<_Tp>::value == is_array<_Up>::value,
     shared_ptr<_Tp>
 >::type
 const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT
 {
     typedef typename remove_extent<_Tp>::type _RTp;
     return shared_ptr<_Tp>(__r, const_cast<_RTp*>(__r.get()));
 }
 
 #ifndef _LIBCPP_NO_RTTI
 
 template<class _Dp, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Dp*
 get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT
 {
     return __p.template __get_deleter<_Dp>();
 }
 
 #endif  // _LIBCPP_NO_RTTI
 
 template<class _Tp>
 class _LIBCPP_TEMPLATE_VIS weak_ptr
 {
 public:
     typedef _Tp element_type;
 private:
     element_type*        __ptr_;
     __shared_weak_count* __cntrl_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR weak_ptr() _NOEXCEPT;
     template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(shared_ptr<_Yp> const& __r,
                    typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
                         _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     weak_ptr(weak_ptr const& __r) _NOEXCEPT;
     template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp> const& __r,
                    typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
                          _NOEXCEPT;
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     weak_ptr(weak_ptr&& __r) _NOEXCEPT;
     template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp>&& __r,
                    typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
                          _NOEXCEPT;
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     ~weak_ptr();
 
     _LIBCPP_INLINE_VISIBILITY
     weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT;
     template<class _Yp>
         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             weak_ptr&
         >::type
         _LIBCPP_INLINE_VISIBILITY
         operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT;
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     _LIBCPP_INLINE_VISIBILITY
     weak_ptr& operator=(weak_ptr&& __r) _NOEXCEPT;
     template<class _Yp>
         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             weak_ptr&
         >::type
         _LIBCPP_INLINE_VISIBILITY
         operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT;
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     template<class _Yp>
         typename enable_if
         <
             is_convertible<_Yp*, element_type*>::value,
             weak_ptr&
         >::type
         _LIBCPP_INLINE_VISIBILITY
         operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(weak_ptr& __r) _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     void reset() _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     long use_count() const _NOEXCEPT
         {return __cntrl_ ? __cntrl_->use_count() : 0;}
     _LIBCPP_INLINE_VISIBILITY
     bool expired() const _NOEXCEPT
         {return __cntrl_ == 0 || __cntrl_->use_count() == 0;}
     shared_ptr<_Tp> lock() const _NOEXCEPT;
     template<class _Up>
         _LIBCPP_INLINE_VISIBILITY
         bool owner_before(const shared_ptr<_Up>& __r) const _NOEXCEPT
         {return __cntrl_ < __r.__cntrl_;}
     template<class _Up>
         _LIBCPP_INLINE_VISIBILITY
         bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPT
         {return __cntrl_ < __r.__cntrl_;}
 
     template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
     template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
 };
 
 template<class _Tp>
 inline
 _LIBCPP_CONSTEXPR
 weak_ptr<_Tp>::weak_ptr() _NOEXCEPT
     : __ptr_(0),
       __cntrl_(0)
 {
 }
 
 template<class _Tp>
 inline
 weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     if (__cntrl_)
         __cntrl_->__add_weak();
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 weak_ptr<_Tp>::weak_ptr(shared_ptr<_Yp> const& __r,
                         typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
                          _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     if (__cntrl_)
         __cntrl_->__add_weak();
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp> const& __r,
                         typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
          _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     if (__cntrl_)
         __cntrl_->__add_weak();
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _Tp>
 inline
 weak_ptr<_Tp>::weak_ptr(weak_ptr&& __r) _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     __r.__ptr_ = 0;
     __r.__cntrl_ = 0;
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp>&& __r,
                         typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
          _NOEXCEPT
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_)
 {
     __r.__ptr_ = 0;
     __r.__cntrl_ = 0;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _Tp>
 weak_ptr<_Tp>::~weak_ptr()
 {
     if (__cntrl_)
         __cntrl_->__release_weak();
 }
 
 template<class _Tp>
 inline
 weak_ptr<_Tp>&
 weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPT
 {
     weak_ptr(__r).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 typename enable_if
 <
     is_convertible<_Yp*, _Tp*>::value,
     weak_ptr<_Tp>&
 >::type
 weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT
 {
     weak_ptr(__r).swap(*this);
     return *this;
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _Tp>
 inline
 weak_ptr<_Tp>&
 weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPT
 {
     weak_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 template<class _Yp>
 inline
 typename enable_if
 <
     is_convertible<_Yp*, _Tp*>::value,
     weak_ptr<_Tp>&
 >::type
 weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT
 {
     weak_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
 template<class _Tp>
 template<class _Yp>
 inline
 typename enable_if
 <
     is_convertible<_Yp*, _Tp*>::value,
     weak_ptr<_Tp>&
 >::type
 weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT
 {
     weak_ptr(__r).swap(*this);
     return *this;
 }
 
 template<class _Tp>
 inline
 void
 weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPT
 {
     _VSTD::swap(__ptr_, __r.__ptr_);
     _VSTD::swap(__cntrl_, __r.__cntrl_);
 }
 
 template<class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(weak_ptr<_Tp>& __x, weak_ptr<_Tp>& __y) _NOEXCEPT
 {
     __x.swap(__y);
 }
 
 template<class _Tp>
 inline
 void
 weak_ptr<_Tp>::reset() _NOEXCEPT
 {
     weak_ptr().swap(*this);
 }
 
 template<class _Tp>
 template<class _Yp>
 shared_ptr<_Tp>::shared_ptr(const weak_ptr<_Yp>& __r,
                             typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
     : __ptr_(__r.__ptr_),
       __cntrl_(__r.__cntrl_ ? __r.__cntrl_->lock() : __r.__cntrl_)
 {
     if (__cntrl_ == 0)
         __throw_bad_weak_ptr();
 }
 
 template<class _Tp>
 shared_ptr<_Tp>
 weak_ptr<_Tp>::lock() const _NOEXCEPT
 {
     shared_ptr<_Tp> __r;
     __r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_;
     if (__r.__cntrl_)
         __r.__ptr_ = __ptr_;
     return __r;
 }
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp = void> struct owner_less;
 #else
 template <class _Tp> struct owner_less;
 #endif
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS owner_less<shared_ptr<_Tp> >
     : binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool>
 {
     typedef bool result_type;
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT
         {return __x.owner_before(__y);}
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(shared_ptr<_Tp> const& __x,   weak_ptr<_Tp> const& __y) const _NOEXCEPT
         {return __x.owner_before(__y);}
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(  weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT
         {return __x.owner_before(__y);}
 };
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS owner_less<weak_ptr<_Tp> >
     : binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool>
 {
     typedef bool result_type;
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(  weak_ptr<_Tp> const& __x,   weak_ptr<_Tp> const& __y) const _NOEXCEPT
         {return __x.owner_before(__y);}
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(shared_ptr<_Tp> const& __x,   weak_ptr<_Tp> const& __y) const _NOEXCEPT
         {return __x.owner_before(__y);}
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(  weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT
         {return __x.owner_before(__y);}
 };
 
 #if _LIBCPP_STD_VER > 14
 template <>
 struct _LIBCPP_TEMPLATE_VIS owner_less<void>
 {
     template <class _Tp, class _Up>
     _LIBCPP_INLINE_VISIBILITY
     bool operator()( shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT
         {return __x.owner_before(__y);}
     template <class _Tp, class _Up>
     _LIBCPP_INLINE_VISIBILITY
     bool operator()( shared_ptr<_Tp> const& __x,   weak_ptr<_Up> const& __y) const _NOEXCEPT
         {return __x.owner_before(__y);}
     template <class _Tp, class _Up>
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(   weak_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT
         {return __x.owner_before(__y);}
     template <class _Tp, class _Up>
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(   weak_ptr<_Tp> const& __x,   weak_ptr<_Up> const& __y) const _NOEXCEPT
         {return __x.owner_before(__y);}
     typedef void is_transparent;
 };
 #endif
 
 template<class _Tp>
 class _LIBCPP_TEMPLATE_VIS enable_shared_from_this
 {
     mutable weak_ptr<_Tp> __weak_this_;
 protected:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
     enable_shared_from_this() _NOEXCEPT {}
     _LIBCPP_INLINE_VISIBILITY
     enable_shared_from_this(enable_shared_from_this const&) _NOEXCEPT {}
     _LIBCPP_INLINE_VISIBILITY
     enable_shared_from_this& operator=(enable_shared_from_this const&) _NOEXCEPT
         {return *this;}
     _LIBCPP_INLINE_VISIBILITY
     ~enable_shared_from_this() {}
 public:
     _LIBCPP_INLINE_VISIBILITY
     shared_ptr<_Tp> shared_from_this()
         {return shared_ptr<_Tp>(__weak_this_);}
     _LIBCPP_INLINE_VISIBILITY
     shared_ptr<_Tp const> shared_from_this() const
         {return shared_ptr<const _Tp>(__weak_this_);}
 
 #if _LIBCPP_STD_VER > 14
     _LIBCPP_INLINE_VISIBILITY
     weak_ptr<_Tp> weak_from_this() _NOEXCEPT
        { return __weak_this_; }
 
     _LIBCPP_INLINE_VISIBILITY
     weak_ptr<const _Tp> weak_from_this() const _NOEXCEPT
         { return __weak_this_; }
 #endif // _LIBCPP_STD_VER > 14
 
     template <class _Up> friend class shared_ptr;
 };
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS hash<shared_ptr<_Tp> >
 {
     typedef shared_ptr<_Tp>      argument_type;
     typedef size_t               result_type;
 
     _LIBCPP_INLINE_VISIBILITY
     result_type operator()(const argument_type& __ptr) const _NOEXCEPT
     {
         return hash<_Tp*>()(__ptr.get());
     }
 };
 
 template<class _CharT, class _Traits, class _Yp>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p);
 
 
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 
 class _LIBCPP_TYPE_VIS __sp_mut
 {
     void* __lx;
 public:
     void lock() _NOEXCEPT;
     void unlock() _NOEXCEPT;
 
 private:
     _LIBCPP_CONSTEXPR __sp_mut(void*) _NOEXCEPT;
     __sp_mut(const __sp_mut&);
     __sp_mut& operator=(const __sp_mut&);
 
     friend _LIBCPP_FUNC_VIS __sp_mut& __get_sp_mut(const void*);
 };
 
 _LIBCPP_FUNC_VIS _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 __sp_mut& __get_sp_mut(const void*);
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 atomic_is_lock_free(const shared_ptr<_Tp>*)
 {
     return false;
 }
 
 template <class _Tp>
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 shared_ptr<_Tp>
 atomic_load(const shared_ptr<_Tp>* __p)
 {
     __sp_mut& __m = __get_sp_mut(__p);
     __m.lock();
     shared_ptr<_Tp> __q = *__p;
     __m.unlock();
     return __q;
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 shared_ptr<_Tp>
 atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
 {
     return atomic_load(__p);
 }
 
 template <class _Tp>
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 void
 atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
 {
     __sp_mut& __m = __get_sp_mut(__p);
     __m.lock();
     __p->swap(__r);
     __m.unlock();
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 void
 atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order)
 {
     atomic_store(__p, __r);
 }
 
 template <class _Tp>
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 shared_ptr<_Tp>
 atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
 {
     __sp_mut& __m = __get_sp_mut(__p);
     __m.lock();
     __p->swap(__r);
     __m.unlock();
     return __r;
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 shared_ptr<_Tp>
 atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order)
 {
     return atomic_exchange(__p, __r);
 }
 
 template <class _Tp>
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 bool
 atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w)
 {
     shared_ptr<_Tp> __temp;
     __sp_mut& __m = __get_sp_mut(__p);
     __m.lock();
     if (__p->__owner_equivalent(*__v))
     {
         _VSTD::swap(__temp, *__p);
         *__p = __w;
         __m.unlock();
         return true;
     }
     _VSTD::swap(__temp, *__v);
     *__v = *__p;
     __m.unlock();
     return false;
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 bool
 atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w)
 {
     return atomic_compare_exchange_strong(__p, __v, __w);
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 bool
 atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
                                         shared_ptr<_Tp> __w, memory_order, memory_order)
 {
     return atomic_compare_exchange_strong(__p, __v, __w);
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 bool
 atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
                                       shared_ptr<_Tp> __w, memory_order, memory_order)
 {
     return atomic_compare_exchange_weak(__p, __v, __w);
 }
 
 #endif  // !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 
 //enum class
 #if defined(_LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE)
 # ifndef _LIBCPP_CXX03_LANG
 enum class pointer_safety : unsigned char {
   relaxed,
   preferred,
   strict
 };
 # endif
 #else
 struct _LIBCPP_TYPE_VIS pointer_safety
 {
     enum __lx
     {
         relaxed,
         preferred,
         strict
     };
 
     __lx __v_;
 
     _LIBCPP_INLINE_VISIBILITY
     pointer_safety() : __v_() {}
 
     _LIBCPP_INLINE_VISIBILITY
     pointer_safety(__lx __v) : __v_(__v) {}
     _LIBCPP_INLINE_VISIBILITY
     operator int() const {return __v_;}
 };
 #endif
 
 #if !defined(_LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE) && \
     defined(_LIBCPP_BUILDING_LIBRARY)
 _LIBCPP_FUNC_VIS pointer_safety get_pointer_safety() _NOEXCEPT;
 #else
 // This function is only offered in C++03 under ABI v1.
 # if !defined(_LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE) || !defined(_LIBCPP_CXX03_LANG)
 inline _LIBCPP_INLINE_VISIBILITY
 pointer_safety get_pointer_safety() _NOEXCEPT {
   return pointer_safety::relaxed;
 }
 # endif
 #endif
 
 
 _LIBCPP_FUNC_VIS void declare_reachable(void* __p);
 _LIBCPP_FUNC_VIS void declare_no_pointers(char* __p, size_t __n);
 _LIBCPP_FUNC_VIS void undeclare_no_pointers(char* __p, size_t __n);
 _LIBCPP_FUNC_VIS void* __undeclare_reachable(void* __p);
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp*
 undeclare_reachable(_Tp* __p)
 {
     return static_cast<_Tp*>(__undeclare_reachable(__p));
 }
 
 _LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);
 
 // --- Helper for container swap --
 template <typename _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 void __swap_allocator(_Alloc & __a1, _Alloc & __a2)
 #if _LIBCPP_STD_VER >= 14
     _NOEXCEPT
 #else
     _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
 #endif
 {
     __swap_allocator(__a1, __a2,
       integral_constant<bool, _VSTD::allocator_traits<_Alloc>::propagate_on_container_swap::value>());
 }
 
 template <typename _Alloc>
 _LIBCPP_INLINE_VISIBILITY
 void __swap_allocator(_Alloc & __a1, _Alloc & __a2, true_type)
 #if _LIBCPP_STD_VER >= 14
     _NOEXCEPT
 #else
     _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
 #endif
 {
     using _VSTD::swap;
     swap(__a1, __a2);
 }
 
 template <typename _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 void __swap_allocator(_Alloc &, _Alloc &, false_type) _NOEXCEPT {}
 
 template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> >
 struct __noexcept_move_assign_container : public integral_constant<bool,
     _Traits::propagate_on_container_move_assignment::value
 #if _LIBCPP_STD_VER > 14
         || _Traits::is_always_equal::value
 #else
         && is_nothrow_move_assignable<_Alloc>::value
 #endif
     > {};
 
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 template <class _Tp, class _Alloc>
 struct __temp_value {
     typedef allocator_traits<_Alloc> _Traits;
 
     typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v;
     _Alloc &__a;
 
     _Tp *__addr() { return reinterpret_cast<_Tp *>(addressof(__v)); }
     _Tp &   get() { return *__addr(); }
 
     template<class... _Args>
     _LIBCPP_NO_CFI
     __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) {
       _Traits::construct(__a, reinterpret_cast<_Tp*>(addressof(__v)),
                          _VSTD::forward<_Args>(__args)...);
     }
 
     ~__temp_value() { _Traits::destroy(__a, __addr()); }
     };
 #endif
 
 template<typename _Alloc, typename = void, typename = void>
 struct __is_allocator : false_type {};
 
 template<typename _Alloc>
 struct __is_allocator<_Alloc,
        typename __void_t<typename _Alloc::value_type>::type,
        typename __void_t<decltype(_VSTD::declval<_Alloc&>().allocate(size_t(0)))>::type
      >
    : true_type {};
 
 // __builtin_new_allocator -- A non-templated helper for allocating and
 // deallocating memory using __builtin_operator_new and
 // __builtin_operator_delete. It should be used in preference to
 // `std::allocator<T>` to avoid additional instantiations.
 struct __builtin_new_allocator {
   struct __builtin_new_deleter {
     typedef void* pointer_type;
 
     _LIBCPP_CONSTEXPR explicit __builtin_new_deleter(size_t __size, size_t __align)
         : __size_(__size), __align_(__align) {}
 
     void operator()(void* p) const _NOEXCEPT {
         std::__libcpp_deallocate(p, __size_, __align_);
     }
 
    private:
     size_t __size_;
     size_t __align_;
   };
 
   typedef unique_ptr<void, __builtin_new_deleter> __holder_t;
 
   static __holder_t __allocate_bytes(size_t __s, size_t __align) {
       return __holder_t(std::__libcpp_allocate(__s, __align),
                      __builtin_new_deleter(__s, __align));
   }
 
   static void __deallocate_bytes(void* __p, size_t __s,
                                  size_t __align) _NOEXCEPT {
       std::__libcpp_deallocate(__p, __s, __align);
   }
 
   template <class _Tp>
   _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
   static __holder_t __allocate_type(size_t __n) {
       return __allocate_bytes(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
   }
 
   template <class _Tp>
   _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
   static void __deallocate_type(void* __p, size_t __n) _NOEXCEPT {
       __deallocate_bytes(__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
   }
 };
 
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if defined(_LIBCPP_HAS_PARALLEL_ALGORITHMS) && _LIBCPP_STD_VER >= 17
 #   include <__pstl_memory>
 #endif
 
 #endif  // _LIBCPP_MEMORY
Index: head/contrib/llvm-project/libcxx/include/regex
===================================================================
--- head/contrib/llvm-project/libcxx/include/regex	(revision 359086)
+++ head/contrib/llvm-project/libcxx/include/regex	(revision 359087)
@@ -1,6672 +1,6673 @@
 // -*- C++ -*-
 //===--------------------------- regex ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_REGEX
 #define _LIBCPP_REGEX
 
 /*
     regex synopsis
 
 #include <initializer_list>
 
 namespace std
 {
 
 namespace regex_constants
 {
 
 emum syntax_option_type
 {
     icase      = unspecified,
     nosubs     = unspecified,
     optimize   = unspecified,
     collate    = unspecified,
     ECMAScript = unspecified,
     basic      = unspecified,
     extended   = unspecified,
     awk        = unspecified,
     grep       = unspecified,
     egrep      = unspecified
 };
 
 constexpr syntax_option_type operator~(syntax_option_type f);
 constexpr syntax_option_type operator&(syntax_option_type lhs, syntax_option_type rhs);
 constexpr syntax_option_type operator|(syntax_option_type lhs, syntax_option_type rhs);
 
 enum match_flag_type
 {
     match_default     = 0,
     match_not_bol     = unspecified,
     match_not_eol     = unspecified,
     match_not_bow     = unspecified,
     match_not_eow     = unspecified,
     match_any         = unspecified,
     match_not_null    = unspecified,
     match_continuous  = unspecified,
     match_prev_avail  = unspecified,
     format_default    = 0,
     format_sed        = unspecified,
     format_no_copy    = unspecified,
     format_first_only = unspecified
 };
 
 constexpr match_flag_type operator~(match_flag_type f);
 constexpr match_flag_type operator&(match_flag_type lhs, match_flag_type rhs);
 constexpr match_flag_type operator|(match_flag_type lhs, match_flag_type rhs);
 
 enum error_type
 {
     error_collate    = unspecified,
     error_ctype      = unspecified,
     error_escape     = unspecified,
     error_backref    = unspecified,
     error_brack      = unspecified,
     error_paren      = unspecified,
     error_brace      = unspecified,
     error_badbrace   = unspecified,
     error_range      = unspecified,
     error_space      = unspecified,
     error_badrepeat  = unspecified,
     error_complexity = unspecified,
     error_stack      = unspecified
 };
 
 }  // regex_constants
 
 class regex_error
     : public runtime_error
 {
 public:
     explicit regex_error(regex_constants::error_type ecode);
     regex_constants::error_type code() const;
 };
 
 template <class charT>
 struct regex_traits
 {
 public:
     typedef charT                   char_type;
     typedef basic_string<char_type> string_type;
     typedef locale                  locale_type;
     typedef /bitmask_type/          char_class_type;
 
     regex_traits();
 
     static size_t length(const char_type* p);
     charT translate(charT c) const;
     charT translate_nocase(charT c) const;
     template <class ForwardIterator>
         string_type
         transform(ForwardIterator first, ForwardIterator last) const;
     template <class ForwardIterator>
         string_type
         transform_primary( ForwardIterator first, ForwardIterator last) const;
     template <class ForwardIterator>
         string_type
         lookup_collatename(ForwardIterator first, ForwardIterator last) const;
     template <class ForwardIterator>
         char_class_type
         lookup_classname(ForwardIterator first, ForwardIterator last,
                          bool icase = false) const;
     bool isctype(charT c, char_class_type f) const;
     int value(charT ch, int radix) const;
     locale_type imbue(locale_type l);
     locale_type getloc()const;
 };
 
 template <class charT, class traits = regex_traits<charT>>
 class basic_regex
 {
 public:
     // types:
     typedef charT                               value_type;
     typedef traits                              traits_type;
     typedef typename traits::string_type        string_type;
     typedef regex_constants::syntax_option_type flag_type;
     typedef typename traits::locale_type        locale_type;
 
     // constants:
     static constexpr regex_constants::syntax_option_type icase = regex_constants::icase;
     static constexpr regex_constants::syntax_option_type nosubs = regex_constants::nosubs;
     static constexpr regex_constants::syntax_option_type optimize = regex_constants::optimize;
     static constexpr regex_constants::syntax_option_type collate = regex_constants::collate;
     static constexpr regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
     static constexpr regex_constants::syntax_option_type basic = regex_constants::basic;
     static constexpr regex_constants::syntax_option_type extended = regex_constants::extended;
     static constexpr regex_constants::syntax_option_type awk = regex_constants::awk;
     static constexpr regex_constants::syntax_option_type grep = regex_constants::grep;
     static constexpr regex_constants::syntax_option_type egrep = regex_constants::egrep;
 
     // construct/copy/destroy:
     basic_regex();
     explicit basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript);
     basic_regex(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript);
     basic_regex(const basic_regex&);
     basic_regex(basic_regex&&) noexcept;
     template <class ST, class SA>
         explicit basic_regex(const basic_string<charT, ST, SA>& p,
                              flag_type f = regex_constants::ECMAScript);
     template <class ForwardIterator>
         basic_regex(ForwardIterator first, ForwardIterator last,
                     flag_type f = regex_constants::ECMAScript);
     basic_regex(initializer_list<charT>, flag_type = regex_constants::ECMAScript);
 
     ~basic_regex();
 
     basic_regex& operator=(const basic_regex&);
     basic_regex& operator=(basic_regex&&) noexcept;
     basic_regex& operator=(const charT* ptr);
     basic_regex& operator=(initializer_list<charT> il);
     template <class ST, class SA>
         basic_regex& operator=(const basic_string<charT, ST, SA>& p);
 
     // assign:
     basic_regex& assign(const basic_regex& that);
     basic_regex& assign(basic_regex&& that) noexcept;
     basic_regex& assign(const charT* ptr,           flag_type f = regex_constants::ECMAScript);
     basic_regex& assign(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript);
     template <class string_traits, class A>
         basic_regex& assign(const basic_string<charT, string_traits, A>& s,
                                                     flag_type f = regex_constants::ECMAScript);
     template <class InputIterator>
         basic_regex& assign(InputIterator first, InputIterator last,
                                                     flag_type f = regex_constants::ECMAScript);
     basic_regex& assign(initializer_list<charT>,    flag_type f = regex_constants::ECMAScript);
 
     // const operations:
     unsigned mark_count() const;
     flag_type flags() const;
 
     // locale:
     locale_type imbue(locale_type loc);
     locale_type getloc() const;
 
     // swap:
     void swap(basic_regex&);
 };
 
 template<class ForwardIterator>
 basic_regex(ForwardIterator, ForwardIterator,
             regex_constants::syntax_option_type = regex_constants::ECMAScript)
     -> basic_regex<typename iterator_traits<ForwardIterator>::value_type>; // C++17
 
 typedef basic_regex<char>    regex;
 typedef basic_regex<wchar_t> wregex;
 
 template <class charT, class traits>
     void swap(basic_regex<charT, traits>& e1, basic_regex<charT, traits>& e2);
 
 template <class BidirectionalIterator>
 class sub_match
     : public pair<BidirectionalIterator, BidirectionalIterator>
 {
 public:
     typedef typename iterator_traits<BidirectionalIterator>::value_type value_type;
     typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
     typedef BidirectionalIterator                                      iterator;
     typedef basic_string<value_type>                                string_type;
 
     bool matched;
 
     constexpr sub_match();
 
     difference_type length() const;
     operator string_type() const;
     string_type str() const;
 
     int compare(const sub_match& s) const;
     int compare(const string_type& s) const;
     int compare(const value_type* s) const;
 };
 
 typedef sub_match<const char*>             csub_match;
 typedef sub_match<const wchar_t*>          wcsub_match;
 typedef sub_match<string::const_iterator>  ssub_match;
 typedef sub_match<wstring::const_iterator> wssub_match;
 
 template <class BiIter>
     bool
     operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator<(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator<=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator>=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 
 template <class BiIter, class ST, class SA>
     bool
     operator==(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
                const sub_match<BiIter>& rhs);
 
 template <class BiIter, class ST, class SA>
     bool
     operator!=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
                const sub_match<BiIter>& rhs);
 
 template <class BiIter, class ST, class SA>
     bool
     operator<(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
               const sub_match<BiIter>& rhs);
 
 template <class BiIter, class ST, class SA>
     bool
     operator>(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
               const sub_match<BiIter>& rhs);
 
 template <class BiIter, class ST, class SA>
     bool operator>=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
                     const sub_match<BiIter>& rhs);
 
 template <class BiIter, class ST, class SA>
     bool
     operator<=(const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
                const sub_match<BiIter>& rhs);
 
 template <class BiIter, class ST, class SA>
     bool
     operator==(const sub_match<BiIter>& lhs,
                const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
 template <class BiIter, class ST, class SA>
     bool
     operator!=(const sub_match<BiIter>& lhs,
                const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
 template <class BiIter, class ST, class SA>
     bool
     operator<(const sub_match<BiIter>& lhs,
               const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
 template <class BiIter, class ST, class SA>
     bool operator>(const sub_match<BiIter>& lhs,
                    const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
 template <class BiIter, class ST, class SA>
     bool
     operator>=(const sub_match<BiIter>& lhs,
                const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
 template <class BiIter, class ST, class SA>
     bool
     operator<=(const sub_match<BiIter>& lhs,
                const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
 template <class BiIter>
     bool
     operator==(typename iterator_traits<BiIter>::value_type const* lhs,
                const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator!=(typename iterator_traits<BiIter>::value_type const* lhs,
                const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator<(typename iterator_traits<BiIter>::value_type const* lhs,
               const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator>(typename iterator_traits<BiIter>::value_type const* lhs,
               const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator>=(typename iterator_traits<BiIter>::value_type const* lhs,
                const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator<=(typename iterator_traits<BiIter>::value_type const* lhs,
                const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator==(const sub_match<BiIter>& lhs,
                typename iterator_traits<BiIter>::value_type const* rhs);
 
 template <class BiIter>
     bool
     operator!=(const sub_match<BiIter>& lhs,
                typename iterator_traits<BiIter>::value_type const* rhs);
 
 template <class BiIter>
     bool
     operator<(const sub_match<BiIter>& lhs,
               typename iterator_traits<BiIter>::value_type const* rhs);
 
 template <class BiIter>
     bool
     operator>(const sub_match<BiIter>& lhs,
               typename iterator_traits<BiIter>::value_type const* rhs);
 
 template <class BiIter>
     bool
     operator>=(const sub_match<BiIter>& lhs,
                typename iterator_traits<BiIter>::value_type const* rhs);
 
 template <class BiIter>
     bool
     operator<=(const sub_match<BiIter>& lhs,
                typename iterator_traits<BiIter>::value_type const* rhs);
 
 template <class BiIter>
     bool
     operator==(typename iterator_traits<BiIter>::value_type const& lhs,
                const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator!=(typename iterator_traits<BiIter>::value_type const& lhs,
                const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator<(typename iterator_traits<BiIter>::value_type const& lhs,
               const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator>(typename iterator_traits<BiIter>::value_type const& lhs,
               const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator>=(typename iterator_traits<BiIter>::value_type const& lhs,
                const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator<=(typename iterator_traits<BiIter>::value_type const& lhs,
                const sub_match<BiIter>& rhs);
 
 template <class BiIter>
     bool
     operator==(const sub_match<BiIter>& lhs,
                typename iterator_traits<BiIter>::value_type const& rhs);
 
 template <class BiIter>
     bool
     operator!=(const sub_match<BiIter>& lhs,
                typename iterator_traits<BiIter>::value_type const& rhs);
 
 template <class BiIter>
     bool
     operator<(const sub_match<BiIter>& lhs,
               typename iterator_traits<BiIter>::value_type const& rhs);
 
 template <class BiIter>
     bool
     operator>(const sub_match<BiIter>& lhs,
               typename iterator_traits<BiIter>::value_type const& rhs);
 
 template <class BiIter>
     bool
     operator>=(const sub_match<BiIter>& lhs,
                typename iterator_traits<BiIter>::value_type const& rhs);
 
 template <class BiIter>
     bool
     operator<=(const sub_match<BiIter>& lhs,
                typename iterator_traits<BiIter>::value_type const& rhs);
 
 template <class charT, class ST, class BiIter>
     basic_ostream<charT, ST>&
     operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
 
 template <class BidirectionalIterator,
           class Allocator = allocator<sub_match<BidirectionalIterator>>>
 class match_results
 {
 public:
     typedef sub_match<BidirectionalIterator>                  value_type;
     typedef const value_type&                                 const_reference;
     typedef value_type&                                       reference;
     typedef /implementation-defined/                          const_iterator;
     typedef const_iterator                                    iterator;
     typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
     typedef typename allocator_traits<Allocator>::size_type   size_type;
     typedef Allocator                                         allocator_type;
     typedef typename iterator_traits<BidirectionalIterator>::value_type char_type;
     typedef basic_string<char_type>                           string_type;
 
     // construct/copy/destroy:
     explicit match_results(const Allocator& a = Allocator());
     match_results(const match_results& m);
     match_results(match_results&& m) noexcept;
     match_results& operator=(const match_results& m);
     match_results& operator=(match_results&& m);
     ~match_results();
 
     bool ready() const;
 
     // size:
     size_type size() const;
     size_type max_size() const;
     bool empty() const;
 
     // element access:
     difference_type length(size_type sub = 0) const;
     difference_type position(size_type sub = 0) const;
     string_type str(size_type sub = 0) const;
     const_reference operator[](size_type n) const;
 
     const_reference prefix() const;
     const_reference suffix() const;
 
     const_iterator begin() const;
     const_iterator end() const;
     const_iterator cbegin() const;
     const_iterator cend() const;
 
     // format:
     template <class OutputIter>
         OutputIter
         format(OutputIter out, const char_type* fmt_first,
                const char_type* fmt_last,
                regex_constants::match_flag_type flags = regex_constants::format_default) const;
     template <class OutputIter, class ST, class SA>
         OutputIter
         format(OutputIter out, const basic_string<char_type, ST, SA>& fmt,
                regex_constants::match_flag_type flags = regex_constants::format_default) const;
     template <class ST, class SA>
         basic_string<char_type, ST, SA>
         format(const basic_string<char_type, ST, SA>& fmt,
                regex_constants::match_flag_type flags = regex_constants::format_default) const;
     string_type
         format(const char_type* fmt,
                regex_constants::match_flag_type flags = regex_constants::format_default) const;
 
     // allocator:
     allocator_type get_allocator() const;
 
     // swap:
     void swap(match_results& that);
 };
 
 typedef match_results<const char*>             cmatch;
 typedef match_results<const wchar_t*>          wcmatch;
 typedef match_results<string::const_iterator>  smatch;
 typedef match_results<wstring::const_iterator> wsmatch;
 
 template <class BidirectionalIterator, class Allocator>
     bool
     operator==(const match_results<BidirectionalIterator, Allocator>& m1,
                const match_results<BidirectionalIterator, Allocator>& m2);
 
 template <class BidirectionalIterator, class Allocator>
     bool
     operator!=(const match_results<BidirectionalIterator, Allocator>& m1,
                const match_results<BidirectionalIterator, Allocator>& m2);
 
 template <class BidirectionalIterator, class Allocator>
     void
     swap(match_results<BidirectionalIterator, Allocator>& m1,
          match_results<BidirectionalIterator, Allocator>& m2);
 
 template <class BidirectionalIterator, class Allocator, class charT, class traits>
     bool
     regex_match(BidirectionalIterator first, BidirectionalIterator last,
                 match_results<BidirectionalIterator, Allocator>& m,
                 const basic_regex<charT, traits>& e,
                 regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class BidirectionalIterator, class charT, class traits>
     bool
     regex_match(BidirectionalIterator first, BidirectionalIterator last,
                 const basic_regex<charT, traits>& e,
                 regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class charT, class Allocator, class traits>
     bool
     regex_match(const charT* str, match_results<const charT*, Allocator>& m,
                 const basic_regex<charT, traits>& e,
                 regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class ST, class SA, class Allocator, class charT, class traits>
     bool
     regex_match(const basic_string<charT, ST, SA>& s,
                 match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
                 const basic_regex<charT, traits>& e,
                 regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class ST, class SA, class Allocator, class charT, class traits>
     bool
     regex_match(const basic_string<charT, ST, SA>&& s,
                 match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
                 const basic_regex<charT, traits>& e,
                 regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // C++14
 
 template <class charT, class traits>
     bool
     regex_match(const charT* str, const basic_regex<charT, traits>& e,
                 regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class ST, class SA, class charT, class traits>
     bool
     regex_match(const basic_string<charT, ST, SA>& s,
                 const basic_regex<charT, traits>& e,
                 regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class BidirectionalIterator, class Allocator, class charT, class traits>
     bool
     regex_search(BidirectionalIterator first, BidirectionalIterator last,
                  match_results<BidirectionalIterator, Allocator>& m,
                  const basic_regex<charT, traits>& e,
                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class BidirectionalIterator, class charT, class traits>
     bool
     regex_search(BidirectionalIterator first, BidirectionalIterator last,
                  const basic_regex<charT, traits>& e,
                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class charT, class Allocator, class traits>
     bool
     regex_search(const charT* str, match_results<const charT*, Allocator>& m,
                  const basic_regex<charT, traits>& e,
                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class charT, class traits>
     bool
     regex_search(const charT* str, const basic_regex<charT, traits>& e,
                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class ST, class SA, class charT, class traits>
     bool
     regex_search(const basic_string<charT, ST, SA>& s,
                  const basic_regex<charT, traits>& e,
                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class ST, class SA, class Allocator, class charT, class traits>
     bool
     regex_search(const basic_string<charT, ST, SA>& s,
                  match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
                  const basic_regex<charT, traits>& e,
                  regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class ST, class SA, class Allocator, class charT, class traits>
     bool
     regex_search(const basic_string<charT, ST, SA>&& s,
                  match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
                  const basic_regex<charT, traits>& e,
                  regex_constants::match_flag_type flags = regex_constants::match_default) = delete; // C++14
 
 template <class OutputIterator, class BidirectionalIterator,
           class traits, class charT, class ST, class SA>
     OutputIterator
     regex_replace(OutputIterator out,
                   BidirectionalIterator first, BidirectionalIterator last,
                   const basic_regex<charT, traits>& e,
                   const basic_string<charT, ST, SA>& fmt,
                   regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class OutputIterator, class BidirectionalIterator,
           class traits, class charT>
     OutputIterator
     regex_replace(OutputIterator out,
                   BidirectionalIterator first, BidirectionalIterator last,
                   const basic_regex<charT, traits>& e, const charT* fmt,
                   regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class traits, class charT, class ST, class SA, class FST, class FSA>>
     basic_string<charT, ST, SA>
     regex_replace(const basic_string<charT, ST, SA>& s,
                   const basic_regex<charT, traits>& e,
                   const basic_string<charT, FST, FSA>& fmt,
                   regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class traits, class charT, class ST, class SA>
     basic_string<charT, ST, SA>
     regex_replace(const basic_string<charT, ST, SA>& s,
                   const basic_regex<charT, traits>& e, const charT* fmt,
                   regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class traits, class charT, class ST, class SA>
     basic_string<charT>
     regex_replace(const charT* s,
                   const basic_regex<charT, traits>& e,
                   const basic_string<charT, ST, SA>& fmt,
                   regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class traits, class charT>
     basic_string<charT>
     regex_replace(const charT* s,
                   const basic_regex<charT, traits>& e,
                   const charT* fmt,
                   regex_constants::match_flag_type flags = regex_constants::match_default);
 
 template <class BidirectionalIterator,
           class charT = typename iterator_traits< BidirectionalIterator>::value_type,
           class traits = regex_traits<charT>>
 class regex_iterator
 {
 public:
     typedef basic_regex<charT, traits>           regex_type;
     typedef match_results<BidirectionalIterator> value_type;
     typedef ptrdiff_t                            difference_type;
     typedef const value_type*                    pointer;
     typedef const value_type&                    reference;
     typedef forward_iterator_tag                 iterator_category;
 
     regex_iterator();
     regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
                    const regex_type& re,
                    regex_constants::match_flag_type m = regex_constants::match_default);
     regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                    const regex_type&& __re,
                    regex_constants::match_flag_type __m
                                      = regex_constants::match_default) = delete; // C++14
     regex_iterator(const regex_iterator&);
     regex_iterator& operator=(const regex_iterator&);
 
     bool operator==(const regex_iterator&) const;
     bool operator!=(const regex_iterator&) const;
 
     const value_type& operator*() const;
     const value_type* operator->() const;
 
     regex_iterator& operator++();
     regex_iterator operator++(int);
 };
 
 typedef regex_iterator<const char*>             cregex_iterator;
 typedef regex_iterator<const wchar_t*>          wcregex_iterator;
 typedef regex_iterator<string::const_iterator>  sregex_iterator;
 typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
 
 template <class BidirectionalIterator,
           class charT = typename iterator_traits< BidirectionalIterator>::value_type,
           class traits = regex_traits<charT>>
 class regex_token_iterator
 {
 public:
     typedef basic_regex<charT, traits>       regex_type;
     typedef sub_match<BidirectionalIterator> value_type;
     typedef ptrdiff_t                        difference_type;
     typedef const value_type*                pointer;
     typedef const value_type&                reference;
     typedef forward_iterator_tag             iterator_category;
 
     regex_token_iterator();
     regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
                          const regex_type& re, int submatch = 0,
                          regex_constants::match_flag_type m = regex_constants::match_default);
     regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
                          const regex_type&& re, int submatch = 0,
                          regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
     regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
                          const regex_type& re, const vector<int>& submatches,
                          regex_constants::match_flag_type m = regex_constants::match_default);
     regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
                          const regex_type&& re, const vector<int>& submatches,
                          regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
     regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
                          const regex_type& re, initializer_list<int> submatches,
                          regex_constants::match_flag_type m = regex_constants::match_default);
     regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
                          const regex_type&& re, initializer_list<int> submatches,
                          regex_constants::match_flag_type m = regex_constants::match_default) = delete; // C++14
     template <size_t N>
         regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
                              const regex_type& re, const int (&submatches)[N],
                              regex_constants::match_flag_type m = regex_constants::match_default);
     template <size_t N>
         regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
                              const regex_type& re, const int (&submatches)[N],
                              regex_constants::match_flag_type m = regex_constants::match_default) = delete // C++14;
     regex_token_iterator(const regex_token_iterator&);
     regex_token_iterator& operator=(const regex_token_iterator&);
 
     bool operator==(const regex_token_iterator&) const;
     bool operator!=(const regex_token_iterator&) const;
 
     const value_type& operator*() const;
     const value_type* operator->() const;
 
     regex_token_iterator& operator++();
     regex_token_iterator operator++(int);
 };
 
 typedef regex_token_iterator<const char*>             cregex_token_iterator;
 typedef regex_token_iterator<const wchar_t*>          wcregex_token_iterator;
 typedef regex_token_iterator<string::const_iterator>  sregex_token_iterator;
 typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
 
 } // std
 */
 
 #include <__config>
 #include <stdexcept>
 #include <__locale>
 #include <initializer_list>
 #include <utility>
 #include <iterator>
 #include <string>
 #include <memory>
 #include <vector>
 #include <deque>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 
 #define _LIBCPP_REGEX_COMPLEXITY_FACTOR 4096
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace regex_constants
 {
 
 // syntax_option_type
 
 enum syntax_option_type
 {
     icase      = 1 << 0,
     nosubs     = 1 << 1,
     optimize   = 1 << 2,
     collate    = 1 << 3,
 #ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
     ECMAScript = 1 << 9,
 #else
     ECMAScript = 0,
 #endif
     basic      = 1 << 4,
     extended   = 1 << 5,
     awk        = 1 << 6,
     grep       = 1 << 7,
     egrep      = 1 << 8
 };
 
 inline _LIBCPP_CONSTEXPR
 syntax_option_type __get_grammar(syntax_option_type __g)
 {
 #ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
     return static_cast<syntax_option_type>(__g & 0x3F0);
 #else
     return static_cast<syntax_option_type>(__g & 0x1F0);
 #endif
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
 syntax_option_type
 operator~(syntax_option_type __x)
 {
     return syntax_option_type(~int(__x) & 0x1FF);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
 syntax_option_type
 operator&(syntax_option_type __x, syntax_option_type __y)
 {
     return syntax_option_type(int(__x) & int(__y));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
 syntax_option_type
 operator|(syntax_option_type __x, syntax_option_type __y)
 {
     return syntax_option_type(int(__x) | int(__y));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
 syntax_option_type
 operator^(syntax_option_type __x, syntax_option_type __y)
 {
     return syntax_option_type(int(__x) ^ int(__y));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 syntax_option_type&
 operator&=(syntax_option_type& __x, syntax_option_type __y)
 {
     __x = __x & __y;
     return __x;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 syntax_option_type&
 operator|=(syntax_option_type& __x, syntax_option_type __y)
 {
     __x = __x | __y;
     return __x;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 syntax_option_type&
 operator^=(syntax_option_type& __x, syntax_option_type __y)
 {
     __x = __x ^ __y;
     return __x;
 }
 
 // match_flag_type
 
 enum match_flag_type
 {
     match_default     = 0,
     match_not_bol     = 1 << 0,
     match_not_eol     = 1 << 1,
     match_not_bow     = 1 << 2,
     match_not_eow     = 1 << 3,
     match_any         = 1 << 4,
     match_not_null    = 1 << 5,
     match_continuous  = 1 << 6,
     match_prev_avail  = 1 << 7,
     format_default    = 0,
     format_sed        = 1 << 8,
     format_no_copy    = 1 << 9,
     format_first_only = 1 << 10,
     __no_update_pos   = 1 << 11,
     __full_match      = 1 << 12
 };
 
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
 match_flag_type
 operator~(match_flag_type __x)
 {
     return match_flag_type(~int(__x) & 0x0FFF);
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
 match_flag_type
 operator&(match_flag_type __x, match_flag_type __y)
 {
     return match_flag_type(int(__x) & int(__y));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
 match_flag_type
 operator|(match_flag_type __x, match_flag_type __y)
 {
     return match_flag_type(int(__x) | int(__y));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR
 match_flag_type
 operator^(match_flag_type __x, match_flag_type __y)
 {
     return match_flag_type(int(__x) ^ int(__y));
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 match_flag_type&
 operator&=(match_flag_type& __x, match_flag_type __y)
 {
     __x = __x & __y;
     return __x;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 match_flag_type&
 operator|=(match_flag_type& __x, match_flag_type __y)
 {
     __x = __x | __y;
     return __x;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 match_flag_type&
 operator^=(match_flag_type& __x, match_flag_type __y)
 {
     __x = __x ^ __y;
     return __x;
 }
 
 enum error_type
 {
     error_collate = 1,
     error_ctype,
     error_escape,
     error_backref,
     error_brack,
     error_paren,
     error_brace,
     error_badbrace,
     error_range,
     error_space,
     error_badrepeat,
     error_complexity,
     error_stack,
     __re_err_grammar,
     __re_err_empty,
     __re_err_unknown,
     __re_err_parse
 };
 
 }  // regex_constants
 
 class _LIBCPP_EXCEPTION_ABI regex_error
     : public runtime_error
 {
     regex_constants::error_type __code_;
 public:
     explicit regex_error(regex_constants::error_type __ecode);
-    virtual ~regex_error() throw();
+    regex_error(const regex_error&) _NOEXCEPT = default;
+    virtual ~regex_error() _NOEXCEPT;
      _LIBCPP_INLINE_VISIBILITY
     regex_constants::error_type code() const {return __code_;}
 };
 
 template <regex_constants::error_type _Ev>
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_regex_error()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw regex_error(_Ev);
 #else
     _VSTD::abort();
 #endif
 }
 
 template <class _CharT>
 struct _LIBCPP_TEMPLATE_VIS regex_traits
 {
 public:
     typedef _CharT                  char_type;
     typedef basic_string<char_type> string_type;
     typedef locale                  locale_type;
     typedef ctype_base::mask        char_class_type;
 
     static const char_class_type __regex_word = ctype_base::__regex_word;
 private:
     locale __loc_;
     const ctype<char_type>* __ct_;
     const collate<char_type>* __col_;
 
 public:
     regex_traits();
 
     _LIBCPP_INLINE_VISIBILITY
     static size_t length(const char_type* __p)
         {return char_traits<char_type>::length(__p);}
     _LIBCPP_INLINE_VISIBILITY
     char_type translate(char_type __c) const {return __c;}
     char_type translate_nocase(char_type __c) const;
     template <class _ForwardIterator>
         string_type
         transform(_ForwardIterator __f, _ForwardIterator __l) const;
     template <class _ForwardIterator>
         _LIBCPP_INLINE_VISIBILITY
         string_type
         transform_primary( _ForwardIterator __f, _ForwardIterator __l) const
             {return __transform_primary(__f, __l, char_type());}
     template <class _ForwardIterator>
         _LIBCPP_INLINE_VISIBILITY
         string_type
         lookup_collatename(_ForwardIterator __f, _ForwardIterator __l) const
             {return __lookup_collatename(__f, __l, char_type());}
     template <class _ForwardIterator>
         _LIBCPP_INLINE_VISIBILITY
         char_class_type
         lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
                          bool __icase = false) const
             {return __lookup_classname(__f, __l, __icase, char_type());}
     bool isctype(char_type __c, char_class_type __m) const;
     _LIBCPP_INLINE_VISIBILITY
     int value(char_type __ch, int __radix) const
         {return __regex_traits_value(__ch, __radix);}
     locale_type imbue(locale_type __l);
     _LIBCPP_INLINE_VISIBILITY
     locale_type getloc()const {return __loc_;}
 
 private:
     void __init();
 
     template <class _ForwardIterator>
         string_type
         __transform_primary(_ForwardIterator __f, _ForwardIterator __l, char) const;
     template <class _ForwardIterator>
         string_type
         __transform_primary(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;
 
     template <class _ForwardIterator>
         string_type
         __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, char) const;
     template <class _ForwardIterator>
         string_type
         __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;
 
     template <class _ForwardIterator>
         char_class_type
         __lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
                            bool __icase, char) const;
     template <class _ForwardIterator>
         char_class_type
         __lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
                            bool __icase, wchar_t) const;
 
     static int __regex_traits_value(unsigned char __ch, int __radix);
     _LIBCPP_INLINE_VISIBILITY
     int __regex_traits_value(char __ch, int __radix) const
         {return __regex_traits_value(static_cast<unsigned char>(__ch), __radix);}
     _LIBCPP_INLINE_VISIBILITY
     int __regex_traits_value(wchar_t __ch, int __radix) const;
 };
 
 template <class _CharT>
 const typename regex_traits<_CharT>::char_class_type
 regex_traits<_CharT>::__regex_word;
 
 template <class _CharT>
 regex_traits<_CharT>::regex_traits()
 {
     __init();
 }
 
 template <class _CharT>
 typename regex_traits<_CharT>::char_type
 regex_traits<_CharT>::translate_nocase(char_type __c) const
 {
     return __ct_->tolower(__c);
 }
 
 template <class _CharT>
 template <class _ForwardIterator>
 typename regex_traits<_CharT>::string_type
 regex_traits<_CharT>::transform(_ForwardIterator __f, _ForwardIterator __l) const
 {
     string_type __s(__f, __l);
     return __col_->transform(__s.data(), __s.data() + __s.size());
 }
 
 template <class _CharT>
 void
 regex_traits<_CharT>::__init()
 {
     __ct_ = &use_facet<ctype<char_type> >(__loc_);
     __col_ = &use_facet<collate<char_type> >(__loc_);
 }
 
 template <class _CharT>
 typename regex_traits<_CharT>::locale_type
 regex_traits<_CharT>::imbue(locale_type __l)
 {
     locale __r = __loc_;
     __loc_ = __l;
     __init();
     return __r;
 }
 
 // transform_primary is very FreeBSD-specific
 
 template <class _CharT>
 template <class _ForwardIterator>
 typename regex_traits<_CharT>::string_type
 regex_traits<_CharT>::__transform_primary(_ForwardIterator __f,
                                           _ForwardIterator __l, char) const
 {
     const string_type __s(__f, __l);
     string_type __d = __col_->transform(__s.data(), __s.data() + __s.size());
     switch (__d.size())
     {
     case 1:
         break;
     case 12:
         __d[11] = __d[3];
         break;
     default:
         __d.clear();
         break;
     }
     return __d;
 }
 
 template <class _CharT>
 template <class _ForwardIterator>
 typename regex_traits<_CharT>::string_type
 regex_traits<_CharT>::__transform_primary(_ForwardIterator __f,
                                           _ForwardIterator __l, wchar_t) const
 {
     const string_type __s(__f, __l);
     string_type __d = __col_->transform(__s.data(), __s.data() + __s.size());
     switch (__d.size())
     {
     case 1:
         break;
     case 3:
         __d[2] = __d[0];
         break;
     default:
         __d.clear();
         break;
     }
     return __d;
 }
 
 // lookup_collatename is very FreeBSD-specific
 
 _LIBCPP_FUNC_VIS string __get_collation_name(const char* __s);
 
 template <class _CharT>
 template <class _ForwardIterator>
 typename regex_traits<_CharT>::string_type
 regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f,
                                            _ForwardIterator __l, char) const
 {
     string_type __s(__f, __l);
     string_type __r;
     if (!__s.empty())
     {
         __r = __get_collation_name(__s.c_str());
         if (__r.empty() && __s.size() <= 2)
         {
             __r = __col_->transform(__s.data(), __s.data() + __s.size());
             if (__r.size() == 1 || __r.size() == 12)
                 __r = __s;
             else
                 __r.clear();
         }
     }
     return __r;
 }
 
 template <class _CharT>
 template <class _ForwardIterator>
 typename regex_traits<_CharT>::string_type
 regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f,
                                            _ForwardIterator __l, wchar_t) const
 {
     string_type __s(__f, __l);
     string __n;
     __n.reserve(__s.size());
     for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end();
                                                               __i != __e; ++__i)
     {
         if (static_cast<unsigned>(*__i) >= 127)
             return string_type();
         __n.push_back(char(*__i));
     }
     string_type __r;
     if (!__s.empty())
     {
         __n = __get_collation_name(__n.c_str());
         if (!__n.empty())
             __r.assign(__n.begin(), __n.end());
         else if (__s.size() <= 2)
         {
             __r = __col_->transform(__s.data(), __s.data() + __s.size());
             if (__r.size() == 1 || __r.size() == 3)
                 __r = __s;
             else
                 __r.clear();
         }
     }
     return __r;
 }
 
 // lookup_classname
 
 regex_traits<char>::char_class_type _LIBCPP_FUNC_VIS
 __get_classname(const char* __s, bool __icase);
 
 template <class _CharT>
 template <class _ForwardIterator>
 typename regex_traits<_CharT>::char_class_type
 regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f,
                                          _ForwardIterator __l,
                                          bool __icase, char) const
 {
     string_type __s(__f, __l);
     __ct_->tolower(&__s[0], &__s[0] + __s.size());
     return __get_classname(__s.c_str(), __icase);
 }
 
 template <class _CharT>
 template <class _ForwardIterator>
 typename regex_traits<_CharT>::char_class_type
 regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f,
                                          _ForwardIterator __l,
                                          bool __icase, wchar_t) const
 {
     string_type __s(__f, __l);
     __ct_->tolower(&__s[0], &__s[0] + __s.size());
     string __n;
     __n.reserve(__s.size());
     for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end();
                                                               __i != __e; ++__i)
     {
         if (static_cast<unsigned>(*__i) >= 127)
             return char_class_type();
         __n.push_back(char(*__i));
     }
     return __get_classname(__n.c_str(), __icase);
 }
 
 template <class _CharT>
 bool
 regex_traits<_CharT>::isctype(char_type __c, char_class_type __m) const
 {
     if (__ct_->is(__m, __c))
         return true;
     return (__c == '_' && (__m & __regex_word));
 }
 
 template <class _CharT>
 int
 regex_traits<_CharT>::__regex_traits_value(unsigned char __ch, int __radix)
 {
     if ((__ch & 0xF8u) == 0x30)  // '0' <= __ch && __ch <= '7'
         return __ch - '0';
     if (__radix != 8)
     {
         if ((__ch & 0xFEu) == 0x38)  // '8' <= __ch && __ch <= '9'
             return __ch - '0';
         if (__radix == 16)
         {
             __ch |= 0x20;  // tolower
             if ('a' <= __ch && __ch <= 'f')
                 return __ch - ('a' - 10);
         }
     }
     return -1;
 }
 
 template <class _CharT>
 inline
 int
 regex_traits<_CharT>::__regex_traits_value(wchar_t __ch, int __radix) const
 {
     return __regex_traits_value(static_cast<unsigned char>(__ct_->narrow(__ch, char_type())), __radix);
 }
 
 template <class _CharT> class __node;
 
 template <class _BidirectionalIterator> class _LIBCPP_TEMPLATE_VIS sub_match;
 
 template <class _BidirectionalIterator,
           class _Allocator = allocator<sub_match<_BidirectionalIterator> > >
 class _LIBCPP_TEMPLATE_VIS match_results;
 
 template <class _CharT>
 struct __state
 {
     enum
     {
         __end_state = -1000,
         __consume_input,  // -999
         __begin_marked_expr, // -998
         __end_marked_expr,   // -997
         __pop_state,           // -996
         __accept_and_consume,  // -995
         __accept_but_not_consume,  // -994
         __reject,                  // -993
         __split,
         __repeat
     };
 
     int __do_;
     const _CharT* __first_;
     const _CharT* __current_;
     const _CharT* __last_;
     vector<sub_match<const _CharT*> > __sub_matches_;
     vector<pair<size_t, const _CharT*> > __loop_data_;
     const __node<_CharT>* __node_;
     regex_constants::match_flag_type __flags_;
     bool __at_first_;
 
     _LIBCPP_INLINE_VISIBILITY
     __state()
         : __do_(0), __first_(nullptr), __current_(nullptr), __last_(nullptr),
           __node_(nullptr), __flags_() {}
 };
 
 // __node
 
 template <class _CharT>
 class __node
 {
     __node(const __node&);
     __node& operator=(const __node&);
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __node() {}
     _LIBCPP_INLINE_VISIBILITY
     virtual ~__node() {}
 
     _LIBCPP_INLINE_VISIBILITY
     virtual void __exec(__state&) const {}
     _LIBCPP_INLINE_VISIBILITY
     virtual void __exec_split(bool, __state&) const {}
 };
 
 // __end_state
 
 template <class _CharT>
 class __end_state
     : public __node<_CharT>
 {
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __end_state() {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
 __end_state<_CharT>::__exec(__state& __s) const
 {
     __s.__do_ = __state::__end_state;
 }
 
 // __has_one_state
 
 template <class _CharT>
 class __has_one_state
     : public __node<_CharT>
 {
     __node<_CharT>* __first_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __has_one_state(__node<_CharT>* __s)
         : __first_(__s) {}
 
     _LIBCPP_INLINE_VISIBILITY
     __node<_CharT>*  first() const {return __first_;}
     _LIBCPP_INLINE_VISIBILITY
     __node<_CharT>*& first()       {return __first_;}
 };
 
 // __owns_one_state
 
 template <class _CharT>
 class __owns_one_state
     : public __has_one_state<_CharT>
 {
     typedef __has_one_state<_CharT> base;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __owns_one_state(__node<_CharT>* __s)
         : base(__s) {}
 
     virtual ~__owns_one_state();
 };
 
 template <class _CharT>
 __owns_one_state<_CharT>::~__owns_one_state()
 {
     delete this->first();
 }
 
 // __empty_state
 
 template <class _CharT>
 class __empty_state
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __empty_state(__node<_CharT>* __s)
         : base(__s) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
 __empty_state<_CharT>::__exec(__state& __s) const
 {
     __s.__do_ = __state::__accept_but_not_consume;
     __s.__node_ = this->first();
 }
 
 // __empty_non_own_state
 
 template <class _CharT>
 class __empty_non_own_state
     : public __has_one_state<_CharT>
 {
     typedef __has_one_state<_CharT> base;
 
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __empty_non_own_state(__node<_CharT>* __s)
         : base(__s) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
 __empty_non_own_state<_CharT>::__exec(__state& __s) const
 {
     __s.__do_ = __state::__accept_but_not_consume;
     __s.__node_ = this->first();
 }
 
 // __repeat_one_loop
 
 template <class _CharT>
 class __repeat_one_loop
     : public __has_one_state<_CharT>
 {
     typedef __has_one_state<_CharT> base;
 
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __repeat_one_loop(__node<_CharT>* __s)
         : base(__s) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
 __repeat_one_loop<_CharT>::__exec(__state& __s) const
 {
     __s.__do_ = __state::__repeat;
     __s.__node_ = this->first();
 }
 
 // __owns_two_states
 
 template <class _CharT>
 class __owns_two_states
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
     base* __second_;
 
 public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __owns_two_states(__node<_CharT>* __s1, base* __s2)
         : base(__s1), __second_(__s2) {}
 
     virtual ~__owns_two_states();
 
     _LIBCPP_INLINE_VISIBILITY
     base*  second() const {return __second_;}
     _LIBCPP_INLINE_VISIBILITY
     base*& second()       {return __second_;}
 };
 
 template <class _CharT>
 __owns_two_states<_CharT>::~__owns_two_states()
 {
     delete __second_;
 }
 
 // __loop
 
 template <class _CharT>
 class __loop
     : public __owns_two_states<_CharT>
 {
     typedef __owns_two_states<_CharT> base;
 
     size_t __min_;
     size_t __max_;
     unsigned __loop_id_;
     unsigned __mexp_begin_;
     unsigned __mexp_end_;
     bool __greedy_;
 
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __loop(unsigned __loop_id,
                           __node<_CharT>* __s1, __owns_one_state<_CharT>* __s2,
                           unsigned __mexp_begin, unsigned __mexp_end,
                           bool __greedy = true,
                           size_t __min = 0,
                           size_t __max = numeric_limits<size_t>::max())
         : base(__s1, __s2), __min_(__min), __max_(__max), __loop_id_(__loop_id),
           __mexp_begin_(__mexp_begin), __mexp_end_(__mexp_end),
           __greedy_(__greedy) {}
 
     virtual void __exec(__state& __s) const;
     virtual void __exec_split(bool __second, __state& __s) const;
 
 private:
     _LIBCPP_INLINE_VISIBILITY
     void __init_repeat(__state& __s) const
     {
         __s.__loop_data_[__loop_id_].second = __s.__current_;
         for (size_t __i = __mexp_begin_-1; __i != __mexp_end_-1; ++__i)
         {
             __s.__sub_matches_[__i].first = __s.__last_;
             __s.__sub_matches_[__i].second = __s.__last_;
             __s.__sub_matches_[__i].matched = false;
         }
     }
 };
 
 template <class _CharT>
 void
 __loop<_CharT>::__exec(__state& __s) const
 {
     if (__s.__do_ == __state::__repeat)
     {
         bool __do_repeat = ++__s.__loop_data_[__loop_id_].first < __max_;
         bool __do_alt = __s.__loop_data_[__loop_id_].first >= __min_;
         if (__do_repeat && __do_alt &&
                                __s.__loop_data_[__loop_id_].second == __s.__current_)
             __do_repeat = false;
         if (__do_repeat && __do_alt)
             __s.__do_ = __state::__split;
         else if (__do_repeat)
         {
             __s.__do_ = __state::__accept_but_not_consume;
             __s.__node_ = this->first();
             __init_repeat(__s);
         }
         else
         {
             __s.__do_ = __state::__accept_but_not_consume;
             __s.__node_ = this->second();
         }
     }
     else
     {
         __s.__loop_data_[__loop_id_].first = 0;
         bool __do_repeat = 0 < __max_;
         bool __do_alt = 0 >= __min_;
         if (__do_repeat && __do_alt)
             __s.__do_ = __state::__split;
         else if (__do_repeat)
         {
             __s.__do_ = __state::__accept_but_not_consume;
             __s.__node_ = this->first();
             __init_repeat(__s);
         }
         else
         {
             __s.__do_ = __state::__accept_but_not_consume;
             __s.__node_ = this->second();
         }
     }
 }
 
 template <class _CharT>
 void
 __loop<_CharT>::__exec_split(bool __second, __state& __s) const
 {
     __s.__do_ = __state::__accept_but_not_consume;
     if (__greedy_ != __second)
     {
         __s.__node_ = this->first();
         __init_repeat(__s);
     }
     else
         __s.__node_ = this->second();
 }
 
 // __alternate
 
 template <class _CharT>
 class __alternate
     : public __owns_two_states<_CharT>
 {
     typedef __owns_two_states<_CharT> base;
 
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __alternate(__owns_one_state<_CharT>* __s1,
                          __owns_one_state<_CharT>* __s2)
         : base(__s1, __s2) {}
 
     virtual void __exec(__state& __s) const;
     virtual void __exec_split(bool __second, __state& __s) const;
 };
 
 template <class _CharT>
 void
 __alternate<_CharT>::__exec(__state& __s) const
 {
     __s.__do_ = __state::__split;
 }
 
 template <class _CharT>
 void
 __alternate<_CharT>::__exec_split(bool __second, __state& __s) const
 {
     __s.__do_ = __state::__accept_but_not_consume;
     if (__second)
         __s.__node_ = this->second();
     else
         __s.__node_ = this->first();
 }
 
 // __begin_marked_subexpression
 
 template <class _CharT>
 class __begin_marked_subexpression
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
     unsigned __mexp_;
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __begin_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
         : base(__s), __mexp_(__mexp) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
 __begin_marked_subexpression<_CharT>::__exec(__state& __s) const
 {
     __s.__do_ = __state::__accept_but_not_consume;
     __s.__sub_matches_[__mexp_-1].first = __s.__current_;
     __s.__node_ = this->first();
 }
 
 // __end_marked_subexpression
 
 template <class _CharT>
 class __end_marked_subexpression
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
     unsigned __mexp_;
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __end_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
         : base(__s), __mexp_(__mexp) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
 __end_marked_subexpression<_CharT>::__exec(__state& __s) const
 {
     __s.__do_ = __state::__accept_but_not_consume;
     __s.__sub_matches_[__mexp_-1].second = __s.__current_;
     __s.__sub_matches_[__mexp_-1].matched = true;
     __s.__node_ = this->first();
 }
 
 // __back_ref
 
 template <class _CharT>
 class __back_ref
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
     unsigned __mexp_;
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __back_ref(unsigned __mexp, __node<_CharT>* __s)
         : base(__s), __mexp_(__mexp) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
 __back_ref<_CharT>::__exec(__state& __s) const
 {
     if (__mexp_ > __s.__sub_matches_.size())
         __throw_regex_error<regex_constants::error_backref>();
     sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1];
     if (__sm.matched)
     {
         ptrdiff_t __len = __sm.second - __sm.first;
         if (__s.__last_ - __s.__current_ >= __len &&
             _VSTD::equal(__sm.first, __sm.second, __s.__current_))
         {
             __s.__do_ = __state::__accept_but_not_consume;
             __s.__current_ += __len;
             __s.__node_ = this->first();
         }
         else
         {
             __s.__do_ = __state::__reject;
             __s.__node_ = nullptr;
         }
     }
     else
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
 // __back_ref_icase
 
 template <class _CharT, class _Traits>
 class __back_ref_icase
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
     _Traits __traits_;
     unsigned __mexp_;
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __back_ref_icase(const _Traits& __traits, unsigned __mexp,
                               __node<_CharT>* __s)
         : base(__s), __traits_(__traits), __mexp_(__mexp) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT, class _Traits>
 void
 __back_ref_icase<_CharT, _Traits>::__exec(__state& __s) const
 {
     sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1];
     if (__sm.matched)
     {
         ptrdiff_t __len = __sm.second - __sm.first;
         if (__s.__last_ - __s.__current_ >= __len)
         {
             for (ptrdiff_t __i = 0; __i < __len; ++__i)
             {
                 if (__traits_.translate_nocase(__sm.first[__i]) !=
                                 __traits_.translate_nocase(__s.__current_[__i]))
                     goto __not_equal;
             }
             __s.__do_ = __state::__accept_but_not_consume;
             __s.__current_ += __len;
             __s.__node_ = this->first();
         }
         else
         {
             __s.__do_ = __state::__reject;
             __s.__node_ = nullptr;
         }
     }
     else
     {
 __not_equal:
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
 // __back_ref_collate
 
 template <class _CharT, class _Traits>
 class __back_ref_collate
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
     _Traits __traits_;
     unsigned __mexp_;
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __back_ref_collate(const _Traits& __traits, unsigned __mexp,
                               __node<_CharT>* __s)
         : base(__s), __traits_(__traits), __mexp_(__mexp) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT, class _Traits>
 void
 __back_ref_collate<_CharT, _Traits>::__exec(__state& __s) const
 {
     sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1];
     if (__sm.matched)
     {
         ptrdiff_t __len = __sm.second - __sm.first;
         if (__s.__last_ - __s.__current_ >= __len)
         {
             for (ptrdiff_t __i = 0; __i < __len; ++__i)
             {
                 if (__traits_.translate(__sm.first[__i]) !=
                                        __traits_.translate(__s.__current_[__i]))
                     goto __not_equal;
             }
             __s.__do_ = __state::__accept_but_not_consume;
             __s.__current_ += __len;
             __s.__node_ = this->first();
         }
         else
         {
             __s.__do_ = __state::__reject;
             __s.__node_ = nullptr;
         }
     }
     else
     {
 __not_equal:
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
 // __word_boundary
 
 template <class _CharT, class _Traits>
 class __word_boundary
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
     _Traits __traits_;
     bool __invert_;
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __word_boundary(const _Traits& __traits, bool __invert,
                              __node<_CharT>* __s)
         : base(__s), __traits_(__traits), __invert_(__invert) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT, class _Traits>
 void
 __word_boundary<_CharT, _Traits>::__exec(__state& __s) const
 {
     bool __is_word_b = false;
     if (__s.__first_ != __s.__last_)
     {
         if (__s.__current_ == __s.__last_)
         {
             if (!(__s.__flags_ & regex_constants::match_not_eow))
             {
                 _CharT __c = __s.__current_[-1];
                 __is_word_b = __c == '_' ||
                               __traits_.isctype(__c, ctype_base::alnum);
             }
         }
         else if (__s.__current_ == __s.__first_ &&
                 !(__s.__flags_ & regex_constants::match_prev_avail))
         {
             if (!(__s.__flags_ & regex_constants::match_not_bow))
             {
                 _CharT __c = *__s.__current_;
                 __is_word_b = __c == '_' ||
                               __traits_.isctype(__c, ctype_base::alnum);
             }
         }
         else
         {
             _CharT __c1 = __s.__current_[-1];
             _CharT __c2 = *__s.__current_;
             bool __is_c1_b = __c1 == '_' ||
                              __traits_.isctype(__c1, ctype_base::alnum);
             bool __is_c2_b = __c2 == '_' ||
                              __traits_.isctype(__c2, ctype_base::alnum);
             __is_word_b = __is_c1_b != __is_c2_b;
         }
     }
     if (__is_word_b != __invert_)
     {
         __s.__do_ = __state::__accept_but_not_consume;
         __s.__node_ = this->first();
     }
     else
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
 // __l_anchor
 
 template <class _CharT>
 class __l_anchor
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __l_anchor(__node<_CharT>* __s)
         : base(__s) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
 __l_anchor<_CharT>::__exec(__state& __s) const
 {
     if (__s.__at_first_ && __s.__current_ == __s.__first_ &&
         !(__s.__flags_ & regex_constants::match_not_bol))
     {
         __s.__do_ = __state::__accept_but_not_consume;
         __s.__node_ = this->first();
     }
     else
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
 // __r_anchor
 
 template <class _CharT>
 class __r_anchor
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __r_anchor(__node<_CharT>* __s)
         : base(__s) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
 __r_anchor<_CharT>::__exec(__state& __s) const
 {
     if (__s.__current_ == __s.__last_ &&
         !(__s.__flags_ & regex_constants::match_not_eol))
     {
         __s.__do_ = __state::__accept_but_not_consume;
         __s.__node_ = this->first();
     }
     else
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
 // __match_any
 
 template <class _CharT>
 class __match_any
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __match_any(__node<_CharT>* __s)
         : base(__s) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
 __match_any<_CharT>::__exec(__state& __s) const
 {
     if (__s.__current_ != __s.__last_ && *__s.__current_ != 0)
     {
         __s.__do_ = __state::__accept_and_consume;
         ++__s.__current_;
         __s.__node_ = this->first();
     }
     else
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
 // __match_any_but_newline
 
 template <class _CharT>
 class __match_any_but_newline
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __match_any_but_newline(__node<_CharT>* __s)
         : base(__s) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<char>::__exec(__state&) const;
 template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<wchar_t>::__exec(__state&) const;
 
 // __match_char
 
 template <class _CharT>
 class __match_char
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
     _CharT __c_;
 
     __match_char(const __match_char&);
     __match_char& operator=(const __match_char&);
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __match_char(_CharT __c, __node<_CharT>* __s)
         : base(__s), __c_(__c) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
 __match_char<_CharT>::__exec(__state& __s) const
 {
     if (__s.__current_ != __s.__last_ && *__s.__current_ == __c_)
     {
         __s.__do_ = __state::__accept_and_consume;
         ++__s.__current_;
         __s.__node_ = this->first();
     }
     else
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
 // __match_char_icase
 
 template <class _CharT, class _Traits>
 class __match_char_icase
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
     _Traits __traits_;
     _CharT __c_;
 
     __match_char_icase(const __match_char_icase&);
     __match_char_icase& operator=(const __match_char_icase&);
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __match_char_icase(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
         : base(__s), __traits_(__traits), __c_(__traits.translate_nocase(__c)) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT, class _Traits>
 void
 __match_char_icase<_CharT, _Traits>::__exec(__state& __s) const
 {
     if (__s.__current_ != __s.__last_ &&
         __traits_.translate_nocase(*__s.__current_) == __c_)
     {
         __s.__do_ = __state::__accept_and_consume;
         ++__s.__current_;
         __s.__node_ = this->first();
     }
     else
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
 // __match_char_collate
 
 template <class _CharT, class _Traits>
 class __match_char_collate
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
     _Traits __traits_;
     _CharT __c_;
 
     __match_char_collate(const __match_char_collate&);
     __match_char_collate& operator=(const __match_char_collate&);
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __match_char_collate(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
         : base(__s), __traits_(__traits), __c_(__traits.translate(__c)) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT, class _Traits>
 void
 __match_char_collate<_CharT, _Traits>::__exec(__state& __s) const
 {
     if (__s.__current_ != __s.__last_ &&
         __traits_.translate(*__s.__current_) == __c_)
     {
         __s.__do_ = __state::__accept_and_consume;
         ++__s.__current_;
         __s.__node_ = this->first();
     }
     else
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
 // __bracket_expression
 
 template <class _CharT, class _Traits>
 class __bracket_expression
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
     typedef typename _Traits::string_type string_type;
 
     _Traits __traits_;
     vector<_CharT> __chars_;
     vector<_CharT> __neg_chars_;
     vector<pair<string_type, string_type> > __ranges_;
     vector<pair<_CharT, _CharT> > __digraphs_;
     vector<string_type> __equivalences_;
     typename regex_traits<_CharT>::char_class_type __mask_;
     typename regex_traits<_CharT>::char_class_type __neg_mask_;
     bool __negate_;
     bool __icase_;
     bool __collate_;
     bool __might_have_digraph_;
 
     __bracket_expression(const __bracket_expression&);
     __bracket_expression& operator=(const __bracket_expression&);
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __bracket_expression(const _Traits& __traits, __node<_CharT>* __s,
                                  bool __negate, bool __icase, bool __collate)
         : base(__s), __traits_(__traits), __mask_(), __neg_mask_(),
           __negate_(__negate), __icase_(__icase), __collate_(__collate),
           __might_have_digraph_(__traits_.getloc().name() != "C") {}
 
     virtual void __exec(__state&) const;
 
     _LIBCPP_INLINE_VISIBILITY
     bool __negated() const {return __negate_;}
 
     _LIBCPP_INLINE_VISIBILITY
     void __add_char(_CharT __c)
         {
             if (__icase_)
                 __chars_.push_back(__traits_.translate_nocase(__c));
             else if (__collate_)
                 __chars_.push_back(__traits_.translate(__c));
             else
                 __chars_.push_back(__c);
         }
     _LIBCPP_INLINE_VISIBILITY
     void __add_neg_char(_CharT __c)
         {
             if (__icase_)
                 __neg_chars_.push_back(__traits_.translate_nocase(__c));
             else if (__collate_)
                 __neg_chars_.push_back(__traits_.translate(__c));
             else
                 __neg_chars_.push_back(__c);
         }
     _LIBCPP_INLINE_VISIBILITY
     void __add_range(string_type __b, string_type __e)
         {
             if (__collate_)
             {
                 if (__icase_)
                 {
                     for (size_t __i = 0; __i < __b.size(); ++__i)
                         __b[__i] = __traits_.translate_nocase(__b[__i]);
                     for (size_t __i = 0; __i < __e.size(); ++__i)
                         __e[__i] = __traits_.translate_nocase(__e[__i]);
                 }
                 else
                 {
                     for (size_t __i = 0; __i < __b.size(); ++__i)
                         __b[__i] = __traits_.translate(__b[__i]);
                     for (size_t __i = 0; __i < __e.size(); ++__i)
                         __e[__i] = __traits_.translate(__e[__i]);
                 }
                 __ranges_.push_back(make_pair(
                                   __traits_.transform(__b.begin(), __b.end()),
                                   __traits_.transform(__e.begin(), __e.end())));
             }
             else
             {
                 if (__b.size() != 1 || __e.size() != 1)
                     __throw_regex_error<regex_constants::error_range>();
                 if (__icase_)
                 {
                     __b[0] = __traits_.translate_nocase(__b[0]);
                     __e[0] = __traits_.translate_nocase(__e[0]);
                 }
                 __ranges_.push_back(make_pair(_VSTD::move(__b), _VSTD::move(__e)));
             }
         }
     _LIBCPP_INLINE_VISIBILITY
     void __add_digraph(_CharT __c1, _CharT __c2)
         {
             if (__icase_)
                 __digraphs_.push_back(make_pair(__traits_.translate_nocase(__c1),
                                                 __traits_.translate_nocase(__c2)));
             else if (__collate_)
                 __digraphs_.push_back(make_pair(__traits_.translate(__c1),
                                                 __traits_.translate(__c2)));
             else
                 __digraphs_.push_back(make_pair(__c1, __c2));
         }
     _LIBCPP_INLINE_VISIBILITY
     void __add_equivalence(const string_type& __s)
         {__equivalences_.push_back(__s);}
     _LIBCPP_INLINE_VISIBILITY
     void __add_class(typename regex_traits<_CharT>::char_class_type __mask)
         {__mask_ |= __mask;}
     _LIBCPP_INLINE_VISIBILITY
     void __add_neg_class(typename regex_traits<_CharT>::char_class_type __mask)
         {__neg_mask_ |= __mask;}
 };
 
 template <class _CharT, class _Traits>
 void
 __bracket_expression<_CharT, _Traits>::__exec(__state& __s) const
 {
     bool __found = false;
     unsigned __consumed = 0;
     if (__s.__current_ != __s.__last_)
     {
         ++__consumed;
         if (__might_have_digraph_)
         {
             const _CharT* __next = _VSTD::next(__s.__current_);
             if (__next != __s.__last_)
             {
                 pair<_CharT, _CharT> __ch2(*__s.__current_, *__next);
                 if (__icase_)
                 {
                     __ch2.first = __traits_.translate_nocase(__ch2.first);
                     __ch2.second = __traits_.translate_nocase(__ch2.second);
                 }
                 else if (__collate_)
                 {
                     __ch2.first = __traits_.translate(__ch2.first);
                     __ch2.second = __traits_.translate(__ch2.second);
                 }
                 if (!__traits_.lookup_collatename(&__ch2.first, &__ch2.first+2).empty())
                 {
                     // __ch2 is a digraph in this locale
                     ++__consumed;
                     for (size_t __i = 0; __i < __digraphs_.size(); ++__i)
                     {
                         if (__ch2 == __digraphs_[__i])
                         {
                             __found = true;
                             goto __exit;
                         }
                     }
                     if (__collate_ && !__ranges_.empty())
                     {
                         string_type __s2 = __traits_.transform(&__ch2.first,
                                                                &__ch2.first + 2);
                         for (size_t __i = 0; __i < __ranges_.size(); ++__i)
                         {
                             if (__ranges_[__i].first <= __s2 &&
                                 __s2 <= __ranges_[__i].second)
                             {
                                 __found = true;
                                 goto __exit;
                             }
                         }
                     }
                     if (!__equivalences_.empty())
                     {
                         string_type __s2 = __traits_.transform_primary(&__ch2.first,
                                                                        &__ch2.first + 2);
                         for (size_t __i = 0; __i < __equivalences_.size(); ++__i)
                         {
                             if (__s2 == __equivalences_[__i])
                             {
                                 __found = true;
                                 goto __exit;
                             }
                         }
                     }
                     if (__traits_.isctype(__ch2.first, __mask_) &&
                         __traits_.isctype(__ch2.second, __mask_))
                     {
                         __found = true;
                         goto __exit;
                     }
                     if (!__traits_.isctype(__ch2.first, __neg_mask_) &&
                         !__traits_.isctype(__ch2.second, __neg_mask_))
                     {
                         __found = true;
                         goto __exit;
                     }
                     goto __exit;
                 }
             }
         }
         // test *__s.__current_ as not a digraph
         _CharT __ch = *__s.__current_;
         if (__icase_)
             __ch = __traits_.translate_nocase(__ch);
         else if (__collate_)
             __ch = __traits_.translate(__ch);
         for (size_t __i = 0; __i < __chars_.size(); ++__i)
         {
             if (__ch == __chars_[__i])
             {
                 __found = true;
                 goto __exit;
             }
         }
         // When there's at least one of __neg_chars_ and __neg_mask_, the set
         // of "__found" chars is
         //   union(complement(union(__neg_chars_, __neg_mask_)),
         //         other cases...)
         //
         // It doesn't make sense to check this when there are no __neg_chars_
         // and no __neg_mask_.
         if (!(__neg_mask_ == 0 && __neg_chars_.empty()))
         {
             const bool __in_neg_mask = __traits_.isctype(__ch, __neg_mask_);
           const bool __in_neg_chars =
               std::find(__neg_chars_.begin(), __neg_chars_.end(), __ch) !=
               __neg_chars_.end();
           if (!(__in_neg_mask || __in_neg_chars))
           {
             __found = true;
             goto __exit;
           }
         }
         if (!__ranges_.empty())
         {
             string_type __s2 = __collate_ ?
                                    __traits_.transform(&__ch, &__ch + 1) :
                                    string_type(1, __ch);
             for (size_t __i = 0; __i < __ranges_.size(); ++__i)
             {
                 if (__ranges_[__i].first <= __s2 && __s2 <= __ranges_[__i].second)
                 {
                     __found = true;
                     goto __exit;
                 }
             }
         }
         if (!__equivalences_.empty())
         {
             string_type __s2 = __traits_.transform_primary(&__ch, &__ch + 1);
             for (size_t __i = 0; __i < __equivalences_.size(); ++__i)
             {
                 if (__s2 == __equivalences_[__i])
                 {
                     __found = true;
                     goto __exit;
                 }
             }
         }
         if (__traits_.isctype(__ch, __mask_))
         {
             __found = true;
             goto __exit;
         }
     }
     else
         __found = __negate_;  // force reject
 __exit:
     if (__found != __negate_)
     {
         __s.__do_ = __state::__accept_and_consume;
         __s.__current_ += __consumed;
         __s.__node_ = this->first();
     }
     else
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
 template <class _CharT, class _Traits> class __lookahead;
 
 template <class _CharT, class _Traits = regex_traits<_CharT> >
 class _LIBCPP_TEMPLATE_VIS basic_regex
 {
 public:
     // types:
     typedef _CharT                              value_type;
     typedef _Traits                             traits_type;
     typedef typename _Traits::string_type       string_type;
     typedef regex_constants::syntax_option_type flag_type;
     typedef typename _Traits::locale_type       locale_type;
 
 private:
     _Traits   __traits_;
     flag_type __flags_;
     unsigned __marked_count_;
     unsigned __loop_count_;
     int __open_count_;
     shared_ptr<__empty_state<_CharT> > __start_;
     __owns_one_state<_CharT>* __end_;
 
     typedef _VSTD::__state<_CharT> __state;
     typedef _VSTD::__node<_CharT> __node;
 
 public:
     // constants:
     static const regex_constants::syntax_option_type icase = regex_constants::icase;
     static const regex_constants::syntax_option_type nosubs = regex_constants::nosubs;
     static const regex_constants::syntax_option_type optimize = regex_constants::optimize;
     static const regex_constants::syntax_option_type collate = regex_constants::collate;
     static const regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
     static const regex_constants::syntax_option_type basic = regex_constants::basic;
     static const regex_constants::syntax_option_type extended = regex_constants::extended;
     static const regex_constants::syntax_option_type awk = regex_constants::awk;
     static const regex_constants::syntax_option_type grep = regex_constants::grep;
     static const regex_constants::syntax_option_type egrep = regex_constants::egrep;
 
     // construct/copy/destroy:
     _LIBCPP_INLINE_VISIBILITY
     basic_regex()
         : __flags_(regex_constants::ECMAScript), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {}
     _LIBCPP_INLINE_VISIBILITY
     explicit basic_regex(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {
         __init(__p, __p + __traits_.length(__p));
         }
 
     _LIBCPP_INLINE_VISIBILITY
     basic_regex(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript)
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {
         __init(__p, __p + __len);
         }
 
 //     basic_regex(const basic_regex&) = default;
 //     basic_regex(basic_regex&&) = default;
     template <class _ST, class _SA>
         _LIBCPP_INLINE_VISIBILITY
         explicit basic_regex(const basic_string<value_type, _ST, _SA>& __p,
                              flag_type __f = regex_constants::ECMAScript)
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {
         __init(__p.begin(), __p.end());
         }
 
     template <class _ForwardIterator>
         _LIBCPP_INLINE_VISIBILITY
         basic_regex(_ForwardIterator __first, _ForwardIterator __last,
                     flag_type __f = regex_constants::ECMAScript)
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {
         __init(__first, __last);
         }
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_regex(initializer_list<value_type> __il,
                 flag_type __f = regex_constants::ECMAScript)
         : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {
         __init(__il.begin(), __il.end());
         }
 #endif  // _LIBCPP_CXX03_LANG
 
 //    ~basic_regex() = default;
 
 //     basic_regex& operator=(const basic_regex&) = default;
 //     basic_regex& operator=(basic_regex&&) = default;
     _LIBCPP_INLINE_VISIBILITY
     basic_regex& operator=(const value_type* __p)
         {return assign(__p);}
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_regex& operator=(initializer_list<value_type> __il)
         {return assign(__il);}
 #endif  // _LIBCPP_CXX03_LANG
     template <class _ST, class _SA>
         _LIBCPP_INLINE_VISIBILITY
         basic_regex& operator=(const basic_string<value_type, _ST, _SA>& __p)
         {return assign(__p);}
 
     // assign:
     _LIBCPP_INLINE_VISIBILITY
     basic_regex& assign(const basic_regex& __that)
         {return *this = __that;}
 #ifndef _LIBCPP_CXX03_LANG
     _LIBCPP_INLINE_VISIBILITY
     basic_regex& assign(basic_regex&& __that) _NOEXCEPT
         {return *this = _VSTD::move(__that);}
 #endif
     _LIBCPP_INLINE_VISIBILITY
     basic_regex& assign(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
         {return assign(__p, __p + __traits_.length(__p), __f);}
     _LIBCPP_INLINE_VISIBILITY
     basic_regex& assign(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript)
         {return assign(__p, __p + __len, __f);}
     template <class _ST, class _SA>
         _LIBCPP_INLINE_VISIBILITY
         basic_regex& assign(const basic_string<value_type, _ST, _SA>& __s,
                             flag_type __f = regex_constants::ECMAScript)
             {return assign(__s.begin(), __s.end(), __f);}
 
     template <class _InputIterator>
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
              __is_cpp17_input_iterator  <_InputIterator>::value &&
             !__is_cpp17_forward_iterator<_InputIterator>::value,
             basic_regex&
         >::type
         assign(_InputIterator __first, _InputIterator __last,
                             flag_type __f = regex_constants::ECMAScript)
         {
             basic_string<_CharT> __t(__first, __last);
             return assign(__t.begin(), __t.end(), __f);
         }
 
 private:
     _LIBCPP_INLINE_VISIBILITY
     void __member_init(flag_type __f)
     {
         __flags_ = __f;
         __marked_count_ = 0;
         __loop_count_ = 0;
         __open_count_ = 0;
         __end_ = nullptr;
     }
 public:
 
     template <class _ForwardIterator>
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
             __is_cpp17_forward_iterator<_ForwardIterator>::value,
             basic_regex&
         >::type
         assign(_ForwardIterator __first, _ForwardIterator __last,
                             flag_type __f = regex_constants::ECMAScript)
         {
             return assign(basic_regex(__first, __last, __f));
         }
 
 #ifndef _LIBCPP_CXX03_LANG
 
     _LIBCPP_INLINE_VISIBILITY
     basic_regex& assign(initializer_list<value_type> __il,
                         flag_type __f = regex_constants::ECMAScript)
         {return assign(__il.begin(), __il.end(), __f);}
 
 #endif  // _LIBCPP_CXX03_LANG
 
     // const operations:
     _LIBCPP_INLINE_VISIBILITY
     unsigned mark_count() const {return __marked_count_;}
     _LIBCPP_INLINE_VISIBILITY
     flag_type flags() const {return __flags_;}
 
     // locale:
     _LIBCPP_INLINE_VISIBILITY
     locale_type imbue(locale_type __loc)
     {
         __member_init(ECMAScript);
         __start_.reset();
         return __traits_.imbue(__loc);
     }
     _LIBCPP_INLINE_VISIBILITY
     locale_type getloc() const {return __traits_.getloc();}
 
     // swap:
     void swap(basic_regex& __r);
 
 private:
     _LIBCPP_INLINE_VISIBILITY
     unsigned __loop_count() const {return __loop_count_;}
 
     template <class _ForwardIterator>
         void
         __init(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_basic_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_RE_expression(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_simple_RE(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_nondupl_RE(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_one_char_or_coll_elem_RE(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_Back_open_paren(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_Back_close_paren(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_Back_open_brace(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_Back_close_brace(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_BACKREF(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_ORD_CHAR(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_QUOTED_CHAR(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_RE_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last,
                                __owns_one_state<_CharT>* __s,
                                unsigned __mexp_begin, unsigned __mexp_end);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_ERE_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last,
                                 __owns_one_state<_CharT>* __s,
                                 unsigned __mexp_begin, unsigned __mexp_end);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_bracket_expression(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_follow_list(_ForwardIterator __first, _ForwardIterator __last,
                             __bracket_expression<_CharT, _Traits>* __ml);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_expression_term(_ForwardIterator __first, _ForwardIterator __last,
                                 __bracket_expression<_CharT, _Traits>* __ml);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_equivalence_class(_ForwardIterator __first, _ForwardIterator __last,
                                   __bracket_expression<_CharT, _Traits>* __ml);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_character_class(_ForwardIterator __first, _ForwardIterator __last,
                                 __bracket_expression<_CharT, _Traits>* __ml);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_collating_symbol(_ForwardIterator __first, _ForwardIterator __last,
                                  basic_string<_CharT>& __col_sym);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_DUP_COUNT(_ForwardIterator __first, _ForwardIterator __last, int& __c);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_extended_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_ERE_branch(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_ERE_expression(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_one_char_or_coll_elem_ERE(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_ORD_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_QUOTED_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_ecma_exp(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_alternative(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_term(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_assertion(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_atom(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_atom_escape(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_decimal_escape(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_character_class_escape(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_character_escape(_ForwardIterator __first, _ForwardIterator __last,
                                  basic_string<_CharT>* __str = nullptr);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_pattern_character(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_grep(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_egrep(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_class_escape(_ForwardIterator __first, _ForwardIterator __last,
                           basic_string<_CharT>& __str,
                           __bracket_expression<_CharT, _Traits>* __ml);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse_awk_escape(_ForwardIterator __first, _ForwardIterator __last,
                           basic_string<_CharT>* __str = nullptr);
 
     _LIBCPP_INLINE_VISIBILITY
     void __push_l_anchor();
     void __push_r_anchor();
     void __push_match_any();
     void __push_match_any_but_newline();
     _LIBCPP_INLINE_VISIBILITY
     void __push_greedy_inf_repeat(size_t __min, __owns_one_state<_CharT>* __s,
                                   unsigned __mexp_begin = 0, unsigned __mexp_end = 0)
         {__push_loop(__min, numeric_limits<size_t>::max(), __s,
                      __mexp_begin, __mexp_end);}
     _LIBCPP_INLINE_VISIBILITY
     void __push_nongreedy_inf_repeat(size_t __min, __owns_one_state<_CharT>* __s,
                                   unsigned __mexp_begin = 0, unsigned __mexp_end = 0)
         {__push_loop(__min, numeric_limits<size_t>::max(), __s,
                      __mexp_begin, __mexp_end, false);}
     void __push_loop(size_t __min, size_t __max, __owns_one_state<_CharT>* __s,
                      size_t __mexp_begin = 0, size_t __mexp_end = 0,
                      bool __greedy = true);
     __bracket_expression<_CharT, _Traits>* __start_matching_list(bool __negate);
     void __push_char(value_type __c);
     void __push_back_ref(int __i);
     void __push_alternation(__owns_one_state<_CharT>* __sa,
                             __owns_one_state<_CharT>* __sb);
     void __push_begin_marked_subexpression();
     void __push_end_marked_subexpression(unsigned);
     void __push_empty();
     void __push_word_boundary(bool);
     void __push_lookahead(const basic_regex&, bool, unsigned);
 
     template <class _Allocator>
         bool
         __search(const _CharT* __first, const _CharT* __last,
                  match_results<const _CharT*, _Allocator>& __m,
                  regex_constants::match_flag_type __flags) const;
 
     template <class _Allocator>
         bool
         __match_at_start(const _CharT* __first, const _CharT* __last,
                  match_results<const _CharT*, _Allocator>& __m,
                  regex_constants::match_flag_type __flags, bool) const;
     template <class _Allocator>
         bool
         __match_at_start_ecma(const _CharT* __first, const _CharT* __last,
                  match_results<const _CharT*, _Allocator>& __m,
                  regex_constants::match_flag_type __flags, bool) const;
     template <class _Allocator>
         bool
         __match_at_start_posix_nosubs(const _CharT* __first, const _CharT* __last,
                  match_results<const _CharT*, _Allocator>& __m,
                  regex_constants::match_flag_type __flags, bool) const;
     template <class _Allocator>
         bool
         __match_at_start_posix_subs(const _CharT* __first, const _CharT* __last,
                  match_results<const _CharT*, _Allocator>& __m,
                  regex_constants::match_flag_type __flags, bool) const;
 
     template <class _Bp, class _Ap, class _Cp, class _Tp>
     friend
     bool
     regex_search(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&,
                  regex_constants::match_flag_type);
 
     template <class _Ap, class _Cp, class _Tp>
     friend
     bool
     regex_search(const _Cp*, const _Cp*, match_results<const _Cp*, _Ap>&,
                  const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
 
     template <class _Bp, class _Cp, class _Tp>
     friend
     bool
     regex_search(_Bp, _Bp, const basic_regex<_Cp, _Tp>&,
                  regex_constants::match_flag_type);
 
     template <class _Cp, class _Tp>
     friend
     bool
     regex_search(const _Cp*, const _Cp*,
                  const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
 
     template <class _Cp, class _Ap, class _Tp>
     friend
     bool
     regex_search(const _Cp*, match_results<const _Cp*, _Ap>&, const basic_regex<_Cp, _Tp>&,
                  regex_constants::match_flag_type);
 
     template <class _ST, class _SA, class _Cp, class _Tp>
     friend
     bool
     regex_search(const basic_string<_Cp, _ST, _SA>& __s,
                  const basic_regex<_Cp, _Tp>& __e,
                  regex_constants::match_flag_type __flags);
 
     template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
     friend
     bool
     regex_search(const basic_string<_Cp, _ST, _SA>& __s,
                  match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
                  const basic_regex<_Cp, _Tp>& __e,
                  regex_constants::match_flag_type __flags);
 
     template <class _Iter, class _Ap, class _Cp, class _Tp>
     friend
     bool
     regex_search(__wrap_iter<_Iter> __first,
                  __wrap_iter<_Iter> __last,
                  match_results<__wrap_iter<_Iter>, _Ap>& __m,
                  const basic_regex<_Cp, _Tp>& __e,
                  regex_constants::match_flag_type __flags);
 
     template <class, class> friend class __lookahead;
 };
 
 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 template <class _ForwardIterator,
           class = typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value, nullptr_t>::type
 >
 basic_regex(_ForwardIterator, _ForwardIterator,
             regex_constants::syntax_option_type = regex_constants::ECMAScript)
     -> basic_regex<typename iterator_traits<_ForwardIterator>::value_type>;
 #endif
 
 template <class _CharT, class _Traits>
     const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::icase;
 template <class _CharT, class _Traits>
     const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::nosubs;
 template <class _CharT, class _Traits>
     const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::optimize;
 template <class _CharT, class _Traits>
     const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::collate;
 template <class _CharT, class _Traits>
     const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::ECMAScript;
 template <class _CharT, class _Traits>
     const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::basic;
 template <class _CharT, class _Traits>
     const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::extended;
 template <class _CharT, class _Traits>
     const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::awk;
 template <class _CharT, class _Traits>
     const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::grep;
 template <class _CharT, class _Traits>
     const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::egrep;
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::swap(basic_regex& __r)
 {
     using _VSTD::swap;
     swap(__traits_, __r.__traits_);
     swap(__flags_, __r.__flags_);
     swap(__marked_count_, __r.__marked_count_);
     swap(__loop_count_, __r.__loop_count_);
     swap(__open_count_, __r.__open_count_);
     swap(__start_, __r.__start_);
     swap(__end_, __r.__end_);
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(basic_regex<_CharT, _Traits>& __x, basic_regex<_CharT, _Traits>& __y)
 {
     return __x.swap(__y);
 }
 
 // __lookahead
 
 template <class _CharT, class _Traits>
 class __lookahead
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
     basic_regex<_CharT, _Traits> __exp_;
     unsigned __mexp_;
     bool __invert_;
 
     __lookahead(const __lookahead&);
     __lookahead& operator=(const __lookahead&);
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __lookahead(const basic_regex<_CharT, _Traits>& __exp, bool __invert, __node<_CharT>* __s, unsigned __mexp)
         : base(__s), __exp_(__exp), __mexp_(__mexp), __invert_(__invert) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT, class _Traits>
 void
 __lookahead<_CharT, _Traits>::__exec(__state& __s) const
 {
     match_results<const _CharT*> __m;
     __m.__init(1 + __exp_.mark_count(), __s.__current_, __s.__last_);
     bool __matched = __exp_.__match_at_start_ecma(
         __s.__current_, __s.__last_,
         __m,
         (__s.__flags_ | regex_constants::match_continuous) &
         ~regex_constants::__full_match,
         __s.__at_first_ && __s.__current_ == __s.__first_);
     if (__matched != __invert_)
     {
         __s.__do_ = __state::__accept_but_not_consume;
         __s.__node_ = this->first();
         for (unsigned __i = 1; __i < __m.size(); ++__i) {
             __s.__sub_matches_[__mexp_ + __i - 1] = __m.__matches_[__i];
         }
     }
     else
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 void
 basic_regex<_CharT, _Traits>::__init(_ForwardIterator __first, _ForwardIterator __last)
 {
     if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript;
     _ForwardIterator __temp = __parse(__first, __last);
     if ( __temp != __last)
         __throw_regex_error<regex_constants::__re_err_parse>();
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse(_ForwardIterator __first,
                                       _ForwardIterator __last)
 {
     {
         unique_ptr<__node> __h(new __end_state<_CharT>);
         __start_.reset(new __empty_state<_CharT>(__h.get()));
         __h.release();
         __end_ = __start_.get();
     }
     switch (__get_grammar(__flags_))
     {
     case ECMAScript:
         __first = __parse_ecma_exp(__first, __last);
         break;
     case basic:
         __first = __parse_basic_reg_exp(__first, __last);
         break;
     case extended:
     case awk:
         __first = __parse_extended_reg_exp(__first, __last);
         break;
     case grep:
         __first = __parse_grep(__first, __last);
         break;
     case egrep:
         __first = __parse_egrep(__first, __last);
         break;
     default:
         __throw_regex_error<regex_constants::__re_err_grammar>();
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_basic_reg_exp(_ForwardIterator __first,
                                                     _ForwardIterator __last)
 {
     if (__first != __last)
     {
         if (*__first == '^')
         {
             __push_l_anchor();
             ++__first;
         }
         if (__first != __last)
         {
             __first = __parse_RE_expression(__first, __last);
             if (__first != __last)
             {
                 _ForwardIterator __temp = _VSTD::next(__first);
                 if (__temp == __last && *__first == '$')
                 {
                     __push_r_anchor();
                     ++__first;
                 }
             }
         }
         if (__first != __last)
             __throw_regex_error<regex_constants::__re_err_empty>();
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_extended_reg_exp(_ForwardIterator __first,
                                                        _ForwardIterator __last)
 {
     __owns_one_state<_CharT>* __sa = __end_;
     _ForwardIterator __temp = __parse_ERE_branch(__first, __last);
     if (__temp == __first)
         __throw_regex_error<regex_constants::__re_err_empty>();
     __first = __temp;
     while (__first != __last && *__first == '|')
     {
         __owns_one_state<_CharT>* __sb = __end_;
         __temp = __parse_ERE_branch(++__first, __last);
         if (__temp == __first)
             __throw_regex_error<regex_constants::__re_err_empty>();
         __push_alternation(__sa, __sb);
         __first = __temp;
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_ERE_branch(_ForwardIterator __first,
                                                  _ForwardIterator __last)
 {
     _ForwardIterator __temp = __parse_ERE_expression(__first, __last);
     if (__temp == __first)
         __throw_regex_error<regex_constants::__re_err_empty>();
     do
     {
         __first = __temp;
         __temp = __parse_ERE_expression(__first, __last);
     } while (__temp != __first);
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_ERE_expression(_ForwardIterator __first,
                                                      _ForwardIterator __last)
 {
     __owns_one_state<_CharT>* __e = __end_;
     unsigned __mexp_begin = __marked_count_;
     _ForwardIterator __temp = __parse_one_char_or_coll_elem_ERE(__first, __last);
     if (__temp == __first && __temp != __last)
     {
         switch (*__temp)
         {
         case '^':
             __push_l_anchor();
             ++__temp;
             break;
         case '$':
             __push_r_anchor();
             ++__temp;
             break;
         case '(':
             __push_begin_marked_subexpression();
             unsigned __temp_count = __marked_count_;
             ++__open_count_;
             __temp = __parse_extended_reg_exp(++__temp, __last);
             if (__temp == __last || *__temp != ')')
                 __throw_regex_error<regex_constants::error_paren>();
             __push_end_marked_subexpression(__temp_count);
             --__open_count_;
             ++__temp;
             break;
         }
     }
     if (__temp != __first)
         __temp = __parse_ERE_dupl_symbol(__temp, __last, __e, __mexp_begin+1,
                                          __marked_count_+1);
     __first = __temp;
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_RE_expression(_ForwardIterator __first,
                                                     _ForwardIterator __last)
 {
     while (true)
     {
         _ForwardIterator __temp = __parse_simple_RE(__first, __last);
         if (__temp == __first)
             break;
         __first = __temp;
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_simple_RE(_ForwardIterator __first,
                                                 _ForwardIterator __last)
 {
     if (__first != __last)
     {
         __owns_one_state<_CharT>* __e = __end_;
         unsigned __mexp_begin = __marked_count_;
         _ForwardIterator __temp = __parse_nondupl_RE(__first, __last);
         if (__temp != __first)
             __first = __parse_RE_dupl_symbol(__temp, __last, __e,
                                              __mexp_begin+1, __marked_count_+1);
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_nondupl_RE(_ForwardIterator __first,
                                                  _ForwardIterator __last)
 {
     _ForwardIterator __temp = __first;
     __first = __parse_one_char_or_coll_elem_RE(__first, __last);
     if (__temp == __first)
     {
         __temp = __parse_Back_open_paren(__first, __last);
         if (__temp != __first)
         {
             __push_begin_marked_subexpression();
             unsigned __temp_count = __marked_count_;
             __first = __parse_RE_expression(__temp, __last);
             __temp = __parse_Back_close_paren(__first, __last);
             if (__temp == __first)
                 __throw_regex_error<regex_constants::error_paren>();
             __push_end_marked_subexpression(__temp_count);
             __first = __temp;
         }
         else
             __first = __parse_BACKREF(__first, __last);
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_RE(
                                                        _ForwardIterator __first,
                                                        _ForwardIterator __last)
 {
     _ForwardIterator __temp = __parse_ORD_CHAR(__first, __last);
     if (__temp == __first)
     {
         __temp = __parse_QUOTED_CHAR(__first, __last);
         if (__temp == __first)
         {
             if (__temp != __last && *__temp == '.')
             {
                 __push_match_any();
                 ++__temp;
             }
             else
                 __temp = __parse_bracket_expression(__first, __last);
         }
     }
     __first = __temp;
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_ERE(
                                                        _ForwardIterator __first,
                                                        _ForwardIterator __last)
 {
     _ForwardIterator __temp = __parse_ORD_CHAR_ERE(__first, __last);
     if (__temp == __first)
     {
         __temp = __parse_QUOTED_CHAR_ERE(__first, __last);
         if (__temp == __first)
         {
             if (__temp != __last && *__temp == '.')
             {
                 __push_match_any();
                 ++__temp;
             }
             else
                 __temp = __parse_bracket_expression(__first, __last);
         }
     }
     __first = __temp;
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_Back_open_paren(_ForwardIterator __first,
                                                       _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\' && *__temp == '(')
                 __first = ++__temp;
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_Back_close_paren(_ForwardIterator __first,
                                                        _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\' && *__temp == ')')
                 __first = ++__temp;
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_Back_open_brace(_ForwardIterator __first,
                                                       _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\' && *__temp == '{')
                 __first = ++__temp;
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_Back_close_brace(_ForwardIterator __first,
                                                        _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\' && *__temp == '}')
                 __first = ++__temp;
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first,
                                               _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\')
             {
                 int __val = __traits_.value(*__temp, 10);
                 if (__val >= 1 && __val <= 9)
                 {
                     __push_back_ref(__val);
                     __first = ++__temp;
                 }
             }
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_ORD_CHAR(_ForwardIterator __first,
                                                _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp == __last && *__first == '$')
             return __first;
         // Not called inside a bracket
         if (*__first == '.' || *__first == '\\' || *__first == '[')
             return __first;
         __push_char(*__first);
         ++__first;
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_ORD_CHAR_ERE(_ForwardIterator __first,
                                                    _ForwardIterator __last)
 {
     if (__first != __last)
     {
         switch (*__first)
         {
         case '^':
         case '.':
         case '[':
         case '$':
         case '(':
         case '|':
         case '*':
         case '+':
         case '?':
         case '{':
         case '\\':
             break;
         case ')':
             if (__open_count_ == 0)
             {
                 __push_char(*__first);
                 ++__first;
             }
             break;
         default:
             __push_char(*__first);
             ++__first;
             break;
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR(_ForwardIterator __first,
                                                   _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\')
             {
                 switch (*__temp)
                 {
                 case '^':
                 case '.':
                 case '*':
                 case '[':
                 case '$':
                 case '\\':
                     __push_char(*__temp);
                     __first = ++__temp;
                     break;
                 }
             }
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first,
                                                       _ForwardIterator __last)
 {
     if (__first != __last)
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\')
             {
                 switch (*__temp)
                 {
                 case '^':
                 case '.':
                 case '*':
                 case '[':
                 case '$':
                 case '\\':
                 case '(':
                 case ')':
                 case '|':
                 case '+':
                 case '?':
                 case '{':
                 case '}':
                     __push_char(*__temp);
                     __first = ++__temp;
                     break;
                 default:
                     if (__get_grammar(__flags_) == awk)
                         __first = __parse_awk_escape(++__first, __last);
                     break;
                 }
             }
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_RE_dupl_symbol(_ForwardIterator __first,
                                                      _ForwardIterator __last,
                                                      __owns_one_state<_CharT>* __s,
                                                      unsigned __mexp_begin,
                                                      unsigned __mexp_end)
 {
     if (__first != __last)
     {
         if (*__first == '*')
         {
             __push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
             ++__first;
         }
         else
         {
             _ForwardIterator __temp = __parse_Back_open_brace(__first, __last);
             if (__temp != __first)
             {
                 int __min = 0;
                 __first = __temp;
                 __temp = __parse_DUP_COUNT(__first, __last, __min);
                 if (__temp == __first)
                     __throw_regex_error<regex_constants::error_badbrace>();
                 __first = __temp;
                 if (__first == __last)
                     __throw_regex_error<regex_constants::error_brace>();
                 if (*__first != ',')
                 {
                     __temp = __parse_Back_close_brace(__first, __last);
                     if (__temp == __first)
                         __throw_regex_error<regex_constants::error_brace>();
                     __push_loop(__min, __min, __s, __mexp_begin, __mexp_end,
                                     true);
                     __first = __temp;
                 }
                 else
                 {
                     ++__first;  // consume ','
                     int __max = -1;
                     __first = __parse_DUP_COUNT(__first, __last, __max);
                     __temp = __parse_Back_close_brace(__first, __last);
                     if (__temp == __first)
                         __throw_regex_error<regex_constants::error_brace>();
                     if (__max == -1)
                         __push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
                     else
                     {
                         if (__max < __min)
                             __throw_regex_error<regex_constants::error_badbrace>();
                         __push_loop(__min, __max, __s, __mexp_begin, __mexp_end,
                                     true);
                     }
                     __first = __temp;
                 }
             }
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_ERE_dupl_symbol(_ForwardIterator __first,
                                                       _ForwardIterator __last,
                                                       __owns_one_state<_CharT>* __s,
                                                       unsigned __mexp_begin,
                                                       unsigned __mexp_end)
 {
     if (__first != __last)
     {
         unsigned __grammar = __get_grammar(__flags_);
         switch (*__first)
         {
         case '*':
             ++__first;
             if (__grammar == ECMAScript && __first != __last && *__first == '?')
             {
                 ++__first;
                 __push_nongreedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
             }
             else
                 __push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
             break;
         case '+':
             ++__first;
             if (__grammar == ECMAScript && __first != __last && *__first == '?')
             {
                 ++__first;
                 __push_nongreedy_inf_repeat(1, __s, __mexp_begin, __mexp_end);
             }
             else
                 __push_greedy_inf_repeat(1, __s, __mexp_begin, __mexp_end);
             break;
         case '?':
             ++__first;
             if (__grammar == ECMAScript && __first != __last && *__first == '?')
             {
                 ++__first;
                 __push_loop(0, 1, __s, __mexp_begin, __mexp_end, false);
             }
             else
                 __push_loop(0, 1, __s, __mexp_begin, __mexp_end);
             break;
         case '{':
             {
                 int __min;
                 _ForwardIterator __temp = __parse_DUP_COUNT(++__first, __last, __min);
                 if (__temp == __first)
                     __throw_regex_error<regex_constants::error_badbrace>();
                 __first = __temp;
                 if (__first == __last)
                     __throw_regex_error<regex_constants::error_brace>();
                 switch (*__first)
                 {
                 case '}':
                     ++__first;
                     if (__grammar == ECMAScript && __first != __last && *__first == '?')
                     {
                         ++__first;
                         __push_loop(__min, __min, __s, __mexp_begin, __mexp_end, false);
                     }
                     else
                         __push_loop(__min, __min, __s, __mexp_begin, __mexp_end);
                     break;
                 case ',':
                     ++__first;
                     if (__first == __last)
                         __throw_regex_error<regex_constants::error_badbrace>();
                     if (*__first == '}')
                     {
                         ++__first;
                         if (__grammar == ECMAScript && __first != __last && *__first == '?')
                         {
                             ++__first;
                             __push_nongreedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
                         }
                         else
                             __push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
                     }
                     else
                     {
                         int __max = -1;
                         __temp = __parse_DUP_COUNT(__first, __last, __max);
                         if (__temp == __first)
                             __throw_regex_error<regex_constants::error_brace>();
                         __first = __temp;
                         if (__first == __last || *__first != '}')
                             __throw_regex_error<regex_constants::error_brace>();
                         ++__first;
                         if (__max < __min)
                             __throw_regex_error<regex_constants::error_badbrace>();
                         if (__grammar == ECMAScript && __first != __last && *__first == '?')
                         {
                             ++__first;
                             __push_loop(__min, __max, __s, __mexp_begin, __mexp_end, false);
                         }
                         else
                             __push_loop(__min, __max, __s, __mexp_begin, __mexp_end);
                     }
                     break;
                 default:
                     __throw_regex_error<regex_constants::error_badbrace>();
                 }
             }
             break;
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_bracket_expression(_ForwardIterator __first,
                                                          _ForwardIterator __last)
 {
     if (__first != __last && *__first == '[')
     {
         ++__first;
         if (__first == __last)
             __throw_regex_error<regex_constants::error_brack>();
         bool __negate = false;
         if (*__first == '^')
         {
             ++__first;
             __negate = true;
         }
         __bracket_expression<_CharT, _Traits>* __ml = __start_matching_list(__negate);
         // __ml owned by *this
         if (__first == __last)
             __throw_regex_error<regex_constants::error_brack>();
         if (__get_grammar(__flags_) != ECMAScript && *__first == ']')
         {
             __ml->__add_char(']');
             ++__first;
         }
         __first = __parse_follow_list(__first, __last, __ml);
         if (__first == __last)
             __throw_regex_error<regex_constants::error_brack>();
         if (*__first == '-')
         {
             __ml->__add_char('-');
             ++__first;
         }
         if (__first == __last || *__first != ']')
             __throw_regex_error<regex_constants::error_brack>();
         ++__first;
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_follow_list(_ForwardIterator __first,
                                     _ForwardIterator __last,
                                     __bracket_expression<_CharT, _Traits>* __ml)
 {
     if (__first != __last)
     {
         while (true)
         {
             _ForwardIterator __temp = __parse_expression_term(__first, __last,
                                                               __ml);
             if (__temp == __first)
                 break;
             __first = __temp;
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
                                     _ForwardIterator __last,
                                     __bracket_expression<_CharT, _Traits>* __ml)
 {
     if (__first != __last && *__first != ']')
     {
         _ForwardIterator __temp = _VSTD::next(__first);
         basic_string<_CharT> __start_range;
         if (__temp != __last && *__first == '[')
         {
             if (*__temp == '=')
                 return __parse_equivalence_class(++__temp, __last, __ml);
             else if (*__temp == ':')
                 return __parse_character_class(++__temp, __last, __ml);
             else if (*__temp == '.')
                 __first = __parse_collating_symbol(++__temp, __last, __start_range);
         }
         unsigned __grammar = __get_grammar(__flags_);
         if (__start_range.empty())
         {
             if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\')
             {
                 if (__grammar == ECMAScript)
                     __first = __parse_class_escape(++__first, __last, __start_range, __ml);
                 else
                     __first = __parse_awk_escape(++__first, __last, &__start_range);
             }
             else
             {
                 __start_range = *__first;
                 ++__first;
             }
         }
         if (__first != __last && *__first != ']')
         {
             __temp = _VSTD::next(__first);
             if (__temp != __last && *__first == '-' && *__temp != ']')
             {
                 // parse a range
                 basic_string<_CharT> __end_range;
                 __first = __temp;
                 ++__temp;
                 if (__temp != __last && *__first == '[' && *__temp == '.')
                     __first = __parse_collating_symbol(++__temp, __last, __end_range);
                 else
                 {
                     if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\')
                     {
                         if (__grammar == ECMAScript)
                             __first = __parse_class_escape(++__first, __last,
                                                            __end_range, __ml);
                         else
                             __first = __parse_awk_escape(++__first, __last,
                                                          &__end_range);
                     }
                     else
                     {
                         __end_range = *__first;
                         ++__first;
                     }
                 }
                 __ml->__add_range(_VSTD::move(__start_range), _VSTD::move(__end_range));
             }
             else if (!__start_range.empty())
             {
                 if (__start_range.size() == 1)
                     __ml->__add_char(__start_range[0]);
                 else
                     __ml->__add_digraph(__start_range[0], __start_range[1]);
             }
         }
         else if (!__start_range.empty())
         {
             if (__start_range.size() == 1)
                 __ml->__add_char(__start_range[0]);
             else
                 __ml->__add_digraph(__start_range[0], __start_range[1]);
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_class_escape(_ForwardIterator __first,
                           _ForwardIterator __last,
                           basic_string<_CharT>& __str,
                           __bracket_expression<_CharT, _Traits>* __ml)
 {
     if (__first == __last)
         __throw_regex_error<regex_constants::error_escape>();
     switch (*__first)
     {
     case 0:
         __str = *__first;
         return ++__first;
     case 'b':
         __str = _CharT(8);
         return ++__first;
     case 'd':
         __ml->__add_class(ctype_base::digit);
         return ++__first;
     case 'D':
         __ml->__add_neg_class(ctype_base::digit);
         return ++__first;
     case 's':
         __ml->__add_class(ctype_base::space);
         return ++__first;
     case 'S':
         __ml->__add_neg_class(ctype_base::space);
         return ++__first;
     case 'w':
         __ml->__add_class(ctype_base::alnum);
         __ml->__add_char('_');
         return ++__first;
     case 'W':
         __ml->__add_neg_class(ctype_base::alnum);
         __ml->__add_neg_char('_');
         return ++__first;
     }
     __first = __parse_character_escape(__first, __last, &__str);
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_awk_escape(_ForwardIterator __first,
                           _ForwardIterator __last,
                           basic_string<_CharT>* __str)
 {
     if (__first == __last)
         __throw_regex_error<regex_constants::error_escape>();
     switch (*__first)
     {
     case '\\':
     case '"':
     case '/':
         if (__str)
             *__str = *__first;
         else
             __push_char(*__first);
         return ++__first;
     case 'a':
         if (__str)
             *__str = _CharT(7);
         else
             __push_char(_CharT(7));
         return ++__first;
     case 'b':
         if (__str)
             *__str = _CharT(8);
         else
             __push_char(_CharT(8));
         return ++__first;
     case 'f':
         if (__str)
             *__str = _CharT(0xC);
         else
             __push_char(_CharT(0xC));
         return ++__first;
     case 'n':
         if (__str)
             *__str = _CharT(0xA);
         else
             __push_char(_CharT(0xA));
         return ++__first;
     case 'r':
         if (__str)
             *__str = _CharT(0xD);
         else
             __push_char(_CharT(0xD));
         return ++__first;
     case 't':
         if (__str)
             *__str = _CharT(0x9);
         else
             __push_char(_CharT(0x9));
         return ++__first;
     case 'v':
         if (__str)
             *__str = _CharT(0xB);
         else
             __push_char(_CharT(0xB));
         return ++__first;
     }
     if ('0' <= *__first && *__first <= '7')
     {
         unsigned __val = *__first - '0';
         if (++__first != __last && ('0' <= *__first && *__first <= '7'))
         {
             __val = 8 * __val + *__first - '0';
             if (++__first != __last && ('0' <= *__first && *__first <= '7'))
                 __val = 8 * __val + *__first++ - '0';
         }
         if (__str)
             *__str = _CharT(__val);
         else
             __push_char(_CharT(__val));
     }
     else
         __throw_regex_error<regex_constants::error_escape>();
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_equivalence_class(_ForwardIterator __first,
                                     _ForwardIterator __last,
                                     __bracket_expression<_CharT, _Traits>* __ml)
 {
     // Found [=
     //   This means =] must exist
     value_type _Equal_close[2] = {'=', ']'};
     _ForwardIterator __temp = _VSTD::search(__first, __last, _Equal_close,
                                                             _Equal_close+2);
     if (__temp == __last)
         __throw_regex_error<regex_constants::error_brack>();
     // [__first, __temp) contains all text in [= ... =]
     string_type __collate_name =
         __traits_.lookup_collatename(__first, __temp);
     if (__collate_name.empty())
         __throw_regex_error<regex_constants::error_collate>();
     string_type __equiv_name =
         __traits_.transform_primary(__collate_name.begin(),
                                     __collate_name.end());
     if (!__equiv_name.empty())
         __ml->__add_equivalence(__equiv_name);
     else
     {
         switch (__collate_name.size())
         {
         case 1:
             __ml->__add_char(__collate_name[0]);
             break;
         case 2:
             __ml->__add_digraph(__collate_name[0], __collate_name[1]);
             break;
         default:
             __throw_regex_error<regex_constants::error_collate>();
         }
     }
     __first = _VSTD::next(__temp, 2);
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_character_class(_ForwardIterator __first,
                                     _ForwardIterator __last,
                                     __bracket_expression<_CharT, _Traits>* __ml)
 {
     // Found [:
     //   This means :] must exist
     value_type _Colon_close[2] = {':', ']'};
     _ForwardIterator __temp = _VSTD::search(__first, __last, _Colon_close,
                                                             _Colon_close+2);
     if (__temp == __last)
         __throw_regex_error<regex_constants::error_brack>();
     // [__first, __temp) contains all text in [: ... :]
     typedef typename _Traits::char_class_type char_class_type;
     char_class_type __class_type =
         __traits_.lookup_classname(__first, __temp, __flags_ & icase);
     if (__class_type == 0)
         __throw_regex_error<regex_constants::error_ctype>();
     __ml->__add_class(__class_type);
     __first = _VSTD::next(__temp, 2);
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_collating_symbol(_ForwardIterator __first,
                                                 _ForwardIterator __last,
                                                 basic_string<_CharT>& __col_sym)
 {
     // Found [.
     //   This means .] must exist
     value_type _Dot_close[2] = {'.', ']'};
     _ForwardIterator __temp = _VSTD::search(__first, __last, _Dot_close,
                                                             _Dot_close+2);
     if (__temp == __last)
         __throw_regex_error<regex_constants::error_brack>();
     // [__first, __temp) contains all text in [. ... .]
     __col_sym = __traits_.lookup_collatename(__first, __temp);
     switch (__col_sym.size())
     {
     case 1:
     case 2:
         break;
     default:
         __throw_regex_error<regex_constants::error_collate>();
     }
     __first = _VSTD::next(__temp, 2);
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_DUP_COUNT(_ForwardIterator __first,
                                                 _ForwardIterator __last,
                                                 int& __c)
 {
     if (__first != __last )
     {
         int __val = __traits_.value(*__first, 10);
         if ( __val != -1 )
         {
             __c = __val;
             for (++__first;
                  __first != __last && ( __val = __traits_.value(*__first, 10)) != -1;
                  ++__first)
             {
                 if (__c >= std::numeric_limits<int>::max() / 10)
                     __throw_regex_error<regex_constants::error_badbrace>();
                 __c *= 10;
                 __c += __val;
             }
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_ecma_exp(_ForwardIterator __first,
                                                _ForwardIterator __last)
 {
     __owns_one_state<_CharT>* __sa = __end_;
     _ForwardIterator __temp = __parse_alternative(__first, __last);
     if (__temp == __first)
         __push_empty();
     __first = __temp;
     while (__first != __last && *__first == '|')
     {
         __owns_one_state<_CharT>* __sb = __end_;
         __temp = __parse_alternative(++__first, __last);
         if (__temp == __first)
             __push_empty();
         __push_alternation(__sa, __sb);
         __first = __temp;
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_alternative(_ForwardIterator __first,
                                                   _ForwardIterator __last)
 {
     while (true)
     {
         _ForwardIterator __temp = __parse_term(__first, __last);
         if (__temp == __first)
             break;
         __first = __temp;
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_term(_ForwardIterator __first,
                                            _ForwardIterator __last)
 {
     _ForwardIterator __temp = __parse_assertion(__first, __last);
     if (__temp == __first)
     {
         __owns_one_state<_CharT>* __e = __end_;
         unsigned __mexp_begin = __marked_count_;
         __temp = __parse_atom(__first, __last);
         if (__temp != __first)
             __first = __parse_ERE_dupl_symbol(__temp, __last, __e,
                                               __mexp_begin+1, __marked_count_+1);
     }
     else
         __first = __temp;
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
                                                 _ForwardIterator __last)
 {
     if (__first != __last)
     {
         switch (*__first)
         {
         case '^':
             __push_l_anchor();
             ++__first;
             break;
         case '$':
             __push_r_anchor();
             ++__first;
             break;
         case '\\':
             {
                 _ForwardIterator __temp = _VSTD::next(__first);
                 if (__temp != __last)
                 {
                     if (*__temp == 'b')
                     {
                         __push_word_boundary(false);
                         __first = ++__temp;
                     }
                     else if (*__temp == 'B')
                     {
                         __push_word_boundary(true);
                         __first = ++__temp;
                     }
                 }
             }
             break;
         case '(':
             {
                 _ForwardIterator __temp = _VSTD::next(__first);
                 if (__temp != __last && *__temp == '?')
                 {
                     if (++__temp != __last)
                     {
                         switch (*__temp)
                         {
                         case '=':
                             {
                                 basic_regex __exp;
                                 __exp.__flags_ = __flags_;
                                 __temp = __exp.__parse(++__temp, __last);
                                 unsigned __mexp = __exp.__marked_count_;
                                 __push_lookahead(_VSTD::move(__exp), false, __marked_count_);
                                 __marked_count_ += __mexp;
                                 if (__temp == __last || *__temp != ')')
                                     __throw_regex_error<regex_constants::error_paren>();
                                 __first = ++__temp;
                             }
                             break;
                         case '!':
                             {
                                 basic_regex __exp;
                                 __exp.__flags_ = __flags_;
                                 __temp = __exp.__parse(++__temp, __last);
                                 unsigned __mexp = __exp.__marked_count_;
                                 __push_lookahead(_VSTD::move(__exp), true, __marked_count_);
                                 __marked_count_ += __mexp;
                                 if (__temp == __last || *__temp != ')')
                                     __throw_regex_error<regex_constants::error_paren>();
                                 __first = ++__temp;
                             }
                             break;
                         }
                     }
                 }
             }
             break;
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_atom(_ForwardIterator __first,
                                            _ForwardIterator __last)
 {
     if (__first != __last)
     {
         switch (*__first)
         {
         case '.':
             __push_match_any_but_newline();
             ++__first;
             break;
         case '\\':
             __first = __parse_atom_escape(__first, __last);
             break;
         case '[':
             __first = __parse_bracket_expression(__first, __last);
             break;
         case '(':
             {
                 ++__first;
                 if (__first == __last)
                     __throw_regex_error<regex_constants::error_paren>();
                 _ForwardIterator __temp = _VSTD::next(__first);
                 if (__temp != __last && *__first == '?' && *__temp == ':')
                 {
                     ++__open_count_;
                     __first = __parse_ecma_exp(++__temp, __last);
                     if (__first == __last || *__first != ')')
                         __throw_regex_error<regex_constants::error_paren>();
                     --__open_count_;
                     ++__first;
                 }
                 else
                 {
                     __push_begin_marked_subexpression();
                     unsigned __temp_count = __marked_count_;
                     ++__open_count_;
                     __first = __parse_ecma_exp(__first, __last);
                     if (__first == __last || *__first != ')')
                         __throw_regex_error<regex_constants::error_paren>();
                     __push_end_marked_subexpression(__temp_count);
                     --__open_count_;
                     ++__first;
                 }
             }
             break;
         case '*':
         case '+':
         case '?':
         case '{':
             __throw_regex_error<regex_constants::error_badrepeat>();
             break;
         default:
             __first = __parse_pattern_character(__first, __last);
             break;
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_atom_escape(_ForwardIterator __first,
                                                   _ForwardIterator __last)
 {
     if (__first != __last && *__first == '\\')
     {
         _ForwardIterator __t1 = _VSTD::next(__first);
         if (__t1 == __last)
             __throw_regex_error<regex_constants::error_escape>();
 
         _ForwardIterator __t2 = __parse_decimal_escape(__t1, __last);
         if (__t2 != __t1)
             __first = __t2;
         else
         {
             __t2 = __parse_character_class_escape(__t1, __last);
             if (__t2 != __t1)
                 __first = __t2;
             else
             {
                 __t2 = __parse_character_escape(__t1, __last);
                 if (__t2 != __t1)
                     __first = __t2;
             }
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_decimal_escape(_ForwardIterator __first,
                                                      _ForwardIterator __last)
 {
     if (__first != __last)
     {
         if (*__first == '0')
         {
             __push_char(_CharT());
             ++__first;
         }
         else if ('1' <= *__first && *__first <= '9')
         {
             unsigned __v = *__first - '0';
             for (++__first;
                     __first != __last && '0' <= *__first && *__first <= '9'; ++__first)
                 {
                 if (__v >= std::numeric_limits<unsigned>::max() / 10)
                     __throw_regex_error<regex_constants::error_backref>();
                 __v = 10 * __v + *__first - '0';
                 }
             if (__v == 0 || __v > mark_count())
                 __throw_regex_error<regex_constants::error_backref>();
             __push_back_ref(__v);
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_character_class_escape(_ForwardIterator __first,
                                                              _ForwardIterator __last)
 {
     if (__first != __last)
     {
         __bracket_expression<_CharT, _Traits>* __ml;
         switch (*__first)
         {
         case 'd':
             __ml = __start_matching_list(false);
             __ml->__add_class(ctype_base::digit);
             ++__first;
             break;
         case 'D':
             __ml = __start_matching_list(true);
             __ml->__add_class(ctype_base::digit);
             ++__first;
             break;
         case 's':
             __ml = __start_matching_list(false);
             __ml->__add_class(ctype_base::space);
             ++__first;
             break;
         case 'S':
             __ml = __start_matching_list(true);
             __ml->__add_class(ctype_base::space);
             ++__first;
             break;
         case 'w':
             __ml = __start_matching_list(false);
             __ml->__add_class(ctype_base::alnum);
             __ml->__add_char('_');
             ++__first;
             break;
         case 'W':
             __ml = __start_matching_list(true);
             __ml->__add_class(ctype_base::alnum);
             __ml->__add_char('_');
             ++__first;
             break;
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_character_escape(_ForwardIterator __first,
                                                     _ForwardIterator __last,
                                                     basic_string<_CharT>* __str)
 {
     if (__first != __last)
     {
         _ForwardIterator __t;
         unsigned __sum = 0;
         int __hd;
         switch (*__first)
         {
         case 'f':
             if (__str)
                 *__str = _CharT(0xC);
             else
                 __push_char(_CharT(0xC));
             ++__first;
             break;
         case 'n':
             if (__str)
                 *__str = _CharT(0xA);
             else
                 __push_char(_CharT(0xA));
             ++__first;
             break;
         case 'r':
             if (__str)
                 *__str = _CharT(0xD);
             else
                 __push_char(_CharT(0xD));
             ++__first;
             break;
         case 't':
             if (__str)
                 *__str = _CharT(0x9);
             else
                 __push_char(_CharT(0x9));
             ++__first;
             break;
         case 'v':
             if (__str)
                 *__str = _CharT(0xB);
             else
                 __push_char(_CharT(0xB));
             ++__first;
             break;
         case 'c':
             if ((__t = _VSTD::next(__first)) != __last)
             {
                 if (('A' <= *__t && *__t <= 'Z') ||
                     ('a' <= *__t && *__t <= 'z'))
                 {
                     if (__str)
                         *__str = _CharT(*__t % 32);
                     else
                         __push_char(_CharT(*__t % 32));
                     __first = ++__t;
                 }
                 else
                     __throw_regex_error<regex_constants::error_escape>();
             }
             else
                 __throw_regex_error<regex_constants::error_escape>();
             break;
         case 'u':
             ++__first;
             if (__first == __last)
                 __throw_regex_error<regex_constants::error_escape>();
             __hd = __traits_.value(*__first, 16);
             if (__hd == -1)
                 __throw_regex_error<regex_constants::error_escape>();
             __sum = 16 * __sum + static_cast<unsigned>(__hd);
             ++__first;
             if (__first == __last)
                 __throw_regex_error<regex_constants::error_escape>();
             __hd = __traits_.value(*__first, 16);
             if (__hd == -1)
                 __throw_regex_error<regex_constants::error_escape>();
             __sum = 16 * __sum + static_cast<unsigned>(__hd);
             // drop through
         case 'x':
             ++__first;
             if (__first == __last)
                 __throw_regex_error<regex_constants::error_escape>();
             __hd = __traits_.value(*__first, 16);
             if (__hd == -1)
                 __throw_regex_error<regex_constants::error_escape>();
             __sum = 16 * __sum + static_cast<unsigned>(__hd);
             ++__first;
             if (__first == __last)
                 __throw_regex_error<regex_constants::error_escape>();
             __hd = __traits_.value(*__first, 16);
             if (__hd == -1)
                 __throw_regex_error<regex_constants::error_escape>();
             __sum = 16 * __sum + static_cast<unsigned>(__hd);
             if (__str)
                 *__str = _CharT(__sum);
             else
                 __push_char(_CharT(__sum));
             ++__first;
             break;
         case '0':
             if (__str)
                 *__str = _CharT(0);
             else
                 __push_char(_CharT(0));
             ++__first;
             break;
         default:
             if (*__first != '_' && !__traits_.isctype(*__first, ctype_base::alnum))
             {
                 if (__str)
                     *__str = *__first;
                 else
                     __push_char(*__first);
                 ++__first;
             }
             else
                 __throw_regex_error<regex_constants::error_escape>();
             break;
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_pattern_character(_ForwardIterator __first,
                                                         _ForwardIterator __last)
 {
     if (__first != __last)
     {
         switch (*__first)
         {
         case '^':
         case '$':
         case '\\':
         case '.':
         case '*':
         case '+':
         case '?':
         case '(':
         case ')':
         case '[':
         case ']':
         case '{':
         case '}':
         case '|':
             break;
         default:
             __push_char(*__first);
             ++__first;
             break;
         }
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_grep(_ForwardIterator __first,
                                            _ForwardIterator __last)
 {
     __owns_one_state<_CharT>* __sa = __end_;
     _ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
     if (__t1 != __first)
         __parse_basic_reg_exp(__first, __t1);
     else
         __push_empty();
     __first = __t1;
     if (__first != __last)
         ++__first;
     while (__first != __last)
     {
         __t1 = _VSTD::find(__first, __last, _CharT('\n'));
         __owns_one_state<_CharT>* __sb = __end_;
         if (__t1 != __first)
             __parse_basic_reg_exp(__first, __t1);
         else
             __push_empty();
         __push_alternation(__sa, __sb);
         __first = __t1;
         if (__first != __last)
             ++__first;
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
 basic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first,
                                             _ForwardIterator __last)
 {
     __owns_one_state<_CharT>* __sa = __end_;
     _ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
     if (__t1 != __first)
         __parse_extended_reg_exp(__first, __t1);
     else
         __push_empty();
     __first = __t1;
     if (__first != __last)
         ++__first;
     while (__first != __last)
     {
         __t1 = _VSTD::find(__first, __last, _CharT('\n'));
         __owns_one_state<_CharT>* __sb = __end_;
         if (__t1 != __first)
             __parse_extended_reg_exp(__first, __t1);
         else
             __push_empty();
         __push_alternation(__sa, __sb);
         __first = __t1;
         if (__first != __last)
             ++__first;
     }
     return __first;
 }
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_loop(size_t __min, size_t __max,
         __owns_one_state<_CharT>* __s, size_t __mexp_begin, size_t __mexp_end,
         bool __greedy)
 {
     unique_ptr<__empty_state<_CharT> > __e1(new __empty_state<_CharT>(__end_->first()));
     __end_->first() = nullptr;
     unique_ptr<__loop<_CharT> > __e2(new __loop<_CharT>(__loop_count_,
                 __s->first(), __e1.get(), __mexp_begin, __mexp_end, __greedy,
                 __min, __max));
     __s->first() = nullptr;
     __e1.release();
     __end_->first() = new __repeat_one_loop<_CharT>(__e2.get());
     __end_ = __e2->second();
     __s->first() = __e2.release();
     ++__loop_count_;
 }
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_char(value_type __c)
 {
     if (flags() & icase)
         __end_->first() = new __match_char_icase<_CharT, _Traits>
                                               (__traits_, __c, __end_->first());
     else if (flags() & collate)
         __end_->first() = new __match_char_collate<_CharT, _Traits>
                                               (__traits_, __c, __end_->first());
     else
         __end_->first() = new __match_char<_CharT>(__c, __end_->first());
     __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_begin_marked_subexpression()
 {
     if (!(__flags_ & nosubs))
     {
         __end_->first() =
                 new __begin_marked_subexpression<_CharT>(++__marked_count_,
                                                          __end_->first());
         __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
     }
 }
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_end_marked_subexpression(unsigned __sub)
 {
     if (!(__flags_ & nosubs))
     {
         __end_->first() =
                 new __end_marked_subexpression<_CharT>(__sub, __end_->first());
         __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
     }
 }
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_l_anchor()
 {
     __end_->first() = new __l_anchor<_CharT>(__end_->first());
     __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_r_anchor()
 {
     __end_->first() = new __r_anchor<_CharT>(__end_->first());
     __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_match_any()
 {
     __end_->first() = new __match_any<_CharT>(__end_->first());
     __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_match_any_but_newline()
 {
     __end_->first() = new __match_any_but_newline<_CharT>(__end_->first());
     __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_empty()
 {
     __end_->first() = new __empty_state<_CharT>(__end_->first());
     __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_word_boundary(bool __invert)
 {
     __end_->first() = new __word_boundary<_CharT, _Traits>(__traits_, __invert,
                                                            __end_->first());
     __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_back_ref(int __i)
 {
     if (flags() & icase)
         __end_->first() = new __back_ref_icase<_CharT, _Traits>
                                               (__traits_, __i, __end_->first());
     else if (flags() & collate)
         __end_->first() = new __back_ref_collate<_CharT, _Traits>
                                               (__traits_, __i, __end_->first());
     else
         __end_->first() = new __back_ref<_CharT>(__i, __end_->first());
     __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_alternation(__owns_one_state<_CharT>* __sa,
                                                  __owns_one_state<_CharT>* __ea)
 {
     __sa->first() = new __alternate<_CharT>(
                          static_cast<__owns_one_state<_CharT>*>(__sa->first()),
                          static_cast<__owns_one_state<_CharT>*>(__ea->first()));
     __ea->first() = nullptr;
     __ea->first() = new __empty_state<_CharT>(__end_->first());
     __end_->first() = nullptr;
     __end_->first() = new __empty_non_own_state<_CharT>(__ea->first());
     __end_ = static_cast<__owns_one_state<_CharT>*>(__ea->first());
 }
 
 template <class _CharT, class _Traits>
 __bracket_expression<_CharT, _Traits>*
 basic_regex<_CharT, _Traits>::__start_matching_list(bool __negate)
 {
     __bracket_expression<_CharT, _Traits>* __r =
         new __bracket_expression<_CharT, _Traits>(__traits_, __end_->first(),
                                                   __negate, __flags_ & icase,
                                                   __flags_ & collate);
     __end_->first() = __r;
     __end_ = __r;
     return __r;
 }
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_lookahead(const basic_regex& __exp,
                                                bool __invert,
                                                unsigned __mexp)
 {
     __end_->first() = new __lookahead<_CharT, _Traits>(__exp, __invert,
                                                            __end_->first(), __mexp);
     __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 typedef basic_regex<char>    regex;
 typedef basic_regex<wchar_t> wregex;
 
 // sub_match
 
 template <class _BidirectionalIterator>
 class _LIBCPP_TEMPLATE_VIS sub_match
     : public pair<_BidirectionalIterator, _BidirectionalIterator>
 {
 public:
     typedef _BidirectionalIterator                              iterator;
     typedef typename iterator_traits<iterator>::value_type      value_type;
     typedef typename iterator_traits<iterator>::difference_type difference_type;
     typedef basic_string<value_type>                            string_type;
 
     bool matched;
 
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR sub_match() : matched() {}
 
     _LIBCPP_INLINE_VISIBILITY
     difference_type length() const
         {return matched ? _VSTD::distance(this->first, this->second) : 0;}
     _LIBCPP_INLINE_VISIBILITY
     string_type str() const
         {return matched ? string_type(this->first, this->second) : string_type();}
     _LIBCPP_INLINE_VISIBILITY
     operator string_type() const
         {return str();}
 
     _LIBCPP_INLINE_VISIBILITY
     int compare(const sub_match& __s) const
         {return str().compare(__s.str());}
     _LIBCPP_INLINE_VISIBILITY
     int compare(const string_type& __s) const
         {return str().compare(__s);}
     _LIBCPP_INLINE_VISIBILITY
     int compare(const value_type* __s) const
         {return str().compare(__s);}
 };
 
 typedef sub_match<const char*>             csub_match;
 typedef sub_match<const wchar_t*>          wcsub_match;
 typedef sub_match<string::const_iterator>  ssub_match;
 typedef sub_match<wstring::const_iterator> wssub_match;
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
 {
     return __x.compare(__y) == 0;
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
 {
     return !(__x == __y);
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
 {
     return __x.compare(__y) < 0;
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
 {
     return !(__y < __x);
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
 {
     return !(__x < __y);
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
 {
     return __y < __x;
 }
 
 template <class _BiIter, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
            const sub_match<_BiIter>& __y)
 {
     return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) == 0;
 }
 
 template <class _BiIter, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
            const sub_match<_BiIter>& __y)
 {
     return !(__x == __y);
 }
 
 template <class _BiIter, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
           const sub_match<_BiIter>& __y)
 {
     return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) > 0;
 }
 
 template <class _BiIter, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
           const sub_match<_BiIter>& __y)
 {
     return __y < __x;
 }
 
 template <class _BiIter, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 bool operator>=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
                 const sub_match<_BiIter>& __y)
 {
     return !(__x < __y);
 }
 
 template <class _BiIter, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
            const sub_match<_BiIter>& __y)
 {
     return !(__y < __x);
 }
 
 template <class _BiIter, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const sub_match<_BiIter>& __x,
            const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
 {
     return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) == 0;
 }
 
 template <class _BiIter, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const sub_match<_BiIter>& __x,
            const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
 {
     return !(__x == __y);
 }
 
 template <class _BiIter, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<(const sub_match<_BiIter>& __x,
           const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
 {
     return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) < 0;
 }
 
 template <class _BiIter, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 bool operator>(const sub_match<_BiIter>& __x,
                const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
 {
     return __y < __x;
 }
 
 template <class _BiIter, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const sub_match<_BiIter>& __x,
            const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
 {
     return !(__x < __y);
 }
 
 template <class _BiIter, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const sub_match<_BiIter>& __x,
            const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
 {
     return !(__y < __x);
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(typename iterator_traits<_BiIter>::value_type const* __x,
            const sub_match<_BiIter>& __y)
 {
     return __y.compare(__x) == 0;
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(typename iterator_traits<_BiIter>::value_type const* __x,
            const sub_match<_BiIter>& __y)
 {
     return !(__x == __y);
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<(typename iterator_traits<_BiIter>::value_type const* __x,
           const sub_match<_BiIter>& __y)
 {
     return __y.compare(__x) > 0;
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>(typename iterator_traits<_BiIter>::value_type const* __x,
           const sub_match<_BiIter>& __y)
 {
     return __y < __x;
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(typename iterator_traits<_BiIter>::value_type const* __x,
            const sub_match<_BiIter>& __y)
 {
     return !(__x < __y);
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(typename iterator_traits<_BiIter>::value_type const* __x,
            const sub_match<_BiIter>& __y)
 {
     return !(__y < __x);
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const sub_match<_BiIter>& __x,
            typename iterator_traits<_BiIter>::value_type const* __y)
 {
     return __x.compare(__y) == 0;
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const sub_match<_BiIter>& __x,
            typename iterator_traits<_BiIter>::value_type const* __y)
 {
     return !(__x == __y);
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<(const sub_match<_BiIter>& __x,
           typename iterator_traits<_BiIter>::value_type const* __y)
 {
     return __x.compare(__y) < 0;
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>(const sub_match<_BiIter>& __x,
           typename iterator_traits<_BiIter>::value_type const* __y)
 {
     return __y < __x;
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const sub_match<_BiIter>& __x,
            typename iterator_traits<_BiIter>::value_type const* __y)
 {
     return !(__x < __y);
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const sub_match<_BiIter>& __x,
            typename iterator_traits<_BiIter>::value_type const* __y)
 {
     return !(__y < __x);
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(typename iterator_traits<_BiIter>::value_type const& __x,
            const sub_match<_BiIter>& __y)
 {
     typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
     return __y.compare(string_type(1, __x)) == 0;
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(typename iterator_traits<_BiIter>::value_type const& __x,
            const sub_match<_BiIter>& __y)
 {
     return !(__x == __y);
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<(typename iterator_traits<_BiIter>::value_type const& __x,
           const sub_match<_BiIter>& __y)
 {
     typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
     return __y.compare(string_type(1, __x)) > 0;
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>(typename iterator_traits<_BiIter>::value_type const& __x,
           const sub_match<_BiIter>& __y)
 {
     return __y < __x;
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(typename iterator_traits<_BiIter>::value_type const& __x,
            const sub_match<_BiIter>& __y)
 {
     return !(__x < __y);
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(typename iterator_traits<_BiIter>::value_type const& __x,
            const sub_match<_BiIter>& __y)
 {
     return !(__y < __x);
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const sub_match<_BiIter>& __x,
            typename iterator_traits<_BiIter>::value_type const& __y)
 {
     typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
     return __x.compare(string_type(1, __y)) == 0;
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const sub_match<_BiIter>& __x,
            typename iterator_traits<_BiIter>::value_type const& __y)
 {
     return !(__x == __y);
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<(const sub_match<_BiIter>& __x,
           typename iterator_traits<_BiIter>::value_type const& __y)
 {
     typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
     return __x.compare(string_type(1, __y)) < 0;
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>(const sub_match<_BiIter>& __x,
           typename iterator_traits<_BiIter>::value_type const& __y)
 {
     return __y < __x;
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const sub_match<_BiIter>& __x,
            typename iterator_traits<_BiIter>::value_type const& __y)
 {
     return !(__x < __y);
 }
 
 template <class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<=(const sub_match<_BiIter>& __x,
            typename iterator_traits<_BiIter>::value_type const& __y)
 {
     return !(__y < __x);
 }
 
 template <class _CharT, class _ST, class _BiIter>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _ST>&
 operator<<(basic_ostream<_CharT, _ST>& __os, const sub_match<_BiIter>& __m)
 {
     return __os << __m.str();
 }
 
 template <class _BidirectionalIterator, class _Allocator>
 class _LIBCPP_TEMPLATE_VIS match_results
 {
 public:
     typedef _Allocator                                        allocator_type;
     typedef sub_match<_BidirectionalIterator>                 value_type;
 private:
     typedef vector<value_type, allocator_type>                __container_type;
 
     __container_type  __matches_;
     value_type __unmatched_;
     value_type __prefix_;
     value_type __suffix_;
     bool       __ready_;
 public:
     _BidirectionalIterator __position_start_;
     typedef const value_type&                                 const_reference;
     typedef value_type&                                       reference;
     typedef typename __container_type::const_iterator         const_iterator;
     typedef const_iterator                                    iterator;
     typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
     typedef typename allocator_traits<allocator_type>::size_type size_type;
     typedef typename iterator_traits<_BidirectionalIterator>::value_type char_type;
     typedef basic_string<char_type>                           string_type;
 
     // construct/copy/destroy:
     explicit match_results(const allocator_type& __a = allocator_type());
 //    match_results(const match_results&) = default;
 //    match_results& operator=(const match_results&) = default;
 //    match_results(match_results&& __m) = default;
 //    match_results& operator=(match_results&& __m) = default;
 //    ~match_results() = default;
 
     _LIBCPP_INLINE_VISIBILITY
     bool ready() const {return __ready_;}
 
     // size:
     _LIBCPP_INLINE_VISIBILITY
     size_type size() const _NOEXCEPT {return __matches_.size();}
     _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const _NOEXCEPT {return __matches_.max_size();}
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     bool empty() const _NOEXCEPT {return size() == 0;}
 
     // element access:
     _LIBCPP_INLINE_VISIBILITY
     difference_type length(size_type __sub = 0) const
         {
         _LIBCPP_ASSERT(ready(), "match_results::length() called when not ready");
         return (*this)[__sub].length();
         }
     _LIBCPP_INLINE_VISIBILITY
     difference_type position(size_type __sub = 0) const
         {
         _LIBCPP_ASSERT(ready(), "match_results::position() called when not ready");
         return _VSTD::distance(__position_start_, (*this)[__sub].first);
         }
     _LIBCPP_INLINE_VISIBILITY
     string_type str(size_type __sub = 0) const
         {
         _LIBCPP_ASSERT(ready(), "match_results::str() called when not ready");
         return (*this)[__sub].str();
         }
     _LIBCPP_INLINE_VISIBILITY
     const_reference operator[](size_type __n) const
         {
         _LIBCPP_ASSERT(ready(), "match_results::operator[]() called when not ready");
         return __n < __matches_.size() ? __matches_[__n] : __unmatched_;
         }
 
     _LIBCPP_INLINE_VISIBILITY
     const_reference prefix() const
         {
         _LIBCPP_ASSERT(ready(), "match_results::prefix() called when not ready");
         return __prefix_;
         }
     _LIBCPP_INLINE_VISIBILITY
     const_reference suffix() const
         {
         _LIBCPP_ASSERT(ready(), "match_results::suffix() called when not ready");
         return __suffix_;
         }
 
     _LIBCPP_INLINE_VISIBILITY
     const_iterator begin() const {return empty() ? __matches_.end() : __matches_.begin();}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator end() const {return __matches_.end();}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator cbegin() const {return empty() ? __matches_.end() : __matches_.begin();}
     _LIBCPP_INLINE_VISIBILITY
     const_iterator cend() const {return __matches_.end();}
 
     // format:
     template <class _OutputIter>
         _OutputIter
         format(_OutputIter __output_iter, const char_type* __fmt_first,
                const char_type* __fmt_last,
                regex_constants::match_flag_type __flags = regex_constants::format_default) const;
     template <class _OutputIter, class _ST, class _SA>
         _LIBCPP_INLINE_VISIBILITY
         _OutputIter
         format(_OutputIter __output_iter, const basic_string<char_type, _ST, _SA>& __fmt,
                regex_constants::match_flag_type __flags = regex_constants::format_default) const
             {return format(__output_iter, __fmt.data(), __fmt.data() + __fmt.size(), __flags);}
     template <class _ST, class _SA>
         _LIBCPP_INLINE_VISIBILITY
         basic_string<char_type, _ST, _SA>
         format(const basic_string<char_type, _ST, _SA>& __fmt,
                regex_constants::match_flag_type __flags = regex_constants::format_default) const
         {
             basic_string<char_type, _ST, _SA> __r;
             format(back_inserter(__r), __fmt.data(), __fmt.data() + __fmt.size(),
                    __flags);
             return __r;
         }
     _LIBCPP_INLINE_VISIBILITY
     string_type
         format(const char_type* __fmt,
                regex_constants::match_flag_type __flags = regex_constants::format_default) const
         {
             string_type __r;
             format(back_inserter(__r), __fmt,
                    __fmt + char_traits<char_type>::length(__fmt), __flags);
             return __r;
         }
 
     // allocator:
     _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const {return __matches_.get_allocator();}
 
     // swap:
     void swap(match_results& __m);
 
     template <class _Bp, class _Ap>
         _LIBCPP_INLINE_VISIBILITY
         void __assign(_BidirectionalIterator __f, _BidirectionalIterator __l,
                       const match_results<_Bp, _Ap>& __m, bool __no_update_pos)
     {
         _Bp __mf = __m.prefix().first;
         __matches_.resize(__m.size());
         for (size_type __i = 0; __i < __matches_.size(); ++__i)
         {
             __matches_[__i].first = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].first));
             __matches_[__i].second = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].second));
             __matches_[__i].matched = __m[__i].matched;
         }
         __unmatched_.first   = __l;
         __unmatched_.second  = __l;
         __unmatched_.matched = false;
         __prefix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().first));
         __prefix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().second));
         __prefix_.matched = __m.prefix().matched;
         __suffix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().first));
         __suffix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().second));
         __suffix_.matched = __m.suffix().matched;
         if (!__no_update_pos)
             __position_start_ = __prefix_.first;
         __ready_ = __m.ready();
     }
 
 private:
     void __init(unsigned __s,
                 _BidirectionalIterator __f, _BidirectionalIterator __l,
                 bool __no_update_pos = false);
 
     template <class, class> friend class basic_regex;
 
     template <class _Bp, class _Ap, class _Cp, class _Tp>
     friend
     bool
     regex_match(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&,
                 regex_constants::match_flag_type);
 
     template <class _Bp, class _Ap>
     friend
     bool
     operator==(const match_results<_Bp, _Ap>&, const match_results<_Bp, _Ap>&);
 
     template <class, class> friend class __lookahead;
 };
 
 template <class _BidirectionalIterator, class _Allocator>
 match_results<_BidirectionalIterator, _Allocator>::match_results(
         const allocator_type& __a)
     : __matches_(__a),
       __unmatched_(),
       __prefix_(),
       __suffix_(),
       __ready_(false),
       __position_start_()
 {
 }
 
 template <class _BidirectionalIterator, class _Allocator>
 void
 match_results<_BidirectionalIterator, _Allocator>::__init(unsigned __s,
                          _BidirectionalIterator __f, _BidirectionalIterator __l,
                          bool __no_update_pos)
 {
     __unmatched_.first   = __l;
     __unmatched_.second  = __l;
     __unmatched_.matched = false;
     __matches_.assign(__s, __unmatched_);
     __prefix_.first      = __f;
     __prefix_.second     = __f;
     __prefix_.matched    = false;
     __suffix_ = __unmatched_;
     if (!__no_update_pos)
         __position_start_ = __prefix_.first;
     __ready_ = true;
 }
 
 template <class _BidirectionalIterator, class _Allocator>
 template <class _OutputIter>
 _OutputIter
 match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __output_iter,
         const char_type* __fmt_first, const char_type* __fmt_last,
         regex_constants::match_flag_type __flags) const
 {
     _LIBCPP_ASSERT(ready(), "match_results::format() called when not ready");
     if (__flags & regex_constants::format_sed)
     {
         for (; __fmt_first != __fmt_last; ++__fmt_first)
         {
             if (*__fmt_first == '&')
                 __output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second,
                                    __output_iter);
             else if (*__fmt_first == '\\' && __fmt_first + 1 != __fmt_last)
             {
                 ++__fmt_first;
                 if ('0' <= *__fmt_first && *__fmt_first <= '9')
                 {
                     size_t __i = *__fmt_first - '0';
                     __output_iter = _VSTD::copy((*this)[__i].first,
                                         (*this)[__i].second, __output_iter);
                 }
                 else
                 {
                     *__output_iter = *__fmt_first;
                     ++__output_iter;
                 }
             }
             else
             {
                 *__output_iter = *__fmt_first;
                 ++__output_iter;
             }
         }
     }
     else
     {
         for (; __fmt_first != __fmt_last; ++__fmt_first)
         {
             if (*__fmt_first == '$' && __fmt_first + 1 != __fmt_last)
             {
                 switch (__fmt_first[1])
                 {
                 case '$':
                     *__output_iter = *++__fmt_first;
                     ++__output_iter;
                     break;
                 case '&':
                     ++__fmt_first;
                     __output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second,
                                        __output_iter);
                     break;
                 case '`':
                     ++__fmt_first;
                     __output_iter = _VSTD::copy(__prefix_.first, __prefix_.second, __output_iter);
                     break;
                 case '\'':
                     ++__fmt_first;
                     __output_iter = _VSTD::copy(__suffix_.first, __suffix_.second, __output_iter);
                     break;
                 default:
                     if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9')
                     {
                         ++__fmt_first;
                         size_t __idx = *__fmt_first - '0';
                         if (__fmt_first + 1 != __fmt_last &&
                             '0' <= __fmt_first[1] && __fmt_first[1] <= '9')
                         {
                             ++__fmt_first;
                             if (__idx >= std::numeric_limits<size_t>::max() / 10)
                                 __throw_regex_error<regex_constants::error_escape>();
                             __idx = 10 * __idx + *__fmt_first - '0';
                         }
                         __output_iter = _VSTD::copy((*this)[__idx].first,
                                             (*this)[__idx].second, __output_iter);
                     }
                     else
                     {
                         *__output_iter = *__fmt_first;
                         ++__output_iter;
                     }
                     break;
                 }
             }
             else
             {
                 *__output_iter = *__fmt_first;
                 ++__output_iter;
             }
         }
     }
     return __output_iter;
 }
 
 template <class _BidirectionalIterator, class _Allocator>
 void
 match_results<_BidirectionalIterator, _Allocator>::swap(match_results& __m)
 {
     using _VSTD::swap;
     swap(__matches_, __m.__matches_);
     swap(__unmatched_, __m.__unmatched_);
     swap(__prefix_, __m.__prefix_);
     swap(__suffix_, __m.__suffix_);
     swap(__position_start_, __m.__position_start_);
     swap(__ready_, __m.__ready_);
 }
 
 typedef match_results<const char*>             cmatch;
 typedef match_results<const wchar_t*>          wcmatch;
 typedef match_results<string::const_iterator>  smatch;
 typedef match_results<wstring::const_iterator> wsmatch;
 
 template <class _BidirectionalIterator, class _Allocator>
 bool
 operator==(const match_results<_BidirectionalIterator, _Allocator>& __x,
            const match_results<_BidirectionalIterator, _Allocator>& __y)
 {
     if (__x.__ready_ != __y.__ready_)
         return false;
     if (!__x.__ready_)
         return true;
     return __x.__matches_ == __y.__matches_ &&
            __x.__prefix_ == __y.__prefix_ &&
            __x.__suffix_ == __y.__suffix_;
 }
 
 template <class _BidirectionalIterator, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const match_results<_BidirectionalIterator, _Allocator>& __x,
            const match_results<_BidirectionalIterator, _Allocator>& __y)
 {
     return !(__x == __y);
 }
 
 template <class _BidirectionalIterator, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(match_results<_BidirectionalIterator, _Allocator>& __x,
      match_results<_BidirectionalIterator, _Allocator>& __y)
 {
     __x.swap(__y);
 }
 
 // regex_search
 
 template <class _CharT, class _Traits>
 template <class _Allocator>
 bool
 basic_regex<_CharT, _Traits>::__match_at_start_ecma(
         const _CharT* __first, const _CharT* __last,
         match_results<const _CharT*, _Allocator>& __m,
         regex_constants::match_flag_type __flags, bool __at_first) const
 {
     vector<__state> __states;
     __node* __st = __start_.get();
     if (__st)
     {
         sub_match<const _CharT*> __unmatched;
         __unmatched.first   = __last;
         __unmatched.second  = __last;
         __unmatched.matched = false;
 
         __states.push_back(__state());
         __states.back().__do_ = 0;
         __states.back().__first_ = __first;
         __states.back().__current_ = __first;
         __states.back().__last_ = __last;
         __states.back().__sub_matches_.resize(mark_count(), __unmatched);
         __states.back().__loop_data_.resize(__loop_count());
         __states.back().__node_ = __st;
         __states.back().__flags_ = __flags;
         __states.back().__at_first_ = __at_first;
         int __counter = 0;
         int __length = __last - __first;
         do
         {
             ++__counter;
             if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
                 __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
               __throw_regex_error<regex_constants::error_complexity>();
             __state& __s = __states.back();
             if (__s.__node_)
                 __s.__node_->__exec(__s);
             switch (__s.__do_)
             {
             case __state::__end_state:
                 if ((__flags & regex_constants::match_not_null) &&
                     __s.__current_ == __first)
                 {
                   __states.pop_back();
                   break;
                 }
                 if ((__flags & regex_constants::__full_match) &&
                     __s.__current_ != __last)
                 {
                   __states.pop_back();
                   break;
                 }
                 __m.__matches_[0].first = __first;
                 __m.__matches_[0].second = _VSTD::next(__first, __s.__current_ - __first);
                 __m.__matches_[0].matched = true;
                 for (unsigned __i = 0; __i < __s.__sub_matches_.size(); ++__i)
                     __m.__matches_[__i+1] = __s.__sub_matches_[__i];
                 return true;
             case __state::__accept_and_consume:
             case __state::__repeat:
             case __state::__accept_but_not_consume:
                 break;
             case __state::__split:
                 {
                 __state __snext = __s;
                 __s.__node_->__exec_split(true, __s);
                 __snext.__node_->__exec_split(false, __snext);
                 __states.push_back(_VSTD::move(__snext));
                 }
                 break;
             case __state::__reject:
                 __states.pop_back();
                 break;
             default:
                 __throw_regex_error<regex_constants::__re_err_unknown>();
                 break;
 
             }
         } while (!__states.empty());
     }
     return false;
 }
 
 template <class _CharT, class _Traits>
 template <class _Allocator>
 bool
 basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
         const _CharT* __first, const _CharT* __last,
         match_results<const _CharT*, _Allocator>& __m,
         regex_constants::match_flag_type __flags, bool __at_first) const
 {
     deque<__state> __states;
     ptrdiff_t __highest_j = 0;
     ptrdiff_t _Np = _VSTD::distance(__first, __last);
     __node* __st = __start_.get();
     if (__st)
     {
         __states.push_back(__state());
         __states.back().__do_ = 0;
         __states.back().__first_ = __first;
         __states.back().__current_ = __first;
         __states.back().__last_ = __last;
         __states.back().__loop_data_.resize(__loop_count());
         __states.back().__node_ = __st;
         __states.back().__flags_ = __flags;
         __states.back().__at_first_ = __at_first;
         bool __matched = false;
         int __counter = 0;
         int __length = __last - __first;
         do
         {
             ++__counter;
             if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
                 __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
               __throw_regex_error<regex_constants::error_complexity>();
             __state& __s = __states.back();
             if (__s.__node_)
                 __s.__node_->__exec(__s);
             switch (__s.__do_)
             {
             case __state::__end_state:
                 if ((__flags & regex_constants::match_not_null) &&
                     __s.__current_ == __first)
                 {
                   __states.pop_back();
                   break;
                 }
                 if ((__flags & regex_constants::__full_match) &&
                     __s.__current_ != __last)
                 {
                   __states.pop_back();
                   break;
                 }
                 if (!__matched || __highest_j < __s.__current_ - __s.__first_)
                     __highest_j = __s.__current_ - __s.__first_;
                 __matched = true;
                 if (__highest_j == _Np)
                     __states.clear();
                 else
                     __states.pop_back();
                 break;
             case __state::__consume_input:
                 break;
             case __state::__accept_and_consume:
                 __states.push_front(_VSTD::move(__s));
                 __states.pop_back();
                 break;
             case __state::__repeat:
             case __state::__accept_but_not_consume:
                 break;
             case __state::__split:
                 {
                 __state __snext = __s;
                 __s.__node_->__exec_split(true, __s);
                 __snext.__node_->__exec_split(false, __snext);
                 __states.push_back(_VSTD::move(__snext));
                 }
                 break;
             case __state::__reject:
                 __states.pop_back();
                 break;
             default:
                 __throw_regex_error<regex_constants::__re_err_unknown>();
                 break;
             }
         } while (!__states.empty());
         if (__matched)
         {
             __m.__matches_[0].first = __first;
             __m.__matches_[0].second = _VSTD::next(__first, __highest_j);
             __m.__matches_[0].matched = true;
             return true;
         }
     }
     return false;
 }
 
 template <class _CharT, class _Traits>
 template <class _Allocator>
 bool
 basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
         const _CharT* __first, const _CharT* __last,
         match_results<const _CharT*, _Allocator>& __m,
         regex_constants::match_flag_type __flags, bool __at_first) const
 {
     vector<__state> __states;
     __state __best_state;
     ptrdiff_t __j = 0;
     ptrdiff_t __highest_j = 0;
     ptrdiff_t _Np = _VSTD::distance(__first, __last);
     __node* __st = __start_.get();
     if (__st)
     {
         sub_match<const _CharT*> __unmatched;
         __unmatched.first   = __last;
         __unmatched.second  = __last;
         __unmatched.matched = false;
 
         __states.push_back(__state());
         __states.back().__do_ = 0;
         __states.back().__first_ = __first;
         __states.back().__current_ = __first;
         __states.back().__last_ = __last;
         __states.back().__sub_matches_.resize(mark_count(), __unmatched);
         __states.back().__loop_data_.resize(__loop_count());
         __states.back().__node_ = __st;
         __states.back().__flags_ = __flags;
         __states.back().__at_first_ = __at_first;
         const _CharT* __current = __first;
         bool __matched = false;
         int __counter = 0;
         int __length = __last - __first;
         do
         {
             ++__counter;
             if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
                 __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
               __throw_regex_error<regex_constants::error_complexity>();
             __state& __s = __states.back();
             if (__s.__node_)
                 __s.__node_->__exec(__s);
             switch (__s.__do_)
             {
             case __state::__end_state:
                 if ((__flags & regex_constants::match_not_null) &&
                     __s.__current_ == __first)
                 {
                   __states.pop_back();
                   break;
                 }
                 if ((__flags & regex_constants::__full_match) &&
                     __s.__current_ != __last)
                 {
                   __states.pop_back();
                   break;
                 }
                 if (!__matched || __highest_j < __s.__current_ - __s.__first_)
                 {
                     __highest_j = __s.__current_ - __s.__first_;
                     __best_state = __s;
                 }
                 __matched = true;
                 if (__highest_j == _Np)
                     __states.clear();
                 else
                     __states.pop_back();
                 break;
             case __state::__accept_and_consume:
                 __j += __s.__current_ - __current;
                 __current = __s.__current_;
                 break;
             case __state::__repeat:
             case __state::__accept_but_not_consume:
                 break;
             case __state::__split:
                 {
                 __state __snext = __s;
                 __s.__node_->__exec_split(true, __s);
                 __snext.__node_->__exec_split(false, __snext);
                 __states.push_back(_VSTD::move(__snext));
                 }
                 break;
             case __state::__reject:
                 __states.pop_back();
                 break;
             default:
                 __throw_regex_error<regex_constants::__re_err_unknown>();
                 break;
             }
         } while (!__states.empty());
         if (__matched)
         {
             __m.__matches_[0].first = __first;
             __m.__matches_[0].second = _VSTD::next(__first, __highest_j);
             __m.__matches_[0].matched = true;
             for (unsigned __i = 0; __i < __best_state.__sub_matches_.size(); ++__i)
                 __m.__matches_[__i+1] = __best_state.__sub_matches_[__i];
             return true;
         }
     }
     return false;
 }
 
 template <class _CharT, class _Traits>
 template <class _Allocator>
 bool
 basic_regex<_CharT, _Traits>::__match_at_start(
         const _CharT* __first, const _CharT* __last,
         match_results<const _CharT*, _Allocator>& __m,
         regex_constants::match_flag_type __flags, bool __at_first) const
 {
     if (__get_grammar(__flags_) == ECMAScript)
         return __match_at_start_ecma(__first, __last, __m, __flags, __at_first);
     if (mark_count() == 0)
         return __match_at_start_posix_nosubs(__first, __last, __m, __flags, __at_first);
     return __match_at_start_posix_subs(__first, __last, __m, __flags, __at_first);
 }
 
 template <class _CharT, class _Traits>
 template <class _Allocator>
 bool
 basic_regex<_CharT, _Traits>::__search(
         const _CharT* __first, const _CharT* __last,
         match_results<const _CharT*, _Allocator>& __m,
         regex_constants::match_flag_type __flags) const
 {
     __m.__init(1 + mark_count(), __first, __last,
                                     __flags & regex_constants::__no_update_pos);
     if (__match_at_start(__first, __last, __m, __flags,
                                     !(__flags & regex_constants::__no_update_pos)))
     {
         __m.__prefix_.second = __m[0].first;
         __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
         __m.__suffix_.first = __m[0].second;
         __m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second;
         return true;
     }
     if (__first != __last && !(__flags & regex_constants::match_continuous))
     {
         __flags |= regex_constants::match_prev_avail;
         for (++__first; __first != __last; ++__first)
         {
             __m.__matches_.assign(__m.size(), __m.__unmatched_);
             if (__match_at_start(__first, __last, __m, __flags, false))
             {
                 __m.__prefix_.second = __m[0].first;
                 __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
                 __m.__suffix_.first = __m[0].second;
                 __m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second;
                 return true;
             }
             __m.__matches_.assign(__m.size(), __m.__unmatched_);
         }
     }
     __m.__matches_.clear();
     return false;
 }
 
 template <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_search(_BidirectionalIterator __first, _BidirectionalIterator __last,
              match_results<_BidirectionalIterator, _Allocator>& __m,
              const basic_regex<_CharT, _Traits>& __e,
              regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     int __offset = (__flags & regex_constants::match_prev_avail) ? 1 : 0;
     basic_string<_CharT> __s(_VSTD::prev(__first, __offset), __last);
     match_results<const _CharT*> __mc;
     bool __r = __e.__search(__s.data() + __offset, __s.data() + __s.size(), __mc, __flags);
     __m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos);
     return __r;
 }
 
 template <class _Iter, class _Allocator, class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_search(__wrap_iter<_Iter> __first,
              __wrap_iter<_Iter> __last,
              match_results<__wrap_iter<_Iter>, _Allocator>& __m,
              const basic_regex<_CharT, _Traits>& __e,
              regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     match_results<const _CharT*> __mc;
     bool __r = __e.__search(__first.base(), __last.base(), __mc, __flags);
     __m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos);
     return __r;
 }
 
 template <class _Allocator, class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_search(const _CharT* __first, const _CharT* __last,
              match_results<const _CharT*, _Allocator>& __m,
              const basic_regex<_CharT, _Traits>& __e,
              regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     return __e.__search(__first, __last, __m, __flags);
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_search(_BidirectionalIterator __first, _BidirectionalIterator __last,
              const basic_regex<_CharT, _Traits>& __e,
              regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     basic_string<_CharT> __s(__first, __last);
     match_results<const _CharT*> __mc;
     return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_search(const _CharT* __first, const _CharT* __last,
              const basic_regex<_CharT, _Traits>& __e,
              regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     match_results<const _CharT*> __mc;
     return __e.__search(__first, __last, __mc, __flags);
 }
 
 template <class _CharT, class _Allocator, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_search(const _CharT* __str, match_results<const _CharT*, _Allocator>& __m,
              const basic_regex<_CharT, _Traits>& __e,
              regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     return __e.__search(__str, __str + _Traits::length(__str), __m, __flags);
 }
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_search(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e,
              regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     match_results<const _CharT*> __m;
     return _VSTD::regex_search(__str, __m, __e, __flags);
 }
 
 template <class _ST, class _SA, class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_search(const basic_string<_CharT, _ST, _SA>& __s,
              const basic_regex<_CharT, _Traits>& __e,
              regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     match_results<const _CharT*> __mc;
     return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
 }
 
 template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_search(const basic_string<_CharT, _ST, _SA>& __s,
              match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
              const basic_regex<_CharT, _Traits>& __e,
              regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     match_results<const _CharT*> __mc;
     bool __r = __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
     __m.__assign(__s.begin(), __s.end(), __mc, __flags & regex_constants::__no_update_pos);
     return __r;
 }
 
 #if _LIBCPP_STD_VER > 11
 template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
 bool
 regex_search(const basic_string<_Cp, _ST, _SA>&& __s,
              match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
              const basic_regex<_Cp, _Tp>& __e,
              regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
 #endif
 
 // regex_match
 
 template <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits>
 bool
 regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last,
             match_results<_BidirectionalIterator, _Allocator>& __m,
             const basic_regex<_CharT, _Traits>& __e,
             regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     bool __r = _VSTD::regex_search(
         __first, __last, __m, __e,
         __flags | regex_constants::match_continuous |
         regex_constants::__full_match);
     if (__r)
     {
         __r = !__m.suffix().matched;
         if (!__r)
             __m.__matches_.clear();
     }
     return __r;
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last,
             const basic_regex<_CharT, _Traits>& __e,
             regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     match_results<_BidirectionalIterator> __m;
     return _VSTD::regex_match(__first, __last, __m, __e, __flags);
 }
 
 template <class _CharT, class _Allocator, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_match(const _CharT* __str, match_results<const _CharT*, _Allocator>& __m,
             const basic_regex<_CharT, _Traits>& __e,
             regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     return _VSTD::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags);
 }
 
 template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_match(const basic_string<_CharT, _ST, _SA>& __s,
             match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
             const basic_regex<_CharT, _Traits>& __e,
             regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     return _VSTD::regex_match(__s.begin(), __s.end(), __m, __e, __flags);
 }
 
 #if _LIBCPP_STD_VER > 11
 template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_match(const basic_string<_CharT, _ST, _SA>&& __s,
             match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
             const basic_regex<_CharT, _Traits>& __e,
             regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
 #endif
 
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_match(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e,
             regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     return _VSTD::regex_match(__str, __str + _Traits::length(__str), __e, __flags);
 }
 
 template <class _ST, class _SA, class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 regex_match(const basic_string<_CharT, _ST, _SA>& __s,
             const basic_regex<_CharT, _Traits>& __e,
             regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     return _VSTD::regex_match(__s.begin(), __s.end(), __e, __flags);
 }
 
 // regex_iterator
 
 template <class _BidirectionalIterator,
           class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
           class _Traits = regex_traits<_CharT> >
 class _LIBCPP_TEMPLATE_VIS regex_iterator
 {
 public:
     typedef basic_regex<_CharT, _Traits>          regex_type;
     typedef match_results<_BidirectionalIterator> value_type;
     typedef ptrdiff_t                             difference_type;
     typedef const value_type*                     pointer;
     typedef const value_type&                     reference;
     typedef forward_iterator_tag                  iterator_category;
 
 private:
     _BidirectionalIterator           __begin_;
     _BidirectionalIterator           __end_;
     const regex_type*                __pregex_;
     regex_constants::match_flag_type __flags_;
     value_type                       __match_;
 
 public:
     regex_iterator();
     regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                    const regex_type& __re,
                    regex_constants::match_flag_type __m
                                               = regex_constants::match_default);
 #if _LIBCPP_STD_VER > 11
     regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                    const regex_type&& __re,
                    regex_constants::match_flag_type __m
                                      = regex_constants::match_default) = delete;
 #endif
 
     bool operator==(const regex_iterator& __x) const;
     _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const regex_iterator& __x) const {return !(*this == __x);}
 
     _LIBCPP_INLINE_VISIBILITY
     reference operator*() const {return  __match_;}
     _LIBCPP_INLINE_VISIBILITY
     pointer operator->() const  {return _VSTD::addressof(__match_);}
 
     regex_iterator& operator++();
     _LIBCPP_INLINE_VISIBILITY
     regex_iterator operator++(int)
     {
         regex_iterator __t(*this);
         ++(*this);
         return __t;
     }
 };
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 regex_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_iterator()
     : __begin_(), __end_(), __pregex_(nullptr), __flags_(), __match_()
 {
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 regex_iterator<_BidirectionalIterator, _CharT, _Traits>::
     regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                    const regex_type& __re, regex_constants::match_flag_type __m)
     : __begin_(__a),
       __end_(__b),
       __pregex_(_VSTD::addressof(__re)),
       __flags_(__m)
 {
     _VSTD::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_);
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 bool
 regex_iterator<_BidirectionalIterator, _CharT, _Traits>::
     operator==(const regex_iterator& __x) const
 {
     if (__match_.empty() && __x.__match_.empty())
         return true;
     if (__match_.empty() || __x.__match_.empty())
         return false;
     return __begin_ == __x.__begin_       &&
            __end_ == __x.__end_           &&
            __pregex_ == __x.__pregex_     &&
            __flags_ == __x.__flags_       &&
            __match_[0] == __x.__match_[0];
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 regex_iterator<_BidirectionalIterator, _CharT, _Traits>&
 regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
 {
     __flags_ |= regex_constants::__no_update_pos;
     _BidirectionalIterator __start = __match_[0].second;
     if (__match_[0].first == __match_[0].second)
     {
         if (__start == __end_)
         {
             __match_ = value_type();
             return *this;
         }
         else if (_VSTD::regex_search(__start, __end_, __match_, *__pregex_,
                                     __flags_ | regex_constants::match_not_null |
                                     regex_constants::match_continuous))
             return *this;
         else
             ++__start;
     }
     __flags_ |= regex_constants::match_prev_avail;
     if (!_VSTD::regex_search(__start, __end_, __match_, *__pregex_, __flags_))
         __match_ = value_type();
     return *this;
 }
 
 typedef regex_iterator<const char*>             cregex_iterator;
 typedef regex_iterator<const wchar_t*>          wcregex_iterator;
 typedef regex_iterator<string::const_iterator>  sregex_iterator;
 typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
 
 // regex_token_iterator
 
 template <class _BidirectionalIterator,
           class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
           class _Traits = regex_traits<_CharT> >
 class _LIBCPP_TEMPLATE_VIS regex_token_iterator
 {
 public:
     typedef basic_regex<_CharT, _Traits>      regex_type;
     typedef sub_match<_BidirectionalIterator> value_type;
     typedef ptrdiff_t                         difference_type;
     typedef const value_type*                 pointer;
     typedef const value_type&                 reference;
     typedef forward_iterator_tag              iterator_category;
 
 private:
     typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Position;
 
     _Position         __position_;
     const value_type* __result_;
     value_type        __suffix_;
     ptrdiff_t         __n_;
     vector<int>       __subs_;
 
 public:
     regex_token_iterator();
     regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                          const regex_type& __re, int __submatch = 0,
                          regex_constants::match_flag_type __m =
                                                 regex_constants::match_default);
 #if _LIBCPP_STD_VER > 11
     regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                          const regex_type&& __re, int __submatch = 0,
                          regex_constants::match_flag_type __m =
                                        regex_constants::match_default) = delete;
 #endif
 
     regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                          const regex_type& __re, const vector<int>& __submatches,
                          regex_constants::match_flag_type __m =
                                                 regex_constants::match_default);
 #if _LIBCPP_STD_VER > 11
     regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                          const regex_type&& __re, const vector<int>& __submatches,
                          regex_constants::match_flag_type __m =
                                      regex_constants::match_default) = delete;
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
     regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                          const regex_type& __re,
                          initializer_list<int> __submatches,
                          regex_constants::match_flag_type __m =
                                                 regex_constants::match_default);
 
 #if _LIBCPP_STD_VER > 11
     regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                          const regex_type&& __re,
                          initializer_list<int> __submatches,
                          regex_constants::match_flag_type __m =
                                        regex_constants::match_default) = delete;
 #endif
 #endif  // _LIBCPP_CXX03_LANG
     template <size_t _Np>
         regex_token_iterator(_BidirectionalIterator __a,
                              _BidirectionalIterator __b,
                              const regex_type& __re,
                              const int (&__submatches)[_Np],
                              regex_constants::match_flag_type __m =
                                                 regex_constants::match_default);
 #if _LIBCPP_STD_VER > 11
     template <std::size_t _Np>
         regex_token_iterator(_BidirectionalIterator __a,
                              _BidirectionalIterator __b,
                              const regex_type&& __re,
                              const int (&__submatches)[_Np],
                              regex_constants::match_flag_type __m =
                                       regex_constants::match_default) = delete;
 #endif
 
     regex_token_iterator(const regex_token_iterator&);
     regex_token_iterator& operator=(const regex_token_iterator&);
 
     bool operator==(const regex_token_iterator& __x) const;
     _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const regex_token_iterator& __x) const {return !(*this == __x);}
 
     _LIBCPP_INLINE_VISIBILITY
     const value_type& operator*() const {return *__result_;}
     _LIBCPP_INLINE_VISIBILITY
     const value_type* operator->() const {return __result_;}
 
     regex_token_iterator& operator++();
     _LIBCPP_INLINE_VISIBILITY
     regex_token_iterator operator++(int)
     {
         regex_token_iterator __t(*this);
         ++(*this);
         return __t;
     }
 
 private:
     void __init(_BidirectionalIterator __a, _BidirectionalIterator __b);
     void __establish_result () {
         if (__subs_[__n_] == -1)
             __result_ = &__position_->prefix();
         else
             __result_ = &(*__position_)[__subs_[__n_]];
         }
 };
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
     regex_token_iterator()
     : __result_(nullptr),
       __suffix_(),
       __n_(0)
 {
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 void
 regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
     __init(_BidirectionalIterator __a, _BidirectionalIterator __b)
 {
     if (__position_ != _Position())
         __establish_result ();
     else if (__subs_[__n_] == -1)
     {
         __suffix_.matched = true;
         __suffix_.first = __a;
         __suffix_.second = __b;
         __result_ = &__suffix_;
     }
     else
         __result_ = nullptr;
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
     regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                          const regex_type& __re, int __submatch,
                          regex_constants::match_flag_type __m)
     : __position_(__a, __b, __re, __m),
       __n_(0),
       __subs_(1, __submatch)
 {
     __init(__a, __b);
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
     regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                          const regex_type& __re, const vector<int>& __submatches,
                          regex_constants::match_flag_type __m)
     : __position_(__a, __b, __re, __m),
       __n_(0),
       __subs_(__submatches)
 {
     __init(__a, __b);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
     regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                          const regex_type& __re,
                          initializer_list<int> __submatches,
                          regex_constants::match_flag_type __m)
     : __position_(__a, __b, __re, __m),
       __n_(0),
       __subs_(__submatches)
 {
     __init(__a, __b);
 }
 
 #endif  // _LIBCPP_CXX03_LANG
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 template <size_t _Np>
 regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
     regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                              const regex_type& __re,
                              const int (&__submatches)[_Np],
                              regex_constants::match_flag_type __m)
     : __position_(__a, __b, __re, __m),
       __n_(0),
       __subs_(begin(__submatches), end(__submatches))
 {
     __init(__a, __b);
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
     regex_token_iterator(const regex_token_iterator& __x)
     : __position_(__x.__position_),
       __result_(__x.__result_),
       __suffix_(__x.__suffix_),
       __n_(__x.__n_),
       __subs_(__x.__subs_)
 {
     if (__x.__result_ == &__x.__suffix_)
         __result_ = &__suffix_;
     else if ( __result_ != nullptr )
         __establish_result ();
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>&
 regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
     operator=(const regex_token_iterator& __x)
 {
     if (this != &__x)
     {
         __position_ = __x.__position_;
         if (__x.__result_ == &__x.__suffix_)
             __result_ = &__suffix_;
         else
             __result_ = __x.__result_;
         __suffix_ = __x.__suffix_;
         __n_ = __x.__n_;
         __subs_ = __x.__subs_;
 
         if ( __result_ != nullptr && __result_ != &__suffix_ )
             __establish_result();
     }
     return *this;
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 bool
 regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
     operator==(const regex_token_iterator& __x) const
 {
     if (__result_ == nullptr && __x.__result_ == nullptr)
         return true;
     if (__result_ == &__suffix_ && __x.__result_ == &__x.__suffix_ &&
             __suffix_ == __x.__suffix_)
         return true;
     if (__result_ == nullptr || __x.__result_ == nullptr)
         return false;
     if (__result_ == &__suffix_ || __x.__result_ == &__x.__suffix_)
         return false;
     return __position_ == __x.__position_ && __n_ == __x.__n_ &&
            __subs_ == __x.__subs_;
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>&
 regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
 {
     _Position __prev = __position_;
     if (__result_ == &__suffix_)
         __result_ = nullptr;
     else if (static_cast<size_t>(__n_ + 1) < __subs_.size())
     {
         ++__n_;
         __establish_result();
     }
     else
     {
         __n_ = 0;
         ++__position_;
         if (__position_ != _Position())
             __establish_result();
         else
         {
             if (_VSTD::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end()
                 && __prev->suffix().length() != 0)
             {
                 __suffix_.matched = true;
                 __suffix_.first = __prev->suffix().first;
                 __suffix_.second = __prev->suffix().second;
                 __result_ = &__suffix_;
             }
             else
                 __result_ = nullptr;
         }
     }
     return *this;
 }
 
 typedef regex_token_iterator<const char*>             cregex_token_iterator;
 typedef regex_token_iterator<const wchar_t*>          wcregex_token_iterator;
 typedef regex_token_iterator<string::const_iterator>  sregex_token_iterator;
 typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
 
 // regex_replace
 
 template <class _OutputIterator, class _BidirectionalIterator,
           class _Traits, class _CharT>
 _OutputIterator
 regex_replace(_OutputIterator __output_iter,
               _BidirectionalIterator __first, _BidirectionalIterator __last,
               const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Iter;
     _Iter __i(__first, __last, __e, __flags);
     _Iter __eof;
     if (__i == __eof)
     {
         if (!(__flags & regex_constants::format_no_copy))
             __output_iter = _VSTD::copy(__first, __last, __output_iter);
     }
     else
     {
         sub_match<_BidirectionalIterator> __lm;
         for (size_t __len = char_traits<_CharT>::length(__fmt); __i != __eof; ++__i)
         {
             if (!(__flags & regex_constants::format_no_copy))
                 __output_iter = _VSTD::copy(__i->prefix().first, __i->prefix().second, __output_iter);
             __output_iter = __i->format(__output_iter, __fmt, __fmt + __len, __flags);
             __lm = __i->suffix();
             if (__flags & regex_constants::format_first_only)
                 break;
         }
         if (!(__flags & regex_constants::format_no_copy))
             __output_iter = _VSTD::copy(__lm.first, __lm.second, __output_iter);
     }
     return __output_iter;
 }
 
 template <class _OutputIterator, class _BidirectionalIterator,
           class _Traits, class _CharT, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
 regex_replace(_OutputIterator __output_iter,
               _BidirectionalIterator __first, _BidirectionalIterator __last,
               const basic_regex<_CharT, _Traits>& __e,
               const basic_string<_CharT, _ST, _SA>& __fmt,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     return _VSTD::regex_replace(__output_iter, __first, __last, __e, __fmt.c_str(), __flags);
 }
 
 template <class _Traits, class _CharT, class _ST, class _SA, class _FST,
           class _FSA>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _ST, _SA>
 regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
               const basic_regex<_CharT, _Traits>& __e,
               const basic_string<_CharT, _FST, _FSA>& __fmt,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     basic_string<_CharT, _ST, _SA> __r;
     _VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
                         __fmt.c_str(), __flags);
     return __r;
 }
 
 template <class _Traits, class _CharT, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT, _ST, _SA>
 regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
               const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     basic_string<_CharT, _ST, _SA> __r;
     _VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
                         __fmt, __flags);
     return __r;
 }
 
 template <class _Traits, class _CharT, class _ST, class _SA>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT>
 regex_replace(const _CharT* __s,
               const basic_regex<_CharT, _Traits>& __e,
               const basic_string<_CharT, _ST, _SA>& __fmt,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     basic_string<_CharT> __r;
     _VSTD::regex_replace(back_inserter(__r), __s,
                         __s + char_traits<_CharT>::length(__s), __e,
                         __fmt.c_str(), __flags);
     return __r;
 }
 
 template <class _Traits, class _CharT>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_string<_CharT>
 regex_replace(const _CharT* __s,
               const basic_regex<_CharT, _Traits>& __e,
               const _CharT* __fmt,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     basic_string<_CharT> __r;
     _VSTD::regex_replace(back_inserter(__r), __s,
                         __s + char_traits<_CharT>::length(__s), __e,
                         __fmt, __flags);
     return __r;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP_REGEX
Index: head/contrib/llvm-project/libcxx/include/stdexcept
===================================================================
--- head/contrib/llvm-project/libcxx/include/stdexcept	(revision 359086)
+++ head/contrib/llvm-project/libcxx/include/stdexcept	(revision 359087)
@@ -1,304 +1,311 @@
 // -*- C++ -*-
 //===--------------------------- stdexcept --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_STDEXCEPT
 #define _LIBCPP_STDEXCEPT
 
 /*
     stdexcept synopsis
 
 namespace std
 {
 
 class logic_error;
     class domain_error;
     class invalid_argument;
     class length_error;
     class out_of_range;
 class runtime_error;
     class range_error;
     class overflow_error;
     class underflow_error;
 
 for each class xxx_error:
 
 class xxx_error : public exception // at least indirectly
 {
 public:
     explicit xxx_error(const string& what_arg);
     explicit xxx_error(const char*   what_arg);
 
     virtual const char* what() const noexcept // returns what_arg
 };
 
 }  // std
 
 */
 
 #include <__config>
 #include <exception>
 #include <iosfwd>  // for string forward decl
 #ifdef _LIBCPP_NO_EXCEPTIONS
 #include <cstdlib>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
 class _LIBCPP_HIDDEN __libcpp_refstring
 {
     const char* __imp_;
 
     bool __uses_refcount() const;
 public:
     explicit __libcpp_refstring(const char* __msg);
     __libcpp_refstring(const __libcpp_refstring& __s) _NOEXCEPT;
     __libcpp_refstring& operator=(const __libcpp_refstring& __s) _NOEXCEPT;
     ~__libcpp_refstring();
 
     const char* c_str() const _NOEXCEPT {return __imp_;}
 };
 #endif // !_LIBCPP_ABI_VCRUNTIME
 
 _LIBCPP_END_NAMESPACE_STD
 
 namespace std  // purposefully not using versioning namespace
 {
 
 class _LIBCPP_EXCEPTION_ABI logic_error
     : public exception
 {
 #ifndef _LIBCPP_ABI_VCRUNTIME
 private:
     _VSTD::__libcpp_refstring __imp_;
 public:
     explicit logic_error(const string&);
     explicit logic_error(const char*);
 
     logic_error(const logic_error&) _NOEXCEPT;
     logic_error& operator=(const logic_error&) _NOEXCEPT;
 
     virtual ~logic_error() _NOEXCEPT;
 
     virtual const char* what() const _NOEXCEPT;
 #else
 public:
     explicit logic_error(const _VSTD::string&); // Symbol uses versioned std::string
     _LIBCPP_INLINE_VISIBILITY explicit logic_error(const char* __s) : exception(__s) {}
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI runtime_error
     : public exception
 {
 #ifndef _LIBCPP_ABI_VCRUNTIME
 private:
     _VSTD::__libcpp_refstring __imp_;
 public:
     explicit runtime_error(const string&);
     explicit runtime_error(const char*);
 
     runtime_error(const runtime_error&) _NOEXCEPT;
     runtime_error& operator=(const runtime_error&) _NOEXCEPT;
 
     virtual ~runtime_error() _NOEXCEPT;
 
     virtual const char* what() const _NOEXCEPT;
 #else
 public:
    explicit runtime_error(const _VSTD::string&); // Symbol uses versioned std::string
    _LIBCPP_INLINE_VISIBILITY explicit runtime_error(const char* __s) : exception(__s) {}
 #endif // _LIBCPP_ABI_VCRUNTIME
 };
 
 class _LIBCPP_EXCEPTION_ABI domain_error
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit domain_error(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit domain_error(const char* __s)   : logic_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
+    domain_error(const domain_error&) _NOEXCEPT = default;
     virtual ~domain_error() _NOEXCEPT;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI invalid_argument
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const char* __s)   : logic_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
+    invalid_argument(const invalid_argument&) _NOEXCEPT = default;
     virtual ~invalid_argument() _NOEXCEPT;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI length_error
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit length_error(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit length_error(const char* __s)   : logic_error(__s) {}
 #ifndef _LIBCPP_ABI_VCRUNTIME
+    length_error(const length_error&) _NOEXCEPT = default;
     virtual ~length_error() _NOEXCEPT;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI out_of_range
     : public logic_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const string& __s) : logic_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const char* __s)   : logic_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
+    out_of_range(const out_of_range&) _NOEXCEPT = default;
     virtual ~out_of_range() _NOEXCEPT;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI range_error
     : public runtime_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit range_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit range_error(const char* __s)   : runtime_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
+    range_error(const range_error&) _NOEXCEPT = default;
     virtual ~range_error() _NOEXCEPT;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI overflow_error
     : public runtime_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const char* __s)   : runtime_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
+    overflow_error(const overflow_error&) _NOEXCEPT = default;
     virtual ~overflow_error() _NOEXCEPT;
 #endif
 };
 
 class _LIBCPP_EXCEPTION_ABI underflow_error
     : public runtime_error
 {
 public:
     _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const string& __s) : runtime_error(__s) {}
     _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const char* __s)   : runtime_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
+    underflow_error(const underflow_error&) _NOEXCEPT = default;
     virtual ~underflow_error() _NOEXCEPT;
 #endif
 };
 
 }  // std
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // in the dylib
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_logic_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw logic_error(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_domain_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw domain_error(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_invalid_argument(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw invalid_argument(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_length_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw length_error(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_out_of_range(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw out_of_range(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_range_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw range_error(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_overflow_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw overflow_error(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_underflow_error(const char*__msg)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw underflow_error(__msg);
 #else
     ((void)__msg);
     _VSTD::abort();
 #endif
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_STDEXCEPT
Index: head/contrib/llvm-project/libcxx/include/system_error
===================================================================
--- head/contrib/llvm-project/libcxx/include/system_error	(revision 359086)
+++ head/contrib/llvm-project/libcxx/include/system_error	(revision 359087)
@@ -1,486 +1,487 @@
 // -*- C++ -*-
 //===---------------------------- system_error ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_SYSTEM_ERROR
 #define _LIBCPP_SYSTEM_ERROR
 
 /*
     system_error synopsis
 
 namespace std
 {
 
 class error_category
 {
 public:
     virtual ~error_category() noexcept;
 
     constexpr error_category();
     error_category(const error_category&) = delete;
     error_category& operator=(const error_category&) = delete;
 
     virtual const char* name() const noexcept = 0;
     virtual error_condition default_error_condition(int ev) const noexcept;
     virtual bool equivalent(int code, const error_condition& condition) const noexcept;
     virtual bool equivalent(const error_code& code, int condition) const noexcept;
     virtual string message(int ev) const = 0;
 
     bool operator==(const error_category& rhs) const noexcept;
     bool operator!=(const error_category& rhs) const noexcept;
     bool operator<(const error_category& rhs) const noexcept;
 };
 
 const error_category& generic_category() noexcept;
 const error_category& system_category() noexcept;
 
 template <class T> struct is_error_code_enum
     : public false_type {};
 
 template <class T> struct is_error_condition_enum
     : public false_type {};
 
 template <class _Tp>
 inline constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; // C++17
 
 template <class _Tp>
 inline constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; // C++17
 
 class error_code
 {
 public:
     // constructors:
     error_code() noexcept;
     error_code(int val, const error_category& cat) noexcept;
     template <class ErrorCodeEnum>
         error_code(ErrorCodeEnum e) noexcept;
 
     // modifiers:
     void assign(int val, const error_category& cat) noexcept;
     template <class ErrorCodeEnum>
         error_code& operator=(ErrorCodeEnum e) noexcept;
     void clear() noexcept;
 
     // observers:
     int value() const noexcept;
     const error_category& category() const noexcept;
     error_condition default_error_condition() const noexcept;
     string message() const;
     explicit operator bool() const noexcept;
 };
 
 // non-member functions:
 bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
 template <class charT, class traits>
     basic_ostream<charT,traits>&
     operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
 
 class error_condition
 {
 public:
     // constructors:
     error_condition() noexcept;
     error_condition(int val, const error_category& cat) noexcept;
     template <class ErrorConditionEnum>
         error_condition(ErrorConditionEnum e) noexcept;
 
     // modifiers:
     void assign(int val, const error_category& cat) noexcept;
     template <class ErrorConditionEnum>
         error_condition& operator=(ErrorConditionEnum e) noexcept;
     void clear() noexcept;
 
     // observers:
     int value() const noexcept;
     const error_category& category() const noexcept;
     string message() const noexcept;
     explicit operator bool() const noexcept;
 };
 
 bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
 
 class system_error
     : public runtime_error
 {
 public:
     system_error(error_code ec, const string& what_arg);
     system_error(error_code ec, const char* what_arg);
     system_error(error_code ec);
     system_error(int ev, const error_category& ecat, const string& what_arg);
     system_error(int ev, const error_category& ecat, const char* what_arg);
     system_error(int ev, const error_category& ecat);
 
     const error_code& code() const noexcept;
     const char* what() const noexcept;
 };
 
 template <> struct is_error_condition_enum<errc>
     : true_type { }
 
 error_code make_error_code(errc e) noexcept;
 error_condition make_error_condition(errc e) noexcept;
 
 // Comparison operators:
 bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
 bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
 bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;
 bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;
 bool operator!=(const error_code& lhs, const error_code& rhs) noexcept;
 bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept;
 bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept;
 bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept;
 
 template <> struct hash<std::error_code>;
 template <> struct hash<std::error_condition>;
 
 }  // std
 
 */
 
 #include <__errc>
 #include <type_traits>
 #include <stdexcept>
 #include <__functional_base>
 #include <string>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // is_error_code_enum
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum
     : public false_type {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 _LIBCPP_INLINE_VAR constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value;
 #endif
 
 // is_error_condition_enum
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum
     : public false_type {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 _LIBCPP_INLINE_VAR constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value;
 #endif
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc>
     : true_type { };
 
 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
 template <>
 struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx>
     : true_type { };
 #endif
 
 class _LIBCPP_TYPE_VIS error_condition;
 class _LIBCPP_TYPE_VIS error_code;
 
 // class error_category
 
 class _LIBCPP_HIDDEN __do_message;
 
 class _LIBCPP_TYPE_VIS error_category
 {
 public:
     virtual ~error_category() _NOEXCEPT;
 
 #if defined(_LIBCPP_BUILDING_LIBRARY) && \
     defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
     error_category() _NOEXCEPT;
 #else
     _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR_AFTER_CXX11 error_category() _NOEXCEPT _LIBCPP_DEFAULT
 #endif
 private:
     error_category(const error_category&);// = delete;
     error_category& operator=(const error_category&);// = delete;
 
 public:
     virtual const char* name() const _NOEXCEPT = 0;
     virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
     virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
     virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
     virtual string message(int __ev) const = 0;
 
     _LIBCPP_INLINE_VISIBILITY
     bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}
 
     _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}
 
     _LIBCPP_INLINE_VISIBILITY
     bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
 
     friend class _LIBCPP_HIDDEN __do_message;
 };
 
 class _LIBCPP_HIDDEN __do_message
     : public error_category
 {
 public:
     virtual string message(int ev) const;
 };
 
 _LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
 _LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT;
 
 class _LIBCPP_TYPE_VIS error_condition
 {
     int __val_;
     const error_category* __cat_;
 public:
     _LIBCPP_INLINE_VISIBILITY
     error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
 
     _LIBCPP_INLINE_VISIBILITY
     error_condition(int __val, const error_category& __cat) _NOEXCEPT
         : __val_(__val), __cat_(&__cat) {}
 
     template <class _Ep>
         _LIBCPP_INLINE_VISIBILITY
         error_condition(_Ep __e,
               typename enable_if<is_error_condition_enum<_Ep>::value>::type* = 0
                                                                      ) _NOEXCEPT
             {*this = make_error_condition(__e);}
 
     _LIBCPP_INLINE_VISIBILITY
     void assign(int __val, const error_category& __cat) _NOEXCEPT
     {
         __val_ = __val;
         __cat_ = &__cat;
     }
 
     template <class _Ep>
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
             is_error_condition_enum<_Ep>::value,
             error_condition&
         >::type
         operator=(_Ep __e) _NOEXCEPT
             {*this = make_error_condition(__e); return *this;}
 
     _LIBCPP_INLINE_VISIBILITY
     void clear() _NOEXCEPT
     {
         __val_ = 0;
         __cat_ = &generic_category();
     }
 
     _LIBCPP_INLINE_VISIBILITY
     int value() const _NOEXCEPT {return __val_;}
 
     _LIBCPP_INLINE_VISIBILITY
     const error_category& category() const _NOEXCEPT {return *__cat_;}
     string message() const;
 
     _LIBCPP_INLINE_VISIBILITY
         _LIBCPP_EXPLICIT
         operator bool() const _NOEXCEPT {return __val_ != 0;}
 };
 
 inline _LIBCPP_INLINE_VISIBILITY
 error_condition
 make_error_condition(errc __e) _NOEXCEPT
 {
     return error_condition(static_cast<int>(__e), generic_category());
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
 {
     return __x.category() < __y.category()
         || (__x.category() == __y.category() && __x.value() < __y.value());
 }
 
 // error_code
 
 class _LIBCPP_TYPE_VIS error_code
 {
     int __val_;
     const error_category* __cat_;
 public:
     _LIBCPP_INLINE_VISIBILITY
     error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
 
     _LIBCPP_INLINE_VISIBILITY
     error_code(int __val, const error_category& __cat) _NOEXCEPT
         : __val_(__val), __cat_(&__cat) {}
 
     template <class _Ep>
         _LIBCPP_INLINE_VISIBILITY
         error_code(_Ep __e,
                    typename enable_if<is_error_code_enum<_Ep>::value>::type* = 0
                                                                      ) _NOEXCEPT
             {*this = make_error_code(__e);}
 
     _LIBCPP_INLINE_VISIBILITY
     void assign(int __val, const error_category& __cat) _NOEXCEPT
     {
         __val_ = __val;
         __cat_ = &__cat;
     }
 
     template <class _Ep>
         _LIBCPP_INLINE_VISIBILITY
         typename enable_if
         <
             is_error_code_enum<_Ep>::value,
             error_code&
         >::type
         operator=(_Ep __e) _NOEXCEPT
             {*this = make_error_code(__e); return *this;}
 
     _LIBCPP_INLINE_VISIBILITY
     void clear() _NOEXCEPT
     {
         __val_ = 0;
         __cat_ = &system_category();
     }
 
     _LIBCPP_INLINE_VISIBILITY
     int value() const _NOEXCEPT {return __val_;}
 
     _LIBCPP_INLINE_VISIBILITY
     const error_category& category() const _NOEXCEPT {return *__cat_;}
 
     _LIBCPP_INLINE_VISIBILITY
     error_condition default_error_condition() const _NOEXCEPT
         {return __cat_->default_error_condition(__val_);}
 
     string message() const;
 
     _LIBCPP_INLINE_VISIBILITY
         _LIBCPP_EXPLICIT
         operator bool() const _NOEXCEPT {return __val_ != 0;}
 };
 
 inline _LIBCPP_INLINE_VISIBILITY
 error_code
 make_error_code(errc __e) _NOEXCEPT
 {
     return error_code(static_cast<int>(__e), generic_category());
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
 {
     return __x.category() < __y.category()
         || (__x.category() == __y.category() && __x.value() < __y.value());
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
 {
     return __x.category() == __y.category() && __x.value() == __y.value();
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
 {
     return __x.category().equivalent(__x.value(), __y)
         || __y.category().equivalent(__x, __y.value());
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
 {
     return __y == __x;
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
 {
     return __x.category() == __y.category() && __x.value() == __y.value();
 }
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
 {return !(__x == __y);}
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
 {return !(__x == __y);}
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
 {return !(__x == __y);}
 
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
 {return !(__x == __y);}
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS hash<error_code>
     : public unary_function<error_code, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const error_code& __ec) const _NOEXCEPT
     {
         return static_cast<size_t>(__ec.value());
     }
 };
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS hash<error_condition>
     : public unary_function<error_condition, size_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const error_condition& __ec) const _NOEXCEPT
     {
         return static_cast<size_t>(__ec.value());
     }
 };
 
 // system_error
 
 class _LIBCPP_TYPE_VIS system_error
     : public runtime_error
 {
     error_code __ec_;
 public:
     system_error(error_code __ec, const string& __what_arg);
     system_error(error_code __ec, const char* __what_arg);
     system_error(error_code __ec);
     system_error(int __ev, const error_category& __ecat, const string& __what_arg);
     system_error(int __ev, const error_category& __ecat, const char* __what_arg);
     system_error(int __ev, const error_category& __ecat);
+    system_error(const system_error&) _NOEXCEPT = default;
     ~system_error() _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     const error_code& code() const _NOEXCEPT {return __ec_;}
 
 private:
     static string __init(const error_code&, string);
 };
 
 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS
 void __throw_system_error(int ev, const char* what_arg);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_SYSTEM_ERROR
Index: head/contrib/llvm-project/libcxx/include/typeinfo
===================================================================
--- head/contrib/llvm-project/libcxx/include/typeinfo	(revision 359086)
+++ head/contrib/llvm-project/libcxx/include/typeinfo	(revision 359087)
@@ -1,350 +1,351 @@
 // -*- C++ -*-
 //===-------------------------- typeinfo ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef __LIBCPP_TYPEINFO
 #define __LIBCPP_TYPEINFO
 
 /*
 
     typeinfo synopsis
 
 namespace std {
 
 class type_info
 {
 public:
     virtual ~type_info();
 
     bool operator==(const type_info& rhs) const noexcept;
     bool operator!=(const type_info& rhs) const noexcept;
 
     bool before(const type_info& rhs) const noexcept;
     size_t hash_code() const noexcept;
     const char* name() const noexcept;
 
     type_info(const type_info& rhs) = delete;
     type_info& operator=(const type_info& rhs) = delete;
 };
 
 class bad_cast
     : public exception
 {
 public:
     bad_cast() noexcept;
     bad_cast(const bad_cast&) noexcept;
     bad_cast& operator=(const bad_cast&) noexcept;
     virtual const char* what() const noexcept;
 };
 
 class bad_typeid
     : public exception
 {
 public:
     bad_typeid() noexcept;
     bad_typeid(const bad_typeid&) noexcept;
     bad_typeid& operator=(const bad_typeid&) noexcept;
     virtual const char* what() const noexcept;
 };
 
 }  // std
 
 */
 
 #include <__config>
 #include <exception>
 #include <cstddef>
 #include <cstdint>
 #ifdef _LIBCPP_NO_EXCEPTIONS
 #include <cstdlib>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 #if defined(_LIBCPP_ABI_VCRUNTIME)
 #include <vcruntime_typeinfo.h>
 #else
 
 namespace std  // purposefully not using versioning namespace
 {
 
 
 #if defined(_LIBCPP_ABI_MICROSOFT)
 
 class _LIBCPP_EXCEPTION_ABI type_info
 {
     type_info& operator=(const type_info&);
     type_info(const type_info&);
 
     mutable struct {
       const char *__undecorated_name;
       const char __decorated_name[1];
     } __data;
 
     int __compare(const type_info &__rhs) const _NOEXCEPT;
 
 public:
     _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE
     virtual ~type_info();
 
     const char *name() const _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     bool before(const type_info& __arg) const _NOEXCEPT {
       return __compare(__arg) < 0;
     }
 
     size_t hash_code() const _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY
     bool operator==(const type_info& __arg) const _NOEXCEPT {
       return __compare(__arg) == 0;
     }
 
     _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const type_info& __arg) const _NOEXCEPT
     { return !operator==(__arg); }
 };
 
 #else // !defined(_LIBCPP_ABI_MICROSOFT)
 
 // ========================================================================== //
 //                           Implementations
 // ========================================================================== //
 // ------------------------------------------------------------------------- //
 //                               Unique
 // ------------------------------------------------------------------------- //
 // This implementation of type_info assumes a unique copy of the RTTI for a
 // given type inside a program. This is a valid assumption when abiding to
 // Itanium ABI (http://itanium-cxx-abi.github.io/cxx-abi/abi.html#vtable-components).
 // Under this assumption, we can always compare the addresses of the type names
 // to implement equality-comparison of type_infos instead of having to perform
 // a deep string comparison.
 // -------------------------------------------------------------------------- //
 //                             NonUnique
 // -------------------------------------------------------------------------- //
 // This implementation of type_info does not assume there is always a unique
 // copy of the RTTI for a given type inside a program. For various reasons
 // the linker may have failed to merge every copy of a types RTTI
 // (For example: -Bsymbolic or llvm.org/PR37398). Under this assumption, two
 // type_infos are equal if their addresses are equal or if a deep string
 // comparison is equal.
 // -------------------------------------------------------------------------- //
 //                          NonUniqueARMRTTIBit
 // -------------------------------------------------------------------------- //
 // This implementation of type_info does not assume always a unique copy of
 // the RTTI for a given type inside a program. It packs the pointer to the
 // type name into a uintptr_t and reserves the high bit of that pointer (which
 // is assumed to be free for use under the ABI in use) to represent whether
 // that specific copy of the RTTI can be assumed unique inside the program.
 // To implement equality-comparison of type_infos, we check whether BOTH
 // type_infos are guaranteed unique, and if so, we simply compare the addresses
 // of their type names instead of doing a deep string comparison, which is
 // faster. If at least one of the type_infos can't guarantee uniqueness, we
 // have no choice but to fall back to a deep string comparison.
 //
 // This implementation is specific to ARM64 on Apple platforms.
 //
 // Note that the compiler is the one setting (or unsetting) the high bit of
 // the pointer when it constructs the type_info, depending on whether it can
 // guarantee uniqueness for that specific type_info.
 
 struct __type_info_implementations {
   struct __string_impl_base {
     typedef const char* __type_name_t;
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
     _LIBCPP_CONSTEXPR static const char* __type_name_to_string(__type_name_t __v) _NOEXCEPT {
       return __v;
     }
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
     _LIBCPP_CONSTEXPR static __type_name_t __string_to_type_name(const char* __v) _NOEXCEPT {
       return __v;
     }
   };
 
   struct __unique_impl : __string_impl_base {
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
     static size_t __hash(__type_name_t __v) _NOEXCEPT {
       return reinterpret_cast<size_t>(__v);
     }
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
     static bool __eq(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
       return __lhs == __rhs;
     }
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
     static bool __lt(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
       return __lhs < __rhs;
     }
   };
 
   struct __non_unique_impl : __string_impl_base {
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
     static size_t __hash(__type_name_t __ptr) _NOEXCEPT {
       size_t __hash = 5381;
       while (unsigned char __c = static_cast<unsigned char>(*__ptr++))
         __hash = (__hash * 33) ^ __c;
       return __hash;
     }
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
     static bool __eq(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
       return __lhs == __rhs || __builtin_strcmp(__lhs, __rhs) == 0;
     }
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
     static bool __lt(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
       return __builtin_strcmp(__lhs, __rhs) < 0;
     }
   };
 
   struct __non_unique_arm_rtti_bit_impl {
     typedef uintptr_t __type_name_t;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
     static const char* __type_name_to_string(__type_name_t __v) _NOEXCEPT {
       return reinterpret_cast<const char*>(__v &
           ~__non_unique_rtti_bit::value);
     }
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
     static __type_name_t __string_to_type_name(const char* __v) _NOEXCEPT {
       return reinterpret_cast<__type_name_t>(__v);
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
     static size_t __hash(__type_name_t __v) _NOEXCEPT {
       if (__is_type_name_unique(__v))
         return reinterpret_cast<size_t>(__v);
       return __non_unique_impl::__hash(__type_name_to_string(__v));
     }
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
     static bool __eq(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
       if (__lhs == __rhs)
         return true;
       if (__is_type_name_unique(__lhs, __rhs))
         return false;
       return __builtin_strcmp(__type_name_to_string(__lhs), __type_name_to_string(__rhs)) == 0;
     }
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
     static bool __lt(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
       if (__is_type_name_unique(__lhs, __rhs))
         return __lhs < __rhs;
       return __builtin_strcmp(__type_name_to_string(__lhs), __type_name_to_string(__rhs)) < 0;
     }
 
    private:
     // The unique bit is the top bit. It is expected that __type_name_t is 64 bits when
     // this implementation is actually used.
     typedef std::integral_constant<__type_name_t,
       (1ULL << ((__CHAR_BIT__ * sizeof(__type_name_t)) - 1))> __non_unique_rtti_bit;
 
     _LIBCPP_INLINE_VISIBILITY
     static bool __is_type_name_unique(__type_name_t __lhs) _NOEXCEPT {
       return !(__lhs & __non_unique_rtti_bit::value);
     }
     _LIBCPP_INLINE_VISIBILITY
     static bool __is_type_name_unique(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
       return !((__lhs & __rhs) & __non_unique_rtti_bit::value);
     }
   };
 
   typedef
 #if defined(__APPLE__) && defined(__LP64__) && !defined(__x86_64__)
     __non_unique_arm_rtti_bit_impl
 #elif _LIBCPP_HAS_MERGED_TYPEINFO_NAMES_DEFAULT == 0
     __non_unique_impl
 #elif _LIBCPP_HAS_MERGED_TYPEINFO_NAMES_DEFAULT == 1
     __unique_impl
 #else
 #   error invalid configuration for _LIBCPP_HAS_MERGED_TYPEINFO_NAMES_DEFAULT
 #endif
      __impl;
 };
 
 class _LIBCPP_EXCEPTION_ABI type_info
 {
   type_info& operator=(const type_info&);
   type_info(const type_info&);
 
  protected:
     typedef __type_info_implementations::__impl __impl;
 
     __impl::__type_name_t __type_name;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit type_info(const char* __n)
       : __type_name(__impl::__string_to_type_name(__n)) {}
 
 public:
     _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE
     virtual ~type_info();
 
     _LIBCPP_INLINE_VISIBILITY
     const char* name() const _NOEXCEPT
     {
       return __impl::__type_name_to_string(__type_name);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     bool before(const type_info& __arg) const _NOEXCEPT
     {
       return __impl::__lt(__type_name, __arg.__type_name);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     size_t hash_code() const _NOEXCEPT
     {
       return __impl::__hash(__type_name);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     bool operator==(const type_info& __arg) const _NOEXCEPT
     {
       return __impl::__eq(__type_name, __arg.__type_name);
     }
 
     _LIBCPP_INLINE_VISIBILITY
     bool operator!=(const type_info& __arg) const _NOEXCEPT
     { return !operator==(__arg); }
 };
 #endif // defined(_LIBCPP_ABI_MICROSOFT)
 
 class _LIBCPP_EXCEPTION_ABI bad_cast
     : public exception
 {
  public:
   bad_cast() _NOEXCEPT;
+  bad_cast(const bad_cast&) _NOEXCEPT = default;
   virtual ~bad_cast() _NOEXCEPT;
   virtual const char* what() const _NOEXCEPT;
 };
 
 class _LIBCPP_EXCEPTION_ABI bad_typeid
     : public exception
 {
  public:
   bad_typeid() _NOEXCEPT;
   virtual ~bad_typeid() _NOEXCEPT;
   virtual const char* what() const _NOEXCEPT;
 };
 
 }  // std
 
 #endif // defined(_LIBCPP_ABI_VCRUNTIME)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 void __throw_bad_cast()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
     throw bad_cast();
 #else
     _VSTD::abort();
 #endif
 }
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // __LIBCPP_TYPEINFO