__noinference__{
#ifndef _MATH_H_
#define _MATH_H_
#ifndef _float_t_def_
#define _float_t_def_
typedef float float_t;
#endif
#ifndef _double_t_def_
#define _double_t_def_
typedef double double_t;
#endif
#ifndef ___isinff_def_
#define ___isinff_def_
extern int __isinff(float x);
#endif
#ifndef ___isinfd_def_
#define ___isinfd_def_
extern int __isinfd(double x);
#endif
#ifndef ___isnanf_def_
#define ___isnanf_def_
extern int __isnanf(float x);
#endif
#ifndef ___isnand_def_
#define ___isnand_def_
extern int __isnand(double x);
#endif
#ifndef ___fpclassifyf_def_
#define ___fpclassifyf_def_
extern int __fpclassifyf(float x);
#endif
#ifndef ___fpclassifyd_def_
#define ___fpclassifyd_def_
extern int __fpclassifyd(double x);
#endif
#ifndef ___signbitf_def_
#define ___signbitf_def_
extern int __signbitf(float x);
#endif
#ifndef ___signbitd_def_
#define ___signbitd_def_
extern int __signbitd(double x);
#endif
#ifndef M_SQRT1_2
#define M_SQRT1_2 0.70710678118654752440
#endif
#ifndef M_PI_4
#define M_PI_4 0.78539816339744830962
#endif
#ifndef isless
#define isless(x,y) (__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); !isunordered(__x,__y) && (__x < __y);}))
#endif
#ifndef FP_NAN
#define FP_NAN 0
#endif
#ifndef M_E
#define M_E 2.7182818284590452354
#endif
#ifndef MAXFLOAT
#define MAXFLOAT 3.40282347e+38F
#endif
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
#ifndef FP_INFINITE
#define FP_INFINITE 1
#endif
#ifndef FP_ILOGBNAN
#define FP_ILOGBNAN INT_MAX
#endif
#ifndef HUGE_VALF
#define HUGE_VALF (__builtin_huge_valf())
#endif
#ifndef HUGE_VALL
#define HUGE_VALL (__builtin_huge_vall())
#endif
#ifndef M_PI_2
#define M_PI_2 1.57079632679489661923
#endif
#ifndef FP_NORMAL
#define FP_NORMAL 4
#endif
#ifndef FP_ILOGB0
#define FP_ILOGB0 (-INT_MAX)
#endif
#ifndef NAN
#define NAN (__builtin_nanf(""))
#endif
#ifndef MATH_ERRNO
#define MATH_ERRNO 1
#endif
#ifndef M_2_PI
#define M_2_PI 0.63661977236758134308
#endif
#ifndef islessgreater
#define islessgreater(x,y) (__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); !isunordered(__x,__y) && (__x < __y || __x > __y);}))
#endif
#ifndef INFINITY
#define INFINITY (__builtin_inff())
#endif
#ifndef math_errhandling
#define math_errhandling MATH_ERRNO
#endif
#ifndef M_LOG2E
#define M_LOG2E 1.4426950408889634074
#endif
#ifndef isnan
#define isnan(x) (__extension__ ({__typeof__(x) __x = (x); (sizeof (__x) == sizeof (float)) ? __isnanf(__x) : __isnand(__x);}))
#endif
#ifndef isnormal
#define isnormal(y) (fpclassify(y) == FP_NORMAL)
#endif
#ifndef FP_SUBNORMAL
#define FP_SUBNORMAL 3
#endif
#ifndef islessequal
#define islessequal(x,y) (__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); !isunordered(__x,__y) && (__x <= __y);}))
#endif
#ifndef FP_ZERO
#define FP_ZERO 2
#endif
#ifndef fpclassify
#define fpclassify(x) (__extension__ ({__typeof__(x) __x = (x); (sizeof (__x) == sizeof (float)) ? __fpclassifyf(__x) : __fpclassifyd(__x);}))
#endif
#ifndef isgreater
#define isgreater(x,y) (__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); !isunordered(__x,__y) && (__x > __y);}))
#endif
#ifndef isfinite
#define isfinite(y) (__extension__ ({__typeof__(y) __y = (y); fpclassify(__y) != FP_INFINITE && fpclassify(__y) != FP_NAN;}))
#endif
#ifndef isinf
#define isinf(x) (__extension__ ({__typeof__(x) __x = (x); (sizeof (__x) == sizeof (float)) ? __isinff(__x) : __isinfd(__x);}))
#endif
#ifndef signbit
#define signbit(x) (__extension__ ({__typeof__(x) __x = (x); (sizeof(__x) == sizeof(float)) ? __signbitf(__x) : __signbitd(__x);}))
#endif
#ifndef isunordered
#define isunordered(a,b) (__extension__ ({__typeof__(a) __a = (a); __typeof__(b) __b = (b); fpclassify(__a) == FP_NAN || fpclassify(__b) == FP_NAN;}))
#endif
#ifndef M_LN10
#define M_LN10 2.30258509299404568402
#endif
#ifndef M_SQRT2
#define M_SQRT2 1.41421356237309504880
#endif
#ifndef MATH_ERREXCEPT
#define MATH_ERREXCEPT 2
#endif
#ifndef isgreaterequal
#define isgreaterequal(x,y) (__extension__ ({__typeof__(x) __x = (x); __typeof__(y) __y = (y); !isunordered(__x,__y) && (__x >= __y);}))
#endif
#ifndef M_LOG10E
#define M_LOG10E 0.43429448190325182765
#endif
#ifndef FLT_EVAL_METHOD
#define FLT_EVAL_METHOD 0
#endif
#ifndef M_1_PI
#define M_1_PI 0.31830988618379067154
#endif
#ifndef M_LN2
#define M_LN2 0.69314718055994530942
#endif

  /* I'd like to do
     include { HUGE_VAL }
     but under Cygwin this brings in 
     extern const union __dmath  __attribute__((dllimport))__infinity[];
     which does not have an array size.
     Works fine in Linux, though.
  */

  extern "C" double acos(double);

  extern "C" float acosf(float);

  extern "C" double acosh(double);

  extern "C" float acoshf(float);

  extern "C" double asin(double);

  extern "C" float asinf(float);

  extern "C" double asinh(double);

  extern "C" float asinhf(float);

  extern "C" double atan(double);

  extern "C" double atan2(double, double);

  extern "C" float atan2f(float, float);

  extern "C" float atanf(float);

  extern "C" double atanh(double);

  extern "C" float atanhf(float);

  extern "C" double cbrt(double);

  extern "C" float cbrtf(float);

  extern "C" double ceil(double);

  extern "C" float ceilf(float);

  extern "C" double copysign(double, double);

  extern "C" float copysignf(float, float);

  extern "C" double cos(double);

  extern "C" float cosf(float);

  extern "C" double cosh(double);

  extern "C" float coshf(float);

  extern "C" double erf(double);

  extern "C" double erfc(double);

  extern "C" float erfcf(float);

  extern "C" float erff(float);

  extern "C" double exp(double);

  extern "C" double exp2(double);

  extern "C" float exp2f(float);

  extern "C" float expf(float);

  extern "C" double expm1(double);

  extern "C" float expm1f(float);

  extern "C" double fabs(double);

  extern "C" float fabsf(float);

  extern "C" double fdim(double, double);

  extern "C" float fdimf(float, float);

  extern "C" double floor(double);

  extern "C" float floorf(float);

  extern "C" double fma(double, double, double);

  extern "C" float fmaf(float, float, float);

  extern "C" double fmax(double, double);

  extern "C" float fmaxf(float, float);

  extern "C" double fmin(double, double);

  extern "C" float fminf(float, float);

  extern "C" double fmod(double, double);

  extern "C" float fmodf(float, float);

  extern "C" double frexp(double, int @);

  extern "C" float frexpf(float value, int @);

  extern "C" double hypot(double, double);

  extern "C" float hypotf(float, float);

  extern "C" int ilogb(double);

  extern "C" int ilogbf(float);

  extern "C" double j0(double);

  extern "C" double j1(double);

  extern "C" double jn(int, double);

  extern "C" double ldexp(double, int);

  extern "C" float ldexpf(float, int);

  extern "C" double lgamma(double);

  extern "C" float lgammaf(float);

  extern "C" double log(double);

  extern "C" double log10(double);

  extern "C" float log10f(float);

  extern "C" double log1p(double);

  extern "C" float log1pf(float);

  extern "C" float logf(float);

  extern "C" long lrint(double);

  extern "C" long lrintf(float);

  extern "C" long lround(double);

  extern "C" long lroundf(float);

  extern "C" double modf(double, double @);

  extern "C" float modff(float, float @);

  // FIX: not yet implemented
  //  extern "C" double nan(const char *);

  // FIX: not yet implemented
  //  extern "C" float nanf(const char *);

  extern "C" double nearbyint(double);

  extern "C" float nearbyintf(float);

  extern "C" double nextafter(double, double);

  extern "C" float nextafterf(float, float);

  extern "C" double pow(double, double);

  extern "C" float powf(float, float);

  extern "C" double remainder(double, double);

  extern "C" float remainderf(float, float);

  extern "C" double remquo(double, double, int @);

  extern "C" float remquof(float, float, int @);

  extern "C" double rint(double);

  extern "C" float rintf(float);

  extern "C" double round(double);

  extern "C" float roundf(float);

  extern "C" double scalbln(double, long);

  extern "C" float scalblnf(float, long);

  extern "C" double scalbn(double, int);

  extern "C" float scalbnf(float, int);

  extern "C" double sin(double);

  extern "C" float sinf(float);

  extern "C" double sinh(double);

  extern "C" float sinhf(float);

  extern "C" double sqrt(double);

  extern "C" float sqrtf(float);

  extern "C" double tan(double);

  extern "C" float tanf(float);

  extern "C" double tanh(double);

  extern "C" float tanhf(float);

  extern "C" double tgamma(double);

  extern "C" float tgammaf(float);

  extern "C" double trunc(double);

  extern "C" float truncf(float);

  extern "C" double y0(double);

  extern "C" double y1(double);

  extern "C" double yn(int, double);

  extern "C" int signgam;
#endif
}
