Fwd: tgmath

[Javier Múgica]

I forgot to attach the promissed preprocessed files.

Also fogot to mention this: When the new file is compiled the following warning 
is diagnosed:

./tgmath.h:35:38: warning: #include_next with absolute path
#if defined(__STDC_NO_COMPLEX__) || !__has_include_next(<complex.h>)
                                     ^

I would ideally push the diagnostics state, then deactivete this warning, then 
pop the state after the problematic line, but because the message does not 
provide de usual -W-... descriptor I couldn't.


The "-hacked" that you see in some file names within the preprocessed files is 
because I had to hack the file in case I wanted the preprocessor to generate 
the definitions for the complex functions, given that preprocessing in my 
computer skips them because _TG_NO_COMPLEX gets (rightly) defined. I had to 
undefine it by hand and comment out the #include <complex.h> line.

# 30 "tgmath_old-hacked.h" 2
# 40 "tgmath_old-hacked.h"
typedef void _Argument_type_is_not_arithmetic;
static _Argument_type_is_not_arithmetic __tg_promote(...)
  __attribute__((__unavailable__,__overloadable__));
static double __attribute__((__overloadable__)) __tg_promote(int);
static double __attribute__((__overloadable__)) __tg_promote(unsigned int);
static double __attribute__((__overloadable__)) __tg_promote(long);
static double __attribute__((__overloadable__)) __tg_promote(unsigned long);
static double __attribute__((__overloadable__)) __tg_promote(long long);
static double __attribute__((__overloadable__)) __tg_promote(unsigned long 
long);
static float __attribute__((__overloadable__)) __tg_promote(float);
static double __attribute__((__overloadable__)) __tg_promote(double);
static long double __attribute__((__overloadable__)) __tg_promote(long double);
static float _Complex __attribute__((__overloadable__)) __tg_promote(float 
_Complex);
static double _Complex __attribute__((__overloadable__)) __tg_promote(double 
_Complex);
static long double _Complex __attribute__((__overloadable__)) __tg_promote(long 
double _Complex);
# 65 "tgmath_old-hacked.h"
static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_acos(float __x) {return ((float)acos((double)(__x)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_acos(double __x) {return acos(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_acos(long double __x) {return ((long double)acos((double)(__x)));}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_acos(float _Complex __x) {return cacosf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_acos(double _Complex __x) {return cacos(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_acos(long double _Complex __x) {return cacosl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_asin(float __x) {return ((float)asin((double)(__x)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_asin(double __x) {return asin(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_asin(long double __x) {return ((long double)asin((double)(__x)));}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_asin(float _Complex __x) {return casinf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_asin(double _Complex __x) {return casin(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_asin(long double _Complex __x) {return casinl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_atan(float __x) {return ((float)atan((double)(__x)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_atan(double __x) {return atan(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_atan(long double __x) {return ((long double)atan((double)(__x)));}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_atan(float _Complex __x) {return catanf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_atan(double _Complex __x) {return catan(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_atan(long double _Complex __x) {return catanl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_acosh(float __x) {return acoshf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_acosh(double __x) {return acosh(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_acosh(long double __x) {return acoshl(__x);}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_acosh(float _Complex __x) {return cacoshf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_acosh(double _Complex __x) {return cacosh(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_acosh(long double _Complex __x) {return cacoshl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_asinh(float __x) {return asinhf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_asinh(double __x) {return asinh(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_asinh(long double __x) {return asinhl(__x);}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_asinh(float _Complex __x) {return casinhf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_asinh(double _Complex __x) {return casinh(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_asinh(long double _Complex __x) {return casinhl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_atanh(float __x) {return atanhf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_atanh(double __x) {return atanh(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_atanh(long double __x) {return atanhl(__x);}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_atanh(float _Complex __x) {return catanhf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_atanh(double _Complex __x) {return catanh(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_atanh(long double _Complex __x) {return catanhl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_cos(float __x) {return ((float)cos((double)(__x)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_cos(double __x) {return cos(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_cos(long double __x) {return ((long double)cos((double)(__x)));}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_cos(float _Complex __x) {return ccosf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_cos(double _Complex __x) {return ccos(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_cos(long double _Complex __x) {return ccosl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_sin(float __x) {return ((float)sin((double)(__x)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_sin(double __x) {return sin(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_sin(long double __x) {return ((long double)sin((double)(__x)));}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_sin(float _Complex __x) {return csinf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_sin(double _Complex __x) {return csin(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_sin(long double _Complex __x) {return csinl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_tan(float __x) {return ((float)tan((double)(__x)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_tan(double __x) {return tan(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_tan(long double __x) {return ((long double)tan((double)(__x)));}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_tan(float _Complex __x) {return ctanf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_tan(double _Complex __x) {return ctan(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_tan(long double _Complex __x) {return ctanl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_cosh(float __x) {return ((float)cosh((double)(__x)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_cosh(double __x) {return cosh(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_cosh(long double __x) {return ((long double)cosh((double)(__x)));}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_cosh(float _Complex __x) {return ccoshf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_cosh(double _Complex __x) {return ccosh(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_cosh(long double _Complex __x) {return ccoshl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_sinh(float __x) {return ((float)sinh((double)(__x)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_sinh(double __x) {return sinh(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_sinh(long double __x) {return ((long double)sinh((double)(__x)));}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_sinh(float _Complex __x) {return csinhf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_sinh(double _Complex __x) {return csinh(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_sinh(long double _Complex __x) {return csinhl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_tanh(float __x) {return ((float)tanh((double)(__x)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_tanh(double __x) {return tanh(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_tanh(long double __x) {return ((long double)tanh((double)(__x)));}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_tanh(float _Complex __x) {return ctanhf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_tanh(double _Complex __x) {return ctanh(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_tanh(long double _Complex __x) {return ctanhl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_exp(float __x) {return ((float)exp((double)(__x)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_exp(double __x) {return exp(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_exp(long double __x) {return ((long double)exp((double)(__x)));}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_exp(float _Complex __x) {return cexpf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_exp(double _Complex __x) {return cexp(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_exp(long double _Complex __x) {return cexpl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_log(float __x) {return ((float)log((double)(__x)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_log(double __x) {return log(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_log(long double __x) {return ((long double)log((double)(__x)));}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_log(float _Complex __x) {return clogf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_log(double _Complex __x) {return clog(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_log(long double _Complex __x) {return clogl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_pow(float __x, float __y) {return ((float)pow((double)(__x), 
(double)(__y)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_pow(double __x, double __y) {return pow(__x, __y);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_pow(long double __x, long double __y) {return ((long 
double)pow((double)(__x), (double)(__y)));}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_pow(float _Complex __x, float _Complex __y) {return cpowf(__x, __y);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_pow(double _Complex __x, double _Complex __y) {return cpow(__x, __y);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_pow(long double _Complex __x, long double _Complex __y)
    {return cpowl(__x, __y);}







static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_sqrt(float __x) {return ((float)sqrt((double)(__x)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_sqrt(double __x) {return sqrt(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_sqrt(long double __x) {return ((long double)sqrt((double)(__x)));}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_sqrt(float _Complex __x) {return csqrtf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_sqrt(double _Complex __x) {return csqrt(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_sqrt(long double _Complex __x) {return csqrtl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_fabs(float __x) {return ((float)fabs((double)(__x)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_fabs(double __x) {return fabs(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_fabs(long double __x) {return ((long double)fabs((double)(__x)));}

static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_fabs(float _Complex __x) {return cabsf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_fabs(double _Complex __x) {return cabs(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_fabs(long double _Complex __x) {return cabsl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_atan2(float __x, float __y) {return ((float)atan2((double)(__x), 
(double)(__y)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_atan2(double __x, double __y) {return atan2(__x, __y);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_atan2(long double __x, long double __y) {return ((long 
double)atan2((double)(__x), (double)(__y)));}







static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_cbrt(float __x) {return cbrtf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_cbrt(double __x) {return cbrt(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_cbrt(long double __x) {return cbrtl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_ceil(float __x) {return ((float)ceil((double)(__x)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_ceil(double __x) {return ceil(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_ceil(long double __x) {return ((long double)ceil((double)(__x)));}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_copysign(float __x, float __y) {return copysignf(__x, __y);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_copysign(double __x, double __y) {return copysign(__x, __y);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_copysign(long double __x, long double __y) {return copysignl(__x, 
__y);}







static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_erf(float __x) {return erff(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_erf(double __x) {return erf(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_erf(long double __x) {return erfl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_erfc(float __x) {return erfcf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_erfc(double __x) {return erfc(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_erfc(long double __x) {return erfcl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_exp2(float __x) {return exp2f(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_exp2(double __x) {return exp2(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_exp2(long double __x) {return exp2l(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_expm1(float __x) {return expm1f(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_expm1(double __x) {return expm1(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_expm1(long double __x) {return expm1l(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_fdim(float __x, float __y) {return fdimf(__x, __y);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_fdim(double __x, double __y) {return fdim(__x, __y);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_fdim(long double __x, long double __y) {return fdiml(__x, __y);}







static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_floor(float __x) {return ((float)floor((double)(__x)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_floor(double __x) {return floor(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_floor(long double __x) {return ((long double)floor((double)(__x)));}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_fma(float __x, float __y, float __z)
    {return fmaf(__x, __y, __z);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_fma(double __x, double __y, double __z)
    {return fma(__x, __y, __z);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_fma(long double __x,long double __y, long double __z)
    {return fmal(__x, __y, __z);}
# 756 "tgmath_old-hacked.h"
static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_fmax(float __x, float __y) {return fmaxf(__x, __y);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_fmax(double __x, double __y) {return fmax(__x, __y);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_fmax(long double __x, long double __y) {return fmaxl(__x, __y);}







static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_fmin(float __x, float __y) {return fminf(__x, __y);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_fmin(double __x, double __y) {return fmin(__x, __y);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_fmin(long double __x, long double __y) {return fminl(__x, __y);}







static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_fmod(float __x, float __y) {return ((float)fmod((double)(__x), 
(double)(__y)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_fmod(double __x, double __y) {return fmod(__x, __y);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_fmod(long double __x, long double __y) {return ((long 
double)fmod((double)(__x), (double)(__y)));}







static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_frexp(float __x, int* __y) {return 
((float)frexp((double)(__x),(__y)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_frexp(double __x, int* __y) {return frexp(__x, __y);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_frexp(long double __x, int* __y) {return ((long 
double)frexp((double)(__x), (__y)));}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_hypot(float __x, float __y) {return hypotf(__x, __y);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_hypot(double __x, double __y) {return hypot(__x, __y);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_hypot(long double __x, long double __y) {return ((long 
double)_hypot((double)(__x), (double)(__y)));}







static int
    __attribute__((__overloadable__, __always_inline__))
    __tg_ilogb(float __x) {return ilogbf(__x);}

static int
    __attribute__((__overloadable__, __always_inline__))
    __tg_ilogb(double __x) {return ilogb(__x);}

static int
    __attribute__((__overloadable__, __always_inline__))
    __tg_ilogb(long double __x) {return ilogbl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_ldexp(float __x, int __y) {return ((float)ldexp((double)(__x),(__y)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_ldexp(double __x, int __y) {return ldexp(__x, __y);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_ldexp(long double __x, int __y) {return ((long 
double)ldexp((double)(__x), (__y)));}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_lgamma(float __x) {return lgammaf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_lgamma(double __x) {return lgamma(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_lgamma(long double __x) {return lgammal(__x);}






static long long
    __attribute__((__overloadable__, __always_inline__))
    __tg_llrint(float __x) {return llrintf(__x);}

static long long
    __attribute__((__overloadable__, __always_inline__))
    __tg_llrint(double __x) {return llrint(__x);}

static long long
    __attribute__((__overloadable__, __always_inline__))
    __tg_llrint(long double __x) {return llrintl(__x);}






static long long
    __attribute__((__overloadable__, __always_inline__))
    __tg_llround(float __x) {return llroundf(__x);}

static long long
    __attribute__((__overloadable__, __always_inline__))
    __tg_llround(double __x) {return llround(__x);}

static long long
    __attribute__((__overloadable__, __always_inline__))
    __tg_llround(long double __x) {return llroundl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_log10(float __x) {return ((float)log10((double)(__x)));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_log10(double __x) {return log10(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_log10(long double __x) {return ((long double)log10((double)(__x)));}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_log1p(float __x) {return log1pf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_log1p(double __x) {return log1p(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_log1p(long double __x) {return log1pl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_log2(float __x) {return log2f(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_log2(double __x) {return log2(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_log2(long double __x) {return log2l(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_logb(float __x) {return logbf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_logb(double __x) {return logb(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_logb(long double __x) {return logbl(__x);}






static long
    __attribute__((__overloadable__, __always_inline__))
    __tg_lrint(float __x) {return lrintf(__x);}

static long
    __attribute__((__overloadable__, __always_inline__))
    __tg_lrint(double __x) {return lrint(__x);}

static long
    __attribute__((__overloadable__, __always_inline__))
    __tg_lrint(long double __x) {return lrintl(__x);}






static long
    __attribute__((__overloadable__, __always_inline__))
    __tg_lround(float __x) {return lroundf(__x);}

static long
    __attribute__((__overloadable__, __always_inline__))
    __tg_lround(double __x) {return lround(__x);}

static long
    __attribute__((__overloadable__, __always_inline__))
    __tg_lround(long double __x) {return lroundl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_nearbyint(float __x) {return nearbyintf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_nearbyint(double __x) {return nearbyint(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_nearbyint(long double __x) {return nearbyintl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_nextafter(float __x, float __y) {return nextafterf(__x, __y);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_nextafter(double __x, double __y) {return nextafter(__x, __y);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_nextafter(long double __x, long double __y) {return nextafterl(__x, 
__y);}







static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_nexttoward(float __x, long double __y) {return nexttowardf(__x, __y);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_nexttoward(double __x, long double __y) {return nexttoward(__x, __y);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_nexttoward(long double __x, long double __y) {return nexttowardl(__x, 
__y);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_remainder(float __x, float __y) {return remainderf(__x, __y);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_remainder(double __x, double __y) {return remainder(__x, __y);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_remainder(long double __x, long double __y) {return remainderl(__x, 
__y);}







static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_remquo(float __x, float __y, int* __z)
    {return remquof(__x, __y, __z);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_remquo(double __x, double __y, int* __z)
    {return remquo(__x, __y, __z);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_remquo(long double __x,long double __y, int* __z)
    {return remquol(__x, __y, __z);}
# 1125 "tgmath_old-hacked.h"
static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_rint(float __x) {return rintf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_rint(double __x) {return rint(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_rint(long double __x) {return rintl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_round(float __x) {return roundf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_round(double __x) {return round(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_round(long double __x) {return roundl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_scalbn(float __x, int __y) {return scalbnf(__x, __y);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_scalbn(double __x, int __y) {return scalbn(__x, __y);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_scalbn(long double __x, int __y) {return scalbnl(__x, __y);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_scalbln(float __x, long __y) {return scalblnf(__x, __y);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_scalbln(double __x, long __y) {return scalbln(__x, __y);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_scalbln(long double __x, long __y) {return scalblnl(__x, __y);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_tgamma(float __x) {return tgammaf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_tgamma(double __x) {return tgamma(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_tgamma(long double __x) {return tgammal(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_trunc(float __x) {return truncf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_trunc(double __x) {return trunc(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_trunc(long double __x) {return truncl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_carg(float __x) {return 
((float)__tg_atan2((__typeof__(__tg_promote(((double)(0.F))) + 
__tg_promote(((double)(__x)))))((double)(0.F)), 
(__typeof__(__tg_promote(((double)(0.F))) + 
__tg_promote(((double)(__x)))))((double)(__x))));}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_carg(double __x) {return __tg_atan2((__typeof__(__tg_promote((0.)) + 
__tg_promote((__x))))(0.), (__typeof__(__tg_promote((0.)) + 
__tg_promote((__x))))(__x));}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_carg(long double __x) {return ((long 
double)__tg_atan2((__typeof__(__tg_promote(((double)(0.L))) + 
__tg_promote(((double)(__x)))))((double)(0.L)), 
(__typeof__(__tg_promote(((double)(0.L))) + 
__tg_promote(((double)(__x)))))((double)(__x))));}

static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_carg(float _Complex __x) {return cargf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_carg(double _Complex __x) {return carg(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_carg(long double _Complex __x) {return cargl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_cimag(float __x) {return 0;}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_cimag(double __x) {return 0;}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_cimag(long double __x) {return 0;}

static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_cimag(float _Complex __x) {return cimagf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_cimag(double _Complex __x) {return cimag(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_cimag(long double _Complex __x) {return cimagl(__x);}






static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_conj(float __x) {return __x;}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_conj(double __x) {return __x;}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_conj(long double __x) {return __x;}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_conj(float _Complex __x) {return conjf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_conj(double _Complex __x) {return conj(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_conj(long double _Complex __x) {return conjl(__x);}






static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_cproj(float __x) {return cprojf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_cproj(double __x) {return cproj(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_cproj(long double __x) {return cprojl(__x);}

static float _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_cproj(float _Complex __x) {return cprojf(__x);}

static double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_cproj(double _Complex __x) {return cproj(__x);}

static long double _Complex
    __attribute__((__overloadable__, __always_inline__))
    __tg_cproj(long double _Complex __x) {return cprojl(__x);}






static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_creal(float __x) {return __x;}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_creal(double __x) {return __x;}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_creal(long double __x) {return __x;}

static float
    __attribute__((__overloadable__, __always_inline__))
    __tg_creal(float _Complex __x) {return crealf(__x);}

static double
    __attribute__((__overloadable__, __always_inline__))
    __tg_creal(double _Complex __x) {return creal(__x);}

static long double
    __attribute__((__overloadable__, __always_inline__))
    __tg_creal(long double _Complex __x) {return creall(__x);}

# 32 "tgmath.h" 2
# 48 "tgmath.h"
typedef void _Argument_type_is_not_arithmetic;
static _Argument_type_is_not_arithmetic __tg_promote(...)
  __attribute__((__unavailable__,__overloadable__));
static double __attribute__((__overloadable__)) __tg_promote(int);
static double __attribute__((__overloadable__)) __tg_promote(unsigned int);
static double __attribute__((__overloadable__)) __tg_promote(long);
static double __attribute__((__overloadable__)) __tg_promote(unsigned long);
static double __attribute__((__overloadable__)) __tg_promote(long long);
static double __attribute__((__overloadable__)) __tg_promote(unsigned long 
long);
static float __attribute__((__overloadable__)) __tg_promote(float);
static double __attribute__((__overloadable__)) __tg_promote(double);
static long double __attribute__((__overloadable__)) __tg_promote(long double);
# 104 "tgmath.h"
   { return func(__x,__y,__z); } static long double 
__attribute__((__overloadable__, __always_inline__)) __tg_func(long double __x, 
long double __y, long double __z) { return func##l(__x,__y,__z); }
# 157 "tgmath.h"
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_acos(float __x) { return ((float)acos((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_acos(double __x) { 
return acos(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_acos(long double __x) { return ((long 
double)acos((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_asin(float __x) { return ((float)asin((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_asin(double __x) { 
return asin(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_asin(long double __x) { return ((long 
double)asin((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_atan(float __x) { return ((float)atan((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_atan(double __x) { 
return atan(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_atan(long double __x) { return ((long 
double)atan((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_acosh(float __x) { return acoshf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_acosh(double __x) { 
return acosh(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_acosh(long double __x) { return acoshl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_asinh(float __x) { return asinhf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_asinh(double __x) { 
return asinh(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_asinh(long double __x) { return asinhl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_atanh(float __x) { return atanhf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_atanh(double __x) { 
return atanh(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_atanh(long double __x) { return atanhl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_cos(float __x) { return ((float)cos((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_cos(double __x) { 
return cos(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_cos(long double __x) { return ((long 
double)cos((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_sin(float __x) { return ((float)sin((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_sin(double __x) { 
return sin(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_sin(long double __x) { return ((long 
double)sin((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_tan(float __x) { return ((float)tan((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_tan(double __x) { 
return tan(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_tan(long double __x) { return ((long 
double)tan((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_cosh(float __x) { return ((float)cosh((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_cosh(double __x) { 
return cosh(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_cosh(long double __x) { return ((long 
double)cosh((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_sinh(float __x) { return ((float)sinh((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_sinh(double __x) { 
return sinh(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_sinh(long double __x) { return ((long 
double)sinh((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_tanh(float __x) { return ((float)tanh((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_tanh(double __x) { 
return tanh(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_tanh(long double __x) { return ((long 
double)tanh((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_exp(float __x) { return ((float)exp((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_exp(double __x) { 
return exp(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_exp(long double __x) { return ((long 
double)exp((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_log(float __x) { return ((float)log((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_log(double __x) { 
return log(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_log(long double __x) { return ((long 
double)log((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_sqrt(float __x) { return ((float)sqrt((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_sqrt(double __x) { 
return sqrt(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_sqrt(long double __x) { return ((long 
double)sqrt((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_fabs(float __x) { return ((float)fabs((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_fabs(double __x) { 
return fabs(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_fabs(long double __x) { return ((long 
double)fabs((double)(__x))); }
# 213 "tgmath.h"
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_pow(float __x, float __y) { return ((float)pow((double)(__x), 
(double)(__y))); } static double __attribute__((__overloadable__, 
__always_inline__)) __tg_pow(double __x, double __y) { return pow(__x,__y); } 
static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_pow(long double __x, long double __y) { return ((long 
double)pow((double)(__x), (double)(__y))); }
# 222 "tgmath.h"
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_atan2(float __x, float __y) { return ((float)atan2((double)(__x), 
(double)(__y))); } static double __attribute__((__overloadable__, 
__always_inline__)) __tg_atan2(double __x, double __y) { return atan2(__x,__y); 
} static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_atan2(long double __x, long double __y) { return ((long 
double)atan2((double)(__x), (double)(__y))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_cbrt(float __x) { return cbrtf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_cbrt(double __x) { 
return cbrt(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_cbrt(long double __x) { return cbrtl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_ceil(float __x) { return ((float)ceil((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_ceil(double __x) { 
return ceil(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_ceil(long double __x) { return ((long 
double)ceil((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_copysign(float __x, float __y) { return copysignf(__x,__y); } static 
double __attribute__((__overloadable__, __always_inline__)) 
__tg_copysign(double __x, double __y) { return copysign(__x,__y); } static long 
double __attribute__((__overloadable__, __always_inline__)) __tg_copysign(long 
double __x, long double __y) { return copysignl(__x,__y); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_erf(float __x) { return erff(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_erf(double __x) { 
return erf(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_erf(long double __x) { return erfl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_erfc(float __x) { return erfcf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_erfc(double __x) { 
return erfc(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_erfc(long double __x) { return erfcl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_exp2(float __x) { return exp2f(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_exp2(double __x) { 
return exp2(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_exp2(long double __x) { return exp2l(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_expm1(float __x) { return expm1f(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_expm1(double __x) { 
return expm1(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_expm1(long double __x) { return expm1l(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_fdim(float __x, float __y) { return fdimf(__x,__y); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_fdim(double __x, 
double __y) { return fdim(__x,__y); } static long double 
__attribute__((__overloadable__, __always_inline__)) __tg_fdim(long double __x, 
long double __y) { return fdiml(__x,__y); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_floor(float __x) { return ((float)floor((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_floor(double __x) { 
return floor(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_floor(long double __x) { return ((long 
double)floor((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_fma(float __x, float __y, float __z) { return fmaf(__x,__y,__z); } static 
double __attribute__((__overloadable__, __always_inline__)) __tg_fma(double 
__x, double __y, double __z)
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_fmax(float __x, float __y) { return fmaxf(__x,__y); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_fmax(double __x, 
double __y) { return fmax(__x,__y); } static long double 
__attribute__((__overloadable__, __always_inline__)) __tg_fmax(long double __x, 
long double __y) { return fmaxl(__x,__y); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_fmin(float __x, float __y) { return fminf(__x,__y); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_fmin(double __x, 
double __y) { return fmin(__x,__y); } static long double 
__attribute__((__overloadable__, __always_inline__)) __tg_fmin(long double __x, 
long double __y) { return fminl(__x,__y); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_fmod(float __x, float __y) { return ((float)fmod((double)(__x), 
(double)(__y))); } static double __attribute__((__overloadable__, 
__always_inline__)) __tg_fmod(double __x, double __y) { return fmod(__x,__y); } 
static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_fmod(long double __x, long double __y) { return ((long 
double)fmod((double)(__x), (double)(__y))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_hypot(float __x, float __y) { return hypotf(__x,__y); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_hypot(double __x, 
double __y) { return hypot(__x,__y); } static long double 
__attribute__((__overloadable__, __always_inline__)) __tg_hypot(long double 
__x, long double __y) { return ((long double)_hypot((double)(__x), 
(double)(__y))); }
static int __attribute__((__overloadable__, __always_inline__)) 
__tg_ilogb(float __x) { return ilogbf(__x); } static int 
__attribute__((__overloadable__, __always_inline__)) __tg_ilogb(double __x) { 
return ilogb(__x); } static int __attribute__((__overloadable__, 
__always_inline__)) __tg_ilogb(long double __x) { return ilogbl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_lgamma(float __x) { return lgammaf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_lgamma(double __x) { 
return lgamma(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_lgamma(long double __x) { return lgammal(__x); }
static long long __attribute__((__overloadable__, __always_inline__)) 
__tg_llrint(float __x) { return llrintf(__x); } static long long 
__attribute__((__overloadable__, __always_inline__)) __tg_llrint(double __x) { 
return llrint(__x); } static long long __attribute__((__overloadable__, 
__always_inline__)) __tg_llrint(long double __x) { return llrintl(__x); }
static long long __attribute__((__overloadable__, __always_inline__)) 
__tg_llround(float __x) { return llroundf(__x); } static long long 
__attribute__((__overloadable__, __always_inline__)) __tg_llround(double __x) { 
return llround(__x); } static long long __attribute__((__overloadable__, 
__always_inline__)) __tg_llround(long double __x) { return llroundl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_log10(float __x) { return ((float)log10((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_log10(double __x) { 
return log10(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_log10(long double __x) { return ((long 
double)log10((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_log1p(float __x) { return log1pf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_log1p(double __x) { 
return log1p(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_log1p(long double __x) { return log1pl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_log2(float __x) { return log2f(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_log2(double __x) { 
return log2(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_log2(long double __x) { return log2l(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_logb(float __x) { return logbf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_logb(double __x) { 
return logb(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_logb(long double __x) { return logbl(__x); }
static long __attribute__((__overloadable__, __always_inline__)) 
__tg_lrint(float __x) { return lrintf(__x); } static long 
__attribute__((__overloadable__, __always_inline__)) __tg_lrint(double __x) { 
return lrint(__x); } static long __attribute__((__overloadable__, 
__always_inline__)) __tg_lrint(long double __x) { return lrintl(__x); }
static long __attribute__((__overloadable__, __always_inline__)) 
__tg_lround(float __x) { return lroundf(__x); } static long 
__attribute__((__overloadable__, __always_inline__)) __tg_lround(double __x) { 
return lround(__x); } static long __attribute__((__overloadable__, 
__always_inline__)) __tg_lround(long double __x) { return lroundl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_nearbyint(float __x) { return nearbyintf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_nearbyint(double __x) 
{ return nearbyint(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_nearbyint(long double __x) { return nearbyintl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_nextafter(float __x, float __y) { return nextafterf(__x,__y); } static 
double __attribute__((__overloadable__, __always_inline__)) 
__tg_nextafter(double __x, double __y) { return nextafter(__x,__y); } static 
long double __attribute__((__overloadable__, __always_inline__)) 
__tg_nextafter(long double __x, long double __y) { return nextafterl(__x,__y); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_reminder(float __x, float __y) { return reminderf(__x,__y); } static 
double __attribute__((__overloadable__, __always_inline__)) 
__tg_reminder(double __x, double __y) { return reminder(__x,__y); } static long 
double __attribute__((__overloadable__, __always_inline__)) __tg_reminder(long 
double __x, long double __y) { return reminderl(__x,__y); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_rint(float __x) { return rintf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_rint(double __x) { 
return rint(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_rint(long double __x) { return rintl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_round(float __x) { return roundf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_round(double __x) { 
return round(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_round(long double __x) { return roundl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_tgamma(float __x) { return tgammaf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_tgamma(double __x) { 
return tgamma(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_tgamma(long double __x) { return tgammal(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_trunc(float __x) { return truncf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_trunc(double __x) { 
return trunc(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_trunc(long double __x) { return truncl(__x); }




static float __attribute__((__overloadable__, __always_inline__)) 
__tg_frexp(float __x, int* __y) {return ((float)frexp((double)(__x),(__y)));}
static double __attribute__((__overloadable__, __always_inline__)) 
__tg_frexp(double __x, int* __y) {return frexp(__x, __y);}
static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_frexp(long double __x, int* __y) {return ((long 
double)frexp((double)(__x), (__y)));}


static float __attribute__((__overloadable__, __always_inline__)) 
__tg_ldexp(float __x, int __y) {return ((float)ldexp((double)(__x),(__y)));}
static double __attribute__((__overloadable__, __always_inline__)) 
__tg_ldexp(double __x, int __y) {return ldexp(__x, __y);}
static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_ldexp(long double __x, int __y) {return ((long double)ldexp((double)(__x), 
(__y)));}


static float __attribute__((__overloadable__, __always_inline__)) 
__tg_nexttoward(float __x, long double __y) {return nexttowardf(__x, __y);}

static double __attribute__((__overloadable__, __always_inline__)) 
__tg_nexttoward(double __x, long double __y) {return nexttoward(__x, __y);}

static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_nexttoward(long double __x, long double __y) {return nexttowardl(__x, 
__y);}



static float __attribute__((__overloadable__, __always_inline__)) 
__tg_remqo(float __x, float __y, int* __z) {return remquof(__x, __y, __z);}

static double __attribute__((__overloadable__, __always_inline__)) 
__tg_remqo(double __x, double __y, int* __z) {return remquo(__x, __y, __z);}

static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_remqo(long double __x,long double __y, int* __z) {return remquol(__x, __y, 
__z);}



static float __attribute__((__overloadable__, __always_inline__)) 
__tg_scalbn(float __x, int __y) {return scalbnf(__x, __y);}
static double __attribute__((__overloadable__, __always_inline__)) 
__tg_scalbn(double __x, int __y) {return scalbn(__x, __y);}
static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_scalbn(long double __x, int __y) {return scalbnl(__x, __y);}



static float __attribute__((__overloadable__, __always_inline__)) 
__tg_scalbln(float __x, long __y) {return scalblnf(__x, __y);}
static double __attribute__((__overloadable__, __always_inline__)) 
__tg_scalbln(double __x, long __y) {return scalbln(__x, __y);}
static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_scalbln(long double __x, long __y) {return scalblnl(__x, __y);}

# 32 "tgmath-hacked.h" 2
# 49 "tgmath-hacked.h"
typedef void _Argument_type_is_not_arithmetic;
static _Argument_type_is_not_arithmetic __tg_promote(...)
  __attribute__((__unavailable__,__overloadable__));
static double __attribute__((__overloadable__)) __tg_promote(int);
static double __attribute__((__overloadable__)) __tg_promote(unsigned int);
static double __attribute__((__overloadable__)) __tg_promote(long);
static double __attribute__((__overloadable__)) __tg_promote(unsigned long);
static double __attribute__((__overloadable__)) __tg_promote(long long);
static double __attribute__((__overloadable__)) __tg_promote(unsigned long 
long);
static float __attribute__((__overloadable__)) __tg_promote(float);
static double __attribute__((__overloadable__)) __tg_promote(double);
static long double __attribute__((__overloadable__)) __tg_promote(long double);

static float _Complex __attribute__((__overloadable__)) __tg_promote(float 
_Complex);
static double _Complex __attribute__((__overloadable__)) __tg_promote(double 
_Complex);
static long double _Complex __attribute__((__overloadable__)) __tg_promote(long 
double _Complex);
# 105 "tgmath-hacked.h"
   { return func(__x,__y,__z); } static long double 
__attribute__((__overloadable__, __always_inline__)) __tg_func(long double __x, 
long double __y, long double __z) { return func##l(__x,__y,__z); }
# 158 "tgmath-hacked.h"
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_acos(float __x) { return ((float)acos((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_acos(double __x) { 
return acos(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_acos(long double __x) { return ((long 
double)acos((double)(__x))); } static float _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_acos(float _Complex 
__x) { return cacosf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_acos(double _Complex 
__x) { return cacos(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_acos(long double 
_Complex __x) { return cacosl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_asin(float __x) { return ((float)asin((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_asin(double __x) { 
return asin(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_asin(long double __x) { return ((long 
double)asin((double)(__x))); } static float _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_asin(float _Complex 
__x) { return casinf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_asin(double _Complex 
__x) { return casin(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_asin(long double 
_Complex __x) { return casinl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_atan(float __x) { return ((float)atan((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_atan(double __x) { 
return atan(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_atan(long double __x) { return ((long 
double)atan((double)(__x))); } static float _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_atan(float _Complex 
__x) { return catanf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_atan(double _Complex 
__x) { return catan(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_atan(long double 
_Complex __x) { return catanl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_acosh(float __x) { return acoshf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_acosh(double __x) { 
return acosh(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_acosh(long double __x) { return acoshl(__x); } static 
float _Complex __attribute__((__overloadable__, __always_inline__)) 
__tg_acosh(float _Complex __x) { return cacoshf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_acosh(double _Complex 
__x) { return cacosh(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_acosh(long double 
_Complex __x) { return cacoshl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_asinh(float __x) { return asinhf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_asinh(double __x) { 
return asinh(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_asinh(long double __x) { return asinhl(__x); } static 
float _Complex __attribute__((__overloadable__, __always_inline__)) 
__tg_asinh(float _Complex __x) { return casinhf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_asinh(double _Complex 
__x) { return casinh(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_asinh(long double 
_Complex __x) { return casinhl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_atanh(float __x) { return atanhf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_atanh(double __x) { 
return atanh(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_atanh(long double __x) { return atanhl(__x); } static 
float _Complex __attribute__((__overloadable__, __always_inline__)) 
__tg_atanh(float _Complex __x) { return catanhf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_atanh(double _Complex 
__x) { return catanh(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_atanh(long double 
_Complex __x) { return catanhl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_cos(float __x) { return ((float)cos((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_cos(double __x) { 
return cos(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_cos(long double __x) { return ((long 
double)cos((double)(__x))); } static float _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_cos(float _Complex 
__x) { return ccosf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_cos(double _Complex 
__x) { return ccos(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_cos(long double 
_Complex __x) { return ccosl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_sin(float __x) { return ((float)sin((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_sin(double __x) { 
return sin(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_sin(long double __x) { return ((long 
double)sin((double)(__x))); } static float _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_sin(float _Complex 
__x) { return csinf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_sin(double _Complex 
__x) { return csin(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_sin(long double 
_Complex __x) { return csinl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_tan(float __x) { return ((float)tan((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_tan(double __x) { 
return tan(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_tan(long double __x) { return ((long 
double)tan((double)(__x))); } static float _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_tan(float _Complex 
__x) { return ctanf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_tan(double _Complex 
__x) { return ctan(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_tan(long double 
_Complex __x) { return ctanl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_cosh(float __x) { return ((float)cosh((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_cosh(double __x) { 
return cosh(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_cosh(long double __x) { return ((long 
double)cosh((double)(__x))); } static float _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_cosh(float _Complex 
__x) { return ccoshf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_cosh(double _Complex 
__x) { return ccosh(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_cosh(long double 
_Complex __x) { return ccoshl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_sinh(float __x) { return ((float)sinh((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_sinh(double __x) { 
return sinh(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_sinh(long double __x) { return ((long 
double)sinh((double)(__x))); } static float _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_sinh(float _Complex 
__x) { return csinhf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_sinh(double _Complex 
__x) { return csinh(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_sinh(long double 
_Complex __x) { return csinhl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_tanh(float __x) { return ((float)tanh((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_tanh(double __x) { 
return tanh(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_tanh(long double __x) { return ((long 
double)tanh((double)(__x))); } static float _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_tanh(float _Complex 
__x) { return ctanhf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_tanh(double _Complex 
__x) { return ctanh(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_tanh(long double 
_Complex __x) { return ctanhl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_exp(float __x) { return ((float)exp((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_exp(double __x) { 
return exp(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_exp(long double __x) { return ((long 
double)exp((double)(__x))); } static float _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_exp(float _Complex 
__x) { return cexpf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_exp(double _Complex 
__x) { return cexp(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_exp(long double 
_Complex __x) { return cexpl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_log(float __x) { return ((float)log((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_log(double __x) { 
return log(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_log(long double __x) { return ((long 
double)log((double)(__x))); } static float _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_log(float _Complex 
__x) { return clogf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_log(double _Complex 
__x) { return clog(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_log(long double 
_Complex __x) { return clogl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_sqrt(float __x) { return ((float)sqrt((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_sqrt(double __x) { 
return sqrt(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_sqrt(long double __x) { return ((long 
double)sqrt((double)(__x))); } static float _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_sqrt(float _Complex 
__x) { return csqrtf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_sqrt(double _Complex 
__x) { return csqrt(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_sqrt(long double 
_Complex __x) { return csqrtl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_fabs(float __x) { return ((float)fabs((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_fabs(double __x) { 
return fabs(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_fabs(long double __x) { return ((long 
double)fabs((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_abs(float _Complex __x) { return cabsf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_abs(double _Complex 
__x) { return cabs(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_abs(long double _Complex __x) { return cabsl(__x); }
# 214 "tgmath-hacked.h"
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_pow(float __x, float __y) { return ((float)pow((double)(__x), 
(double)(__y))); } static double __attribute__((__overloadable__, 
__always_inline__)) __tg_pow(double __x, double __y) { return pow(__x,__y); } 
static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_pow(long double __x, long double __y) { return ((long 
double)pow((double)(__x), (double)(__y))); }
static float _Complex __attribute__((__overloadable__, __always_inline__)) 
__tg_pow(float _Complex __x, float _Complex __y) { return cpowf(__x,__y); } 
static double _Complex __attribute__((__overloadable__, __always_inline__)) 
__tg_pow(double _Complex __x, double _Complex __y) { return cpow(__x,__y); } 
static long double _Complex __attribute__((__overloadable__, 
__always_inline__)) __tg_pow(long double _Complex __x, long double _Complex 
__y) { return cpowl(__x,__y); }







static float __attribute__((__overloadable__, __always_inline__)) 
__tg_atan2(float __x, float __y) { return ((float)atan2((double)(__x), 
(double)(__y))); } static double __attribute__((__overloadable__, 
__always_inline__)) __tg_atan2(double __x, double __y) { return atan2(__x,__y); 
} static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_atan2(long double __x, long double __y) { return ((long 
double)atan2((double)(__x), (double)(__y))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_cbrt(float __x) { return cbrtf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_cbrt(double __x) { 
return cbrt(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_cbrt(long double __x) { return cbrtl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_ceil(float __x) { return ((float)ceil((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_ceil(double __x) { 
return ceil(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_ceil(long double __x) { return ((long 
double)ceil((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_copysign(float __x, float __y) { return copysignf(__x,__y); } static 
double __attribute__((__overloadable__, __always_inline__)) 
__tg_copysign(double __x, double __y) { return copysign(__x,__y); } static long 
double __attribute__((__overloadable__, __always_inline__)) __tg_copysign(long 
double __x, long double __y) { return copysignl(__x,__y); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_erf(float __x) { return erff(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_erf(double __x) { 
return erf(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_erf(long double __x) { return erfl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_erfc(float __x) { return erfcf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_erfc(double __x) { 
return erfc(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_erfc(long double __x) { return erfcl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_exp2(float __x) { return exp2f(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_exp2(double __x) { 
return exp2(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_exp2(long double __x) { return exp2l(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_expm1(float __x) { return expm1f(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_expm1(double __x) { 
return expm1(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_expm1(long double __x) { return expm1l(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_fdim(float __x, float __y) { return fdimf(__x,__y); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_fdim(double __x, 
double __y) { return fdim(__x,__y); } static long double 
__attribute__((__overloadable__, __always_inline__)) __tg_fdim(long double __x, 
long double __y) { return fdiml(__x,__y); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_floor(float __x) { return ((float)floor((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_floor(double __x) { 
return floor(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_floor(long double __x) { return ((long 
double)floor((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_fma(float __x, float __y, float __z) { return fmaf(__x,__y,__z); } static 
double __attribute__((__overloadable__, __always_inline__)) __tg_fma(double 
__x, double __y, double __z)
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_fmax(float __x, float __y) { return fmaxf(__x,__y); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_fmax(double __x, 
double __y) { return fmax(__x,__y); } static long double 
__attribute__((__overloadable__, __always_inline__)) __tg_fmax(long double __x, 
long double __y) { return fmaxl(__x,__y); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_fmin(float __x, float __y) { return fminf(__x,__y); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_fmin(double __x, 
double __y) { return fmin(__x,__y); } static long double 
__attribute__((__overloadable__, __always_inline__)) __tg_fmin(long double __x, 
long double __y) { return fminl(__x,__y); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_fmod(float __x, float __y) { return ((float)fmod((double)(__x), 
(double)(__y))); } static double __attribute__((__overloadable__, 
__always_inline__)) __tg_fmod(double __x, double __y) { return fmod(__x,__y); } 
static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_fmod(long double __x, long double __y) { return ((long 
double)fmod((double)(__x), (double)(__y))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_hypot(float __x, float __y) { return hypotf(__x,__y); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_hypot(double __x, 
double __y) { return hypot(__x,__y); } static long double 
__attribute__((__overloadable__, __always_inline__)) __tg_hypot(long double 
__x, long double __y) { return ((long double)_hypot((double)(__x), 
(double)(__y))); }
static int __attribute__((__overloadable__, __always_inline__)) 
__tg_ilogb(float __x) { return ilogbf(__x); } static int 
__attribute__((__overloadable__, __always_inline__)) __tg_ilogb(double __x) { 
return ilogb(__x); } static int __attribute__((__overloadable__, 
__always_inline__)) __tg_ilogb(long double __x) { return ilogbl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_lgamma(float __x) { return lgammaf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_lgamma(double __x) { 
return lgamma(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_lgamma(long double __x) { return lgammal(__x); }
static long long __attribute__((__overloadable__, __always_inline__)) 
__tg_llrint(float __x) { return llrintf(__x); } static long long 
__attribute__((__overloadable__, __always_inline__)) __tg_llrint(double __x) { 
return llrint(__x); } static long long __attribute__((__overloadable__, 
__always_inline__)) __tg_llrint(long double __x) { return llrintl(__x); }
static long long __attribute__((__overloadable__, __always_inline__)) 
__tg_llround(float __x) { return llroundf(__x); } static long long 
__attribute__((__overloadable__, __always_inline__)) __tg_llround(double __x) { 
return llround(__x); } static long long __attribute__((__overloadable__, 
__always_inline__)) __tg_llround(long double __x) { return llroundl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_log10(float __x) { return ((float)log10((double)(__x))); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_log10(double __x) { 
return log10(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_log10(long double __x) { return ((long 
double)log10((double)(__x))); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_log1p(float __x) { return log1pf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_log1p(double __x) { 
return log1p(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_log1p(long double __x) { return log1pl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_log2(float __x) { return log2f(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_log2(double __x) { 
return log2(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_log2(long double __x) { return log2l(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_logb(float __x) { return logbf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_logb(double __x) { 
return logb(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_logb(long double __x) { return logbl(__x); }
static long __attribute__((__overloadable__, __always_inline__)) 
__tg_lrint(float __x) { return lrintf(__x); } static long 
__attribute__((__overloadable__, __always_inline__)) __tg_lrint(double __x) { 
return lrint(__x); } static long __attribute__((__overloadable__, 
__always_inline__)) __tg_lrint(long double __x) { return lrintl(__x); }
static long __attribute__((__overloadable__, __always_inline__)) 
__tg_lround(float __x) { return lroundf(__x); } static long 
__attribute__((__overloadable__, __always_inline__)) __tg_lround(double __x) { 
return lround(__x); } static long __attribute__((__overloadable__, 
__always_inline__)) __tg_lround(long double __x) { return lroundl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_nearbyint(float __x) { return nearbyintf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_nearbyint(double __x) 
{ return nearbyint(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_nearbyint(long double __x) { return nearbyintl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_nextafter(float __x, float __y) { return nextafterf(__x,__y); } static 
double __attribute__((__overloadable__, __always_inline__)) 
__tg_nextafter(double __x, double __y) { return nextafter(__x,__y); } static 
long double __attribute__((__overloadable__, __always_inline__)) 
__tg_nextafter(long double __x, long double __y) { return nextafterl(__x,__y); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_reminder(float __x, float __y) { return reminderf(__x,__y); } static 
double __attribute__((__overloadable__, __always_inline__)) 
__tg_reminder(double __x, double __y) { return reminder(__x,__y); } static long 
double __attribute__((__overloadable__, __always_inline__)) __tg_reminder(long 
double __x, long double __y) { return reminderl(__x,__y); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_rint(float __x) { return rintf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_rint(double __x) { 
return rint(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_rint(long double __x) { return rintl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_round(float __x) { return roundf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_round(double __x) { 
return round(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_round(long double __x) { return roundl(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_tgamma(float __x) { return tgammaf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_tgamma(double __x) { 
return tgamma(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_tgamma(long double __x) { return tgammal(__x); }
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_trunc(float __x) { return truncf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_trunc(double __x) { 
return trunc(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_trunc(long double __x) { return truncl(__x); }




static float __attribute__((__overloadable__, __always_inline__)) 
__tg_frexp(float __x, int* __y) {return ((float)frexp((double)(__x),(__y)));}
static double __attribute__((__overloadable__, __always_inline__)) 
__tg_frexp(double __x, int* __y) {return frexp(__x, __y);}
static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_frexp(long double __x, int* __y) {return ((long 
double)frexp((double)(__x), (__y)));}


static float __attribute__((__overloadable__, __always_inline__)) 
__tg_ldexp(float __x, int __y) {return ((float)ldexp((double)(__x),(__y)));}
static double __attribute__((__overloadable__, __always_inline__)) 
__tg_ldexp(double __x, int __y) {return ldexp(__x, __y);}
static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_ldexp(long double __x, int __y) {return ((long double)ldexp((double)(__x), 
(__y)));}


static float __attribute__((__overloadable__, __always_inline__)) 
__tg_nexttoward(float __x, long double __y) {return nexttowardf(__x, __y);}

static double __attribute__((__overloadable__, __always_inline__)) 
__tg_nexttoward(double __x, long double __y) {return nexttoward(__x, __y);}

static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_nexttoward(long double __x, long double __y) {return nexttowardl(__x, 
__y);}



static float __attribute__((__overloadable__, __always_inline__)) 
__tg_remqo(float __x, float __y, int* __z) {return remquof(__x, __y, __z);}

static double __attribute__((__overloadable__, __always_inline__)) 
__tg_remqo(double __x, double __y, int* __z) {return remquo(__x, __y, __z);}

static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_remqo(long double __x,long double __y, int* __z) {return remquol(__x, __y, 
__z);}



static float __attribute__((__overloadable__, __always_inline__)) 
__tg_scalbn(float __x, int __y) {return scalbnf(__x, __y);}
static double __attribute__((__overloadable__, __always_inline__)) 
__tg_scalbn(double __x, int __y) {return scalbn(__x, __y);}
static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_scalbn(long double __x, int __y) {return scalbnl(__x, __y);}



static float __attribute__((__overloadable__, __always_inline__)) 
__tg_scalbln(float __x, long __y) {return scalblnf(__x, __y);}
static double __attribute__((__overloadable__, __always_inline__)) 
__tg_scalbln(double __x, long __y) {return scalbln(__x, __y);}
static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_scalbln(long double __x, long __y) {return scalblnl(__x, __y);}
# 396 "tgmath-hacked.h"
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_carg(float __x) {return 
((float)__tg_atan2((__typeof__(__tg_promote(((double)(0.F))) + 
__tg_promote(((double)(__x)))))((double)(0.F)), 
(__typeof__(__tg_promote(((double)(0.F))) + 
__tg_promote(((double)(__x)))))((double)(__x))));}
static double __attribute__((__overloadable__, __always_inline__)) 
__tg_carg(double __x) {return __tg_atan2((__typeof__(__tg_promote((0.)) + 
__tg_promote((__x))))(0.), (__typeof__(__tg_promote((0.)) + 
__tg_promote((__x))))(__x));}
static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_carg(long double __x) {return ((long 
double)__tg_atan2((__typeof__(__tg_promote(((double)(0.L))) + 
__tg_promote(((double)(__x)))))((double)(0.L)), 
(__typeof__(__tg_promote(((double)(0.L))) + 
__tg_promote(((double)(__x)))))((double)(__x))));}
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_arg(float _Complex __x) { return cargf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_arg(double _Complex 
__x) { return carg(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_arg(long double _Complex __x) { return cargl(__x); }


static float __attribute__((__overloadable__, __always_inline__)) 
__tg_cimag(float __x) {return 0;}
static double __attribute__((__overloadable__, __always_inline__)) 
__tg_cimag(double __x) {return 0;}
static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_cimag(long double __x) {return 0;}
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_imag(float _Complex __x) { return cimagf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_imag(double _Complex 
__x) { return cimag(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_imag(long double _Complex __x) { return cimagl(__x); }


static float _Complex __attribute__((__overloadable__, __always_inline__)) 
__tg_conj(float __x) {return __x;}
static double _Complex __attribute__((__overloadable__, __always_inline__)) 
__tg_conj(double __x) {return __x;}
static long double _Complex __attribute__((__overloadable__, 
__always_inline__)) __tg_conj(long double __x) {return __x;}
static float _Complex __attribute__((__overloadable__, __always_inline__)) 
__tg_onj(float _Complex __x) { return conjf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_onj(double _Complex 
__x) { return conj(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_onj(long double 
_Complex __x) { return conjl(__x); }


static float _Complex __attribute__((__overloadable__, __always_inline__)) 
__tg_cproj(float __x) {return cprojf(__x);}
static double _Complex __attribute__((__overloadable__, __always_inline__)) 
__tg_cproj(double __x) {return cproj(__x);}
static long double _Complex __attribute__((__overloadable__, 
__always_inline__)) __tg_cproj(long double __x) {return cprojl(__x);}
static float _Complex __attribute__((__overloadable__, __always_inline__)) 
__tg_proj(float _Complex __x) { return cprojf(__x); } static double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_proj(double _Complex 
__x) { return cproj(__x); } static long double _Complex 
__attribute__((__overloadable__, __always_inline__)) __tg_proj(long double 
_Complex __x) { return cprojl(__x); }


static float __attribute__((__overloadable__, __always_inline__)) 
__tg_creal(float __x) {return __x;}
static double __attribute__((__overloadable__, __always_inline__)) 
__tg_creal(double __x) {return __x;}
static long double __attribute__((__overloadable__, __always_inline__)) 
__tg_creal(long double __x) {return __x;}
static float __attribute__((__overloadable__, __always_inline__)) 
__tg_real(float _Complex __x) { return crealf(__x); } static double 
__attribute__((__overloadable__, __always_inline__)) __tg_real(double _Complex 
__x) { return creal(__x); } static long double __attribute__((__overloadable__, 
__always_inline__)) __tg_real(long double _Complex __x) { return creall(__x); }

_______________________________________________
cfe-commits mailing list
cfe-commits@cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits