libcxx: update to LLVM 18

release/18.x branch, commit 78b99c73ee4b96fe9ce0e294d4632326afb2db42

This adds the flag `-D_LIBCPP_HARDENING_MODE` which is determined based
on the Zig optimization mode.

This commit also fixes libunwind, libcxx, and libcxxabi to properly
report sub compilation errors.

1 files changed, 2114 insertions, 3784 deletions

diff --git a/lib/libcxx/include/valarray b/lib/libcxx/include/valarray
index 09a7c9016c..fb61868495 100644
--- a/lib/libcxx/include/valarray
+++ b/lib/libcxx/include/valarray
@@ -379,355 +379,264 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Tp> class _LIBCPP_TEMPLATE_VIS valarray;
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS valarray;
+
+class _LIBCPP_TEMPLATE_VIS slice {
+  size_t __start_;
+  size_t __size_;
+  size_t __stride_;
 
-class _LIBCPP_TEMPLATE_VIS slice
-{
-    size_t __start_;
-    size_t __size_;
-    size_t __stride_;
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    slice()
-        : __start_(0),
-          __size_(0),
-          __stride_(0)
-          {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    slice(size_t __start, size_t __size, size_t __stride)
-        : __start_(__start),
-          __size_(__size),
-          __stride_(__stride)
-          {}
-
-    _LIBCPP_INLINE_VISIBILITY size_t start()  const {return __start_;}
-    _LIBCPP_INLINE_VISIBILITY size_t size()   const {return __size_;}
-    _LIBCPP_INLINE_VISIBILITY size_t stride() const {return __stride_;}
+  _LIBCPP_HIDE_FROM_ABI slice() : __start_(0), __size_(0), __stride_(0) {}
+
+  _LIBCPP_HIDE_FROM_ABI slice(size_t __start, size_t __size, size_t __stride)
+      : __start_(__start), __size_(__size), __stride_(__stride) {}
+
+  _LIBCPP_HIDE_FROM_ABI size_t start() const { return __start_; }
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; }
+  _LIBCPP_HIDE_FROM_ABI size_t stride() const { return __stride_; }
 
 #if _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_HIDE_FROM_ABI friend bool operator==(const slice& __x, const slice& __y) {
-      return __x.start() == __y.start() && __x.size() == __y.size() && __x.stride() == __y.stride();
-    }
+  _LIBCPP_HIDE_FROM_ABI friend bool operator==(const slice& __x, const slice& __y) {
+    return __x.start() == __y.start() && __x.size() == __y.size() && __x.stride() == __y.stride();
+  }
 
 #endif
 };
 
-template <class _Tp> class _LIBCPP_TEMPLATE_VIS slice_array;
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS slice_array;
 class _LIBCPP_EXPORTED_FROM_ABI gslice;
-template <class _Tp> class _LIBCPP_TEMPLATE_VIS gslice_array;
-template <class _Tp> class _LIBCPP_TEMPLATE_VIS mask_array;
-template <class _Tp> class _LIBCPP_TEMPLATE_VIS indirect_array;
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS gslice_array;
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS mask_array;
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS indirect_array;
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_Tp*
-begin(valarray<_Tp>& __v);
+_LIBCPP_HIDE_FROM_ABI _Tp* begin(valarray<_Tp>& __v);
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-const _Tp*
-begin(const valarray<_Tp>& __v);
+_LIBCPP_HIDE_FROM_ABI const _Tp* begin(const valarray<_Tp>& __v);
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_Tp*
-end(valarray<_Tp>& __v);
+_LIBCPP_HIDE_FROM_ABI _Tp* end(valarray<_Tp>& __v);
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-const _Tp*
-end(const valarray<_Tp>& __v);
+_LIBCPP_HIDE_FROM_ABI const _Tp* end(const valarray<_Tp>& __v);
 
 template <class _Op, class _A0>
-struct _UnaryOp
-{
-    typedef typename _Op::__result_type __result_type;
-    using value_type = __decay_t<__result_type>;
+struct _UnaryOp {
+  typedef typename _Op::__result_type __result_type;
+  using value_type = __decay_t<__result_type>;
 
-    _Op __op_;
-    _A0 __a0_;
+  _Op __op_;
+  _A0 __a0_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {}
+  _LIBCPP_HIDE_FROM_ABI _UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i]); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __a0_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
 };
 
 template <class _Op, class _A0, class _A1>
-struct _BinaryOp
-{
-    typedef typename _Op::__result_type __result_type;
-    using value_type = __decay_t<__result_type>;
+struct _BinaryOp {
+  typedef typename _Op::__result_type __result_type;
+  using value_type = __decay_t<__result_type>;
 
-    _Op __op_;
-    _A0 __a0_;
-    _A1 __a1_;
+  _Op __op_;
+  _A0 __a0_;
+  _A1 __a1_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1)
-        : __op_(__op), __a0_(__a0), __a1_(__a1) {}
+  _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1)
+      : __op_(__op), __a0_(__a0), __a1_(__a1) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __a0_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
 };
 
 template <class _Tp>
-class __scalar_expr
-{
+class __scalar_expr {
 public:
-    typedef _Tp        value_type;
-    typedef const _Tp& __result_type;
+  typedef _Tp value_type;
+  typedef const _Tp& __result_type;
+
 private:
-    const value_type& __t_;
-    size_t __s_;
+  const value_type& __t_;
+  size_t __s_;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __scalar_expr(const value_type& __t, size_t __s) : __t_(__t), __s_(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __scalar_expr(const value_type& __t, size_t __s) : __t_(__t), __s_(__s) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t) const {return __t_;}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t) const { return __t_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __s_;}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __s_; }
 };
 
 template <class _Tp>
-struct __unary_plus
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return +__x;}
+struct __unary_plus {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return +__x; }
 };
 
 template <class _Tp>
-struct __bit_not
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return ~__x;}
+struct __bit_not {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return ~__x; }
 };
 
 template <class _Tp>
-struct __bit_shift_left
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x << __y;}
+struct __bit_shift_left {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x << __y; }
 };
 
 template <class _Tp>
-struct __bit_shift_right
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x >> __y;}
+struct __bit_shift_right {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x >> __y; }
 };
 
 template <class _Tp, class _Fp>
-struct __apply_expr
-{
+struct __apply_expr {
 private:
-    _Fp __f_;
+  _Fp __f_;
+
 public:
-    typedef _Tp __result_type;
+  typedef _Tp __result_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __apply_expr(_Fp __f) : __f_(__f) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __apply_expr(_Fp __f) : __f_(__f) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return __f_(__x);}
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return __f_(__x); }
 };
 
 template <class _Tp>
-struct __abs_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::abs(__x);}
+struct __abs_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::abs(__x); }
 };
 
 template <class _Tp>
-struct __acos_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::acos(__x);}
+struct __acos_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::acos(__x); }
 };
 
 template <class _Tp>
-struct __asin_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::asin(__x);}
+struct __asin_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::asin(__x); }
 };
 
 template <class _Tp>
-struct __atan_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::atan(__x);}
+struct __atan_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::atan(__x); }
 };
 
 template <class _Tp>
-struct __atan2_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return std::atan2(__x, __y);}
+struct __atan2_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return std::atan2(__x, __y); }
 };
 
 template <class _Tp>
-struct __cos_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::cos(__x);}
+struct __cos_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::cos(__x); }
 };
 
 template <class _Tp>
-struct __cosh_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::cosh(__x);}
+struct __cosh_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::cosh(__x); }
 };
 
 template <class _Tp>
-struct __exp_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::exp(__x);}
+struct __exp_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::exp(__x); }
 };
 
 template <class _Tp>
-struct __log_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::log(__x);}
+struct __log_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::log(__x); }
 };
 
 template <class _Tp>
-struct __log10_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::log10(__x);}
+struct __log10_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::log10(__x); }
 };
 
 template <class _Tp>
-struct __pow_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return std::pow(__x, __y);}
+struct __pow_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return std::pow(__x, __y); }
 };
 
 template <class _Tp>
-struct __sin_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::sin(__x);}
+struct __sin_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::sin(__x); }
 };
 
 template <class _Tp>
-struct __sinh_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::sinh(__x);}
+struct __sinh_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::sinh(__x); }
 };
 
 template <class _Tp>
-struct __sqrt_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::sqrt(__x);}
+struct __sqrt_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::sqrt(__x); }
 };
 
 template <class _Tp>
-struct __tan_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::tan(__x);}
+struct __tan_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::tan(__x); }
 };
 
 template <class _Tp>
-struct __tanh_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::tanh(__x);}
+struct __tanh_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::tanh(__x); }
 };
 
 template <class _ValExpr>
-class __slice_expr
-{
-    typedef __libcpp_remove_reference_t<_ValExpr>  _RmExpr;
+class __slice_expr {
+  typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
+
 public:
-    typedef typename _RmExpr::value_type value_type;
-    typedef value_type __result_type;
+  typedef typename _RmExpr::value_type value_type;
+  typedef value_type __result_type;
 
 private:
-    _ValExpr __expr_;
-    size_t __start_;
-    size_t __size_;
-    size_t __stride_;
-
-    _LIBCPP_INLINE_VISIBILITY
-    __slice_expr(const slice& __sl, const _RmExpr& __e)
-        : __expr_(__e),
-          __start_(__sl.start()),
-          __size_(__sl.size()),
-          __stride_(__sl.stride())
-        {}
-public:
+  _ValExpr __expr_;
+  size_t __start_;
+  size_t __size_;
+  size_t __stride_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const
-        {return __expr_[__start_ + __i * __stride_];}
+  _LIBCPP_HIDE_FROM_ABI __slice_expr(const slice& __sl, const _RmExpr& __e)
+      : __expr_(__e), __start_(__sl.start()), __size_(__sl.size()), __stride_(__sl.stride()) {}
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__start_ + __i * __stride_]; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __size_;}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; }
 
-    template <class> friend class __val_expr;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
+  template <class>
+  friend class __val_expr;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS valarray;
 };
 
 template <class _ValExpr>
@@ -737,3018 +646,1904 @@ template <class _ValExpr>
 class __indirect_expr;
 
 template <class _ValExpr>
-class __shift_expr
-{
-    typedef __libcpp_remove_reference_t<_ValExpr>  _RmExpr;
+class __shift_expr {
+  typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
+
 public:
-    typedef typename _RmExpr::value_type value_type;
-    typedef value_type __result_type;
+  typedef typename _RmExpr::value_type value_type;
+  typedef value_type __result_type;
 
 private:
-    _ValExpr __expr_;
-    size_t __size_;
-    ptrdiff_t __ul_;
-    ptrdiff_t __sn_;
-    ptrdiff_t __n_;
-    static const ptrdiff_t _Np = static_cast<ptrdiff_t>(
-                                    sizeof(ptrdiff_t) * __CHAR_BIT__ - 1);
-
-    _LIBCPP_INLINE_VISIBILITY
-    __shift_expr(int __n, const _RmExpr& __e)
-        : __expr_(__e),
-          __size_(__e.size()),
-          __n_(__n)
-        {
-            ptrdiff_t __neg_n = static_cast<ptrdiff_t>(__n_ >> _Np);
-            __sn_ = __neg_n | static_cast<ptrdiff_t>(static_cast<size_t>(-__n_) >> _Np);
-            __ul_ = ((__size_ - __n_) & ~__neg_n) | ((__n_ + 1) & __neg_n);
-        }
-public:
+  _ValExpr __expr_;
+  size_t __size_;
+  ptrdiff_t __ul_;
+  ptrdiff_t __sn_;
+  ptrdiff_t __n_;
+  static const ptrdiff_t _Np = static_cast<ptrdiff_t>(sizeof(ptrdiff_t) * __CHAR_BIT__ - 1);
+
+  _LIBCPP_HIDE_FROM_ABI __shift_expr(int __n, const _RmExpr& __e) : __expr_(__e), __size_(__e.size()), __n_(__n) {
+    ptrdiff_t __neg_n = static_cast<ptrdiff_t>(__n_ >> _Np);
+    __sn_             = __neg_n | static_cast<ptrdiff_t>(static_cast<size_t>(-__n_) >> _Np);
+    __ul_             = ((__size_ - __n_) & ~__neg_n) | ((__n_ + 1) & __neg_n);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __j) const
-        {
-            ptrdiff_t __i = static_cast<ptrdiff_t>(__j);
-            ptrdiff_t __m = (__sn_ * __i - __ul_) >> _Np;
-            return (__expr_[(__i + __n_) & __m] & __m) | (value_type() & ~__m);
-        }
+public:
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __j) const {
+    ptrdiff_t __i = static_cast<ptrdiff_t>(__j);
+    ptrdiff_t __m = (__sn_ * __i - __ul_) >> _Np;
+    return (__expr_[(__i + __n_) & __m] & __m) | (value_type() & ~__m);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __size_;}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; }
 
