T(acos,        d_d)

T(acosf,       f_f)

T(acosl,       l_l)

T(acosh,       d_d)

T(acoshf,      f_f)

T(acoshl,      l_l)

T(asin,        d_d)

T(asinf,       f_f)

T(asinl,       l_l)

T(asinh,       d_d)

T(asinhf,      f_f)

T(asinhl,      l_l)

T(atan,        d_d)

T(atanf,       f_f)

T(atanl,       l_l)

T(atan2,       dd_d)

T(atan2f,      ff_f)

T(atan2l,      ll_l)

T(atanh,       d_d)

T(atanhf,      f_f)

T(atanhl,      l_l)

T(cbrt,        d_d)

T(cbrtf,       f_f)

T(cbrtl,       l_l)

T(ceil,        d_d)

T(ceilf,       f_f)

T(ceill,       l_l)

T(copysign,    dd_d)

T(copysignf,   ff_f)

T(copysignl,   ll_l)

T(cos,         d_d)

T(cosf,        f_f)

T(cosl,        l_l)

T(cosh,        d_d)

T(coshf,       f_f)

T(coshl,       l_l)

T(erf,         d_d)

T(erff,        f_f)

T(erfl,        l_l)

T(erfc,        d_d)

T(erfcf,       f_f)

T(erfcl,       l_l)

T(exp,         d_d)

T(expf,        f_f)

T(expl,        l_l)

T(exp2,        d_d)

T(exp2f,       f_f)

T(exp2l,       l_l)

T(expm1,       d_d)

T(expm1f,      f_f)

T(expm1l,      l_l)

T(fabs,        d_d)

T(fabsf,       f_f)

T(fabsl,       l_l)

T(fdim,        dd_d)

T(fdimf,       ff_f)

T(fdiml,       ll_l)

T(floor,       d_d)

T(floorf,      f_f)

T(floorl,      l_l)

T(fmax,        dd_d)

T(fmaxf,       ff_f)

T(fmaxl,       ll_l)

T(fmin,        dd_d)

T(fminf,       ff_f)

T(fminl,       ll_l)

T(fmod,        dd_d)

T(fmodf,       ff_f)

T(fmodl,       ll_l)

T(hypot,       dd_d)

T(hypotf,      ff_f)

T(hypotl,      ll_l)

T(log,         d_d)

T(logf,        f_f)

T(logl,        l_l)

T(log10,       d_d)

T(log10f,      f_f)

T(log10l,      l_l)

T(log1p,       d_d)

T(log1pf,      f_f)

T(log1pl,      l_l)

T(log2,        d_d)

T(log2f,       f_f)

T(log2l,       l_l)

T(logb,        d_d)

T(logbf,       f_f)

T(logbl,       l_l)

T(nearbyint,   d_d)

T(nearbyintf,  f_f)

T(nearbyintl,  l_l)

T(nextafter,   dd_d)

T(nextafterf,  ff_f)

T(nextafterl,  ll_l)

T(nexttoward,  dl_d)

T(nexttowardf, fl_f)

T(nexttowardl, ll_l)

T(pow,         dd_d)

T(powf,        ff_f)

T(powl,        ll_l)

T(remainder,   dd_d)

T(remainderf,  ff_f)

T(remainderl,  ll_l)

T(rint,        d_d)

T(rintf,       f_f)

T(rintl,       l_l)

T(round,       d_d)

T(roundf,      f_f)

T(roundl,      l_l)

T(sin,         d_d)

T(sinf,        f_f)

T(sinl,        l_l)

T(sinh,        d_d)

T(sinhf,       f_f)

T(sinhl,       l_l)

T(sqrt,        d_d)

T(sqrtf,       f_f)

T(sqrtl,       l_l)

T(tan,         d_d)

T(tanf,        f_f)

T(tanl,        l_l)

T(tanh,        d_d)

T(tanhf,       f_f)

T(tanhl,       l_l)

T(tgamma,      d_d)

T(tgammaf,     f_f)

T(tgammal,     l_l)

T(trunc,       d_d)

T(truncf,      f_f)

T(truncl,      l_l)

T(j0,          d_d)

T(j1,          d_d)

T(y0,          d_d)

T(y1,          d_d)

T(scalb,       dd_d)

T(scalbf,      ff_f)

T(j0f,         f_f)

T(j1f,         f_f)

T(y0f,         f_f)

T(y1f,         f_f)

T(exp10,       d_d)

T(exp10f,      f_f)

T(exp10l,      l_l)

T(pow10,       d_d)

T(pow10f,      f_f)

T(pow10l,      l_l)

T(frexp,       d_di)

T(frexpf,      f_fi)

T(frexpl,      l_li)

T(ldexp,       di_d)

T(ldexpf,      fi_f)

T(ldexpl,      li_l)

T(scalbn,      di_d)

T(scalbnf,     fi_f)

T(scalbnl,     li_l)

T(scalbln,     di_d)

T(scalblnf,    fi_f)

T(scalblnl,    li_l)

T(lgamma,      d_di)

T(lgammaf,     f_fi)

T(lgammal,     l_li)

T(lgamma_r,    d_di)

T(lgammaf_r,   f_fi)

T(lgammal_r,   l_li)

T(ilogb,       d_i)

T(ilogbf,      f_i)

T(ilogbl,      l_i)

T(llrint,      d_i)

T(llrintf,     f_i)

T(llrintl,     l_i)

T(lrint,       d_i)

T(lrintf,      f_i)

T(lrintl,      l_i)

T(llround,     d_i)

T(llroundf,    f_i)

T(llroundl,    l_i)

T(lround,      d_i)

T(lroundf,     f_i)

T(lroundl,     l_i)

T(modf,        d_dd)

T(modff,       f_ff)

T(modfl,       l_ll)

T(sincos,      d_dd)

T(sincosf,     f_ff)

T(sincosl,     l_ll)

T(remquo,      dd_di)

T(remquof,     ff_fi)

T(remquol,     ll_li)

T(fma,         ddd_d)

T(fmaf,        fff_f)

T(fmal,        lll_l)

T(jn,          di_d)

T(jnf,         fi_f)

T(yn,          di_d)

T(ynf,         fi_f)