cmath

// cmath standard header

// Copyright (c) Microsoft Corporation.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

#pragma once
#ifndef _CMATH_
#define _CMATH_
#include <yvals.h>
#if _STL_COMPILER_PREPROCESSOR

#include <cstdlib>
#include <xtr1common>

#if _HAS_CXX20
#include <xutility>
#endif // _HAS_CXX20

#pragma pack(push, _CRT_PACKING)
#pragma warning(push, _STL_WARNING_LEVEL)
#pragma warning(disable : _STL_DISABLED_WARNINGS)
_STL_DISABLE_CLANG_WARNINGS
#pragma push_macro("new")
#undef new

_NODISCARD _Check_return_ inline float acos(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD acosf(_Xx);
}

_NODISCARD _Check_return_ inline float acosh(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD acoshf(_Xx);
}

_NODISCARD _Check_return_ inline float asin(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD asinf(_Xx);
}

_NODISCARD _Check_return_ inline float asinh(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD asinhf(_Xx);
}

_NODISCARD _Check_return_ inline float atan(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD atanf(_Xx);
}

_NODISCARD _Check_return_ inline float atanh(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD atanhf(_Xx);
}

_NODISCARD _Check_return_ inline float atan2(_In_ float _Yx, _In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD atan2f(_Yx, _Xx);
}

_NODISCARD _Check_return_ inline float cbrt(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD cbrtf(_Xx);
}

_NODISCARD _Check_return_ inline float ceil(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD ceilf(_Xx);
}

_NODISCARD _Check_return_ inline float copysign(_In_ float _Number, _In_ float _Sign) noexcept /* strengthened */ {
    return _CSTD copysignf(_Number, _Sign);
}

_NODISCARD _Check_return_ inline float cos(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD cosf(_Xx);
}

_NODISCARD _Check_return_ inline float cosh(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD coshf(_Xx);
}

_NODISCARD _Check_return_ inline float erf(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD erff(_Xx);
}

_NODISCARD _Check_return_ inline float erfc(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD erfcf(_Xx);
}

_NODISCARD _Check_return_ inline float exp(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD expf(_Xx);
}

_NODISCARD _Check_return_ inline float exp2(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD exp2f(_Xx);
}

_NODISCARD _Check_return_ inline float expm1(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD expm1f(_Xx);
}

_NODISCARD _Check_return_ inline float fabs(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD fabsf(_Xx);
}