-    template <class> friend class __val_expr;
+  template <class>
+  friend class __val_expr;
 };
 
 template <class _ValExpr>
-class __cshift_expr
-{
-    typedef __libcpp_remove_reference_t<_ValExpr>  _RmExpr;
+class __cshift_expr {
+  typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
+
 public:
-    typedef typename _RmExpr::value_type value_type;
-    typedef value_type __result_type;
+  typedef typename _RmExpr::value_type value_type;
+  typedef value_type __result_type;
 
 private:
-    _ValExpr __expr_;
-    size_t __size_;
-    size_t __m_;
-    size_t __o1_;
-    size_t __o2_;
-
-    _LIBCPP_INLINE_VISIBILITY
-    __cshift_expr(int __n, const _RmExpr& __e)
-        : __expr_(__e),
-          __size_(__e.size())
-        {
-            __n %= static_cast<int>(__size_);
-            if (__n >= 0)
-            {
-                __m_ = __size_ - __n;
-                __o1_ = __n;
-                __o2_ = __n - __size_;
-            }
-            else
-            {
-                __m_ = -__n;
-                __o1_ = __n + __size_;
-                __o2_ = __n;
-            }
-        }
-public:
+  _ValExpr __expr_;
+  size_t __size_;
+  size_t __m_;
+  size_t __o1_;
+  size_t __o2_;
+
+  _LIBCPP_HIDE_FROM_ABI __cshift_expr(int __n, const _RmExpr& __e) : __expr_(__e), __size_(__e.size()) {
+    __n %= static_cast<int>(__size_);
+    if (__n >= 0) {
+      __m_  = __size_ - __n;
+      __o1_ = __n;
+      __o2_ = __n - __size_;
+    } else {
+      __m_  = -__n;
+      __o1_ = __n + __size_;
+      __o2_ = __n;
+    }
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const
-        {
-            if (__i < __m_)
-                return __expr_[__i + __o1_];
-            return __expr_[__i + __o2_];
-        }
+public:
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const {
+    if (__i < __m_)
+      return __expr_[__i + __o1_];
+    return __expr_[__i + __o2_];
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __size_;}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; }
 
-    template <class> friend class __val_expr;
+  template <class>
+  friend class __val_expr;
 };
 
-template<class _ValExpr>
+template <class _ValExpr>
 class __val_expr;
 
-template<class _ValExpr>
+template <class _ValExpr>
 struct __is_val_expr : false_type {};
 
-template<class _ValExpr>
+template <class _ValExpr>
 struct __is_val_expr<__val_expr<_ValExpr> > : true_type {};
 
-template<class _Tp>
+template <class _Tp>
 struct __is_val_expr<valarray<_Tp> > : true_type {};
 
-template<class _Tp>
-class _LIBCPP_TEMPLATE_VIS valarray
-{
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS valarray {
 public:
-    typedef _Tp value_type;
-    typedef _Tp __result_type;
+  typedef _Tp value_type;
+  typedef _Tp __result_type;
 
 private:
-    value_type* __begin_;
-    value_type* __end_;
+  value_type* __begin_;
+  value_type* __end_;
 
 public:
-    // construct/destroy:
-    _LIBCPP_INLINE_VISIBILITY
-    valarray() : __begin_(nullptr), __end_(nullptr) {}
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    explicit valarray(size_t __n);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray(const value_type& __x, size_t __n);
-    valarray(const value_type* __p, size_t __n);
-    valarray(const valarray& __v);
+  // construct/destroy:
+  _LIBCPP_HIDE_FROM_ABI valarray() : __begin_(nullptr), __end_(nullptr) {}
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit valarray(size_t __n);
+  _LIBCPP_HIDE_FROM_ABI valarray(const value_type& __x, size_t __n);
+  valarray(const value_type* __p, size_t __n);
+  valarray(const valarray& __v);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    valarray(valarray&& __v) _NOEXCEPT;
-    valarray(initializer_list<value_type> __il);
+  _LIBCPP_HIDE_FROM_ABI valarray(valarray&& __v) _NOEXCEPT;
+  valarray(initializer_list<value_type> __il);
 #endif // _LIBCPP_CXX03_LANG
-    valarray(const slice_array<value_type>& __sa);
-    valarray(const gslice_array<value_type>& __ga);
-    valarray(const mask_array<value_type>& __ma);
-    valarray(const indirect_array<value_type>& __ia);
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    ~valarray();
-
-    // assignment:
-    valarray& operator=(const valarray& __v);
+  valarray(const slice_array<value_type>& __sa);
+  valarray(const gslice_array<value_type>& __ga);
+  valarray(const mask_array<value_type>& __ma);
+  valarray(const indirect_array<value_type>& __ia);
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 ~valarray();
+
+  // assignment:
+  valarray& operator=(const valarray& __v);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator=(valarray&& __v) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator=(initializer_list<value_type>);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator=(valarray&& __v) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI valarray& operator=(initializer_list<value_type>);
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator=(const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator=(const slice_array<value_type>& __sa);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator=(const gslice_array<value_type>& __ga);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator=(const mask_array<value_type>& __ma);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator=(const indirect_array<value_type>& __ia);
-    template <class _ValExpr>
-        _LIBCPP_INLINE_VISIBILITY
-        valarray& operator=(const __val_expr<_ValExpr>& __v);
-
-    // element access:
-    _LIBCPP_INLINE_VISIBILITY
-    const value_type& operator[](size_t __i) const {return __begin_[__i];}
-
-    _LIBCPP_INLINE_VISIBILITY
-    value_type&       operator[](size_t __i)       {return __begin_[__i];}
-
-    // subset operations:
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__slice_expr<const valarray&> >    operator[](slice __s) const;
-    _LIBCPP_INLINE_VISIBILITY
-    slice_array<value_type>                       operator[](slice __s);
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__indirect_expr<const valarray&> > operator[](const gslice& __gs) const;
-    _LIBCPP_INLINE_VISIBILITY
-    gslice_array<value_type>   operator[](const gslice& __gs);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator=(const slice_array<value_type>& __sa);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator=(const gslice_array<value_type>& __ga);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator=(const mask_array<value_type>& __ma);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator=(const indirect_array<value_type>& __ia);
+  template <class _ValExpr>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator=(const __val_expr<_ValExpr>& __v);
+
+  // element access:
+  _LIBCPP_HIDE_FROM_ABI const value_type& operator[](size_t __i) const { return __begin_[__i]; }
+
+  _LIBCPP_HIDE_FROM_ABI value_type& operator[](size_t __i) { return __begin_[__i]; }
+
+  // subset operations:
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__slice_expr<const valarray&> > operator[](slice __s) const;
+  _LIBCPP_HIDE_FROM_ABI slice_array<value_type> operator[](slice __s);
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](const gslice& __gs) const;
+  _LIBCPP_HIDE_FROM_ABI gslice_array<value_type> operator[](const gslice& __gs);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const;
-    _LIBCPP_INLINE_VISIBILITY
-    gslice_array<value_type>                      operator[](gslice&& __gs);
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const;
+  _LIBCPP_HIDE_FROM_ABI gslice_array<value_type> operator[](gslice&& __gs);
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__mask_expr<const valarray&> >     operator[](const valarray<bool>& __vb) const;
-    _LIBCPP_INLINE_VISIBILITY
-    mask_array<value_type>                        operator[](const valarray<bool>& __vb);
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<const valarray&> > operator[](const valarray<bool>& __vb) const;
+  _LIBCPP_HIDE_FROM_ABI mask_array<value_type> operator[](const valarray<bool>& __vb);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__mask_expr<const valarray&> >     operator[](valarray<bool>&& __vb) const;
-    _LIBCPP_INLINE_VISIBILITY
-    mask_array<value_type>                        operator[](valarray<bool>&& __vb);
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<const valarray&> > operator[](valarray<bool>&& __vb) const;
+  _LIBCPP_HIDE_FROM_ABI mask_array<value_type> operator[](valarray<bool>&& __vb);
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__indirect_expr<const valarray&> > operator[](const valarray<size_t>& __vs) const;
-    _LIBCPP_INLINE_VISIBILITY
-    indirect_array<value_type>                    operator[](const valarray<size_t>& __vs);
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](const valarray<size_t>& __vs) const;
+  _LIBCPP_HIDE_FROM_ABI indirect_array<value_type> operator[](const valarray<size_t>& __vs);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__indirect_expr<const valarray&> > operator[](valarray<size_t>&& __vs) const;
-    _LIBCPP_INLINE_VISIBILITY
-    indirect_array<value_type>                    operator[](valarray<size_t>&& __vs);
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](valarray<size_t>&& __vs) const;
+  _LIBCPP_HIDE_FROM_ABI indirect_array<value_type> operator[](valarray<size_t>&& __vs);
 #endif // _LIBCPP_CXX03_LANG
 
-    // unary operators:
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray&> >   operator+() const;
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<negate<_Tp>, const valarray&> >         operator-() const;
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray&> >      operator~() const;
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<logical_not<_Tp>, const valarray&> >    operator!() const;
+  // unary operators:
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray&> > operator+() const;
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<negate<_Tp>, const valarray&> > operator-() const;
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray&> > operator~() const;
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<logical_not<_Tp>, const valarray&> > operator!() const;
 
-    // computed assignment:
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator*= (const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator/= (const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator%= (const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator+= (const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator-= (const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator^= (const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator&= (const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator|= (const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator<<=(const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator>>=(const value_type& __x);
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator*= (const _Expr& __v);
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator/= (const _Expr& __v);
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator%= (const _Expr& __v);
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator+= (const _Expr& __v);
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator-= (const _Expr& __v);
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator^= (const _Expr& __v);
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator|= (const _Expr& __v);
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator&= (const _Expr& __v);
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator<<= (const _Expr& __v);
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator>>= (const _Expr& __v);
+  // computed assignment:
+  _LIBCPP_HIDE_FROM_ABI valarray& operator*=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator/=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator%=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator+=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator-=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator^=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator&=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator|=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator<<=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator>>=(const value_type& __x);
 
-    // member functions:
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(valarray& __v) _NOEXCEPT;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator*=(const _Expr& __v);
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return static_cast<size_t>(__end_ - __begin_);}
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator/=(const _Expr& __v);
 
-    _LIBCPP_INLINE_VISIBILITY
-    value_type sum() const;
-    _LIBCPP_INLINE_VISIBILITY
-    value_type min() const;
-    _LIBCPP_INLINE_VISIBILITY
-    value_type max() const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator%=(const _Expr& __v);
 
-    valarray shift (int __i) const;
-    valarray cshift(int __i) const;
-    valarray apply(value_type __f(value_type)) const;
-    valarray apply(value_type __f(const value_type&)) const;
-    void     resize(size_t __n, value_type __x = value_type());
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator+=(const _Expr& __v);
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator-=(const _Expr& __v);
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator^=(const _Expr& __v);
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator|=(const _Expr& __v);
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator&=(const _Expr& __v);
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator<<=(const _Expr& __v);
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator>>=(const _Expr& __v);
+
+  // member functions:
+  _LIBCPP_HIDE_FROM_ABI void swap(valarray& __v) _NOEXCEPT;
+
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return static_cast<size_t>(__end_ - __begin_); }
+
+  _LIBCPP_HIDE_FROM_ABI value_type sum() const;
+  _LIBCPP_HIDE_FROM_ABI value_type min() const;
+  _LIBCPP_HIDE_FROM_ABI value_type max() const;
+
+  valarray shift(int __i) const;
+  valarray cshift(int __i) const;
+  valarray apply(value_type __f(value_type)) const;
+  valarray apply(value_type __f(const value_type&)) const;
+  void resize(size_t __n, value_type __x = value_type());
 
 private:
-    template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS slice_array;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS gslice_array;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS mask_array;
-    template <class> friend class __mask_expr;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS indirect_array;
-    template <class> friend class __indirect_expr;
-    template <class> friend class __val_expr;
-
-    template <class _Up>
-    friend
-    _Up*
-    begin(valarray<_Up>& __v);
-
-    template <class _Up>
-    friend
-    const _Up*
-    begin(const valarray<_Up>& __v);
-
-    template <class _Up>
-    friend
-    _Up*
-    end(valarray<_Up>& __v);
-
-    template <class _Up>
-    friend
-    const _Up*
-    end(const valarray<_Up>& __v);
-
-    _LIBCPP_INLINE_VISIBILITY
-    void __clear(size_t __capacity);
-    valarray& __assign_range(const value_type* __f, const value_type* __l);
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS valarray;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS slice_array;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS gslice_array;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS mask_array;
+  template <class>
+  friend class __mask_expr;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS indirect_array;
+  template <class>
+  friend class __indirect_expr;
+  template <class>
+  friend class __val_expr;
+
+  template <class _Up>
+  friend _Up* begin(valarray<_Up>& __v);
+
+  template <class _Up>
+  friend const _Up* begin(const valarray<_Up>& __v);
+
+  template <class _Up>
+  friend _Up* end(valarray<_Up>& __v);
+
+  template <class _Up>
+  friend const _Up* end(const valarray<_Up>& __v);
+
+  _LIBCPP_HIDE_FROM_ABI void __clear(size_t __capacity);
+  valarray& __assign_range(const value_type* __f, const value_type* __l);
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _Tp, size_t _Size>
-valarray(const _Tp(&)[_Size], size_t) -> valarray<_Tp>;
+template <class _Tp, size_t _Size>
+valarray(const _Tp (&)[_Size], size_t) -> valarray<_Tp>;
 #endif
 
 extern template _LIBCPP_EXPORTED_FROM_ABI void valarray<size_t>::resize(size_t, size_t);
 
 template <class _Op, class _Tp>
-struct _UnaryOp<_Op, valarray<_Tp> >
-{
-    typedef typename _Op::__result_type __result_type;
-    using value_type = __decay_t<__result_type>;
+struct _UnaryOp<_Op, valarray<_Tp> > {
+  typedef typename _Op::__result_type __result_type;
+  using value_type = __decay_t<__result_type>;
 
-    _Op __op_;
-    const valarray<_Tp>& __a0_;
+  _Op __op_;
+  const valarray<_Tp>& __a0_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {}
+  _LIBCPP_HIDE_FROM_ABI _UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i]); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __a0_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
 };
 
 template <class _Op, class _Tp, class _A1>
-struct _BinaryOp<_Op, valarray<_Tp>, _A1>
-{
-    typedef typename _Op::__result_type __result_type;
-    using value_type = __decay_t<__result_type>;
+struct _BinaryOp<_Op, valarray<_Tp>, _A1> {
+  typedef typename _Op::__result_type __result_type;
+  using value_type = __decay_t<__result_type>;
 
-    _Op __op_;
-    const valarray<_Tp>& __a0_;
-    _A1 __a1_;
+  _Op __op_;
+  const valarray<_Tp>& __a0_;
+  _A1 __a1_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1)
-        : __op_(__op), __a0_(__a0), __a1_(__a1) {}
+  _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1)
+      : __op_(__op), __a0_(__a0), __a1_(__a1) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __a0_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
 };
 
 template <class _Op, class _A0, class _Tp>
-struct _BinaryOp<_Op, _A0, valarray<_Tp> >
-{
-    typedef typename _Op::__result_type __result_type;
-    using value_type = __decay_t<__result_type>;
+struct _BinaryOp<_Op, _A0, valarray<_Tp> > {
+  typedef typename _Op::__result_type __result_type;
+  using value_type = __decay_t<__result_type>;
 
-    _Op __op_;
-    _A0 __a0_;
-    const valarray<_Tp>& __a1_;
+  _Op __op_;
+  _A0 __a0_;
+  const valarray<_Tp>& __a1_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1)
-        : __op_(__op), __a0_(__a0), __a1_(__a1) {}
+  _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1)
+      : __op_(__op), __a0_(__a0), __a1_(__a1) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __a0_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
 };
 
 template <class _Op, class _Tp>
-struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> >
-{
-    typedef typename _Op::__result_type __result_type;
-    using value_type = __decay_t<__result_type>;
+struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> > {
+  typedef typename _Op::__result_type __result_type;
+  using value_type = __decay_t<__result_type>;
 
-    _Op __op_;
-    const valarray<_Tp>& __a0_;
-    const valarray<_Tp>& __a1_;
+  _Op __op_;
+  const valarray<_Tp>& __a0_;
+  const valarray<_Tp>& __a1_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1)
-        : __op_(__op), __a0_(__a0), __a1_(__a1) {}
+  _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1)
+      : __op_(__op), __a0_(__a0), __a1_(__a1) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __a0_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
 };
 
 // slice_array
 
 template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS slice_array
-{
+class _LIBCPP_TEMPLATE_VIS slice_array {
 public:
-    typedef _Tp value_type;
+  typedef _Tp value_type;
 
 private:
-    value_type* __vp_;
-    size_t __size_;
-    size_t __stride_;
+  value_type* __vp_;
+  size_t __size_;
+  size_t __stride_;
 
 public:
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator*=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator/=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator%=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator+=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator-=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator^=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator&=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator|=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator<<=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator>>=(const _Expr& __v) const;
-
-    slice_array(slice_array const&) = default;
-
-    _LIBCPP_INLINE_VISIBILITY
-    const slice_array& operator=(const slice_array& __sa) const;
-
-    _LIBCPP_INLINE_VISIBILITY
-    void operator=(const value_type& __x) const;
-
-    _LIBCPP_INLINE_VISIBILITY
-    void operator=(const valarray<value_type>& __va) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const;
+
+  slice_array(slice_array const&) = default;
+
+  _LIBCPP_HIDE_FROM_ABI const slice_array& operator=(const slice_array& __sa) const;
+
+  _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const;
+
+  _LIBCPP_HIDE_FROM_ABI void operator=(const valarray<value_type>& __va) const;
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    slice_array(const slice& __sl, const valarray<value_type>& __v)
-        : __vp_(const_cast<value_type*>(__v.__begin_ + __sl.start())),
-          __size_(__sl.size()),
-          __stride_(__sl.stride())
-        {}
-
-    template <class> friend class valarray;
+  _LIBCPP_HIDE_FROM_ABI slice_array(const slice& __sl, const valarray<value_type>& __v)
+      : __vp_(const_cast<value_type*>(__v.__begin_ + __sl.start())), __size_(__sl.size()), __stride_(__sl.stride()) {}
+
+  template <class>
+  friend class valarray;
 };
 
 template <class _Tp>
-inline
-const slice_array<_Tp>&
-slice_array<_Tp>::operator=(const slice_array& __sa) const
-{
-    value_type* __t = __vp_;
-    const value_type* __s = __sa.__vp_;
-    for (size_t __n = __size_; __n; --__n, __t += __stride_, __s += __sa.__stride_)
-        *__t = *__s;
-    return *this;
-}
-
-template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t = __v[__i];
+inline const slice_array<_Tp>& slice_array<_Tp>::operator=(const slice_array& __sa) const {
+  value_type* __t       = __vp_;
+  const value_type* __s = __sa.__vp_;
+  for (size_t __n = __size_; __n; --__n, __t += __stride_, __s += __sa.__stride_)
+    *__t = *__s;
+  return *this;
 }
 
 template <class _Tp>
-inline void
-slice_array<_Tp>::operator=(const valarray<value_type>& __va) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __va.size(); ++__i, __t += __stride_)
-        *__t = __va[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t = __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator*=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t *= __v[__i];
+inline void slice_array<_Tp>::operator=(const valarray<value_type>& __va) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __va.size(); ++__i, __t += __stride_)
+    *__t = __va[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator/=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t /= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator*=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t *= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator%=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t %= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator/=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t /= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator+=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t += __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator%=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t %= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator-=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t -= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator+=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t += __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator^=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t ^= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator-=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t -= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator&=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t &= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator^=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t ^= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator|=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t |= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator&=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t &= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator<<=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t <<= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator|=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t |= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator>>=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t >>= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator<<=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t <<= __v[__i];
 }
 
 template <class _Tp>
-inline
-void
-slice_array<_Tp>::operator=(const value_type& __x) const
-{
-    value_type* __t = __vp_;
-    for (size_t __n = __size_; __n; --__n, __t += __stride_)
-        *__t = __x;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator>>=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t >>= __v[__i];
+}
+
+template <class _Tp>
+inline void slice_array<_Tp>::operator=(const value_type& __x) const {
+  value_type* __t = __vp_;
+  for (size_t __n = __size_; __n; --__n, __t += __stride_)
+    *__t = __x;
 }
 
 // gslice
 
-class _LIBCPP_EXPORTED_FROM_ABI gslice
-{
-    valarray<size_t> __size_;
-    valarray<size_t> __stride_;
-    valarray<size_t> __1d_;
+class _LIBCPP_EXPORTED_FROM_ABI gslice {
+  valarray<size_t> __size_;
+  valarray<size_t> __stride_;
+  valarray<size_t> __1d_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    gslice() {}
+  _LIBCPP_HIDE_FROM_ABI gslice() {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    gslice(size_t __start, const valarray<size_t>& __size,
-                           const valarray<size_t>& __stride)
-        : __size_(__size),
-          __stride_(__stride)
-        {__init(__start);}
+  _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, const valarray<size_t>& __size, const valarray<size_t>& __stride)
+      : __size_(__size), __stride_(__stride) {
+    __init(__start);
+  }
 
 #ifndef _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    gslice(size_t __start, const valarray<size_t>&  __size,
-                                 valarray<size_t>&& __stride)
-        : __size_(__size),
-          __stride_(std::move(__stride))
-        {__init(__start);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    gslice(size_t __start,       valarray<size_t>&& __size,
-                           const valarray<size_t>&  __stride)
-        : __size_(std::move(__size)),
-          __stride_(__stride)
-        {__init(__start);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    gslice(size_t __start,       valarray<size_t>&& __size,
-                                 valarray<size_t>&& __stride)
-        : __size_(std::move(__size)),
-          __stride_(std::move(__stride))
-        {__init(__start);}
+  _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, const valarray<size_t>& __size, valarray<size_t>&& __stride)
+      : __size_(__size), __stride_(std::move(__stride)) {
+    __init(__start);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, valarray<size_t>&& __size, const valarray<size_t>& __stride)
+      : __size_(std::move(__size)), __stride_(__stride) {
+    __init(__start);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, valarray<size_t>&& __size, valarray<size_t>&& __stride)
+      : __size_(std::move(__size)), __stride_(std::move(__stride)) {
+    __init(__start);
+  }
 
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t           start()  const {return __1d_.size() ? __1d_[0] : 0;}
+  _LIBCPP_HIDE_FROM_ABI size_t start() const { return __1d_.size() ? __1d_[0] : 0; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    valarray<size_t> size()   const {return __size_;}
+  _LIBCPP_HIDE_FROM_ABI valarray<size_t> size() const { return __size_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    valarray<size_t> stride() const {return __stride_;}
+  _LIBCPP_HIDE_FROM_ABI valarray<size_t> stride() const { return __stride_; }
 
 private:
-    void __init(size_t __start);
-
-    template <class> friend class gslice_array;
-    template <class> friend class valarray;
-    template <class> friend class __val_expr;
+  void __init(size_t __start);
+
+  template <class>
+  friend class gslice_array;
+  template <class>
+  friend class valarray;
+  template <class>
+  friend class __val_expr;
 };
 
 // gslice_array
 
 template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS gslice_array
-{
+class _LIBCPP_TEMPLATE_VIS gslice_array {
 public:
-    typedef _Tp value_type;
+  typedef _Tp value_type;
 
 private:
-    value_type*      __vp_;
-    valarray<size_t> __1d_;
+  value_type* __vp_;
+  valarray<size_t> __1d_;
 
 public:
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator*=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator/=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator%=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator+=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator-=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator^=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator&=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator|=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator<<=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator>>=(const _Expr& __v) const;
-
-    _LIBCPP_INLINE_VISIBILITY
-    const gslice_array& operator=(const gslice_array& __ga) const;
-
-    _LIBCPP_INLINE_VISIBILITY
-    void operator=(const value_type& __x) const;
-
-    gslice_array(const gslice_array&)            = default;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const;
+
+  _LIBCPP_HIDE_FROM_ABI const gslice_array& operator=(const gslice_array& __ga) const;
+
+  _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const;
+
+  gslice_array(const gslice_array&) = default;
 
 private:
-    gslice_array(const gslice& __gs, const valarray<value_type>& __v)
-        : __vp_(const_cast<value_type*>(__v.__begin_)),
-          __1d_(__gs.__1d_)
-        {}
+  gslice_array(const gslice& __gs, const valarray<value_type>& __v)
+      : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(__gs.__1d_) {}
 
 #ifndef _LIBCPP_CXX03_LANG
-    gslice_array(gslice&& __gs, const valarray<value_type>& __v)
-        : __vp_(const_cast<value_type*>(__v.__begin_)),
-          __1d_(std::move(__gs.__1d_))
-        {}
+  gslice_array(gslice&& __gs, const valarray<value_type>& __v)
+      : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(std::move(__gs.__1d_)) {}
 #endif // _LIBCPP_CXX03_LANG
 
-    template <class> friend class valarray;
+  template <class>
+  friend class valarray;
 };
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] = __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] = __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator*=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] *= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator*=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] *= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator/=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] /= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator/=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] /= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator%=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] %= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator%=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] %= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator+=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] += __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator+=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] += __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator-=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] -= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator-=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] -= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator^=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] ^= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator^=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] ^= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator&=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] &= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator&=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] &= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator|=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] |= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator|=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] |= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator<<=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] <<= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator<<=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] <<= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator>>=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] >>= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator>>=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] >>= __v[__j];
 }
 
 template <class _Tp>
