Restoring authorship annotation for Andrey Khalyavin <halyavin@gmail.com>. Commit 1 of 2.

1 files changed, 1356 insertions, 1356 deletions

diff --git a/contrib/libs/cxxsupp/libcxx/include/optional b/contrib/libs/cxxsupp/libcxx/include/optional
index 0f6d233051..c594036647 100644
--- a/contrib/libs/cxxsupp/libcxx/include/optional
+++ b/contrib/libs/cxxsupp/libcxx/include/optional
@@ -1,1392 +1,1392 @@
-// -*- C++ -*-
-//===-------------------------- optional ----------------------------------===//
-//
+// -*- C++ -*- 
+//===-------------------------- optional ----------------------------------===// 
+// 
 // 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_OPTIONAL
-#define _LIBCPP_OPTIONAL
-
-/*
-    optional synopsis
-
-// C++1z
-
-namespace std {
-  // 23.6.3, optional for object types
-  template <class T> class optional;
-
-  // 23.6.4, no-value state indicator
-  struct nullopt_t{see below };
-  inline constexpr nullopt_t nullopt(unspecified );
-
-  // 23.6.5, class bad_optional_access
-  class bad_optional_access;
-
-  // 23.6.6, relational operators
-  template <class T, class U>
-  constexpr bool operator==(const optional<T>&, const optional<U>&);
-  template <class T, class U>
-  constexpr bool operator!=(const optional<T>&, const optional<U>&);
-  template <class T, class U>
-  constexpr bool operator<(const optional<T>&, const optional<U>&);
-  template <class T, class U>
-  constexpr bool operator>(const optional<T>&, const optional<U>&);
-  template <class T, class U>
-  constexpr bool operator<=(const optional<T>&, const optional<U>&);
-  template <class T, class U>
-  constexpr bool operator>=(const optional<T>&, const optional<U>&);
-
-  // 23.6.7 comparison with nullopt
-  template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept;
-  template <class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept;
-  template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept;
-  template <class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept;
-  template <class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept;
-  template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept;
-  template <class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept;
-
-  // 23.6.8, comparison with T
-  template <class T, class U> constexpr bool operator==(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator==(const T&, const optional<U>&);
-  template <class T, class U> constexpr bool operator!=(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator!=(const T&, const optional<U>&);
-  template <class T, class U> constexpr bool operator<(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator<(const T&, const optional<U>&);
-  template <class T, class U> constexpr bool operator<=(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator<=(const T&, const optional<U>&);
-  template <class T, class U> constexpr bool operator>(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator>(const T&, const optional<U>&);
-  template <class T, class U> constexpr bool operator>=(const optional<T>&, const U&);
-  template <class T, class U> constexpr bool operator>=(const T&, const optional<U>&);
-
-  // 23.6.9, specialized algorithms
-  template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below ); // constexpr in C++20
-  template <class T> constexpr optional<see below > make_optional(T&&);
-  template <class T, class... Args>
-    constexpr optional<T> make_optional(Args&&... args);
-  template <class T, class U, class... Args>
-    constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args);
-
-  // 23.6.10, hash support
-  template <class T> struct hash;
-  template <class T> struct hash<optional<T>>;
-
-  template <class T> class optional {
-  public:
-    using value_type = T;
-
-    // 23.6.3.1, constructors
-    constexpr optional() noexcept;
-    constexpr optional(nullopt_t) noexcept;
-    optional(const optional &);
-    optional(optional &&) noexcept(see below);
-    template <class... Args> constexpr explicit optional(in_place_t, Args &&...);
-    template <class U, class... Args>
-      constexpr explicit optional(in_place_t, initializer_list<U>, Args &&...);
-    template <class U = T>
-      constexpr EXPLICIT optional(U &&);
-    template <class U>
-      EXPLICIT optional(const optional<U> &);   // constexpr in C++20
-    template <class U>
-      EXPLICIT optional(optional<U> &&);        // constexpr in C++20
-
-    // 23.6.3.2, destructor
-    ~optional(); // constexpr in C++20
-
-    // 23.6.3.3, assignment
-    optional &operator=(nullopt_t) noexcept;                     // constexpr in C++20
-    optional &operator=(const optional &);                       // constexpr in C++20
-    optional &operator=(optional &&) noexcept(see below);        // constexpr in C++20
-    template <class U = T> optional &operator=(U &&);            // constexpr in C++20
-    template <class U> optional &operator=(const optional<U> &); // constexpr in C++20
-    template <class U> optional &operator=(optional<U> &&);      // constexpr in C++20
-    template <class... Args> T& emplace(Args &&...);             // constexpr in C++20
-    template <class U, class... Args>
-      T& emplace(initializer_list<U>, Args &&...);               // constexpr in C++20
-
-    // 23.6.3.4, swap
-    void swap(optional &) noexcept(see below ); // constexpr in C++20
-
-    // 23.6.3.5, observers
-    constexpr T const *operator->() const;
-    constexpr T *operator->();
-    constexpr T const &operator*() const &;
-    constexpr T &operator*() &;
-    constexpr T &&operator*() &&;
-    constexpr const T &&operator*() const &&;
-    constexpr explicit operator bool() const noexcept;
-    constexpr bool has_value() const noexcept;
-    constexpr T const &value() const &;
-    constexpr T &value() &;
-    constexpr T &&value() &&;
-    constexpr const T &&value() const &&;
-    template <class U> constexpr T value_or(U &&) const &;
-    template <class U> constexpr T value_or(U &&) &&;
-
-    // 23.6.3.6, modifiers
-    void reset() noexcept; // constexpr in C++20
-
-  private:
-    T *val; // exposition only
-  };
-
-template<class T>
-  optional(T) -> optional<T>;
-
-} // namespace std
-
-*/
-
-#include <__availability>
-#include <__config>
-#include <__debug>
-#include <__functional_base>
-#include <compare>
-#include <functional>
-#include <initializer_list>
-#include <new>
-#include <stdexcept>
-#include <type_traits>
-#include <utility>
+// 
+//===----------------------------------------------------------------------===// 
+ 
+#ifndef _LIBCPP_OPTIONAL 
+#define _LIBCPP_OPTIONAL 
+ 
+/* 
+    optional synopsis 
+ 
+// C++1z 
+ 
+namespace std { 
+  // 23.6.3, optional for object types 
+  template <class T> class optional; 
+ 
+  // 23.6.4, no-value state indicator 
+  struct nullopt_t{see below }; 
+  inline constexpr nullopt_t nullopt(unspecified ); 
+ 
+  // 23.6.5, class bad_optional_access 
+  class bad_optional_access; 
+ 
+  // 23.6.6, relational operators 
+  template <class T, class U> 
+  constexpr bool operator==(const optional<T>&, const optional<U>&); 
+  template <class T, class U> 
+  constexpr bool operator!=(const optional<T>&, const optional<U>&); 
+  template <class T, class U> 
+  constexpr bool operator<(const optional<T>&, const optional<U>&); 
+  template <class T, class U> 
+  constexpr bool operator>(const optional<T>&, const optional<U>&); 
+  template <class T, class U> 
+  constexpr bool operator<=(const optional<T>&, const optional<U>&); 
+  template <class T, class U> 
+  constexpr bool operator>=(const optional<T>&, const optional<U>&); 
+ 
+  // 23.6.7 comparison with nullopt 
+  template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept; 
+  template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept; 
+  template <class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept; 
+  template <class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept; 
+  template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept; 
+  template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept; 
+  template <class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept; 
+  template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept; 
+  template <class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept; 
+  template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept; 
+  template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept; 
+  template <class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept; 
+ 
+  // 23.6.8, comparison with T 
+  template <class T, class U> constexpr bool operator==(const optional<T>&, const U&); 
+  template <class T, class U> constexpr bool operator==(const T&, const optional<U>&); 
+  template <class T, class U> constexpr bool operator!=(const optional<T>&, const U&); 
+  template <class T, class U> constexpr bool operator!=(const T&, const optional<U>&); 
+  template <class T, class U> constexpr bool operator<(const optional<T>&, const U&); 
+  template <class T, class U> constexpr bool operator<(const T&, const optional<U>&); 
+  template <class T, class U> constexpr bool operator<=(const optional<T>&, const U&); 
+  template <class T, class U> constexpr bool operator<=(const T&, const optional<U>&); 
+  template <class T, class U> constexpr bool operator>(const optional<T>&, const U&); 
+  template <class T, class U> constexpr bool operator>(const T&, const optional<U>&); 
+  template <class T, class U> constexpr bool operator>=(const optional<T>&, const U&); 
+  template <class T, class U> constexpr bool operator>=(const T&, const optional<U>&); 
+ 
+  // 23.6.9, specialized algorithms 
+  template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below ); // constexpr in C++20 
+  template <class T> constexpr optional<see below > make_optional(T&&); 
+  template <class T, class... Args> 
+    constexpr optional<T> make_optional(Args&&... args); 
+  template <class T, class U, class... Args> 
+    constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args); 
+ 
+  // 23.6.10, hash support 
+  template <class T> struct hash; 
+  template <class T> struct hash<optional<T>>; 
+ 
+  template <class T> class optional { 
+  public: 
+    using value_type = T; 
+ 
+    // 23.6.3.1, constructors 
+    constexpr optional() noexcept; 
+    constexpr optional(nullopt_t) noexcept; 
+    optional(const optional &); 
+    optional(optional &&) noexcept(see below); 
+    template <class... Args> constexpr explicit optional(in_place_t, Args &&...); 
+    template <class U, class... Args> 
+      constexpr explicit optional(in_place_t, initializer_list<U>, Args &&...); 
+    template <class U = T> 
+      constexpr EXPLICIT optional(U &&); 
+    template <class U> 
+      EXPLICIT optional(const optional<U> &);   // constexpr in C++20 
+    template <class U> 
+      EXPLICIT optional(optional<U> &&);        // constexpr in C++20 
+ 
+    // 23.6.3.2, destructor 
+    ~optional(); // constexpr in C++20 
+ 
+    // 23.6.3.3, assignment 
+    optional &operator=(nullopt_t) noexcept;                     // constexpr in C++20 
+    optional &operator=(const optional &);                       // constexpr in C++20 
+    optional &operator=(optional &&) noexcept(see below);        // constexpr in C++20 
+    template <class U = T> optional &operator=(U &&);            // constexpr in C++20 
+    template <class U> optional &operator=(const optional<U> &); // constexpr in C++20 
+    template <class U> optional &operator=(optional<U> &&);      // constexpr in C++20 
+    template <class... Args> T& emplace(Args &&...);             // constexpr in C++20 
+    template <class U, class... Args> 
+      T& emplace(initializer_list<U>, Args &&...);               // constexpr in C++20 
+ 
+    // 23.6.3.4, swap 
+    void swap(optional &) noexcept(see below ); // constexpr in C++20 
+ 
+    // 23.6.3.5, observers 
+    constexpr T const *operator->() const; 
+    constexpr T *operator->(); 
+    constexpr T const &operator*() const &; 
+    constexpr T &operator*() &; 
+    constexpr T &&operator*() &&; 
+    constexpr const T &&operator*() const &&; 
+    constexpr explicit operator bool() const noexcept; 
+    constexpr bool has_value() const noexcept; 
+    constexpr T const &value() const &; 
+    constexpr T &value() &; 
+    constexpr T &&value() &&; 
+    constexpr const T &&value() const &&; 
+    template <class U> constexpr T value_or(U &&) const &; 
+    template <class U> constexpr T value_or(U &&) &&; 
+ 
+    // 23.6.3.6, modifiers 
+    void reset() noexcept; // constexpr in C++20 
+ 
+  private: 
+    T *val; // exposition only 
+  }; 
+ 
+template<class T> 
+  optional(T) -> optional<T>; 
+ 
+} // namespace std 
+ 
+*/ 
+ 
+#include <__availability> 
+#include <__config> 
+#include <__debug> 
+#include <__functional_base> 
+#include <compare> 
+#include <functional> 
+#include <initializer_list> 
+#include <new> 
+#include <stdexcept> 
+#include <type_traits> 
+#include <utility> 
 #include <version>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#pragma GCC system_header
