int main() {
long double ld = 0.1/0.0;
printf("%LF", ld);
printf("%d", __isinfl(ld));
if (!__isinfl(ld)) {
//@ assert \false;
}
}
int main(void) {
long double NaN = 0.0l / 0.0l;
long double Inf = 1.0l / 0.0l;
long double negInf = -1.0l / 0.0l;
long double val = __VERIFIER_nondet_long_double();
if (!__isnanl(val) && !__isinfl(val) && !__iszerol(val)) {
if (val > 0) {
assert(fabsl(val) == val);
} else {
assert(fabsl(val) == val);
}
}
assert(fabsl(0.0l) == 0.0l);
assert(fabsl(-0.0l) == 0.0l);
int isNeg = __signbitl(fabsl(-0.0l));
assert(!isNeg);
assert(fabsl(Inf) == Inf);
assert(fabsl(negInf) == Inf);
assert(__isnanl(fabsl(NaN)));
return 0;
}
__complex__ long double
__ctanl (__complex__ long double x)
{
__complex__ long double res;
if (!isfinite (__real__ x) || !isfinite (__imag__ x))
{
if (__isinfl (__imag__ x))
{
__real__ res = __copysignl (0.0, __real__ x);
__imag__ res = __copysignl (1.0, __imag__ x);
}
else if (__real__ x == 0.0)
{
res = x;
}
else
{
__real__ res = __nanl ("");
__imag__ res = __nanl ("");
#ifdef FE_INVALID
if (__isinfl (__real__ x))
feraiseexcept (FE_INVALID);
#endif
}
}
else
{
long double sin2rx, cos2rx;
long double den;
__sincosl (2.0 * __real__ x, &sin2rx, &cos2rx);
den = cos2rx + __ieee754_coshl (2.0 * __imag__ x);
__real__ res = sin2rx / den;
__imag__ res = __ieee754_sinhl (2.0 * __imag__ x) / den;
}
return res;
}
int main(void) {
assert(floor(2.7) == 2.0);
assert(floor(-2.7) == -3.0);
double c = floor(-0.0);
assert(c == -0.0);
assert(sizeof(c) == sizeof(float) ?
__signbitf(c) : sizeof(c) == sizeof(double) ? __signbit(c) : __signbitl(c));
c = floor(-(__builtin_inff()));
assert(sizeof((__builtin_inff())) == sizeof(float) ? __isinff((__builtin_inff())) :
sizeof((__builtin_inff())) == sizeof(double) ? __isinf((__builtin_inff())) : __isinfl((__builtin_inff())));
assert(sizeof(c) == sizeof(float) ?
__signbitf(c) : sizeof(c) == sizeof(double) ? __signbit(c) : __signbitl(c));
return 0;
}
__complex__ long double
__casinl (__complex__ long double x)
{
__complex__ long double res;
if (isnan (__real__ x) || isnan (__imag__ x))
{
if (__real__ x == 0.0)
{
res = x;
}
else if (__isinfl (__real__ x) || __isinfl (__imag__ x))
{
__real__ res = __nanl ("");
__imag__ res = __copysignl (HUGE_VALL, __imag__ x);
}
else
{
__real__ res = __nanl ("");
__imag__ res = __nanl ("");
}
}
else
{
__complex__ long double y;
__real__ y = -__imag__ x;
__imag__ y = __real__ x;
y = __casinhl (y);
__real__ res = __imag__ y;
__imag__ res = -__real__ y;
}
return res;
}
sysv_scalbl (long double x, long double fn)
{
long double z = __ieee754_scalbl (x, fn);
if (__glibc_unlikely (__isinfl (z)))
{
if (__finitel (x))
return __kernel_standard_l (x, fn, 232); /* scalb overflow */
else
__set_errno (ERANGE);
}
else if (__builtin_expect (z == 0.0L, 0) && z != x)
return __kernel_standard_l (x, fn, 233); /* scalb underflow */
return z;
}
int
printf_size (FILE *fp, const struct printf_info *info, const void *const *args)
{
/* Units for the both formats. */
#define BINARY_UNITS " kmgtpezy"
#define DECIMAL_UNITS " KMGTPEZY"
static const char units[2][sizeof (BINARY_UNITS)] =
{
BINARY_UNITS, /* For binary format. */
DECIMAL_UNITS /* For decimal format. */
};
const char *tag = units[isupper (info->spec) != 0];
int divisor = isupper (info->spec) ? 1000 : 1024;
/* The floating-point value to output. */
union
{
union ieee754_double dbl;
union ieee854_long_double ldbl;
}
fpnum;
const void *ptr = &fpnum;
int negative = 0;
/* "NaN" or "Inf" for the special cases. */
const char *special = NULL;
const wchar_t *wspecial = NULL;
struct printf_info fp_info;
int done = 0;
int wide = info->wide;
/* Fetch the argument value. */
#ifndef __NO_LONG_DOUBLE_MATH
if (info->is_long_double && sizeof (long double) > sizeof (double))
{
fpnum.ldbl.d = *(const long double *) args[0];
/* Check for special values: not a number or infinity. */
if (__isnanl (fpnum.ldbl.d))
{
special = "nan";
wspecial = L"nan";
negative = 0;
}
else if (__isinfl (fpnum.ldbl.d))
{
special = "inf";
wspecial = L"inf";
negative = fpnum.ldbl.d < 0;
}
else
while (fpnum.ldbl.d >= divisor && tag[1] != '\0')
{
fpnum.ldbl.d /= divisor;
++tag;
}
}
else
#endif /* no long double */
{
fpnum.dbl.d = *(const double *) args[0];
/* Check for special values: not a number or infinity. */
if (__isnan (fpnum.dbl.d))
{
special = "nan";
wspecial = L"nan";
negative = 0;
}
else if (__isinf (fpnum.dbl.d))
{
special = "inf";
wspecial = L"inf";
negative = fpnum.dbl.d < 0;
}
else
while (fpnum.dbl.d >= divisor && tag[1] != '\0')
{
fpnum.dbl.d /= divisor;
++tag;
}
}
if (special)
{
int width = info->prec > width ? info->prec : info->width;
if (negative || info->showsign || info->space)
--width;
width -= 3;
if (!info->left && width > 0)
PADN (' ', width);
if (negative)
outchar ('-');
else if (info->showsign)
outchar ('+');
else if (info->space)
outchar (' ');
PRINT (special, wspecial, 3);
if (info->left && width > 0)
PADN (' ', width);
return done;
}
/* Prepare to print the number. We want to use `__printf_fp' so we
have to prepare a `printf_info' structure. */
fp_info.spec = 'f';
fp_info.prec = info->prec < 0 ? 3 : info->prec;
fp_info.is_long_double = info->is_long_double;
fp_info.is_short = info->is_short;
fp_info.is_long = info->is_long;
fp_info.alt = info->alt;
fp_info.space = info->space;
fp_info.left = info->left;
fp_info.showsign = info->showsign;
fp_info.group = info->group;
fp_info.extra = info->extra;
fp_info.pad = info->pad;
fp_info.wide = wide;
if (fp_info.left && fp_info.pad == L' ')
{
/* We must do the padding ourself since the unit character must
be placed before the padding spaces. */
fp_info.width = 0;
done = __printf_fp (fp, &fp_info, &ptr);
if (done > 0)
{
outchar (*tag);
if (info->width > done)
PADN (' ', info->width - done);
}
}
else
{
/* We can let __printf_fp do all the printing and just add our
unit character afterwards. */
fp_info.width = info->width - 1;
done = __printf_fp (fp, &fp_info, &ptr);
if (done > 0)
outchar (*tag);
}
return done;
}
__complex__ long double
__ctanhl (__complex__ long double x)
{
__complex__ long double res;
if (!isfinite (__real__ x) || !isfinite (__imag__ x))
{
if (__isinfl (__real__ x))
{
__real__ res = __copysignl (1.0L, __real__ x);
__imag__ res = __copysignl (0.0L, __imag__ x);
}
else if (__imag__ x == 0.0)
{
res = x;
}
else
{
__real__ res = __nanl ("");
__imag__ res = __nanl ("");
#ifdef FE_INVALID
if (__isinfl (__imag__ x))
feraiseexcept (FE_INVALID);
#endif
}
}
else
{
long double sinix, cosix;
long double den;
const int t = (int) ((LDBL_MAX_EXP - 1) * M_LN2l / 2.0L);
/* tanh(x+iy) = (sinh(2x) + i*sin(2y))/(cosh(2x) + cos(2y))
= (sinh(x)*cosh(x) + i*sin(y)*cos(y))/(sinh(x)^2 + cos(y)^2). */
__sincosl (__imag__ x, &sinix, &cosix);
if (fabsl (__real__ x) > t)
{
/* Avoid intermediate overflow when the imaginary part of
the result may be subnormal. Ignoring negligible terms,
the real part is +/- 1, the imaginary part is
sin(y)*cos(y)/sinh(x)^2 = 4*sin(y)*cos(y)/exp(2x). */
long double exp_2t = __ieee754_expl (2 * t);
__real__ res = __copysignl (1.0L, __real__ x);
__imag__ res = 4 * sinix * cosix;
__real__ x = fabsl (__real__ x);
__real__ x -= t;
__imag__ res /= exp_2t;
if (__real__ x > t)
{
/* Underflow (original real part of x has absolute value
> 2t). */
__imag__ res /= exp_2t;
}
else
__imag__ res /= __ieee754_expl (2.0L * __real__ x);
}
else
{
long double sinhrx, coshrx;
if (fabs (__real__ x) > LDBL_MIN)
{
sinhrx = __ieee754_sinhl (__real__ x);
coshrx = __ieee754_coshl (__real__ x);
}
else
{
sinhrx = __real__ x;
coshrx = 1.0L;
}
if (fabsl (sinhrx) > fabsl (cosix) * ldbl_eps)
den = sinhrx * sinhrx + cosix * cosix;
else
den = cosix * cosix;
__real__ res = sinhrx * (coshrx / den);
__imag__ res = sinix * (cosix / den);
}
/* __gcc_qmul does not respect -0.0 so we need the following fixup. */
if ((__real__ res == 0.0L) && (__real__ x == 0.0L))
__real__ res = __real__ x;
if ((__real__ res == 0.0L) && (__imag__ x == 0.0L))
__imag__ res = __imag__ x;
}
return res;
}
int
__printf_fphex (FILE *fp,
const struct printf_info *info,
const void *const *args)
{
/* The floating-point value to output. */
union
{
union ieee754_double dbl;
long double ldbl;
}
fpnum;
/* Locale-dependent representation of decimal point. */
const char *decimal;
wchar_t decimalwc;
/* "NaN" or "Inf" for the special cases. */
const char *special = NULL;
const wchar_t *wspecial = NULL;
/* Buffer for the generated number string for the mantissa. The
maximal size for the mantissa is 128 bits. */
char numbuf[32];
char *numstr;
char *numend;
wchar_t wnumbuf[32];
wchar_t *wnumstr;
wchar_t *wnumend;
int negative;
/* The maximal exponent of two in decimal notation has 5 digits. */
char expbuf[5];
char *expstr;
wchar_t wexpbuf[5];
wchar_t *wexpstr;
int expnegative;
int exponent;
/* Non-zero is mantissa is zero. */
int zero_mantissa;
/* The leading digit before the decimal point. */
char leading;
/* Precision. */
int precision = info->prec;
/* Width. */
int width = info->width;
/* Number of characters written. */
int done = 0;
/* Nonzero if this is output on a wide character stream. */
#if __OPTION_POSIX_C_LANG_WIDE_CHAR
int wide = info->wide;
#else
/* This should never be called on a wide-oriented stream when
OPTION_POSIX_C_LANG_WIDE_CHAR is disabled, but the compiler can't
be trusted to figure that out. */
const int wide = 0;
#endif
/* Figure out the decimal point character. */
#if __OPTION_EGLIBC_LOCALE_CODE
if (info->extra == 0)
{
decimal = _NL_CURRENT (LC_NUMERIC, DECIMAL_POINT);
decimalwc = _NL_CURRENT_WORD (LC_NUMERIC, _NL_NUMERIC_DECIMAL_POINT_WC);
}
else
{
decimal = _NL_CURRENT (LC_MONETARY, MON_DECIMAL_POINT);
decimalwc = _NL_CURRENT_WORD (LC_MONETARY,
_NL_MONETARY_DECIMAL_POINT_WC);
}
/* The decimal point character must never be zero. */
assert (*decimal != '\0' && decimalwc != L'\0');
#else
decimal = ".";
decimalwc = L'.';
#endif
/* Fetch the argument value. */
#ifndef __NO_LONG_DOUBLE_MATH
if (info->is_long_double && sizeof (long double) > sizeof (double))
{
fpnum.ldbl = *(const long double *) args[0];
/* Check for special values: not a number or infinity. */
if (__isnanl (fpnum.ldbl))
{
if (isupper (info->spec))
{
special = "NAN";
wspecial = L"NAN";
}
else
{
special = "nan";
wspecial = L"nan";
}
}
else
{
if (__isinfl (fpnum.ldbl))
{
if (isupper (info->spec))
{
special = "INF";
wspecial = L"INF";
}
else
{
special = "inf";
wspecial = L"inf";
}
}
}
negative = signbit (fpnum.ldbl);
}
else
#endif /* no long double */
{
fpnum.dbl.d = *(const double *) args[0];
/* Check for special values: not a number or infinity. */
if (__isnan (fpnum.dbl.d))
{
negative = fpnum.dbl.ieee.negative != 0;
if (isupper (info->spec))
{
special = "NAN";
wspecial = L"NAN";
}
else
{
special = "nan";
wspecial = L"nan";
}
}
else
{
int res = __isinf (fpnum.dbl.d);
if (res)
{
if (isupper (info->spec))
{
special = "INF";
wspecial = L"INF";
}
else
{
special = "inf";
wspecial = L"inf";
}
negative = res < 0;
}
else
negative = signbit (fpnum.dbl.d);
}
}
if (special)
{
int width = info->width;
if (negative || info->showsign || info->space)
--width;
width -= 3;
if (!info->left && width > 0)
PADN (' ', width);
if (negative)
outchar ('-');
else if (info->showsign)
outchar ('+');
else if (info->space)
outchar (' ');
PRINT (special, wspecial, 3);
if (info->left && width > 0)
PADN (' ', width);
return done;
}
if (info->is_long_double == 0 || sizeof (double) == sizeof (long double))
{
/* We have 52 bits of mantissa plus one implicit digit. Since
52 bits are representable without rest using hexadecimal
digits we use only the implicit digits for the number before
the decimal point. */
unsigned long long int num;
num = (((unsigned long long int) fpnum.dbl.ieee.mantissa0) << 32
| fpnum.dbl.ieee.mantissa1);
zero_mantissa = num == 0;
if (sizeof (unsigned long int) > 6)
{
wnumstr = _itowa_word (num, wnumbuf + (sizeof wnumbuf) / sizeof (wchar_t), 16,
info->spec == 'A');
numstr = _itoa_word (num, numbuf + sizeof numbuf, 16,
info->spec == 'A');
}
else
{
wnumstr = _itowa (num, wnumbuf + sizeof wnumbuf / sizeof (wchar_t), 16,
info->spec == 'A');
numstr = _itoa (num, numbuf + sizeof numbuf, 16,
info->spec == 'A');
}
/* Fill with zeroes. */
while (wnumstr > wnumbuf + (sizeof wnumbuf - 52) / sizeof (wchar_t))
{
*--wnumstr = L'0';
*--numstr = '0';
}
leading = fpnum.dbl.ieee.exponent == 0 ? '0' : '1';
exponent = fpnum.dbl.ieee.exponent;
if (exponent == 0)
{
if (zero_mantissa)
expnegative = 0;
else
{
/* This is a denormalized number. */
expnegative = 1;
exponent = IEEE754_DOUBLE_BIAS - 1;
}
}
else if (exponent >= IEEE754_DOUBLE_BIAS)
{
expnegative = 0;
exponent -= IEEE754_DOUBLE_BIAS;
}
else
{
expnegative = 1;
exponent = -(exponent - IEEE754_DOUBLE_BIAS);
}
}
#ifdef PRINT_FPHEX_LONG_DOUBLE
else
PRINT_FPHEX_LONG_DOUBLE;
#endif
/* Look for trailing zeroes. */
if (! zero_mantissa)
{
wnumend = &wnumbuf[sizeof wnumbuf / sizeof wnumbuf[0]];
numend = &numbuf[sizeof numbuf / sizeof numbuf[0]];
while (wnumend[-1] == L'0')
{
--wnumend;
--numend;
}
bool do_round_away = false;
if (precision != -1 && precision < numend - numstr)
{
char last_digit = precision > 0 ? numstr[precision - 1] : leading;
char next_digit = numstr[precision];
int last_digit_value = (last_digit >= 'A' && last_digit <= 'F'
? last_digit - 'A' + 10
: (last_digit >= 'a' && last_digit <= 'f'
? last_digit - 'a' + 10
: last_digit - '0'));
int next_digit_value = (next_digit >= 'A' && next_digit <= 'F'
? next_digit - 'A' + 10
: (next_digit >= 'a' && next_digit <= 'f'
? next_digit - 'a' + 10
: next_digit - '0'));
bool more_bits = ((next_digit_value & 7) != 0
|| precision + 1 < numend - numstr);
int rounding_mode = get_rounding_mode ();
do_round_away = round_away (negative, last_digit_value & 1,
next_digit_value >= 8, more_bits,
rounding_mode);
}
if (precision == -1)
precision = numend - numstr;
else if (do_round_away)
{
/* Round up. */
int cnt = precision;
while (--cnt >= 0)
{
char ch = numstr[cnt];
/* We assume that the digits and the letters are ordered
like in ASCII. This is true for the rest of GNU, too. */
if (ch == '9')
{
wnumstr[cnt] = (wchar_t) info->spec;
numstr[cnt] = info->spec; /* This is tricky,
think about it! */
break;
}
else if (tolower (ch) < 'f')
{
++numstr[cnt];
++wnumstr[cnt];
break;
}
else
{
numstr[cnt] = '0';
wnumstr[cnt] = L'0';
}
}
if (cnt < 0)
{
/* The mantissa so far was fff...f Now increment the
leading digit. Here it is again possible that we
get an overflow. */
if (leading == '9')
leading = info->spec;
else if (tolower (leading) < 'f')
++leading;
else
{
leading = '1';
if (expnegative)
{
exponent -= 4;
if (exponent <= 0)
{
exponent = -exponent;
expnegative = 0;
}
}
else
exponent += 4;
}
}
}
}
else
{
if (precision == -1)
precision = 0;
numend = numstr;
wnumend = wnumstr;
}
/* Now we can compute the exponent string. */
expstr = _itoa_word (exponent, expbuf + sizeof expbuf, 10, 0);
wexpstr = _itowa_word (exponent,
wexpbuf + sizeof wexpbuf / sizeof (wchar_t), 10, 0);
/* Now we have all information to compute the size. */
width -= ((negative || info->showsign || info->space)
/* Sign. */
+ 2 + 1 + 0 + precision + 1 + 1
/* 0x h . hhh P ExpoSign. */
+ ((expbuf + sizeof expbuf) - expstr));
/* Exponent. */
/* Count the decimal point.
A special case when the mantissa or the precision is zero and the `#'
is not given. In this case we must not print the decimal point. */
if (precision > 0 || info->alt)
width -= wide ? 1 : strlen (decimal);
if (!info->left && info->pad != '0' && width > 0)
PADN (' ', width);
if (negative)
outchar ('-');
else if (info->showsign)
outchar ('+');
else if (info->space)
outchar (' ');
outchar ('0');
if ('X' - 'A' == 'x' - 'a')
outchar (info->spec + ('x' - 'a'));
else
outchar (info->spec == 'A' ? 'X' : 'x');
if (!info->left && info->pad == '0' && width > 0)
PADN ('0', width);
outchar (leading);
if (precision > 0 || info->alt)
{
const wchar_t *wtmp = &decimalwc;
PRINT (decimal, wtmp, wide ? 1 : strlen (decimal));
}
if (precision > 0)
{
ssize_t tofill = precision - (numend - numstr);
PRINT (numstr, wnumstr, MIN (numend - numstr, precision));
if (tofill > 0)
PADN ('0', tofill);
}
if ('P' - 'A' == 'p' - 'a')
outchar (info->spec + ('p' - 'a'));
else
outchar (info->spec == 'A' ? 'P' : 'p');
outchar (expnegative ? '-' : '+');
PRINT (expstr, wexpstr, (expbuf + sizeof expbuf) - expstr);
if (info->left && info->pad != '0' && width > 0)
PADN (info->pad, width);
return done;
}
int
__printf_size (FILE *fp, const struct printf_info *info,
const void *const *args)
{
/* Units for the both formats. */
#define BINARY_UNITS " kmgtpezy"
#define DECIMAL_UNITS " KMGTPEZY"
static const char units[2][sizeof (BINARY_UNITS)] =
{
BINARY_UNITS, /* For binary format. */
DECIMAL_UNITS /* For decimal format. */
};
const char *tag = units[isupper (info->spec) != 0];
int divisor = isupper (info->spec) ? 1000 : 1024;
/* The floating-point value to output. */
union
{
union ieee754_double dbl;
union ieee854_long_double ldbl;
}
fpnum;
const void *ptr = &fpnum;
int fpnum_sign = 0;
/* "NaN" or "Inf" for the special cases. */
const char *special = NULL;
const wchar_t *wspecial = NULL;
struct printf_info fp_info;
int done = 0;
#if __OPTION_POSIX_C_LANG_WIDE_CHAR
int wide = info->wide;
#else
/* This should never be called on a wide-oriented stream when
OPTION_POSIX_C_LANG_WIDE_CHAR is disabled, but the compiler can't
be trusted to figure that out. */
const int wide = 0;
#endif
int res;
/* Fetch the argument value. */
#ifndef __NO_LONG_DOUBLE_MATH
if (info->is_long_double && sizeof (long double) > sizeof (double))
{
fpnum.ldbl.d = *(const long double *) args[0];
/* Check for special values: not a number or infinity. */
if (__isnanl (fpnum.ldbl.d))
{
special = "nan";
wspecial = L"nan";
// fpnum_sign = 0; Already zero
}
else if ((res = __isinfl (fpnum.ldbl.d)))
{
fpnum_sign = res;
special = "inf";
wspecial = L"inf";
}
else
while (fpnum.ldbl.d >= divisor && tag[1] != '\0')
{
fpnum.ldbl.d /= divisor;
++tag;
}
}
else
#endif /* no long double */
{
fpnum.dbl.d = *(const double *) args[0];
/* Check for special values: not a number or infinity. */
if (__isnan (fpnum.dbl.d))
{
special = "nan";
wspecial = L"nan";
// fpnum_sign = 0; Already zero
}
else if ((res = __isinf (fpnum.dbl.d)))
{
fpnum_sign = res;
special = "inf";
wspecial = L"inf";
}
else
while (fpnum.dbl.d >= divisor && tag[1] != '\0')
{
fpnum.dbl.d /= divisor;
++tag;
}
}
if (special)
{
int width = info->prec > info->width ? info->prec : info->width;
if (fpnum_sign < 0 || info->showsign || info->space)
--width;
width -= 3;
if (!info->left && width > 0)
PADN (' ', width);
if (fpnum_sign < 0)
outchar ('-');
else if (info->showsign)
outchar ('+');
else if (info->space)
outchar (' ');
PRINT (special, wspecial, 3);
if (info->left && width > 0)
PADN (' ', width);
return done;
}
/* Prepare to print the number. We want to use `__printf_fp' so we
have to prepare a `printf_info' structure. */
fp_info = *info;
fp_info.spec = 'f';
fp_info.prec = info->prec < 0 ? 3 : info->prec;
fp_info.wide = wide;
if (fp_info.left && fp_info.pad == L' ')
{
/* We must do the padding ourself since the unit character must
be placed before the padding spaces. */
fp_info.width = 0;
done = __printf_fp (fp, &fp_info, &ptr);
if (done > 0)
{
outchar (*tag);
if (info->width > done)
PADN (' ', info->width - done);
}
}
else
{
/* We can let __printf_fp do all the printing and just add our
unit character afterwards. */
fp_info.width = info->width - 1;
done = __printf_fp (fp, &fp_info, &ptr);
if (done > 0)
outchar (*tag);
}
return done;
}
TEST(math, __isinfl) {
ASSERT_FALSE(__isinfl(123.0L));
ASSERT_TRUE(__isinfl(HUGE_VALL));
}
/// Return whether the given value is valid (does not overflow)
inline static bool isValid( double _fdValue ) {
return !__isinfl( _fdValue );
};
static int testl(long double long_double_x, int int_x, long long_x)
{
int r = 0;
r += __finitel(long_double_x);
r += __fpclassifyl(long_double_x);
r += __isinfl(long_double_x);
r += __isnanl(long_double_x);
r += __signbitl(long_double_x);
r += acoshl(long_double_x);
r += acosl(long_double_x);
r += asinhl(long_double_x);
r += asinl(long_double_x);
r += atan2l(long_double_x, long_double_x);
r += atanhl(long_double_x);
r += atanl(long_double_x);
r += cbrtl(long_double_x);
r += ceill(long_double_x);
r += copysignl(long_double_x, long_double_x);
r += coshl(long_double_x);
r += cosl(long_double_x);
r += erfcl(long_double_x);
r += erfl(long_double_x);
r += exp2l(long_double_x);
r += expl(long_double_x);
r += expm1l(long_double_x);
r += fabsl(long_double_x);
r += fdiml(long_double_x, long_double_x);
r += floorl(long_double_x);
r += fmal(long_double_x, long_double_x, long_double_x);
r += fmaxl(long_double_x, long_double_x);
r += fminl(long_double_x, long_double_x);
r += fmodl(long_double_x, long_double_x);
r += frexpl(long_double_x, &int_x);
r += hypotl(long_double_x, long_double_x);
r += ilogbl(long_double_x);
r += ldexpl(long_double_x, int_x);
r += lgammal(long_double_x);
r += llrintl(long_double_x);
r += llroundl(long_double_x);
r += log10l(long_double_x);
r += log1pl(long_double_x);
r += log2l(long_double_x);
r += logbl(long_double_x);
r += logl(long_double_x);
r += lrintl(long_double_x);
r += lroundl(long_double_x);
r += modfl(long_double_x, &long_double_x);
r += nearbyintl(long_double_x);
r += nextafterl(long_double_x, long_double_x);
r += nexttowardl(long_double_x, long_double_x);
r += powl(long_double_x, long_double_x);
r += remainderl(long_double_x, long_double_x);
r += remquol(long_double_x, long_double_x, &int_x);
r += rintl(long_double_x);
r += roundl(long_double_x);
r += scalblnl(long_double_x, long_x);
r += scalbnl(long_double_x, int_x);
r += sinhl(long_double_x);
r += sinl(long_double_x);
r += sqrtl(long_double_x);
r += tanhl(long_double_x);
r += tanl(long_double_x);
r += tgammal(long_double_x);
r += truncl(long_double_x);
return r;
}