-inline
-const gslice_array<_Tp>&
-gslice_array<_Tp>::operator=(const gslice_array& __ga) const
-{
-    typedef const size_t* _Ip;
-    const value_type* __s = __ga.__vp_;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ga.__1d_.__begin_;
-            __i != __e; ++__i, ++__j)
-        __vp_[*__i] = __s[*__j];
-    return *this;
+inline const gslice_array<_Tp>& gslice_array<_Tp>::operator=(const gslice_array& __ga) const {
+  typedef const size_t* _Ip;
+  const value_type* __s = __ga.__vp_;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ga.__1d_.__begin_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] = __s[*__j];
+  return *this;
 }
 
 template <class _Tp>
-inline
-void
-gslice_array<_Tp>::operator=(const value_type& __x) const
-{
-    typedef const size_t* _Ip;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
-        __vp_[*__i] = __x;
+inline void gslice_array<_Tp>::operator=(const value_type& __x) const {
+  typedef const size_t* _Ip;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
+    __vp_[*__i] = __x;
 }
 
 // mask_array
 
 template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS mask_array
-{
+class _LIBCPP_TEMPLATE_VIS mask_array {
 public:
-    typedef _Tp value_type;
+  typedef _Tp value_type;
 
 private:
-    value_type*      __vp_;
-    valarray<size_t> __1d_;
+  value_type* __vp_;
+  valarray<size_t> __1d_;
 
 public:
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator*=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator/=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator%=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator+=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator-=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator^=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator&=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator|=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator<<=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator>>=(const _Expr& __v) const;
-
-    mask_array(const mask_array&) = default;
-
-    _LIBCPP_INLINE_VISIBILITY
-    const mask_array& operator=(const mask_array& __ma) const;
-
-    _LIBCPP_INLINE_VISIBILITY
-    void operator=(const value_type& __x) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const;
+
+  mask_array(const mask_array&) = default;
+
+  _LIBCPP_HIDE_FROM_ABI const mask_array& operator=(const mask_array& __ma) const;
+
+  _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const;
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v)
-        : __vp_(const_cast<value_type*>(__v.__begin_)),
-          __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true)))
-          {
-              size_t __j = 0;
-              for (size_t __i = 0; __i < __vb.size(); ++__i)
-                  if (__vb[__i])
-                      __1d_[__j++] = __i;
-          }
-
-    template <class> friend class valarray;
+  _LIBCPP_HIDE_FROM_ABI mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v)
+      : __vp_(const_cast<value_type*>(__v.__begin_)),
+        __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true))) {
+    size_t __j = 0;
+    for (size_t __i = 0; __i < __vb.size(); ++__i)
+      if (__vb[__i])
+        __1d_[__j++] = __i;
+  }
+
+  template <class>
+  friend class valarray;
 };
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] = __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] = __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator*=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] *= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator*=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] *= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator/=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] /= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator/=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] /= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator%=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] %= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator%=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] %= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator+=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] += __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator+=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] += __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator-=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] -= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator-=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] -= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator^=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] ^= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator^=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] ^= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator&=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] &= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator&=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] &= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator|=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] |= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator|=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] |= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator<<=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] <<= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator<<=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] <<= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator>>=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] >>= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator>>=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] >>= __v[__i];
 }
 
 template <class _Tp>
