core.stdc.tgmath

alias acos = acos;

alias acos = acosf;

alias acos = acosl;

alias acos = cacos;

alias acos = cacosf;

alias acos = core.stdc.complex.cacosl;

alias asin = asin;

alias asin = asinf;

alias asin = asinl;

alias asin = casin;

alias asin = casinf;

alias asin = core.stdc.complex.casinl;

alias atan = atan;

alias atan = atanf;

alias atan = atanl;

alias atan = catan;

alias atan = catanf;

alias atan = core.stdc.complex.catanl;

alias atan2 = atan2;

alias atan2 = atan2f;

alias atan2 = core.stdc.math.atan2l;

alias cos = cos;

alias cos = cosf;

alias cos = cosl;

alias cos = ccos;

alias cos = ccosf;

alias cos = core.stdc.complex.ccosl;

alias sin = sin;

alias sin = sinf;

alias sin = core.stdc.math.sinl;

alias csin = csin;

alias csin = csinf;

alias csin = core.stdc.complex.csinl;

alias tan = tan;

alias tan = tanf;

alias tan = tanl;

alias tan = ctan;

alias tan = ctanf;

alias tan = core.stdc.complex.ctanl;

alias acosh = acosh;

alias acosh = acoshf;

alias acosh = acoshl;

alias acosh = cacosh;

alias acosh = cacoshf;

alias acosh = core.stdc.complex.cacoshl;

alias asinh = asinh;

alias asinh = asinhf;

alias asinh = asinhl;

alias asinh = casinh;

alias asinh = casinhf;

alias asinh = core.stdc.complex.casinhl;

alias atanh = atanh;

alias atanh = atanhf;

alias atanh = atanhl;

alias atanh = catanh;

alias atanh = catanhf;

alias atanh = core.stdc.complex.catanhl;

alias cosh = cosh;

alias cosh = coshf;

alias cosh = coshl;

alias cosh = ccosh;

alias cosh = ccoshf;

alias cosh = core.stdc.complex.ccoshl;

alias sinh = sinh;

alias sinh = sinhf;

alias sinh = sinhl;

alias sinh = csinh;

alias sinh = csinhf;

alias sinh = core.stdc.complex.csinhl;

alias tanh = tanh;

alias tanh = tanhf;

alias tanh = tanhl;

alias tanh = ctanh;

alias tanh = ctanhf;

alias tanh = core.stdc.complex.ctanhl;

alias exp = exp;

alias exp = expf;

alias exp = expl;

alias exp = cexp;

alias exp = cexpf;

alias exp = core.stdc.complex.cexpl;

alias exp2 = exp2;

alias exp2 = exp2f;

alias exp2 = core.stdc.math.exp2l;

alias expm1 = expm1;

alias expm1 = expm1f;

alias expm1 = core.stdc.math.expm1l;

alias frexp = frexp;

alias frexp = frexpf;

alias frexp = core.stdc.math.frexpl;

alias ilogb = ilogb;

alias ilogb = ilogbf;

alias ilogb = core.stdc.math.ilogbl;

alias ldexp = ldexp;

alias ldexp = ldexpf;

alias ldexp = core.stdc.math.ldexpl;

alias log = log;

alias log = logf;

alias log = logl;

alias log = clog;

alias log = clogf;

alias log = core.stdc.complex.clogl;

alias log10 = log10;

alias log10 = log10f;

alias log10 = core.stdc.math.log10l;

alias log1p = log1p;

alias log1p = log1pf;

alias log1p = core.stdc.math.log1pl;

alias log2 = log2;

alias log2 = log2f;

alias log2 = core.stdc.math.log2l;

alias logb = logb;

alias logb = logbf;

alias logb = core.stdc.math.logbl;

alias modf = modf;

alias modf = modff;

alias modf = core.stdc.math.modfl;

alias scalbn = scalbn;

alias scalbn = scalbnf;

alias scalbn = core.stdc.math.scalbnl;

alias scalbln = scalbln;

alias scalbln = scalblnf;