_NODISCARD _Check_return_ inline float fdim(_In_ float _Xx, _In_ float _Yx) noexcept /* strengthened */ {
    return _CSTD fdimf(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline float floor(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD floorf(_Xx);
}

_NODISCARD _Check_return_ inline float fma(_In_ float _Xx, _In_ float _Yx, _In_ float _Zx) noexcept /* strengthened */ {
    return _CSTD fmaf(_Xx, _Yx, _Zx);
}

_NODISCARD _Check_return_ inline float fmax(_In_ float _Xx, _In_ float _Yx) noexcept /* strengthened */ {
    return _CSTD fmaxf(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline float fmin(_In_ float _Xx, _In_ float _Yx) noexcept /* strengthened */ {
    return _CSTD fminf(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline float fmod(_In_ float _Xx, _In_ float _Yx) noexcept /* strengthened */ {
    return _CSTD fmodf(_Xx, _Yx);
}

inline float frexp(_In_ float _Xx, _Out_ int* _Yx) noexcept /* strengthened */ {
    return _CSTD frexpf(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline float hypot(_In_ float _Xx, _In_ float _Yx) noexcept /* strengthened */ {
    return _CSTD hypotf(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline int ilogb(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD ilogbf(_Xx);
}

_NODISCARD _Check_return_ inline float ldexp(_In_ float _Xx, _In_ int _Yx) noexcept /* strengthened */ {
    return _CSTD ldexpf(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline float lgamma(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD lgammaf(_Xx);
}

_NODISCARD _Check_return_ inline long long llrint(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD llrintf(_Xx);
}

_NODISCARD _Check_return_ inline long long llround(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD llroundf(_Xx);
}

_NODISCARD _Check_return_ inline float log(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD logf(_Xx);
}

_NODISCARD _Check_return_ inline float log10(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD log10f(_Xx);
}

_NODISCARD _Check_return_ inline float log1p(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD log1pf(_Xx);
}

_NODISCARD _Check_return_ inline float log2(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD log2f(_Xx);
}

_NODISCARD _Check_return_ inline float logb(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD logbf(_Xx);
}

_NODISCARD _Check_return_ inline long lrint(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD lrintf(_Xx);
}

_NODISCARD _Check_return_ inline long lround(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD lroundf(_Xx);
}

inline float modf(_In_ float _Xx, _Out_ float* _Yx) noexcept /* strengthened */ {
    return _CSTD modff(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline float nearbyint(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD nearbyintf(_Xx);
}

_NODISCARD _Check_return_ inline float nextafter(_In_ float _Xx, _In_ float _Yx) noexcept /* strengthened */ {
    return _CSTD nextafterf(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline float nexttoward(_In_ float _Xx, _In_ long double _Yx) noexcept /* strengthened */ {
    return _CSTD nexttowardf(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline float pow(_In_ float _Xx, _In_ float _Yx) noexcept /* strengthened */ {
    return _CSTD powf(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline float remainder(_In_ float _Xx, _In_ float _Yx) noexcept /* strengthened */ {
    return _CSTD remainderf(_Xx, _Yx);
}

inline float remquo(_In_ float _Xx, _In_ float _Yx, _Out_ int* _Zx) noexcept /* strengthened */ {
    return _CSTD remquof(_Xx, _Yx, _Zx);
}

_NODISCARD _Check_return_ inline float rint(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD rintf(_Xx);
}

_NODISCARD _Check_return_ inline float round(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD roundf(_Xx);
}

_NODISCARD _Check_return_ inline float scalbln(_In_ float _Xx, _In_ long _Yx) noexcept /* strengthened */ {
    return _CSTD scalblnf(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline float scalbn(_In_ float _Xx, _In_ int _Yx) noexcept /* strengthened */ {
    return _CSTD scalbnf(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline float sin(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD sinf(_Xx);
}

_NODISCARD _Check_return_ inline float sinh(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD sinhf(_Xx);
}

_NODISCARD _Check_return_ inline float sqrt(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD sqrtf(_Xx);
}

_NODISCARD _Check_return_ inline float tan(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD tanf(_Xx);
}

_NODISCARD _Check_return_ inline float tanh(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD tanhf(_Xx);
}

_NODISCARD _Check_return_ inline float tgamma(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD tgammaf(_Xx);
}

_NODISCARD _Check_return_ inline float trunc(_In_ float _Xx) noexcept /* strengthened */ {
    return _CSTD truncf(_Xx);
}

_NODISCARD _Check_return_ inline long double acos(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD acosl(_Xx);
}

_NODISCARD _Check_return_ inline long double acosh(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD acoshl(_Xx);
}

_NODISCARD _Check_return_ inline long double asin(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD asinl(_Xx);
}

_NODISCARD _Check_return_ inline long double asinh(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD asinhl(_Xx);
}

_NODISCARD _Check_return_ inline long double atan(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD atanl(_Xx);
}

_NODISCARD _Check_return_ inline long double atanh(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD atanhl(_Xx);
}

_NODISCARD _Check_return_ inline long double atan2(_In_ long double _Yx, _In_ long double _Xx) noexcept
/* strengthened */ {
    return _CSTD atan2l(_Yx, _Xx);
}

_NODISCARD _Check_return_ inline long double cbrt(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD cbrtl(_Xx);
}

_NODISCARD _Check_return_ inline long double ceil(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD ceill(_Xx);
}

_NODISCARD _Check_return_ inline long double copysign(_In_ long double _Number, _In_ long double _Sign) noexcept
/* strengthened */ {
    return _CSTD copysignl(_Number, _Sign);
}

_NODISCARD _Check_return_ inline long double cos(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD cosl(_Xx);
}

_NODISCARD _Check_return_ inline long double cosh(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD coshl(_Xx);
}

_NODISCARD _Check_return_ inline long double erf(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD erfl(_Xx);
}

_NODISCARD _Check_return_ inline long double erfc(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD erfcl(_Xx);
}

_NODISCARD _Check_return_ inline long double exp(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD expl(_Xx);
}

_NODISCARD _Check_return_ inline long double exp2(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD exp2l(_Xx);
}

_NODISCARD _Check_return_ inline long double expm1(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD expm1l(_Xx);
}

_NODISCARD _Check_return_ inline long double fabs(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD fabsl(_Xx);
}

_NODISCARD _Check_return_ inline long double fdim(_In_ long double _Xx, _In_ long double _Yx) noexcept
/* strengthened */ {
    return _CSTD fdiml(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline long double floor(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD floorl(_Xx);
}

_NODISCARD _Check_return_ inline long double fma(
    _In_ long double _Xx, _In_ long double _Yx, _In_ long double _Zx) noexcept /* strengthened */ {
    return _CSTD fmal(_Xx, _Yx, _Zx);
}

_NODISCARD _Check_return_ inline long double fmax(_In_ long double _Xx, _In_ long double _Yx) noexcept
/* strengthened */ {
    return _CSTD fmaxl(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline long double fmin(_In_ long double _Xx, _In_ long double _Yx) noexcept
/* strengthened */ {
    return _CSTD fminl(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline long double fmod(_In_ long double _Xx, _In_ long double _Yx) noexcept
/* strengthened */ {
    return _CSTD fmodl(_Xx, _Yx);
}

inline long double frexp(_In_ long double _Xx, _Out_ int* _Yx) noexcept /* strengthened */ {
    return _CSTD frexpl(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline long double hypot(_In_ long double _Xx, _In_ long double _Yx) noexcept
/* strengthened */ {
    return _CSTD hypotl(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline int ilogb(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD ilogbl(_Xx);
}

_NODISCARD _Check_return_ inline long double ldexp(_In_ long double _Xx, _In_ int _Yx) noexcept /* strengthened */ {
    return _CSTD ldexpl(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline long double lgamma(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD lgammal(_Xx);
}

_NODISCARD _Check_return_ inline long long llrint(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD llrintl(_Xx);
}

_NODISCARD _Check_return_ inline long long llround(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD llroundl(_Xx);
}

_NODISCARD _Check_return_ inline long double log(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD logl(_Xx);
}

_NODISCARD _Check_return_ inline long double log10(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD log10l(_Xx);
}

_NODISCARD _Check_return_ inline long double log1p(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD log1pl(_Xx);
}

_NODISCARD _Check_return_ inline long double log2(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD log2l(_Xx);
}

_NODISCARD _Check_return_ inline long double logb(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD logbl(_Xx);
}

_NODISCARD _Check_return_ inline long lrint(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD lrintl(_Xx);
}

_NODISCARD _Check_return_ inline long lround(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD lroundl(_Xx);
}

inline long double modf(_In_ long double _Xx, _Out_ long double* _Yx) noexcept /* strengthened */ {
    return _CSTD modfl(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline long double nearbyint(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD nearbyintl(_Xx);
}

_NODISCARD _Check_return_ inline long double nextafter(_In_ long double _Xx, _In_ long double _Yx) noexcept
/* strengthened */ {
    return _CSTD nextafterl(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline long double nexttoward(_In_ long double _Xx, _In_ long double _Yx) noexcept
/* strengthened */ {
    return _CSTD nexttowardl(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline long double pow(_In_ long double _Xx, _In_ long double _Yx) noexcept
/* strengthened */ {
    return _CSTD powl(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline long double remainder(_In_ long double _Xx, _In_ long double _Yx) noexcept
/* strengthened */ {
    return _CSTD remainderl(_Xx, _Yx);
}

inline long double remquo(_In_ long double _Xx, _In_ long double _Yx, _Out_ int* _Zx) noexcept /* strengthened */ {
    return _CSTD remquol(_Xx, _Yx, _Zx);
}

_NODISCARD _Check_return_ inline long double rint(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD rintl(_Xx);
}

_NODISCARD _Check_return_ inline long double round(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD roundl(_Xx);
}

_NODISCARD _Check_return_ inline long double scalbln(_In_ long double _Xx, _In_ long _Yx) noexcept /* strengthened */ {
    return _CSTD scalblnl(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline long double scalbn(_In_ long double _Xx, _In_ int _Yx) noexcept /* strengthened */ {
    return _CSTD scalbnl(_Xx, _Yx);
}

_NODISCARD _Check_return_ inline long double sin(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD sinl(_Xx);
}

_NODISCARD _Check_return_ inline long double sinh(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD sinhl(_Xx);
}

_NODISCARD _Check_return_ inline long double sqrt(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD sqrtl(_Xx);
}

_NODISCARD _Check_return_ inline long double tan(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD tanl(_Xx);
}

_NODISCARD _Check_return_ inline long double tanh(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD tanhl(_Xx);
}

_NODISCARD _Check_return_ inline long double tgamma(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD tgammal(_Xx);
}

_NODISCARD _Check_return_ inline long double trunc(_In_ long double _Xx) noexcept /* strengthened */ {
    return _CSTD truncl(_Xx);
}


_STD_BEGIN
template <class _Ty1, class _Ty2>
using _Common_float_type_t = conditional_t<is_same_v<_Ty1, long double> || is_same_v<_Ty2, long double>, long double,
    conditional_t<is_same_v<_Ty1, float> && is_same_v<_Ty2, float>, float,
        double>>; // find type for two-argument math function
_STD_END

// FUNCTION TEMPLATE frexp
template <class _Ty, _STD enable_if_t<_STD is_integral_v<_Ty>, int> = 0>
double frexp(_Ty _Value, _Out_ int* const _Exp) noexcept /* strengthened */ {
    return _CSTD frexp(static_cast<double>(_Value), _Exp);
}

// FUNCTION TEMPLATE fma
#if !_HAS_IF_CONSTEXPR
inline float _Fma(float _Left, float _Middle, float _Right) noexcept {
    return _CSTD fmaf(_Left, _Middle, _Right);
}

inline double _Fma(double _Left, double _Middle, double _Right) noexcept {
    return _CSTD fma(_Left, _Middle, _Right);
}

inline long double _Fma(long double _Left, long double _Middle, long double _Right) noexcept {
    return _CSTD fmal(_Left, _Middle, _Right);
}
#endif // !_HAS_IF_CONSTEXPR

template <class _Ty1, class _Ty2, class _Ty3,
    _STD enable_if_t<_STD is_arithmetic_v<_Ty1> && _STD is_arithmetic_v<_Ty2> && _STD is_arithmetic_v<_Ty3>, int> = 0>
_NODISCARD _STD _Common_float_type_t<_Ty1, _STD _Common_float_type_t<_Ty2, _Ty3>> fma(
    _Ty1 _Left, _Ty2 _Middle, _Ty3 _Right) noexcept /* strengthened */ {
    using _Common = _STD _Common_float_type_t<_Ty1, _STD _Common_float_type_t<_Ty2, _Ty3>>;
#if _HAS_IF_CONSTEXPR
    if constexpr (_STD is_same_v<_Common, float>) {
        return _CSTD fmaf(static_cast<_Common>(_Left), static_cast<_Common>(_Middle), static_cast<_Common>(_Right));
    } else if constexpr (_STD is_same_v<_Common, double>) {
        return _CSTD fma(static_cast<_Common>(_Left), static_cast<_Common>(_Middle), static_cast<_Common>(_Right));
    } else {
        return _CSTD fmal(static_cast<_Common>(_Left), static_cast<_Common>(_Middle), static_cast<_Common>(_Right));
    }
#else // ^^^ use "if constexpr" dispatch / use overload resolution vvv
    return _Fma(static_cast<_Common>(_Left), static_cast<_Common>(_Middle), static_cast<_Common>(_Right));
#endif // _HAS_IF_CONSTEXPR
}

// FUNCTION TEMPLATE remquo
#if !_HAS_IF_CONSTEXPR
inline float _Remquo(float _Left, float _Right, int* _Pquo) noexcept {
    return _CSTD remquof(_Left, _Right, _Pquo);
}

inline double _Remquo(double _Left, double _Right, int* _Pquo) noexcept {
    return _CSTD remquo(_Left, _Right, _Pquo);
}

inline long double _Remquo(long double _Left, long double _Right, int* _Pquo) noexcept {
    return _CSTD remquol(_Left, _Right, _Pquo);
}
#endif // !_HAS_IF_CONSTEXPR

template <class _Ty1, class _Ty2, _STD enable_if_t<_STD is_arithmetic_v<_Ty1> && _STD is_arithmetic_v<_Ty2>, int> = 0>
_STD _Common_float_type_t<_Ty1, _Ty2> remquo(_Ty1 _Left, _Ty2 _Right, int* _Pquo) noexcept /* strengthened */ {
    using _Common = _STD _Common_float_type_t<_Ty1, _Ty2>;
#if _HAS_IF_CONSTEXPR
    if constexpr (_STD is_same_v<_Common, float>) {
        return _CSTD remquof(static_cast<_Common>(_Left), static_cast<_Common>(_Right), _Pquo);
    } else if constexpr (_STD is_same_v<_Common, double>) {
        return _CSTD remquo(static_cast<_Common>(_Left), static_cast<_Common>(_Right), _Pquo);
    } else {
        return _CSTD remquol(static_cast<_Common>(_Left), static_cast<_Common>(_Right), _Pquo);
    }
#else // ^^^ use "if constexpr" dispatch / use overload resolution vvv
    return _Remquo(static_cast<_Common>(_Left), static_cast<_Common>(_Right), _Pquo);
#endif // _HAS_IF_CONSTEXPR
}

#define _GENERIC_MATH1R(FUN, RET)                                            \
    template <class _Ty, _STD enable_if_t<_STD is_integral_v<_Ty>, int> = 0> \
    _NODISCARD RET FUN(_Ty _Left) noexcept /* strengthened */ {              \
        return _CSTD FUN(static_cast<double>(_Left));                        \
    }

#define _GENERIC_MATH1(FUN) _GENERIC_MATH1R(FUN, double)

#define _GENERIC_MATH1X(FUN, ARG2)                                             \
    template <class _Ty, _STD enable_if_t<_STD is_integral_v<_Ty>, int> = 0>   \
    _NODISCARD double FUN(_Ty _Left, ARG2 _Arg2) noexcept /* strengthened */ { \
        return _CSTD FUN(static_cast<double>(_Left), _Arg2);                   \
    }

#define _GENERIC_MATH2(FUN)                                                                                     \
    template <class _Ty1, class _Ty2,                                                                           \
        _STD enable_if_t<_STD is_arithmetic_v<_Ty1> && _STD is_arithmetic_v<_Ty2>, int> = 0>                    \
    _NODISCARD _STD _Common_float_type_t<_Ty1, _Ty2> FUN(_Ty1 _Left, _Ty2 _Right) noexcept /* strengthened */ { \
        using _Common = _STD _Common_float_type_t<_Ty1, _Ty2>;                                                  \
        return _CSTD FUN(static_cast<_Common>(_Left), static_cast<_Common>(_Right));                            \
    }

// The following order matches N4820 26.8.1 [cmath.syn].
_GENERIC_MATH1(acos)
_GENERIC_MATH1(asin)
_GENERIC_MATH1(atan)
_GENERIC_MATH2(atan2)
_GENERIC_MATH1(cos)
_GENERIC_MATH1(sin)
_GENERIC_MATH1(tan)
_GENERIC_MATH1(acosh)
_GENERIC_MATH1(asinh)
_GENERIC_MATH1(atanh)
_GENERIC_MATH1(cosh)
_GENERIC_MATH1(sinh)
_GENERIC_MATH1(tanh)
_GENERIC_MATH1(exp)
_GENERIC_MATH1(exp2)
_GENERIC_MATH1(expm1)
// frexp() is hand-crafted
_GENERIC_MATH1R(ilogb, int)
_GENERIC_MATH1X(ldexp, int)
_GENERIC_MATH1(log)
_GENERIC_MATH1(log10)
_GENERIC_MATH1(log1p)
_GENERIC_MATH1(log2)
_GENERIC_MATH1(logb)
// No modf(), types must match
_GENERIC_MATH1X(scalbn, int)
_GENERIC_MATH1X(scalbln, long)
_GENERIC_MATH1(cbrt)
// abs() has integer overloads
_GENERIC_MATH1(fabs)
_GENERIC_MATH2(hypot)
// 3-arg hypot() is hand-crafted
_GENERIC_MATH2(pow)
_GENERIC_MATH1(sqrt)
_GENERIC_MATH1(erf)
_GENERIC_MATH1(erfc)
_GENERIC_MATH1(lgamma)
_GENERIC_MATH1(tgamma)
_GENERIC_MATH1(ceil)
_GENERIC_MATH1(floor)
_GENERIC_MATH1(nearbyint)
_GENERIC_MATH1(rint)
_GENERIC_MATH1R(lrint, long)
_GENERIC_MATH1R(llrint, long long)
_GENERIC_MATH1(round)
_GENERIC_MATH1R(lround, long)
_GENERIC_MATH1R(llround, long long)
_GENERIC_MATH1(trunc)
_GENERIC_MATH2(fmod)
_GENERIC_MATH2(remainder)
// remquo() is hand-crafted
_GENERIC_MATH2(copysign)
// nan(const char*) is exempt
_GENERIC_MATH2(nextafter)
_GENERIC_MATH1X(nexttoward, long double)
_GENERIC_MATH2(fdim)
_GENERIC_MATH2(fmax)
_GENERIC_MATH2(fmin)
// fma() is hand-crafted
// lerp() should be exempt, LWG-3223
// The "classification/comparison functions" (fpclassify(), etc.) are exempt, LWG-1327
// TRANSITION, VSO-945789, Special Math shouldn't be exempt

#undef _GENERIC_MATH1R
#undef _GENERIC_MATH1
#undef _GENERIC_MATH1X
#undef _GENERIC_MATH2


_STD_BEGIN
using _CSTD abs;
using _CSTD acos;
using _CSTD asin;
using _CSTD atan;
using _CSTD atan2;
using _CSTD ceil;
using _CSTD cos;
using _CSTD cosh;
using _CSTD exp;
using _CSTD fabs;
using _CSTD floor;
using _CSTD fmod;
using _CSTD frexp;
using _CSTD ldexp;
using _CSTD log;
using _CSTD log10;
using _CSTD modf;
using _CSTD pow;
using _CSTD sin;
using _CSTD sinh;
using _CSTD sqrt;
using _CSTD tan;
using _CSTD tanh;

using _CSTD acosf;
using _CSTD asinf;
using _CSTD atanf;
using _CSTD atan2f;
using _CSTD ceilf;
using _CSTD cosf;
using _CSTD coshf;
using _CSTD expf;
using _CSTD fabsf;
using _CSTD floorf;
using _CSTD fmodf;
using _CSTD frexpf;
using _CSTD ldexpf;
using _CSTD logf;
using _CSTD log10f;
using _CSTD modff;
using _CSTD powf;
using _CSTD sinf;
using _CSTD sinhf;
using _CSTD sqrtf;
using _CSTD tanf;
using _CSTD tanhf;

using _CSTD acosl;
using _CSTD asinl;
using _CSTD atanl;
using _CSTD atan2l;
using _CSTD ceill;
using _CSTD cosl;
using _CSTD coshl;
using _CSTD expl;
using _CSTD fabsl;
using _CSTD floorl;
using _CSTD fmodl;
using _CSTD frexpl;
using _CSTD ldexpl;
using _CSTD logl;
using _CSTD log10l;
using _CSTD modfl;
using _CSTD powl;
using _CSTD sinl;
using _CSTD sinhl;
using _CSTD sqrtl;
using _CSTD tanl;
using _CSTD tanhl;

using _CSTD float_t;
using _CSTD double_t;

using _CSTD acosh;
using _CSTD asinh;
using _CSTD atanh;
using _CSTD cbrt;
using _CSTD erf;
using _CSTD erfc;
using _CSTD expm1;
using _CSTD exp2;
using _CSTD hypot;
using _CSTD ilogb;
using _CSTD lgamma;
using _CSTD log1p;
using _CSTD log2;
using _CSTD logb;
using _CSTD llrint;
using _CSTD lrint;
using _CSTD nearbyint;
using _CSTD rint;
using _CSTD llround;
using _CSTD lround;
using _CSTD fdim;
using _CSTD fma;
using _CSTD fmax;
using _CSTD fmin;
using _CSTD round;
using _CSTD trunc;
using _CSTD remainder;
using _CSTD remquo;
using _CSTD copysign;
using _CSTD nan;
using _CSTD nextafter;
using _CSTD scalbn;
using _CSTD scalbln;
using _CSTD nexttoward;
using _CSTD tgamma;

using _CSTD acoshf;
using _CSTD asinhf;
using _CSTD atanhf;
using _CSTD cbrtf;
using _CSTD erff;
using _CSTD erfcf;
using _CSTD expm1f;
using _CSTD exp2f;
using _CSTD hypotf;
using _CSTD ilogbf;
using _CSTD lgammaf;
using _CSTD log1pf;
using _CSTD log2f;
using _CSTD logbf;
using _CSTD llrintf;
using _CSTD lrintf;
using _CSTD nearbyintf;
using _CSTD rintf;
using _CSTD llroundf;
using _CSTD lroundf;
using _CSTD fdimf;
using _CSTD fmaf;
using _CSTD fmaxf;
using _CSTD fminf;
using _CSTD roundf;
using _CSTD truncf;
using _CSTD remainderf;
using _CSTD remquof;
using _CSTD copysignf;
using _CSTD nanf;
using _CSTD nextafterf;
using _CSTD scalbnf;
using _CSTD scalblnf;
using _CSTD nexttowardf;
using _CSTD tgammaf;

using _CSTD acoshl;
using _CSTD asinhl;
using _CSTD atanhl;
using _CSTD cbrtl;
using _CSTD erfl;
using _CSTD erfcl;
using _CSTD expm1l;
using _CSTD exp2l;
using _CSTD hypotl;
using _CSTD ilogbl;
using _CSTD lgammal;
using _CSTD log1pl;
using _CSTD log2l;
using _CSTD logbl;
using _CSTD llrintl;
using _CSTD lrintl;
using _CSTD nearbyintl;
using _CSTD rintl;
using _CSTD llroundl;
using _CSTD lroundl;
using _CSTD fdiml;
using _CSTD fmal;
using _CSTD fmaxl;
using _CSTD fminl;
using _CSTD roundl;
using _CSTD truncl;
using _CSTD remainderl;
using _CSTD remquol;
using _CSTD copysignl;
using _CSTD nanl;
using _CSTD nextafterl;
using _CSTD scalbnl;
using _CSTD scalblnl;
using _CSTD nexttowardl;
using _CSTD tgammal;

using _CSTD fpclassify;
using _CSTD signbit;
using _CSTD isfinite;
using _CSTD isinf;
using _CSTD isnan;
using _CSTD isnormal;
using _CSTD isgreater;
using _CSTD isgreaterequal;
using _CSTD isless;
using _CSTD islessequal;
using _CSTD islessgreater;
using _CSTD isunordered;
_STD_END

#if _HAS_CXX17
_EXTERN_C
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_assoc_laguerre(unsigned int, unsigned int, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_assoc_laguerref(unsigned int, unsigned int, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_assoc_legendre(unsigned int, unsigned int, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_assoc_legendref(unsigned int, unsigned int, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_beta(double, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_betaf(float, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_comp_ellint_1(double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_comp_ellint_1f(float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_comp_ellint_2(double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_comp_ellint_2f(float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_comp_ellint_3(double, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_comp_ellint_3f(float, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_cyl_bessel_i(double, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_cyl_bessel_if(float, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_cyl_bessel_j(double, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_cyl_bessel_jf(float, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_cyl_bessel_k(double, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_cyl_bessel_kf(float, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_cyl_neumann(double, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_cyl_neumannf(float, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_ellint_1(double, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_ellint_1f(float, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_ellint_2(double, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_ellint_2f(float, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_ellint_3(double, double, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_ellint_3f(float, float, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_expint(double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_expintf(float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_hermite(unsigned int, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_hermitef(unsigned int, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_laguerre(unsigned int, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_laguerref(unsigned int, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_legendre(unsigned int, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_legendref(unsigned int, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_riemann_zeta(double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_riemann_zetaf(float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_sph_bessel(unsigned int, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_sph_besself(unsigned int, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_sph_legendre(unsigned int, unsigned int, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_sph_legendref(unsigned int, unsigned int, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_sph_neumann(unsigned int, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_sph_neumannf(unsigned int, float) noexcept;
_CRT_SATELLITE_2 _NODISCARD double __stdcall __std_smf_hypot3(double, double, double) noexcept;
_CRT_SATELLITE_2 _NODISCARD float __stdcall __std_smf_hypot3f(float, float, float) noexcept;
_END_EXTERN_C

_STD_BEGIN
// FUNCTION assoc_laguerre
_NODISCARD inline double assoc_laguerre(const unsigned int _Degree, const unsigned int _Order, const double _Value) {
    return __std_smf_assoc_laguerre(_Degree, _Order, _Value);
}

// FUNCTION assoc_laguerref
_NODISCARD inline float assoc_laguerref(const unsigned int _Degree, const unsigned int _Order, const float _Value) {
    return __std_smf_assoc_laguerref(_Degree, _Order, _Value);
}

// FUNCTION assoc_laguerrel
_NODISCARD inline long double assoc_laguerrel(
    const unsigned int _Degree, const unsigned int _Order, const long double _Value) {
    return __std_smf_assoc_laguerre(_Degree, _Order, static_cast<double>(_Value));
}

// FUNCTION assoc_legendre
_NODISCARD inline double assoc_legendre(const unsigned int _Degree, const unsigned int _Order, const double _Value) {
    return __std_smf_assoc_legendre(_Degree, _Order, _Value);
}

// FUNCTION assoc_legendref
_NODISCARD inline float assoc_legendref(const unsigned int _Degree, const unsigned int _Order, const float _Value) {
    return __std_smf_assoc_legendref(_Degree, _Order, _Value);
}

// FUNCTION assoc_legendrel
_NODISCARD inline long double assoc_legendrel(
    const unsigned int _Degree, const unsigned int _Order, const long double _Value) {
    return __std_smf_assoc_legendre(_Degree, _Order, static_cast<double>(_Value));
}

// FUNCTION beta
_NODISCARD inline double beta(const double _Arg1, const double _Arg2) {
    return __std_smf_beta(_Arg1, _Arg2);
}

// FUNCTION betaf
_NODISCARD inline float betaf(const float _Arg1, const float _Arg2) {
    return __std_smf_betaf(_Arg1, _Arg2);
}

// FUNCTION betal
_NODISCARD inline long double betal(const long double _Arg1, const long double _Arg2) {
    return __std_smf_beta(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

// FUNCTION comp_ellint_1
_NODISCARD inline double comp_ellint_1(const double _Arg) {
    return __std_smf_comp_ellint_1(_Arg);
}

// FUNCTION comp_ellint_1f
_NODISCARD inline float comp_ellint_1f(const float _Arg) {
    return __std_smf_comp_ellint_1f(_Arg);
}

// FUNCTION comp_ellint_1l
_NODISCARD inline long double comp_ellint_1l(const long double _Arg) {
    return __std_smf_comp_ellint_1(static_cast<double>(_Arg));
}

// FUNCTION comp_ellint_2
_NODISCARD inline double comp_ellint_2(const double _Arg) {
    return __std_smf_comp_ellint_2(_Arg);
}

// FUNCTION comp_ellint_2f
_NODISCARD inline float comp_ellint_2f(const float _Arg) {
    return __std_smf_comp_ellint_2f(_Arg);
}

// FUNCTION comp_ellint_2l
_NODISCARD inline long double comp_ellint_2l(const long double _Arg) {
    return __std_smf_comp_ellint_2(static_cast<double>(_Arg));
}

// FUNCTION comp_ellint_3
_NODISCARD inline double comp_ellint_3(const double _Arg1, const double _Arg2) {
    return __std_smf_comp_ellint_3(_Arg1, _Arg2);
}

// FUNCTION comp_ellint_3f
_NODISCARD inline float comp_ellint_3f(const float _Arg1, const float _Arg2) {
    return __std_smf_comp_ellint_3f(_Arg1, _Arg2);
}

// FUNCTION comp_ellint_3l
_NODISCARD inline long double comp_ellint_3l(const long double _Arg1, const long double _Arg2) {
    return __std_smf_comp_ellint_3(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

// FUNCTION cyl_bessel_i
_NODISCARD inline double cyl_bessel_i(const double _Arg1, const double _Arg2) {
    return __std_smf_cyl_bessel_i(_Arg1, _Arg2);
}

// FUNCTION cyl_bessel_if
_NODISCARD inline float cyl_bessel_if(const float _Arg1, const float _Arg2) {
    return __std_smf_cyl_bessel_if(_Arg1, _Arg2);
}

// FUNCTION cyl_bessel_il
_NODISCARD inline long double cyl_bessel_il(const long double _Arg1, const long double _Arg2) {
    return __std_smf_cyl_bessel_i(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

// FUNCTION cyl_bessel_j
_NODISCARD inline double cyl_bessel_j(const double _Arg1, const double _Arg2) {
    return __std_smf_cyl_bessel_j(_Arg1, _Arg2);
}

// FUNCTION cyl_bessel_jf
_NODISCARD inline float cyl_bessel_jf(const float _Arg1, const float _Arg2) {
    return __std_smf_cyl_bessel_jf(_Arg1, _Arg2);
}

// FUNCTION cyl_bessel_jl
_NODISCARD inline long double cyl_bessel_jl(const long double _Arg1, const long double _Arg2) {
    return __std_smf_cyl_bessel_j(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

// FUNCTION cyl_bessel_k
_NODISCARD inline double cyl_bessel_k(const double _Arg1, const double _Arg2) {
    return __std_smf_cyl_bessel_k(_Arg1, _Arg2);
}

// FUNCTION cyl_bessel_kf
_NODISCARD inline float cyl_bessel_kf(const float _Arg1, const float _Arg2) {
    return __std_smf_cyl_bessel_kf(_Arg1, _Arg2);
}

// FUNCTION cyl_bessel_kl
_NODISCARD inline long double cyl_bessel_kl(const long double _Arg1, const long double _Arg2) {
    return __std_smf_cyl_bessel_k(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

// FUNCTION cyl_neumann
_NODISCARD inline double cyl_neumann(const double _Arg1, const double _Arg2) {
    return __std_smf_cyl_neumann(_Arg1, _Arg2);
}

// FUNCTION cyl_neumannf
_NODISCARD inline float cyl_neumannf(const float _Arg1, const float _Arg2) {
    return __std_smf_cyl_neumannf(_Arg1, _Arg2);
}

// FUNCTION cyl_neumannl
_NODISCARD inline long double cyl_neumannl(const long double _Arg1, const long double _Arg2) {
    return __std_smf_cyl_neumann(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

// FUNCTION ellint_1
_NODISCARD inline double ellint_1(const double _Arg1, const double _Arg2) {
    return __std_smf_ellint_1(_Arg1, _Arg2);
}

// FUNCTION ellint_1f
_NODISCARD inline float ellint_1f(const float _Arg1, const float _Arg2) {
    return __std_smf_ellint_1f(_Arg1, _Arg2);
}

// FUNCTION ellint_1l
_NODISCARD inline long double ellint_1l(const long double _Arg1, const long double _Arg2) {
    return __std_smf_ellint_1(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

// FUNCTION ellint_2
_NODISCARD inline double ellint_2(const double _Arg1, const double _Arg2) {
    return __std_smf_ellint_2(_Arg1, _Arg2);
}

// FUNCTION ellint_2f
_NODISCARD inline float ellint_2f(const float _Arg1, const float _Arg2) {
    return __std_smf_ellint_2f(_Arg1, _Arg2);
}

// FUNCTION ellint_2l
_NODISCARD inline long double ellint_2l(const long double _Arg1, const long double _Arg2) {
    return __std_smf_ellint_2(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

// FUNCTION ellint_3
_NODISCARD inline double ellint_3(const double _Arg1, const double _Arg2, const double _Arg3) {
    return __std_smf_ellint_3(_Arg1, _Arg2, _Arg3);
}

// FUNCTION ellint_3f
_NODISCARD inline float ellint_3f(const float _Arg1, const float _Arg2, const float _Arg3) {
    return __std_smf_ellint_3f(_Arg1, _Arg2, _Arg3);
}

// FUNCTION ellint_3l
_NODISCARD inline long double ellint_3l(const long double _Arg1, const long double _Arg2, const long double _Arg3) {
    return __std_smf_ellint_3(static_cast<double>(_Arg1), static_cast<double>(_Arg2), static_cast<double>(_Arg3));
}

// FUNCTION expint
_NODISCARD inline double expint(const double _Arg) {
    return __std_smf_expint(_Arg);
}

// FUNCTION expintf
_NODISCARD inline float expintf(const float _Arg) {
    return __std_smf_expintf(_Arg);
}

// FUNCTION expintl
_NODISCARD inline long double expintl(const long double _Arg) {
    return __std_smf_expint(static_cast<double>(_Arg));
}

// FUNCTION hermite
_NODISCARD inline double hermite(const unsigned int _Arg1, const double _Arg2) {
    return __std_smf_hermite(_Arg1, _Arg2);
}

// FUNCTION hermitef
_NODISCARD inline float hermitef(const unsigned int _Arg1, const float _Arg2) {
    return __std_smf_hermitef(_Arg1, _Arg2);
}

// FUNCTION hermitel
_NODISCARD inline long double hermitel(const unsigned int _Arg1, const long double _Arg2) {
    return __std_smf_hermite(_Arg1, static_cast<double>(_Arg2));
}

// FUNCTION laguerre
_NODISCARD inline double laguerre(const unsigned int _Arg1, const double _Arg2) {
    return __std_smf_laguerre(_Arg1, _Arg2);
}

// FUNCTION laguerref
_NODISCARD inline float laguerref(const unsigned int _Arg1, const float _Arg2) {
    return __std_smf_laguerref(_Arg1, _Arg2);
}

// FUNCTION laguerrel
_NODISCARD inline long double laguerrel(const unsigned int _Arg1, const long double _Arg2) {
    return __std_smf_laguerre(_Arg1, static_cast<double>(_Arg2));
}

// FUNCTION legendre
_NODISCARD inline double legendre(const unsigned int _Degree, const double _Value) {
    return __std_smf_legendre(_Degree, _Value);
}

// FUNCTION legendref
_NODISCARD inline float legendref(const unsigned int _Degree, const float _Value) {
    return __std_smf_legendref(_Degree, _Value);
}

// FUNCTION legendrel
_NODISCARD inline long double legendrel(const unsigned int _Degree, const long double _Value) {
    return __std_smf_legendre(_Degree, static_cast<double>(_Value));
}

// FUNCTION riemann_zeta
_NODISCARD inline double riemann_zeta(const double _Arg) {
    return __std_smf_riemann_zeta(_Arg);
}

// FUNCTION riemann_zetaf
_NODISCARD inline float riemann_zetaf(const float _Arg) {
    return __std_smf_riemann_zetaf(_Arg);
}

// FUNCTION riemann_zetal
_NODISCARD inline long double riemann_zetal(const long double _Arg) {
    return __std_smf_riemann_zeta(static_cast<double>(_Arg));
}

// FUNCTION sph_bessel
_NODISCARD inline double sph_bessel(const unsigned int _Arg1, const double _Arg2) {
    return __std_smf_sph_bessel(_Arg1, _Arg2);
}

// FUNCTION sph_besself
_NODISCARD inline float sph_besself(const unsigned int _Arg1, const float _Arg2) {
    return __std_smf_sph_besself(_Arg1, _Arg2);
}

// FUNCTION sph_bessell
_NODISCARD inline long double sph_bessell(const unsigned int _Arg1, const long double _Arg2) {
    return __std_smf_sph_bessel(_Arg1, static_cast<double>(_Arg2));
}

// FUNCTION sph_legendre
_NODISCARD inline double sph_legendre(const unsigned int _Arg1, const unsigned int _Arg2, const double _Theta) {
    return __std_smf_sph_legendre(_Arg1, _Arg2, _Theta);
}

// FUNCTION sph_legendref
_NODISCARD inline float sph_legendref(const unsigned int _Arg1, const unsigned int _Arg2, const float _Theta) {
    return __std_smf_sph_legendref(_Arg1, _Arg2, _Theta);
}

// FUNCTION sph_legendrel
_NODISCARD inline long double sph_legendrel(
    const unsigned int _Arg1, const unsigned int _Arg2, const long double _Theta) {
    return __std_smf_sph_legendre(_Arg1, _Arg2, static_cast<double>(_Theta));
}

// FUNCTION sph_neumann
_NODISCARD inline double sph_neumann(const unsigned int _Arg1, const double _Arg2) {
    return __std_smf_sph_neumann(_Arg1, _Arg2);
}

// FUNCTION sph_neumannf
_NODISCARD inline float sph_neumannf(const unsigned int _Arg1, const float _Arg2) {
    return __std_smf_sph_neumannf(_Arg1, _Arg2);
}

// FUNCTION sph_neumannl
_NODISCARD inline long double sph_neumannl(const unsigned int _Arg1, const long double _Arg2) {
    return __std_smf_sph_neumann(_Arg1, static_cast<double>(_Arg2));
}

// FUNCTION hypot (3-argument overloads)
_NODISCARD inline double hypot(const double _Dx, const double _Dy, const double _Dz) {
    return __std_smf_hypot3(_Dx, _Dy, _Dz);
}

_NODISCARD inline float hypot(const float _Dx, const float _Dy, const float _Dz) {
    return __std_smf_hypot3f(_Dx, _Dy, _Dz);
}

_NODISCARD inline long double hypot(const long double _Dx, const long double _Dy, const long double _Dz) {
    return __std_smf_hypot3(static_cast<double>(_Dx), static_cast<double>(_Dy), static_cast<double>(_Dz));
}

template <class _Ty1, class _Ty2, class _Ty3,
    enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2> && is_arithmetic_v<_Ty3>, int> = 0>
_NODISCARD auto hypot(const _Ty1 _Dx, const _Ty2 _Dy, const _Ty3 _Dz) {
    // N4727 [cmath.syn]/2 "Sufficient additional overloads"
    // Note that this template is selected by overload resolution only when at least one
    // argument is double/long double/integral but not all three are double or long double.
    using _Common      = _Common_float_type_t<_Ty1, _Common_float_type_t<_Ty2, _Ty3>>; // TRANSITION, fold expressions
    const auto _Result = __std_smf_hypot3(static_cast<double>(_Dx), static_cast<double>(_Dy), static_cast<double>(_Dz));
    return static_cast<_Common>(_Result);
}

#if _HAS_CXX20
// FUNCTION lerp
template <class _Ty>
_NODISCARD constexpr _Ty _Common_lerp(const _Ty _ArgA, const _Ty _ArgB, const _Ty _ArgT) noexcept {
    // on a line intersecting {(0.0, _ArgA), (1.0, _ArgB)}, return the Y value for X == _ArgT

    const bool _T_is_finite = _Is_finite(_ArgT);
    if (_T_is_finite && _Is_finite(_ArgA) && _Is_finite(_ArgB)) {
        // 99% case, put it first; this block comes from P0811R3
        if ((_ArgA <= 0 && _ArgB >= 0) || (_ArgA >= 0 && _ArgB <= 0)) {
            // exact, monotonic, bounded, determinate, and (for _ArgA == _ArgB == 0) consistent:
            return _ArgT * _ArgB + (1 - _ArgT) * _ArgA;
        }

        if (_ArgT == 1) {
            // exact
            return _ArgB;
        }

        // exact at _ArgT == 0, monotonic except near _ArgT == 1, bounded, determinate, and consistent:
        const auto _Candidate = _ArgA + _ArgT * (_ArgB - _ArgA);
        // monotonic near _ArgT == 1:
        if ((_ArgT > 1) == (_ArgB > _ArgA)) {
            if (_ArgB > _Candidate) {
                return _ArgB;
            }
        } else {
            if (_Candidate > _ArgB) {
                return _ArgB;
            }
        }

        return _Candidate;
    }

    if (_STD is_constant_evaluated()) {
        if (_Is_nan(_ArgA)) {
            return _ArgA;
        }

        if (_Is_nan(_ArgB)) {
            return _ArgB;
        }

        if (_Is_nan(_ArgT)) {
            return _ArgT;
        }
    } else {
        // raise FE_INVALID if at least one of _ArgA, _ArgB, and _ArgT is signaling NaN
        if (_Is_nan(_ArgA) || _Is_nan(_ArgB)) {
            return (_ArgA + _ArgB) + _ArgT;
        }

        if (_Is_nan(_ArgT)) {
            return _ArgT + _ArgT;
        }
    }

    if (_T_is_finite) {
        // _ArgT is finite, _ArgA and/or _ArgB is infinity
        if (_ArgT < 0) {
            // if _ArgT < 0:     return infinity in the "direction" of _ArgA if that exists, NaN otherwise
            return _ArgA - _ArgB;
        } else if (_ArgT <= 1) {
            // if _ArgT == 0:    return _ArgA (infinity) if _ArgB is finite, NaN otherwise
            // if 0 < _ArgT < 1: return infinity "between" _ArgA and _ArgB if that exists, NaN otherwise
            // if _ArgT == 1:    return _ArgB (infinity) if _ArgA is finite, NaN otherwise
            return _ArgT * _ArgB + (1 - _ArgT) * _ArgA;
        } else {
            // if _ArgT > 1:     return infinity in the "direction" of _ArgB if that exists, NaN otherwise
            return _ArgB - _ArgA;
        }
    } else {
        // _ArgT is an infinity; return infinity in the "direction" of _ArgA and _ArgB if that exists, NaN otherwise
        return _ArgT * (_ArgB - _ArgA);
    }
}

// As of 2019-06-17 it is unclear whether the "sufficient additional overloads" clause is intended to target lerp;
// LWG-3223 is pending.

_NODISCARD constexpr inline float lerp(const float _ArgA, const float _ArgB, const float _ArgT) noexcept {
    return _Common_lerp(_ArgA, _ArgB, _ArgT);
}

_NODISCARD constexpr inline double lerp(const double _ArgA, const double _ArgB, const double _ArgT) noexcept {
    return _Common_lerp(_ArgA, _ArgB, _ArgT);
}

_NODISCARD constexpr inline long double lerp(
    const long double _ArgA, const long double _ArgB, const long double _ArgT) noexcept {
    return _Common_lerp(_ArgA, _ArgB, _ArgT);
}
#endif // _HAS_CXX20
_STD_END
#endif // _HAS_CXX17

#pragma pop_macro("new")
_STL_RESTORE_CLANG_WARNINGS
#pragma warning(pop)
#pragma pack(pop)

#endif // _STL_COMPILER_PREPROCESSOR
#endif // _CMATH_