-inline
-const mask_array<_Tp>&
-mask_array<_Tp>::operator=(const mask_array& __ma) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] = __ma.__vp_[__1d_[__i]];
-    return *this;
+inline const mask_array<_Tp>& mask_array<_Tp>::operator=(const mask_array& __ma) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] = __ma.__vp_[__1d_[__i]];
+  return *this;
 }
 
 template <class _Tp>
-inline
-void
-mask_array<_Tp>::operator=(const value_type& __x) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] = __x;
+inline void mask_array<_Tp>::operator=(const value_type& __x) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] = __x;
 }
 
 template <class _ValExpr>
-class __mask_expr
-{
-    typedef __libcpp_remove_reference_t<_ValExpr>  _RmExpr;
+class __mask_expr {
+  typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
+
 public:
-    typedef typename _RmExpr::value_type value_type;
-    typedef value_type __result_type;
+  typedef typename _RmExpr::value_type value_type;
+  typedef value_type __result_type;
 
 private:
-    _ValExpr __expr_;
-    valarray<size_t> __1d_;
-
-    _LIBCPP_INLINE_VISIBILITY
-    __mask_expr(const valarray<bool>& __vb, const _RmExpr& __e)
-        : __expr_(__e),
-          __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true)))
-          {
-              size_t __j = 0;
-              for (size_t __i = 0; __i < __vb.size(); ++__i)
-                  if (__vb[__i])
-                      __1d_[__j++] = __i;
-          }
+  _ValExpr __expr_;
+  valarray<size_t> __1d_;
+
+  _LIBCPP_HIDE_FROM_ABI __mask_expr(const valarray<bool>& __vb, const _RmExpr& __e)
+      : __expr_(__e), __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true))) {
+    size_t __j = 0;
+    for (size_t __i = 0; __i < __vb.size(); ++__i)
+      if (__vb[__i])
+        __1d_[__j++] = __i;
+  }
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const
-        {return __expr_[__1d_[__i]];}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__1d_[__i]]; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __1d_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __1d_.size(); }
 
-    template <class> friend class __val_expr;
-    template <class> friend class valarray;
+  template <class>
+  friend class __val_expr;
+  template <class>
+  friend class valarray;
 };
 
 // indirect_array
 
 template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS indirect_array
-{
+class _LIBCPP_TEMPLATE_VIS indirect_array {
 public:
-    typedef _Tp value_type;
+  typedef _Tp value_type;
 
 private:
-    value_type*      __vp_;
-    valarray<size_t> __1d_;
+  value_type* __vp_;
+  valarray<size_t> __1d_;
 
 public:
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator*=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator/=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator%=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator+=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator-=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator^=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator&=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator|=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator<<=(const _Expr& __v) const;
-
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator>>=(const _Expr& __v) const;
-
-    indirect_array(const indirect_array&) = default;
-
-    _LIBCPP_INLINE_VISIBILITY
-    const indirect_array& operator=(const indirect_array& __ia) const;
-
-    _LIBCPP_INLINE_VISIBILITY
-    void operator=(const value_type& __x) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const;
+
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const;
+
+  indirect_array(const indirect_array&) = default;
+
+  _LIBCPP_HIDE_FROM_ABI const indirect_array& operator=(const indirect_array& __ia) const;
+
+  _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const;
 
 private:
-     _LIBCPP_INLINE_VISIBILITY
-   indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v)
-        : __vp_(const_cast<value_type*>(__v.__begin_)),
-          __1d_(__ia)
-        {}
+  _LIBCPP_HIDE_FROM_ABI indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v)
+      : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(__ia) {}
 
 #ifndef _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    indirect_array(valarray<size_t>&& __ia, const valarray<value_type>& __v)
-        : __vp_(const_cast<value_type*>(__v.__begin_)),
-          __1d_(std::move(__ia))
-        {}
+  _LIBCPP_HIDE_FROM_ABI indirect_array(valarray<size_t>&& __ia, const valarray<value_type>& __v)
+      : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(std::move(__ia)) {}
 
 #endif // _LIBCPP_CXX03_LANG
 
-    template <class> friend class valarray;
+  template <class>
+  friend class valarray;
 };
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] = __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] = __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator*=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] *= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator*=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] *= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator/=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] /= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator/=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] /= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator%=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] %= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator%=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] %= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator+=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] += __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator+=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] += __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator-=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] -= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator-=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] -= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator^=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] ^= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator^=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] ^= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator&=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] &= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator&=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] &= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator|=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] |= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator|=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] |= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator<<=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] <<= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator<<=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] <<= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator>>=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] >>= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator>>=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] >>= __v[__i];
 }
 
 template <class _Tp>
