From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <gcc-prs-return-22356-listarch-gcc-prs=gcc.gnu.org@gcc.gnu.org>
Received: (qmail 21738 invoked by alias); 30 Sep 2002 15:46:06 -0000
Mailing-List: contact gcc-prs-help@gcc.gnu.org; run by ezmlm
Precedence: bulk
List-Archive: <http://gcc.gnu.org/ml/gcc-prs/>
List-Post: <mailto:gcc-prs@gcc.gnu.org>
List-Help: <mailto:gcc-prs-help@gcc.gnu.org>
Sender: gcc-prs-owner@gcc.gnu.org
Received: (qmail 21719 invoked by uid 71); 30 Sep 2002 15:46:04 -0000
Resent-Date: 30 Sep 2002 15:46:04 -0000
Resent-Message-ID: <20020930154604.21718.qmail@sources.redhat.com>
Resent-From: gcc-gnats@gcc.gnu.org (GNATS Filer)
Resent-Cc: gcc-prs@gcc.gnu.org, gcc-bugs@gcc.gnu.org
Resent-Reply-To: gcc-gnats@gcc.gnu.org, fojtik@vision.felk.cvut.cz
Received: (qmail 19887 invoked by uid 61); 30 Sep 2002 15:37:52 -0000
Message-Id: <20020930153752.19886.qmail@sources.redhat.com>
Date: Mon, 30 Sep 2002 08:46:00 -0000
From: fojtik@vision.felk.cvut.cz
Reply-To: fojtik@vision.felk.cvut.cz
To: gcc-gnats@gcc.gnu.org
X-Send-Pr-Version: gnatsweb-2.9.3 (1.1.1.1.2.31)
Subject: c++/8098: gcc is crashing
X-SW-Source: 2002-09/txt/msg00862.txt.bz2
List-Id: <gcc-prs.sourceware.org>