alias scalbln = core.stdc.math.scalblnl;

alias cbrt = cbrt;

alias cbrt = cbrtf;

alias cbrt = core.stdc.math.cbrtl;

alias fabs = fabs;

alias fabs = fabsf;

alias fabs = fabsl;

alias fabs = cabs;

alias fabs = cabsf;

alias fabs = core.stdc.complex.cabsl;

alias hypot = hypot;

alias hypot = hypotf;

alias hypot = core.stdc.math.hypotl;

alias pow = pow;

alias pow = powf;

alias pow = powl;

alias pow = cpow;

alias pow = cpowf;

alias pow = core.stdc.complex.cpowl;

alias sqrt = sqrt;

alias sqrt = sqrtf;

alias sqrt = sqrtl;

alias sqrt = csqrt;

alias sqrt = csqrtf;

alias sqrt = core.stdc.complex.csqrtl;

alias erf = erf;

alias erf = erff;

alias erf = core.stdc.math.erfl;

alias erfc = erfc;

alias erfc = erfcf;

alias erfc = core.stdc.math.erfcl;

alias lgamma = lgamma;

alias lgamma = lgammaf;

alias lgamma = core.stdc.math.lgammal;

alias tgamma = tgamma;

alias tgamma = tgammaf;

alias tgamma = core.stdc.math.tgammal;

alias ceil = ceil;

alias ceil = ceilf;

alias ceil = core.stdc.math.ceill;

alias floor = floor;

alias floor = floorf;

alias floor = core.stdc.math.floorl;

alias nearbyint = nearbyint;

alias nearbyint = nearbyintf;

alias nearbyint = core.stdc.math.nearbyintl;

alias rint = rint;

alias rint = rintf;

alias rint = core.stdc.math.rintl;

alias lrint = lrint;

alias lrint = lrintf;

alias lrint = core.stdc.math.lrintl;

alias llrint = llrint;

alias llrint = llrintf;

alias llrint = core.stdc.math.llrintl;

alias round = round;

alias round = roundf;

alias round = core.stdc.math.roundl;

alias lround = lround;

alias lround = lroundf;

alias lround = core.stdc.math.lroundl;

alias llround = llround;

alias llround = llroundf;

alias llround = core.stdc.math.llroundl;

alias trunc = trunc;

alias trunc = truncf;

alias trunc = core.stdc.math.truncl;

alias fmod = fmod;

alias fmod = fmodf;

alias fmod = core.stdc.math.fmodl;

alias remainder = remainder;

alias remainder = remainderf;

alias remainder = core.stdc.math.remainderl;

alias remquo = remquo;

alias remquo = remquof;

alias remquo = core.stdc.math.remquol;

alias copysign = copysign;

alias copysign = copysignf;

alias copysign = core.stdc.math.copysignl;

alias nan = nan;

alias nan = nanf;

alias nan = core.stdc.math.nanl;

alias nextafter = nextafter;

alias nextafter = nextafterf;

alias nextafter = core.stdc.math.nextafterl;

alias nexttoward = nexttoward;

alias nexttoward = nexttowardf;

alias nexttoward = core.stdc.math.nexttowardl;

alias fdim = fdim;

alias fdim = fdimf;

alias fdim = core.stdc.math.fdiml;

alias fmax = fmax;

alias fmax = fmaxf;

alias fmax = core.stdc.math.fmaxl;

alias fmin = fmin;

alias fmin = fmin;

alias fmin = core.stdc.math.fminl;

alias fma = fma;

alias fma = fmaf;

alias fma = core.stdc.math.fmal;

alias carg = carg;

alias carg = cargf;

alias carg = core.stdc.complex.cargl;

alias cimag = cimag;

alias cimag = cimagf;

alias cimag = core.stdc.complex.cimagl;

alias conj = conj;

alias conj = conjf;

alias conj = core.stdc.complex.conjl;

alias cproj = cproj;

alias cproj = cprojf;

alias cproj = core.stdc.complex.cprojl;