-inline
-const indirect_array<_Tp>&
-indirect_array<_Tp>::operator=(const indirect_array& __ia) const
-{
-    typedef const size_t* _Ip;
-    const value_type* __s = __ia.__vp_;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ia.__1d_.__begin_;
-            __i != __e; ++__i, ++__j)
-        __vp_[*__i] = __s[*__j];
-    return *this;
+inline const indirect_array<_Tp>& indirect_array<_Tp>::operator=(const indirect_array& __ia) const {
+  typedef const size_t* _Ip;
+  const value_type* __s = __ia.__vp_;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ia.__1d_.__begin_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] = __s[*__j];
+  return *this;
 }
 
 template <class _Tp>
-inline
-void
-indirect_array<_Tp>::operator=(const value_type& __x) const
-{
-    typedef const size_t* _Ip;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
-        __vp_[*__i] = __x;
+inline void indirect_array<_Tp>::operator=(const value_type& __x) const {
+  typedef const size_t* _Ip;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
+    __vp_[*__i] = __x;
 }
 
 template <class _ValExpr>
-class __indirect_expr
-{
-    typedef __libcpp_remove_reference_t<_ValExpr>  _RmExpr;
+class __indirect_expr {
+  typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
+
 public:
-    typedef typename _RmExpr::value_type value_type;
-    typedef value_type __result_type;
+  typedef typename _RmExpr::value_type value_type;
+  typedef value_type __result_type;
 
 private:
-    _ValExpr __expr_;
-    valarray<size_t> __1d_;
+  _ValExpr __expr_;
+  valarray<size_t> __1d_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e)
-        : __expr_(__e),
-          __1d_(__ia)
-          {}
+  _LIBCPP_HIDE_FROM_ABI __indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e) : __expr_(__e), __1d_(__ia) {}
 
 #ifndef _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    __indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e)
-        : __expr_(__e),
-          __1d_(std::move(__ia))
-          {}
+  _LIBCPP_HIDE_FROM_ABI __indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e)
+      : __expr_(__e), __1d_(std::move(__ia)) {}
 
 #endif // _LIBCPP_CXX03_LANG
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const
-        {return __expr_[__1d_[__i]];}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__1d_[__i]]; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __1d_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __1d_.size(); }
 
-    template <class> friend class __val_expr;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
+  template <class>
+  friend class __val_expr;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS valarray;
 };
 