>Number:         8098
>Category:       c++
>Synopsis:       gcc is crashing
>Confidential:   no
>Severity:       serious
>Priority:       medium
>Responsible:    unassigned
>State:          open
>Class:          sw-bug
>Submitter-Id:   net
>Arrival-Date:   Mon Sep 30 08:46:03 PDT 2002
>Closed-Date:
>Last-Modified:
>Originator:     fojtik@vision.felk.cvut.cz
>Release:        unknown-1.0
>Organization:
>Environment:
Slackware linux gcc 3.0 kernel 2.2.21
>Description:
gcc -D__CPU__=386 -Wall -O1 -m386 -g -c -o libm.o libm.c
`-m386' is deprecated. Use `-march=i386' or `-mcpu=i386' instead.
libm.c: In function `fmodf':
libm.c:729: Internal compiler error in subst_stack_regs_pat, at reg-stack.c:1397
Please submit a full bug report,
with preprocessed source if appropriate.
See <URL:http://www.gnu.org/software/gcc/bugs.html> for instructions.
make: *** [libm.o] Error 1
>How-To-Repeat:
Compile attached example

The bug is repeatable even if I place -march=i386
>Fix:

>Release-Note:
>Audit-Trail:
>Unformatted:
----gnatsweb-attachment----
Content-Type: text/plain; name="libm.i"
Content-Disposition: inline; filename="libm.i"

# 46 "libm.c"
# 1 "/usr/include/math.h" 1 3
# 27 "/usr/include/math.h" 3
# 1 "/usr/include/features.h" 1 3
# 249 "/usr/include/features.h" 3
# 1 "/usr/include/sys/cdefs.h" 1 3
# 250 "/usr/include/features.h" 2 3
# 277 "/usr/include/features.h" 3
# 1 "/usr/local/include/gnu/stubs.h" 1 3
# 278 "/usr/include/features.h" 2 3
# 28 "/usr/include/math.h" 2 3





# 1 "/usr/include/bits/huge_val.h" 1 3
# 25 "/usr/include/bits/huge_val.h" 3
# 1 "/usr/include/features.h" 1 3
# 26 "/usr/include/bits/huge_val.h" 2 3
# 34 "/usr/include/math.h" 2 3






# 1 "/usr/include/bits/mathdef.h" 1 3
# 41 "/usr/include/math.h" 2 3
# 63 "/usr/include/math.h" 3
# 1 "/usr/include/bits/mathcalls.h" 1 3
# 54 "/usr/include/bits/mathcalls.h" 3
extern double acos (double __x); extern double __acos (double __x);

extern double asin (double __x); extern double __asin (double __x);

extern double atan (double __x); extern double __atan (double __x);

extern double atan2 (double __y, double __x); extern double __atan2 (double __y, double __x);


extern double cos (double __x); extern double __cos (double __x);

extern double sin (double __x); extern double __sin (double __x);

extern double tan (double __x); extern double __tan (double __x);
# 78 "/usr/include/bits/mathcalls.h" 3
extern double cosh (double __x); extern double __cosh (double __x);

extern double sinh (double __x); extern double __sinh (double __x);

extern double tanh (double __x); extern double __tanh (double __x);



extern double acosh (double __x); extern double __acosh (double __x);

extern double asinh (double __x); extern double __asinh (double __x);

extern double atanh (double __x); extern double __atanh (double __x);





extern double exp (double __x); extern double __exp (double __x);
# 106 "/usr/include/bits/mathcalls.h" 3
extern double frexp (double __x, int *__exponent); extern double __frexp (double __x, int *__exponent);


extern double ldexp (double __x, int __exponent); extern double __ldexp (double __x, int __exponent);


extern double log (double __x); extern double __log (double __x);


extern double log10 (double __x); extern double __log10 (double __x);


extern double modf (double __x, double *__iptr); extern double __modf (double __x, double *__iptr);



extern double expm1 (double __x); extern double __expm1 (double __x);


extern double log1p (double __x); extern double __log1p (double __x);


extern double logb (double __x); extern double __logb (double __x);
# 143 "/usr/include/bits/mathcalls.h" 3
extern double pow (double __x, double __y); extern double __pow (double __x, double __y);


extern double sqrt (double __x); extern double __sqrt (double __x);



extern double hypot (double __x, double __y); extern double __hypot (double __x, double __y);




extern double cbrt (double __x); extern double __cbrt (double __x);






extern double ceil (double __x); extern double __ceil (double __x);


extern double fabs (double __x) __attribute__ ((__const__)); extern double __fabs (double __x) __attribute__ ((__const__));


extern double floor (double __x); extern double __floor (double __x);


extern double fmod (double __x, double __y); extern double __fmod (double __x, double __y);




extern int __isinf (double __value) __attribute__ ((__const__));




extern int isinf (double __value) __attribute__ ((__const__));


extern int finite (double __value) __attribute__ ((__const__)); extern int __finite (double __value) __attribute__ ((__const__));







extern double infnan (int __error) __attribute__ ((__const__)); extern double __infnan (int __error) __attribute__ ((__const__));


extern double drem (double __x, double __y); extern double __drem (double __x, double __y);



extern double significand (double __x); extern double __significand (double __x);




extern double copysign (double __x, double __y) __attribute__ ((__const__)); extern double __copysign (double __x, double __y) __attribute__ ((__const__));
# 215 "/usr/include/bits/mathcalls.h" 3
extern int isnan (double __value) __attribute__ ((__const__)); extern int __isnan (double __value) __attribute__ ((__const__));


extern double j0 (double); extern double __j0 (double);
extern double j1 (double); extern double __j1 (double);
extern double jn (int, double); extern double __jn (int, double);
extern double y0 (double); extern double __y0 (double);
extern double y1 (double); extern double __y1 (double);
extern double yn (int, double); extern double __yn (int, double);





extern double erf (double); extern double __erf (double);
extern double erfc (double); extern double __erfc (double);
extern double lgamma (double); extern double __lgamma (double);
extern double tgamma (double); extern double __tgamma (double);




extern double gamma (double); extern double __gamma (double);






extern double lgamma_r (double, int *__signgamp); extern double __lgamma_r (double, int *__signgamp);






extern double rint (double __x); extern double __rint (double __x);


extern double nextafter (double __x, double __y) __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) __attribute__ ((__const__));





extern double remainder (double __x, double __y); extern double __remainder (double __x, double __y);



extern double scalb (double __x, double __n); extern double __scalb (double __x, double __n);



extern double scalbn (double __x, int __n); extern double __scalbn (double __x, int __n);


extern int ilogb (double __x); extern int __ilogb (double __x);
# 64 "/usr/include/math.h" 2 3
# 82 "/usr/include/math.h" 3
# 1 "/usr/include/bits/mathcalls.h" 1 3
# 54 "/usr/include/bits/mathcalls.h" 3
extern float acosf (float __x); extern float __acosf (float __x);

extern float asinf (float __x); extern float __asinf (float __x);

extern float atanf (float __x); extern float __atanf (float __x);

extern float atan2f (float __y, float __x); extern float __atan2f (float __y, float __x);


extern float cosf (float __x); extern float __cosf (float __x);

extern float sinf (float __x); extern float __sinf (float __x);

extern float tanf (float __x); extern float __tanf (float __x);
# 78 "/usr/include/bits/mathcalls.h" 3
extern float coshf (float __x); extern float __coshf (float __x);

extern float sinhf (float __x); extern float __sinhf (float __x);

extern float tanhf (float __x); extern float __tanhf (float __x);



extern float acoshf (float __x); extern float __acoshf (float __x);

extern float asinhf (float __x); extern float __asinhf (float __x);

extern float atanhf (float __x); extern float __atanhf (float __x);





extern float expf (float __x); extern float __expf (float __x);
# 106 "/usr/include/bits/mathcalls.h" 3
extern float frexpf (float __x, int *__exponent); extern float __frexpf (float __x, int *__exponent);


extern float ldexpf (float __x, int __exponent); extern float __ldexpf (float __x, int __exponent);


extern float logf (float __x); extern float __logf (float __x);


extern float log10f (float __x); extern float __log10f (float __x);


extern float modff (float __x, float *__iptr); extern float __modff (float __x, float *__iptr);



extern float expm1f (float __x); extern float __expm1f (float __x);


extern float log1pf (float __x); extern float __log1pf (float __x);


extern float logbf (float __x); extern float __logbf (float __x);
# 143 "/usr/include/bits/mathcalls.h" 3
extern float powf (float __x, float __y); extern float __powf (float __x, float __y);


extern float sqrtf (float __x); extern float __sqrtf (float __x);



extern float hypotf (float __x, float __y); extern float __hypotf (float __x, float __y);




extern float cbrtf (float __x); extern float __cbrtf (float __x);






extern float ceilf (float __x); extern float __ceilf (float __x);


extern float fabsf (float __x) __attribute__ ((__const__)); extern float __fabsf (float __x) __attribute__ ((__const__));


extern float floorf (float __x); extern float __floorf (float __x);


extern float fmodf (float __x, float __y); extern float __fmodf (float __x, float __y);




extern int __isinff (float __value) __attribute__ ((__const__));




extern int isinff (float __value) __attribute__ ((__const__));


extern int finitef (float __value) __attribute__ ((__const__)); extern int __finitef (float __value) __attribute__ ((__const__));







extern float infnanf (int __error) __attribute__ ((__const__)); extern float __infnanf (int __error) __attribute__ ((__const__));


extern float dremf (float __x, float __y); extern float __dremf (float __x, float __y);



extern float significandf (float __x); extern float __significandf (float __x);




extern float copysignf (float __x, float __y) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) __attribute__ ((__const__));
# 215 "/usr/include/bits/mathcalls.h" 3
extern int isnanf (float __value) __attribute__ ((__const__)); extern int __isnanf (float __value) __attribute__ ((__const__));


extern float j0f (float); extern float __j0f (float);
extern float j1f (float); extern float __j1f (float);
extern float jnf (int, float); extern float __jnf (int, float);
extern float y0f (float); extern float __y0f (float);
extern float y1f (float); extern float __y1f (float);
extern float ynf (int, float); extern float __ynf (int, float);





extern float erff (float); extern float __erff (float);
extern float erfcf (float); extern float __erfcf (float);
extern float lgammaf (float); extern float __lgammaf (float);
extern float tgammaf (float); extern float __tgammaf (float);




extern float gammaf (float); extern float __gammaf (float);






extern float lgammaf_r (float, int *__signgamp); extern float __lgammaf_r (float, int *__signgamp);






extern float rintf (float __x); extern float __rintf (float __x);


extern float nextafterf (float __x, float __y) __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) __attribute__ ((__const__));





extern float remainderf (float __x, float __y); extern float __remainderf (float __x, float __y);



extern float scalbf (float __x, float __n); extern float __scalbf (float __x, float __n);



extern float scalbnf (float __x, int __n); extern float __scalbnf (float __x, int __n);


extern int ilogbf (float __x); extern int __ilogbf (float __x);
# 83 "/usr/include/math.h" 2 3
# 99 "/usr/include/math.h" 3
# 1 "/usr/include/bits/mathcalls.h" 1 3
# 54 "/usr/include/bits/mathcalls.h" 3
extern long double acosl (long double __x); extern long double __acosl (long double __x);

extern long double asinl (long double __x); extern long double __asinl (long double __x);

extern long double atanl (long double __x); extern long double __atanl (long double __x);

extern long double atan2l (long double __y, long double __x); extern long double __atan2l (long double __y, long double __x);


extern long double cosl (long double __x); extern long double __cosl (long double __x);

extern long double sinl (long double __x); extern long double __sinl (long double __x);

extern long double tanl (long double __x); extern long double __tanl (long double __x);
# 78 "/usr/include/bits/mathcalls.h" 3
extern long double coshl (long double __x); extern long double __coshl (long double __x);

extern long double sinhl (long double __x); extern long double __sinhl (long double __x);

extern long double tanhl (long double __x); extern long double __tanhl (long double __x);



extern long double acoshl (long double __x); extern long double __acoshl (long double __x);

extern long double asinhl (long double __x); extern long double __asinhl (long double __x);

extern long double atanhl (long double __x); extern long double __atanhl (long double __x);





extern long double expl (long double __x); extern long double __expl (long double __x);
# 106 "/usr/include/bits/mathcalls.h" 3
extern long double frexpl (long double __x, int *__exponent); extern long double __frexpl (long double __x, int *__exponent);


extern long double ldexpl (long double __x, int __exponent); extern long double __ldexpl (long double __x, int __exponent);


extern long double logl (long double __x); extern long double __logl (long double __x);


extern long double log10l (long double __x); extern long double __log10l (long double __x);


extern long double modfl (long double __x, long double *__iptr); extern long double __modfl (long double __x, long double *__iptr);



extern long double expm1l (long double __x); extern long double __expm1l (long double __x);


extern long double log1pl (long double __x); extern long double __log1pl (long double __x);


extern long double logbl (long double __x); extern long double __logbl (long double __x);
# 143 "/usr/include/bits/mathcalls.h" 3
extern long double powl (long double __x, long double __y); extern long double __powl (long double __x, long double __y);


extern long double sqrtl (long double __x); extern long double __sqrtl (long double __x);



extern long double hypotl (long double __x, long double __y); extern long double __hypotl (long double __x, long double __y);




extern long double cbrtl (long double __x); extern long double __cbrtl (long double __x);






extern long double ceill (long double __x); extern long double __ceill (long double __x);


extern long double fabsl (long double __x) __attribute__ ((__const__)); extern long double __fabsl (long double __x) __attribute__ ((__const__));


extern long double floorl (long double __x); extern long double __floorl (long double __x);


extern long double fmodl (long double __x, long double __y); extern long double __fmodl (long double __x, long double __y);




extern int __isinfl (long double __value) __attribute__ ((__const__));




extern int isinfl (long double __value) __attribute__ ((__const__));


extern int finitel (long double __value) __attribute__ ((__const__)); extern int __finitel (long double __value) __attribute__ ((__const__));







extern long double infnanl (int __error) __attribute__ ((__const__)); extern long double __infnanl (int __error) __attribute__ ((__const__));


extern long double dreml (long double __x, long double __y); extern long double __dreml (long double __x, long double __y);



extern long double significandl (long double __x); extern long double __significandl (long double __x);




extern long double copysignl (long double __x, long double __y) __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) __attribute__ ((__const__));
# 215 "/usr/include/bits/mathcalls.h" 3
extern int isnanl (long double __value) __attribute__ ((__const__)); extern int __isnanl (long double __value) __attribute__ ((__const__));


extern long double j0l (long double); extern long double __j0l (long double);
extern long double j1l (long double); extern long double __j1l (long double);
extern long double jnl (int, long double); extern long double __jnl (int, long double);
extern long double y0l (long double); extern long double __y0l (long double);
extern long double y1l (long double); extern long double __y1l (long double);
extern long double ynl (int, long double); extern long double __ynl (int, long double);





extern long double erfl (long double); extern long double __erfl (long double);
extern long double erfcl (long double); extern long double __erfcl (long double);
extern long double lgammal (long double); extern long double __lgammal (long double);
extern long double tgammal (long double); extern long double __tgammal (long double);




extern long double gammal (long double); extern long double __gammal (long double);






extern long double lgammal_r (long double, int *__signgamp); extern long double __lgammal_r (long double, int *__signgamp);






extern long double rintl (long double __x); extern long double __rintl (long double __x);


extern long double nextafterl (long double __x, long double __y) __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) __attribute__ ((__const__));





extern long double remainderl (long double __x, long double __y); extern long double __remainderl (long double __x, long double __y);



extern long double scalbl (long double __x, long double __n); extern long double __scalbl (long double __x, long double __n);



extern long double scalbnl (long double __x, int __n); extern long double __scalbnl (long double __x, int __n);


extern int ilogbl (long double __x); extern int __ilogbl (long double __x);
# 100 "/usr/include/math.h" 2 3
# 113 "/usr/include/math.h" 3
extern int signgam;
# 236 "/usr/include/math.h" 3
typedef enum
{
  _IEEE_ = -1,
  _SVID_,
  _XOPEN_,
  _POSIX_,
  _ISOC_
} _LIB_VERSION_TYPE;




extern _LIB_VERSION_TYPE _LIB_VERSION;
# 261 "/usr/include/math.h" 3
struct exception

  {
    int type;
    char *name;
    double arg1;
    double arg2;
    double retval;
  };




extern int matherr (struct exception *__exc) ;
# 289 "/usr/include/math.h" 3
# 1 "/usr/local/lib/gcc-lib/i586-pc-linux-gnu/3.0/include/float.h" 1 3
# 290 "/usr/include/math.h" 2 3
# 348 "/usr/include/math.h" 3
# 1 "/usr/include/bits/mathinline.h" 1 3
# 349 "/usr/include/math.h" 2 3
# 47 "libm.c" 2







typedef unsigned int uint32_t;
# 130 "libm.c"
int (isnanf)(float x)
{
  register int retval;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); retval=((sw&0x4500)==0x0100);};
  return retval;
}

int (isnan)(double x)
{
  register int retval;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); retval=((sw&0x4500)==0x0100);};
  return retval;
}

int (isnanl)(long double x)
{
  register int retval;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); retval=((sw&0x4500)==0x0100);};
  return retval;
}

int (isfinitef)(float x)
{
  register int retval;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); retval=((sw&0x4500)==0x0400)||((sw&0x4500)==0x4000);};
  return retval;
}

int (isfinite)(double x)
{
  register int retval;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); retval=((sw&0x4500)==0x0400)||((sw&0x4500)==0x4000);};
  return retval;
}

int (isfinitel)(long double x)
{
  register int retval;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); retval=((sw&0x4500)==0x0400)||((sw&0x4500)==0x4000);};
  return retval;
}

int (isnormalf)(float x)
{
  register int retval;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); retval=((sw&0x4500)==0x0400);};
  return retval;
}

int (isnormal)(double x)
{
  register int retval;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); retval=((sw&0x4500)==0x0400);};
  return retval;
}

int (isnormall)(long double x)
{
  register int retval;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); retval=((sw&0x4500)==0x0400);};
  return retval;
}

int (isinff)(float x)
{
  register int retval;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); retval=((sw&0x4500)==0x0500); if((sw&0x0200)) retval =- retval;};
  return retval;
}

int (isinf)(double x)
{
  register int retval;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); retval=((sw&0x4500)==0x0500); if((sw&0x0200)) retval =- retval;};
  return retval;
}

int (isinfl)(long double x)
{
  register int retval;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); retval=((sw&0x4500)==0x0500); if((sw&0x0200)) retval =- retval;};
  return retval;
}
# 230 "libm.c"
int (__fpclassifyf)(float x)
{
  register int sw, retval;
  const uint32_t *xp;
  xp = (const uint32_t *)&x;
  asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x));
  if(((sw&0x4500)==0x0100)) retval = 0;
  else
  if(((sw&0x4500)==0x0500)) retval = 1;
  else
  if(((sw&0x4500)==0x4000)) retval = 2;
  else
  if((xp[0] & ~0x80000000UL) < 0x01000000UL) retval = 3;
  else
  retval = 4;
  return retval;
}

int (__fpclassify)(double x)
{
  register int sw, retval;
  const uint32_t *xp;
  xp = (const uint32_t *)&x;
  asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x));
  if(((sw&0x4500)==0x0100)) retval = 0;
  else
  if(((sw&0x4500)==0x0500)) retval = 1;
  else
  if(((sw&0x4500)==0x4000)) retval = 2;
  else
  if(!xp[1]) retval = 3;
  else
  retval = 4;
  return retval;
}

int (__fpclassifyl)(long double x)
{
  register int sw, retval;
  const uint32_t *xp;
  xp = (const uint32_t *)&x;
  asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x));
  if(((sw&0x4500)==0x0100)) retval = 0;
  else
  if(((sw&0x4500)==0x0500)) retval = 1;
  else
  if(((sw&0x4500)==0x4000)) retval = 2;
  else
  if(!xp[2] && (xp[1] & 0x80000000UL) == 0) retval = 3;
  else
  retval = 4;
  return retval;
}
# 302 "libm.c"
int (isgreaterf)(float x, float y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	testb	$0x45, %h0\n" "	setz	%b0" :"=a"(retval) :"u"(y),"t"(x) :"st","st(1)");
  return retval;
}

int (isgreater)(double x, double y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	testb	$0x45, %h0\n" "	setz	%b0" :"=a"(retval) :"u"(y),"t"(x) :"st","st(1)");
  return retval;
}

int (isgreaterl)(long double x, long double y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	testb	$0x45, %h0\n" "	setz	%b0" :"=a"(retval) :"u"(y),"t"(x) :"st","st(1)");
  return retval;
}
# 341 "libm.c"
int (isgreaterequalf)(float x, float y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	testb	$0x05, %h0\n" "	setz	%b0" :"=a"(retval) :"u"(y),"t"(x) :"st","st(1)");
  return retval;
}

int (isgreaterequal)(double x, double y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	testb	$0x05, %h0\n" "	setz	%b0" :"=a"(retval) :"u"(y),"t"(x) :"st","st(1)");
  return retval;
}

int (isgreaterequall)(long double x, long double y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	testb	$0x05, %h0\n" "	setz	%b0" :"=a"(retval) :"u"(y),"t"(x) :"st","st(1)");
  return retval;
}
# 380 "libm.c"
int (islessf)(float x, float y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	testb	$0x45, %h0\n" "	setz	%b0" :"=a"(retval) :"u"(x),"t"(y) :"st","st(1)");
  return retval;
}

int (isless)(double x, double y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	testb	$0x45, %h0\n" "	setz	%b0" :"=a"(retval) :"u"(x),"t"(y) :"st","st(1)");
  return retval;
}

int (islessl)(long double x, long double y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	testb	$0x45, %h0\n" "	setz	%b0" :"=a"(retval) :"u"(x),"t"(y) :"st","st(1)");
  return retval;
}
# 419 "libm.c"
int (islessequalf)(float x, float y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	testb	$0x05, %h0\n" "	setz	%b0" :"=a"(retval) :"u"(x),"t"(y) :"st","st(1)");
  return retval;
}

int (islessequal)(double x, double y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	testb	$0x05, %h0\n" "	setz	%b0" :"=a"(retval) :"u"(x),"t"(y) :"st","st(1)");
  return retval;
}

int (islessequall)(long double x, long double y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	testb	$0x05, %h0\n" "	setz	%b0" :"=a"(retval) :"u"(x),"t"(y) :"st","st(1)");
  return retval;
}
# 458 "libm.c"
int (islessgreaterf)(float x, float y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	testb	$0x44, %h0\n" "	setz	%b0" :"=a"(retval) :"u"(y),"t"(x) :"st","st(1)");
  return retval;
}

int (islessgreater)(double x, double y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	testb	$0x44, %h0\n" "	setz	%b0" :"=a"(retval) :"u"(y),"t"(x) :"st","st(1)");
  return retval;
}

int (islessgreaterl)(long double x, long double y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	testb	$0x44, %h0\n" "	setz	%b0" :"=a"(retval) :"u"(y),"t"(x) :"st","st(1)");
  return retval;
}
# 497 "libm.c"
int (isunorderedf)(float x, float y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	sahf\n" "	setp	%b0" :"=a"(retval) :"u"(y),"t"(x) :"st","st(1)");
  return retval;
}

int (isunordered)(double x, double y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	sahf\n" "	setp	%b0" :"=a"(retval) :"u"(y),"t"(x) :"st","st(1)");
  return retval;
}

int (isunorderedl)(long double x, long double y)
{
  register int retval;
  asm("fucompp\n" "	fnstsw\n" "	sahf\n" "	setp	%b0" :"=a"(retval) :"u"(y),"t"(x) :"st","st(1)");
  return retval;
}
# 532 "libm.c"
float (acosf)(float x)
{
  register float ret;
  asm("fld	%0\n" "	fmul	%0\n" "	fld1\n" "	fsubp\n" "	fsqrt\n" "	fxch	%%st(1)\n" "	fpatan" : "=t"(ret) : "0"(x) : "st(1)");
  return ret;
}

double (acos)(double x)
{
  register double ret;
  asm("fld	%0\n" "	fmul	%0\n" "	fld1\n" "	fsubp\n" "	fsqrt\n" "	fxch	%%st(1)\n" "	fpatan" : "=t"(ret) : "0"(x) : "st(1)");
  return ret;
}

long double (acosl)(long double x)
{
  register long double ret;
  asm("fld	%0\n" "	fmul	%0\n" "	fld1\n" "	fsubp\n" "	fsqrt\n" "	fxch	%%st(1)\n" "	fpatan" : "=t"(ret) : "0"(x) : "st(1)");
  return ret;
}
# 566 "libm.c"
float (asinf)(float x)
{
  register float ret;
  asm("fld	%0\n" "	fmul	%0\n" "	fld1\n" "	fsubp\n" "	fsqrt\n" "	fpatan" : "=t"(ret) : "0"(x) : "st(1)");
  return ret;
}

double (asin)(double x)
{
  register double ret;
  asm("fld	%0\n" "	fmul	%0\n" "	fld1\n" "	fsubp\n" "	fsqrt\n" "	fpatan" : "=t"(ret) : "0"(x) : "st(1)");
  return ret;
}

long double (asinl)(long double x)
{
  register long double ret;
  asm("fld	%0\n" "	fmul	%0\n" "	fld1\n" "	fsubp\n" "	fsqrt\n" "	fpatan" : "=t"(ret) : "0"(x) : "st(1)");
  return ret;
}
# 594 "libm.c"
float (atan2f)(float y,float x)
{
  register float ret;
  asm("fpatan" : "=t"(ret): "u"(y), "0"(x) : "st(1)");
  return ret;
}

double (atan2)(double y,double x)
{
  register double ret;
  asm("fpatan" : "=t"(ret): "u"(y), "0"(x) : "st(1)");
  return ret;
}

long double (atan2l)(long double y,long double x)
{
  register long double ret;
  asm("fpatan" : "=t"(ret): "u"(y), "0"(x) : "st(1)");
  return ret;
}
# 642 "libm.c"
float (expf)(float x)
{
  register float ret;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) ret = 0.; else ret = x; } else asm("fldl2e\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale": "=t"(ret): "0"(x): "st(1)", "st(2)");};
  return ret;
}

double (exp)(double x)
{
  register double ret;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) ret = 0.; else ret = x; } else asm("fldl2e\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale": "=t"(ret): "0"(x): "st(1)", "st(2)");};
  return ret;
}

long double (expl)(long double x)
{
  register long double ret;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) ret = 0.; else ret = x; } else asm("fldl2e\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale": "=t"(ret): "0"(x): "st(1)", "st(2)");};
  return ret;
}
# 692 "libm.c"
float (exp10f)(float x)
{
  register float ret;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) ret = 0.; else ret = x; } else asm("fldl2t\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale\n" "	ffree	%%st(1)\n": "=t"(ret): "0"(x): "st(2)");};
  return ret;
}

double (exp10)(double x)
{
  register double ret;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) ret = 0.; else ret = x; } else asm("fldl2t\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale\n" "	ffree	%%st(1)\n": "=t"(ret): "0"(x): "st(2)");};
  return ret;
}

long double (exp10l)(long double x)
{
  register long double ret;
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) ret = 0.; else ret = x; } else asm("fldl2t\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale\n" "	ffree	%%st(1)\n": "=t"(ret): "0"(x): "st(2)");};
  return ret;
}
# 724 "libm.c"
float (fmodf)(float x,float y)
{
  register float ret;
  asm("1:\n" "	fprem\n" "	fstsw	%%ax\n" "	sahf\n" "	jp  	1b\n": "=t"(ret): "u"(y), "0"(x): "eax","st");
  return ret;
}

double (fmod)(double x,double y)
{
  register double ret;
  asm("1:\n" "	fprem\n" "	fstsw	%%ax\n" "	sahf\n" "	jp  	1b\n": "=t"(ret): "u"(y), "0"(x): "eax","st");
  return ret;
}

long double (fmodl)(long double x,long double y)
{
  long double ret;
  asm("1:\n" "	fprem\n" "	fstsw	%%ax\n" "	sahf\n" "	jp  	1b\n": "=t"(ret): "u"(y), "0"(x): "eax","st");
  return ret;
}
# 787 "libm.c"
float (hypotf)(float x,float y)
{
  register float retval;
  asm ( "fxam\n" "	fnstsw\n" "	movb	%%ah, %%ch\n" "	fxch	%2\n" "	fld	%0\n" "	fstp	%0\n" "	fxam\n" "	fnstsw\n" "	movb	%%ah, %%al\n" "	orb	%%ch, %%ah\n" "	sahf\n" "	jc	1f\n" "	fxch	%2\n" "	fmul	%0\n" "	fxch\n" "	fmul	%0\n" "	faddp\n" "	fsqrt\n" "	jmp	2f\n""1:	andb	$0x45, %%al\n" "	cmpb	$5, %%al\n" "	je	3f\n" "	andb	$0x45, %%ch\n" "	cmpb	$5, %%ch\n" "	jne	4f\n" "	fxch\n""3:	fstp	%2\n" "	fabs\n" "	jmp	2f\n""4:	testb	$1, %%al\n" "	jnz	5f\n" "	fxch\n""5:	fstp	%2\n""2:": "=t"(retval) : "0"(x),"u"(y) : "eax","ecx","st(1)");
  return retval;
}

double (hypot)(double x,double y)
{
  register double retval;
  asm ( "fxam\n" "	fnstsw\n" "	movb	%%ah, %%ch\n" "	fxch	%2\n" "	fld	%0\n" "	fstp	%0\n" "	fxam\n" "	fnstsw\n" "	movb	%%ah, %%al\n" "	orb	%%ch, %%ah\n" "	sahf\n" "	jc	1f\n" "	fxch	%2\n" "	fmul	%0\n" "	fxch\n" "	fmul	%0\n" "	faddp\n" "	fsqrt\n" "	jmp	2f\n""1:	andb	$0x45, %%al\n" "	cmpb	$5, %%al\n" "	je	3f\n" "	andb	$0x45, %%ch\n" "	cmpb	$5, %%ch\n" "	jne	4f\n" "	fxch\n""3:	fstp	%2\n" "	fabs\n" "	jmp	2f\n""4:	testb	$1, %%al\n" "	jnz	5f\n" "	fxch\n""5:	fstp	%2\n""2:": "=t"(retval) : "0"(x),"u"(y) : "eax","ecx","st(1)");
  return retval;
}

long double (hypotl)(long double x,long double y)
{
  register long double retval;
  asm ( "fxam\n" "	fnstsw\n" "	movb	%%ah, %%ch\n" "	fxch	%2\n" "	fld	%0\n" "	fstp	%0\n" "	fxam\n" "	fnstsw\n" "	movb	%%ah, %%al\n" "	orb	%%ch, %%ah\n" "	sahf\n" "	jc	1f\n" "	fxch	%2\n" "	fmul	%0\n" "	fxch\n" "	fmul	%0\n" "	faddp\n" "	fsqrt\n" "	jmp	2f\n""1:	andb	$0x45, %%al\n" "	cmpb	$5, %%al\n" "	je	3f\n" "	andb	$0x45, %%ch\n" "	cmpb	$5, %%ch\n" "	jne	4f\n" "	fxch\n""3:	fstp	%2\n" "	fabs\n" "	jmp	2f\n""4:	testb	$1, %%al\n" "	jnz	5f\n" "	fxch\n""5:	fstp	%2\n""2:": "=t"(retval) : "0"(x),"u"(y) : "eax","ecx","st(1)");
  return retval;
}
# 820 "libm.c"
float (logf)(float x)
{
  register float ret;
  asm("fldln2\n" "	fxch\n" "	fyl2x": "=t"(ret): "0"(x));
  return ret;
}

double (log)(double x)
{
  register double ret;
  asm("fldln2\n" "	fxch\n" "	fyl2x": "=t"(ret): "0"(x));
  return ret;
}

long double (logl)(long double x)
{
  register long double ret;
  asm("fldln2\n" "	fxch\n" "	fyl2x": "=t"(ret): "0"(x));
  return ret;
}
# 848 "libm.c"
float (log10f)(float x)
{
  register float ret;
  asm("fldlg2\n" "	fxch\n" "	fyl2x": "=t"(ret): "0"(x));
  return ret;
}

double (log10)(double x)
{
  register double ret;
  asm("fldlg2\n" "	fxch\n" "	fyl2x": "=t"(ret): "0"(x));
  return ret;
}

long double (log10l)(long double x)
{
  register long double ret;
  asm("fldlg2\n" "	fxch\n" "	fyl2x": "=t"(ret): "0"(x));
  return ret;
}
# 880 "libm.c"
float (remainderf)(float x,float y)
{
  register float ret;
  asm("\n1:	fprem1\n" "	fstsw	%%ax\n" "	sahf\n" "	jp	1b\n" "	fstp	%2" : "=t"(ret) : "0"(x), "u"(y): "st(1)","eax");
  return ret;
}

double (remainder)(double x,double y)
{
  register double ret;
  asm("\n1:	fprem1\n" "	fstsw	%%ax\n" "	sahf\n" "	jp	1b\n" "	fstp	%2" : "=t"(ret) : "0"(x), "u"(y): "st(1)","eax");
  return ret;
}

long double (remainderl)(long double x,long double y)
{
  register long double ret;
  asm("\n1:	fprem1\n" "	fstsw	%%ax\n" "	sahf\n" "	jp	1b\n" "	fstp	%2" : "=t"(ret) : "0"(x), "u"(y): "st(1)","eax");
  return ret;
}

float (dremf)(float x,float y)
{
  register float ret;
  asm("\n1:	fprem1\n" "	fstsw	%%ax\n" "	sahf\n" "	jp	1b\n" "	fstp	%2" : "=t"(ret) : "0"(x), "u"(y): "st(1)","eax");
  return ret;
}

double (drem)(double x,double y)
{
  register double ret;
  asm("\n1:	fprem1\n" "	fstsw	%%ax\n" "	sahf\n" "	jp	1b\n" "	fstp	%2" : "=t"(ret) : "0"(x), "u"(y): "st(1)","eax");
  return ret;
}

long double (dreml)(long double x,long double y)
{
  register long double ret;
  asm("\n1:	fprem1\n" "	fstsw	%%ax\n" "	sahf\n" "	jp	1b\n" "	fstp	%2" : "=t"(ret) : "0"(x), "u"(y): "st(1)","eax");
  return ret;
}






float (sqrtf)(float x)
{
  register float ret;
  asm("fsqrt" : "=t"(ret): "0"(x));
  return ret;
}

double (sqrt)(double x)
{
  register double ret;
  asm("fsqrt" : "=t"(ret): "0"(x));
  return ret;
}

long double (sqrtl)(long double x)
{
  register long double ret;
  asm("fsqrt" : "=t"(ret): "0"(x));
  return ret;
}







float (atanf)(float x)
{
  register float ret;
  asm("fld1\n" "	fpatan": "=t"(ret): "0"(x));
  return ret;
}

double (atan)(double x)
{
  register double ret;
  asm("fld1\n" "	fpatan": "=t"(ret): "0"(x));
  return ret;
}

long double (atanl)(long double x)
{
  register long double ret;
  asm("fld1\n" "	fpatan": "=t"(ret): "0"(x));
  return ret;
}
# 986 "libm.c"
float (ceilf)(float val)
{
  unsigned int cw;
  unsigned int new_cw;
  register float ret;
  asm("fstcw	%0":"=m"(cw)::"memory"); new_cw = (cw | 0x800) & 0xfbff; asm("fldcw	%3\n" "	frndint\n" "	fldcw	%2" :"=t"(ret) :"0"(val), "m"(cw), "m"(new_cw));
  return ret;
}

double (ceil)(double val)
{
  unsigned int cw;
  unsigned int new_cw;
  register double ret;
  asm("fstcw	%0":"=m"(cw)::"memory"); new_cw = (cw | 0x800) & 0xfbff; asm("fldcw	%3\n" "	frndint\n" "	fldcw	%2" :"=t"(ret) :"0"(val), "m"(cw), "m"(new_cw));
  return ret;
}

long double (ceill)(long double val)
{
  unsigned int cw;
  unsigned int new_cw;
  register long double ret;
  asm("fstcw	%0":"=m"(cw)::"memory"); new_cw = (cw | 0x800) & 0xfbff; asm("fldcw	%3\n" "	frndint\n" "	fldcw	%2" :"=t"(ret) :"0"(val), "m"(cw), "m"(new_cw));
  return ret;
}

float (copysignf)(float x,float y)
{
  register int sw;
  uint32_t *xp;
  asm("fxam\n" "	fnstsw":"=a"(sw):"t"(y));
  xp = (uint32_t *)&x;
  if((sw&0x0200)) xp[0] |= 0x80000000UL;
  else xp[0] &= ~0x80000000UL;
  return x;
}

double (copysign)(double x,double y)
{
  register int sw;
  uint32_t *xp;
  asm("fxam\n" "	fnstsw":"=a"(sw):"t"(y));
  xp = (uint32_t *)&x;
  if((sw&0x0200)) xp[1] |= 0x80000000UL;
  else xp[1] &= ~0x80000000UL;
  return x;
}

long double (copysignl)(long double x,long double y)
{
  register int sw;
  uint32_t *xp;
  asm("fxam\n" "	fnstsw":"=a"(sw):"t"(y));
  xp = (uint32_t *)&x;
  if((sw&0x0200)) xp[2] |= 0x8000UL;
  else xp[2] &= ~0x8000UL;
  return x;
}
# 1065 "libm.c"
float (cosf)(float x)
{
  register float ret;
  asm("fcos\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	je	2f\n" "	fldpi\n" "	fadd	%0\n" "	fxch	%%st(1)\n""1:	fprem1\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	jne	1b\n" "	fstp	%%st(1)\n" "	""fcos\n""2:": "=t"(ret) : "0"(x): "st(1)","eax");
  return ret;
}

double (cos)(double x)
{
  register double ret;
  asm("fcos\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	je	2f\n" "	fldpi\n" "	fadd	%0\n" "	fxch	%%st(1)\n""1:	fprem1\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	jne	1b\n" "	fstp	%%st(1)\n" "	""fcos\n""2:": "=t"(ret) : "0"(x): "st(1)","eax");
  return ret;
}

long double (cosl)(long double x)
{
  register long double ret;
  asm("fcos\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	je	2f\n" "	fldpi\n" "	fadd	%0\n" "	fxch	%%st(1)\n""1:	fprem1\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	jne	1b\n" "	fstp	%%st(1)\n" "	""fcos\n""2:": "=t"(ret) : "0"(x): "st(1)","eax");
  return ret;
}

float (sinf)(float x)
{
  register float ret;
  asm("fsin\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	je	2f\n" "	fldpi\n" "	fadd	%0\n" "	fxch	%%st(1)\n""1:	fprem1\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	jne	1b\n" "	fstp	%%st(1)\n" "	""fsin\n""2:": "=t"(ret) : "0"(x): "st(1)","eax");
  return ret;
}

double (sin)(double x)
{
  register double ret;
  asm("fsin\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	je	2f\n" "	fldpi\n" "	fadd	%0\n" "	fxch	%%st(1)\n""1:	fprem1\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	jne	1b\n" "	fstp	%%st(1)\n" "	""fsin\n""2:": "=t"(ret) : "0"(x): "st(1)","eax");
  return ret;
}

long double (sinl)(long double x)
{
  register long double ret;
  asm("fsin\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	je	2f\n" "	fldpi\n" "	fadd	%0\n" "	fxch	%%st(1)\n""1:	fprem1\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	jne	1b\n" "	fstp	%%st(1)\n" "	""fsin\n""2:": "=t"(ret) : "0"(x): "st(1)","eax");
  return ret;
}
# 1127 "libm.c"
float (tanf)(float x)
{
  register float ret;
  asm("fptan\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	je	2f\n" "	fldpi\n" "	fadd	%0\n" "	fxch	%%st(1)\n""1:	fprem1\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	jne	1b\n" "	fstp	%%st(1)\n" "	fptan\n""2:\n" "ffreep""	%0": "=t"(ret) : "0"(x): "st(1)","eax");
  return ret;
}

double (tan)(double x)
{
  register double ret;
  asm("fptan\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	je	2f\n" "	fldpi\n" "	fadd	%0\n" "	fxch	%%st(1)\n""1:	fprem1\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	jne	1b\n" "	fstp	%%st(1)\n" "	fptan\n""2:\n" "ffreep""	%0": "=t"(ret) : "0"(x): "st(1)","eax");
  return ret;
}

long double (tanl)(long double x)
{
  register long double ret;
  asm("fptan\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	je	2f\n" "	fldpi\n" "	fadd	%0\n" "	fxch	%%st(1)\n""1:	fprem1\n" "	fnstsw	%%ax\n" "	testb	$0x04, %%ah\n" "	jne	1b\n" "	fstp	%%st(1)\n" "	fptan\n""2:\n" "ffreep""	%0": "=t"(ret) : "0"(x): "st(1)","eax");
  return ret;
}
# 1174 "libm.c"
float (exp2f)(float x)
{
  register float ret;
  asm("fxam\n" "	fstsw	%%ax\n" "	movb	$0x45, %%dh\n" "	andb	%%ah, %%dh\n" "	cmpb	$0x05, %%dh\n" "	je	1f\n" "	fld	%0\n" "	frndint\n" "	fsubr	%0, %%st(1)\n" "	fxch\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale\n" "	fstp	%%st(1)\n" "	jmp	2f\n""1:	testl	$0x200, %%eax\n" "	jz	2f\n" "ffreep""	%0\n" "	fldz\n""2:": "=t"(ret): "0"(x): "eax","edx");
  return ret;
}

double (exp2)(double x)
{
  register double ret;
  asm("fxam\n" "	fstsw	%%ax\n" "	movb	$0x45, %%dh\n" "	andb	%%ah, %%dh\n" "	cmpb	$0x05, %%dh\n" "	je	1f\n" "	fld	%0\n" "	frndint\n" "	fsubr	%0, %%st(1)\n" "	fxch\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale\n" "	fstp	%%st(1)\n" "	jmp	2f\n""1:	testl	$0x200, %%eax\n" "	jz	2f\n" "ffreep""	%0\n" "	fldz\n""2:": "=t"(ret): "0"(x): "eax","edx");
  return ret;
}

long double (exp2l)(long double x)
{
  register long double ret;
  asm("fxam\n" "	fstsw	%%ax\n" "	movb	$0x45, %%dh\n" "	andb	%%ah, %%dh\n" "	cmpb	$0x05, %%dh\n" "	je	1f\n" "	fld	%0\n" "	frndint\n" "	fsubr	%0, %%st(1)\n" "	fxch\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale\n" "	fstp	%%st(1)\n" "	jmp	2f\n""1:	testl	$0x200, %%eax\n" "	jz	2f\n" "ffreep""	%0\n" "	fldz\n""2:": "=t"(ret): "0"(x): "eax","edx");
  return ret;
}
# 1202 "libm.c"
float (fdimf)(float x, float y)
{
  register float ret;
  asm("fsubp	%2\n" "	fabs": "=t"(ret): "0"(y), "u"(x));
  return ret;
}

double (fdim)(double x, double y)
{
  register double ret;
  asm("fsubp	%2\n" "	fabs": "=t"(ret): "0"(y), "u"(x));
  return ret;
}

long double (fdiml)(long double x, long double y)
{
  register long double ret;
  asm("fsubp	%2\n" "	fabs": "=t"(ret): "0"(y), "u"(x));
  return ret;
}
# 1235 "libm.c"
float (floorf)(float val)
{
  unsigned int cw;
  unsigned int new_cw;
  register float ret;
  asm("fstcw	%0":"=m"(cw)::"memory"); new_cw = (cw | 0x400) & 0xf7ff; asm("fldcw	%3\n" "	frndint\n" "	fldcw	%2" :"=t"(ret) :"0"(val), "m"(cw), "m"(new_cw));
  return ret;
}

double (floor)(double val)
{
  unsigned int cw;
  unsigned int new_cw;
  register double ret;
  asm("fstcw	%0":"=m"(cw)::"memory"); new_cw = (cw | 0x400) & 0xf7ff; asm("fldcw	%3\n" "	frndint\n" "	fldcw	%2" :"=t"(ret) :"0"(val), "m"(cw), "m"(new_cw));
  return ret;
}

long double (floorl)(long double val)
{
  unsigned int cw;
  unsigned int new_cw;
  register long double ret;
  asm("fstcw	%0":"=m"(cw)::"memory"); new_cw = (cw | 0x400) & 0xf7ff; asm("fldcw	%3\n" "	frndint\n" "	fldcw	%2" :"=t"(ret) :"0"(val), "m"(cw), "m"(new_cw));
  return ret;
}



float (fmaf)(float x,float y,float z)
{
  return ((x*y)+z);
}

double (fma)(double x,double y,double z)
{
  return ((x*y)+z);
}

long double (fmal)(long double x,long double y,long double z)
{
  return ((x*y)+z);
}
# 1311 "libm.c"
float (fmaxf)(float x, float y)
{
  register float ret;
  asm("fxam\n" "	fnstsw\n" "	andb	$0x45, %%ah\n" "	fxch	%2\n" "	cmpb	$0x01, %%ah\n" "	je	1f\n" "	fucom	%2\n" "	fnstsw\n" "	sahf\n" "	jnc	1f\n" "	fxch	%2\n""1:	fstp	%2": "=t"(ret): "0"(y), "u"(x): "eax","st(1)");
  return ret;
}

double (fmax)(double x, double y)
{
  register double ret;
  asm("fxam\n" "	fnstsw\n" "	andb	$0x45, %%ah\n" "	fxch	%2\n" "	cmpb	$0x01, %%ah\n" "	je	1f\n" "	fucom	%2\n" "	fnstsw\n" "	sahf\n" "	jnc	1f\n" "	fxch	%2\n""1:	fstp	%2": "=t"(ret): "0"(y), "u"(x): "eax","st(1)");
  return ret;
}

long double (fmaxl)(long double x, long double y)
{
  register long double ret;
  asm("fxam\n" "	fnstsw\n" "	andb	$0x45, %%ah\n" "	fxch	%2\n" "	cmpb	$0x01, %%ah\n" "	je	1f\n" "	fucom	%2\n" "	fnstsw\n" "	sahf\n" "	jnc	1f\n" "	fxch	%2\n""1:	fstp	%2": "=t"(ret): "0"(y), "u"(x): "eax","st(1)");
  return ret;
}
# 1362 "libm.c"
float (fminf)(float x, float y)
{
  register float ret;
  asm("fxam\n" "	fnstsw\n" "	andb	$0x45, %%ah\n" "	cmpb	$0x01, %%ah\n" "	je	1f\n" "	fucom	%2\n" "	fnstsw\n" "	sahf\n" "	jc	2f\n""1:	fxch	%2\n""2:	fstp	%2\n": "=t"(ret): "0"(y), "u"(x): "eax","st(1)");
  return ret;
}

double (fmin)(double x, double y)
{
  register double ret;
  asm("fxam\n" "	fnstsw\n" "	andb	$0x45, %%ah\n" "	cmpb	$0x01, %%ah\n" "	je	1f\n" "	fucom	%2\n" "	fnstsw\n" "	sahf\n" "	jc	2f\n""1:	fxch	%2\n""2:	fstp	%2\n": "=t"(ret): "0"(y), "u"(x): "eax","st(1)");
  return ret;
}

long double (fminl)(long double x, long double y)
{
  register long double ret;
  asm("fxam\n" "	fnstsw\n" "	andb	$0x45, %%ah\n" "	cmpb	$0x01, %%ah\n" "	je	1f\n" "	fucom	%2\n" "	fnstsw\n" "	sahf\n" "	jc	2f\n""1:	fxch	%2\n""2:	fstp	%2\n": "=t"(ret): "0"(y), "u"(x): "eax","st(1)");
  return ret;
}
# 1412 "libm.c"
float (frexpf)(float x, int *eptr)
{
  register float retval;
  { register long double minus_one; asm("fld1\n" "	fchs": "=t"(minus_one)); *eptr = 0; asm("ftst\n" "	fstsw	%%ax\n" "	andb	$0x41, %%ah\n" "	xorb	$0x40, %%ah\n" "	jz	1f\n" "	fxtract\n" "	fxch	%2\n" "	fistpl	(%3)\n" "	fscale\n" "	incl	(%3)\n""1:	fstp	%2": "=t"(retval): "0"(x), "u"(minus_one), "r"(eptr): "eax","memory","st(1)");};
  return retval;
}

double (frexp)(double x, int *eptr)
{
  register double retval;
  { register long double minus_one; asm("fld1\n" "	fchs": "=t"(minus_one)); *eptr = 0; asm("ftst\n" "	fstsw	%%ax\n" "	andb	$0x41, %%ah\n" "	xorb	$0x40, %%ah\n" "	jz	1f\n" "	fxtract\n" "	fxch	%2\n" "	fistpl	(%3)\n" "	fscale\n" "	incl	(%3)\n""1:	fstp	%2": "=t"(retval): "0"(x), "u"(minus_one), "r"(eptr): "eax","memory","st(1)");};
  return retval;
}

long double (frexpl)(long double x, int *eptr)
{
  register long double retval;
  { register long double minus_one; asm("fld1\n" "	fchs": "=t"(minus_one)); *eptr = 0; asm("ftst\n" "	fstsw	%%ax\n" "	andb	$0x41, %%ah\n" "	xorb	$0x40, %%ah\n" "	jz	1f\n" "	fxtract\n" "	fxch	%2\n" "	fistpl	(%3)\n" "	fscale\n" "	incl	(%3)\n""1:	fstp	%2": "=t"(retval): "0"(x), "u"(minus_one), "r"(eptr): "eax","memory","st(1)");};
  return retval;
}
# 1441 "libm.c"
int (ilogbf)(float x)
{
  int ret;
  asm("fxtract\n" "	fstp	%1\n" "	fistpl	%0\n" "	fwait" : "=m"(ret): "t"(x));
  return ret;
}

int (ilogb)(double x)
{
  int ret;
  asm("fxtract\n" "	fstp	%1\n" "	fistpl	%0\n" "	fwait" : "=m"(ret): "t"(x));
  return ret;
}

int (ilogbl)(long double x)
{
  int ret;
  asm("fxtract\n" "	fstp	%1\n" "	fistpl	%0\n" "	fwait" : "=m"(ret): "t"(x));
  return ret;
}
# 1469 "libm.c"
long long int (llrintf)(float x)
{
  long long int ret;
  asm("fistpll	%0\n" "	fwait" : "=m"(ret): "t"(x) : "st");
  return ret;
}

long long int (llrint)(double x)
{
  long long int ret;
  asm("fistpll	%0\n" "	fwait" : "=m"(ret): "t"(x) : "st");
  return ret;
}

long long int (llrintl)(long double x)
{
  long long int ret;
  asm("fistpll	%0\n" "	fwait" : "=m"(ret): "t"(x) : "st");
  return ret;
}
# 1509 "libm.c"
float (log1pf)(float x)
{
  register float retval;
  asm("fldln2\n" "	fxch\n" "	fld1\n" "	faddp %%st(1)\n" "	fyl2x": "=t"(retval): "0"(x));
  return retval;
}

double (log1p)(double x)
{
  register double retval;
  asm("fldln2\n" "	fxch\n" "	fld1\n" "	faddp %%st(1)\n" "	fyl2x": "=t"(retval): "0"(x));
  return retval;
}

long double (log1pl)(long double x)
{
  register long double retval;
  asm("fldln2\n" "	fxch\n" "	fld1\n" "	faddp %%st(1)\n" "	fyl2x": "=t"(retval): "0"(x));
  return retval;
}
# 1537 "libm.c"
float (log2f)(float x)
{
  register float retval;
  asm("fld1\n" "	fxch\n" "	fyl2x": "=t"(retval): "0"(x));
  return retval;
}

double (log2)(double x)
{
  register double retval;
  asm("fld1\n" "	fxch\n" "	fyl2x": "=t"(retval): "0"(x));
  return retval;
}

long double (log2l)(long double x)
{
  register long double retval;
  asm("fld1\n" "	fxch\n" "	fyl2x": "=t"(retval): "0"(x));
  return retval;
}
# 1565 "libm.c"
float (logbf)(float x)
{
  register float ret;
  asm("fxtract\n" "	fstp	%0": "=t"(ret) : "0"(x) : "st(1)");
  return ret;
}

double (logb)(double x)
{
  register double ret;
  asm("fxtract\n" "	fstp	%0": "=t"(ret) : "0"(x) : "st(1)");
  return ret;
}

long double (logbl)(long double x)
{
  register long double ret;
  asm("fxtract\n" "	fstp	%0": "=t"(ret) : "0"(x) : "st(1)");
  return ret;
}
# 1593 "libm.c"
long int (lrintf)(float x)
{
  long int ret;
  asm("fistpl	%0\n" "	fwait" : "=m"(ret): "t"(x) : "st");
  return ret;
}

long int (lrint)(double x)
{
  long int ret;
  asm("fistpl	%0\n" "	fwait" : "=m"(ret): "t"(x) : "st");
  return ret;
}

long int (lrintl)(long double x)
{
  long int ret;
  asm("fistpl	%0\n" "	fwait" : "=m"(ret): "t"(x) : "st");
  return ret;
}






float (rintf)(float x)
{
  register float ret;
  asm("frndint": "=t"(ret) : "0"(x));
  return ret;
}

double (rint)(double x)
{
  register double ret;
  asm("frndint": "=t"(ret) : "0"(x));
  return ret;
}

long double (rintl)(long double x)
{
  register long double ret;
  asm("frndint": "=t"(ret) : "0"(x));
  return ret;
}
# 1647 "libm.c"
float (scalbnf)(float x,int n)
{
  register float ret;
  asm("fscale" : "=t"(ret) : "0"(x), "u"((float)n): "st");
  return ret;
}

double (scalbn)(double x,int n)
{
  register double ret;
  asm("fscale" : "=t"(ret) : "0"(x), "u"((double)n): "st");
  return ret;
}

long double (scalbnl)(long double x,int n)
{
  register long double ret;
  asm("fscale" : "=t"(ret) : "0"(x), "u"((long double)n): "st");
  return ret;
}

float (ldexpf)(float x,int n)
{
  register float ret;
  asm("fscale" : "=t"(ret) : "0"(x), "u"((float)n): "st");
  return ret;
}

double (ldexp)(double x,int n)
{
  register double ret;
  asm("fscale" : "=t"(ret) : "0"(x), "u"((double)n): "st");
  return ret;
}

long double (ldexpl)(long double x,int n)
{
  register long double ret;
  asm("fscale" : "=t"(ret) : "0"(x), "u"((long double)n): "st");
  return ret;
}







float (significandf)(float x)
{
  float ret;
  asm("fxtract\n" "	fstp	%%st(1)": "=t"(ret) : "0"(x));
  return ret;
}

double (significand)(double x)
{
  double ret;
  asm("fxtract\n" "	fstp	%%st(1)": "=t"(ret) : "0"(x));
  return ret;
}

long double (significandl)(long double x)
{
  long double ret;
  asm("fxtract\n" "	fstp	%%st(1)": "=t"(ret) : "0"(x));
  return ret;
}
# 1724 "libm.c"
void (sincosf)(float x,float *sinptr,float *cosptr)
{
  { register long double sv,cv; asm("fsincos":"=t"(cv),"=u"(sv):"0"(x):"st","st(1)"); *cosptr = cv; *sinptr = sv;};
}

void (sincos)(double x,double *sinptr,double *cosptr)
{
  { register long double sv,cv; asm("fsincos":"=t"(cv),"=u"(sv):"0"(x):"st","st(1)"); *cosptr = cv; *sinptr = sv;};
}

void (sincosl)(long double x,long double *sinptr,long double *cosptr)
{
  { register long double sv,cv; asm("fsincos":"=t"(cv),"=u"(sv):"0"(x):"st","st(1)"); *cosptr = cv; *sinptr = sv;};
}
# 1750 "libm.c"
float (truncf)(float x)
{
  register float ret;
  int i1,i2;
  asm("fstcw	%0":"=m"(i1)::"memory"); i2 = i1 | 0xc00; asm("fldcw	%3\n" "	frndint\n" "	fldcw	%2": "=t"(ret) : "0"(x), "m"(i1), "m"(i2));
  return ret;
}

double (trunc)(double x)
{
  register double ret;
  int i1,i2;
  asm("fstcw	%0":"=m"(i1)::"memory"); i2 = i1 | 0xc00; asm("fldcw	%3\n" "	frndint\n" "	fldcw	%2": "=t"(ret) : "0"(x), "m"(i1), "m"(i2));
  return ret;
}

long double (truncl)(long double x)
{
  register long double ret;
  int i1,i2;
  asm("fstcw	%0":"=m"(i1)::"memory"); i2 = i1 | 0xc00; asm("fldcw	%3\n" "	frndint\n" "	fldcw	%2": "=t"(ret) : "0"(x), "m"(i1), "m"(i2));
  return ret;
}






float (fabsf)(float x)
{
  register float ret;
  asm("fabs" : "=t"(ret): "0"(x));
  return ret;
}

double (fabs)(double x)
{
  register double ret;
  asm("fabs" : "=t"(ret): "0"(x));
  return ret;
}

long double (fabsl)(long double x)
{
  register long double ret;
  asm("fabs" : "=t"(ret): "0"(x));
  return ret;
}

static void (frac)( void )
{
  short cw1,cw2;
   asm("fnstcw	%0\n"
      "	fwait"
      :"=m"(cw1));
  cw2 = (cw1 & 0xf3ff) | 0x0400;
   asm("fldcw	%1\n"
      "	fld	%%st\n"
      "	frndint\n"
      "	fldcw	%0\n"
      "	fxch	%%st(1)\n"
      "	fsub	%%st(1), %%st"
      ::"m"(cw1),"m"(cw2):"memory");
}






static void (Lpow2)( void )
{
   asm("call	frac\n"
      "	f2xm1\n"
      "	fld1\n"
      "	faddp	%%st(1)\n"
      "	fscale\n"
      "	fstp	%%st(1)\n"
      ::: "memory");
}
# 1900 "libm.c"
float (powf)(float x, float y)
{
  register float retval;
  register int sw;
  asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x));
  if(((sw&0x4500)==0x0500) || x == 1) return x;
  else
  if(x == (float)10.) { asm("fldl2t\n" "	fmulp\n" "call	frac\n" "	f2xm1\n" "	fld1\n" "	faddp	%1, %%st(1)\n" "	fscale\n" "	fstp	%%st(1)\n" :"=t"(retval) :"0"(y));}
  else { int yint; asm("ftst\n" "	fnstsw	%%ax\n" "	sahf\n" "	jbe	1f\n" "	fyl2x\n" "call	Lpow2\n" "	jmp	6f\n""1:	jb	4f\n" "	fstp	%0\n" "	ftst\n" "	fnstsw	%%ax\n" "	sahf\n" "	ja	3f\n" "	jb	2f\n" "	fstp	%0\n" "	fld1\n" "	fchs\n""2:	fsqrt\n" "	jmp     6f\n""3:	fstp	%0\n" "	fldz\n" "	jmp	6f\n""4:	fabs\n" "	fxch	%2\n" "call	frac\n" "	ftst\n" "	fnstsw	%%ax\n" "	fstp	%0\n" "	sahf\n" "	je	5f\n" "	fstp	%0\n" "	fchs\n" "	jmp	2b\n""5:	fistl	%3\n" "	fxch	%2\n" "	fyl2x\n" "call	Lpow2\n" "	andl	$1, %3\n" "	jz	6f\n" "	fchs\n""6:" :"=t"(retval) :"0"(x),"u"(y),"m"(yint) :"eax","memory","st(1)");}
  return retval;
}

double (pow)(double x, double y)
{
  register double retval;
  register int sw;
  asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x));
  if(((sw&0x4500)==0x0500) || x == 1) return x;
  else
  if(x == (double)10.) { asm("fldl2t\n" "	fmulp\n" "call	frac\n" "	f2xm1\n" "	fld1\n" "	faddp	%1, %%st(1)\n" "	fscale\n" "	fstp	%%st(1)\n" :"=t"(retval) :"0"(y));}
  else { int yint; asm("ftst\n" "	fnstsw	%%ax\n" "	sahf\n" "	jbe	1f\n" "	fyl2x\n" "call	Lpow2\n" "	jmp	6f\n""1:	jb	4f\n" "	fstp	%0\n" "	ftst\n" "	fnstsw	%%ax\n" "	sahf\n" "	ja	3f\n" "	jb	2f\n" "	fstp	%0\n" "	fld1\n" "	fchs\n""2:	fsqrt\n" "	jmp     6f\n""3:	fstp	%0\n" "	fldz\n" "	jmp	6f\n""4:	fabs\n" "	fxch	%2\n" "call	frac\n" "	ftst\n" "	fnstsw	%%ax\n" "	fstp	%0\n" "	sahf\n" "	je	5f\n" "	fstp	%0\n" "	fchs\n" "	jmp	2b\n""5:	fistl	%3\n" "	fxch	%2\n" "	fyl2x\n" "call	Lpow2\n" "	andl	$1, %3\n" "	jz	6f\n" "	fchs\n""6:" :"=t"(retval) :"0"(x),"u"(y),"m"(yint) :"eax","memory","st(1)");}
  return retval;
}

long double (powl)(long double x, long double y)
{
  register long double retval;
  register int sw;
  asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x));
  if(((sw&0x4500)==0x0500) || x == 1) return x;
  else
  if(x == (long double)10.) { asm("fldl2t\n" "	fmulp\n" "call	frac\n" "	f2xm1\n" "	fld1\n" "	faddp	%1, %%st(1)\n" "	fscale\n" "	fstp	%%st(1)\n" :"=t"(retval) :"0"(y));}
  else { int yint; asm("ftst\n" "	fnstsw	%%ax\n" "	sahf\n" "	jbe	1f\n" "	fyl2x\n" "call	Lpow2\n" "	jmp	6f\n""1:	jb	4f\n" "	fstp	%0\n" "	ftst\n" "	fnstsw	%%ax\n" "	sahf\n" "	ja	3f\n" "	jb	2f\n" "	fstp	%0\n" "	fld1\n" "	fchs\n""2:	fsqrt\n" "	jmp     6f\n""3:	fstp	%0\n" "	fldz\n" "	jmp	6f\n""4:	fabs\n" "	fxch	%2\n" "call	frac\n" "	ftst\n" "	fnstsw	%%ax\n" "	fstp	%0\n" "	sahf\n" "	je	5f\n" "	fstp	%0\n" "	fchs\n" "	jmp	2b\n""5:	fistl	%3\n" "	fxch	%2\n" "	fyl2x\n" "call	Lpow2\n" "	andl	$1, %3\n" "	jz	6f\n" "	fchs\n""6:" :"=t"(retval) :"0"(x),"u"(y),"m"(yint) :"eax","memory","st(1)");}
  return retval;
}

float (pow10f)(float y)
{
  register float retval;
  register int sw;
  asm("fxam\n" "	fnstsw":"=a"(sw):"t"(y));
  if(((sw&0x4500)==0x0500)) return y;
  else
  { asm("fldl2t\n" "	fmulp\n" "call	frac\n" "	f2xm1\n" "	fld1\n" "	faddp	%1, %%st(1)\n" "	fscale\n" "	fstp	%%st(1)\n" :"=t"(retval) :"0"(y));}
  return retval;
}

double (pow10)(double y)
{
  register double retval;
  register int sw;
  asm("fxam\n" "	fnstsw":"=a"(sw):"t"(y));
  if(((sw&0x4500)==0x0500)) return y;
  else
  { asm("fldl2t\n" "	fmulp\n" "call	frac\n" "	f2xm1\n" "	fld1\n" "	faddp	%1, %%st(1)\n" "	fscale\n" "	fstp	%%st(1)\n" :"=t"(retval) :"0"(y));}
  return retval;
}

long double (pow10l)(long double y)
{
  register long double retval;
  register int sw;
  asm("fxam\n" "	fnstsw":"=a"(sw):"t"(y));
  if(((sw&0x4500)==0x0500)) return y;
  else
  { asm("fldl2t\n" "	fmulp\n" "call	frac\n" "	f2xm1\n" "	fld1\n" "	faddp	%1, %%st(1)\n" "	fscale\n" "	fstp	%%st(1)\n" :"=t"(retval) :"0"(y));}
  return retval;
}





float (cbrtf)(float x)
{
  register int sw;
  asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x));
  if(((sw&0x4500)==0x0500)) return x;
  else
  if (x >= 0)
    return powf (x, 1.0 / 3.0);
  else
    return -powf (-x, 1.0 / 3.0);
}

double (cbrt)(double x)
{
  register int sw;
  asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x));
  if(((sw&0x4500)==0x0500)) return x;
  else
  if (x >= 0)
    return pow (x, 1.0 / 3.0);
  else
    return -pow (-x, 1.0 / 3.0);
}

long double (cbrtl)(long double x)
{
  register int sw;
  asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x));
  if(((sw&0x4500)==0x0500)) return x;
  else
  if (x >= 0)
    return powl (x, 1.0 / 3.0);
  else
    return -powl (-x, 1.0 / 3.0);
}

float (acoshf)(float x)
{

  float retval;
  asm("fsqrt" : "=t"(retval): "0"(x*x-1));
  asm("fldln2\n" "	fxch\n" "	fyl2x": "=t"(retval): "0"(x + retval));
  return retval;
}

double (acosh)(double x)
{

  double retval;
  asm("fsqrt" : "=t"(retval): "0"(x*x-1));
  asm("fldln2\n" "	fxch\n" "	fyl2x": "=t"(retval): "0"(x + retval));
  return retval;
}

long double (acoshl)(long double x)
{

  long double retval;
  asm("fsqrt" : "=t"(retval): "0"(x*x-1));
  asm("fldln2\n" "	fxch\n" "	fyl2x": "=t"(retval): "0"(x + retval));
  return retval;
}

float (asinhf)(float x)
{

  float retval;
  asm("fsqrt" : "=t"(retval): "0"(x*x+1));
  if(x>0) asm("fldln2\n" "	fxch\n" "	fyl2x": "=t"(retval): "0"(x + retval));
  else
  {
    asm("fldln2\n" "	fxch\n" "	fyl2x": "=t"(retval): "0"(retval-x));
    retval = -retval;
  }
  return retval;
}

double (asinh)(double x)
{

  double retval;
  asm("fsqrt" : "=t"(retval): "0"(x*x+1));
  if(x>0) asm("fldln2\n" "	fxch\n" "	fyl2x": "=t"(retval): "0"(x + retval));
  else
  {
    asm("fldln2\n" "	fxch\n" "	fyl2x": "=t"(retval): "0"(retval-x));
    retval = -retval;
  }
  return retval;
}

long double (asinhl)(long double x)
{

  long double retval;
  asm("fsqrt" : "=t"(retval): "0"(x*x+1));
  if(x>0) asm("fldln2\n" "	fxch\n" "	fyl2x": "=t"(retval): "0"(x + retval));
  else
  {
    asm("fldln2\n" "	fxch\n" "	fyl2x": "=t"(retval): "0"(retval-x));
    retval = -retval;
  }
  return retval;
}

float (atanhf)(float x)
{

  float retval;
  asm("fldln2\n" "	fxch\n" "	fyl2x": "=t"(retval): "0"((1+x)/(1-x)));
  return retval/2.;
}

double (atanh)(double x)
{

  double retval;
  asm("fldln2\n" "	fxch\n" "	fyl2x": "=t"(retval): "0"((1+x)/(1-x)));
  return retval/2.;
}

long double (atanhl)(long double x)
{

  long double retval;
  asm("fldln2\n" "	fxch\n" "	fyl2x": "=t"(retval): "0"((1+x)/(1-x)));
  return retval/2.;
}

float (coshf)(float x)
{
  float retval;
  asm("fabs" : "=t"(retval): "0"(x));
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(retval)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) retval = 0.; else retval = retval; } else asm("fldl2e\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale": "=t"(retval): "0"(retval): "st(1)", "st(2)");};
  return (retval + 1.0/retval) / 2.0;
}

double (cosh)(double x)
{
  double retval;
  asm("fabs" : "=t"(retval): "0"(x));
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(retval)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) retval = 0.; else retval = retval; } else asm("fldl2e\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale": "=t"(retval): "0"(retval): "st(1)", "st(2)");};
  return (retval + 1.0/retval) / 2.0;
}

long double (coshl)(long double x)
{
  long double retval;
  asm("fabs" : "=t"(retval): "0"(x));
  { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(retval)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) retval = 0.; else retval = retval; } else asm("fldl2e\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale": "=t"(retval): "0"(retval): "st(1)", "st(2)");};
  return (retval + 1.0/retval) / 2.0;
}

float (sinhf)(float x)
{
 if(x >= 0.0)
 {
   float epos;
   { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) epos = 0.; else epos = x; } else asm("fldl2e\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale": "=t"(epos): "0"(x): "st(1)", "st(2)");};
   return (epos - 1.0/epos) / 2.0;
 }
 else
 {
   float eneg;
   { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(-x)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) eneg = 0.; else eneg = -x; } else asm("fldl2e\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale": "=t"(eneg): "0"(-x): "st(1)", "st(2)");};
   return (1.0/eneg - eneg) / 2.0;
 }
}

double (sinh)(double x)
{
 if(x >= 0.0)
 {
   double epos;
   { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) epos = 0.; else epos = x; } else asm("fldl2e\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale": "=t"(epos): "0"(x): "st(1)", "st(2)");};
   return (epos - 1.0/epos) / 2.0;
 }
 else
 {
   double eneg;
   { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(-x)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) eneg = 0.; else eneg = -x; } else asm("fldl2e\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale": "=t"(eneg): "0"(-x): "st(1)", "st(2)");};
   return (1.0/eneg - eneg) / 2.0;
 }
}

long double (sinhl)(long double x)
{
 if(x >= 0.0)
 {
   long double epos;
   { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) epos = 0.; else epos = x; } else asm("fldl2e\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale": "=t"(epos): "0"(x): "st(1)", "st(2)");};
   return (epos - 1.0/epos) / 2.0;
 }
 else
 {
   long double eneg;
   { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(-x)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) eneg = 0.; else eneg = -x; } else asm("fldl2e\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale": "=t"(eneg): "0"(-x): "st(1)", "st(2)");};
   return (1.0/eneg - eneg) / 2.0;
 }
}

float (tanhf)(float x)
{
  if (x > 50)
    return 1;
  else if (x < -50)
    return -1;
  else
  {
    float ebig;
    float esmall;
    { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) ebig = 0.; else ebig = x; } else asm("fldl2e\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale": "=t"(ebig): "0"(x): "st(1)", "st(2)");};
    esmall = 1./ebig;
    return (ebig - esmall) / (ebig + esmall);
  }
}

double (tanh)(double x)
{
  if (x > 50)
    return 1;
  else if (x < -50)
    return -1;
  else
  {
    double ebig;
    double esmall;
    { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) ebig = 0.; else ebig = x; } else asm("fldl2e\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale": "=t"(ebig): "0"(x): "st(1)", "st(2)");};
    esmall = 1./ebig;
    return (ebig - esmall) / (ebig + esmall);
  }
}

long double (tanhl)(long double x)
{
  if (x > 50)
    return 1;
  else if (x < -50)
    return -1;
  else
  {
    long double ebig;
    long double esmall;
    { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); if(((sw&0x4500)==0x0500)) { if((sw&0x0200)) ebig = 0.; else ebig = x; } else asm("fldl2e\n" "	fxch	%%st(1)\n" "	fmulp\n" "	fst	%%st(1)\n" "	frndint\n" "	fst	%%st(2)\n" "	fsubrp\n" "	f2xm1\n" "	fld1\n" "	faddp\n" "	fscale": "=t"(ebig): "0"(x): "st(1)", "st(2)");};
    esmall = 1./ebig;
    return (ebig - esmall) / (ebig + esmall);
  }
}
# 2236 "libm.c"
float (nearbyintf)(float x)
{
  register float retval;
  int new_sw,org_sw;
  asm("fnstcw	%0\n": "=m"(org_sw)); new_sw = org_sw & (~0x20); asm( "	fldcw	%2\n" "	frndint\n" "	fnclex\n" "	fldcw	%3": "=t"(retval): "0"(x), "m"(new_sw), "m"(org_sw));
  return retval;
}

double (nearbyint)(double x)
{
  register double retval;
  int new_sw,org_sw;
  asm("fnstcw	%0\n": "=m"(org_sw)); new_sw = org_sw & (~0x20); asm( "	fldcw	%2\n" "	frndint\n" "	fnclex\n" "	fldcw	%3": "=t"(retval): "0"(x), "m"(new_sw), "m"(org_sw));
  return retval;
}

long double (nearbyintl)(long double x)
{
  register long double retval;
  int new_sw,org_sw;
  asm("fnstcw	%0\n": "=m"(org_sw)); new_sw = org_sw & (~0x20); asm( "	fldcw	%2\n" "	frndint\n" "	fnclex\n" "	fldcw	%3": "=t"(retval): "0"(x), "m"(new_sw), "m"(org_sw));
  return retval;
}
# 2295 "libm.c"
float (expm1f)(float x)
{
  register float retval;
  asm("fxam\n" "	fstsw	%%ax\n" "	movb	$0x45, %%ch\n" "	andb	%%ah, %%ch\n" "	cmpb	$0x40, %%ch\n" "	je	3f\n" "	cmpb	$0x05, %%ch\n" "	je	2f\n" "	fldl2e\n" "	fmulp\n" "	fld	%1\n" "	frndint\n" "	fsubr	%1,  %%st(1)\n" "	fxch\n" "	f2xm1\n" "	fscale\n" "	fxch\n" "	fld1\n" "	fscale\n" "	fld1\n" "	fsubp	%1, %%st(1)\n" "	fstp	%%st(1)\n" "	fsubrp	%1, %%st(1)\n" "	jmp	3f\n""2:	testb	$0x02, %%ah\n" "	jz	3f\n" "ffreep""	%1\n" "	fld1\n" "	fchs\n""3:": "=t"(retval): "0"(x): "eax","ecx","st(1)");
  return retval;
}

double (expm1)(double x)
{
  register double retval;
  asm("fxam\n" "	fstsw	%%ax\n" "	movb	$0x45, %%ch\n" "	andb	%%ah, %%ch\n" "	cmpb	$0x40, %%ch\n" "	je	3f\n" "	cmpb	$0x05, %%ch\n" "	je	2f\n" "	fldl2e\n" "	fmulp\n" "	fld	%1\n" "	frndint\n" "	fsubr	%1,  %%st(1)\n" "	fxch\n" "	f2xm1\n" "	fscale\n" "	fxch\n" "	fld1\n" "	fscale\n" "	fld1\n" "	fsubp	%1, %%st(1)\n" "	fstp	%%st(1)\n" "	fsubrp	%1, %%st(1)\n" "	jmp	3f\n""2:	testb	$0x02, %%ah\n" "	jz	3f\n" "ffreep""	%1\n" "	fld1\n" "	fchs\n""3:": "=t"(retval): "0"(x): "eax","ecx","st(1)");
  return retval;
}

long double (expm1l)(long double x)
{
  register long double retval;
  asm("fxam\n" "	fstsw	%%ax\n" "	movb	$0x45, %%ch\n" "	andb	%%ah, %%ch\n" "	cmpb	$0x40, %%ch\n" "	je	3f\n" "	cmpb	$0x05, %%ch\n" "	je	2f\n" "	fldl2e\n" "	fmulp\n" "	fld	%1\n" "	frndint\n" "	fsubr	%1,  %%st(1)\n" "	fxch\n" "	f2xm1\n" "	fscale\n" "	fxch\n" "	fld1\n" "	fscale\n" "	fld1\n" "	fsubp	%1, %%st(1)\n" "	fstp	%%st(1)\n" "	fsubrp	%1, %%st(1)\n" "	jmp	3f\n""2:	testb	$0x02, %%ah\n" "	jz	3f\n" "ffreep""	%1\n" "	fld1\n" "	fchs\n""3:": "=t"(retval): "0"(x): "eax","ecx","st(1)");
  return retval;
}
# 2340 "libm.c"
float (scalbf)(float x, float n)
{
  register float retval;
  { register int nx, nfn; { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); nx=((sw&0x4500)==0x0100);}; { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(n)); nfn=((sw&0x4500)==0x0100);}; if (nx||nfn) return x*n; { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); nx=((sw&0x4500)==0x0400)||((sw&0x4500)==0x4000);}; { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(n)); nfn=((sw&0x4500)==0x0400)||((sw&0x4500)==0x4000);}; if (!nfn) { if(n>0.0) return x*n; else if (x == 0) return x; else if (!nx) return (0./0.); else return x/(-n); } if (rint(n)!=n) return (0./0.); if ( n > 65000.0) return scalbn(x, 65000); if (-n > 65000.0) return scalbn(x,-65000); return scalbn(x,(int)n);};
  return retval;
}

double (scalb)(double x, double n)
{
  register double retval;
  { register int nx, nfn; { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); nx=((sw&0x4500)==0x0100);}; { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(n)); nfn=((sw&0x4500)==0x0100);}; if (nx||nfn) return x*n; { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); nx=((sw&0x4500)==0x0400)||((sw&0x4500)==0x4000);}; { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(n)); nfn=((sw&0x4500)==0x0400)||((sw&0x4500)==0x4000);}; if (!nfn) { if(n>0.0) return x*n; else if (x == 0) return x; else if (!nx) return (0./0.); else return x/(-n); } if (rint(n)!=n) return (0./0.); if ( n > 65000.0) return scalbn(x, 65000); if (-n > 65000.0) return scalbn(x,-65000); return scalbn(x,(int)n);};
  return retval;
}

long double (scalbl)(long double x, long double n)
{
  register long double retval;
  { register int nx, nfn; { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); nx=((sw&0x4500)==0x0100);}; { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(n)); nfn=((sw&0x4500)==0x0100);}; if (nx||nfn) return x*n; { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(x)); nx=((sw&0x4500)==0x0400)||((sw&0x4500)==0x4000);}; { register int sw; asm("fxam\n" "	fnstsw":"=a"(sw):"t"(n)); nfn=((sw&0x4500)==0x0400)||((sw&0x4500)==0x4000);}; if (!nfn) { if(n>0.0) return x*n; else if (x == 0) return x; else if (!nx) return (0./0.); else return x/(-n); } if (rint(n)!=n) return (0./0.); if ( n > 65000.0) return scalbn(x, 65000); if (-n > 65000.0) return scalbn(x,-65000); return scalbn(x,(int)n);};
  return retval;
}