-#endif
-
-namespace std  // purposefully not using versioning namespace
-{
-
+ 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 
+#pragma GCC system_header 
+#endif 
+ 
+namespace std  // purposefully not using versioning namespace 
+{ 
+ 
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access
-    : public exception
-{
-public:
-    // Get the key function ~bad_optional_access() into the dylib
-    virtual ~bad_optional_access() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
-};
-
-}  // std
-
-#if _LIBCPP_STD_VER > 14
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-_LIBCPP_NORETURN
-inline _LIBCPP_INLINE_VISIBILITY
+    : public exception 
+{ 
+public: 
+    // Get the key function ~bad_optional_access() into the dylib 
+    virtual ~bad_optional_access() _NOEXCEPT; 
+    virtual const char* what() const _NOEXCEPT; 
+}; 
+ 
+}  // std 
+ 
+#if _LIBCPP_STD_VER > 14 
+ 
+_LIBCPP_BEGIN_NAMESPACE_STD 
+ 
+_LIBCPP_NORETURN 
+inline _LIBCPP_INLINE_VISIBILITY 
 _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-void __throw_bad_optional_access() {
-#ifndef _LIBCPP_NO_EXCEPTIONS
-        throw bad_optional_access();
-#else
-        _VSTD::abort();
-#endif
-}
-
-struct nullopt_t
-{
-    struct __secret_tag { _LIBCPP_INLINE_VISIBILITY explicit __secret_tag() = default; };
-    _LIBCPP_INLINE_VISIBILITY constexpr explicit nullopt_t(__secret_tag, __secret_tag) noexcept {}
-};
-
-inline constexpr nullopt_t nullopt{nullopt_t::__secret_tag{}, nullopt_t::__secret_tag{}};
-
-template <class _Tp, bool = is_trivially_destructible<_Tp>::value>
-struct __optional_destruct_base;
-
-template <class _Tp>
-struct __optional_destruct_base<_Tp, false>
-{
-    typedef _Tp value_type;
-    static_assert(is_object_v<value_type>,
-        "instantiation of optional with a non-object type is undefined behavior");
-    union
-    {
-        char __null_state_;
-        value_type __val_;
-    };
-    bool __engaged_;
-
-    _LIBCPP_INLINE_VISIBILITY
-    /* _LIBCPP_CONSTEXPR_AFTER_CXX17 */ ~__optional_destruct_base()
-    {
-        if (__engaged_)
-            __val_.~value_type();
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr __optional_destruct_base() noexcept
-        :  __null_state_(),
-           __engaged_(false) {}
-
-    template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
-        :  __val_(_VSTD::forward<_Args>(__args)...),
-           __engaged_(true) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 void reset() noexcept
-    {
-        if (__engaged_)
-        {
-            __val_.~value_type();
-            __engaged_ = false;
-        }
-    }
-};
-
-template <class _Tp>
-struct __optional_destruct_base<_Tp, true>
-{
-    typedef _Tp value_type;
-    static_assert(is_object_v<value_type>,
-        "instantiation of optional with a non-object type is undefined behavior");
-    union
-    {
-        char __null_state_;
-        value_type __val_;
-    };
-    bool __engaged_;
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr __optional_destruct_base() noexcept
-        :  __null_state_(),
-           __engaged_(false) {}
-
-    template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
-        :  __val_(_VSTD::forward<_Args>(__args)...),
-           __engaged_(true) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 void reset() noexcept
-    {
-        if (__engaged_)
-        {
-            __engaged_ = false;
-        }
-    }
-};
-
-template <class _Tp, bool = is_reference<_Tp>::value>
-struct __optional_storage_base : __optional_destruct_base<_Tp>
-{
-    using __base = __optional_destruct_base<_Tp>;
-    using value_type = _Tp;
-    using __base::__base;
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr bool has_value() const noexcept
-    {
-        return this->__engaged_;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr value_type& __get() & noexcept
-    {
-        return this->__val_;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr const value_type& __get() const& noexcept
-    {
-        return this->__val_;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr value_type&& __get() && noexcept
-    {
-        return _VSTD::move(this->__val_);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr const value_type&& __get() const&& noexcept
-    {
-        return _VSTD::move(this->__val_);
-    }
-
-    template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct(_Args&&... __args)
-    {
-        _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage");
-#if _LIBCPP_STD_VER > 17
-        _VSTD::construct_at(_VSTD::addressof(this->__val_), _VSTD::forward<_Args>(__args)...);
-#else
+void __throw_bad_optional_access() { 
+#ifndef _LIBCPP_NO_EXCEPTIONS 
+        throw bad_optional_access(); 
+#else 
+        _VSTD::abort(); 
+#endif 
+} 
+ 
+struct nullopt_t 
+{ 
+    struct __secret_tag { _LIBCPP_INLINE_VISIBILITY explicit __secret_tag() = default; }; 
+    _LIBCPP_INLINE_VISIBILITY constexpr explicit nullopt_t(__secret_tag, __secret_tag) noexcept {} 
+}; 
+ 
+inline constexpr nullopt_t nullopt{nullopt_t::__secret_tag{}, nullopt_t::__secret_tag{}}; 
+ 
+template <class _Tp, bool = is_trivially_destructible<_Tp>::value> 
+struct __optional_destruct_base; 
+ 
+template <class _Tp> 
+struct __optional_destruct_base<_Tp, false> 
+{ 
+    typedef _Tp value_type; 
+    static_assert(is_object_v<value_type>, 
+        "instantiation of optional with a non-object type is undefined behavior"); 
+    union 
+    { 
+        char __null_state_; 
+        value_type __val_; 
+    }; 
+    bool __engaged_; 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    /* _LIBCPP_CONSTEXPR_AFTER_CXX17 */ ~__optional_destruct_base() 
+    { 
+        if (__engaged_) 
+            __val_.~value_type(); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr __optional_destruct_base() noexcept 
+        :  __null_state_(), 
+           __engaged_(false) {} 
+ 
+    template <class... _Args> 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args) 
+        :  __val_(_VSTD::forward<_Args>(__args)...), 
+           __engaged_(true) {} 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void reset() noexcept 
+    { 
+        if (__engaged_) 
+        { 
+            __val_.~value_type(); 
+            __engaged_ = false; 
+        } 
+    } 
+}; 
+ 
+template <class _Tp> 
+struct __optional_destruct_base<_Tp, true> 
+{ 
+    typedef _Tp value_type; 
+    static_assert(is_object_v<value_type>, 
+        "instantiation of optional with a non-object type is undefined behavior"); 
+    union 
+    { 
+        char __null_state_; 
+        value_type __val_; 
+    }; 
+    bool __engaged_; 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr __optional_destruct_base() noexcept 
+        :  __null_state_(), 
+           __engaged_(false) {} 
+ 
+    template <class... _Args> 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args) 
+        :  __val_(_VSTD::forward<_Args>(__args)...), 
+           __engaged_(true) {} 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void reset() noexcept 
+    { 
+        if (__engaged_) 
+        { 
+            __engaged_ = false; 
+        } 
+    } 
+}; 
+ 
+template <class _Tp, bool = is_reference<_Tp>::value> 
+struct __optional_storage_base : __optional_destruct_base<_Tp> 
+{ 
+    using __base = __optional_destruct_base<_Tp>; 
+    using value_type = _Tp; 
+    using __base::__base; 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr bool has_value() const noexcept 
+    { 
+        return this->__engaged_; 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr value_type& __get() & noexcept 
+    { 
+        return this->__val_; 
+    } 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr const value_type& __get() const& noexcept 
+    { 
+        return this->__val_; 
+    } 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr value_type&& __get() && noexcept 
+    { 
+        return _VSTD::move(this->__val_); 
+    } 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr const value_type&& __get() const&& noexcept 
+    { 
+        return _VSTD::move(this->__val_); 
+    } 
+ 
+    template <class... _Args> 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct(_Args&&... __args) 
+    { 
+        _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage"); 
+#if _LIBCPP_STD_VER > 17 
+        _VSTD::construct_at(_VSTD::addressof(this->__val_), _VSTD::forward<_Args>(__args)...); 
+#else 
         ::new ((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...);
-#endif
-        this->__engaged_ = true;
-    }
-
-    template <class _That>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_from(_That&& __opt)
-    {
-        if (__opt.has_value())
-            __construct(_VSTD::forward<_That>(__opt).__get());
-    }
-
-    template <class _That>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __assign_from(_That&& __opt)
-    {
-        if (this->__engaged_ == __opt.has_value())
-        {
-            if (this->__engaged_)
-                this->__val_ = _VSTD::forward<_That>(__opt).__get();
-        }
-        else
-        {
-            if (this->__engaged_)
-                this->reset();
-            else
-                __construct(_VSTD::forward<_That>(__opt).__get());
-        }
-    }
-};
-
-// optional<T&> is currently required ill-formed, however it may to be in the
-// future. For this reason it has already been implemented to ensure we can
-// make the change in an ABI compatible manner.
-template <class _Tp>
-struct __optional_storage_base<_Tp, true>
-{
-    using value_type = _Tp;
-    using __raw_type = remove_reference_t<_Tp>;
-    __raw_type* __value_;
-
-    template <class _Up>
-    static constexpr bool __can_bind_reference() {
-        using _RawUp = typename remove_reference<_Up>::type;
-        using _UpPtr = _RawUp*;
-        using _RawTp = typename remove_reference<_Tp>::type;
-        using _TpPtr = _RawTp*;
-        using _CheckLValueArg = integral_constant<bool,
-            (is_lvalue_reference<_Up>::value && is_convertible<_UpPtr, _TpPtr>::value)
-        ||  is_same<_RawUp, reference_wrapper<_RawTp>>::value
-        ||  is_same<_RawUp, reference_wrapper<typename remove_const<_RawTp>::type>>::value
-        >;
-        return (is_lvalue_reference<_Tp>::value && _CheckLValueArg::value)
-            || (is_rvalue_reference<_Tp>::value && !is_lvalue_reference<_Up>::value &&
-                is_convertible<_UpPtr, _TpPtr>::value);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr __optional_storage_base() noexcept
-        :  __value_(nullptr) {}
-
-    template <class _UArg>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg)
-        :  __value_(_VSTD::addressof(__uarg))
-    {
-      static_assert(__can_bind_reference<_UArg>(),
-        "Attempted to construct a reference element in tuple from a "
-        "possible temporary");
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 void reset() noexcept { __value_ = nullptr; }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr bool has_value() const noexcept
-      { return __value_ != nullptr; }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr value_type& __get() const& noexcept
-      { return *__value_; }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr value_type&& __get() const&& noexcept
-      { return _VSTD::forward<value_type>(*__value_); }
-
-    template <class _UArg>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct(_UArg&& __val)
-    {
-        _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage");
-        static_assert(__can_bind_reference<_UArg>(),
-            "Attempted to construct a reference element in tuple from a "
-            "possible temporary");
-        __value_ = _VSTD::addressof(__val);
-    }
-
-    template <class _That>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_from(_That&& __opt)
-    {
-        if (__opt.has_value())
-            __construct(_VSTD::forward<_That>(__opt).__get());
-    }
-
-    template <class _That>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __assign_from(_That&& __opt)
-    {
-        if (has_value() == __opt.has_value())
-        {
-            if (has_value())
-                *__value_ = _VSTD::forward<_That>(__opt).__get();
-        }
-        else
-        {
-            if (has_value())
-                reset();
-            else
-                __construct(_VSTD::forward<_That>(__opt).__get());
-        }
-    }
-};
-
-template <class _Tp, bool = is_trivially_copy_constructible<_Tp>::value>
-struct __optional_copy_base : __optional_storage_base<_Tp>
-{
-    using __optional_storage_base<_Tp>::__optional_storage_base;
-};
-
-template <class _Tp>
-struct __optional_copy_base<_Tp, false> : __optional_storage_base<_Tp>
-{
-    using __optional_storage_base<_Tp>::__optional_storage_base;
-
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_base() = default;
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_copy_base(const __optional_copy_base& __opt)
-    {
-        this->__construct_from(__opt);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_base(__optional_copy_base&&) = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_base& operator=(const __optional_copy_base&) = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_base& operator=(__optional_copy_base&&) = default;
-};
-
-template <class _Tp, bool = is_trivially_move_constructible<_Tp>::value>
-struct __optional_move_base : __optional_copy_base<_Tp>
-{
-    using __optional_copy_base<_Tp>::__optional_copy_base;
-};
-
-template <class _Tp>
-struct __optional_move_base<_Tp, false> : __optional_copy_base<_Tp>
-{
-    using value_type = _Tp;
-    using __optional_copy_base<_Tp>::__optional_copy_base;
-
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_move_base() = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_move_base(const __optional_move_base&) = default;
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_move_base(__optional_move_base&& __opt)
-        noexcept(is_nothrow_move_constructible_v<value_type>)
-    {
-        this->__construct_from(_VSTD::move(__opt));
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_move_base& operator=(const __optional_move_base&) = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_move_base& operator=(__optional_move_base&&) = default;
-};
-
-template <class _Tp, bool =
-    is_trivially_destructible<_Tp>::value &&
-    is_trivially_copy_constructible<_Tp>::value &&
-    is_trivially_copy_assignable<_Tp>::value>
-struct __optional_copy_assign_base : __optional_move_base<_Tp>
-{
-    using __optional_move_base<_Tp>::__optional_move_base;
-};
-
-template <class _Tp>
-struct __optional_copy_assign_base<_Tp, false> : __optional_move_base<_Tp>
-{
-    using __optional_move_base<_Tp>::__optional_move_base;
-
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_assign_base() = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_assign_base(const __optional_copy_assign_base&) = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_assign_base(__optional_copy_assign_base&&) = default;
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_copy_assign_base& operator=(const __optional_copy_assign_base& __opt)
-    {
-        this->__assign_from(__opt);
-        return *this;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_assign_base& operator=(__optional_copy_assign_base&&) = default;
-};
-
-template <class _Tp, bool =
-    is_trivially_destructible<_Tp>::value &&
-    is_trivially_move_constructible<_Tp>::value &&
-    is_trivially_move_assignable<_Tp>::value>
-struct __optional_move_assign_base : __optional_copy_assign_base<_Tp>
-{
-    using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
-};
-
-template <class _Tp>
-struct __optional_move_assign_base<_Tp, false> : __optional_copy_assign_base<_Tp>
-{
-    using value_type = _Tp;
-    using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
-
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_move_assign_base() = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_move_assign_base(const __optional_move_assign_base& __opt) = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_move_assign_base(__optional_move_assign_base&&) = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_move_assign_base& operator=(const __optional_move_assign_base&) = default;
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_move_assign_base& operator=(__optional_move_assign_base&& __opt)
-        noexcept(is_nothrow_move_assignable_v<value_type> &&
-                 is_nothrow_move_constructible_v<value_type>)
-    {
-        this->__assign_from(_VSTD::move(__opt));
-        return *this;
-    }
-};
-
-template <class _Tp>
-using __optional_sfinae_ctor_base_t = __sfinae_ctor_base<
-    is_copy_constructible<_Tp>::value,
-    is_move_constructible<_Tp>::value
->;
-
-template <class _Tp>
-using __optional_sfinae_assign_base_t = __sfinae_assign_base<
-    (is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value),
-    (is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value)
->;
-
-template <class _Tp>
-class optional
-    : private __optional_move_assign_base<_Tp>
-    , private __optional_sfinae_ctor_base_t<_Tp>
-    , private __optional_sfinae_assign_base_t<_Tp>
-{
-    using __base = __optional_move_assign_base<_Tp>;
-public:
-    using value_type = _Tp;
-
-private:
-     // Disable the reference extension using this static assert.
-    static_assert(!is_same_v<__uncvref_t<value_type>, in_place_t>,
-        "instantiation of optional with in_place_t is ill-formed");
-    static_assert(!is_same_v<__uncvref_t<value_type>, nullopt_t>,
-        "instantiation of optional with nullopt_t is ill-formed");
-    static_assert(!is_reference_v<value_type>,
-        "instantiation of optional with a reference type is ill-formed");
-    static_assert(is_destructible_v<value_type>,
-        "instantiation of optional with a non-destructible type is ill-formed");
-    static_assert(!is_array_v<value_type>,
-        "instantiation of optional with an array type is ill-formed");
-
-    // LWG2756: conditionally explicit conversion from _Up
-    struct _CheckOptionalArgsConstructor {
-      template <class _Up>
+#endif 
+        this->__engaged_ = true; 
+    } 
+ 
+    template <class _That> 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_from(_That&& __opt) 
+    { 
+        if (__opt.has_value()) 
+            __construct(_VSTD::forward<_That>(__opt).__get()); 
+    } 
+ 
+    template <class _That> 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __assign_from(_That&& __opt) 
+    { 
+        if (this->__engaged_ == __opt.has_value()) 
+        { 
+            if (this->__engaged_) 
+                this->__val_ = _VSTD::forward<_That>(__opt).__get(); 
+        } 
+        else 
+        { 
+            if (this->__engaged_) 
+                this->reset(); 
+            else 
+                __construct(_VSTD::forward<_That>(__opt).__get()); 
+        } 
+    } 
+}; 
+ 
+// optional<T&> is currently required ill-formed, however it may to be in the 
+// future. For this reason it has already been implemented to ensure we can 
+// make the change in an ABI compatible manner. 
+template <class _Tp> 
+struct __optional_storage_base<_Tp, true> 
+{ 
+    using value_type = _Tp; 
+    using __raw_type = remove_reference_t<_Tp>; 
+    __raw_type* __value_; 
+ 
+    template <class _Up> 
+    static constexpr bool __can_bind_reference() { 
+        using _RawUp = typename remove_reference<_Up>::type; 
+        using _UpPtr = _RawUp*; 
+        using _RawTp = typename remove_reference<_Tp>::type; 
+        using _TpPtr = _RawTp*; 
+        using _CheckLValueArg = integral_constant<bool, 
+            (is_lvalue_reference<_Up>::value && is_convertible<_UpPtr, _TpPtr>::value) 
+        ||  is_same<_RawUp, reference_wrapper<_RawTp>>::value 
+        ||  is_same<_RawUp, reference_wrapper<typename remove_const<_RawTp>::type>>::value 
+        >; 
+        return (is_lvalue_reference<_Tp>::value && _CheckLValueArg::value) 
+            || (is_rvalue_reference<_Tp>::value && !is_lvalue_reference<_Up>::value && 
+                is_convertible<_UpPtr, _TpPtr>::value); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr __optional_storage_base() noexcept 
+        :  __value_(nullptr) {} 
+ 
+    template <class _UArg> 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg) 
+        :  __value_(_VSTD::addressof(__uarg)) 
+    { 
+      static_assert(__can_bind_reference<_UArg>(), 
+        "Attempted to construct a reference element in tuple from a " 
+        "possible temporary"); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void reset() noexcept { __value_ = nullptr; } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr bool has_value() const noexcept 
+      { return __value_ != nullptr; } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr value_type& __get() const& noexcept 
+      { return *__value_; } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr value_type&& __get() const&& noexcept 
+      { return _VSTD::forward<value_type>(*__value_); } 
+ 
+    template <class _UArg> 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct(_UArg&& __val) 
+    { 
+        _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage"); 
+        static_assert(__can_bind_reference<_UArg>(), 
+            "Attempted to construct a reference element in tuple from a " 
+            "possible temporary"); 
+        __value_ = _VSTD::addressof(__val); 
+    } 
+ 
+    template <class _That> 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __construct_from(_That&& __opt) 
+    { 
+        if (__opt.has_value()) 
+            __construct(_VSTD::forward<_That>(__opt).__get()); 
+    } 
+ 
+    template <class _That> 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void __assign_from(_That&& __opt) 
+    { 
+        if (has_value() == __opt.has_value()) 
+        { 
+            if (has_value()) 
+                *__value_ = _VSTD::forward<_That>(__opt).__get(); 
+        } 
+        else 
+        { 
+            if (has_value()) 
+                reset(); 
+            else 
+                __construct(_VSTD::forward<_That>(__opt).__get()); 
+        } 
+    } 
+}; 
+ 
+template <class _Tp, bool = is_trivially_copy_constructible<_Tp>::value> 
+struct __optional_copy_base : __optional_storage_base<_Tp> 
+{ 
+    using __optional_storage_base<_Tp>::__optional_storage_base; 
+}; 
+ 
+template <class _Tp> 
+struct __optional_copy_base<_Tp, false> : __optional_storage_base<_Tp> 
+{ 
+    using __optional_storage_base<_Tp>::__optional_storage_base; 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    __optional_copy_base() = default; 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_copy_base(const __optional_copy_base& __opt) 
+    { 
+        this->__construct_from(__opt); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    __optional_copy_base(__optional_copy_base&&) = default; 
+    _LIBCPP_INLINE_VISIBILITY 
+    __optional_copy_base& operator=(const __optional_copy_base&) = default; 
+    _LIBCPP_INLINE_VISIBILITY 
+    __optional_copy_base& operator=(__optional_copy_base&&) = default; 
+}; 
+ 
+template <class _Tp, bool = is_trivially_move_constructible<_Tp>::value> 
+struct __optional_move_base : __optional_copy_base<_Tp> 
+{ 
+    using __optional_copy_base<_Tp>::__optional_copy_base; 
+}; 
+ 
+template <class _Tp> 
+struct __optional_move_base<_Tp, false> : __optional_copy_base<_Tp> 
+{ 
+    using value_type = _Tp; 
+    using __optional_copy_base<_Tp>::__optional_copy_base; 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    __optional_move_base() = default; 
+    _LIBCPP_INLINE_VISIBILITY 
+    __optional_move_base(const __optional_move_base&) = default; 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_move_base(__optional_move_base&& __opt) 
+        noexcept(is_nothrow_move_constructible_v<value_type>) 
+    { 
+        this->__construct_from(_VSTD::move(__opt)); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    __optional_move_base& operator=(const __optional_move_base&) = default; 
+    _LIBCPP_INLINE_VISIBILITY 
+    __optional_move_base& operator=(__optional_move_base&&) = default; 
+}; 
+ 
+template <class _Tp, bool = 
+    is_trivially_destructible<_Tp>::value && 
+    is_trivially_copy_constructible<_Tp>::value && 
+    is_trivially_copy_assignable<_Tp>::value> 
+struct __optional_copy_assign_base : __optional_move_base<_Tp> 
+{ 
+    using __optional_move_base<_Tp>::__optional_move_base; 
+}; 
+ 
+template <class _Tp> 
+struct __optional_copy_assign_base<_Tp, false> : __optional_move_base<_Tp> 
+{ 
+    using __optional_move_base<_Tp>::__optional_move_base; 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    __optional_copy_assign_base() = default; 
+    _LIBCPP_INLINE_VISIBILITY 
+    __optional_copy_assign_base(const __optional_copy_assign_base&) = default; 
+    _LIBCPP_INLINE_VISIBILITY 
+    __optional_copy_assign_base(__optional_copy_assign_base&&) = default; 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_copy_assign_base& operator=(const __optional_copy_assign_base& __opt) 
+    { 
+        this->__assign_from(__opt); 
+        return *this; 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    __optional_copy_assign_base& operator=(__optional_copy_assign_base&&) = default; 
+}; 
+ 
+template <class _Tp, bool = 
+    is_trivially_destructible<_Tp>::value && 
+    is_trivially_move_constructible<_Tp>::value && 
+    is_trivially_move_assignable<_Tp>::value> 
+struct __optional_move_assign_base : __optional_copy_assign_base<_Tp> 
+{ 
+    using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base; 
+}; 
+ 
+template <class _Tp> 
+struct __optional_move_assign_base<_Tp, false> : __optional_copy_assign_base<_Tp> 
+{ 
+    using value_type = _Tp; 
+    using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base; 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    __optional_move_assign_base() = default; 
+    _LIBCPP_INLINE_VISIBILITY 
+    __optional_move_assign_base(const __optional_move_assign_base& __opt) = default; 
+    _LIBCPP_INLINE_VISIBILITY 
+    __optional_move_assign_base(__optional_move_assign_base&&) = default; 
+    _LIBCPP_INLINE_VISIBILITY 
+    __optional_move_assign_base& operator=(const __optional_move_assign_base&) = default; 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 __optional_move_assign_base& operator=(__optional_move_assign_base&& __opt) 
+        noexcept(is_nothrow_move_assignable_v<value_type> && 
+                 is_nothrow_move_constructible_v<value_type>) 
+    { 
+        this->__assign_from(_VSTD::move(__opt)); 
+        return *this; 
+    } 
+}; 
+ 
+template <class _Tp> 
+using __optional_sfinae_ctor_base_t = __sfinae_ctor_base< 
+    is_copy_constructible<_Tp>::value, 
+    is_move_constructible<_Tp>::value 
+>; 
+ 
+template <class _Tp> 
+using __optional_sfinae_assign_base_t = __sfinae_assign_base< 
+    (is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value), 
+    (is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value) 
+>; 
+ 
+template <class _Tp> 
+class optional 
+    : private __optional_move_assign_base<_Tp> 
+    , private __optional_sfinae_ctor_base_t<_Tp> 
+    , private __optional_sfinae_assign_base_t<_Tp> 
+{ 
+    using __base = __optional_move_assign_base<_Tp>; 
+public: 
+    using value_type = _Tp; 
+ 
+private: 
+     // Disable the reference extension using this static assert. 
+    static_assert(!is_same_v<__uncvref_t<value_type>, in_place_t>, 
+        "instantiation of optional with in_place_t is ill-formed"); 
+    static_assert(!is_same_v<__uncvref_t<value_type>, nullopt_t>, 
+        "instantiation of optional with nullopt_t is ill-formed"); 
+    static_assert(!is_reference_v<value_type>, 
+        "instantiation of optional with a reference type is ill-formed"); 
+    static_assert(is_destructible_v<value_type>, 
+        "instantiation of optional with a non-destructible type is ill-formed"); 
+    static_assert(!is_array_v<value_type>, 
+        "instantiation of optional with an array type is ill-formed"); 
+ 
+    // LWG2756: conditionally explicit conversion from _Up 
+    struct _CheckOptionalArgsConstructor { 
+      template <class _Up> 
       static constexpr bool __enable_implicit =
           is_constructible_v<_Tp, _Up&&> &&
           is_convertible_v<_Up&&, _Tp>;
-
-      template <class _Up>
+ 
+      template <class _Up> 
       static constexpr bool __enable_explicit =
           is_constructible_v<_Tp, _Up&&> &&
           !is_convertible_v<_Up&&, _Tp>;
-    };
-    template <class _Up>
-    using _CheckOptionalArgsCtor = _If<
-        _IsNotSame<__uncvref_t<_Up>, in_place_t>::value &&
-        _IsNotSame<__uncvref_t<_Up>, optional>::value,
-        _CheckOptionalArgsConstructor,
-        __check_tuple_constructor_fail
-    >;
-    template <class _QualUp>
-    struct _CheckOptionalLikeConstructor {
-      template <class _Up, class _Opt = optional<_Up>>
-      using __check_constructible_from_opt = _Or<
-          is_constructible<_Tp, _Opt&>,
-          is_constructible<_Tp, _Opt const&>,
-          is_constructible<_Tp, _Opt&&>,
-          is_constructible<_Tp, _Opt const&&>,
-          is_convertible<_Opt&, _Tp>,
-          is_convertible<_Opt const&, _Tp>,
-          is_convertible<_Opt&&, _Tp>,
-          is_convertible<_Opt const&&, _Tp>
-      >;
-      template <class _Up, class _Opt = optional<_Up>>
-      using __check_assignable_from_opt = _Or<
-          is_assignable<_Tp&, _Opt&>,
-          is_assignable<_Tp&, _Opt const&>,
-          is_assignable<_Tp&, _Opt&&>,
-          is_assignable<_Tp&, _Opt const&&>
-      >;
-      template <class _Up, class _QUp = _QualUp>
+    }; 
+    template <class _Up> 
+    using _CheckOptionalArgsCtor = _If< 
+        _IsNotSame<__uncvref_t<_Up>, in_place_t>::value && 
+        _IsNotSame<__uncvref_t<_Up>, optional>::value, 
+        _CheckOptionalArgsConstructor, 
+        __check_tuple_constructor_fail 
+    >; 
+    template <class _QualUp> 
+    struct _CheckOptionalLikeConstructor { 
+      template <class _Up, class _Opt = optional<_Up>> 
+      using __check_constructible_from_opt = _Or< 
+          is_constructible<_Tp, _Opt&>, 
+          is_constructible<_Tp, _Opt const&>, 
+          is_constructible<_Tp, _Opt&&>, 
+          is_constructible<_Tp, _Opt const&&>, 
+          is_convertible<_Opt&, _Tp>, 
+          is_convertible<_Opt const&, _Tp>, 
+          is_convertible<_Opt&&, _Tp>, 
+          is_convertible<_Opt const&&, _Tp> 
+      >; 
+      template <class _Up, class _Opt = optional<_Up>> 
+      using __check_assignable_from_opt = _Or< 
+          is_assignable<_Tp&, _Opt&>, 
+          is_assignable<_Tp&, _Opt const&>, 
+          is_assignable<_Tp&, _Opt&&>, 
+          is_assignable<_Tp&, _Opt const&&> 
+      >; 
+      template <class _Up, class _QUp = _QualUp> 
       static constexpr bool __enable_implicit =
           is_convertible<_QUp, _Tp>::value &&
           !__check_constructible_from_opt<_Up>::value;
 
-      template <class _Up, class _QUp = _QualUp>
+      template <class _Up, class _QUp = _QualUp> 
       static constexpr bool __enable_explicit =
           !is_convertible<_QUp, _Tp>::value &&
           !__check_constructible_from_opt<_Up>::value;
 
-      template <class _Up, class _QUp = _QualUp>
+      template <class _Up, class _QUp = _QualUp> 
       static constexpr bool __enable_assign =
           !__check_constructible_from_opt<_Up>::value &&
           !__check_assignable_from_opt<_Up>::value;
-    };
-
-    template <class _Up, class _QualUp>
-    using _CheckOptionalLikeCtor = _If<
-      _And<
-         _IsNotSame<_Up, _Tp>,
-          is_constructible<_Tp, _QualUp>
-      >::value,
-      _CheckOptionalLikeConstructor<_QualUp>,
-      __check_tuple_constructor_fail
-    >;
-    template <class _Up, class _QualUp>
-    using _CheckOptionalLikeAssign = _If<
-      _And<
-          _IsNotSame<_Up, _Tp>,
-          is_constructible<_Tp, _QualUp>,
-          is_assignable<_Tp&, _QualUp>
-      >::value,
-      _CheckOptionalLikeConstructor<_QualUp>,
-      __check_tuple_constructor_fail
-    >;
-public:
-
-    _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {}
-    _LIBCPP_INLINE_VISIBILITY constexpr optional(const optional&) = default;
-    _LIBCPP_INLINE_VISIBILITY constexpr optional(optional&&) = default;
-    _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {}
-
-    template <class _InPlaceT, class... _Args, class = enable_if_t<
-          _And<
-              _IsSame<_InPlaceT, in_place_t>,
-            is_constructible<value_type, _Args...>
-            >::value
-        >
-    >
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit optional(_InPlaceT, _Args&&... __args)
-        : __base(in_place, _VSTD::forward<_Args>(__args)...) {}
-
-    template <class _Up, class... _Args, class = enable_if_t<
-        is_constructible_v<value_type, initializer_list<_Up>&, _Args...>>
-    >
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
-        : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {}
-
-    template <class _Up = value_type, enable_if_t<
+    }; 
+ 
+    template <class _Up, class _QualUp> 
+    using _CheckOptionalLikeCtor = _If< 
+      _And< 
+         _IsNotSame<_Up, _Tp>, 
+          is_constructible<_Tp, _QualUp> 
+      >::value, 
+      _CheckOptionalLikeConstructor<_QualUp>, 
+      __check_tuple_constructor_fail 
+    >; 
+    template <class _Up, class _QualUp> 
+    using _CheckOptionalLikeAssign = _If< 
+      _And< 
+          _IsNotSame<_Up, _Tp>, 
+          is_constructible<_Tp, _QualUp>, 
+          is_assignable<_Tp&, _QualUp> 
+      >::value, 
+      _CheckOptionalLikeConstructor<_QualUp>, 
+      __check_tuple_constructor_fail 
+    >; 
+public: 
+ 
+    _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {} 
+    _LIBCPP_INLINE_VISIBILITY constexpr optional(const optional&) = default; 
+    _LIBCPP_INLINE_VISIBILITY constexpr optional(optional&&) = default; 
+    _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {} 
+ 
+    template <class _InPlaceT, class... _Args, class = enable_if_t< 
+          _And< 
+              _IsSame<_InPlaceT, in_place_t>, 
+            is_constructible<value_type, _Args...> 
+            >::value 
+        > 
+    > 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr explicit optional(_InPlaceT, _Args&&... __args) 
+        : __base(in_place, _VSTD::forward<_Args>(__args)...) {} 
+ 
+    template <class _Up, class... _Args, class = enable_if_t< 
+        is_constructible_v<value_type, initializer_list<_Up>&, _Args...>> 
+    > 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args) 
+        : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {} 
+ 
+    template <class _Up = value_type, enable_if_t< 
         _CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr optional(_Up&& __v)
-        : __base(in_place, _VSTD::forward<_Up>(__v)) {}
-
-    template <class _Up, enable_if_t<
+    , int> = 0> 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr optional(_Up&& __v) 
+        : __base(in_place, _VSTD::forward<_Up>(__v)) {} 
+ 
+    template <class _Up, enable_if_t< 
         _CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit optional(_Up&& __v)
-        : __base(in_place, _VSTD::forward<_Up>(__v)) {}
-
-    // LWG2756: conditionally explicit conversion from const optional<_Up>&
-    template <class _Up, enable_if_t<
+    , int> = 0> 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr explicit optional(_Up&& __v) 
+        : __base(in_place, _VSTD::forward<_Up>(__v)) {} 
+ 
+    // LWG2756: conditionally explicit conversion from const optional<_Up>& 
+    template <class _Up, enable_if_t< 
         _CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional(const optional<_Up>& __v)
-    {
-        this->__construct_from(__v);
-    }
-    template <class _Up, enable_if_t<
+    , int> = 0> 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional(const optional<_Up>& __v) 
+    { 
+        this->__construct_from(__v); 
+    } 
+    template <class _Up, enable_if_t< 
         _CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit optional(const optional<_Up>& __v)
-    {
-        this->__construct_from(__v);
-    }
-
-    // LWG2756: conditionally explicit conversion from optional<_Up>&&
-    template <class _Up, enable_if_t<
+    , int> = 0> 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit optional(const optional<_Up>& __v) 
+    { 
+        this->__construct_from(__v); 
+    } 
+ 
+    // LWG2756: conditionally explicit conversion from optional<_Up>&& 
+    template <class _Up, enable_if_t< 
         _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_implicit<_Up>
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional(optional<_Up>&& __v)
-    {
-        this->__construct_from(_VSTD::move(__v));
-    }
-    template <class _Up, enable_if_t<
+    , int> = 0> 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional(optional<_Up>&& __v) 
+    { 
+        this->__construct_from(_VSTD::move(__v)); 
+    } 
+    template <class _Up, enable_if_t< 
         _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_explicit<_Up>
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit optional(optional<_Up>&& __v)
-    {
-        this->__construct_from(_VSTD::move(__v));
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional& operator=(nullopt_t) noexcept
-    {
-        reset();
-        return *this;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY optional& operator=(const optional&) = default;
-    _LIBCPP_INLINE_VISIBILITY optional& operator=(optional&&) = default;
-
-    // LWG2756
-    template <class _Up = value_type,
-              class = enable_if_t<
-                      _And<
-                          _IsNotSame<__uncvref_t<_Up>, optional>,
-                          _Or<
-                              _IsNotSame<__uncvref_t<_Up>, value_type>,
-                              _Not<is_scalar<value_type>>
-                          >,
-                          is_constructible<value_type, _Up>,
-                          is_assignable<value_type&, _Up>
-                      >::value>
-             >
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional&
-    operator=(_Up&& __v)
-    {
-        if (this->has_value())
-            this->__get() = _VSTD::forward<_Up>(__v);
-        else
-            this->__construct(_VSTD::forward<_Up>(__v));
-        return *this;
-    }
-
-    // LWG2756
-    template <class _Up, enable_if_t<
+    , int> = 0> 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit optional(optional<_Up>&& __v) 
+    { 
+        this->__construct_from(_VSTD::move(__v)); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional& operator=(nullopt_t) noexcept 
+    { 
+        reset(); 
+        return *this; 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY optional& operator=(const optional&) = default; 
+    _LIBCPP_INLINE_VISIBILITY optional& operator=(optional&&) = default; 
+ 
+    // LWG2756 
+    template <class _Up = value_type, 
+              class = enable_if_t< 
+                      _And< 
+                          _IsNotSame<__uncvref_t<_Up>, optional>, 
+                          _Or< 
+                              _IsNotSame<__uncvref_t<_Up>, value_type>, 
+                              _Not<is_scalar<value_type>> 
+                          >, 
+                          is_constructible<value_type, _Up>, 
+                          is_assignable<value_type&, _Up> 
+                      >::value> 
+             > 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional& 
+    operator=(_Up&& __v) 
+    { 
+        if (this->has_value()) 
+            this->__get() = _VSTD::forward<_Up>(__v); 
+        else 
+            this->__construct(_VSTD::forward<_Up>(__v)); 
+        return *this; 
+    } 
+ 
+    // LWG2756 
+    template <class _Up, enable_if_t< 
         _CheckOptionalLikeAssign<_Up, _Up const&>::template __enable_assign<_Up>
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional&
-    operator=(const optional<_Up>& __v)
-    {
-        this->__assign_from(__v);
-        return *this;
-    }
-
-    // LWG2756
-    template <class _Up, enable_if_t<
+    , int> = 0> 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional& 
+    operator=(const optional<_Up>& __v) 
+    { 
+        this->__assign_from(__v); 
+        return *this; 
+    } 
+ 
+    // LWG2756 
+    template <class _Up, enable_if_t< 
         _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_assign<_Up>
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional&
-    operator=(optional<_Up>&& __v)
-    {
-        this->__assign_from(_VSTD::move(__v));
-        return *this;
-    }
-
-    template <class... _Args,
-              class = enable_if_t
-                      <
-                          is_constructible_v<value_type, _Args...>
-                      >
-             >
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp &
-    emplace(_Args&&... __args)
-    {
-        reset();
-        this->__construct(_VSTD::forward<_Args>(__args)...);
-        return this->__get();
-    }
-
-    template <class _Up, class... _Args,
-              class = enable_if_t
-                      <
-                          is_constructible_v<value_type, initializer_list<_Up>&, _Args...>
-                      >
-             >
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp &
-    emplace(initializer_list<_Up> __il, _Args&&... __args)
-    {
-        reset();
-        this->__construct(__il, _VSTD::forward<_Args>(__args)...);
-        return this->__get();
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_AFTER_CXX17 void swap(optional& __opt)
-        noexcept(is_nothrow_move_constructible_v<value_type> &&
-                 is_nothrow_swappable_v<value_type>)
-    {
-        if (this->has_value() == __opt.has_value())
-        {
-            using _VSTD::swap;
-            if (this->has_value())
-                swap(this->__get(), __opt.__get());
-        }
-        else
-        {
-            if (this->has_value())
-            {
-                __opt.__construct(_VSTD::move(this->__get()));
-                reset();
-            }
-            else
-            {
-                this->__construct(_VSTD::move(__opt.__get()));
-                __opt.reset();
-            }
-        }
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr
-    add_pointer_t<value_type const>
-    operator->() const
-    {
-        _LIBCPP_ASSERT(this->has_value(), "optional operator-> called on a disengaged value");
-        return _VSTD::addressof(this->__get());
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr
-    add_pointer_t<value_type>
-    operator->()
-    {
-        _LIBCPP_ASSERT(this->has_value(), "optional operator-> called on a disengaged value");
-        return _VSTD::addressof(this->__get());
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr
-    const value_type&
-    operator*() const& noexcept
-    {
-        _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
-        return this->__get();
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr
-    value_type&
-    operator*() & noexcept
-    {
-        _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
-        return this->__get();
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr
-    value_type&&
-    operator*() && noexcept
-    {
-        _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
-        return _VSTD::move(this->__get());
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr
-    const value_type&&
-    operator*() const&& noexcept
-    {
-        _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
-        return _VSTD::move(this->__get());
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit operator bool() const noexcept { return has_value(); }
-
-    using __base::has_value;
-    using __base::__get;
-
-    _LIBCPP_INLINE_VISIBILITY
+    , int> = 0> 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 optional& 
+    operator=(optional<_Up>&& __v) 
+    { 
+        this->__assign_from(_VSTD::move(__v)); 
+        return *this; 
+    } 
+ 
+    template <class... _Args, 
+              class = enable_if_t 
+                      < 
+                          is_constructible_v<value_type, _Args...> 
+                      > 
+             > 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp & 
+    emplace(_Args&&... __args) 
+    { 
+        reset(); 
+        this->__construct(_VSTD::forward<_Args>(__args)...); 
+        return this->__get(); 
+    } 
+ 
+    template <class _Up, class... _Args, 
+              class = enable_if_t 
+                      < 
+                          is_constructible_v<value_type, initializer_list<_Up>&, _Args...> 
+                      > 
+             > 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 _Tp & 
+    emplace(initializer_list<_Up> __il, _Args&&... __args) 
+    { 
+        reset(); 
+        this->__construct(__il, _VSTD::forward<_Args>(__args)...); 
+        return this->__get(); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX17 void swap(optional& __opt) 
+        noexcept(is_nothrow_move_constructible_v<value_type> && 
+                 is_nothrow_swappable_v<value_type>) 
+    { 
+        if (this->has_value() == __opt.has_value()) 
+        { 
+            using _VSTD::swap; 
+            if (this->has_value()) 
+                swap(this->__get(), __opt.__get()); 
+        } 
+        else 
+        { 
+            if (this->has_value()) 
+            { 
+                __opt.__construct(_VSTD::move(this->__get())); 
+                reset(); 
+            } 
+            else 
+            { 
+                this->__construct(_VSTD::move(__opt.__get())); 
+                __opt.reset(); 
+            } 
+        } 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr 
+    add_pointer_t<value_type const> 
+    operator->() const 
+    { 
+        _LIBCPP_ASSERT(this->has_value(), "optional operator-> called on a disengaged value"); 
+        return _VSTD::addressof(this->__get()); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr 
+    add_pointer_t<value_type> 
+    operator->() 
+    { 
+        _LIBCPP_ASSERT(this->has_value(), "optional operator-> called on a disengaged value"); 
+        return _VSTD::addressof(this->__get()); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr 
+    const value_type& 
+    operator*() const& noexcept 
+    { 
+        _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value"); 
+        return this->__get(); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr 
+    value_type& 
+    operator*() & noexcept 
+    { 
+        _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value"); 
+        return this->__get(); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr 
+    value_type&& 
+    operator*() && noexcept 
+    { 
+        _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value"); 
+        return _VSTD::move(this->__get()); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr 
+    const value_type&& 
+    operator*() const&& noexcept 
+    { 
+        _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value"); 
+        return _VSTD::move(this->__get()); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr explicit operator bool() const noexcept { return has_value(); } 
+ 
+    using __base::has_value; 
+    using __base::__get; 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
     _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-    constexpr value_type const& value() const&
-    {
-        if (!this->has_value())
-            __throw_bad_optional_access();
-        return this->__get();
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
+    constexpr value_type const& value() const& 
+    { 
+        if (!this->has_value()) 
+            __throw_bad_optional_access(); 
+        return this->__get(); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
     _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-    constexpr value_type& value() &
-    {
-        if (!this->has_value())
-            __throw_bad_optional_access();
-        return this->__get();
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
+    constexpr value_type& value() & 
+    { 
+        if (!this->has_value()) 
+            __throw_bad_optional_access(); 
+        return this->__get(); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
     _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-    constexpr value_type&& value() &&
-    {
-        if (!this->has_value())
-            __throw_bad_optional_access();
-        return _VSTD::move(this->__get());
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
+    constexpr value_type&& value() && 
+    { 
+        if (!this->has_value()) 
+            __throw_bad_optional_access(); 
+        return _VSTD::move(this->__get()); 
+    } 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
     _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-    constexpr value_type const&& value() const&&
-    {
-        if (!this->has_value())
-            __throw_bad_optional_access();
-        return _VSTD::move(this->__get());
-    }
-
-    template <class _Up>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr value_type value_or(_Up&& __v) const&
-    {
-        static_assert(is_copy_constructible_v<value_type>,
-                      "optional<T>::value_or: T must be copy constructible");
-        static_assert(is_convertible_v<_Up, value_type>,
-                      "optional<T>::value_or: U must be convertible to T");
-        return this->has_value() ? this->__get() :
-                                  static_cast<value_type>(_VSTD::forward<_Up>(__v));
-    }
-
-    template <class _Up>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr value_type value_or(_Up&& __v) &&
-    {
-        static_assert(is_move_constructible_v<value_type>,
-                      "optional<T>::value_or: T must be move constructible");
-        static_assert(is_convertible_v<_Up, value_type>,
-                      "optional<T>::value_or: U must be convertible to T");
-        return this->has_value() ? _VSTD::move(this->__get()) :
-                                  static_cast<value_type>(_VSTD::forward<_Up>(__v));
-    }
-
-    using __base::reset;
-};
-
-#if _LIBCPP_STD_VER >= 17
-template<class T>
-    optional(T) -> optional<T>;
-#endif
-
-// Comparisons between optionals
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() ==
-        declval<const _Up&>()), bool>,
-    bool
->
-operator==(const optional<_Tp>& __x, const optional<_Up>& __y)
-{
-    if (static_cast<bool>(__x) != static_cast<bool>(__y))
-        return false;
-    if (!static_cast<bool>(__x))
-        return true;
-    return *__x == *__y;
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() !=
-        declval<const _Up&>()), bool>,
-    bool
->
-operator!=(const optional<_Tp>& __x, const optional<_Up>& __y)
-{
-    if (static_cast<bool>(__x) != static_cast<bool>(__y))
-        return true;
-    if (!static_cast<bool>(__x))
-        return false;
-    return *__x != *__y;
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() <
-        declval<const _Up&>()), bool>,
-    bool
->
-operator<(const optional<_Tp>& __x, const optional<_Up>& __y)
-{
-    if (!static_cast<bool>(__y))
-        return false;
-    if (!static_cast<bool>(__x))
-        return true;
-    return *__x < *__y;
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() >
-        declval<const _Up&>()), bool>,
-    bool
->
-operator>(const optional<_Tp>& __x, const optional<_Up>& __y)
-{
-    if (!static_cast<bool>(__x))
-        return false;
-    if (!static_cast<bool>(__y))
-        return true;
-    return *__x > *__y;
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() <=
-        declval<const _Up&>()), bool>,
-    bool
->
-operator<=(const optional<_Tp>& __x, const optional<_Up>& __y)
-{
-    if (!static_cast<bool>(__x))
-        return true;
-    if (!static_cast<bool>(__y))
-        return false;
-    return *__x <= *__y;
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() >=
-        declval<const _Up&>()), bool>,
-    bool
->
-operator>=(const optional<_Tp>& __x, const optional<_Up>& __y)
-{
-    if (!static_cast<bool>(__y))
-        return true;
-    if (!static_cast<bool>(__x))
-        return false;
-    return *__x >= *__y;
-}
-
-// Comparisons with nullopt
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator==(const optional<_Tp>& __x, nullopt_t) noexcept
-{
-    return !static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator==(nullopt_t, const optional<_Tp>& __x) noexcept
-{
-    return !static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator!=(const optional<_Tp>& __x, nullopt_t) noexcept
-{
-    return static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator!=(nullopt_t, const optional<_Tp>& __x) noexcept
-{
-    return static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator<(const optional<_Tp>&, nullopt_t) noexcept
-{
-    return false;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator<(nullopt_t, const optional<_Tp>& __x) noexcept
-{
-    return static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator<=(const optional<_Tp>& __x, nullopt_t) noexcept
-{
-    return !static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator<=(nullopt_t, const optional<_Tp>&) noexcept
-{
-    return true;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator>(const optional<_Tp>& __x, nullopt_t) noexcept
-{
-    return static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator>(nullopt_t, const optional<_Tp>&) noexcept
-{
-    return false;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator>=(const optional<_Tp>&, nullopt_t) noexcept
-{
-    return true;
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator>=(nullopt_t, const optional<_Tp>& __x) noexcept
-{
-    return !static_cast<bool>(__x);
-}
-
-// Comparisons with T
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() ==
-        declval<const _Up&>()), bool>,
-    bool
->
-operator==(const optional<_Tp>& __x, const _Up& __v)
-{
-    return static_cast<bool>(__x) ? *__x == __v : false;
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() ==
-        declval<const _Up&>()), bool>,
-    bool
->
-operator==(const _Tp& __v, const optional<_Up>& __x)
-{
-    return static_cast<bool>(__x) ? __v == *__x : false;
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() !=
-        declval<const _Up&>()), bool>,
-    bool
->
-operator!=(const optional<_Tp>& __x, const _Up& __v)
-{
-    return static_cast<bool>(__x) ? *__x != __v : true;
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() !=
-        declval<const _Up&>()), bool>,
-    bool
->
-operator!=(const _Tp& __v, const optional<_Up>& __x)
-{
-    return static_cast<bool>(__x) ? __v != *__x : true;
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() <
-        declval<const _Up&>()), bool>,
-    bool
->
-operator<(const optional<_Tp>& __x, const _Up& __v)
-{
-    return static_cast<bool>(__x) ? *__x < __v : true;
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() <
-        declval<const _Up&>()), bool>,
-    bool
->
-operator<(const _Tp& __v, const optional<_Up>& __x)
-{
-    return static_cast<bool>(__x) ? __v < *__x : false;
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() <=
-        declval<const _Up&>()), bool>,
-    bool
->
-operator<=(const optional<_Tp>& __x, const _Up& __v)
-{
-    return static_cast<bool>(__x) ? *__x <= __v : true;
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() <=
-        declval<const _Up&>()), bool>,
-    bool
->
-operator<=(const _Tp& __v, const optional<_Up>& __x)
-{
-    return static_cast<bool>(__x) ? __v <= *__x : false;
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() >
-        declval<const _Up&>()), bool>,
-    bool
->
-operator>(const optional<_Tp>& __x, const _Up& __v)
-{
-    return static_cast<bool>(__x) ? *__x > __v : false;
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() >
-        declval<const _Up&>()), bool>,
-    bool
->
-operator>(const _Tp& __v, const optional<_Up>& __x)
-{
-    return static_cast<bool>(__x) ? __v > *__x : true;
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() >=
-        declval<const _Up&>()), bool>,
-    bool
->
-operator>=(const optional<_Tp>& __x, const _Up& __v)
-{
-    return static_cast<bool>(__x) ? *__x >= __v : false;
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(declval<const _Tp&>() >=
-        declval<const _Up&>()), bool>,
-    bool
->
-operator>=(const _Tp& __v, const optional<_Up>& __x)
-{
-    return static_cast<bool>(__x) ? __v >= *__x : true;
-}
-
-
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-enable_if_t<
-    is_move_constructible_v<_Tp> && is_swappable_v<_Tp>,
-    void
->
-swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
-{
-    __x.swap(__y);
-}
-
-template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-optional<decay_t<_Tp>> make_optional(_Tp&& __v)
-{
-    return optional<decay_t<_Tp>>(_VSTD::forward<_Tp>(__v));
-}
-
-template <class _Tp, class... _Args>
-_LIBCPP_INLINE_VISIBILITY constexpr
-optional<_Tp> make_optional(_Args&&... __args)
-{
-    return optional<_Tp>(in_place, _VSTD::forward<_Args>(__args)...);
-}
-
-template <class _Tp, class _Up, class... _Args>
-_LIBCPP_INLINE_VISIBILITY constexpr
-optional<_Tp> make_optional(initializer_list<_Up> __il,  _Args&&... __args)
-{
-    return optional<_Tp>(in_place, __il, _VSTD::forward<_Args>(__args)...);
-}
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS hash<
-    __enable_hash_helper<optional<_Tp>, remove_const_t<_Tp>>
->
-{
-#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef optional<_Tp> argument_type;
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t        result_type;
-#endif
-
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const optional<_Tp>& __opt) const
-    {
-        return static_cast<bool>(__opt) ? hash<remove_const_t<_Tp>>()(*__opt) : 0;
-    }
-};
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP_STD_VER > 14
-
-#endif // _LIBCPP_OPTIONAL
+    constexpr value_type const&& value() const&& 
+    { 
+        if (!this->has_value()) 
+            __throw_bad_optional_access(); 
+        return _VSTD::move(this->__get()); 
+    } 
+ 
+    template <class _Up> 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr value_type value_or(_Up&& __v) const& 
+    { 
+        static_assert(is_copy_constructible_v<value_type>, 
+                      "optional<T>::value_or: T must be copy constructible"); 
+        static_assert(is_convertible_v<_Up, value_type>, 
+                      "optional<T>::value_or: U must be convertible to T"); 
+        return this->has_value() ? this->__get() : 
+                                  static_cast<value_type>(_VSTD::forward<_Up>(__v)); 
+    } 
+ 
+    template <class _Up> 
+    _LIBCPP_INLINE_VISIBILITY 
+    constexpr value_type value_or(_Up&& __v) && 
+    { 
+        static_assert(is_move_constructible_v<value_type>, 
+                      "optional<T>::value_or: T must be move constructible"); 
+        static_assert(is_convertible_v<_Up, value_type>, 
+                      "optional<T>::value_or: U must be convertible to T"); 
+        return this->has_value() ? _VSTD::move(this->__get()) : 
+                                  static_cast<value_type>(_VSTD::forward<_Up>(__v)); 
+    } 
+ 
+    using __base::reset; 
+}; 
+ 
+#if _LIBCPP_STD_VER >= 17 
+template<class T> 
+    optional(T) -> optional<T>; 
+#endif 
+ 
+// Comparisons between optionals 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() == 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator==(const optional<_Tp>& __x, const optional<_Up>& __y) 
+{ 
+    if (static_cast<bool>(__x) != static_cast<bool>(__y)) 
+        return false; 
+    if (!static_cast<bool>(__x)) 
+        return true; 
+    return *__x == *__y; 
+} 
+ 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() != 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator!=(const optional<_Tp>& __x, const optional<_Up>& __y) 
+{ 
+    if (static_cast<bool>(__x) != static_cast<bool>(__y)) 
+        return true; 
+    if (!static_cast<bool>(__x)) 
+        return false; 
+    return *__x != *__y; 
+} 
+ 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() < 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator<(const optional<_Tp>& __x, const optional<_Up>& __y) 
+{ 
+    if (!static_cast<bool>(__y)) 
+        return false; 
+    if (!static_cast<bool>(__x)) 
+        return true; 
+    return *__x < *__y; 
+} 
+ 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() > 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator>(const optional<_Tp>& __x, const optional<_Up>& __y) 
+{ 
+    if (!static_cast<bool>(__x)) 
+        return false; 
+    if (!static_cast<bool>(__y)) 
+        return true; 
+    return *__x > *__y; 
+} 
+ 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() <= 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator<=(const optional<_Tp>& __x, const optional<_Up>& __y) 
+{ 
+    if (!static_cast<bool>(__x)) 
+        return true; 
+    if (!static_cast<bool>(__y)) 
+        return false; 
+    return *__x <= *__y; 
+} 
+ 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() >= 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator>=(const optional<_Tp>& __x, const optional<_Up>& __y) 
+{ 
+    if (!static_cast<bool>(__y)) 
+        return true; 
+    if (!static_cast<bool>(__x)) 
+        return false; 
+    return *__x >= *__y; 
+} 
+ 
+// Comparisons with nullopt 
+template <class _Tp> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+bool 
+operator==(const optional<_Tp>& __x, nullopt_t) noexcept 
+{ 
+    return !static_cast<bool>(__x); 
+} 
+ 
+template <class _Tp> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+bool 
+operator==(nullopt_t, const optional<_Tp>& __x) noexcept 
+{ 
+    return !static_cast<bool>(__x); 
+} 
+ 
+template <class _Tp> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+bool 
+operator!=(const optional<_Tp>& __x, nullopt_t) noexcept 
+{ 
+    return static_cast<bool>(__x); 
+} 
+ 
+template <class _Tp> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+bool 
+operator!=(nullopt_t, const optional<_Tp>& __x) noexcept 
+{ 
+    return static_cast<bool>(__x); 
+} 
+ 
+template <class _Tp> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+bool 
+operator<(const optional<_Tp>&, nullopt_t) noexcept 
+{ 
+    return false; 
+} 
+ 
+template <class _Tp> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+bool 
+operator<(nullopt_t, const optional<_Tp>& __x) noexcept 
+{ 
+    return static_cast<bool>(__x); 
+} 
+ 
+template <class _Tp> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+bool 
+operator<=(const optional<_Tp>& __x, nullopt_t) noexcept 
+{ 
+    return !static_cast<bool>(__x); 
+} 
+ 
+template <class _Tp> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+bool 
+operator<=(nullopt_t, const optional<_Tp>&) noexcept 
+{ 
+    return true; 
+} 
+ 
+template <class _Tp> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+bool 
+operator>(const optional<_Tp>& __x, nullopt_t) noexcept 
+{ 
+    return static_cast<bool>(__x); 
+} 
+ 
+template <class _Tp> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+bool 
+operator>(nullopt_t, const optional<_Tp>&) noexcept 
+{ 
+    return false; 
+} 
+ 
+template <class _Tp> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+bool 
+operator>=(const optional<_Tp>&, nullopt_t) noexcept 
+{ 
+    return true; 
+} 
+ 
+template <class _Tp> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+bool 
+operator>=(nullopt_t, const optional<_Tp>& __x) noexcept 
+{ 
+    return !static_cast<bool>(__x); 
+} 
+ 
+// Comparisons with T 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() == 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator==(const optional<_Tp>& __x, const _Up& __v) 
+{ 
+    return static_cast<bool>(__x) ? *__x == __v : false; 
+} 
+ 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() == 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator==(const _Tp& __v, const optional<_Up>& __x) 
+{ 
+    return static_cast<bool>(__x) ? __v == *__x : false; 
+} 
+ 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() != 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator!=(const optional<_Tp>& __x, const _Up& __v) 
+{ 
+    return static_cast<bool>(__x) ? *__x != __v : true; 
+} 
+ 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() != 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator!=(const _Tp& __v, const optional<_Up>& __x) 
+{ 
+    return static_cast<bool>(__x) ? __v != *__x : true; 
+} 
+ 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() < 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator<(const optional<_Tp>& __x, const _Up& __v) 
+{ 
+    return static_cast<bool>(__x) ? *__x < __v : true; 
+} 
+ 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() < 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator<(const _Tp& __v, const optional<_Up>& __x) 
+{ 
+    return static_cast<bool>(__x) ? __v < *__x : false; 
+} 
+ 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() <= 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator<=(const optional<_Tp>& __x, const _Up& __v) 
+{ 
+    return static_cast<bool>(__x) ? *__x <= __v : true; 
+} 
+ 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() <= 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator<=(const _Tp& __v, const optional<_Up>& __x) 
+{ 
+    return static_cast<bool>(__x) ? __v <= *__x : false; 
+} 
+ 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() > 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator>(const optional<_Tp>& __x, const _Up& __v) 
+{ 
+    return static_cast<bool>(__x) ? *__x > __v : false; 
+} 
+ 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() > 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator>(const _Tp& __v, const optional<_Up>& __x) 
+{ 
+    return static_cast<bool>(__x) ? __v > *__x : true; 
+} 
+ 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() >= 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator>=(const optional<_Tp>& __x, const _Up& __v) 
+{ 
+    return static_cast<bool>(__x) ? *__x >= __v : false; 
+} 
+ 
+template <class _Tp, class _Up> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+enable_if_t< 
+    is_convertible_v<decltype(declval<const _Tp&>() >= 
+        declval<const _Up&>()), bool>, 
+    bool 
+> 
+operator>=(const _Tp& __v, const optional<_Up>& __x) 
+{ 
+    return static_cast<bool>(__x) ? __v >= *__x : true; 
+} 
+ 
+ 
+template <class _Tp> 
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 
+enable_if_t< 
+    is_move_constructible_v<_Tp> && is_swappable_v<_Tp>, 
+    void 
+> 
+swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))) 
+{ 
+    __x.swap(__y); 
+} 
+ 
+template <class _Tp> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+optional<decay_t<_Tp>> make_optional(_Tp&& __v) 
+{ 
+    return optional<decay_t<_Tp>>(_VSTD::forward<_Tp>(__v)); 
+} 
+ 
+template <class _Tp, class... _Args> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+optional<_Tp> make_optional(_Args&&... __args) 
+{ 
+    return optional<_Tp>(in_place, _VSTD::forward<_Args>(__args)...); 
+} 
+ 
+template <class _Tp, class _Up, class... _Args> 
+_LIBCPP_INLINE_VISIBILITY constexpr 
+optional<_Tp> make_optional(initializer_list<_Up> __il,  _Args&&... __args) 
+{ 
+    return optional<_Tp>(in_place, __il, _VSTD::forward<_Args>(__args)...); 
+} 
+ 
+template <class _Tp> 
+struct _LIBCPP_TEMPLATE_VIS hash< 
+    __enable_hash_helper<optional<_Tp>, remove_const_t<_Tp>> 
+> 
+{ 
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 
+    _LIBCPP_DEPRECATED_IN_CXX17 typedef optional<_Tp> argument_type; 
+    _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t        result_type; 
+#endif 
+ 
+    _LIBCPP_INLINE_VISIBILITY 
+    size_t operator()(const optional<_Tp>& __opt) const 
+    { 
+        return static_cast<bool>(__opt) ? hash<remove_const_t<_Tp>>()(*__opt) : 0; 
+    } 
+}; 
+ 
+_LIBCPP_END_NAMESPACE_STD 
+ 
+#endif // _LIBCPP_STD_VER > 14 
+ 
+#endif // _LIBCPP_OPTIONAL