-template<class _ValExpr>
-class __val_expr
-{
-    typedef __libcpp_remove_reference_t<_ValExpr>  _RmExpr;
+template <class _ValExpr>
+class __val_expr {
+  typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
+
+  _ValExpr __expr_;
 
-    _ValExpr __expr_;
 public:
-    typedef typename _RmExpr::value_type value_type;
-    typedef typename _RmExpr::__result_type __result_type;
+  typedef typename _RmExpr::value_type value_type;
+  typedef typename _RmExpr::__result_type __result_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const
-        {return __expr_[__i];}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__i]; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__slice_expr<_ValExpr> > operator[](slice __s) const
-    {
-        typedef __slice_expr<_ValExpr> _NewExpr;
-        return __val_expr< _NewExpr >(_NewExpr(__s, __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__slice_expr<_ValExpr> > operator[](slice __s) const {
+    typedef __slice_expr<_ValExpr> _NewExpr;
+    return __val_expr< _NewExpr >(_NewExpr(__s, __expr_));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__indirect_expr<_ValExpr> > operator[](const gslice& __gs) const
-    {
-        typedef __indirect_expr<_ValExpr> _NewExpr;
-        return __val_expr<_NewExpr >(_NewExpr(__gs.__1d_, __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<_ValExpr> > operator[](const gslice& __gs) const {
+    typedef __indirect_expr<_ValExpr> _NewExpr;
+    return __val_expr<_NewExpr >(_NewExpr(__gs.__1d_, __expr_));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__mask_expr<_ValExpr> > operator[](const valarray<bool>& __vb) const
-    {
-        typedef __mask_expr<_ValExpr> _NewExpr;
-        return __val_expr< _NewExpr >( _NewExpr(__vb, __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<_ValExpr> > operator[](const valarray<bool>& __vb) const {
+    typedef __mask_expr<_ValExpr> _NewExpr;
+    return __val_expr< _NewExpr >(_NewExpr(__vb, __expr_));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__indirect_expr<_ValExpr> > operator[](const valarray<size_t>& __vs) const
-    {
-        typedef __indirect_expr<_ValExpr> _NewExpr;
-        return __val_expr< _NewExpr >(_NewExpr(__vs, __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<_ValExpr> > operator[](const valarray<size_t>& __vs) const {
+    typedef __indirect_expr<_ValExpr> _NewExpr;
+    return __val_expr< _NewExpr >(_NewExpr(__vs, __expr_));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<__unary_plus<value_type>, _ValExpr> >
-    operator+() const
-    {
-        typedef _UnaryOp<__unary_plus<value_type>, _ValExpr> _NewExpr;
-        return __val_expr<_NewExpr>(_NewExpr(__unary_plus<value_type>(), __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__unary_plus<value_type>, _ValExpr> > operator+() const {
+    typedef _UnaryOp<__unary_plus<value_type>, _ValExpr> _NewExpr;
+    return __val_expr<_NewExpr>(_NewExpr(__unary_plus<value_type>(), __expr_));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<negate<value_type>, _ValExpr> >
-    operator-() const
-    {
-        typedef _UnaryOp<negate<value_type>, _ValExpr> _NewExpr;
-        return __val_expr<_NewExpr>(_NewExpr(negate<value_type>(), __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<negate<value_type>, _ValExpr> > operator-() const {
+    typedef _UnaryOp<negate<value_type>, _ValExpr> _NewExpr;
+    return __val_expr<_NewExpr>(_NewExpr(negate<value_type>(), __expr_));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<__bit_not<value_type>, _ValExpr> >
-    operator~() const
-    {
-        typedef _UnaryOp<__bit_not<value_type>, _ValExpr> _NewExpr;
-        return __val_expr<_NewExpr>(_NewExpr(__bit_not<value_type>(), __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__bit_not<value_type>, _ValExpr> > operator~() const {
+    typedef _UnaryOp<__bit_not<value_type>, _ValExpr> _NewExpr;
+    return __val_expr<_NewExpr>(_NewExpr(__bit_not<value_type>(), __expr_));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<logical_not<value_type>, _ValExpr> >
-    operator!() const
-    {
-        typedef _UnaryOp<logical_not<value_type>, _ValExpr> _NewExpr;
-        return __val_expr<_NewExpr>(_NewExpr(logical_not<value_type>(), __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<logical_not<value_type>, _ValExpr> > operator!() const {
+    typedef _UnaryOp<logical_not<value_type>, _ValExpr> _NewExpr;
+    return __val_expr<_NewExpr>(_NewExpr(logical_not<value_type>(), __expr_));
+  }
 
-    operator valarray<__result_type>() const;
+  operator valarray<__result_type>() const;
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __expr_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __expr_.size(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type sum() const
-    {
-        size_t __n = __expr_.size();
-        __result_type __r = __n ? __expr_[0] : __result_type();
-        for (size_t __i = 1; __i < __n; ++__i)
-            __r += __expr_[__i];
-        return __r;
-    }
+  _LIBCPP_HIDE_FROM_ABI __result_type sum() const {
+    size_t __n        = __expr_.size();
+    __result_type __r = __n ? __expr_[0] : __result_type();
+    for (size_t __i = 1; __i < __n; ++__i)
+      __r += __expr_[__i];
+    return __r;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type min() const
-    {
-        size_t __n = size();
-        __result_type __r = __n ? (*this)[0] : __result_type();
-        for (size_t __i = 1; __i < __n; ++__i)
-        {
-            __result_type __x = __expr_[__i];
-            if (__x < __r)
-                __r = __x;
-        }
-        return __r;
+  _LIBCPP_HIDE_FROM_ABI __result_type min() const {
+    size_t __n        = size();
+    __result_type __r = __n ? (*this)[0] : __result_type();
+    for (size_t __i = 1; __i < __n; ++__i) {
+      __result_type __x = __expr_[__i];
+      if (__x < __r)
+        __r = __x;
     }
+    return __r;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type max() const
-    {
-        size_t __n = size();
-        __result_type __r = __n ? (*this)[0] : __result_type();
-        for (size_t __i = 1; __i < __n; ++__i)
-        {
-            __result_type __x = __expr_[__i];
-            if (__r < __x)
-                __r = __x;
-        }
-        return __r;
+  _LIBCPP_HIDE_FROM_ABI __result_type max() const {
+    size_t __n        = size();
+    __result_type __r = __n ? (*this)[0] : __result_type();
+    for (size_t __i = 1; __i < __n; ++__i) {
+      __result_type __x = __expr_[__i];
+      if (__r < __x)
+        __r = __x;
     }
+    return __r;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__shift_expr<_ValExpr> > shift (int __i) const
-        {return __val_expr<__shift_expr<_ValExpr> >(__shift_expr<_ValExpr>(__i, __expr_));}
-
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__cshift_expr<_ValExpr> > cshift(int __i) const
-        {return __val_expr<__cshift_expr<_ValExpr> >(__cshift_expr<_ValExpr>(__i, __expr_));}
-
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<__apply_expr<value_type, value_type(*)(value_type)>, _ValExpr> >
-    apply(value_type __f(value_type)) const
-    {
-        typedef __apply_expr<value_type, value_type(*)(value_type)> _Op;
-        typedef _UnaryOp<_Op, _ValExpr> _NewExpr;
-        return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__shift_expr<_ValExpr> > shift(int __i) const {
+    return __val_expr<__shift_expr<_ValExpr> >(__shift_expr<_ValExpr>(__i, __expr_));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<__apply_expr<value_type, value_type(*)(const value_type&)>, _ValExpr> >
-    apply(value_type __f(const value_type&)) const
-    {
-        typedef __apply_expr<value_type, value_type(*)(const value_type&)> _Op;
-        typedef _UnaryOp<_Op, _ValExpr> _NewExpr;
-        return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__cshift_expr<_ValExpr> > cshift(int __i) const {
+    return __val_expr<__cshift_expr<_ValExpr> >(__cshift_expr<_ValExpr>(__i, __expr_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__apply_expr<value_type, value_type (*)(value_type)>, _ValExpr> >
+  apply(value_type __f(value_type)) const {
+    typedef __apply_expr<value_type, value_type (*)(value_type)> _Op;
+    typedef _UnaryOp<_Op, _ValExpr> _NewExpr;
+    return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__apply_expr<value_type, value_type (*)(const value_type&)>, _ValExpr> >
+  apply(value_type __f(const value_type&)) const {
+    typedef __apply_expr<value_type, value_type (*)(const value_type&)> _Op;
+    typedef _UnaryOp<_Op, _ValExpr> _NewExpr;
+    return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_));
+  }
 };
 
-template<class _ValExpr>
-__val_expr<_ValExpr>::operator valarray<__val_expr::__result_type>() const
-{
-    valarray<__result_type> __r;
-    size_t __n = __expr_.size();
-    if (__n)
-    {
-        __r.__begin_ =
-            __r.__end_ = allocator<__result_type>().allocate(__n);
-        for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i)
-            ::new ((void*)__r.__end_) __result_type(__expr_[__i]);
-    }
-    return __r;
+template <class _ValExpr>
+__val_expr<_ValExpr>::operator valarray<__val_expr::__result_type>() const {
+  valarray<__result_type> __r;
+  size_t __n = __expr_.size();
+  if (__n) {
+    __r.__begin_ = __r.__end_ = allocator<__result_type>().allocate(__n);
+    for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i)
+      ::new ((void*)__r.__end_) __result_type(__expr_[__i]);
+  }
+  return __r;
 }
 
 // valarray
 
 template <class _Tp>
-inline
-valarray<_Tp>::valarray(size_t __n)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    if (__n)
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__n);
+inline valarray<_Tp>::valarray(size_t __n) : __begin_(nullptr), __end_(nullptr) {
+  if (__n) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__n);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
-                ::new ((void*)__end_) value_type();
+      for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
+        ::new ((void*)__end_) value_type();
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__n);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__n);
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>::valarray(const value_type& __x, size_t __n)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    resize(__n, __x);
+inline valarray<_Tp>::valarray(const value_type& __x, size_t __n) : __begin_(nullptr), __end_(nullptr) {
+  resize(__n, __x);
 }
 
 template <class _Tp>
-valarray<_Tp>::valarray(const value_type* __p, size_t __n)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    if (__n)
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__n);
+valarray<_Tp>::valarray(const value_type* __p, size_t __n) : __begin_(nullptr), __end_(nullptr) {
+  if (__n) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__n);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (size_t __n_left = __n; __n_left; ++__end_, ++__p, --__n_left)
-                ::new ((void*)__end_) value_type(*__p);
+      for (size_t __n_left = __n; __n_left; ++__end_, ++__p, --__n_left)
+        ::new ((void*)__end_) value_type(*__p);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__n);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__n);
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 template <class _Tp>
-valarray<_Tp>::valarray(const valarray& __v)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    if (__v.size())
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__v.size());
+valarray<_Tp>::valarray(const valarray& __v) : __begin_(nullptr), __end_(nullptr) {
+  if (__v.size()) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__v.size());
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p)
-                ::new ((void*)__end_) value_type(*__p);
+      for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p)
+        ::new ((void*)__end_) value_type(*__p);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__v.size());
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__v.size());
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-valarray<_Tp>::valarray(valarray&& __v) _NOEXCEPT
-    : __begin_(__v.__begin_),
-      __end_(__v.__end_)
-{
-    __v.__begin_ = __v.__end_ = nullptr;
+inline valarray<_Tp>::valarray(valarray&& __v) _NOEXCEPT : __begin_(__v.__begin_), __end_(__v.__end_) {
+  __v.__begin_ = __v.__end_ = nullptr;
 }
 
 template <class _Tp>
-valarray<_Tp>::valarray(initializer_list<value_type> __il)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    const size_t __n = __il.size();
-    if (__n)
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__n);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            size_t __n_left = __n;
-            for (const value_type* __p = __il.begin(); __n_left; ++__end_, ++__p, --__n_left)
-                ::new ((void*)__end_) value_type(*__p);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__n);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+valarray<_Tp>::valarray(initializer_list<value_type> __il) : __begin_(nullptr), __end_(nullptr) {
+  const size_t __n = __il.size();
+  if (__n) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__n);
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      size_t __n_left = __n;
+      for (const value_type* __p = __il.begin(); __n_left; ++__end_, ++__p, --__n_left)
+        ::new ((void*)__end_) value_type(*__p);
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__n);
+      throw;
     }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-valarray<_Tp>::valarray(const slice_array<value_type>& __sa)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    const size_t __n = __sa.__size_;
-    if (__n)
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__n);
+valarray<_Tp>::valarray(const slice_array<value_type>& __sa) : __begin_(nullptr), __end_(nullptr) {
+  const size_t __n = __sa.__size_;
+  if (__n) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__n);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            size_t __n_left = __n;
-            for (const value_type* __p = __sa.__vp_; __n_left; ++__end_, __p += __sa.__stride_, --__n_left)
-                ::new ((void*)__end_) value_type(*__p);
+      size_t __n_left = __n;
+      for (const value_type* __p = __sa.__vp_; __n_left; ++__end_, __p += __sa.__stride_, --__n_left)
+        ::new ((void*)__end_) value_type(*__p);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__n);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__n);
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 template <class _Tp>
-valarray<_Tp>::valarray(const gslice_array<value_type>& __ga)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    const size_t __n = __ga.__1d_.size();
-    if (__n)
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__n);
+valarray<_Tp>::valarray(const gslice_array<value_type>& __ga) : __begin_(nullptr), __end_(nullptr) {
+  const size_t __n = __ga.__1d_.size();
+  if (__n) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__n);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            typedef const size_t* _Ip;
-            const value_type* __s = __ga.__vp_;
-            for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_;
-                    __i != __e; ++__i, ++__end_)
-                ::new ((void*)__end_) value_type(__s[*__i]);
+      typedef const size_t* _Ip;
+      const value_type* __s = __ga.__vp_;
+      for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__end_)
+        ::new ((void*)__end_) value_type(__s[*__i]);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__n);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__n);
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 template <class _Tp>
-valarray<_Tp>::valarray(const mask_array<value_type>& __ma)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    const size_t __n = __ma.__1d_.size();
-    if (__n)
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__n);
+valarray<_Tp>::valarray(const mask_array<value_type>& __ma) : __begin_(nullptr), __end_(nullptr) {
+  const size_t __n = __ma.__1d_.size();
+  if (__n) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__n);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            typedef const size_t* _Ip;
-            const value_type* __s = __ma.__vp_;
-            for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_;
-                    __i != __e; ++__i, ++__end_)
-                ::new ((void*)__end_) value_type(__s[*__i]);
+      typedef const size_t* _Ip;
+      const value_type* __s = __ma.__vp_;
+      for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__end_)
+        ::new ((void*)__end_) value_type(__s[*__i]);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__n);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__n);
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 template <class _Tp>
-valarray<_Tp>::valarray(const indirect_array<value_type>& __ia)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    const size_t __n = __ia.__1d_.size();
-    if (__n)
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__n);
+valarray<_Tp>::valarray(const indirect_array<value_type>& __ia) : __begin_(nullptr), __end_(nullptr) {
+  const size_t __n = __ia.__1d_.size();
+  if (__n) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__n);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            typedef const size_t* _Ip;
-            const value_type* __s = __ia.__vp_;
-            for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_;
-                    __i != __e; ++__i, ++__end_)
-                ::new ((void*)__end_) value_type(__s[*__i]);
+      typedef const size_t* _Ip;
+      const value_type* __s = __ia.__vp_;
+      for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__end_)
+        ::new ((void*)__end_) value_type(__s[*__i]);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__n);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__n);
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>::~valarray()
-{
-    __clear(size());
+inline valarray<_Tp>::~valarray() {
+  __clear(size());
 }
 
 template <class _Tp>
-valarray<_Tp>&
-valarray<_Tp>::__assign_range(const value_type* __f, const value_type* __l)
-{
-    size_t __n = __l - __f;
-    if (size() != __n)
-    {
-        __clear(size());
-        __begin_ = allocator<value_type>().allocate(__n);
-        __end_ = __begin_ + __n;
-        _VSTD::uninitialized_copy(__f, __l, __begin_);
-    } else {
-        _VSTD::copy(__f, __l, __begin_);
-    }
-    return *this;
+valarray<_Tp>& valarray<_Tp>::__assign_range(const value_type* __f, const value_type* __l) {
+  size_t __n = __l - __f;
+  if (size() != __n) {
+    __clear(size());
+    __begin_ = allocator<value_type>().allocate(__n);
+    __end_   = __begin_ + __n;
+    std::uninitialized_copy(__f, __l, __begin_);
+  } else {
+    std::copy(__f, __l, __begin_);
+  }
+  return *this;
 }
 
 template <class _Tp>
-valarray<_Tp>&
-valarray<_Tp>::operator=(const valarray& __v)
-{
-    if (this != _VSTD::addressof(__v))
-        return __assign_range(__v.__begin_, __v.__end_);
-    return *this;
+valarray<_Tp>& valarray<_Tp>::operator=(const valarray& __v) {
+  if (this != std::addressof(__v))
+    return __assign_range(__v.__begin_, __v.__end_);
+  return *this;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT
-{
-    __clear(size());
-    __begin_ = __v.__begin_;
-    __end_ = __v.__end_;
-    __v.__begin_ = nullptr;
-    __v.__end_ = nullptr;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT {
+  __clear(size());
+  __begin_     = __v.__begin_;
+  __end_       = __v.__end_;
+  __v.__begin_ = nullptr;
+  __v.__end_   = nullptr;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator=(initializer_list<value_type> __il)
-{
-    return __assign_range(__il.begin(), __il.end());
+inline valarray<_Tp>& valarray<_Tp>::operator=(initializer_list<value_type> __il) {
+  return __assign_range(__il.begin(), __il.end());
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator=(const value_type& __x)
-{
-    _VSTD::fill(__begin_, __end_, __x);
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator=(const value_type& __x) {
+  std::fill(__begin_, __end_, __x);
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator=(const slice_array<value_type>& __sa)
-{
-    value_type* __t = __begin_;
-    const value_type* __s = __sa.__vp_;
-    for (size_t __n = __sa.__size_; __n; --__n, __s += __sa.__stride_, ++__t)
-        *__t = *__s;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator=(const slice_array<value_type>& __sa) {
+  value_type* __t       = __begin_;
+  const value_type* __s = __sa.__vp_;
+  for (size_t __n = __sa.__size_; __n; --__n, __s += __sa.__stride_, ++__t)
+    *__t = *__s;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator=(const gslice_array<value_type>& __ga)
-{
-    typedef const size_t* _Ip;
-    value_type* __t = __begin_;
-    const value_type* __s = __ga.__vp_;
-    for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_;
-                    __i != __e; ++__i, ++__t)
-        *__t = __s[*__i];
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator=(const gslice_array<value_type>& __ga) {
+  typedef const size_t* _Ip;
+  value_type* __t       = __begin_;
+  const value_type* __s = __ga.__vp_;
+  for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__t)
+    *__t = __s[*__i];
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator=(const mask_array<value_type>& __ma)
-{
-    typedef const size_t* _Ip;
-    value_type* __t = __begin_;
-    const value_type* __s = __ma.__vp_;
-    for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_;
-                    __i != __e; ++__i, ++__t)
-        *__t = __s[*__i];
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator=(const mask_array<value_type>& __ma) {
+  typedef const size_t* _Ip;
+  value_type* __t       = __begin_;
+  const value_type* __s = __ma.__vp_;
+  for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__t)
+    *__t = __s[*__i];
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator=(const indirect_array<value_type>& __ia)
-{
-    typedef const size_t* _Ip;
-    value_type* __t = __begin_;
-    const value_type* __s = __ia.__vp_;
-    for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_;
-                    __i != __e; ++__i, ++__t)
-        *__t = __s[*__i];
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator=(const indirect_array<value_type>& __ia) {
+  typedef const size_t* _Ip;
+  value_type* __t       = __begin_;
+  const value_type* __s = __ia.__vp_;
+  for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__t)
+    *__t = __s[*__i];
+  return *this;
 }
 
 template <class _Tp>
 template <class _ValExpr>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator=(const __val_expr<_ValExpr>& __v)
-{
-    size_t __n = __v.size();
-    if (size() != __n)
-        resize(__n);
-    value_type* __t = __begin_;
-    for (size_t __i = 0; __i != __n; ++__t, ++__i)
-        *__t = __result_type(__v[__i]);
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator=(const __val_expr<_ValExpr>& __v) {
+  size_t __n = __v.size();
+  if (size() != __n)
+    resize(__n);
+  value_type* __t = __begin_;
+  for (size_t __i = 0; __i != __n; ++__t, ++__i)
+    *__t = __result_type(__v[__i]);
+  return *this;
 }
 
 template <class _Tp>
-inline
-__val_expr<__slice_expr<const valarray<_Tp>&> >
-valarray<_Tp>::operator[](slice __s) const
-{
-    return __val_expr<__slice_expr<const valarray&> >(__slice_expr<const valarray&>(__s, *this));
+inline __val_expr<__slice_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](slice __s) const {
+  return __val_expr<__slice_expr<const valarray&> >(__slice_expr<const valarray&>(__s, *this));
 }
 
 template <class _Tp>
-inline
-slice_array<_Tp>
-valarray<_Tp>::operator[](slice __s)
-{
-    return slice_array<value_type>(__s, *this);
+inline slice_array<_Tp> valarray<_Tp>::operator[](slice __s) {
+  return slice_array<value_type>(__s, *this);
 }
 
 template <class _Tp>
-inline
-__val_expr<__indirect_expr<const valarray<_Tp>&> >
-valarray<_Tp>::operator[](const gslice& __gs) const
-{
-    return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__gs.__1d_, *this));
+inline __val_expr<__indirect_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](const gslice& __gs) const {
+  return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__gs.__1d_, *this));
 }
 
 template <class _Tp>
-inline
-gslice_array<_Tp>
-valarray<_Tp>::operator[](const gslice& __gs)
-{
-    return gslice_array<value_type>(__gs, *this);
+inline gslice_array<_Tp> valarray<_Tp>::operator[](const gslice& __gs) {
+  return gslice_array<value_type>(__gs, *this);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-__val_expr<__indirect_expr<const valarray<_Tp>&> >
-valarray<_Tp>::operator[](gslice&& __gs) const
-{
-    return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(std::move(__gs.__1d_), *this));
+inline __val_expr<__indirect_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](gslice&& __gs) const {
+  return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(std::move(__gs.__1d_), *this));
 }
 
 template <class _Tp>
-inline
-gslice_array<_Tp>
-valarray<_Tp>::operator[](gslice&& __gs)
-{
-    return gslice_array<value_type>(std::move(__gs), *this);
+inline gslice_array<_Tp> valarray<_Tp>::operator[](gslice&& __gs) {
+  return gslice_array<value_type>(std::move(__gs), *this);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-__val_expr<__mask_expr<const valarray<_Tp>&> >
-valarray<_Tp>::operator[](const valarray<bool>& __vb) const
-{
-    return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(__vb, *this));
+inline __val_expr<__mask_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](const valarray<bool>& __vb) const {
+  return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(__vb, *this));
 }
 
 template <class _Tp>
-inline
-mask_array<_Tp>
-valarray<_Tp>::operator[](const valarray<bool>& __vb)
-{
-    return mask_array<value_type>(__vb, *this);
+inline mask_array<_Tp> valarray<_Tp>::operator[](const valarray<bool>& __vb) {
+  return mask_array<value_type>(__vb, *this);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-__val_expr<__mask_expr<const valarray<_Tp>&> >
-valarray<_Tp>::operator[](valarray<bool>&& __vb) const
-{
-    return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(std::move(__vb), *this));
+inline __val_expr<__mask_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](valarray<bool>&& __vb) const {
+  return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(std::move(__vb), *this));
 }
 
 template <class _Tp>
-inline
-mask_array<_Tp>
-valarray<_Tp>::operator[](valarray<bool>&& __vb)
-{
-    return mask_array<value_type>(std::move(__vb), *this);
+inline mask_array<_Tp> valarray<_Tp>::operator[](valarray<bool>&& __vb) {
+  return mask_array<value_type>(std::move(__vb), *this);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-__val_expr<__indirect_expr<const valarray<_Tp>&> >
-valarray<_Tp>::operator[](const valarray<size_t>& __vs) const
-{
-    return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__vs, *this));
+inline __val_expr<__indirect_expr<const valarray<_Tp>&> >
+valarray<_Tp>::operator[](const valarray<size_t>& __vs) const {
+  return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__vs, *this));
 }
 
 template <class _Tp>
-inline
-indirect_array<_Tp>
-valarray<_Tp>::operator[](const valarray<size_t>& __vs)
-{
-    return indirect_array<value_type>(__vs, *this);
+inline indirect_array<_Tp> valarray<_Tp>::operator[](const valarray<size_t>& __vs) {
+  return indirect_array<value_type>(__vs, *this);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-__val_expr<__indirect_expr<const valarray<_Tp>&> >
-valarray<_Tp>::operator[](valarray<size_t>&& __vs) const
-{
-    return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(std::move(__vs), *this));
+inline __val_expr<__indirect_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](valarray<size_t>&& __vs) const {
+  return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(std::move(__vs), *this));
 }
 
 template <class _Tp>
-inline
-indirect_array<_Tp>
-valarray<_Tp>::operator[](valarray<size_t>&& __vs)
-{
-    return indirect_array<value_type>(std::move(__vs), *this);
+inline indirect_array<_Tp> valarray<_Tp>::operator[](valarray<size_t>&& __vs) {
+  return indirect_array<value_type>(std::move(__vs), *this);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-__val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&> >
-valarray<_Tp>::operator+() const
-{
-    using _Op = _UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&>;
-    return __val_expr<_Op>(_Op(__unary_plus<_Tp>(), *this));
+inline __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator+() const {
+  using _Op = _UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&>;
+  return __val_expr<_Op>(_Op(__unary_plus<_Tp>(), *this));
 }
 
 template <class _Tp>
-inline
-__val_expr<_UnaryOp<negate<_Tp>, const valarray<_Tp>&> >
-valarray<_Tp>::operator-() const
-{
-    using _Op = _UnaryOp<negate<_Tp>, const valarray<_Tp>&>;
-    return __val_expr<_Op>(_Op(negate<_Tp>(), *this));
+inline __val_expr<_UnaryOp<negate<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator-() const {
+  using _Op = _UnaryOp<negate<_Tp>, const valarray<_Tp>&>;
+  return __val_expr<_Op>(_Op(negate<_Tp>(), *this));
 }
 
 template <class _Tp>
-inline
-__val_expr<_UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&> >
-valarray<_Tp>::operator~() const
-{
-    using _Op = _UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&>;
-    return __val_expr<_Op>(_Op(__bit_not<_Tp>(), *this));
+inline __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator~() const {
+  using _Op = _UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&>;
+  return __val_expr<_Op>(_Op(__bit_not<_Tp>(), *this));
 }
 
 template <class _Tp>
-inline
-__val_expr<_UnaryOp<logical_not<_Tp>, const valarray<_Tp>&> >
-valarray<_Tp>::operator!() const
-{
-    using _Op = _UnaryOp<logical_not<_Tp>, const valarray<_Tp>&>;
-    return __val_expr<_Op>(_Op(logical_not<_Tp>(), *this));
+inline __val_expr<_UnaryOp<logical_not<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator!() const {
+  using _Op = _UnaryOp<logical_not<_Tp>, const valarray<_Tp>&>;
+  return __val_expr<_Op>(_Op(logical_not<_Tp>(), *this));
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator*=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p *= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator*=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p *= __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator/=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p /= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator/=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p /= __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator%=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p %= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator%=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p %= __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator+=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p += __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator+=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p += __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator-=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p -= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator-=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p -= __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator^=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p ^= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator^=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p ^= __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator&=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p &= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator&=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p &= __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator|=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p |= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator|=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p |= __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator<<=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p <<= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator<<=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p <<= __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator>>=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p >>= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator>>=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p >>= __x;
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator*=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t *= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator*=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t *= __v[__i];
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator/=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t /= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator/=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t /= __v[__i];
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator%=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t %= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator%=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t %= __v[__i];
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator+=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t += __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator+=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t += __v[__i];
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator-=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t -= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator-=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t -= __v[__i];
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator^=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t ^= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator^=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t ^= __v[__i];
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator|=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t |= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator|=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t |= __v[__i];
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator&=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t &= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator&=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t &= __v[__i];
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator<<=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t <<= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator<<=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t <<= __v[__i];
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator>>=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t >>= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator>>=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t >>= __v[__i];
+  return *this;
 }
 
 template <class _Tp>
-inline
-void
-valarray<_Tp>::swap(valarray& __v) _NOEXCEPT
-{
-    _VSTD::swap(__begin_, __v.__begin_);
-    _VSTD::swap(__end_, __v.__end_);
+inline void valarray<_Tp>::swap(valarray& __v) _NOEXCEPT {
+  std::swap(__begin_, __v.__begin_);
+  std::swap(__end_, __v.__end_);
 }
 
 template <class _Tp>
-inline
-_Tp
-valarray<_Tp>::sum() const
-{
-    if (__begin_ == __end_)
-        return value_type();
-    const value_type* __p = __begin_;
-    _Tp __r = *__p;
-    for (++__p; __p != __end_; ++__p)
-        __r += *__p;
-    return __r;
+inline _Tp valarray<_Tp>::sum() const {
+  if (__begin_ == __end_)
+    return value_type();
+  const value_type* __p = __begin_;
+  _Tp __r               = *__p;
+  for (++__p; __p != __end_; ++__p)
+    __r += *__p;
+  return __r;
 }
 
 template <class _Tp>
-inline
-_Tp
-valarray<_Tp>::min() const
-{
-    if (__begin_ == __end_)
-        return value_type();
-    return *_VSTD::min_element(__begin_, __end_);
+inline _Tp valarray<_Tp>::min() const {
+  if (__begin_ == __end_)
+    return value_type();
+  return *std::min_element(__begin_, __end_);
 }
 
 template <class _Tp>
-inline
-_Tp
-valarray<_Tp>::max() const
-{
-    if (__begin_ == __end_)
-        return value_type();
-    return *_VSTD::max_element(__begin_, __end_);
+inline _Tp valarray<_Tp>::max() const {
+  if (__begin_ == __end_)
+    return value_type();
+  return *std::max_element(__begin_, __end_);
 }
 
 template <class _Tp>
-valarray<_Tp>
-valarray<_Tp>::shift(int __i) const
-{
-    valarray<value_type> __r;
-    size_t __n = size();
-    if (__n)
-    {
-        __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
-        const value_type* __sb;
-        value_type* __tb;
-        value_type* __te;
-        if (__i >= 0)
-        {
-            __i = _VSTD::min(__i, static_cast<int>(__n));
-            __sb = __begin_ + __i;
-            __tb = __r.__begin_;
-            __te = __r.__begin_ + (__n - __i);
-        }
-        else
-        {
-            __i = _VSTD::min(-__i, static_cast<int>(__n));
-            __sb = __begin_;
-            __tb = __r.__begin_ + __i;
-            __te = __r.__begin_ + __n;
-        }
-        for (; __r.__end_ != __tb; ++__r.__end_)
-            ::new ((void*)__r.__end_) value_type();
-        for (; __r.__end_ != __te; ++__r.__end_, ++__sb)
-            ::new ((void*)__r.__end_) value_type(*__sb);
-        for (__te = __r.__begin_ + __n; __r.__end_ != __te; ++__r.__end_)
-            ::new ((void*)__r.__end_) value_type();
+valarray<_Tp> valarray<_Tp>::shift(int __i) const {
+  valarray<value_type> __r;
+  size_t __n = size();
+  if (__n) {
+    __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
+    const value_type* __sb;
+    value_type* __tb;
+    value_type* __te;
+    if (__i >= 0) {
+      __i  = std::min(__i, static_cast<int>(__n));
+      __sb = __begin_ + __i;
+      __tb = __r.__begin_;
+      __te = __r.__begin_ + (__n - __i);
+    } else {
+      __i  = std::min(-__i, static_cast<int>(__n));
+      __sb = __begin_;
+      __tb = __r.__begin_ + __i;
+      __te = __r.__begin_ + __n;
     }
-    return __r;
+    for (; __r.__end_ != __tb; ++__r.__end_)
+      ::new ((void*)__r.__end_) value_type();
+    for (; __r.__end_ != __te; ++__r.__end_, ++__sb)
+      ::new ((void*)__r.__end_) value_type(*__sb);
+    for (__te = __r.__begin_ + __n; __r.__end_ != __te; ++__r.__end_)
+      ::new ((void*)__r.__end_) value_type();
+  }
+  return __r;
 }
 
 template <class _Tp>
-valarray<_Tp>
-valarray<_Tp>::cshift(int __i) const
-{
-    valarray<value_type> __r;
-    size_t __n = size();
-    if (__n)
-    {
-        __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
-        __i %= static_cast<int>(__n);
-        const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i;
-        for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s)
-            ::new ((void*)__r.__end_) value_type(*__s);
-        for (const value_type* __s = __begin_; __s != __m; ++__r.__end_, ++__s)
-            ::new ((void*)__r.__end_) value_type(*__s);
-    }
-    return __r;
+valarray<_Tp> valarray<_Tp>::cshift(int __i) const {
+  valarray<value_type> __r;
+  size_t __n = size();
+  if (__n) {
+    __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
+    __i %= static_cast<int>(__n);
+    const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i;
+    for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s)
+      ::new ((void*)__r.__end_) value_type(*__s);
+    for (const value_type* __s = __begin_; __s != __m; ++__r.__end_, ++__s)
+      ::new ((void*)__r.__end_) value_type(*__s);
+  }
+  return __r;
 }
 
 template <class _Tp>
-valarray<_Tp>
-valarray<_Tp>::apply(value_type __f(value_type)) const
-{
-    valarray<value_type> __r;
-    size_t __n = size();
-    if (__n)
-    {
-        __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
-        for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
-            ::new ((void*)__r.__end_) value_type(__f(*__p));
-    }
-    return __r;
+valarray<_Tp> valarray<_Tp>::apply(value_type __f(value_type)) const {
+  valarray<value_type> __r;
+  size_t __n = size();
+  if (__n) {
+    __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
+    for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
+      ::new ((void*)__r.__end_) value_type(__f(*__p));
+  }
+  return __r;
 }
 
 template <class _Tp>
-valarray<_Tp>
-valarray<_Tp>::apply(value_type __f(const value_type&)) const
-{
-    valarray<value_type> __r;
-    size_t __n = size();
-    if (__n)
-    {
-        __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
-        for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
-            ::new ((void*)__r.__end_) value_type(__f(*__p));
-    }
-    return __r;
+valarray<_Tp> valarray<_Tp>::apply(value_type __f(const value_type&)) const {
+  valarray<value_type> __r;
+  size_t __n = size();
+  if (__n) {
+    __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
+    for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
+      ::new ((void*)__r.__end_) value_type(__f(*__p));
+  }
+  return __r;
 }
 
 template <class _Tp>
-inline
-void valarray<_Tp>::__clear(size_t __capacity)
-{
-  if (__begin_ != nullptr)
-  {
+inline void valarray<_Tp>::__clear(size_t __capacity) {
+  if (__begin_ != nullptr) {
     while (__end_ != __begin_)
       (--__end_)->~value_type();
     allocator<value_type>().deallocate(__begin_, __capacity);
@@ -3757,1184 +2552,719 @@ void valarray<_Tp>::__clear(size_t __capacity)
 }
 
 template <class _Tp>
-void
-valarray<_Tp>::resize(size_t __n, value_type __x)
-{
-    __clear(size());
-    if (__n)
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__n);
+void valarray<_Tp>::resize(size_t __n, value_type __x) {
+  __clear(size());
+  if (__n) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__n);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
-                ::new ((void*)__end_) value_type(__x);
+      for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
+        ::new ((void*)__end_) value_type(__x);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__n);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__n);
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT
-{
-    __x.swap(__y);
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI void swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT {
+  __x.swap(__y);
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<multiplies<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator*(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<multiplies<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    operator*(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<multiplies<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    operator*(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<multiplies<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(multiplies<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<divides<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator/(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<divides<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(divides<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<divides<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    operator/(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<divides<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(divides<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<divides<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    operator/(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<divides<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(divides<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<modulus<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator%(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<modulus<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<modulus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    operator%(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<modulus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<modulus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    operator%(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<modulus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(modulus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<plus<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator+(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<plus<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(plus<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<plus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    operator+(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<plus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(plus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<plus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    operator+(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<plus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(plus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<minus<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator-(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<minus<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(minus<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<minus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    operator-(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<minus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(minus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<minus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    operator-(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<minus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(minus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<bit_xor<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator^(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<bit_xor<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    operator^(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<bit_xor<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    operator^(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<bit_xor<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(bit_xor<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<bit_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator&(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<bit_and<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    operator&(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<bit_and<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    operator&(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<bit_and<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(bit_and<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<bit_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator|(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<bit_or<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    operator|(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<bit_or<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    operator|(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<bit_or<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(bit_or<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__bit_shift_left<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator<<(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<__bit_shift_left<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<
+    _BinaryOp<__bit_shift_left<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator<<(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<__bit_shift_left<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<
+    _BinaryOp<__bit_shift_left<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator<<(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<__bit_shift_left<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__bit_shift_right<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator>>(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<__bit_shift_right<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<
+    _BinaryOp<__bit_shift_right<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator>>(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<__bit_shift_right<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<
+    _BinaryOp<__bit_shift_right<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator>>(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<__bit_shift_right<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<logical_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator&&(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<logical_and<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    operator&&(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<logical_and<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    operator&&(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<logical_and<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(logical_and<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<logical_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator||(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<logical_or<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    operator||(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<logical_or<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    operator||(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<logical_or<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(logical_or<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator==(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<equal_to<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    operator==(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    operator==(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(equal_to<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<not_equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator!=(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<not_equal_to<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    operator!=(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<not_equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    operator!=(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<not_equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<less<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator<(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<less<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(less<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<less<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    operator<(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<less<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(less<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<less<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    operator<(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<less<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(less<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<greater<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator>(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<greater<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(greater<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<greater<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    operator>(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<greater<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(greater<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<greater<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    operator>(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<greater<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(greater<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<less_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator<=(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<less_equal<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    operator<=(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<less_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    operator<=(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<less_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(less_equal<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<greater_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator>=(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<greater_equal<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    operator>=(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<greater_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    operator>=(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<greater_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(greater_equal<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> >
+abs(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__abs_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__abs_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> >
+acos(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__acos_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__acos_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> >
+asin(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__asin_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__asin_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> >
+atan(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__atan_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__atan_expr<value_type>(), __x));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
+atan2(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<__atan2_expr<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    atan2(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<__atan2_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    atan2(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<__atan2_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> >
+cos(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__cos_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__cos_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> >
+cosh(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__cosh_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__cosh_expr<value_type>(), __x));
 }
 
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<multiplies<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator*(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<multiplies<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator*(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<multiplies<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(multiplies<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator*(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<multiplies<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(multiplies<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<divides<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator/(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<divides<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(divides<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<divides<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator/(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<divides<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(divides<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<divides<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator/(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<divides<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(divides<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<modulus<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator%(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<modulus<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<modulus<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator%(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<modulus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(modulus<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<modulus<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator%(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<modulus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(modulus<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<plus<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator+(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<plus<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(plus<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<plus<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator+(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<plus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(plus<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<plus<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator+(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<plus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(plus<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<minus<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator-(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<minus<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(minus<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<minus<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator-(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<minus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(minus<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<minus<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator-(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<minus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(minus<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<bit_xor<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator^(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<bit_xor<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator^(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<bit_xor<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(bit_xor<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator^(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<bit_xor<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(bit_xor<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<bit_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator&(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<bit_and<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator&(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<bit_and<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(bit_and<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator&(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<bit_and<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(bit_and<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<bit_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator|(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<bit_or<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator|(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<bit_or<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(bit_or<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator|(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<bit_or<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(bit_or<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<__bit_shift_left<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator<<(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<__bit_shift_left<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator<<(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<__bit_shift_left<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator<<(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<__bit_shift_left<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<__bit_shift_right<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator>>(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<__bit_shift_right<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator>>(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<__bit_shift_right<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator>>(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<__bit_shift_right<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<logical_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator&&(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<logical_and<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator&&(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<logical_and<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(logical_and<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator&&(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<logical_and<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(logical_and<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<logical_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator||(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<logical_or<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator||(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<logical_or<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(logical_or<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator||(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<logical_or<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(logical_or<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator==(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<equal_to<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator==(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(equal_to<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator==(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(equal_to<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<not_equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator!=(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<not_equal_to<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator!=(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<not_equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(not_equal_to<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator!=(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<not_equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(not_equal_to<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<less<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator<(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<less<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(less<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<less<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator<(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<less<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(less<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<less<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator<(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<less<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(less<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<greater<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator>(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<greater<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(greater<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<greater<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator>(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<greater<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(greater<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<greater<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator>(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<greater<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(greater<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<less_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator<=(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<less_equal<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator<=(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<less_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(less_equal<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator<=(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<less_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(less_equal<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<greater_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator>=(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<greater_equal<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator>=(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<greater_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(greater_equal<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator>=(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<greater_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(greater_equal<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> >
->::type
-abs(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__abs_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__abs_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> >
->::type
-acos(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__acos_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__acos_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> >
->::type
-asin(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__asin_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__asin_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> >
->::type
-atan(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__atan_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__atan_expr<value_type>(), __x));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-atan2(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<__atan2_expr<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-atan2(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<__atan2_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(__atan2_expr<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-atan2(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<__atan2_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__atan2_expr<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> >
->::type
-cos(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__cos_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__cos_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> >
->::type
-cosh(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__cosh_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__cosh_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> >
->::type
-exp(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__exp_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__exp_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> >
->::type
-log(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__log_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__log_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> >
->::type
-log10(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__log10_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__log10_expr<value_type>(), __x));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-pow(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<__pow_expr<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-pow(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<__pow_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(__pow_expr<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-pow(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<__pow_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__pow_expr<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> >
->::type
-sin(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__sin_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__sin_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> >
->::type
-sinh(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__sinh_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__sinh_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> >
->::type
-sqrt(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__sqrt_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__sqrt_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> >
->::type
-tan(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__tan_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__tan_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> >
->::type
-tanh(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__tanh_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__tanh_expr<value_type>(), __x));
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> >
+exp(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__exp_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__exp_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> >
+log(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__log_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__log_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> >
+log10(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__log10_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__log10_expr<value_type>(), __x));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
+pow(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<__pow_expr<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+    pow(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<__pow_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+    __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+    pow(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<__pow_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> >
+sin(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__sin_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__sin_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> >
+sinh(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__sinh_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__sinh_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> >
+sqrt(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__sqrt_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__sqrt_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> >
+tan(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__tan_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__tan_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> >
+tanh(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__tanh_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__tanh_expr<value_type>(), __x));
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_Tp*
-begin(valarray<_Tp>& __v)
-{
-    return __v.__begin_;
+inline _LIBCPP_HIDE_FROM_ABI _Tp* begin(valarray<_Tp>& __v) {
+  return __v.__begin_;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-const _Tp*
-begin(const valarray<_Tp>& __v)
-{
-    return __v.__begin_;
+inline _LIBCPP_HIDE_FROM_ABI const _Tp* begin(const valarray<_Tp>& __v) {
+  return __v.__begin_;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_Tp*
-end(valarray<_Tp>& __v)
-{
-    return __v.__end_;
+inline _LIBCPP_HIDE_FROM_ABI _Tp* end(valarray<_Tp>& __v) {
+  return __v.__end_;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-const _Tp*
-end(const valarray<_Tp>& __v)
-{
-    return __v.__end_;
+inline _LIBCPP_HIDE_FROM_ABI const _Tp* end(const valarray<_Tp>& __v) {
+  return __v.__end_;
 }
 
 _LIBCPP_END_NAMESPACE_STD