text: /*===---- tgmath.h - Standard header for type generic math ----------------===*\
   *
   * Based on Clang 3.7 - clang/lib/Headers/tgmath.h - Commit 75883618
   * https://github.com/llvm-mirror/clang/blob/75883618c9d91fbabe20350c875fce48f519ada6/lib/Headers/tgmath.h
   *
   * Copyright (c) 2009 Howard Hinnant
   *
   * Permission is hereby granted, free of charge, to any person obtaining a copy
   * of this software and associated documentation files (the "Software"), to deal
   * in the Software without restriction, including without limitation the rights
   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   * copies of the Software, and to permit persons to whom the Software is
   * furnished to do so, subject to the following conditions:
   *
   * The above copyright notice and this permission notice shall be included in
   * all copies or substantial portions of the Software.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   * THE SOFTWARE.
   *
  \*===----------------------------------------------------------------------===*/
  
  #ifndef __TGMATH_H
  #define __TGMATH_H
  
  /* C99 7.22 Type-generic math <tgmath.h>. */
  #include <cmath>
  
  /* Type genericity for C++ is handled with overloading in cmath. */
  #if !defined(__cplusplus) && !defined(RC_INVOKED)
  #include <complex.h>
  
  #define _TG_ATTRSp __attribute__((__overloadable__))
  #define _TG_ATTRS __attribute__((__overloadable__, __always_inline__))
  
  // promotion
  
  typedef void _Argument_type_is_not_arithmetic;
  static _Argument_type_is_not_arithmetic __tg_promote(...) __attribute__((__unavailable__, __overloadable__));
  static double _TG_ATTRSp __tg_promote(int);
  static double _TG_ATTRSp __tg_promote(unsigned int);
  static double _TG_ATTRSp __tg_promote(long);
  static double _TG_ATTRSp __tg_promote(unsigned long);
  static double _TG_ATTRSp __tg_promote(long long);
  static double _TG_ATTRSp __tg_promote(unsigned long long);
  static float _TG_ATTRSp __tg_promote(float);
  static double _TG_ATTRSp __tg_promote(double);
  static long double _TG_ATTRSp __tg_promote(long double);
  static float _Complex _TG_ATTRSp __tg_promote(float _Complex);
  static double _Complex _TG_ATTRSp __tg_promote(double _Complex);
  static long double _Complex _TG_ATTRSp __tg_promote(long double _Complex);
  
  #define __tg_promote1(__x) (__typeof__(__tg_promote(__x)))
  #define __tg_promote2(__x, __y) (__typeof__(__tg_promote(__x) + __tg_promote(__y)))
  #define __tg_promote3(__x, __y, __z) (__typeof__(__tg_promote(__x) + __tg_promote(__y) + __tg_promote(__z)))
  
  // acos
  
  static float _TG_ATTRS __tg_acos(float __x) {
      return acosf(__x);
  }
  
  static double _TG_ATTRS __tg_acos(double __x) {
      return acos(__x);
  }
  
  static long double _TG_ATTRS __tg_acos(long double __x) {
      return acosl(__x);
  }
  
  static float _Complex _TG_ATTRS __tg_acos(float _Complex __x) {
      return cacosf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_acos(double _Complex __x) {
      return cacos(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_acos(long double _Complex __x) {
      return cacosl(__x);
  }
  
  #undef acos
  #define acos(__x) __tg_acos(__tg_promote1((__x))(__x))
  
  // asin
  
  static float _TG_ATTRS __tg_asin(float __x) {
      return asinf(__x);
  }
  
  static double _TG_ATTRS __tg_asin(double __x) {
      return asin(__x);
  }
  
  static long double _TG_ATTRS __tg_asin(long double __x) {
      return asinl(__x);
  }
  
  static float _Complex _TG_ATTRS __tg_asin(float _Complex __x) {
      return casinf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_asin(double _Complex __x) {
      return casin(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_asin(long double _Complex __x) {
      return casinl(__x);
  }
  
  #undef asin
  #define asin(__x) __tg_asin(__tg_promote1((__x))(__x))
  
  // atan
  
  static float _TG_ATTRS __tg_atan(float __x) {
      return atanf(__x);
  }
  
  static double _TG_ATTRS __tg_atan(double __x) {
      return atan(__x);
  }
  
  static long double _TG_ATTRS __tg_atan(long double __x) {
      return atanl(__x);
  }
  
  static float _Complex _TG_ATTRS __tg_atan(float _Complex __x) {
      return catanf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_atan(double _Complex __x) {
      return catan(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_atan(long double _Complex __x) {
      return catanl(__x);
  }
  
  #undef atan
  #define atan(__x) __tg_atan(__tg_promote1((__x))(__x))
  
  // acosh
  
  static float _TG_ATTRS __tg_acosh(float __x) {
      return acoshf(__x);
  }
  
  static double _TG_ATTRS __tg_acosh(double __x) {
      return acosh(__x);
  }
  
  static long double _TG_ATTRS __tg_acosh(long double __x) {
      return acoshl(__x);
  }
  
  static float _Complex _TG_ATTRS __tg_acosh(float _Complex __x) {
      return cacoshf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_acosh(double _Complex __x) {
      return cacosh(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_acosh(long double _Complex __x) {
      return cacoshl(__x);
  }
  
  #undef acosh
  #define acosh(__x) __tg_acosh(__tg_promote1((__x))(__x))
  
  // asinh
  
  static float _TG_ATTRS __tg_asinh(float __x) {
      return asinhf(__x);
  }
  
  static double _TG_ATTRS __tg_asinh(double __x) {
      return asinh(__x);
  }
  
  static long double _TG_ATTRS __tg_asinh(long double __x) {
      return asinhl(__x);
  }
  
  static float _Complex _TG_ATTRS __tg_asinh(float _Complex __x) {
      return casinhf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_asinh(double _Complex __x) {
      return casinh(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_asinh(long double _Complex __x) {
      return casinhl(__x);
  }
  
  #undef asinh
  #define asinh(__x) __tg_asinh(__tg_promote1((__x))(__x))
  
  // atanh
  
  static float _TG_ATTRS __tg_atanh(float __x) {
      return atanhf(__x);
  }
  
  static double _TG_ATTRS __tg_atanh(double __x) {
      return atanh(__x);
  }
  
  static long double _TG_ATTRS __tg_atanh(long double __x) {
      return atanhl(__x);
  }
  
  static float _Complex _TG_ATTRS __tg_atanh(float _Complex __x) {
      return catanhf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_atanh(double _Complex __x) {
      return catanh(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_atanh(long double _Complex __x) {
      return catanhl(__x);
  }
  
  #undef atanh
  #define atanh(__x) __tg_atanh(__tg_promote1((__x))(__x))
  
  // cos
  
  static float _TG_ATTRS __tg_cos(float __x) {
      return cosf(__x);
  }
  
  static double _TG_ATTRS __tg_cos(double __x) {
      return cos(__x);
  }
  
  static long double _TG_ATTRS __tg_cos(long double __x) {
      return cosl(__x);
  }
  
  static float _Complex _TG_ATTRS __tg_cos(float _Complex __x) {
      return ccosf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_cos(double _Complex __x) {
      return ccos(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_cos(long double _Complex __x) {
      return ccosl(__x);
  }
  
  #undef cos
  #define cos(__x) __tg_cos(__tg_promote1((__x))(__x))
  
  // sin
  
  static float _TG_ATTRS __tg_sin(float __x) {
      return sinf(__x);
  }
  
  static double _TG_ATTRS __tg_sin(double __x) {
      return sin(__x);
  }
  
  static long double _TG_ATTRS __tg_sin(long double __x) {
      return sinl(__x);
  }
  
  static float _Complex _TG_ATTRS __tg_sin(float _Complex __x) {
      return csinf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_sin(double _Complex __x) {
      return csin(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_sin(long double _Complex __x) {
      return csinl(__x);
  }
  
  #undef sin
  #define sin(__x) __tg_sin(__tg_promote1((__x))(__x))
  
  // tan
  
  static float _TG_ATTRS __tg_tan(float __x) {
      return tanf(__x);
  }
  
  static double _TG_ATTRS __tg_tan(double __x) {
      return tan(__x);
  }
  
  static long double _TG_ATTRS __tg_tan(long double __x) {
      return tanl(__x);
  }
  
  static float _Complex _TG_ATTRS __tg_tan(float _Complex __x) {
      return ctanf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_tan(double _Complex __x) {
      return ctan(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_tan(long double _Complex __x) {
      return ctanl(__x);
  }
  
  #undef tan
  #define tan(__x) __tg_tan(__tg_promote1((__x))(__x))
  
  // cosh
  
  static float _TG_ATTRS __tg_cosh(float __x) {
      return coshf(__x);
  }
  
  static double _TG_ATTRS __tg_cosh(double __x) {
      return cosh(__x);
  }
  
  static long double _TG_ATTRS __tg_cosh(long double __x) {
      return coshl(__x);
  }
  
  static float _Complex _TG_ATTRS __tg_cosh(float _Complex __x) {
      return ccoshf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_cosh(double _Complex __x) {
      return ccosh(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_cosh(long double _Complex __x) {
      return ccoshl(__x);
  }
  
  #undef cosh
  #define cosh(__x) __tg_cosh(__tg_promote1((__x))(__x))
  
  // sinh
  
  static float _TG_ATTRS __tg_sinh(float __x) {
      return sinhf(__x);
  }
  
  static double _TG_ATTRS __tg_sinh(double __x) {
      return sinh(__x);
  }
  
  static long double _TG_ATTRS __tg_sinh(long double __x) {
      return sinhl(__x);
  }
  
  static float _Complex _TG_ATTRS __tg_sinh(float _Complex __x) {
      return csinhf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_sinh(double _Complex __x) {
      return csinh(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_sinh(long double _Complex __x) {
      return csinhl(__x);
  }
  
  #undef sinh
  #define sinh(__x) __tg_sinh(__tg_promote1((__x))(__x))
  
  // tanh
  
  static float _TG_ATTRS __tg_tanh(float __x) {
      return tanhf(__x);
  }
  
  static double _TG_ATTRS __tg_tanh(double __x) {
      return tanh(__x);
  }
  
  static long double _TG_ATTRS __tg_tanh(long double __x) {
      return tanhl(__x);
  }
  
  static float _Complex _TG_ATTRS __tg_tanh(float _Complex __x) {
      return ctanhf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_tanh(double _Complex __x) {
      return ctanh(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_tanh(long double _Complex __x) {
      return ctanhl(__x);
  }
  
  #undef tanh
  #define tanh(__x) __tg_tanh(__tg_promote1((__x))(__x))
  
  // exp
  
  static float _TG_ATTRS __tg_exp(float __x) {
      return expf(__x);
  }
  
  static double _TG_ATTRS __tg_exp(double __x) {
      return exp(__x);
  }
  
  static long double _TG_ATTRS __tg_exp(long double __x) {
      return expl(__x);
  }
  
  static float _Complex _TG_ATTRS __tg_exp(float _Complex __x) {
      return cexpf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_exp(double _Complex __x) {
      return cexp(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_exp(long double _Complex __x) {
      return cexpl(__x);
  }
  
  #undef exp
  #define exp(__x) __tg_exp(__tg_promote1((__x))(__x))
  
  // log
  
  static float _TG_ATTRS __tg_log(float __x) {
      return logf(__x);
  }
  
  static double _TG_ATTRS __tg_log(double __x) {
      return log(__x);
  }
  
  static long double _TG_ATTRS __tg_log(long double __x) {
      return logl(__x);
  }
  
  static float _Complex _TG_ATTRS __tg_log(float _Complex __x) {
      return clogf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_log(double _Complex __x) {
      return clog(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_log(long double _Complex __x) {
      return clogl(__x);
  }
  
  #undef log
  #define log(__x) __tg_log(__tg_promote1((__x))(__x))
  
  // pow
  
  static float _TG_ATTRS __tg_pow(float __x, float __y) {
      return powf(__x, __y);
  }
  
  static double _TG_ATTRS __tg_pow(double __x, double __y) {
      return pow(__x, __y);
  }
  
  static long double _TG_ATTRS __tg_pow(long double __x, long double __y) {
      return powl(__x, __y);
  }
  
  static float _Complex _TG_ATTRS __tg_pow(float _Complex __x, float _Complex __y) {
      return cpowf(__x, __y);
  }
  
  static double _Complex _TG_ATTRS __tg_pow(double _Complex __x, double _Complex __y) {
      return cpow(__x, __y);
  }
  
  static long double _Complex _TG_ATTRS __tg_pow(long double _Complex __x, long double _Complex __y) {
      return cpowl(__x, __y);
  }
  
  #undef pow
  #define pow(__x, __y) __tg_pow(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))
  
  // sqrt
  
  static float _TG_ATTRS __tg_sqrt(float __x) {
      return sqrtf(__x);
  }
  
  static double _TG_ATTRS __tg_sqrt(double __x) {
      return sqrt(__x);
  }
  
  static long double _TG_ATTRS __tg_sqrt(long double __x) {
      return sqrtl(__x);
  }
  
  static float _Complex _TG_ATTRS __tg_sqrt(float _Complex __x) {
      return csqrtf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_sqrt(double _Complex __x) {
      return csqrt(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_sqrt(long double _Complex __x) {
      return csqrtl(__x);
  }
  
  #undef sqrt
  #define sqrt(__x) __tg_sqrt(__tg_promote1((__x))(__x))
  
  // fabs
  
  static float _TG_ATTRS __tg_fabs(float __x) {
      return fabsf(__x);
  }
  
  static double _TG_ATTRS __tg_fabs(double __x) {
      return fabs(__x);
  }
  
  static long double _TG_ATTRS __tg_fabs(long double __x) {
      return fabsl(__x);
  }
  
  static float _TG_ATTRS __tg_fabs(float _Complex __x) {
      return cabsf(__x);
  }
  
  static double _TG_ATTRS __tg_fabs(double _Complex __x) {
      return cabs(__x);
  }
  
  static long double _TG_ATTRS __tg_fabs(long double _Complex __x) {
      return cabsl(__x);
  }
  
  #undef fabs
  #define fabs(__x) __tg_fabs(__tg_promote1((__x))(__x))
  
  // atan2
  
  static float _TG_ATTRS __tg_atan2(float __x, float __y) {
      return atan2f(__x, __y);
  }
  
  static double _TG_ATTRS __tg_atan2(double __x, double __y) {
      return atan2(__x, __y);
  }
  
  static long double _TG_ATTRS __tg_atan2(long double __x, long double __y) {
      return atan2l(__x, __y);
  }
  
  #undef atan2
  #define atan2(__x, __y) __tg_atan2(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))
  
  // cbrt
  
  static float _TG_ATTRS __tg_cbrt(float __x) {
      return cbrtf(__x);
  }
  
  static double _TG_ATTRS __tg_cbrt(double __x) {
      return cbrt(__x);
  }
  
  static long double _TG_ATTRS __tg_cbrt(long double __x) {
      return cbrtl(__x);
  }
  
  #undef cbrt
  #define cbrt(__x) __tg_cbrt(__tg_promote1((__x))(__x))
  
  // ceil
  
  static float _TG_ATTRS __tg_ceil(float __x) {
      return ceilf(__x);
  }
  
  static double _TG_ATTRS __tg_ceil(double __x) {
      return ceil(__x);
  }
  
  static long double _TG_ATTRS __tg_ceil(long double __x) {
      return ceill(__x);
  }
  
  #undef ceil
  #define ceil(__x) __tg_ceil(__tg_promote1((__x))(__x))
  
  // copysign
  
  static float _TG_ATTRS __tg_copysign(float __x, float __y) {
      return copysignf(__x, __y);
  }
  
  static double _TG_ATTRS __tg_copysign(double __x, double __y) {
      return copysign(__x, __y);
  }
  
  static long double _TG_ATTRS __tg_copysign(long double __x, long double __y) {
      return copysignl(__x, __y);
  }
  
  #undef copysign
  #define copysign(__x, __y) __tg_copysign(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))
  
  // erf
  
  static float _TG_ATTRS __tg_erf(float __x) {
      return erff(__x);
  }
  
  static double _TG_ATTRS __tg_erf(double __x) {
      return erf(__x);
  }
  
  static long double _TG_ATTRS __tg_erf(long double __x) {
      return erfl(__x);
  }
  
  #undef erf
  #define erf(__x) __tg_erf(__tg_promote1((__x))(__x))
  
  // erfc
  
  static float _TG_ATTRS __tg_erfc(float __x) {
      return erfcf(__x);
  }
  
  static double _TG_ATTRS __tg_erfc(double __x) {
      return erfc(__x);
  }
  
  static long double _TG_ATTRS __tg_erfc(long double __x) {
      return erfcl(__x);
  }
  
  #undef erfc
  #define erfc(__x) __tg_erfc(__tg_promote1((__x))(__x))
  
  // exp2
  
  static float _TG_ATTRS __tg_exp2(float __x) {
      return exp2f(__x);
  }
  
  static double _TG_ATTRS __tg_exp2(double __x) {
      return exp2(__x);
  }
  
  static long double _TG_ATTRS __tg_exp2(long double __x) {
      return exp2l(__x);
  }
  
  #undef exp2
  #define exp2(__x) __tg_exp2(__tg_promote1((__x))(__x))
  
  // expm1
  
  static float _TG_ATTRS __tg_expm1(float __x) {
      return expm1f(__x);
  }
  
  static double _TG_ATTRS __tg_expm1(double __x) {
      return expm1(__x);
  }
  
  static long double _TG_ATTRS __tg_expm1(long double __x) {
      return expm1l(__x);
  }
  
  #undef expm1
  #define expm1(__x) __tg_expm1(__tg_promote1((__x))(__x))
  
  // fdim
  
  static float _TG_ATTRS __tg_fdim(float __x, float __y) {
      return fdimf(__x, __y);
  }
  
  static double _TG_ATTRS __tg_fdim(double __x, double __y) {
      return fdim(__x, __y);
  }
  
  static long double _TG_ATTRS __tg_fdim(long double __x, long double __y) {
      return fdiml(__x, __y);
  }
  
  #undef fdim
  #define fdim(__x, __y) __tg_fdim(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))
  
  // floor
  
  static float _TG_ATTRS __tg_floor(float __x) {
      return floorf(__x);
  }
  
  static double _TG_ATTRS __tg_floor(double __x) {
      return floor(__x);
  }
  
  static long double _TG_ATTRS __tg_floor(long double __x) {
      return floorl(__x);
  }
  
  #undef floor
  #define floor(__x) __tg_floor(__tg_promote1((__x))(__x))
  
  // fma
  
  static float _TG_ATTRS __tg_fma(float __x, float __y, float __z) {
      return fmaf(__x, __y, __z);
  }
  
  static double _TG_ATTRS __tg_fma(double __x, double __y, double __z) {
      return fma(__x, __y, __z);
  }
  
  static long double _TG_ATTRS __tg_fma(long double __x, long double __y, long double __z) {
      return fmal(__x, __y, __z);
  }
  
  #undef fma
  #define fma(__x, __y, __z) \
      __tg_fma(__tg_promote3((__x), (__y), (__z))(__x), __tg_promote3((__x), (__y), (__z))(__y), __tg_promote3((__x), (__y), (__z))(__z))
  
  // fmax
  
  static float _TG_ATTRS __tg_fmax(float __x, float __y) {
      return fmaxf(__x, __y);
  }
  
  static double _TG_ATTRS __tg_fmax(double __x, double __y) {
      return fmax(__x, __y);
  }
  
  static long double _TG_ATTRS __tg_fmax(long double __x, long double __y) {
      return fmaxl(__x, __y);
  }
  
  #undef fmax
  #define fmax(__x, __y) __tg_fmax(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))
  
  // fmin
  
  static float _TG_ATTRS __tg_fmin(float __x, float __y) {
      return fminf(__x, __y);
  }
  
  static double _TG_ATTRS __tg_fmin(double __x, double __y) {
      return fmin(__x, __y);
  }
  
  static long double _TG_ATTRS __tg_fmin(long double __x, long double __y) {
      return fminl(__x, __y);
  }
  
  #undef fmin
  #define fmin(__x, __y) __tg_fmin(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))
  
  // fmod
  
  static float _TG_ATTRS __tg_fmod(float __x, float __y) {
      return fmodf(__x, __y);
  }
  
  static double _TG_ATTRS __tg_fmod(double __x, double __y) {
      return fmod(__x, __y);
  }
  
  static long double _TG_ATTRS __tg_fmod(long double __x, long double __y) {
      return fmodl(__x, __y);
  }
  
  #undef fmod
  #define fmod(__x, __y) __tg_fmod(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))
  
  // frexp
  
  static float _TG_ATTRS __tg_frexp(float __x, int* __y) {
      return frexpf(__x, __y);
  }
  
  static double _TG_ATTRS __tg_frexp(double __x, int* __y) {
      return frexp(__x, __y);
  }
  
  static long double _TG_ATTRS __tg_frexp(long double __x, int* __y) {
      return frexpl(__x, __y);
  }
  
  #undef frexp
  #define frexp(__x, __y) __tg_frexp(__tg_promote1((__x))(__x), __y)
  
  // hypot
  
  static float _TG_ATTRS __tg_hypot(float __x, float __y) {
      return hypotf(__x, __y);
  }
  
  static double _TG_ATTRS __tg_hypot(double __x, double __y) {
      return hypot(__x, __y);
  }
  
  static long double _TG_ATTRS __tg_hypot(long double __x, long double __y) {
      return hypotl(__x, __y);
  }
  
  #undef hypot
  #define hypot(__x, __y) __tg_hypot(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))
  
  // ilogb
  
  static int _TG_ATTRS __tg_ilogb(float __x) {
      return ilogbf(__x);
  }
  
  static int _TG_ATTRS __tg_ilogb(double __x) {
      return ilogb(__x);
  }
  
  static int _TG_ATTRS __tg_ilogb(long double __x) {
      return ilogbl(__x);
  }
  
  #undef ilogb
  #define ilogb(__x) __tg_ilogb(__tg_promote1((__x))(__x))
  
  // ldexp
  
  static float _TG_ATTRS __tg_ldexp(float __x, int __y) {
      return ldexpf(__x, __y);
  }
  
  static double _TG_ATTRS __tg_ldexp(double __x, int __y) {
      return ldexp(__x, __y);
  }
  
  static long double _TG_ATTRS __tg_ldexp(long double __x, int __y) {
      return ldexpl(__x, __y);
  }
  
  #undef ldexp
  #define ldexp(__x, __y) __tg_ldexp(__tg_promote1((__x))(__x), __y)
  
  // lgamma
  
  static float _TG_ATTRS __tg_lgamma(float __x) {
      return lgammaf(__x);
  }
  
  static double _TG_ATTRS __tg_lgamma(double __x) {
      return lgamma(__x);
  }
  
  static long double _TG_ATTRS __tg_lgamma(long double __x) {
      return lgammal(__x);
  }
  
  #undef lgamma
  #define lgamma(__x) __tg_lgamma(__tg_promote1((__x))(__x))
  
  // llrint
  
  static long long _TG_ATTRS __tg_llrint(float __x) {
      return llrintf(__x);
  }
  
  static long long _TG_ATTRS __tg_llrint(double __x) {
      return llrint(__x);
  }
  
  static long long _TG_ATTRS __tg_llrint(long double __x) {
      return llrintl(__x);
  }
  
  #undef llrint
  #define llrint(__x) __tg_llrint(__tg_promote1((__x))(__x))
  
  // llround
  
  static long long _TG_ATTRS __tg_llround(float __x) {
      return llroundf(__x);
  }
  
  static long long _TG_ATTRS __tg_llround(double __x) {
      return llround(__x);
  }
  
  static long long _TG_ATTRS __tg_llround(long double __x) {
      return llroundl(__x);
  }
  
  #undef llround
  #define llround(__x) __tg_llround(__tg_promote1((__x))(__x))
  
  // log10
  
  static float _TG_ATTRS __tg_log10(float __x) {
      return log10f(__x);
  }
  
  static double _TG_ATTRS __tg_log10(double __x) {
      return log10(__x);
  }
  
  static long double _TG_ATTRS __tg_log10(long double __x) {
      return log10l(__x);
  }
  
  #undef log10
  #define log10(__x) __tg_log10(__tg_promote1((__x))(__x))
  
  // log1p
  
  static float _TG_ATTRS __tg_log1p(float __x) {
      return log1pf(__x);
  }
  
  static double _TG_ATTRS __tg_log1p(double __x) {
      return log1p(__x);
  }
  
  static long double _TG_ATTRS __tg_log1p(long double __x) {
      return log1pl(__x);
  }
  
  #undef log1p
  #define log1p(__x) __tg_log1p(__tg_promote1((__x))(__x))
  
  // log2
  
  static float _TG_ATTRS __tg_log2(float __x) {
      return log2f(__x);
  }
  
  static double _TG_ATTRS __tg_log2(double __x) {
      return log2(__x);
  }
  
  static long double _TG_ATTRS __tg_log2(long double __x) {
      return log2l(__x);
  }
  
  #undef log2
  #define log2(__x) __tg_log2(__tg_promote1((__x))(__x))
  
  // logb
  
  static float _TG_ATTRS __tg_logb(float __x) {
      return logbf(__x);
  }
  
  static double _TG_ATTRS __tg_logb(double __x) {
      return logb(__x);
  }
  
  static long double _TG_ATTRS __tg_logb(long double __x) {
      return logbl(__x);
  }
  
  #undef logb
  #define logb(__x) __tg_logb(__tg_promote1((__x))(__x))
  
  // lrint
  
  static long _TG_ATTRS __tg_lrint(float __x) {
      return lrintf(__x);
  }
  
  static long _TG_ATTRS __tg_lrint(double __x) {
      return lrint(__x);
  }
  
  static long _TG_ATTRS __tg_lrint(long double __x) {
      return lrintl(__x);
  }
  
  #undef lrint
  #define lrint(__x) __tg_lrint(__tg_promote1((__x))(__x))
  
  // lround
  
  static long _TG_ATTRS __tg_lround(float __x) {
      return lroundf(__x);
  }
  
  static long _TG_ATTRS __tg_lround(double __x) {
      return lround(__x);
  }
  
  static long _TG_ATTRS __tg_lround(long double __x) {
      return lroundl(__x);
  }
  
  #undef lround
  #define lround(__x) __tg_lround(__tg_promote1((__x))(__x))
  
  // nearbyint
  
  static float _TG_ATTRS __tg_nearbyint(float __x) {
      return nearbyintf(__x);
  }
  
  static double _TG_ATTRS __tg_nearbyint(double __x) {
      return nearbyint(__x);
  }
  
  static long double _TG_ATTRS __tg_nearbyint(long double __x) {
      return nearbyintl(__x);
  }
  
  #undef nearbyint
  #define nearbyint(__x) __tg_nearbyint(__tg_promote1((__x))(__x))
  
  // nextafter
  
  static float _TG_ATTRS __tg_nextafter(float __x, float __y) {
      return nextafterf(__x, __y);
  }
  
  static double _TG_ATTRS __tg_nextafter(double __x, double __y) {
      return nextafter(__x, __y);
  }
  
  static long double _TG_ATTRS __tg_nextafter(long double __x, long double __y) {
      return nextafterl(__x, __y);
  }
  
  #undef nextafter
  #define nextafter(__x, __y) __tg_nextafter(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))
  
  // nexttoward
  
  static float _TG_ATTRS __tg_nexttoward(float __x, long double __y) {
      return nexttowardf(__x, __y);
  }
  
  static double _TG_ATTRS __tg_nexttoward(double __x, long double __y) {
      return nexttoward(__x, __y);
  }
  
  static long double _TG_ATTRS __tg_nexttoward(long double __x, long double __y) {
      return nexttowardl(__x, __y);
  }
  
  #undef nexttoward
  #define nexttoward(__x, __y) __tg_nexttoward(__tg_promote1((__x))(__x), (__y))
  
  // remainder
  
  static float _TG_ATTRS __tg_remainder(float __x, float __y) {
      return remainderf(__x, __y);
  }
  
  static double _TG_ATTRS __tg_remainder(double __x, double __y) {
      return remainder(__x, __y);
  }
  
  static long double _TG_ATTRS __tg_remainder(long double __x, long double __y) {
      return remainderl(__x, __y);
  }
  
  #undef remainder
  #define remainder(__x, __y) __tg_remainder(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y))
  
  // remquo
  
  static float _TG_ATTRS __tg_remquo(float __x, float __y, int* __z) {
      return remquof(__x, __y, __z);
  }
  
  static double _TG_ATTRS __tg_remquo(double __x, double __y, int* __z) {
      return remquo(__x, __y, __z);
  }
  
  static long double _TG_ATTRS __tg_remquo(long double __x, long double __y, int* __z) {
      return remquol(__x, __y, __z);
  }
  
  #undef remquo
  #define remquo(__x, __y, __z) __tg_remquo(__tg_promote2((__x), (__y))(__x), __tg_promote2((__x), (__y))(__y), (__z))
  
  // rint
  
  static float _TG_ATTRS __tg_rint(float __x) {
      return rintf(__x);
  }
  
  static double _TG_ATTRS __tg_rint(double __x) {
      return rint(__x);
  }
  
  static long double _TG_ATTRS __tg_rint(long double __x) {
      return rintl(__x);
  }
  
  #undef rint
  #define rint(__x) __tg_rint(__tg_promote1((__x))(__x))
  
  // round
  
  static float _TG_ATTRS __tg_round(float __x) {
      return roundf(__x);
  }
  
  static double _TG_ATTRS __tg_round(double __x) {
      return round(__x);
  }
  
  static long double _TG_ATTRS __tg_round(long double __x) {
      return roundl(__x);
  }
  
  #undef round
  #define round(__x) __tg_round(__tg_promote1((__x))(__x))
  
  // scalbn
  
  static float _TG_ATTRS __tg_scalbn(float __x, int __y) {
      return scalbnf(__x, __y);
  }
  
  static double _TG_ATTRS __tg_scalbn(double __x, int __y) {
      return scalbn(__x, __y);
  }
  
  static long double _TG_ATTRS __tg_scalbn(long double __x, int __y) {
      return scalbnl(__x, __y);
  }
  
  #undef scalbn
  #define scalbn(__x, __y) __tg_scalbn(__tg_promote1((__x))(__x), __y)
  
  // scalbln
  
  static float _TG_ATTRS __tg_scalbln(float __x, long __y) {
      return scalblnf(__x, __y);
  }
  
  static double _TG_ATTRS __tg_scalbln(double __x, long __y) {
      return scalbln(__x, __y);
  }
  
  static long double _TG_ATTRS __tg_scalbln(long double __x, long __y) {
      return scalblnl(__x, __y);
  }
  
  #undef scalbln
  #define scalbln(__x, __y) __tg_scalbln(__tg_promote1((__x))(__x), __y)
  
  // tgamma
  
  static float _TG_ATTRS __tg_tgamma(float __x) {
      return tgammaf(__x);
  }
  
  static double _TG_ATTRS __tg_tgamma(double __x) {
      return tgamma(__x);
  }
  
  static long double _TG_ATTRS __tg_tgamma(long double __x) {
      return tgammal(__x);
  }
  
  #undef tgamma
  #define tgamma(__x) __tg_tgamma(__tg_promote1((__x))(__x))
  
  // trunc
  
  static float _TG_ATTRS __tg_trunc(float __x) {
      return truncf(__x);
  }
  
  static double _TG_ATTRS __tg_trunc(double __x) {
      return trunc(__x);
  }
  
  static long double _TG_ATTRS __tg_trunc(long double __x) {
      return truncl(__x);
  }
  
  #undef trunc
  #define trunc(__x) __tg_trunc(__tg_promote1((__x))(__x))
  
  // carg
  
  static float _TG_ATTRS __tg_carg(float __x) {
      return atan2f(0.F, __x);
  }
  
  static double _TG_ATTRS __tg_carg(double __x) {
      return atan2(0., __x);
  }
  
  static long double _TG_ATTRS __tg_carg(long double __x) {
      return atan2l(0.L, __x);
  }
  
  static float _TG_ATTRS __tg_carg(float _Complex __x) {
      return cargf(__x);
  }
  
  static double _TG_ATTRS __tg_carg(double _Complex __x) {
      return carg(__x);
  }
  
  static long double _TG_ATTRS __tg_carg(long double _Complex __x) {
      return cargl(__x);
  }
  
  #undef carg
  #define carg(__x) __tg_carg(__tg_promote1((__x))(__x))
  
  // cimag
  
  static float _TG_ATTRS __tg_cimag(float __x) {
      return 0;
  }
  
  static double _TG_ATTRS __tg_cimag(double __x) {
      return 0;
  }
  
  static long double _TG_ATTRS __tg_cimag(long double __x) {
      return 0;
  }
  
  static float _TG_ATTRS __tg_cimag(float _Complex __x) {
      return cimagf(__x);
  }
  
  static double _TG_ATTRS __tg_cimag(double _Complex __x) {
      return cimag(__x);
  }
  
  static long double _TG_ATTRS __tg_cimag(long double _Complex __x) {
      return cimagl(__x);
  }
  
  #undef cimag
  #define cimag(__x) __tg_cimag(__tg_promote1((__x))(__x))
  
  // conj
  
  static float _Complex _TG_ATTRS __tg_conj(float __x) {
      return __x;
  }
  
  static double _Complex _TG_ATTRS __tg_conj(double __x) {
      return __x;
  }
  
  static long double _Complex _TG_ATTRS __tg_conj(long double __x) {
      return __x;
  }
  
  static float _Complex _TG_ATTRS __tg_conj(float _Complex __x) {
      return conjf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_conj(double _Complex __x) {
      return conj(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_conj(long double _Complex __x) {
      return conjl(__x);
  }
  
  #undef conj
  #define conj(__x) __tg_conj(__tg_promote1((__x))(__x))
  
  // cproj
  
  static float _Complex _TG_ATTRS __tg_cproj(float __x) {
      return cprojf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_cproj(double __x) {
      return cproj(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_cproj(long double __x) {
      return cprojl(__x);
  }
  
  static float _Complex _TG_ATTRS __tg_cproj(float _Complex __x) {
      return cprojf(__x);
  }
  
  static double _Complex _TG_ATTRS __tg_cproj(double _Complex __x) {
      return cproj(__x);
  }
  
  static long double _Complex _TG_ATTRS __tg_cproj(long double _Complex __x) {
      return cprojl(__x);
  }
  
  #undef cproj
  #define cproj(__x) __tg_cproj(__tg_promote1((__x))(__x))
  
  // creal
  
  static float _TG_ATTRS __tg_creal(float __x) {
      return __x;
  }
  
  static double _TG_ATTRS __tg_creal(double __x) {
      return __x;
  }
  
  static long double _TG_ATTRS __tg_creal(long double __x) {
      return __x;
  }
  
  static float _TG_ATTRS __tg_creal(float _Complex __x) {
      return crealf(__x);
  }
  
  static double _TG_ATTRS __tg_creal(double _Complex __x) {
      return creal(__x);
  }
  
  static long double _TG_ATTRS __tg_creal(long double _Complex __x) {
      return creall(__x);
  }
  
  #undef creal
  #define creal(__x) __tg_creal(__tg_promote1((__x))(__x))
  
  #undef _TG_ATTRSp
  #undef _TG_ATTRS
  
  #endif /* !defined(__cplusplus) && !defined(RC_INVOKED) */
  #endif /* __TGMATH_H */
  