Prepare for radical source tree reorganization. zack/build-layout-experiment

All top-level files and directories are moved into a temporary storage
directory, REORG.TODO, except for files that will certainly still
exist in their current form at top level when we're done (COPYING,
COPYING.LIB, LICENSES, NEWS, README), all old ChangeLog files (which
are moved to the new directory OldChangeLogs, instead), and the
generated file INSTALL (which is just deleted; in the new order, there
will be no generated files checked into version control).

82 files changed, 7032 insertions, 0 deletions

diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_acosf.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_acosf.c
new file mode 100644
index 0000000000..6f792f6604
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_acosf.c
@@ -0,0 +1,78 @@
+/* e_acosf.c -- float version of e_acos.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+static const float
+one =  1.0000000000e+00, /* 0x3F800000 */
+pi =  3.1415925026e+00, /* 0x40490fda */
+pio2_hi =  1.5707962513e+00, /* 0x3fc90fda */
+pio2_lo =  7.5497894159e-08, /* 0x33a22168 */
+pS0 =  1.6666667163e-01, /* 0x3e2aaaab */
+pS1 = -3.2556581497e-01, /* 0xbea6b090 */
+pS2 =  2.0121252537e-01, /* 0x3e4e0aa8 */
+pS3 = -4.0055535734e-02, /* 0xbd241146 */
+pS4 =  7.9153501429e-04, /* 0x3a4f7f04 */
+pS5 =  3.4793309169e-05, /* 0x3811ef08 */
+qS1 = -2.4033949375e+00, /* 0xc019d139 */
+qS2 =  2.0209457874e+00, /* 0x4001572d */
+qS3 = -6.8828397989e-01, /* 0xbf303361 */
+qS4 =  7.7038154006e-02; /* 0x3d9dc62e */
+
+float
+__ieee754_acosf(float x)
+{
+	float z,p,q,r,w,s,c,df;
+	int32_t hx,ix;
+	GET_FLOAT_WORD(hx,x);
+	ix = hx&0x7fffffff;
+	if(ix==0x3f800000) {		/* |x|==1 */
+	    if(hx>0) return 0.0;	/* acos(1) = 0  */
+	    else return pi+(float)2.0*pio2_lo;	/* acos(-1)= pi */
+	} else if(ix>0x3f800000) {	/* |x| >= 1 */
+	    return (x-x)/(x-x);		/* acos(|x|>1) is NaN */
+	}
+	if(ix<0x3f000000) {	/* |x| < 0.5 */
+	    if(ix<=0x32800000) return pio2_hi+pio2_lo;/*if|x|<=2**-26*/
+	    z = x*x;
+	    p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
+	    q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
+	    r = p/q;
+	    return pio2_hi - (x - (pio2_lo-x*r));
+	} else  if (hx<0) {		/* x < -0.5 */
+	    z = (one+x)*(float)0.5;
+	    p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
+	    q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
+	    s = __ieee754_sqrtf(z);
+	    r = p/q;
+	    w = r*s-pio2_lo;
+	    return pi - (float)2.0*(s+w);
+	} else {			/* x > 0.5 */
+	    int32_t idf;
+	    z = (one-x)*(float)0.5;
+	    s = __ieee754_sqrtf(z);
+	    df = s;
+	    GET_FLOAT_WORD(idf,df);
+	    SET_FLOAT_WORD(df,idf&0xfffff000);
+	    c  = (z-df*df)/(s+df);
+	    p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
+	    q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
+	    r = p/q;
+	    w = r*s+c;
+	    return (float)2.0*(df+w);
+	}
+}
+strong_alias (__ieee754_acosf, __acosf_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_acoshf.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_acoshf.c
new file mode 100644
index 0000000000..aabfb85df7
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_acoshf.c
@@ -0,0 +1,49 @@
+/* e_acoshf.c -- float version of e_acosh.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: e_acoshf.c,v 1.5 1995/05/12 04:57:20 jtc Exp $";
+#endif
+
+#include <math.h>
+#include <math_private.h>
+
+static const float
+one	= 1.0,
+ln2	= 6.9314718246e-01;  /* 0x3f317218 */
+
+float __ieee754_acoshf(float x)
+{
+	float t;
+	int32_t hx;
+	GET_FLOAT_WORD(hx,x);
+	if(hx<0x3f800000) {		/* x < 1 */
+	    return (x-x)/(x-x);
+	} else if(hx >=0x4d800000) {	/* x > 2**28 */
+	    if(hx >=0x7f800000) {	/* x is inf of NaN */
+		return x+x;
+	    } else
+		return __ieee754_logf(x)+ln2;	/* acosh(huge)=log(2x) */
+	} else if (hx==0x3f800000) {
+	    return 0.0;			/* acosh(1) = 0 */
+	} else if (hx > 0x40000000) {	/* 2**28 > x > 2 */
+	    t=x*x;
+	    return __ieee754_logf((float)2.0*x-one/(x+__ieee754_sqrtf(t-one)));
+	} else {			/* 1<x<2 */
+	    t = x-one;
+	    return __log1pf(t+__ieee754_sqrtf((float)2.0*t+t*t));
+	}
+}
+strong_alias (__ieee754_acoshf, __acoshf_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_asinf.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_asinf.c
new file mode 100644
index 0000000000..2ca2dbcb28
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_asinf.c
@@ -0,0 +1,104 @@
+/* e_asinf.c -- float version of e_asin.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+/*
+  Modifications for single precision expansion are
+  Copyright (C) 2001 Stephen L. Moshier <moshier@na-net.ornl.gov>
+  and are incorporated herein by permission of the author.  The author
+  reserves the right to distribute this material elsewhere under different
+  copying permissions.  These modifications are distributed here under
+  the following terms:
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, see
+    <http://www.gnu.org/licenses/>.  */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: e_asinf.c,v 1.5 1995/05/12 04:57:25 jtc Exp $";
+#endif
+
+#include <float.h>
+#include <math.h>
+#include <math_private.h>
+
+static const float
+one =  1.0000000000e+00, /* 0x3F800000 */
+huge =  1.000e+30,
+
+pio2_hi = 1.57079637050628662109375f,
+pio2_lo = -4.37113900018624283e-8f,
+pio4_hi = 0.785398185253143310546875f,
+
+/* asin x = x + x^3 p(x^2)
+   -0.5 <= x <= 0.5;
+   Peak relative error 4.8e-9 */
+p0 = 1.666675248e-1f,
+p1 = 7.495297643e-2f,
+p2 = 4.547037598e-2f,
+p3 = 2.417951451e-2f,
+p4 = 4.216630880e-2f;
+
+float __ieee754_asinf(float x)
+{
+	float t,w,p,q,c,r,s;
+	int32_t hx,ix;
+	GET_FLOAT_WORD(hx,x);
+	ix = hx&0x7fffffff;
+	if(ix==0x3f800000) {
+		/* asin(1)=+-pi/2 with inexact */
+	    return x*pio2_hi+x*pio2_lo;
+	} else if(ix> 0x3f800000) {	/* |x|>= 1 */
+	    return (x-x)/(x-x);		/* asin(|x|>1) is NaN */
+	} else if (ix<0x3f000000) {	/* |x|<0.5 */
+	    if(ix<0x32000000) {		/* if |x| < 2**-27 */
+		math_check_force_underflow (x);
+		if(huge+x>one) return x;/* return x with inexact if x!=0*/
+	    } else {
+		t = x*x;
+		w = t * (p0 + t * (p1 + t * (p2 + t * (p3 + t * p4))));
+		return x+x*w;
+	    }
+	}
+	/* 1> |x|>= 0.5 */
+	w = one-fabsf(x);
+	t = w*0.5f;
+	p = t * (p0 + t * (p1 + t * (p2 + t * (p3 + t * p4))));
+	s = __ieee754_sqrtf(t);
+	if(ix>=0x3F79999A) {	/* if |x| > 0.975 */
+	    t = pio2_hi-(2.0f*(s+s*p)-pio2_lo);
+	} else {
+	    int32_t iw;
+	    w  = s;
+	    GET_FLOAT_WORD(iw,w);
+	    SET_FLOAT_WORD(w,iw&0xfffff000);
+	    c  = (t-w*w)/(s+w);
+	    r  = p;
+	    p  = 2.0f*s*r-(pio2_lo-2.0f*c);
+	    q  = pio4_hi-2.0f*w;
+	    t  = pio4_hi-(p-q);
+	}
+	if(hx>0) return t; else return -t;
+}
+strong_alias (__ieee754_asinf, __asinf_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_atan2f.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_atan2f.c
new file mode 100644
index 0000000000..29eefc0dd6
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_atan2f.c
@@ -0,0 +1,94 @@
+/* e_atan2f.c -- float version of e_atan2.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+static const float
+tiny  = 1.0e-30,
+zero  = 0.0,
+pi_o_4  = 7.8539818525e-01,  /* 0x3f490fdb */
+pi_o_2  = 1.5707963705e+00,  /* 0x3fc90fdb */
+pi      = 3.1415927410e+00,  /* 0x40490fdb */
+pi_lo   = -8.7422776573e-08; /* 0xb3bbbd2e */
+
+float
+__ieee754_atan2f (float y, float x)
+{
+	float z;
+	int32_t k,m,hx,hy,ix,iy;
+
+	GET_FLOAT_WORD(hx,x);
+	ix = hx&0x7fffffff;
+	GET_FLOAT_WORD(hy,y);
+	iy = hy&0x7fffffff;
+	if((ix>0x7f800000)||
+	   (iy>0x7f800000))	/* x or y is NaN */
+	   return x+y;
+	if(hx==0x3f800000) return __atanf(y);   /* x=1.0 */
+	m = ((hy>>31)&1)|((hx>>30)&2);	/* 2*sign(x)+sign(y) */
+
+    /* when y = 0 */
+	if(iy==0) {
+	    switch(m) {
+		case 0:
+		case 1: return y;	/* atan(+-0,+anything)=+-0 */
+		case 2: return  pi+tiny;/* atan(+0,-anything) = pi */
+		case 3: return -pi-tiny;/* atan(-0,-anything) =-pi */
+	    }
+	}
+    /* when x = 0 */
+	if(ix==0) return (hy<0)?  -pi_o_2-tiny: pi_o_2+tiny;
+
+    /* when x is INF */
+	if(ix==0x7f800000) {
+	    if(iy==0x7f800000) {
+		switch(m) {
+		    case 0: return  pi_o_4+tiny;/* atan(+INF,+INF) */
+		    case 1: return -pi_o_4-tiny;/* atan(-INF,+INF) */
+		    case 2: return  (float)3.0*pi_o_4+tiny;/*atan(+INF,-INF)*/
+		    case 3: return (float)-3.0*pi_o_4-tiny;/*atan(-INF,-INF)*/
+		}
+	    } else {
+		switch(m) {
+		    case 0: return  zero  ;	/* atan(+...,+INF) */
+		    case 1: return -zero  ;	/* atan(-...,+INF) */
+		    case 2: return  pi+tiny  ;	/* atan(+...,-INF) */
+		    case 3: return -pi-tiny  ;	/* atan(-...,-INF) */
+		}
+	    }
+	}
+    /* when y is INF */
+	if(iy==0x7f800000) return (hy<0)? -pi_o_2-tiny: pi_o_2+tiny;
+
+    /* compute y/x */
+	k = (iy-ix)>>23;
+	if(k > 60) z=pi_o_2+(float)0.5*pi_lo;	/* |y/x| >  2**60 */
+	else if(hx<0&&k<-60) z=0.0;	/* |y|/x < -2**60 */
+	else z=__atanf(fabsf(y/x));	/* safe to do y/x */
+	switch (m) {
+	    case 0: return       z  ;	/* atan(+,+) */
+	    case 1: {
+		      u_int32_t zh;
+		      GET_FLOAT_WORD(zh,z);
+		      SET_FLOAT_WORD(z,zh ^ 0x80000000);
+		    }
+		    return       z  ;	/* atan(-,+) */
+	    case 2: return  pi-(z-pi_lo);/* atan(+,-) */
+	    default: /* case 3 */
+		    return  (z-pi_lo)-pi;/* atan(-,-) */
+	}
+}
+strong_alias (__ieee754_atan2f, __atan2f_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_atanhf.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_atanhf.c
new file mode 100644
index 0000000000..feb6beeec7
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_atanhf.c
@@ -0,0 +1,74 @@
+/* Copyright (C) 2011-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@gmail.com>, 2011.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+
+/* __ieee754_atanh(x)
+   Method :
+      1.Reduced x to positive by atanh(-x) = -atanh(x)
+      2.For x>=0.5
+		    1              2x                          x
+	atanh(x) = --- * log(1 + -------) = 0.5 * log1p(2 * --------)
+		    2             1 - x                      1 - x
+
+	For x<0.5
+	atanh(x) = 0.5*log1p(2x+2x*x/(1-x))
+
+   Special cases:
+	atanh(x) is NaN if |x| > 1 with signal;
+	atanh(NaN) is that NaN with no signal;
+	atanh(+-1) is +-INF with signal.
+
+ */
+
+#include <float.h>
+#include <inttypes.h>
+#include <math.h>
+#include <math_private.h>
+
+static const float huge = 1e30;
+
+float
+__ieee754_atanhf (float x)
+{
+  float xa = fabsf (x);
+  float t;
+  if (isless (xa, 0.5f))
+    {
+      if (__glibc_unlikely (xa < 0x1.0p-28f))
+	{
+	  math_force_eval (huge + x);
+	  math_check_force_underflow (x);
+	  return x;
+	}
+
+      t = xa + xa;
+      t = 0.5f * __log1pf (t + t * xa / (1.0f - xa));
+    }
+  else if (__glibc_likely (isless (xa, 1.0f)))
+    t = 0.5f * __log1pf ((xa + xa) / (1.0f - xa));
+  else
+    {
+      if (isgreater (xa, 1.0f))
+	return (x - x) / (x - x);
+
+      return x / 0.0f;
+    }
+
+  return __copysignf (t, x);
+}
+strong_alias (__ieee754_atanhf, __atanhf_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_coshf.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_coshf.c
new file mode 100644
index 0000000000..7b223758e1
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_coshf.c
@@ -0,0 +1,63 @@
+/* e_coshf.c -- float version of e_cosh.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ * Optimizations by Ulrich Drepper <drepper@gmail.com>, 2011
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+static const float huge = 1.0e30;
+static const float one = 1.0, half=0.5;
+
+float
+__ieee754_coshf (float x)
+{
+	float t,w;
+	int32_t ix;
+
+	GET_FLOAT_WORD(ix,x);
+	ix &= 0x7fffffff;
+
+    /* |x| in [0,22] */
+	if (ix < 0x41b00000) {
+	    /* |x| in [0,0.5*ln2], return 1+expm1(|x|)^2/(2*exp(|x|)) */
+		if(ix<0x3eb17218) {
+		    if (ix<0x24000000) return one;	/* cosh(tiny) = 1 */
+		    t = __expm1f(fabsf(x));
+		    w = one+t;
+		    return one+(t*t)/(w+w);
+		}
+
+	    /* |x| in [0.5*ln2,22], return (exp(|x|)+1/exp(|x|)/2; */
+		t = __ieee754_expf(fabsf(x));
+		return half*t+half/t;
+	}
+
+    /* |x| in [22, log(maxdouble)] return half*exp(|x|) */
+	if (ix < 0x42b17180)  return half*__ieee754_expf(fabsf(x));
+
+    /* |x| in [log(maxdouble), overflowthresold] */
+	if (ix<=0x42b2d4fc) {
+	    w = __ieee754_expf(half*fabsf(x));
+	    t = half*w;
+	    return t*w;
+	}
+
+    /* x is INF or NaN */
+	if(ix>=0x7f800000) return x*x;
+
+    /* |x| > overflowthresold, cosh(x) overflow */
+	return math_narrow_eval (huge*huge);
+}
+strong_alias (__ieee754_coshf, __coshf_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_exp2f.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_exp2f.c
new file mode 100644
index 0000000000..567d3ff6d0
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_exp2f.c
@@ -0,0 +1,132 @@
+/* Single-precision floating point 2^x.
+   Copyright (C) 1997-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Geoffrey Keating <geoffk@ozemail.com.au>
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+/* The basic design here is from
+   Shmuel Gal and Boris Bachelis, "An Accurate Elementary Mathematical
+   Library for the IEEE Floating Point Standard", ACM Trans. Math. Soft.,
+   17 (1), March 1991, pp. 26-45.
+   It has been slightly modified to compute 2^x instead of e^x, and for
+   single-precision.
+   */
+#ifndef _GNU_SOURCE
+# define _GNU_SOURCE
+#endif
+#include <stdlib.h>
+#include <float.h>
+#include <ieee754.h>
+#include <math.h>
+#include <fenv.h>
+#include <inttypes.h>
+#include <math_private.h>
+
+#include "t_exp2f.h"
+
+static const float TWOM100 = 7.88860905e-31;
+static const float TWO127 = 1.7014118346e+38;
+
+float
+__ieee754_exp2f (float x)
+{
+  static const float himark = (float) FLT_MAX_EXP;
+  static const float lomark = (float) (FLT_MIN_EXP - FLT_MANT_DIG - 1);
+
+  /* Check for usual case.  */
+  if (isless (x, himark) && isgreaterequal (x, lomark))
+    {
+      static const float THREEp14 = 49152.0;
+      int tval, unsafe;
+      float rx, x22, result;
+      union ieee754_float ex2_u, scale_u;
+
+      if (fabsf (x) < FLT_EPSILON / 4.0f)
+	return 1.0f + x;
+
+      {
+	SET_RESTORE_ROUND_NOEXF (FE_TONEAREST);
+
+	/* 1. Argument reduction.
+	   Choose integers ex, -128 <= t < 128, and some real
+	   -1/512 <= x1 <= 1/512 so that
+	   x = ex + t/512 + x1.
+
+	   First, calculate rx = ex + t/256.  */
+	rx = x + THREEp14;
+	rx -= THREEp14;
+	x -= rx;  /* Compute x=x1. */
+	/* Compute tval = (ex*256 + t)+128.
+	   Now, t = (tval mod 256)-128 and ex=tval/256  [that's mod, NOT %;
+	   and /-round-to-nearest not the usual c integer /].  */
+	tval = (int) (rx * 256.0f + 128.0f);
+
+	/* 2. Adjust for accurate table entry.
+	   Find e so that
+	   x = ex + t/256 + e + x2
+	   where -7e-4 < e < 7e-4, and
+	   (float)(2^(t/256+e))
+	   is accurate to one part in 2^-64.  */
+
+	/* 'tval & 255' is the same as 'tval%256' except that it's always
+	   positive.
+	   Compute x = x2.  */
+	x -= __exp2f_deltatable[tval & 255];
+
+	/* 3. Compute ex2 = 2^(t/255+e+ex).  */
+	ex2_u.f = __exp2f_atable[tval & 255];
+	tval >>= 8;
+	/* x2 is an integer multiple of 2^-30; avoid intermediate
+	   underflow from the calculation of x22 * x.  */
+	unsafe = abs(tval) >= -FLT_MIN_EXP - 32;
+	ex2_u.ieee.exponent += tval >> unsafe;
+	scale_u.f = 1.0;
+	scale_u.ieee.exponent += tval - (tval >> unsafe);
+
+	/* 4. Approximate 2^x2 - 1, using a second-degree polynomial,
+	   with maximum error in [-2^-9 - 2^-14, 2^-9 + 2^-14]
+	   less than 1.3e-10.  */
+
+	x22 = (.24022656679f * x + .69314736128f) * ex2_u.f;
+      }
+
+      /* 5. Return (2^x2-1) * 2^(t/512+e+ex) + 2^(t/512+e+ex).  */
+      result = x22 * x + ex2_u.f;
+
+      if (!unsafe)
+	return result;
+      else
+	{
+	  result *= scale_u.f;
+	  math_check_force_underflow_nonneg (result);
+	  return result;
+	}
+    }
+  /* Exceptional cases:  */
+  else if (isless (x, himark))
+    {
+      if (isinf (x))
+	/* e^-inf == 0, with no error.  */
+	return 0;
+      else
+	/* Underflow */
+	return TWOM100 * TWOM100;
+    }
+  else
+    /* Return x, if x is a NaN or Inf; or overflow, otherwise.  */
+    return TWO127*x;
+}
+strong_alias (__ieee754_exp2f, __exp2f_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_expf.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_expf.c
new file mode 100644
index 0000000000..782072f213
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_expf.c
@@ -0,0 +1,133 @@
+/* Single-precision floating point e^x.
+   Copyright (C) 1997-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Geoffrey Keating <geoffk@ozemail.com.au>
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+/* How this works:
+
+   The input value, x, is written as
+
+   x = n * ln(2) + t/512 + delta[t] + x;
+
+   where:
+   - n is an integer, 127 >= n >= -150;
+   - t is an integer, 177 >= t >= -177
+   - delta is based on a table entry, delta[t] < 2^-28
+   - x is whatever is left, |x| < 2^-10
+
+   Then e^x is approximated as
+
+   e^x = 2^n ( e^(t/512 + delta[t])
+	       + ( e^(t/512 + delta[t])
+		   * ( p(x + delta[t] + n * ln(2)) - delta ) ) )
+
+   where
+   - p(x) is a polynomial approximating e(x)-1;
+   - e^(t/512 + delta[t]) is obtained from a table.
+
+   The table used is the same one as for the double precision version;
+   since we have the table, we might as well use it.
+
+   It turns out to be faster to do calculations in double precision than
+   to perform an 'accurate table method' expf, because of the range reduction
+   overhead (compare exp2f).
+   */
+#include <float.h>
+#include <ieee754.h>
+#include <math.h>
+#include <fenv.h>
+#include <inttypes.h>
+#include <math_private.h>
+
+extern const float __exp_deltatable[178];
+extern const double __exp_atable[355] /* __attribute__((mode(DF))) */;
+
+static const float TWOM100 = 7.88860905e-31;
+static const float TWO127 = 1.7014118346e+38;
+
+float
+__ieee754_expf (float x)
+{
+  static const float himark = 88.72283935546875;
+  static const float lomark = -103.972084045410;
+  /* Check for usual case.  */
+  if (isless (x, himark) && isgreater (x, lomark))
+    {
+      static const float THREEp42 = 13194139533312.0;
+      static const float THREEp22 = 12582912.0;
+      /* 1/ln(2).  */
+#undef M_1_LN2
+      static const float M_1_LN2 = 1.44269502163f;
+      /* ln(2) */
+#undef M_LN2
+      static const double M_LN2 = .6931471805599452862;
+
+      int tval;
+      double x22, t, result, dx;
+      float n, delta;
+      union ieee754_double ex2_u;
+
+      {
+	SET_RESTORE_ROUND_NOEXF (FE_TONEAREST);
+
+	/* Calculate n.  */
+	n = x * M_1_LN2 + THREEp22;
+	n -= THREEp22;
+	dx = x - n*M_LN2;
+
+	/* Calculate t/512.  */
+	t = dx + THREEp42;
+	t -= THREEp42;
+	dx -= t;
+
+	/* Compute tval = t.  */
+	tval = (int) (t * 512.0);
+
+	if (t >= 0)
+	  delta = - __exp_deltatable[tval];
+	else
+	  delta = __exp_deltatable[-tval];
+
+	/* Compute ex2 = 2^n e^(t/512+delta[t]).  */
+	ex2_u.d = __exp_atable[tval+177];
+	ex2_u.ieee.exponent += (int) n;
+
+	/* Approximate e^(dx+delta) - 1, using a second-degree polynomial,
+	   with maximum error in [-2^-10-2^-28,2^-10+2^-28]
+	   less than 5e-11.  */
+	x22 = (0.5000000496709180453 * dx + 1.0000001192102037084) * dx + delta;
+      }
+
+      /* Return result.  */
+      result = x22 * ex2_u.d + ex2_u.d;
+      return (float) result;
+    }
+  /* Exceptional cases:  */
+  else if (isless (x, himark))
+    {
+      if (isinf (x))
+	/* e^-inf == 0, with no error.  */
+	return 0;
+      else
+	/* Underflow */
+	return TWOM100 * TWOM100;
+    }
+  else
+    /* Return x, if x is a NaN or Inf; or overflow, otherwise.  */
+    return TWO127*x;
+}
+strong_alias (__ieee754_expf, __expf_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_fmodf.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_fmodf.c
new file mode 100644
index 0000000000..8d8fad4eb5
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_fmodf.c
@@ -0,0 +1,102 @@
+/* e_fmodf.c -- float version of e_fmod.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+/*
+ * __ieee754_fmodf(x,y)
+ * Return x mod y in exact arithmetic
+ * Method: shift and subtract
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+static const float one = 1.0, Zero[] = {0.0, -0.0,};
+
+float
+__ieee754_fmodf (float x, float y)
+{
+	int32_t n,hx,hy,hz,ix,iy,sx,i;
+
+	GET_FLOAT_WORD(hx,x);
+	GET_FLOAT_WORD(hy,y);
+	sx = hx&0x80000000;		/* sign of x */
+	hx ^=sx;		/* |x| */
+	hy &= 0x7fffffff;	/* |y| */
+
+    /* purge off exception values */
+	if(hy==0||(hx>=0x7f800000)||		/* y=0,or x not finite */
+	   (hy>0x7f800000))			/* or y is NaN */
+	    return (x*y)/(x*y);
+	if(hx<hy) return x;			/* |x|<|y| return x */
+	if(hx==hy)
+	    return Zero[(u_int32_t)sx>>31];	/* |x|=|y| return x*0*/
+
+    /* determine ix = ilogb(x) */
+	if(hx<0x00800000) {	/* subnormal x */
+	    for (ix = -126,i=(hx<<8); i>0; i<<=1) ix -=1;
+	} else ix = (hx>>23)-127;
+
+    /* determine iy = ilogb(y) */
+	if(hy<0x00800000) {	/* subnormal y */
+	    for (iy = -126,i=(hy<<8); i>=0; i<<=1) iy -=1;
+	} else iy = (hy>>23)-127;
+
+    /* set up {hx,lx}, {hy,ly} and align y to x */
+	if(ix >= -126)
+	    hx = 0x00800000|(0x007fffff&hx);
+	else {		/* subnormal x, shift x to normal */
+	    n = -126-ix;
+	    hx = hx<<n;
+	}
+	if(iy >= -126)
+	    hy = 0x00800000|(0x007fffff&hy);
+	else {		/* subnormal y, shift y to normal */
+	    n = -126-iy;
+	    hy = hy<<n;
+	}
+
+    /* fix point fmod */
+	n = ix - iy;
+	while(n--) {
+	    hz=hx-hy;
+	    if(hz<0){hx = hx+hx;}
+	    else {
+		if(hz==0)		/* return sign(x)*0 */
+		    return Zero[(u_int32_t)sx>>31];
+		hx = hz+hz;
+	    }
+	}
+	hz=hx-hy;
+	if(hz>=0) {hx=hz;}
+
+    /* convert back to floating value and restore the sign */
+	if(hx==0)			/* return sign(x)*0 */
+	    return Zero[(u_int32_t)sx>>31];
+	while(hx<0x00800000) {		/* normalize x */
+	    hx = hx+hx;
+	    iy -= 1;
+	}
+	if(iy>= -126) {		/* normalize output */
+	    hx = ((hx-0x00800000)|((iy+127)<<23));
+	    SET_FLOAT_WORD(x,hx|sx);
+	} else {		/* subnormal output */
+	    n = -126 - iy;
+	    hx >>= n;
+	    SET_FLOAT_WORD(x,hx|sx);
+	    x *= one;		/* create necessary signal */
+	}
+	return x;		/* exact output */
+}
+strong_alias (__ieee754_fmodf, __fmodf_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_gammaf_r.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_gammaf_r.c
new file mode 100644
index 0000000000..1157dec2fe
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_gammaf_r.c
@@ -0,0 +1,212 @@
+/* Implementation of gamma function according to ISO C.
+   Copyright (C) 1997-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math.h>
+#include <math_private.h>
+#include <float.h>
+
+/* Coefficients B_2k / 2k(2k-1) of x^-(2k-1) inside exp in Stirling's
+   approximation to gamma function.  */
+
+static const float gamma_coeff[] =
+  {
+    0x1.555556p-4f,
+    -0xb.60b61p-12f,
+    0x3.403404p-12f,
+  };
+
+#define NCOEFF (sizeof (gamma_coeff) / sizeof (gamma_coeff[0]))
+
+/* Return gamma (X), for positive X less than 42, in the form R *
+   2^(*EXP2_ADJ), where R is the return value and *EXP2_ADJ is set to
+   avoid overflow or underflow in intermediate calculations.  */
+
+static float
+gammaf_positive (float x, int *exp2_adj)
+{
+  int local_signgam;
+  if (x < 0.5f)
+    {
+      *exp2_adj = 0;
+      return __ieee754_expf (__ieee754_lgammaf_r (x + 1, &local_signgam)) / x;
+    }
+  else if (x <= 1.5f)
+    {
+      *exp2_adj = 0;
+      return __ieee754_expf (__ieee754_lgammaf_r (x, &local_signgam));
+    }
+  else if (x < 2.5f)
+    {
+      *exp2_adj = 0;
+      float x_adj = x - 1;
+      return (__ieee754_expf (__ieee754_lgammaf_r (x_adj, &local_signgam))
+	      * x_adj);
+    }
+  else
+    {
+      float eps = 0;
+      float x_eps = 0;
+      float x_adj = x;
+      float prod = 1;
+      if (x < 4.0f)
+	{
+	  /* Adjust into the range for applying Stirling's
+	     approximation.  */
+	  float n = __ceilf (4.0f - x);
+	  x_adj = math_narrow_eval (x + n);
+	  x_eps = (x - (x_adj - n));
+	  prod = __gamma_productf (x_adj - n, x_eps, n, &eps);
+	}
+      /* The result is now gamma (X_ADJ + X_EPS) / (PROD * (1 + EPS)).
+	 Compute gamma (X_ADJ + X_EPS) using Stirling's approximation,
+	 starting by computing pow (X_ADJ, X_ADJ) with a power of 2
+	 factored out.  */
+      float exp_adj = -eps;
+      float x_adj_int = __roundf (x_adj);
+      float x_adj_frac = x_adj - x_adj_int;
+      int x_adj_log2;
+      float x_adj_mant = __frexpf (x_adj, &x_adj_log2);
+      if (x_adj_mant < (float) M_SQRT1_2)
+	{
+	  x_adj_log2--;
+	  x_adj_mant *= 2.0f;
+	}
+      *exp2_adj = x_adj_log2 * (int) x_adj_int;
+      float ret = (__ieee754_powf (x_adj_mant, x_adj)
+		   * __ieee754_exp2f (x_adj_log2 * x_adj_frac)
+		   * __ieee754_expf (-x_adj)
+		   * __ieee754_sqrtf (2 * (float) M_PI / x_adj)
+		   / prod);
+      exp_adj += x_eps * __ieee754_logf (x_adj);
+      float bsum = gamma_coeff[NCOEFF - 1];
+      float x_adj2 = x_adj * x_adj;
+      for (size_t i = 1; i <= NCOEFF - 1; i++)
+	bsum = bsum / x_adj2 + gamma_coeff[NCOEFF - 1 - i];
+      exp_adj += bsum / x_adj;
+      return ret + ret * __expm1f (exp_adj);
+    }
+}
+
+float
+__ieee754_gammaf_r (float x, int *signgamp)
+{
+  int32_t hx;
+  float ret;
+
+  GET_FLOAT_WORD (hx, x);
+
+  if (__glibc_unlikely ((hx & 0x7fffffff) == 0))
+    {
+      /* Return value for x == 0 is Inf with divide by zero exception.  */
+      *signgamp = 0;
+      return 1.0 / x;
+    }
+  if (__builtin_expect (hx < 0, 0)
+      && (u_int32_t) hx < 0xff800000 && __rintf (x) == x)
+    {
+      /* Return value for integer x < 0 is NaN with invalid exception.  */
+      *signgamp = 0;
+      return (x - x) / (x - x);
+    }
+  if (__glibc_unlikely (hx == 0xff800000))
+    {
+      /* x == -Inf.  According to ISO this is NaN.  */
+      *signgamp = 0;
+      return x - x;
+    }
+  if (__glibc_unlikely ((hx & 0x7f800000) == 0x7f800000))
+    {
+      /* Positive infinity (return positive infinity) or NaN (return
+	 NaN).  */
+      *signgamp = 0;
+      return x + x;
+    }
+
+  if (x >= 36.0f)
+    {
+      /* Overflow.  */
+      *signgamp = 0;
+      ret = math_narrow_eval (FLT_MAX * FLT_MAX);
+      return ret;
+    }
+  else
+    {
+      SET_RESTORE_ROUNDF (FE_TONEAREST);
+      if (x > 0.0f)
+	{
+	  *signgamp = 0;
+	  int exp2_adj;
+	  float tret = gammaf_positive (x, &exp2_adj);
+	  ret = __scalbnf (tret, exp2_adj);
+	}
+      else if (x >= -FLT_EPSILON / 4.0f)
+	{
+	  *signgamp = 0;
+	  ret = 1.0f / x;
+	}
+      else
+	{
+	  float tx = __truncf (x);
+	  *signgamp = (tx == 2.0f * __truncf (tx / 2.0f)) ? -1 : 1;
+	  if (x <= -42.0f)
+	    /* Underflow.  */
+	    ret = FLT_MIN * FLT_MIN;
+	  else
+	    {
+	      float frac = tx - x;
+	      if (frac > 0.5f)
+		frac = 1.0f - frac;
+	      float sinpix = (frac <= 0.25f
+			      ? __sinf ((float) M_PI * frac)
+			      : __cosf ((float) M_PI * (0.5f - frac)));
+	      int exp2_adj;
+	      float tret = (float) M_PI / (-x * sinpix
+					   * gammaf_positive (-x, &exp2_adj));
+	      ret = __scalbnf (tret, -exp2_adj);
+	      math_check_force_underflow_nonneg (ret);
+	    }
+	}
+      ret = math_narrow_eval (ret);
+    }
+  if (isinf (ret) && x != 0)
+    {
+      if (*signgamp < 0)
+	{
+	  ret = math_narrow_eval (-__copysignf (FLT_MAX, ret) * FLT_MAX);
+	  ret = -ret;
+	}
+      else
+	ret = math_narrow_eval (__copysignf (FLT_MAX, ret) * FLT_MAX);
+      return ret;
+    }
+  else if (ret == 0)
+    {
+      if (*signgamp < 0)
+	{
+	  ret = math_narrow_eval (-__copysignf (FLT_MIN, ret) * FLT_MIN);
+	  ret = -ret;
+	}
+      else
+	ret = math_narrow_eval (__copysignf (FLT_MIN, ret) * FLT_MIN);
+      return ret;
+    }
+  else
+    return ret;
+}
+strong_alias (__ieee754_gammaf_r, __gammaf_r_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_hypotf.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_hypotf.c
new file mode 100644
index 0000000000..fda2651a84
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_hypotf.c
@@ -0,0 +1,45 @@
+/* e_hypotf.c -- float version of e_hypot.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+float
+__ieee754_hypotf(float x, float y)
+{
+	double d_x, d_y;
+	int32_t ha, hb;
+
+	GET_FLOAT_WORD(ha,x);
+	ha &= 0x7fffffff;
+	GET_FLOAT_WORD(hb,y);
+	hb &= 0x7fffffff;
+	if (ha == 0x7f800000 && !issignaling (y))
+	  return fabsf(x);
+	else if (hb == 0x7f800000 && !issignaling (x))
+	  return fabsf(y);
+	else if (ha > 0x7f800000 || hb > 0x7f800000)
+	  return fabsf(x) * fabsf(y);
+	else if (ha == 0)
+	  return fabsf(y);
+	else if (hb == 0)
+	  return fabsf(x);
+
+	d_x = (double) x;
+	d_y = (double) y;
+
+	return (float) __ieee754_sqrt(d_x * d_x + d_y * d_y);
+}
+strong_alias (__ieee754_hypotf, __hypotf_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_ilogbf.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_ilogbf.c
new file mode 100644
index 0000000000..1ae344ea39
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_ilogbf.c
@@ -0,0 +1,44 @@
+/* s_ilogbf.c -- float version of s_ilogb.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: s_ilogbf.c,v 1.4 1995/05/10 20:47:31 jtc Exp $";
+#endif
+
+#include <limits.h>
+#include <math.h>
+#include <math_private.h>
+
+int __ieee754_ilogbf(float x)
+{
+	int32_t hx,ix;
+
+	GET_FLOAT_WORD(hx,x);
+	hx &= 0x7fffffff;
+	if(hx<0x00800000) {
+	    if(hx==0)
+		return FP_ILOGB0;	/* ilogb(0) = FP_ILOGB0 */
+	    else			/* subnormal x */
+	        for (ix = -126,hx<<=8; hx>0; hx<<=1) ix -=1;
+	    return ix;
+	}
+	else if (hx<0x7f800000) return (hx>>23)-127;
+	else if (FP_ILOGBNAN != INT_MAX) {
+	    /* ISO C99 requires ilogbf(+-Inf) == INT_MAX.  */
+	    if (hx==0x7f800000)
+		return INT_MAX;
+	}
+	return FP_ILOGBNAN;
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_j0f.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_j0f.c
new file mode 100644
index 0000000000..b783dd069d
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_j0f.c
@@ -0,0 +1,337 @@
+/* e_j0f.c -- float version of e_j0.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+static float pzerof(float), qzerof(float);
+
+static const float
+huge	= 1e30,
+one	= 1.0,
+invsqrtpi=  5.6418961287e-01, /* 0x3f106ebb */
+tpi      =  6.3661974669e-01, /* 0x3f22f983 */
+		/* R0/S0 on [0, 2.00] */
+R02  =  1.5625000000e-02, /* 0x3c800000 */
+R03  = -1.8997929874e-04, /* 0xb947352e */
+R04  =  1.8295404516e-06, /* 0x35f58e88 */
+R05  = -4.6183270541e-09, /* 0xb19eaf3c */
+S01  =  1.5619102865e-02, /* 0x3c7fe744 */
+S02  =  1.1692678527e-04, /* 0x38f53697 */
+S03  =  5.1354652442e-07, /* 0x3509daa6 */
+S04  =  1.1661400734e-09; /* 0x30a045e8 */
+
+static const float zero = 0.0;
+
+float
+__ieee754_j0f(float x)
+{
+	float z, s,c,ss,cc,r,u,v;
+	int32_t hx,ix;
+
+	GET_FLOAT_WORD(hx,x);
+	ix = hx&0x7fffffff;
+	if(ix>=0x7f800000) return one/(x*x);
+	x = fabsf(x);
+	if(ix >= 0x40000000) {	/* |x| >= 2.0 */
+		__sincosf (x, &s, &c);
+		ss = s-c;
+		cc = s+c;
+		if(ix<0x7f000000) {  /* make sure x+x not overflow */
+		    z = -__cosf(x+x);
+		    if ((s*c)<zero) cc = z/ss;
+		    else	    ss = z/cc;
+		}
+	/*
+	 * j0(x) = 1/sqrt(pi) * (P(0,x)*cc - Q(0,x)*ss) / sqrt(x)
+	 * y0(x) = 1/sqrt(pi) * (P(0,x)*ss + Q(0,x)*cc) / sqrt(x)
+	 */
+		if(ix>0x48000000) z = (invsqrtpi*cc)/__ieee754_sqrtf(x);
+		else {
+		    u = pzerof(x); v = qzerof(x);
+		    z = invsqrtpi*(u*cc-v*ss)/__ieee754_sqrtf(x);
+		}
+		return z;
+	}
+	if(ix<0x39000000) {	/* |x| < 2**-13 */
+	    math_force_eval(huge+x);		/* raise inexact if x != 0 */
+	    if(ix<0x32000000) return one;	/* |x|<2**-27 */
+	    else	      return one - (float)0.25*x*x;
+	}
+	z = x*x;
+	r =  z*(R02+z*(R03+z*(R04+z*R05)));
+	s =  one+z*(S01+z*(S02+z*(S03+z*S04)));
+	if(ix < 0x3F800000) {	/* |x| < 1.00 */
+	    return one + z*((float)-0.25+(r/s));
+	} else {
+	    u = (float)0.5*x;
+	    return((one+u)*(one-u)+z*(r/s));
+	}
+}
+strong_alias (__ieee754_j0f, __j0f_finite)
+
+static const float
+u00  = -7.3804296553e-02, /* 0xbd9726b5 */
+u01  =  1.7666645348e-01, /* 0x3e34e80d */
+u02  = -1.3818567619e-02, /* 0xbc626746 */
+u03  =  3.4745343146e-04, /* 0x39b62a69 */
+u04  = -3.8140706238e-06, /* 0xb67ff53c */
+u05  =  1.9559013964e-08, /* 0x32a802ba */
+u06  = -3.9820518410e-11, /* 0xae2f21eb */
+v01  =  1.2730483897e-02, /* 0x3c509385 */
+v02  =  7.6006865129e-05, /* 0x389f65e0 */
+v03  =  2.5915085189e-07, /* 0x348b216c */
+v04  =  4.4111031494e-10; /* 0x2ff280c2 */
+
+float
+__ieee754_y0f(float x)
+{
+	float z, s,c,ss,cc,u,v;
+	int32_t hx,ix;
+
+	GET_FLOAT_WORD(hx,x);
+	ix = 0x7fffffff&hx;
+    /* Y0(NaN) is NaN, y0(-inf) is Nan, y0(inf) is 0, y0(0) is -inf.  */
+	if(ix>=0x7f800000) return  one/(x+x*x);
+	if(ix==0) return -1/zero; /* -inf and divide by zero exception.  */
+	if(hx<0) return zero/(zero*x);
+	if(ix >= 0x40000000) {  /* |x| >= 2.0 */
+	/* y0(x) = sqrt(2/(pi*x))*(p0(x)*sin(x0)+q0(x)*cos(x0))
+	 * where x0 = x-pi/4
+	 *      Better formula:
+	 *              cos(x0) = cos(x)cos(pi/4)+sin(x)sin(pi/4)
+	 *                      =  1/sqrt(2) * (sin(x) + cos(x))
+	 *              sin(x0) = sin(x)cos(3pi/4)-cos(x)sin(3pi/4)
+	 *                      =  1/sqrt(2) * (sin(x) - cos(x))
+	 * To avoid cancellation, use
+	 *              sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x))
+	 * to compute the worse one.
+	 */
+		__sincosf (x, &s, &c);
+		ss = s-c;
+		cc = s+c;
+	/*
+	 * j0(x) = 1/sqrt(pi) * (P(0,x)*cc - Q(0,x)*ss) / sqrt(x)
+	 * y0(x) = 1/sqrt(pi) * (P(0,x)*ss + Q(0,x)*cc) / sqrt(x)
+	 */
+		if(ix<0x7f000000) {  /* make sure x+x not overflow */
+		    z = -__cosf(x+x);
+		    if ((s*c)<zero) cc = z/ss;
+		    else            ss = z/cc;
+		}
+		if(ix>0x48000000) z = (invsqrtpi*ss)/__ieee754_sqrtf(x);
+		else {
+		    u = pzerof(x); v = qzerof(x);
+		    z = invsqrtpi*(u*ss+v*cc)/__ieee754_sqrtf(x);
+		}
+		return z;
+	}
+	if(ix<=0x39800000) {	/* x < 2**-13 */
+	    return(u00 + tpi*__ieee754_logf(x));
+	}
+	z = x*x;
+	u = u00+z*(u01+z*(u02+z*(u03+z*(u04+z*(u05+z*u06)))));
+	v = one+z*(v01+z*(v02+z*(v03+z*v04)));
+	return(u/v + tpi*(__ieee754_j0f(x)*__ieee754_logf(x)));
+}
+strong_alias (__ieee754_y0f, __y0f_finite)
+
+/* The asymptotic expansions of pzero is
+ *	1 - 9/128 s^2 + 11025/98304 s^4 - ...,	where s = 1/x.
+ * For x >= 2, We approximate pzero by
+ *	pzero(x) = 1 + (R/S)
+ * where  R = pR0 + pR1*s^2 + pR2*s^4 + ... + pR5*s^10
+ *	  S = 1 + pS0*s^2 + ... + pS4*s^10
+ * and
+ *	| pzero(x)-1-R/S | <= 2  ** ( -60.26)
+ */
+static const float pR8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
+  0.0000000000e+00, /* 0x00000000 */
+ -7.0312500000e-02, /* 0xbd900000 */
+ -8.0816707611e+00, /* 0xc1014e86 */
+ -2.5706311035e+02, /* 0xc3808814 */
+ -2.4852163086e+03, /* 0xc51b5376 */
+ -5.2530439453e+03, /* 0xc5a4285a */
+};
+static const float pS8[5] = {
+  1.1653436279e+02, /* 0x42e91198 */
+  3.8337448730e+03, /* 0x456f9beb */
+  4.0597855469e+04, /* 0x471e95db */
+  1.1675296875e+05, /* 0x47e4087c */
+  4.7627726562e+04, /* 0x473a0bba */
+};
+static const float pR5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
+ -1.1412546255e-11, /* 0xad48c58a */
+ -7.0312492549e-02, /* 0xbd8fffff */
+ -4.1596107483e+00, /* 0xc0851b88 */
+ -6.7674766541e+01, /* 0xc287597b */
+ -3.3123129272e+02, /* 0xc3a59d9b */
+ -3.4643338013e+02, /* 0xc3ad3779 */
+};
+static const float pS5[5] = {
+  6.0753936768e+01, /* 0x42730408 */
+  1.0512523193e+03, /* 0x44836813 */
+  5.9789707031e+03, /* 0x45bad7c4 */
+  9.6254453125e+03, /* 0x461665c8 */
+  2.4060581055e+03, /* 0x451660ee */
+};
+
+static const float pR3[6] = {/* for x in [4.547,2.8571]=1/[0.2199,0.35001] */
+ -2.5470459075e-09, /* 0xb12f081b */
+ -7.0311963558e-02, /* 0xbd8fffb8 */
+ -2.4090321064e+00, /* 0xc01a2d95 */
+ -2.1965976715e+01, /* 0xc1afba52 */
+ -5.8079170227e+01, /* 0xc2685112 */
+ -3.1447946548e+01, /* 0xc1fb9565 */
+};
+static const float pS3[5] = {
+  3.5856033325e+01, /* 0x420f6c94 */
+  3.6151397705e+02, /* 0x43b4c1ca */
+  1.1936077881e+03, /* 0x44953373 */
+  1.1279968262e+03, /* 0x448cffe6 */
+  1.7358093262e+02, /* 0x432d94b8 */
+};
+
+static const float pR2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
+ -8.8753431271e-08, /* 0xb3be98b7 */
+ -7.0303097367e-02, /* 0xbd8ffb12 */
+ -1.4507384300e+00, /* 0xbfb9b1cc */
+ -7.6356959343e+00, /* 0xc0f4579f */
+ -1.1193166733e+01, /* 0xc1331736 */
+ -3.2336456776e+00, /* 0xc04ef40d */
+};
+static const float pS2[5] = {
+  2.2220300674e+01, /* 0x41b1c32d */
+  1.3620678711e+02, /* 0x430834f0 */
+  2.7047027588e+02, /* 0x43873c32 */
+  1.5387539673e+02, /* 0x4319e01a */
+  1.4657617569e+01, /* 0x416a859a */
+};
+
+static float
+pzerof(float x)
+{
+	const float *p,*q;
+	float z,r,s;
+	int32_t ix;
+	GET_FLOAT_WORD(ix,x);
+	ix &= 0x7fffffff;
+	/* ix >= 0x40000000 for all calls to this function.  */
+	if(ix>=0x41000000)     {p = pR8; q= pS8;}
+	else if(ix>=0x40f71c58){p = pR5; q= pS5;}
+	else if(ix>=0x4036db68){p = pR3; q= pS3;}
+	else {p = pR2; q= pS2;}
+	z = one/(x*x);
+	r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
+	s = one+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*q[4]))));
+	return one+ r/s;
+}
+
+
+/* For x >= 8, the asymptotic expansions of qzero is
+ *	-1/8 s + 75/1024 s^3 - ..., where s = 1/x.
+ * We approximate pzero by
+ *	qzero(x) = s*(-1.25 + (R/S))
+ * where  R = qR0 + qR1*s^2 + qR2*s^4 + ... + qR5*s^10
+ *	  S = 1 + qS0*s^2 + ... + qS5*s^12
+ * and
+ *	| qzero(x)/s +1.25-R/S | <= 2  ** ( -61.22)
+ */
+static const float qR8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
+  0.0000000000e+00, /* 0x00000000 */
+  7.3242187500e-02, /* 0x3d960000 */
+  1.1768206596e+01, /* 0x413c4a93 */
+  5.5767340088e+02, /* 0x440b6b19 */
+  8.8591972656e+03, /* 0x460a6cca */
+  3.7014625000e+04, /* 0x471096a0 */
+};
+static const float qS8[6] = {
+  1.6377603149e+02, /* 0x4323c6aa */
+  8.0983447266e+03, /* 0x45fd12c2 */
+  1.4253829688e+05, /* 0x480b3293 */
+  8.0330925000e+05, /* 0x49441ed4 */
+  8.4050156250e+05, /* 0x494d3359 */
+ -3.4389928125e+05, /* 0xc8a7eb69 */
+};
+
+static const float qR5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
+  1.8408595828e-11, /* 0x2da1ec79 */
+  7.3242180049e-02, /* 0x3d95ffff */
+  5.8356351852e+00, /* 0x40babd86 */
+  1.3511157227e+02, /* 0x43071c90 */
+  1.0272437744e+03, /* 0x448067cd */
+  1.9899779053e+03, /* 0x44f8bf4b */
+};
+static const float qS5[6] = {
+  8.2776611328e+01, /* 0x42a58da0 */
+  2.0778142090e+03, /* 0x4501dd07 */
+  1.8847289062e+04, /* 0x46933e94 */
+  5.6751113281e+04, /* 0x475daf1d */
+  3.5976753906e+04, /* 0x470c88c1 */
+ -5.3543427734e+03, /* 0xc5a752be */
+};
+
+static const float qR3[6] = {/* for x in [4.547,2.8571]=1/[0.2199,0.35001] */
+  4.3774099900e-09, /* 0x3196681b */
+  7.3241114616e-02, /* 0x3d95ff70 */
+  3.3442313671e+00, /* 0x405607e3 */
+  4.2621845245e+01, /* 0x422a7cc5 */
+  1.7080809021e+02, /* 0x432acedf */
+  1.6673394775e+02, /* 0x4326bbe4 */
+};
+static const float qS3[6] = {
+  4.8758872986e+01, /* 0x42430916 */
+  7.0968920898e+02, /* 0x44316c1c */
+  3.7041481934e+03, /* 0x4567825f */
+  6.4604252930e+03, /* 0x45c9e367 */
+  2.5163337402e+03, /* 0x451d4557 */
+ -1.4924745178e+02, /* 0xc3153f59 */
+};
+
+static const float qR2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
+  1.5044444979e-07, /* 0x342189db */
+  7.3223426938e-02, /* 0x3d95f62a */
+  1.9981917143e+00, /* 0x3fffc4bf */
+  1.4495602608e+01, /* 0x4167edfd */
+  3.1666231155e+01, /* 0x41fd5471 */
+  1.6252708435e+01, /* 0x4182058c */
+};
+static const float qS2[6] = {
+  3.0365585327e+01, /* 0x41f2ecb8 */
+  2.6934811401e+02, /* 0x4386ac8f */
+  8.4478375244e+02, /* 0x44533229 */
+  8.8293585205e+02, /* 0x445cbbe5 */
+  2.1266638184e+02, /* 0x4354aa98 */
+ -5.3109550476e+00, /* 0xc0a9f358 */
+};
+
+static float
+qzerof(float x)
+{
+	const float *p,*q;
+	float s,r,z;
+	int32_t ix;
+	GET_FLOAT_WORD(ix,x);
+	ix &= 0x7fffffff;
+	/* ix >= 0x40000000 for all calls to this function.  */
+	if(ix>=0x41000000)     {p = qR8; q= qS8;}
+	else if(ix>=0x40f71c58){p = qR5; q= qS5;}
+	else if(ix>=0x4036db68){p = qR3; q= qS3;}
+	else {p = qR2; q= qS2;}
+	z = one/(x*x);
+	r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
+	s = one+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*(q[4]+z*q[5])))));
+	return (-(float).125 + r/s)/x;
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_j1f.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_j1f.c
new file mode 100644
index 0000000000..805a87d85b
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_j1f.c
@@ -0,0 +1,347 @@
+/* e_j1f.c -- float version of e_j1.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <errno.h>
+#include <float.h>
+#include <math.h>
+#include <math_private.h>
+
+static float ponef(float), qonef(float);
+
+static const float
+huge    = 1e30,
+one	= 1.0,
+invsqrtpi=  5.6418961287e-01, /* 0x3f106ebb */
+tpi      =  6.3661974669e-01, /* 0x3f22f983 */
+	/* R0/S0 on [0,2] */
+r00  = -6.2500000000e-02, /* 0xbd800000 */
+r01  =  1.4070566976e-03, /* 0x3ab86cfd */
+r02  = -1.5995563444e-05, /* 0xb7862e36 */
+r03  =  4.9672799207e-08, /* 0x335557d2 */
+s01  =  1.9153760746e-02, /* 0x3c9ce859 */
+s02  =  1.8594678841e-04, /* 0x3942fab6 */
+s03  =  1.1771846857e-06, /* 0x359dffc2 */
+s04  =  5.0463624390e-09, /* 0x31ad6446 */
+s05  =  1.2354227016e-11; /* 0x2d59567e */
+
+static const float zero    = 0.0;
+
+float
+__ieee754_j1f(float x)
+{
+	float z, s,c,ss,cc,r,u,v,y;
+	int32_t hx,ix;
+
+	GET_FLOAT_WORD(hx,x);
+	ix = hx&0x7fffffff;
+	if(__builtin_expect(ix>=0x7f800000, 0)) return one/x;
+	y = fabsf(x);
+	if(ix >= 0x40000000) {	/* |x| >= 2.0 */
+		__sincosf (y, &s, &c);
+		ss = -s-c;
+		cc = s-c;
+		if(ix<0x7f000000) {  /* make sure y+y not overflow */
+		    z = __cosf(y+y);
+		    if ((s*c)>zero) cc = z/ss;
+		    else	    ss = z/cc;
+		}
+	/*
+	 * j1(x) = 1/sqrt(pi) * (P(1,x)*cc - Q(1,x)*ss) / sqrt(x)
+	 * y1(x) = 1/sqrt(pi) * (P(1,x)*ss + Q(1,x)*cc) / sqrt(x)
+	 */
+		if(ix>0x48000000) z = (invsqrtpi*cc)/__ieee754_sqrtf(y);
+		else {
+		    u = ponef(y); v = qonef(y);
+		    z = invsqrtpi*(u*cc-v*ss)/__ieee754_sqrtf(y);
+		}
+		if(hx<0) return -z;
+		else	 return  z;
+	}
+	if(__builtin_expect(ix<0x32000000, 0)) {	/* |x|<2**-27 */
+	    if(huge+x>one) {		/* inexact if x!=0 necessary */
+		float ret = math_narrow_eval ((float) 0.5 * x);
+		math_check_force_underflow (ret);
+		if (ret == 0 && x != 0)
+		  __set_errno (ERANGE);
+		return ret;
+	    }
+	}
+	z = x*x;
+	r =  z*(r00+z*(r01+z*(r02+z*r03)));
+	s =  one+z*(s01+z*(s02+z*(s03+z*(s04+z*s05))));
+	r *= x;
+	return(x*(float)0.5+r/s);
+}
+strong_alias (__ieee754_j1f, __j1f_finite)
+
+static const float U0[5] = {
+ -1.9605709612e-01, /* 0xbe48c331 */
+  5.0443872809e-02, /* 0x3d4e9e3c */
+ -1.9125689287e-03, /* 0xbafaaf2a */
+  2.3525259166e-05, /* 0x37c5581c */
+ -9.1909917899e-08, /* 0xb3c56003 */
+};
+static const float V0[5] = {
+  1.9916731864e-02, /* 0x3ca3286a */
+  2.0255257550e-04, /* 0x3954644b */
+  1.3560879779e-06, /* 0x35b602d4 */
+  6.2274145840e-09, /* 0x31d5f8eb */
+  1.6655924903e-11, /* 0x2d9281cf */
+};
+
+float
+__ieee754_y1f(float x)
+{
+	float z, s,c,ss,cc,u,v;
+	int32_t hx,ix;
+
+	GET_FLOAT_WORD(hx,x);
+	ix = 0x7fffffff&hx;
+    /* if Y1(NaN) is NaN, Y1(-inf) is NaN, Y1(inf) is 0 */
+	if(__builtin_expect(ix>=0x7f800000, 0)) return  one/(x+x*x);
+	if(__builtin_expect(ix==0, 0))
+		return -1/zero; /* -inf and divide by zero exception.  */
+	if(__builtin_expect(hx<0, 0)) return zero/(zero*x);
+	if(ix >= 0x40000000) {  /* |x| >= 2.0 */
+		SET_RESTORE_ROUNDF (FE_TONEAREST);
+		__sincosf (x, &s, &c);
+		ss = -s-c;
+		cc = s-c;
+		if(ix<0x7f000000) {  /* make sure x+x not overflow */
+		    z = __cosf(x+x);
+		    if ((s*c)>zero) cc = z/ss;
+		    else            ss = z/cc;
+		}
+	/* y1(x) = sqrt(2/(pi*x))*(p1(x)*sin(x0)+q1(x)*cos(x0))
+	 * where x0 = x-3pi/4
+	 *      Better formula:
+	 *              cos(x0) = cos(x)cos(3pi/4)+sin(x)sin(3pi/4)
+	 *                      =  1/sqrt(2) * (sin(x) - cos(x))
+	 *              sin(x0) = sin(x)cos(3pi/4)-cos(x)sin(3pi/4)
+	 *                      = -1/sqrt(2) * (cos(x) + sin(x))
+	 * To avoid cancellation, use
+	 *              sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x))
+	 * to compute the worse one.
+	 */
+		if(ix>0x48000000) z = (invsqrtpi*ss)/__ieee754_sqrtf(x);
+		else {
+		    u = ponef(x); v = qonef(x);
+		    z = invsqrtpi*(u*ss+v*cc)/__ieee754_sqrtf(x);
+		}
+		return z;
+	}
+	if(__builtin_expect(ix<=0x33000000, 0)) {    /* x < 2**-25 */
+	    z = -tpi / x;
+	    if (isinf (z))
+		__set_errno (ERANGE);
+	    return z;
+	}
+	z = x*x;
+	u = U0[0]+z*(U0[1]+z*(U0[2]+z*(U0[3]+z*U0[4])));
+	v = one+z*(V0[0]+z*(V0[1]+z*(V0[2]+z*(V0[3]+z*V0[4]))));
+	return(x*(u/v) + tpi*(__ieee754_j1f(x)*__ieee754_logf(x)-one/x));
+}
+strong_alias (__ieee754_y1f, __y1f_finite)
+
+/* For x >= 8, the asymptotic expansions of pone is
+ *	1 + 15/128 s^2 - 4725/2^15 s^4 - ...,	where s = 1/x.
+ * We approximate pone by
+ *	pone(x) = 1 + (R/S)
+ * where  R = pr0 + pr1*s^2 + pr2*s^4 + ... + pr5*s^10
+ *	  S = 1 + ps0*s^2 + ... + ps4*s^10
+ * and
+ *	| pone(x)-1-R/S | <= 2  ** ( -60.06)
+ */
+
+static const float pr8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
+  0.0000000000e+00, /* 0x00000000 */
+  1.1718750000e-01, /* 0x3df00000 */
+  1.3239480972e+01, /* 0x4153d4ea */
+  4.1205184937e+02, /* 0x43ce06a3 */
+  3.8747453613e+03, /* 0x45722bed */
+  7.9144794922e+03, /* 0x45f753d6 */
+};
+static const float ps8[5] = {
+  1.1420736694e+02, /* 0x42e46a2c */
+  3.6509309082e+03, /* 0x45642ee5 */
+  3.6956207031e+04, /* 0x47105c35 */
+  9.7602796875e+04, /* 0x47bea166 */
+  3.0804271484e+04, /* 0x46f0a88b */
+};
+
+static const float pr5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
+  1.3199052094e-11, /* 0x2d68333f */
+  1.1718749255e-01, /* 0x3defffff */
+  6.8027510643e+00, /* 0x40d9b023 */
+  1.0830818176e+02, /* 0x42d89dca */
+  5.1763616943e+02, /* 0x440168b7 */
+  5.2871520996e+02, /* 0x44042dc6 */
+};
+static const float ps5[5] = {
+  5.9280597687e+01, /* 0x426d1f55 */
+  9.9140142822e+02, /* 0x4477d9b1 */
+  5.3532670898e+03, /* 0x45a74a23 */
+  7.8446904297e+03, /* 0x45f52586 */
+  1.5040468750e+03, /* 0x44bc0180 */
+};
+
+static const float pr3[6] = {
+  3.0250391081e-09, /* 0x314fe10d */
+  1.1718686670e-01, /* 0x3defffab */
+  3.9329774380e+00, /* 0x407bb5e7 */
+  3.5119403839e+01, /* 0x420c7a45 */
+  9.1055007935e+01, /* 0x42b61c2a */
+  4.8559066772e+01, /* 0x42423c7c */
+};
+static const float ps3[5] = {
+  3.4791309357e+01, /* 0x420b2a4d */
+  3.3676245117e+02, /* 0x43a86198 */
+  1.0468714600e+03, /* 0x4482dbe3 */
+  8.9081134033e+02, /* 0x445eb3ed */
+  1.0378793335e+02, /* 0x42cf936c */
+};
+
+static const float pr2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
+  1.0771083225e-07, /* 0x33e74ea8 */
+  1.1717621982e-01, /* 0x3deffa16 */
+  2.3685150146e+00, /* 0x401795c0 */
+  1.2242610931e+01, /* 0x4143e1bc */
+  1.7693971634e+01, /* 0x418d8d41 */
+  5.0735230446e+00, /* 0x40a25a4d */
+};
+static const float ps2[5] = {
+  2.1436485291e+01, /* 0x41ab7dec */
+  1.2529022980e+02, /* 0x42fa9499 */
+  2.3227647400e+02, /* 0x436846c7 */
+  1.1767937469e+02, /* 0x42eb5bd7 */
+  8.3646392822e+00, /* 0x4105d590 */
+};
+
+static float
+ponef(float x)
+{
+	const float *p,*q;
+	float z,r,s;
+	int32_t ix;
+	GET_FLOAT_WORD(ix,x);
+	ix &= 0x7fffffff;
+	/* ix >= 0x40000000 for all calls to this function.  */
+	if(ix>=0x41000000)     {p = pr8; q= ps8;}
+	else if(ix>=0x40f71c58){p = pr5; q= ps5;}
+	else if(ix>=0x4036db68){p = pr3; q= ps3;}
+	else {p = pr2; q= ps2;}
+	z = one/(x*x);
+	r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
+	s = one+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*q[4]))));
+	return one+ r/s;
+}
+
+
+/* For x >= 8, the asymptotic expansions of qone is
+ *	3/8 s - 105/1024 s^3 - ..., where s = 1/x.
+ * We approximate pone by
+ *	qone(x) = s*(0.375 + (R/S))
+ * where  R = qr1*s^2 + qr2*s^4 + ... + qr5*s^10
+ *	  S = 1 + qs1*s^2 + ... + qs6*s^12
+ * and
+ *	| qone(x)/s -0.375-R/S | <= 2  ** ( -61.13)
+ */
+
+static const float qr8[6] = { /* for x in [inf, 8]=1/[0,0.125] */
+  0.0000000000e+00, /* 0x00000000 */
+ -1.0253906250e-01, /* 0xbdd20000 */
+ -1.6271753311e+01, /* 0xc1822c8d */
+ -7.5960174561e+02, /* 0xc43de683 */
+ -1.1849806641e+04, /* 0xc639273a */
+ -4.8438511719e+04, /* 0xc73d3683 */
+};
+static const float qs8[6] = {
+  1.6139537048e+02, /* 0x43216537 */
+  7.8253862305e+03, /* 0x45f48b17 */
+  1.3387534375e+05, /* 0x4802bcd6 */
+  7.1965775000e+05, /* 0x492fb29c */
+  6.6660125000e+05, /* 0x4922be94 */
+ -2.9449025000e+05, /* 0xc88fcb48 */
+};
+
+static const float qr5[6] = { /* for x in [8,4.5454]=1/[0.125,0.22001] */
+ -2.0897993405e-11, /* 0xadb7d219 */
+ -1.0253904760e-01, /* 0xbdd1fffe */
+ -8.0564479828e+00, /* 0xc100e736 */
+ -1.8366960144e+02, /* 0xc337ab6b */
+ -1.3731937256e+03, /* 0xc4aba633 */
+ -2.6124443359e+03, /* 0xc523471c */
+};
+static const float qs5[6] = {
+  8.1276550293e+01, /* 0x42a28d98 */
+  1.9917987061e+03, /* 0x44f8f98f */
+  1.7468484375e+04, /* 0x468878f8 */
+  4.9851425781e+04, /* 0x4742bb6d */
+  2.7948074219e+04, /* 0x46da5826 */
+ -4.7191835938e+03, /* 0xc5937978 */
+};
+
+static const float qr3[6] = {
+ -5.0783124372e-09, /* 0xb1ae7d4f */
+ -1.0253783315e-01, /* 0xbdd1ff5b */
+ -4.6101160049e+00, /* 0xc0938612 */
+ -5.7847221375e+01, /* 0xc267638e */
+ -2.2824453735e+02, /* 0xc3643e9a */
+ -2.1921012878e+02, /* 0xc35b35cb */
+};
+static const float qs3[6] = {
+  4.7665153503e+01, /* 0x423ea91e */
+  6.7386511230e+02, /* 0x4428775e */
+  3.3801528320e+03, /* 0x45534272 */
+  5.5477290039e+03, /* 0x45ad5dd5 */
+  1.9031191406e+03, /* 0x44ede3d0 */
+ -1.3520118713e+02, /* 0xc3073381 */
+};
+
+static const float qr2[6] = {/* for x in [2.8570,2]=1/[0.3499,0.5] */
+ -1.7838172539e-07, /* 0xb43f8932 */
+ -1.0251704603e-01, /* 0xbdd1f475 */
+ -2.7522056103e+00, /* 0xc0302423 */
+ -1.9663616180e+01, /* 0xc19d4f16 */
+ -4.2325313568e+01, /* 0xc2294d1f */
+ -2.1371921539e+01, /* 0xc1aaf9b2 */
+};
+static const float qs2[6] = {
+  2.9533363342e+01, /* 0x41ec4454 */
+  2.5298155212e+02, /* 0x437cfb47 */
+  7.5750280762e+02, /* 0x443d602e */
+  7.3939318848e+02, /* 0x4438d92a */
+  1.5594900513e+02, /* 0x431bf2f2 */
+ -4.9594988823e+00, /* 0xc09eb437 */
+};
+
+static float
+qonef(float x)
+{
+	const float *p,*q;
+	float  s,r,z;
+	int32_t ix;
+	GET_FLOAT_WORD(ix,x);
+	ix &= 0x7fffffff;
+	/* ix >= 0x40000000 for all calls to this function.  */
+	if(ix>=0x40200000)     {p = qr8; q= qs8;}
+	else if(ix>=0x40f71c58){p = qr5; q= qs5;}
+	else if(ix>=0x4036db68){p = qr3; q= qs3;}
+	else {p = qr2; q= qs2;}
+	z = one/(x*x);
+	r = p[0]+z*(p[1]+z*(p[2]+z*(p[3]+z*(p[4]+z*p[5]))));
+	s = one+z*(q[0]+z*(q[1]+z*(q[2]+z*(q[3]+z*(q[4]+z*q[5])))));
+	return ((float).375 + r/s)/x;
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_jnf.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_jnf.c
new file mode 100644
index 0000000000..4e634778d3
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_jnf.c
@@ -0,0 +1,233 @@
+/* e_jnf.c -- float version of e_jn.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <errno.h>
+#include <float.h>
+#include <math.h>
+#include <math_private.h>
+
+static const float
+two   =  2.0000000000e+00, /* 0x40000000 */
+one   =  1.0000000000e+00; /* 0x3F800000 */
+
+static const float zero  =  0.0000000000e+00;
+
+float
+__ieee754_jnf(int n, float x)
+{
+    float ret;
+    {
+	int32_t i,hx,ix, sgn;
+	float a, b, temp, di;
+	float z, w;
+
+    /* J(-n,x) = (-1)^n * J(n, x), J(n, -x) = (-1)^n * J(n, x)
+     * Thus, J(-n,x) = J(n,-x)
+     */
+	GET_FLOAT_WORD(hx,x);
+	ix = 0x7fffffff&hx;
+    /* if J(n,NaN) is NaN */
+	if(__builtin_expect(ix>0x7f800000, 0)) return x+x;
+	if(n<0){
+		n = -n;
+		x = -x;
+		hx ^= 0x80000000;
+	}
+	if(n==0) return(__ieee754_j0f(x));
+	if(n==1) return(__ieee754_j1f(x));
+	sgn = (n&1)&(hx>>31);	/* even n -- 0, odd n -- sign(x) */
+	x = fabsf(x);
+	SET_RESTORE_ROUNDF (FE_TONEAREST);
+	if(__builtin_expect(ix==0||ix>=0x7f800000, 0))	/* if x is 0 or inf */
+	    return sgn == 1 ? -zero : zero;
+	else if((float)n<=x) {
+		/* Safe to use J(n+1,x)=2n/x *J(n,x)-J(n-1,x) */
+	    a = __ieee754_j0f(x);
+	    b = __ieee754_j1f(x);
+	    for(i=1;i<n;i++){
+		temp = b;
+		b = b*((double)(i+i)/x) - a; /* avoid underflow */
+		a = temp;
+	    }
+	} else {
+	    if(ix<0x30800000) {	/* x < 2**-29 */
+    /* x is tiny, return the first Taylor expansion of J(n,x)
+     * J(n,x) = 1/n!*(x/2)^n  - ...
+     */
+		if(n>33)	/* underflow */
+		    b = zero;
+		else {
+		    temp = x*(float)0.5; b = temp;
+		    for (a=one,i=2;i<=n;i++) {
+			a *= (float)i;		/* a = n! */
+			b *= temp;		/* b = (x/2)^n */
+		    }
+		    b = b/a;
+		}
+	    } else {
+		/* use backward recurrence */
+		/*			x      x^2      x^2
+		 *  J(n,x)/J(n-1,x) =  ----   ------   ------   .....
+		 *			2n  - 2(n+1) - 2(n+2)
+		 *
+		 *			1      1        1
+		 *  (for large x)   =  ----  ------   ------   .....
+		 *			2n   2(n+1)   2(n+2)
+		 *			-- - ------ - ------ -
+		 *			 x     x         x
+		 *
+		 * Let w = 2n/x and h=2/x, then the above quotient
+		 * is equal to the continued fraction:
+		 *		    1
+		 *	= -----------------------
+		 *		       1
+		 *	   w - -----------------
+		 *			  1
+		 *		w+h - ---------
+		 *		       w+2h - ...
+		 *
+		 * To determine how many terms needed, let
+		 * Q(0) = w, Q(1) = w(w+h) - 1,
+		 * Q(k) = (w+k*h)*Q(k-1) - Q(k-2),
+		 * When Q(k) > 1e4	good for single
+		 * When Q(k) > 1e9	good for double
+		 * When Q(k) > 1e17	good for quadruple
+		 */
+	    /* determine k */
+		float t,v;
+		float q0,q1,h,tmp; int32_t k,m;
+		w  = (n+n)/(float)x; h = (float)2.0/(float)x;
+		q0 = w;  z = w+h; q1 = w*z - (float)1.0; k=1;
+		while(q1<(float)1.0e9) {
+			k += 1; z += h;
+			tmp = z*q1 - q0;
+			q0 = q1;
+			q1 = tmp;
+		}
+		m = n+n;
+		for(t=zero, i = 2*(n+k); i>=m; i -= 2) t = one/(i/x-t);
+		a = t;
+		b = one;
+		/*  estimate log((2/x)^n*n!) = n*log(2/x)+n*ln(n)
+		 *  Hence, if n*(log(2n/x)) > ...
+		 *  single 8.8722839355e+01
+		 *  double 7.09782712893383973096e+02
+		 *  long double 1.1356523406294143949491931077970765006170e+04
+		 *  then recurrent value may overflow and the result is
+		 *  likely underflow to zero
+		 */
+		tmp = n;
+		v = two/x;
+		tmp = tmp*__ieee754_logf(fabsf(v*tmp));
+		if(tmp<(float)8.8721679688e+01) {
+		    for(i=n-1,di=(float)(i+i);i>0;i--){
+			temp = b;
+			b *= di;
+			b  = b/x - a;
+			a = temp;
+			di -= two;
+		    }
+		} else {
+		    for(i=n-1,di=(float)(i+i);i>0;i--){
+			temp = b;
+			b *= di;
+			b  = b/x - a;
+			a = temp;
+			di -= two;
+		    /* scale b to avoid spurious overflow */
+			if(b>(float)1e10) {
+			    a /= b;
+			    t /= b;
+			    b  = one;
+			}
+		    }
+		}
+		/* j0() and j1() suffer enormous loss of precision at and
+		 * near zero; however, we know that their zero points never
+		 * coincide, so just choose the one further away from zero.
+		 */
+		z = __ieee754_j0f (x);
+		w = __ieee754_j1f (x);
+		if (fabsf (z) >= fabsf (w))
+		  b = (t * z / b);
+		else
+		  b = (t * w / a);
+	    }
+	}
+	if(sgn==1) ret = -b; else ret = b;
+	ret = math_narrow_eval (ret);
+    }
+    if (ret == 0)
+      {
+	ret = math_narrow_eval (__copysignf (FLT_MIN, ret) * FLT_MIN);
+	__set_errno (ERANGE);
+      }
+    else
+	math_check_force_underflow (ret);
+    return ret;
+}
+strong_alias (__ieee754_jnf, __jnf_finite)
+
+float
+__ieee754_ynf(int n, float x)
+{
+    float ret;
+    {
+	int32_t i,hx,ix;
+	u_int32_t ib;
+	int32_t sign;
+	float a, b, temp;
+
+	GET_FLOAT_WORD(hx,x);
+	ix = 0x7fffffff&hx;
+    /* if Y(n,NaN) is NaN */
+	if(__builtin_expect(ix>0x7f800000, 0)) return x+x;
+	if(__builtin_expect(ix==0, 0))
+		return -HUGE_VALF+x;  /* -inf and overflow exception.  */
+	if(__builtin_expect(hx<0, 0)) return zero/(zero*x);
+	sign = 1;
+	if(n<0){
+		n = -n;
+		sign = 1 - ((n&1)<<1);
+	}
+	if(n==0) return(__ieee754_y0f(x));
+	SET_RESTORE_ROUNDF (FE_TONEAREST);
+	if(n==1) {
+	    ret = sign*__ieee754_y1f(x);
+	    goto out;
+	}
+	if(__builtin_expect(ix==0x7f800000, 0)) return zero;
+
+	a = __ieee754_y0f(x);
+	b = __ieee754_y1f(x);
+	/* quit if b is -inf */
+	GET_FLOAT_WORD(ib,b);
+	for(i=1;i<n&&ib!=0xff800000;i++){
+	    temp = b;
+	    b = ((double)(i+i)/x)*b - a;
+	    GET_FLOAT_WORD(ib,b);
+	    a = temp;
+	}
+	/* If B is +-Inf, set up errno accordingly.  */
+	if (! isfinite (b))
+	  __set_errno (ERANGE);
+	if(sign>0) ret = b; else ret = -b;
+    }
+ out:
+    if (isinf (ret))
+	ret = __copysignf (FLT_MAX, ret) * FLT_MAX;
+    return ret;
+}
+strong_alias (__ieee754_ynf, __ynf_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_lgammaf_r.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_lgammaf_r.c
new file mode 100644
index 0000000000..1b30dcd84d
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_lgammaf_r.c
@@ -0,0 +1,246 @@
+/* e_lgammaf_r.c -- float version of e_lgamma_r.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+#include <libc-diag.h>
+
+static const float
+two23=  8.3886080000e+06, /* 0x4b000000 */
+half=  5.0000000000e-01, /* 0x3f000000 */
+one =  1.0000000000e+00, /* 0x3f800000 */
+pi  =  3.1415927410e+00, /* 0x40490fdb */
+a0  =  7.7215664089e-02, /* 0x3d9e233f */
+a1  =  3.2246702909e-01, /* 0x3ea51a66 */
+a2  =  6.7352302372e-02, /* 0x3d89f001 */
+a3  =  2.0580807701e-02, /* 0x3ca89915 */
+a4  =  7.3855509982e-03, /* 0x3bf2027e */
+a5  =  2.8905137442e-03, /* 0x3b3d6ec6 */
+a6  =  1.1927076848e-03, /* 0x3a9c54a1 */
+a7  =  5.1006977446e-04, /* 0x3a05b634 */
+a8  =  2.2086278477e-04, /* 0x39679767 */
+a9  =  1.0801156895e-04, /* 0x38e28445 */
+a10 =  2.5214456400e-05, /* 0x37d383a2 */
+a11 =  4.4864096708e-05, /* 0x383c2c75 */
+tc  =  1.4616321325e+00, /* 0x3fbb16c3 */
+tf  = -1.2148628384e-01, /* 0xbdf8cdcd */
+/* tt = -(tail of tf) */
+tt  =  6.6971006518e-09, /* 0x31e61c52 */
+t0  =  4.8383611441e-01, /* 0x3ef7b95e */
+t1  = -1.4758771658e-01, /* 0xbe17213c */
+t2  =  6.4624942839e-02, /* 0x3d845a15 */
+t3  = -3.2788541168e-02, /* 0xbd064d47 */
+t4  =  1.7970675603e-02, /* 0x3c93373d */
+t5  = -1.0314224288e-02, /* 0xbc28fcfe */
+t6  =  6.1005386524e-03, /* 0x3bc7e707 */
+t7  = -3.6845202558e-03, /* 0xbb7177fe */
+t8  =  2.2596477065e-03, /* 0x3b141699 */
+t9  = -1.4034647029e-03, /* 0xbab7f476 */
+t10 =  8.8108185446e-04, /* 0x3a66f867 */
+t11 = -5.3859531181e-04, /* 0xba0d3085 */
+t12 =  3.1563205994e-04, /* 0x39a57b6b */
+t13 = -3.1275415677e-04, /* 0xb9a3f927 */
+t14 =  3.3552918467e-04, /* 0x39afe9f7 */
+u0  = -7.7215664089e-02, /* 0xbd9e233f */
+u1  =  6.3282704353e-01, /* 0x3f2200f4 */
+u2  =  1.4549225569e+00, /* 0x3fba3ae7 */
+u3  =  9.7771751881e-01, /* 0x3f7a4bb2 */
+u4  =  2.2896373272e-01, /* 0x3e6a7578 */
+u5  =  1.3381091878e-02, /* 0x3c5b3c5e */
+v1  =  2.4559779167e+00, /* 0x401d2ebe */
+v2  =  2.1284897327e+00, /* 0x4008392d */
+v3  =  7.6928514242e-01, /* 0x3f44efdf */
+v4  =  1.0422264785e-01, /* 0x3dd572af */
+v5  =  3.2170924824e-03, /* 0x3b52d5db */
+s0  = -7.7215664089e-02, /* 0xbd9e233f */
+s1  =  2.1498242021e-01, /* 0x3e5c245a */
+s2  =  3.2577878237e-01, /* 0x3ea6cc7a */
+s3  =  1.4635047317e-01, /* 0x3e15dce6 */
+s4  =  2.6642270386e-02, /* 0x3cda40e4 */
+s5  =  1.8402845599e-03, /* 0x3af135b4 */
+s6  =  3.1947532989e-05, /* 0x3805ff67 */
+r1  =  1.3920053244e+00, /* 0x3fb22d3b */
+r2  =  7.2193557024e-01, /* 0x3f38d0c5 */
+r3  =  1.7193385959e-01, /* 0x3e300f6e */
+r4  =  1.8645919859e-02, /* 0x3c98bf54 */
+r5  =  7.7794247773e-04, /* 0x3a4beed6 */
+r6  =  7.3266842264e-06, /* 0x36f5d7bd */
+w0  =  4.1893854737e-01, /* 0x3ed67f1d */
+w1  =  8.3333335817e-02, /* 0x3daaaaab */
+w2  = -2.7777778450e-03, /* 0xbb360b61 */
+w3  =  7.9365057172e-04, /* 0x3a500cfd */
+w4  = -5.9518753551e-04, /* 0xba1c065c */
+w5  =  8.3633989561e-04, /* 0x3a5b3dd2 */
+w6  = -1.6309292987e-03; /* 0xbad5c4e8 */
+
+static const float zero=  0.0000000000e+00;
+
+static float
+sin_pif(float x)
+{
+	float y,z;
+	int n,ix;
+
+	GET_FLOAT_WORD(ix,x);
+	ix &= 0x7fffffff;
+
+	if(ix<0x3e800000) return __kernel_sinf(pi*x,zero,0);
+	y = -x;		/* x is assume negative */
+
+    /*
+     * argument reduction, make sure inexact flag not raised if input
+     * is an integer
+     */
+	z = __floorf(y);
+	if(z!=y) {				/* inexact anyway */
+	    y  *= (float)0.5;
+	    y   = (float)2.0*(y - __floorf(y));	/* y = |x| mod 2.0 */
+	    n   = (int) (y*(float)4.0);
+	} else {
+	    if(ix>=0x4b800000) {
+		y = zero; n = 0;                 /* y must be even */
+	    } else {
+		if(ix<0x4b000000) z = y+two23;	/* exact */
+		GET_FLOAT_WORD(n,z);
+		n &= 1;
+		y  = n;
+		n<<= 2;
+	    }
+	}
+	switch (n) {
+	    case 0:   y =  __kernel_sinf(pi*y,zero,0); break;
+	    case 1:
+	    case 2:   y =  __kernel_cosf(pi*((float)0.5-y),zero); break;
+	    case 3:
+	    case 4:   y =  __kernel_sinf(pi*(one-y),zero,0); break;
+	    case 5:
+	    case 6:   y = -__kernel_cosf(pi*(y-(float)1.5),zero); break;
+	    default:  y =  __kernel_sinf(pi*(y-(float)2.0),zero,0); break;
+	    }
+	return -y;
+}
+
+
+float
+__ieee754_lgammaf_r(float x, int *signgamp)
+{
+	float t,y,z,nadj,p,p1,p2,p3,q,r,w;
+	int i,hx,ix;
+
+	GET_FLOAT_WORD(hx,x);
+
+    /* purge off +-inf, NaN, +-0, and negative arguments */
+	*signgamp = 1;
+	ix = hx&0x7fffffff;
+	if(__builtin_expect(ix>=0x7f800000, 0)) return x*x;
+	if(__builtin_expect(ix==0, 0))
+	  {
+	    if (hx < 0)
+	      *signgamp = -1;
+	    return one/fabsf(x);
+	  }
+	if(__builtin_expect(ix<0x30800000, 0)) {
+	    /* |x|<2**-30, return -log(|x|) */
+	    if(hx<0) {
+		*signgamp = -1;
+		return -__ieee754_logf(-x);
+	    } else return -__ieee754_logf(x);
+	}
+	if(hx<0) {
+	    if(ix>=0x4b000000)	/* |x|>=2**23, must be -integer */
+		return __fabsf (x)/zero;
+	    if (ix > 0x40000000 /* X < 2.0f.  */
+		&& ix < 0x41700000 /* X > -15.0f.  */)
+		return __lgamma_negf (x, signgamp);
+	    t = sin_pif(x);
+	    if(t==zero) return one/fabsf(t); /* -integer */
+	    nadj = __ieee754_logf(pi/fabsf(t*x));
+	    if(t<zero) *signgamp = -1;
+	    x = -x;
+	}
+
+    /* purge off 1 and 2 */
+	if (ix==0x3f800000||ix==0x40000000) r = 0;
+    /* for x < 2.0 */
+	else if(ix<0x40000000) {
+	    if(ix<=0x3f666666) {	/* lgamma(x) = lgamma(x+1)-log(x) */
+		r = -__ieee754_logf(x);
+		if(ix>=0x3f3b4a20) {y = one-x; i= 0;}
+		else if(ix>=0x3e6d3308) {y= x-(tc-one); i=1;}
+		else {y = x; i=2;}
+	    } else {
+		r = zero;
+		if(ix>=0x3fdda618) {y=(float)2.0-x;i=0;} /* [1.7316,2] */
+		else if(ix>=0x3F9da620) {y=x-tc;i=1;} /* [1.23,1.73] */
+		else {y=x-one;i=2;}
+	    }
+	    switch(i) {
+	      case 0:
+		z = y*y;
+		p1 = a0+z*(a2+z*(a4+z*(a6+z*(a8+z*a10))));
+		p2 = z*(a1+z*(a3+z*(a5+z*(a7+z*(a9+z*a11)))));
+		p  = y*p1+p2;
+		r  += (p-(float)0.5*y); break;
+	      case 1:
+		z = y*y;
+		w = z*y;
+		p1 = t0+w*(t3+w*(t6+w*(t9 +w*t12)));	/* parallel comp */
+		p2 = t1+w*(t4+w*(t7+w*(t10+w*t13)));
+		p3 = t2+w*(t5+w*(t8+w*(t11+w*t14)));
+		p  = z*p1-(tt-w*(p2+y*p3));
+		r += (tf + p); break;
+	      case 2:
+		p1 = y*(u0+y*(u1+y*(u2+y*(u3+y*(u4+y*u5)))));
+		p2 = one+y*(v1+y*(v2+y*(v3+y*(v4+y*v5))));
+		r += (-(float)0.5*y + p1/p2);
+	    }
+	}
+	else if(ix<0x41000000) {			/* x < 8.0 */
+	    i = (int)x;
+	    t = zero;
+	    y = x-(float)i;
+	    p = y*(s0+y*(s1+y*(s2+y*(s3+y*(s4+y*(s5+y*s6))))));
+	    q = one+y*(r1+y*(r2+y*(r3+y*(r4+y*(r5+y*r6)))));
+	    r = half*y+p/q;
+	    z = one;	/* lgamma(1+s) = log(s) + lgamma(s) */
+	    switch(i) {
+	    case 7: z *= (y+(float)6.0);	/* FALLTHRU */
+	    case 6: z *= (y+(float)5.0);	/* FALLTHRU */
+	    case 5: z *= (y+(float)4.0);	/* FALLTHRU */
+	    case 4: z *= (y+(float)3.0);	/* FALLTHRU */
+	    case 3: z *= (y+(float)2.0);	/* FALLTHRU */
+		    r += __ieee754_logf(z); break;
+	    }
+    /* 8.0 <= x < 2**26 */
+	} else if (ix < 0x4c800000) {
+	    t = __ieee754_logf(x);
+	    z = one/x;
+	    y = z*z;
+	    w = w0+z*(w1+y*(w2+y*(w3+y*(w4+y*(w5+y*w6)))));
+	    r = (x-half)*(t-one)+w;
+	} else
+    /* 2**26 <= x <= inf */
+	    r =  math_narrow_eval (x*(__ieee754_logf(x)-one));
+	/* NADJ is set for negative arguments but not otherwise,
+	   resulting in warnings that it may be used uninitialized
+	   although in the cases where it is used it has always been
+	   set.  */
+	DIAG_PUSH_NEEDS_COMMENT;
+	DIAG_IGNORE_NEEDS_COMMENT (4.9, "-Wmaybe-uninitialized");
+	if(hx<0) r = nadj - r;
+	DIAG_POP_NEEDS_COMMENT;
+	return r;
+}
+strong_alias (__ieee754_lgammaf_r, __lgammaf_r_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_log10f.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_log10f.c
new file mode 100644
index 0000000000..aa21bbc9c5
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_log10f.c
@@ -0,0 +1,54 @@
+/* e_log10f.c -- float version of e_log10.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+#include <fix-int-fp-convert-zero.h>
+
+static const float
+two25      =  3.3554432000e+07, /* 0x4c000000 */
+ivln10     =  4.3429449201e-01, /* 0x3ede5bd9 */
+log10_2hi  =  3.0102920532e-01, /* 0x3e9a2080 */
+log10_2lo  =  7.9034151668e-07; /* 0x355427db */
+
+float
+__ieee754_log10f(float x)
+{
+	float y,z;
+	int32_t i,k,hx;
+
+	GET_FLOAT_WORD(hx,x);
+
+	k=0;
+	if (hx < 0x00800000) {			/* x < 2**-126  */
+	    if (__builtin_expect((hx&0x7fffffff)==0, 0))
+	      return -two25/__fabsf (x);	/* log(+-0)=-inf  */
+	    if (__builtin_expect(hx<0, 0))
+		return (x-x)/(x-x);	/* log(-#) = NaN */
+	    k -= 25; x *= two25; /* subnormal number, scale up x */
+	    GET_FLOAT_WORD(hx,x);
+	}
+	if (__builtin_expect(hx >= 0x7f800000, 0)) return x+x;
+	k += (hx>>23)-127;
+	i  = ((u_int32_t)k&0x80000000)>>31;
+	hx = (hx&0x007fffff)|((0x7f-i)<<23);
+	y  = (float)(k+i);
+	if (FIX_INT_FP_CONVERT_ZERO && y == 0.0f)
+	  y = 0.0f;
+	SET_FLOAT_WORD(x,hx);
+	z  = y*log10_2lo + ivln10*__ieee754_logf(x);
+	return  z+y*log10_2hi;
+}
+strong_alias (__ieee754_log10f, __log10f_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_log2f.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_log2f.c
new file mode 100644
index 0000000000..782d901094
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_log2f.c
@@ -0,0 +1,86 @@
+/* e_logf.c -- float version of e_log.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ * adapted for log2 by Ulrich Drepper <drepper@cygnus.com>
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+
+#include <math.h>
+#include <math_private.h>
+#include <fix-int-fp-convert-zero.h>
+
+static const float
+ln2 = 0.69314718055994530942,
+two25 =    3.355443200e+07,	/* 0x4c000000 */
+Lg1 = 6.6666668653e-01,	/* 3F2AAAAB */
+Lg2 = 4.0000000596e-01,	/* 3ECCCCCD */
+Lg3 = 2.8571429849e-01, /* 3E924925 */
+Lg4 = 2.2222198546e-01, /* 3E638E29 */
+Lg5 = 1.8183572590e-01, /* 3E3A3325 */
+Lg6 = 1.5313838422e-01, /* 3E1CD04F */
+Lg7 = 1.4798198640e-01; /* 3E178897 */
+
+static const float zero   =  0.0;
+
+float
+__ieee754_log2f(float x)
+{
+	float hfsq,f,s,z,R,w,t1,t2,dk;
+	int32_t k,ix,i,j;
+
+	GET_FLOAT_WORD(ix,x);
+
+	k=0;
+	if (ix < 0x00800000) {			/* x < 2**-126  */
+	    if (__builtin_expect((ix&0x7fffffff)==0, 0))
+		return -two25/__fabsf (x);	/* log(+-0)=-inf  */
+	    if (__builtin_expect(ix<0, 0))
+		return (x-x)/(x-x);	/* log(-#) = NaN */
+	    k -= 25; x *= two25; /* subnormal number, scale up x */
+	    GET_FLOAT_WORD(ix,x);
+	}
+	if (__builtin_expect(ix >= 0x7f800000, 0)) return x+x;
+	k += (ix>>23)-127;
+	ix &= 0x007fffff;
+	i = (ix+(0x95f64<<3))&0x800000;
+	SET_FLOAT_WORD(x,ix|(i^0x3f800000));	/* normalize x or x/2 */
+	k += (i>>23);
+	dk = (float)k;
+	f = x-(float)1.0;
+	if((0x007fffff&(15+ix))<16) {	/* |f| < 2**-20 */
+	    if(f==zero)
+	      {
+		if (FIX_INT_FP_CONVERT_ZERO && dk == 0.0f)
+		  dk = 0.0f;
+		return dk;
+	      }
+	    R = f*f*((float)0.5-(float)0.33333333333333333*f);
+	    return dk-(R-f)/ln2;
+	}
+	s = f/((float)2.0+f);
+	z = s*s;
+	i = ix-(0x6147a<<3);
+	w = z*z;
+	j = (0x6b851<<3)-ix;
+	t1= w*(Lg2+w*(Lg4+w*Lg6));
+	t2= z*(Lg1+w*(Lg3+w*(Lg5+w*Lg7)));
+	i |= j;
+	R = t2+t1;
+	if(i>0) {
+	    hfsq=(float)0.5*f*f;
+	    return dk-((hfsq-(s*(hfsq+R)))-f)/ln2;
+	} else {
+	    return dk-((s*(f-R))-f)/ln2;
+	}
+}
+strong_alias (__ieee754_log2f, __log2f_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_logf.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_logf.c
new file mode 100644
index 0000000000..cf75e11781
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_logf.c
@@ -0,0 +1,85 @@
+/* e_logf.c -- float version of e_log.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+static const float
+ln2_hi =   6.9313812256e-01,	/* 0x3f317180 */
+ln2_lo =   9.0580006145e-06,	/* 0x3717f7d1 */
+two25 =    3.355443200e+07,	/* 0x4c000000 */
+Lg1 = 6.6666668653e-01,	/* 3F2AAAAB */
+Lg2 = 4.0000000596e-01,	/* 3ECCCCCD */
+Lg3 = 2.8571429849e-01, /* 3E924925 */
+Lg4 = 2.2222198546e-01, /* 3E638E29 */
+Lg5 = 1.8183572590e-01, /* 3E3A3325 */
+Lg6 = 1.5313838422e-01, /* 3E1CD04F */
+Lg7 = 1.4798198640e-01; /* 3E178897 */
+
+static const float zero   =  0.0;
+
+float
+__ieee754_logf(float x)
+{
+	float hfsq,f,s,z,R,w,t1,t2,dk;
+	int32_t k,ix,i,j;
+
+	GET_FLOAT_WORD(ix,x);
+
+	k=0;
+	if (ix < 0x00800000) {			/* x < 2**-126  */
+	    if (__builtin_expect((ix&0x7fffffff)==0, 0))
+		return -two25/zero;		/* log(+-0)=-inf */
+	    if (__builtin_expect(ix<0, 0))
+		return (x-x)/(x-x);	/* log(-#) = NaN */
+	    k -= 25; x *= two25; /* subnormal number, scale up x */
+	    GET_FLOAT_WORD(ix,x);
+	}
+	if (__builtin_expect(ix >= 0x7f800000, 0)) return x+x;
+	k += (ix>>23)-127;
+	ix &= 0x007fffff;
+	i = (ix+(0x95f64<<3))&0x800000;
+	SET_FLOAT_WORD(x,ix|(i^0x3f800000));	/* normalize x or x/2 */
+	k += (i>>23);
+	f = x-(float)1.0;
+	if((0x007fffff&(15+ix))<16) {	/* |f| < 2**-20 */
+	    if(f==zero) {
+	      if(k==0) return zero;  else {dk=(float)k;
+					   return dk*ln2_hi+dk*ln2_lo;}
+	    }
+	    R = f*f*((float)0.5-(float)0.33333333333333333*f);
+	    if(k==0) return f-R; else {dk=(float)k;
+		     return dk*ln2_hi-((R-dk*ln2_lo)-f);}
+	}
+	s = f/((float)2.0+f);
+	dk = (float)k;
+	z = s*s;
+	i = ix-(0x6147a<<3);
+	w = z*z;
+	j = (0x6b851<<3)-ix;
+	t1= w*(Lg2+w*(Lg4+w*Lg6));
+	t2= z*(Lg1+w*(Lg3+w*(Lg5+w*Lg7)));
+	i |= j;
+	R = t2+t1;
+	if(i>0) {
+	    hfsq=(float)0.5*f*f;
+	    if(k==0) return f-(hfsq-s*(hfsq+R)); else
+		     return dk*ln2_hi-((hfsq-(s*(hfsq+R)+dk*ln2_lo))-f);
+	} else {
+	    if(k==0) return f-s*(f-R); else
+		     return dk*ln2_hi-((s*(f-R)-dk*ln2_lo)-f);
+	}
+}
+strong_alias (__ieee754_logf, __logf_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_powf.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_powf.c
new file mode 100644
index 0000000000..13b49def8e
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_powf.c
@@ -0,0 +1,258 @@
+/* e_powf.c -- float version of e_pow.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+static const float huge = 1.0e+30, tiny = 1.0e-30;
+
+static const float
+bp[] = {1.0, 1.5,},
+dp_h[] = { 0.0, 5.84960938e-01,}, /* 0x3f15c000 */
+dp_l[] = { 0.0, 1.56322085e-06,}, /* 0x35d1cfdc */
+zero    =  0.0,
+one	=  1.0,
+two	=  2.0,
+two24	=  16777216.0,	/* 0x4b800000 */
+	/* poly coefs for (3/2)*(log(x)-2s-2/3*s**3 */
+L1  =  6.0000002384e-01, /* 0x3f19999a */
+L2  =  4.2857143283e-01, /* 0x3edb6db7 */
+L3  =  3.3333334327e-01, /* 0x3eaaaaab */
+L4  =  2.7272811532e-01, /* 0x3e8ba305 */
+L5  =  2.3066075146e-01, /* 0x3e6c3255 */
+L6  =  2.0697501302e-01, /* 0x3e53f142 */
+P1   =  1.6666667163e-01, /* 0x3e2aaaab */
+P2   = -2.7777778450e-03, /* 0xbb360b61 */
+P3   =  6.6137559770e-05, /* 0x388ab355 */
+P4   = -1.6533901999e-06, /* 0xb5ddea0e */
+P5   =  4.1381369442e-08, /* 0x3331bb4c */
+lg2  =  6.9314718246e-01, /* 0x3f317218 */
+lg2_h  =  6.93145752e-01, /* 0x3f317200 */
+lg2_l  =  1.42860654e-06, /* 0x35bfbe8c */
+ovt =  4.2995665694e-08, /* -(128-log2(ovfl+.5ulp)) */
+cp    =  9.6179670095e-01, /* 0x3f76384f =2/(3ln2) */
+cp_h  =  0xf.64p-4, /* cp high 12 bits.  */
+cp_l  =  -0x7.b11e3p-16, /* 2/(3ln2) - cp_h.  */
+ivln2    =  1.4426950216e+00, /* 0x3fb8aa3b =1/ln2 */
+ivln2_h  =  1.4426879883e+00, /* 0x3fb8aa00 =16b 1/ln2*/
+ivln2_l  =  7.0526075433e-06; /* 0x36eca570 =1/ln2 tail*/
+
+float
+__ieee754_powf(float x, float y)
+{
+	float z,ax,z_h,z_l,p_h,p_l;
+	float y1,t1,t2,r,s,t,u,v,w;
+	int32_t i,j,k,yisint,n;
+	int32_t hx,hy,ix,iy,is;
+
+	GET_FLOAT_WORD(hx,x);
+	GET_FLOAT_WORD(hy,y);
+	ix = hx&0x7fffffff;  iy = hy&0x7fffffff;
+
+    /* y==zero: x**0 = 1 */
+	if(iy==0 && !issignaling (x)) return one;
+
+    /* x==+-1 */
+	if(x == 1.0 && !issignaling (y)) return one;
+	if(x == -1.0 && isinf(y)) return one;
+
+    /* +-NaN return x+y */
+	if(__builtin_expect(ix > 0x7f800000 ||
+			    iy > 0x7f800000, 0))
+		return x+y;
+
+    /* determine if y is an odd int when x < 0
+     * yisint = 0	... y is not an integer
+     * yisint = 1	... y is an odd int
+     * yisint = 2	... y is an even int
+     */
+	yisint  = 0;
+	if(hx<0) {
+	    if(iy>=0x4b800000) yisint = 2; /* even integer y */
+	    else if(iy>=0x3f800000) {
+		k = (iy>>23)-0x7f;	   /* exponent */
+		j = iy>>(23-k);
+		if((j<<(23-k))==iy) yisint = 2-(j&1);
+	    }
+	}
+
+    /* special value of y */
+	if (__builtin_expect(iy==0x7f800000, 0)) {	/* y is +-inf */
+	    if (ix==0x3f800000)
+		return  y - y;	/* inf**+-1 is NaN */
+	    else if (ix > 0x3f800000)/* (|x|>1)**+-inf = inf,0 */
+		return (hy>=0)? y: zero;
+	    else			/* (|x|<1)**-,+inf = inf,0 */
+		return (hy<0)?-y: zero;
+	}
+	if(iy==0x3f800000) {	/* y is  +-1 */
+	    if(hy<0) return one/x; else return x;
+	}
+	if(hy==0x40000000) return x*x; /* y is  2 */
+	if(hy==0x3f000000) {	/* y is  0.5 */
+	    if(__builtin_expect(hx>=0, 1))	/* x >= +0 */
+	    return __ieee754_sqrtf(x);
+	}
+
+	ax   = fabsf(x);
+    /* special value of x */
+	if(__builtin_expect(ix==0x7f800000||ix==0||ix==0x3f800000, 0)){
+	    z = ax;			/*x is +-0,+-inf,+-1*/
+	    if(hy<0) z = one/z;	/* z = (1/|x|) */
+	    if(hx<0) {
+		if(((ix-0x3f800000)|yisint)==0) {
+		    z = (z-z)/(z-z); /* (-1)**non-int is NaN */
+		} else if(yisint==1)
+		    z = -z;		/* (x<0)**odd = -(|x|**odd) */
+	    }
+	    return z;
+	}
+
+    /* (x<0)**(non-int) is NaN */
+	if(__builtin_expect(((((u_int32_t)hx>>31)-1)|yisint)==0, 0))
+	    return (x-x)/(x-x);
+
+    /* |y| is huge */
+	if(__builtin_expect(iy>0x4d000000, 0)) { /* if |y| > 2**27 */
+	/* over/underflow if x is not close to one */
+	    if(ix<0x3f7ffff8) return (hy<0)? huge*huge:tiny*tiny;
+	    if(ix>0x3f800007) return (hy>0)? huge*huge:tiny*tiny;
+	/* now |1-x| is tiny <= 2**-20, suffice to compute
+	   log(x) by x-x^2/2+x^3/3-x^4/4 */
+	    t = ax-1;		/* t has 20 trailing zeros */
+	    w = (t*t)*((float)0.5-t*((float)0.333333333333-t*(float)0.25));
+	    u = ivln2_h*t;	/* ivln2_h has 16 sig. bits */
+	    v = t*ivln2_l-w*ivln2;
+	    t1 = u+v;
+	    GET_FLOAT_WORD(is,t1);
+	    SET_FLOAT_WORD(t1,is&0xfffff000);
+	    t2 = v-(t1-u);
+	} else {
+	    float s2,s_h,s_l,t_h,t_l;
+	    /* Avoid internal underflow for tiny y.  The exact value
+	       of y does not matter if |y| <= 2**-32.  */
+	    if (iy < 0x2f800000)
+	      SET_FLOAT_WORD (y, (hy & 0x80000000) | 0x2f800000);
+	    n = 0;
+	/* take care subnormal number */
+	    if(ix<0x00800000)
+		{ax *= two24; n -= 24; GET_FLOAT_WORD(ix,ax); }
+	    n  += ((ix)>>23)-0x7f;
+	    j  = ix&0x007fffff;
+	/* determine interval */
+	    ix = j|0x3f800000;		/* normalize ix */
+	    if(j<=0x1cc471) k=0;	/* |x|<sqrt(3/2) */
+	    else if(j<0x5db3d7) k=1;	/* |x|<sqrt(3)   */
+	    else {k=0;n+=1;ix -= 0x00800000;}
+	    SET_FLOAT_WORD(ax,ix);
+
+	/* compute s = s_h+s_l = (x-1)/(x+1) or (x-1.5)/(x+1.5) */
+	    u = ax-bp[k];		/* bp[0]=1.0, bp[1]=1.5 */
+	    v = one/(ax+bp[k]);
+	    s = u*v;
+	    s_h = s;
+	    GET_FLOAT_WORD(is,s_h);
+	    SET_FLOAT_WORD(s_h,is&0xfffff000);
+	/* t_h=ax+bp[k] High */
+	    SET_FLOAT_WORD (t_h,
+			    ((((ix>>1)|0x20000000)+0x00400000+(k<<21))
+			     & 0xfffff000));
+	    t_l = ax - (t_h-bp[k]);
+	    s_l = v*((u-s_h*t_h)-s_h*t_l);
+	/* compute log(ax) */
+	    s2 = s*s;
+	    r = s2*s2*(L1+s2*(L2+s2*(L3+s2*(L4+s2*(L5+s2*L6)))));
+	    r += s_l*(s_h+s);
+	    s2  = s_h*s_h;
+	    t_h = (float)3.0+s2+r;
+	    GET_FLOAT_WORD(is,t_h);
+	    SET_FLOAT_WORD(t_h,is&0xfffff000);
+	    t_l = r-((t_h-(float)3.0)-s2);
+	/* u+v = s*(1+...) */
+	    u = s_h*t_h;
+	    v = s_l*t_h+t_l*s;
+	/* 2/(3log2)*(s+...) */
+	    p_h = u+v;
+	    GET_FLOAT_WORD(is,p_h);
+	    SET_FLOAT_WORD(p_h,is&0xfffff000);
+	    p_l = v-(p_h-u);
+	    z_h = cp_h*p_h;		/* cp_h+cp_l = 2/(3*log2) */
+	    z_l = cp_l*p_h+p_l*cp+dp_l[k];
+	/* log2(ax) = (s+..)*2/(3*log2) = n + dp_h + z_h + z_l */
+	    t = (float)n;
+	    t1 = (((z_h+z_l)+dp_h[k])+t);
+	    GET_FLOAT_WORD(is,t1);
+	    SET_FLOAT_WORD(t1,is&0xfffff000);
+	    t2 = z_l-(((t1-t)-dp_h[k])-z_h);
+	}
+
+	s = one; /* s (sign of result -ve**odd) = -1 else = 1 */
+	if(((((u_int32_t)hx>>31)-1)|(yisint-1))==0)
+	    s = -one;	/* (-ve)**(odd int) */
+
+    /* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */
+	GET_FLOAT_WORD(is,y);
+	SET_FLOAT_WORD(y1,is&0xfffff000);
+	p_l = (y-y1)*t1+y*t2;
+	p_h = y1*t1;
+	z = p_l+p_h;
+	GET_FLOAT_WORD(j,z);
+	if (__builtin_expect(j>0x43000000, 0))		/* if z > 128 */
+	    return s*huge*huge;				/* overflow */
+	else if (__builtin_expect(j==0x43000000, 0)) {	/* if z == 128 */
+	    if(p_l+ovt>z-p_h) return s*huge*huge;	/* overflow */
+	}
+	else if (__builtin_expect((j&0x7fffffff)>0x43160000, 0))/* z <= -150 */
+	    return s*tiny*tiny;				/* underflow */
+	else if (__builtin_expect((u_int32_t) j==0xc3160000, 0)){/* z == -150*/
+	    if(p_l<=z-p_h) return s*tiny*tiny;		/* underflow */
+	}
+    /*
+     * compute 2**(p_h+p_l)
+     */
+	i = j&0x7fffffff;
+	k = (i>>23)-0x7f;
+	n = 0;
+	if(i>0x3f000000) {		/* if |z| > 0.5, set n = [z+0.5] */
+	    n = j+(0x00800000>>(k+1));
+	    k = ((n&0x7fffffff)>>23)-0x7f;	/* new k for n */
+	    SET_FLOAT_WORD(t,n&~(0x007fffff>>k));
+	    n = ((n&0x007fffff)|0x00800000)>>(23-k);
+	    if(j<0) n = -n;
+	    p_h -= t;
+	}
+	t = p_l+p_h;
+	GET_FLOAT_WORD(is,t);
+	SET_FLOAT_WORD(t,is&0xfffff000);
+	u = t*lg2_h;
+	v = (p_l-(t-p_h))*lg2+t*lg2_l;
+	z = u+v;
+	w = v-(z-u);
+	t  = z*z;
+	t1  = z - t*(P1+t*(P2+t*(P3+t*(P4+t*P5))));
+	r  = (z*t1)/(t1-two)-(w+z*w);
+	z  = one-(r-z);
+	GET_FLOAT_WORD(j,z);
+	j += (n<<23);
+	if((j>>23)<=0)	/* subnormal output */
+	  {
+	    z = __scalbnf (z, n);
+	    float force_underflow = z * z;
+	    math_force_eval (force_underflow);
+	  }
+	else SET_FLOAT_WORD(z,j);
+	return s*z;
+}
+strong_alias (__ieee754_powf, __powf_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_rem_pio2f.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_rem_pio2f.c
new file mode 100644
index 0000000000..c4d28c8657
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_rem_pio2f.c
@@ -0,0 +1,179 @@
+/* e_rem_pio2f.c -- float version of e_rem_pio2.c
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: e_rem_pio2f.c,v 1.5 1995/05/10 20:46:03 jtc Exp $";
+#endif
+
+/* __ieee754_rem_pio2f(x,y)
+ *
+ * return the remainder of x rem pi/2 in y[0]+y[1]
+ * use __kernel_rem_pio2f()
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+/*
+ * Table of constants for 2/pi, 396 Hex digits (476 decimal) of 2/pi
+ */
+static const int32_t two_over_pi[] = {
+0xA2, 0xF9, 0x83, 0x6E, 0x4E, 0x44, 0x15, 0x29, 0xFC,
+0x27, 0x57, 0xD1, 0xF5, 0x34, 0xDD, 0xC0, 0xDB, 0x62,
+0x95, 0x99, 0x3C, 0x43, 0x90, 0x41, 0xFE, 0x51, 0x63,
+0xAB, 0xDE, 0xBB, 0xC5, 0x61, 0xB7, 0x24, 0x6E, 0x3A,
+0x42, 0x4D, 0xD2, 0xE0, 0x06, 0x49, 0x2E, 0xEA, 0x09,
+0xD1, 0x92, 0x1C, 0xFE, 0x1D, 0xEB, 0x1C, 0xB1, 0x29,
+0xA7, 0x3E, 0xE8, 0x82, 0x35, 0xF5, 0x2E, 0xBB, 0x44,
+0x84, 0xE9, 0x9C, 0x70, 0x26, 0xB4, 0x5F, 0x7E, 0x41,
+0x39, 0x91, 0xD6, 0x39, 0x83, 0x53, 0x39, 0xF4, 0x9C,
+0x84, 0x5F, 0x8B, 0xBD, 0xF9, 0x28, 0x3B, 0x1F, 0xF8,
+0x97, 0xFF, 0xDE, 0x05, 0x98, 0x0F, 0xEF, 0x2F, 0x11,
+0x8B, 0x5A, 0x0A, 0x6D, 0x1F, 0x6D, 0x36, 0x7E, 0xCF,
+0x27, 0xCB, 0x09, 0xB7, 0x4F, 0x46, 0x3F, 0x66, 0x9E,
+0x5F, 0xEA, 0x2D, 0x75, 0x27, 0xBA, 0xC7, 0xEB, 0xE5,
+0xF1, 0x7B, 0x3D, 0x07, 0x39, 0xF7, 0x8A, 0x52, 0x92,
+0xEA, 0x6B, 0xFB, 0x5F, 0xB1, 0x1F, 0x8D, 0x5D, 0x08,
+0x56, 0x03, 0x30, 0x46, 0xFC, 0x7B, 0x6B, 0xAB, 0xF0,
+0xCF, 0xBC, 0x20, 0x9A, 0xF4, 0x36, 0x1D, 0xA9, 0xE3,
+0x91, 0x61, 0x5E, 0xE6, 0x1B, 0x08, 0x65, 0x99, 0x85,
+0x5F, 0x14, 0xA0, 0x68, 0x40, 0x8D, 0xFF, 0xD8, 0x80,
+0x4D, 0x73, 0x27, 0x31, 0x06, 0x06, 0x15, 0x56, 0xCA,
+0x73, 0xA8, 0xC9, 0x60, 0xE2, 0x7B, 0xC0, 0x8C, 0x6B,
+};
+
+/* This array is like the one in e_rem_pio2.c, but the numbers are
+   single precision and the last 8 bits are forced to 0.  */
+static const int32_t npio2_hw[] = {
+0x3fc90f00, 0x40490f00, 0x4096cb00, 0x40c90f00, 0x40fb5300, 0x4116cb00,
+0x412fed00, 0x41490f00, 0x41623100, 0x417b5300, 0x418a3a00, 0x4196cb00,
+0x41a35c00, 0x41afed00, 0x41bc7e00, 0x41c90f00, 0x41d5a000, 0x41e23100,
+0x41eec200, 0x41fb5300, 0x4203f200, 0x420a3a00, 0x42108300, 0x4216cb00,
+0x421d1400, 0x42235c00, 0x4229a500, 0x422fed00, 0x42363600, 0x423c7e00,
+0x4242c700, 0x42490f00
+};
+
+/*
+ * invpio2:  24 bits of 2/pi
+ * pio2_1:   first  17 bit of pi/2
+ * pio2_1t:  pi/2 - pio2_1
+ * pio2_2:   second 17 bit of pi/2
+ * pio2_2t:  pi/2 - (pio2_1+pio2_2)
+ * pio2_3:   third  17 bit of pi/2
+ * pio2_3t:  pi/2 - (pio2_1+pio2_2+pio2_3)
+ */
+
+static const float
+zero =  0.0000000000e+00, /* 0x00000000 */
+half =  5.0000000000e-01, /* 0x3f000000 */
+two8 =  2.5600000000e+02, /* 0x43800000 */
+invpio2 =  6.3661980629e-01, /* 0x3f22f984 */
+pio2_1  =  1.5707855225e+00, /* 0x3fc90f80 */
+pio2_1t =  1.0804334124e-05, /* 0x37354443 */
+pio2_2  =  1.0804273188e-05, /* 0x37354400 */
+pio2_2t =  6.0770999344e-11, /* 0x2e85a308 */
+pio2_3  =  6.0770943833e-11, /* 0x2e85a300 */
+pio2_3t =  6.1232342629e-17; /* 0x248d3132 */
+
+int32_t __ieee754_rem_pio2f(float x, float *y)
+{
+	float z,w,t,r,fn;
+	float tx[3];
+	int32_t e0,i,j,nx,n,ix,hx;
+
+	GET_FLOAT_WORD(hx,x);
+	ix = hx&0x7fffffff;
+	if(ix<=0x3f490fd8)   /* |x| ~<= pi/4 , no need for reduction */
+	    {y[0] = x; y[1] = 0; return 0;}
+	if(ix<0x4016cbe4) {  /* |x| < 3pi/4, special case with n=+-1 */
+	    if(hx>0) {
+		z = x - pio2_1;
+		if((ix&0xffffffc0)!=0x3fc90fc0) { /* 24+24 bit pi OK */
+		    y[0] = z - pio2_1t;
+		    y[1] = (z-y[0])-pio2_1t;
+		} else {		/* near pi/2, use 24+24+24 bit pi */
+		    z -= pio2_2;
+		    y[0] = z - pio2_2t;
+		    y[1] = (z-y[0])-pio2_2t;
+		}
+		return 1;
+	    } else {	/* negative x */
+		z = x + pio2_1;
+		if((ix&0xffffffc0)!=0x3fc90fc0) { /* 24+24 bit pi OK */
+		    y[0] = z + pio2_1t;
+		    y[1] = (z-y[0])+pio2_1t;
+		} else {		/* near pi/2, use 24+24+24 bit pi */
+		    z += pio2_2;
+		    y[0] = z + pio2_2t;
+		    y[1] = (z-y[0])+pio2_2t;
+		}
+		return -1;
+	    }
+	}
+	if(ix<=0x43490f80) { /* |x| ~<= 2^7*(pi/2), medium size */
+	    t  = fabsf(x);
+	    n  = (int32_t) (t*invpio2+half);
+	    fn = (float)n;
+	    r  = t-fn*pio2_1;
+	    w  = fn*pio2_1t;	/* 1st round good to 40 bit */
+	    if(n<32&&(int32_t)(ix&0xffffff00)!=npio2_hw[n-1]) {
+		y[0] = r-w;	/* quick check no cancellation */
+	    } else {
+	        u_int32_t high;
+	        j  = ix>>23;
+	        y[0] = r-w;
+		GET_FLOAT_WORD(high,y[0]);
+	        i = j-((high>>23)&0xff);
+	        if(i>8) {  /* 2nd iteration needed, good to 57 */
+		    t  = r;
+		    w  = fn*pio2_2;
+		    r  = t-w;
+		    w  = fn*pio2_2t-((t-r)-w);
+		    y[0] = r-w;
+		    GET_FLOAT_WORD(high,y[0]);
+		    i = j-((high>>23)&0xff);
+		    if(i>25)  {	/* 3rd iteration need, 74 bits acc */
+			t  = r;	/* will cover all possible cases */
+			w  = fn*pio2_3;
+			r  = t-w;
+			w  = fn*pio2_3t-((t-r)-w);
+			y[0] = r-w;
+		    }
+		}
+	    }
+	    y[1] = (r-y[0])-w;
+	    if(hx<0) 	{y[0] = -y[0]; y[1] = -y[1]; return -n;}
+	    else	 return n;
+	}
+    /*
+     * all other (large) arguments
+     */
+	if(ix>=0x7f800000) {		/* x is inf or NaN */
+	    y[0]=y[1]=x-x; return 0;
+	}
+    /* set z = scalbn(|x|,ilogb(x)-7) */
+	e0 	= (ix>>23)-134;		/* e0 = ilogb(z)-7; */
+	SET_FLOAT_WORD(z, ix - ((int32_t)(e0<<23)));
+	for(i=0;i<2;i++) {
+		tx[i] = (float)((int32_t)(z));
+		z     = (z-tx[i])*two8;
+	}
+	tx[2] = z;
+	nx = 3;
+	while(tx[nx-1]==zero) nx--;	/* skip zero term */
+	n  =  __kernel_rem_pio2f(tx,y,e0,nx,2,two_over_pi);
+	if(hx<0) {y[0] = -y[0]; y[1] = -y[1]; return -n;}
+	return n;
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_remainderf.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_remainderf.c
new file mode 100644
index 0000000000..cc0167862e
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_remainderf.c
@@ -0,0 +1,62 @@
+/* e_remainderf.c -- float version of e_remainder.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+static const float zero = 0.0;
+
+
+float
+__ieee754_remainderf(float x, float p)
+{
+	int32_t hx,hp;
+	u_int32_t sx;
+	float p_half;
+
+	GET_FLOAT_WORD(hx,x);
+	GET_FLOAT_WORD(hp,p);
+	sx = hx&0x80000000;
+	hp &= 0x7fffffff;
+	hx &= 0x7fffffff;
+
+    /* purge off exception values */
+	if(hp==0) return (x*p)/(x*p);		/* p = 0 */
+	if((hx>=0x7f800000)||			/* x not finite */
+	  ((hp>0x7f800000)))			/* p is NaN */
+	    return (x*p)/(x*p);
+
+
+	if (hp<=0x7effffff) x = __ieee754_fmodf(x,p+p);	/* now x < 2p */
+	if ((hx-hp)==0) return zero*x;
+	x  = fabsf(x);
+	p  = fabsf(p);
+	if (hp<0x01000000) {
+	    if(x+x>p) {
+		x-=p;
+		if(x+x>=p) x -= p;
+	    }
+	} else {
+	    p_half = (float)0.5*p;
+	    if(x>p_half) {
+		x-=p;
+		if(x>=p_half) x -= p;
+	    }
+	}
+	GET_FLOAT_WORD(hx,x);
+	SET_FLOAT_WORD(x,hx^sx);
+	return x;
+}
+strong_alias (__ieee754_remainderf, __remainderf_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_sinhf.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_sinhf.c
new file mode 100644
index 0000000000..6100d95c55
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_sinhf.c
@@ -0,0 +1,60 @@
+/* e_sinhf.c -- float version of e_sinh.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <float.h>
+#include <math.h>
+#include <math_private.h>
+
+static const float one = 1.0, shuge = 1.0e37;
+
+float
+__ieee754_sinhf(float x)
+{
+	float t,w,h;
+	int32_t ix,jx;
+
+	GET_FLOAT_WORD(jx,x);
+	ix = jx&0x7fffffff;
+
+    /* x is INF or NaN */
+	if(__builtin_expect(ix>=0x7f800000, 0)) return x+x;
+
+	h = 0.5;
+	if (jx<0) h = -h;
+    /* |x| in [0,22], return sign(x)*0.5*(E+E/(E+1))) */
+	if (ix < 0x41b00000) {		/* |x|<22 */
+	    if (__builtin_expect(ix<0x31800000, 0)) {	/* |x|<2**-28 */
+		math_check_force_underflow (x);
+		if(shuge+x>one) return x;/* sinh(tiny) = tiny with inexact */
+	    }
+	    t = __expm1f(fabsf(x));
+	    if(ix<0x3f800000) return h*((float)2.0*t-t*t/(t+one));
+	    return h*(t+t/(t+one));
+	}
+
+    /* |x| in [22, log(maxdouble)] return 0.5*exp(|x|) */
+	if (ix < 0x42b17180)  return h*__ieee754_expf(fabsf(x));
+
+    /* |x| in [log(maxdouble), overflowthresold] */
+	if (ix<=0x42b2d4fc) {
+	    w = __ieee754_expf((float)0.5*fabsf(x));
+	    t = h*w;
+	    return t*w;
+	}
+
+    /* |x| > overflowthresold, sinh(x) overflow */
+	return math_narrow_eval (x*shuge);
+}
+strong_alias (__ieee754_sinhf, __sinhf_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/e_sqrtf.c b/REORG.TODO/sysdeps/ieee754/flt-32/e_sqrtf.c
new file mode 100644
index 0000000000..c02206ac01
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/e_sqrtf.c
@@ -0,0 +1,86 @@
+/* e_sqrtf.c -- float version of e_sqrt.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+static	const float	one	= 1.0, tiny=1.0e-30;
+
+float
+__ieee754_sqrtf(float x)
+{
+	float z;
+	int32_t sign = (int)0x80000000;
+	int32_t ix,s,q,m,t,i;
+	u_int32_t r;
+
+	GET_FLOAT_WORD(ix,x);
+
+    /* take care of Inf and NaN */
+	if((ix&0x7f800000)==0x7f800000) {
+	    return x*x+x;		/* sqrt(NaN)=NaN, sqrt(+inf)=+inf
+					   sqrt(-inf)=sNaN */
+	}
+    /* take care of zero */
+	if(ix<=0) {
+	    if((ix&(~sign))==0) return x;/* sqrt(+-0) = +-0 */
+	    else if(ix<0)
+		return (x-x)/(x-x);		/* sqrt(-ve) = sNaN */
+	}
+    /* normalize x */
+	m = (ix>>23);
+	if(m==0) {				/* subnormal x */
+	    for(i=0;(ix&0x00800000)==0;i++) ix<<=1;
+	    m -= i-1;
+	}
+	m -= 127;	/* unbias exponent */
+	ix = (ix&0x007fffff)|0x00800000;
+	if(m&1)	/* odd m, double x to make it even */
+	    ix += ix;
+	m >>= 1;	/* m = [m/2] */
+
+    /* generate sqrt(x) bit by bit */
+	ix += ix;
+	q = s = 0;		/* q = sqrt(x) */
+	r = 0x01000000;		/* r = moving bit from right to left */
+
+	while(r!=0) {
+	    t = s+r;
+	    if(t<=ix) {
+		s    = t+r;
+		ix  -= t;
+		q   += r;
+	    }
+	    ix += ix;
+	    r>>=1;
+	}
+
+    /* use floating add to find out rounding direction */
+	if(ix!=0) {
+	    z = one-tiny; /* trigger inexact flag */
+	    if (z>=one) {
+		z = one+tiny;
+		if (z>one)
+		    q += 2;
+		else
+		    q += (q&1);
+	    }
+	}
+	ix = (q>>1)+0x3f000000;
+	ix += (m <<23);
+	SET_FLOAT_WORD(z,ix);
+	return z;
+}
+strong_alias (__ieee754_sqrtf, __sqrtf_finite)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/k_cosf.c b/REORG.TODO/sysdeps/ieee754/flt-32/k_cosf.c
new file mode 100644
index 0000000000..63ca822f8c
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/k_cosf.c
@@ -0,0 +1,55 @@
+/* k_cosf.c -- float version of k_cos.c
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: k_cosf.c,v 1.4 1995/05/10 20:46:23 jtc Exp $";
+#endif
+
+#include <math.h>
+#include <math_private.h>
+
+static const float
+one =  1.0000000000e+00, /* 0x3f800000 */
+C1  =  4.1666667908e-02, /* 0x3d2aaaab */
+C2  = -1.3888889225e-03, /* 0xbab60b61 */
+C3  =  2.4801587642e-05, /* 0x37d00d01 */
+C4  = -2.7557314297e-07, /* 0xb493f27c */
+C5  =  2.0875723372e-09, /* 0x310f74f6 */
+C6  = -1.1359647598e-11; /* 0xad47d74e */
+
+float __kernel_cosf(float x, float y)
+{
+	float a,hz,z,r,qx;
+	int32_t ix;
+	GET_FLOAT_WORD(ix,x);
+	ix &= 0x7fffffff;			/* ix = |x|'s high word*/
+	if(ix<0x32000000) {			/* if x < 2**27 */
+	    if(((int)x)==0) return one;		/* generate inexact */
+	}
+	z  = x*x;
+	r  = z*(C1+z*(C2+z*(C3+z*(C4+z*(C5+z*C6)))));
+	if(ix < 0x3e99999a) 			/* if |x| < 0.3 */
+	    return one - ((float)0.5*z - (z*r - x*y));
+	else {
+	    if(ix > 0x3f480000) {		/* x > 0.78125 */
+		qx = (float)0.28125;
+	    } else {
+	        SET_FLOAT_WORD(qx,ix-0x01000000);	/* x/4 */
+	    }
+	    hz = (float)0.5*z-qx;
+	    a  = one-qx;
+	    return a - (hz - (z*r-x*y));
+	}
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/k_rem_pio2f.c b/REORG.TODO/sysdeps/ieee754/flt-32/k_rem_pio2f.c
new file mode 100644
index 0000000000..a8d5b216e6
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/k_rem_pio2f.c
@@ -0,0 +1,208 @@
+/* k_rem_pio2f.c -- float version of k_rem_pio2.c
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: k_rem_pio2f.c,v 1.4 1995/05/10 20:46:28 jtc Exp $";
+#endif
+
+#include <math.h>
+#include <math_private.h>
+#include <libc-diag.h>
+
+/* In the float version, the input parameter x contains 8 bit
+   integers, not 24 bit integers.  113 bit precision is not supported.  */
+
+static const int init_jk[] = {4,7,9}; /* initial value for jk */
+
+static const float PIo2[] = {
+  1.5703125000e+00, /* 0x3fc90000 */
+  4.5776367188e-04, /* 0x39f00000 */
+  2.5987625122e-05, /* 0x37da0000 */
+  7.5437128544e-08, /* 0x33a20000 */
+  6.0026650317e-11, /* 0x2e840000 */
+  7.3896444519e-13, /* 0x2b500000 */
+  5.3845816694e-15, /* 0x27c20000 */
+  5.6378512969e-18, /* 0x22d00000 */
+  8.3009228831e-20, /* 0x1fc40000 */
+  3.2756352257e-22, /* 0x1bc60000 */
+  6.3331015649e-25, /* 0x17440000 */
+};
+
+static const float
+zero   = 0.0,
+one    = 1.0,
+two8   =  2.5600000000e+02, /* 0x43800000 */
+twon8  =  3.9062500000e-03; /* 0x3b800000 */
+
+int __kernel_rem_pio2f(float *x, float *y, int e0, int nx, int prec, const int32_t *ipio2)
+{
+	int32_t jz,jx,jv,jp,jk,carry,n,iq[20],i,j,k,m,q0,ih;
+	float z,fw,f[20],fq[20],q[20];
+
+    /* initialize jk*/
+	jk = init_jk[prec];
+	jp = jk;
+
+    /* determine jx,jv,q0, note that 3>q0 */
+	jx =  nx-1;
+	jv = (e0-3)/8; if(jv<0) jv=0;
+	q0 =  e0-8*(jv+1);
+
+    /* set up f[0] to f[jx+jk] where f[jx+jk] = ipio2[jv+jk] */
+	j = jv-jx; m = jx+jk;
+	for(i=0;i<=m;i++,j++) f[i] = (j<0)? zero : (float) ipio2[j];
+
+    /* compute q[0],q[1],...q[jk] */
+	for (i=0;i<=jk;i++) {
+	    for(j=0,fw=0.0;j<=jx;j++)
+		fw += x[j]*f[jx+i-j];
+	    q[i] = fw;
+	}
+
+	jz = jk;
+recompute:
+    /* distill q[] into iq[] reversingly */
+	for(i=0,j=jz,z=q[jz];j>0;i++,j--) {
+	    fw    =  (float)((int32_t)(twon8* z));
+	    iq[i] =  (int32_t)(z-two8*fw);
+	    z     =  q[j-1]+fw;
+	}
+
+    /* compute n */
+	z  = __scalbnf(z,q0);		/* actual value of z */
+	z -= (float)8.0*__floorf(z*(float)0.125);	/* trim off integer >= 8 */
+	n  = (int32_t) z;
+	z -= (float)n;
+	ih = 0;
+	if(q0>0) {	/* need iq[jz-1] to determine n */
+	    i  = (iq[jz-1]>>(8-q0)); n += i;
+	    iq[jz-1] -= i<<(8-q0);
+	    ih = iq[jz-1]>>(7-q0);
+	}
+	else if(q0==0) ih = iq[jz-1]>>7;
+	else if(z>=(float)0.5) ih=2;
+
+	if(ih>0) {	/* q > 0.5 */
+	    n += 1; carry = 0;
+	    for(i=0;i<jz ;i++) {	/* compute 1-q */
+		j = iq[i];
+		if(carry==0) {
+		    if(j!=0) {
+			carry = 1; iq[i] = 0x100- j;
+		    }
+		} else  iq[i] = 0xff - j;
+	    }
+	    if(q0>0) {		/* rare case: chance is 1 in 12 */
+	        switch(q0) {
+	        case 1:
+		   iq[jz-1] &= 0x7f; break;
+		case 2:
+		   iq[jz-1] &= 0x3f; break;
+	        }
+	    }
+	    if(ih==2) {
+		z = one - z;
+		if(carry!=0) z -= __scalbnf(one,q0);
+	    }
+	}
+
+    /* check if recomputation is needed */
+	if(z==zero) {
+	    j = 0;
+	    for (i=jz-1;i>=jk;i--) j |= iq[i];
+	    if(j==0) { /* need recomputation */
+		/* On s390x gcc 6.1 -O3 produces the warning "array subscript is
+		   below array bounds [-Werror=array-bounds]".  Only
+		   __ieee754_rem_pio2f calls __kernel_rem_pio2f for normal
+		   numbers and |x| ~> 2^7*(pi/2).  Thus x can't be zero and
+		   ipio2 is not zero, too.  Thus not all iq[] values can't be
+		   zero.  */
+		DIAG_PUSH_NEEDS_COMMENT;
+		DIAG_IGNORE_NEEDS_COMMENT (6.1, "-Warray-bounds");
+		for(k=1;iq[jk-k]==0;k++);   /* k = no. of terms needed */
+		DIAG_POP_NEEDS_COMMENT;
+
+		for(i=jz+1;i<=jz+k;i++) {   /* add q[jz+1] to q[jz+k] */
+		    f[jx+i] = (float) ipio2[jv+i];
+		    for(j=0,fw=0.0;j<=jx;j++) fw += x[j]*f[jx+i-j];
+		    q[i] = fw;
+		}
+		jz += k;
+		goto recompute;
+	    }
+	}
+
+    /* chop off zero terms */
+	if(z==(float)0.0) {
+	    jz -= 1; q0 -= 8;
+	    while(iq[jz]==0) { jz--; q0-=8;}
+	} else { /* break z into 8-bit if necessary */
+	    z = __scalbnf(z,-q0);
+	    if(z>=two8) {
+		fw = (float)((int32_t)(twon8*z));
+		iq[jz] = (int32_t)(z-two8*fw);
+		jz += 1; q0 += 8;
+		iq[jz] = (int32_t) fw;
+	    } else iq[jz] = (int32_t) z ;
+	}
+
+    /* convert integer "bit" chunk to floating-point value */
+	fw = __scalbnf(one,q0);
+	for(i=jz;i>=0;i--) {
+	    q[i] = fw*(float)iq[i]; fw*=twon8;
+	}
+
+    /* compute PIo2[0,...,jp]*q[jz,...,0] */
+	for(i=jz;i>=0;i--) {
+	    for(fw=0.0,k=0;k<=jp&&k<=jz-i;k++) fw += PIo2[k]*q[i+k];
+	    fq[jz-i] = fw;
+	}
+
+    /* compress fq[] into y[] */
+	switch(prec) {
+	    case 0:
+		fw = 0.0;
+		for (i=jz;i>=0;i--) fw += fq[i];
+		y[0] = (ih==0)? fw: -fw;
+		break;
+	    case 1:
+	    case 2:;
+		float fv = 0.0;
+		for (i=jz;i>=0;i--) fv = math_narrow_eval (fv + fq[i]);
+		y[0] = (ih==0)? fv: -fv;
+		fv = math_narrow_eval (fq[0]-fv);
+		for (i=1;i<=jz;i++) fv = math_narrow_eval (fv + fq[i]);
+		y[1] = (ih==0)? fv: -fv;
+		break;
+	    case 3:	/* painful */
+		for (i=jz;i>0;i--) {
+		    float fv = math_narrow_eval (fq[i-1]+fq[i]);
+		    fq[i]  += fq[i-1]-fv;
+		    fq[i-1] = fv;
+		}
+		for (i=jz;i>1;i--) {
+		    float fv = math_narrow_eval (fq[i-1]+fq[i]);
+		    fq[i]  += fq[i-1]-fv;
+		    fq[i-1] = fv;
+		}
+		for (fw=0.0,i=jz;i>=2;i--) fw += fq[i];
+		if(ih==0) {
+		    y[0] =  fq[0]; y[1] =  fq[1]; y[2] =  fw;
+		} else {
+		    y[0] = -fq[0]; y[1] = -fq[1]; y[2] = -fw;
+		}
+	}
+	return n&7;
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/k_sinf.c b/REORG.TODO/sysdeps/ieee754/flt-32/k_sinf.c
new file mode 100644
index 0000000000..a195d59466
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/k_sinf.c
@@ -0,0 +1,50 @@
+/* k_sinf.c -- float version of k_sin.c
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: k_sinf.c,v 1.4 1995/05/10 20:46:33 jtc Exp $";
+#endif
+
+#include <float.h>
+#include <math.h>
+#include <math_private.h>
+
+static const float
+half =  5.0000000000e-01,/* 0x3f000000 */
+S1  = -1.6666667163e-01, /* 0xbe2aaaab */
+S2  =  8.3333337680e-03, /* 0x3c088889 */
+S3  = -1.9841270114e-04, /* 0xb9500d01 */
+S4  =  2.7557314297e-06, /* 0x3638ef1b */
+S5  = -2.5050759689e-08, /* 0xb2d72f34 */
+S6  =  1.5896910177e-10; /* 0x2f2ec9d3 */
+
+float __kernel_sinf(float x, float y, int iy)
+{
+	float z,r,v;
+	int32_t ix;
+	GET_FLOAT_WORD(ix,x);
+	ix &= 0x7fffffff;			/* high word of x */
+	if(ix<0x32000000)			/* |x| < 2**-27 */
+	  {
+	    math_check_force_underflow (x);
+	    if ((int) x == 0)
+	      return x;		/* generate inexact */
+	  }
+	z	=  x*x;
+	v	=  z*x;
+	r	=  S2+z*(S3+z*(S4+z*(S5+z*S6)));
+	if(iy==0) return x+v*(S1+z*r);
+	else      return x-((z*(half*y-v*r)-y)-v*S1);
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/k_tanf.c b/REORG.TODO/sysdeps/ieee754/flt-32/k_tanf.c
new file mode 100644
index 0000000000..9f0e55860f
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/k_tanf.c
@@ -0,0 +1,101 @@
+/* k_tanf.c -- float version of k_tan.c
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: k_tanf.c,v 1.4 1995/05/10 20:46:39 jtc Exp $";
+#endif
+
+#include <float.h>
+#include <math.h>
+#include <math_private.h>
+static const float
+one   =  1.0000000000e+00, /* 0x3f800000 */
+pio4  =  7.8539812565e-01, /* 0x3f490fda */
+pio4lo=  3.7748947079e-08, /* 0x33222168 */
+T[] =  {
+  3.3333334327e-01, /* 0x3eaaaaab */
+  1.3333334029e-01, /* 0x3e088889 */
+  5.3968254477e-02, /* 0x3d5d0dd1 */
+  2.1869488060e-02, /* 0x3cb327a4 */
+  8.8632395491e-03, /* 0x3c11371f */
+  3.5920790397e-03, /* 0x3b6b6916 */
+  1.4562094584e-03, /* 0x3abede48 */
+  5.8804126456e-04, /* 0x3a1a26c8 */
+  2.4646313977e-04, /* 0x398137b9 */
+  7.8179444245e-05, /* 0x38a3f445 */
+  7.1407252108e-05, /* 0x3895c07a */
+ -1.8558637748e-05, /* 0xb79bae5f */
+  2.5907305826e-05, /* 0x37d95384 */
+};
+
+float __kernel_tanf(float x, float y, int iy)
+{
+	float z,r,v,w,s;
+	int32_t ix,hx;
+	GET_FLOAT_WORD(hx,x);
+	ix = hx&0x7fffffff;	/* high word of |x| */
+	if(ix<0x39000000)			/* x < 2**-13 */
+	    {if((int)x==0) {			/* generate inexact */
+		if((ix|(iy+1))==0) return one/fabsf(x);
+		else if (iy == 1)
+		  {
+		    math_check_force_underflow (x);
+		    return x;
+		  }
+		else
+		  return -one / x;
+	    }
+	    }
+	if(ix>=0x3f2ca140) { 			/* |x|>=0.6744 */
+	    if(hx<0) {x = -x; y = -y;}
+	    z = pio4-x;
+	    w = pio4lo-y;
+	    x = z+w; y = 0.0;
+	    if (fabsf (x) < 0x1p-13f)
+		return (1 - ((hx >> 30) & 2)) * iy * (1.0f - 2 * iy * x);
+	}
+	z	=  x*x;
+	w 	=  z*z;
+    /* Break x^5*(T[1]+x^2*T[2]+...) into
+     *	  x^5(T[1]+x^4*T[3]+...+x^20*T[11]) +
+     *	  x^5(x^2*(T[2]+x^4*T[4]+...+x^22*[T12]))
+     */
+	r = T[1]+w*(T[3]+w*(T[5]+w*(T[7]+w*(T[9]+w*T[11]))));
+	v = z*(T[2]+w*(T[4]+w*(T[6]+w*(T[8]+w*(T[10]+w*T[12])))));
+	s = z*x;
+	r = y + z*(s*(r+v)+y);
+	r += T[0]*s;
+	w = x+r;
+	if(ix>=0x3f2ca140) {
+	    v = (float)iy;
+	    return (float)(1-((hx>>30)&2))*(v-(float)2.0*(x-(w*w/(w+v)-r)));
+	}
+	if(iy==1) return w;
+	else {		/* if allow error up to 2 ulp,
+			   simply return -1.0/(x+r) here */
+     /*  compute -1.0/(x+r) accurately */
+	    float a,t;
+	    int32_t i;
+	    z  = w;
+	    GET_FLOAT_WORD(i,z);
+	    SET_FLOAT_WORD(z,i&0xfffff000);
+	    v  = r-(z - x); 	/* z+v = r+x */
+	    t = a  = -(float)1.0/w;	/* a = -1.0/w */
+	    GET_FLOAT_WORD(i,t);
+	    SET_FLOAT_WORD(t,i&0xfffff000);
+	    s  = (float)1.0+t*z;
+	    return t+a*(s+t*v);
+	}
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/lgamma_negf.c b/REORG.TODO/sysdeps/ieee754/flt-32/lgamma_negf.c
new file mode 100644
index 0000000000..71bcbb0f9d
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/lgamma_negf.c
@@ -0,0 +1,280 @@
+/* lgammaf expanding around zeros.
+   Copyright (C) 2015-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <float.h>
+#include <math.h>
+#include <math_private.h>
+
+static const float lgamma_zeros[][2] =
+  {
+    { -0x2.74ff94p+0f, 0x1.3fe0f2p-24f },
+    { -0x2.bf682p+0f, -0x1.437b2p-24f },
+    { -0x3.24c1b8p+0f, 0x6.c34cap-28f },
+    { -0x3.f48e2cp+0f, 0x1.707a04p-24f },
+    { -0x4.0a13ap+0f, 0x1.e99aap-24f },
+    { -0x4.fdd5ep+0f, 0x1.64454p-24f },
+    { -0x5.021a98p+0f, 0x2.03d248p-24f },
+    { -0x5.ffa4cp+0f, 0x2.9b82fcp-24f },
+    { -0x6.005ac8p+0f, -0x1.625f24p-24f },
+    { -0x6.fff3p+0f, 0x2.251e44p-24f },
+    { -0x7.000dp+0f, 0x8.48078p-28f },
+    { -0x7.fffe6p+0f, 0x1.fa98c4p-28f },
+    { -0x8.0001ap+0f, -0x1.459fcap-28f },
+    { -0x8.ffffdp+0f, -0x1.c425e8p-24f },
+    { -0x9.00003p+0f, 0x1.c44b82p-24f },
+    { -0xap+0f, 0x4.9f942p-24f },
+    { -0xap+0f, -0x4.9f93b8p-24f },
+    { -0xbp+0f, 0x6.b9916p-28f },
+    { -0xbp+0f, -0x6.b9915p-28f },
+    { -0xcp+0f, 0x8.f76c8p-32f },
+    { -0xcp+0f, -0x8.f76c7p-32f },
+    { -0xdp+0f, 0xb.09231p-36f },
+    { -0xdp+0f, -0xb.09231p-36f },
+    { -0xep+0f, 0xc.9cba5p-40f },
+    { -0xep+0f, -0xc.9cba5p-40f },
+    { -0xfp+0f, 0xd.73f9fp-44f },
+  };
+
+static const float e_hi = 0x2.b7e15p+0f, e_lo = 0x1.628aeep-24f;
+
+/* Coefficients B_2k / 2k(2k-1) of x^-(2k-1) in Stirling's
+   approximation to lgamma function.  */
+
+static const float lgamma_coeff[] =
+  {
+    0x1.555556p-4f,
+    -0xb.60b61p-12f,
+    0x3.403404p-12f,
+  };
+
+#define NCOEFF (sizeof (lgamma_coeff) / sizeof (lgamma_coeff[0]))
+
+/* Polynomial approximations to (|gamma(x)|-1)(x-n)/(x-x0), where n is
+   the integer end-point of the half-integer interval containing x and
+   x0 is the zero of lgamma in that half-integer interval.  Each
+   polynomial is expressed in terms of x-xm, where xm is the midpoint
+   of the interval for which the polynomial applies.  */
+
+static const float poly_coeff[] =
+  {
+    /* Interval [-2.125, -2] (polynomial degree 5).  */
+    -0x1.0b71c6p+0f,
+    -0xc.73a1ep-4f,
+    -0x1.ec8462p-4f,
+    -0xe.37b93p-4f,
+    -0x1.02ed36p-4f,
+    -0xe.cbe26p-4f,
+    /* Interval [-2.25, -2.125] (polynomial degree 5).  */
+    -0xf.29309p-4f,
+    -0xc.a5cfep-4f,
+    0x3.9c93fcp-4f,
+    -0x1.02a2fp+0f,
+    0x9.896bep-4f,
+    -0x1.519704p+0f,
+    /* Interval [-2.375, -2.25] (polynomial degree 5).  */
+    -0xd.7d28dp-4f,
+    -0xe.6964cp-4f,
+    0xb.0d4f1p-4f,
+    -0x1.9240aep+0f,
+    0x1.dadabap+0f,
+    -0x3.1778c4p+0f,
+    /* Interval [-2.5, -2.375] (polynomial degree 6).  */
+    -0xb.74ea2p-4f,
+    -0x1.2a82cp+0f,
+    0x1.880234p+0f,
+    -0x3.320c4p+0f,
+    0x5.572a38p+0f,
+    -0x9.f92bap+0f,
+    0x1.1c347ep+4f,
+    /* Interval [-2.625, -2.5] (polynomial degree 6).  */
+    -0x3.d10108p-4f,
+    0x1.cd5584p+0f,
+    0x3.819c24p+0f,
+    0x6.84cbb8p+0f,
+    0xb.bf269p+0f,
+    0x1.57fb12p+4f,
+    0x2.7b9854p+4f,
+    /* Interval [-2.75, -2.625] (polynomial degree 6).  */
+    -0x6.b5d25p-4f,
+    0x1.28d604p+0f,
+    0x1.db6526p+0f,
+    0x2.e20b38p+0f,
+    0x4.44c378p+0f,
+    0x6.62a08p+0f,
+    0x9.6db3ap+0f,
+    /* Interval [-2.875, -2.75] (polynomial degree 5).  */
+    -0x8.a41b2p-4f,
+    0xc.da87fp-4f,
+    0x1.147312p+0f,
+    0x1.7617dap+0f,
+    0x1.d6c13p+0f,
+    0x2.57a358p+0f,
+    /* Interval [-3, -2.875] (polynomial degree 5).  */
+    -0xa.046d6p-4f,
+    0x9.70b89p-4f,
+    0xa.a89a6p-4f,
+    0xd.2f2d8p-4f,
+    0xd.e32b4p-4f,
+    0xf.fb741p-4f,
+  };
+
+static const size_t poly_deg[] =
+  {
+    5,
+    5,
+    5,
+    6,
+    6,
+    6,
+    5,
+    5,
+  };
+
+static const size_t poly_end[] =
+  {
+    5,
+    11,
+    17,
+    24,
+    31,
+    38,
+    44,
+    50,
+  };
+
+/* Compute sin (pi * X) for -0.25 <= X <= 0.5.  */
+
+static float
+lg_sinpi (float x)
+{
+  if (x <= 0.25f)
+    return __sinf ((float) M_PI * x);
+  else
+    return __cosf ((float) M_PI * (0.5f - x));
+}
+
+/* Compute cos (pi * X) for -0.25 <= X <= 0.5.  */
+
+static float
+lg_cospi (float x)
+{
+  if (x <= 0.25f)
+    return __cosf ((float) M_PI * x);
+  else
+    return __sinf ((float) M_PI * (0.5f - x));
+}
+
+/* Compute cot (pi * X) for -0.25 <= X <= 0.5.  */
+
+static float
+lg_cotpi (float x)
+{
+  return lg_cospi (x) / lg_sinpi (x);
+}
+
+/* Compute lgamma of a negative argument -15 < X < -2, setting
+   *SIGNGAMP accordingly.  */
+
+float
+__lgamma_negf (float x, int *signgamp)
+{
+  /* Determine the half-integer region X lies in, handle exact
+     integers and determine the sign of the result.  */
+  int i = __floorf (-2 * x);
+  if ((i & 1) == 0 && i == -2 * x)
+    return 1.0f / 0.0f;
+  float xn = ((i & 1) == 0 ? -i / 2 : (-i - 1) / 2);
+  i -= 4;
+  *signgamp = ((i & 2) == 0 ? -1 : 1);
+
+  SET_RESTORE_ROUNDF (FE_TONEAREST);
+
+  /* Expand around the zero X0 = X0_HI + X0_LO.  */
+  float x0_hi = lgamma_zeros[i][0], x0_lo = lgamma_zeros[i][1];
+  float xdiff = x - x0_hi - x0_lo;
+
+  /* For arguments in the range -3 to -2, use polynomial
+     approximations to an adjusted version of the gamma function.  */
+  if (i < 2)
+    {
+      int j = __floorf (-8 * x) - 16;
+      float xm = (-33 - 2 * j) * 0.0625f;
+      float x_adj = x - xm;
+      size_t deg = poly_deg[j];
+      size_t end = poly_end[j];
+      float g = poly_coeff[end];
+      for (size_t j = 1; j <= deg; j++)
+	g = g * x_adj + poly_coeff[end - j];
+      return __log1pf (g * xdiff / (x - xn));
+    }
+
+  /* The result we want is log (sinpi (X0) / sinpi (X))
+     + log (gamma (1 - X0) / gamma (1 - X)).  */
+  float x_idiff = fabsf (xn - x), x0_idiff = fabsf (xn - x0_hi - x0_lo);
+  float log_sinpi_ratio;
+  if (x0_idiff < x_idiff * 0.5f)
+    /* Use log not log1p to avoid inaccuracy from log1p of arguments
+       close to -1.  */
+    log_sinpi_ratio = __ieee754_logf (lg_sinpi (x0_idiff)
+				      / lg_sinpi (x_idiff));
+  else
+    {
+      /* Use log1p not log to avoid inaccuracy from log of arguments
+	 close to 1.  X0DIFF2 has positive sign if X0 is further from
+	 XN than X is from XN, negative sign otherwise.  */
+      float x0diff2 = ((i & 1) == 0 ? xdiff : -xdiff) * 0.5f;
+      float sx0d2 = lg_sinpi (x0diff2);
+      float cx0d2 = lg_cospi (x0diff2);
+      log_sinpi_ratio = __log1pf (2 * sx0d2
+				  * (-sx0d2 + cx0d2 * lg_cotpi (x_idiff)));
+    }
+
+  float log_gamma_ratio;
+  float y0 = math_narrow_eval (1 - x0_hi);
+  float y0_eps = -x0_hi + (1 - y0) - x0_lo;
+  float y = math_narrow_eval (1 - x);
+  float y_eps = -x + (1 - y);
+  /* We now wish to compute LOG_GAMMA_RATIO
+     = log (gamma (Y0 + Y0_EPS) / gamma (Y + Y_EPS)).  XDIFF
+     accurately approximates the difference Y0 + Y0_EPS - Y -
+     Y_EPS.  Use Stirling's approximation.  */
+  float log_gamma_high
+    = (xdiff * __log1pf ((y0 - e_hi - e_lo + y0_eps) / e_hi)
+       + (y - 0.5f + y_eps) * __log1pf (xdiff / y));
+  /* Compute the sum of (B_2k / 2k(2k-1))(Y0^-(2k-1) - Y^-(2k-1)).  */
+  float y0r = 1 / y0, yr = 1 / y;
+  float y0r2 = y0r * y0r, yr2 = yr * yr;
+  float rdiff = -xdiff / (y * y0);
+  float bterm[NCOEFF];
+  float dlast = rdiff, elast = rdiff * yr * (yr + y0r);
+  bterm[0] = dlast * lgamma_coeff[0];
+  for (size_t j = 1; j < NCOEFF; j++)
+    {
+      float dnext = dlast * y0r2 + elast;
+      float enext = elast * yr2;
+      bterm[j] = dnext * lgamma_coeff[j];
+      dlast = dnext;
+      elast = enext;
+    }
+  float log_gamma_low = 0;
+  for (size_t j = 0; j < NCOEFF; j++)
+    log_gamma_low += bterm[NCOEFF - 1 - j];
+  log_gamma_ratio = log_gamma_high + log_gamma_low;
+
+  return log_sinpi_ratio + log_gamma_ratio;
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/lgamma_productf.c b/REORG.TODO/sysdeps/ieee754/flt-32/lgamma_productf.c
new file mode 100644
index 0000000000..1cc8931700
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/lgamma_productf.c
@@ -0,0 +1 @@
+/* Not needed.  */
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/mpn2flt.c b/REORG.TODO/sysdeps/ieee754/flt-32/mpn2flt.c
new file mode 100644
index 0000000000..abf6510f4e
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/mpn2flt.c
@@ -0,0 +1,41 @@
+/* Copyright (C) 1995-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include "gmp.h"
+#include "gmp-impl.h"
+#include <ieee754.h>
+#include <float.h>
+
+/* Convert a multi-precision integer of the needed number of bits (24 for
+   float) and an integral power of two to a `float' in IEEE754 single-
+   precision format.  */
+
+float
+__mpn_construct_float (mp_srcptr frac_ptr, int expt, int sign)
+{
+  union ieee754_float u;
+
+  u.ieee.negative = sign;
+  u.ieee.exponent = expt + IEEE754_FLOAT_BIAS;
+#if BITS_PER_MP_LIMB > FLT_MANT_DIG
+  u.ieee.mantissa = frac_ptr[0] & (((mp_limb_t) 1 << FLT_MANT_DIG) - 1);
+#else
+  #error "mp_limb size " BITS_PER_MP_LIMB "not accounted for"
+#endif
+
+  return u.f;
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_asinhf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_asinhf.c
new file mode 100644
index 0000000000..da9cafb600
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_asinhf.c
@@ -0,0 +1,50 @@
+/* s_asinhf.c -- float version of s_asinh.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <float.h>
+#include <math.h>
+#include <math_private.h>
+
+static const float
+one =  1.0000000000e+00, /* 0x3F800000 */
+ln2 =  6.9314718246e-01, /* 0x3f317218 */
+huge=  1.0000000000e+30;
+
+float
+__asinhf(float x)
+{
+	float w;
+	int32_t hx,ix;
+	GET_FLOAT_WORD(hx,x);
+	ix = hx&0x7fffffff;
+	if(__builtin_expect(ix< 0x38000000, 0)) {	/* |x|<2**-14 */
+	    math_check_force_underflow (x);
+	    if(huge+x>one) return x;	/* return x inexact except 0 */
+	}
+	if(__builtin_expect(ix>0x47000000, 0)) {	/* |x| > 2**14 */
+	    if(ix>=0x7f800000) return x+x;	/* x is inf or NaN */
+	    w = __ieee754_logf(fabsf(x))+ln2;
+	} else {
+	    float xa = fabsf(x);
+	    if (ix>0x40000000) {	/* 2**14 > |x| > 2.0 */
+		w = __ieee754_logf(2.0f*xa+one/(__ieee754_sqrtf(xa*xa+one)+xa));
+	    } else {		/* 2.0 > |x| > 2**-14 */
+		float t = xa*xa;
+		w =__log1pf(xa+t/(one+__ieee754_sqrtf(one+t)));
+	    }
+	}
+	return __copysignf(w, x);
+}
+weak_alias (__asinhf, asinhf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_atanf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_atanf.c
new file mode 100644
index 0000000000..e322a1d41f
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_atanf.c
@@ -0,0 +1,101 @@
+/* s_atanf.c -- float version of s_atan.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: s_atanf.c,v 1.4 1995/05/10 20:46:47 jtc Exp $";
+#endif
+
+#include <float.h>
+#include <math.h>
+#include <math_private.h>
+
+static const float atanhi[] = {
+  4.6364760399e-01, /* atan(0.5)hi 0x3eed6338 */
+  7.8539812565e-01, /* atan(1.0)hi 0x3f490fda */
+  9.8279368877e-01, /* atan(1.5)hi 0x3f7b985e */
+  1.5707962513e+00, /* atan(inf)hi 0x3fc90fda */
+};
+
+static const float atanlo[] = {
+  5.0121582440e-09, /* atan(0.5)lo 0x31ac3769 */
+  3.7748947079e-08, /* atan(1.0)lo 0x33222168 */
+  3.4473217170e-08, /* atan(1.5)lo 0x33140fb4 */
+  7.5497894159e-08, /* atan(inf)lo 0x33a22168 */
+};
+
+static const float aT[] = {
+  3.3333334327e-01, /* 0x3eaaaaaa */
+ -2.0000000298e-01, /* 0xbe4ccccd */
+  1.4285714924e-01, /* 0x3e124925 */
+ -1.1111110449e-01, /* 0xbde38e38 */
+  9.0908870101e-02, /* 0x3dba2e6e */
+ -7.6918758452e-02, /* 0xbd9d8795 */
+  6.6610731184e-02, /* 0x3d886b35 */
+ -5.8335702866e-02, /* 0xbd6ef16b */
+  4.9768779427e-02, /* 0x3d4bda59 */
+ -3.6531571299e-02, /* 0xbd15a221 */
+  1.6285819933e-02, /* 0x3c8569d7 */
+};
+
+static const float
+one   = 1.0,
+huge   = 1.0e30;
+
+float __atanf(float x)
+{
+	float w,s1,s2,z;
+	int32_t ix,hx,id;
+
+	GET_FLOAT_WORD(hx,x);
+	ix = hx&0x7fffffff;
+	if(ix>=0x4c000000) {	/* if |x| >= 2^25 */
+	    if(ix>0x7f800000)
+		return x+x;		/* NaN */
+	    if(hx>0) return  atanhi[3]+atanlo[3];
+	    else     return -atanhi[3]-atanlo[3];
+	} if (ix < 0x3ee00000) {	/* |x| < 0.4375 */
+	    if (ix < 0x31000000) {	/* |x| < 2^-29 */
+		math_check_force_underflow (x);
+		if(huge+x>one) return x;	/* raise inexact */
+	    }
+	    id = -1;
+	} else {
+	x = fabsf(x);
+	if (ix < 0x3f980000) {		/* |x| < 1.1875 */
+	    if (ix < 0x3f300000) {	/* 7/16 <=|x|<11/16 */
+		id = 0; x = ((float)2.0*x-one)/((float)2.0+x);
+	    } else {			/* 11/16<=|x|< 19/16 */
+		id = 1; x  = (x-one)/(x+one);
+	    }
+	} else {
+	    if (ix < 0x401c0000) {	/* |x| < 2.4375 */
+		id = 2; x  = (x-(float)1.5)/(one+(float)1.5*x);
+	    } else {			/* 2.4375 <= |x| < 2^66 */
+		id = 3; x  = -(float)1.0/x;
+	    }
+	}}
+    /* end of argument reduction */
+	z = x*x;
+	w = z*z;
+    /* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */
+	s1 = z*(aT[0]+w*(aT[2]+w*(aT[4]+w*(aT[6]+w*(aT[8]+w*aT[10])))));
+	s2 = w*(aT[1]+w*(aT[3]+w*(aT[5]+w*(aT[7]+w*aT[9]))));
+	if (id<0) return x - x*(s1+s2);
+	else {
+	    z = atanhi[id] - ((x*(s1+s2) - atanlo[id]) - x);
+	    return (hx<0)? -z:z;
+	}
+}
+weak_alias (__atanf, atanf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_cbrtf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_cbrtf.c
new file mode 100644
index 0000000000..1ac294c189
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_cbrtf.c
@@ -0,0 +1,63 @@
+/* Compute cubic root of float value.
+   Copyright (C) 1997-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Dirk Alboth <dirka@uni-paderborn.de> and
+   Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math.h>
+#include <math_private.h>
+
+
+#define CBRT2 1.2599210498948731648		/* 2^(1/3) */
+#define SQR_CBRT2 1.5874010519681994748		/* 2^(2/3) */
+
+static const double factor[5] =
+{
+  1.0 / SQR_CBRT2,
+  1.0 / CBRT2,
+  1.0,
+  CBRT2,
+  SQR_CBRT2
+};
+
+
+float
+__cbrtf (float x)
+{
+  float xm, ym, u, t2;
+  int xe;
+
+  /* Reduce X.  XM now is an range 1.0 to 0.5.  */
+  xm = __frexpf (fabsf (x), &xe);
+
+  /* If X is not finite or is null return it (with raising exceptions
+     if necessary.
+     Note: *Our* version of `frexp' sets XE to zero if the argument is
+     Inf or NaN.  This is not portable but faster.  */
+  if (xe == 0 && fpclassify (x) <= FP_ZERO)
+    return x + x;
+
+  u = (0.492659620528969547 + (0.697570460207922770
+			       - 0.191502161678719066 * xm) * xm);
+
+  t2 = u * u * u;
+
+  ym = u * (t2 + 2.0 * xm) / (2.0 * t2 + xm) * factor[2 + xe % 3];
+
+  return __ldexpf (x > 0.0 ? ym : -ym, xe / 3);
+}
+weak_alias (__cbrtf, cbrtf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_ceilf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_ceilf.c
new file mode 100644
index 0000000000..bff26c33cb
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_ceilf.c
@@ -0,0 +1,48 @@
+/* s_ceilf.c -- float version of s_ceil.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+
+float
+__ceilf(float x)
+{
+	int32_t i0,j0;
+	u_int32_t i;
+
+	GET_FLOAT_WORD(i0,x);
+	j0 = ((i0>>23)&0xff)-0x7f;
+	if(j0<23) {
+	    if(j0<0) {
+		/* return 0*sign(x) if |x|<1 */
+		if(i0<0) {i0=0x80000000;}
+		else if(i0!=0) { i0=0x3f800000;}
+	    } else {
+		i = (0x007fffff)>>j0;
+		if((i0&i)==0) return x; /* x is integral */
+		if(i0>0) i0 += (0x00800000)>>j0;
+		i0 &= (~i);
+	    }
+	} else {
+	    if(__builtin_expect(j0==0x80, 0)) return x+x; /* inf or NaN */
+	    else return x;		/* x is integral */
+	}
+	SET_FLOAT_WORD(x,i0);
+	return x;
+}
+#ifndef __ceilf
+weak_alias (__ceilf, ceilf)
+#endif
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_copysignf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_copysignf.c
new file mode 100644
index 0000000000..1621836065
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_copysignf.c
@@ -0,0 +1,37 @@
+/* s_copysignf.c -- float version of s_copysign.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: s_copysignf.c,v 1.4 1995/05/10 20:46:59 jtc Exp $";
+#endif
+
+/*
+ * copysignf(float x, float y)
+ * copysignf(x,y) returns a value with the magnitude of x and
+ * with the sign bit of y.
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+float __copysignf(float x, float y)
+{
+	u_int32_t ix,iy;
+	GET_FLOAT_WORD(ix,x);
+	GET_FLOAT_WORD(iy,y);
+	SET_FLOAT_WORD(x,(ix&0x7fffffff)|(iy&0x80000000));
+        return x;
+}
+weak_alias (__copysignf, copysignf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_cosf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_cosf.c
new file mode 100644
index 0000000000..0affd406bb
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_cosf.c
@@ -0,0 +1,63 @@
+/* s_cosf.c -- float version of s_cos.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: s_cosf.c,v 1.4 1995/05/10 20:47:03 jtc Exp $";
+#endif
+
+#include <errno.h>
+#include <math.h>
+#include <math_private.h>
+
+#ifndef COSF
+# define COSF_FUNC __cosf
+#else
+# define COSF_FUNC COSF
+#endif
+
+float COSF_FUNC(float x)
+{
+	float y[2],z=0.0;
+	int32_t n,ix;
+
+	GET_FLOAT_WORD(ix,x);
+
+    /* |x| ~< pi/4 */
+	ix &= 0x7fffffff;
+	if(ix <= 0x3f490fd8) return __kernel_cosf(x,z);
+
+    /* cos(Inf or NaN) is NaN */
+	else if (ix>=0x7f800000) {
+	  if (ix == 0x7f800000)
+	    __set_errno (EDOM);
+	  return x-x;
+	}
+
+    /* argument reduction needed */
+	else {
+	    n = __ieee754_rem_pio2f(x,y);
+	    switch(n&3) {
+		case 0: return  __kernel_cosf(y[0],y[1]);
+		case 1: return -__kernel_sinf(y[0],y[1],1);
+		case 2: return -__kernel_cosf(y[0],y[1]);
+		default:
+		        return  __kernel_sinf(y[0],y[1],1);
+	    }
+	}
+}
+
+#ifndef COSF
+weak_alias (__cosf, cosf)
+#endif
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_erff.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_erff.c
new file mode 100644
index 0000000000..c8b6287503
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_erff.c
@@ -0,0 +1,230 @@
+/* s_erff.c -- float version of s_erf.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: s_erff.c,v 1.4 1995/05/10 20:47:07 jtc Exp $";
+#endif
+
+#include <errno.h>
+#include <float.h>
+#include <math.h>
+#include <math_private.h>
+#include <fix-int-fp-convert-zero.h>
+
+static const float
+tiny	    = 1e-30,
+half=  5.0000000000e-01, /* 0x3F000000 */
+one =  1.0000000000e+00, /* 0x3F800000 */
+two =  2.0000000000e+00, /* 0x40000000 */
+	/* c = (subfloat)0.84506291151 */
+erx =  8.4506291151e-01, /* 0x3f58560b */
+/*
+ * Coefficients for approximation to  erf on [0,0.84375]
+ */
+efx =  1.2837916613e-01, /* 0x3e0375d4 */
+pp0  =  1.2837916613e-01, /* 0x3e0375d4 */
+pp1  = -3.2504209876e-01, /* 0xbea66beb */
+pp2  = -2.8481749818e-02, /* 0xbce9528f */
+pp3  = -5.7702702470e-03, /* 0xbbbd1489 */
+pp4  = -2.3763017452e-05, /* 0xb7c756b1 */
+qq1  =  3.9791721106e-01, /* 0x3ecbbbce */
+qq2  =  6.5022252500e-02, /* 0x3d852a63 */
+qq3  =  5.0813062117e-03, /* 0x3ba68116 */
+qq4  =  1.3249473704e-04, /* 0x390aee49 */
+qq5  = -3.9602282413e-06, /* 0xb684e21a */
+/*
+ * Coefficients for approximation to  erf  in [0.84375,1.25]
+ */
+pa0  = -2.3621185683e-03, /* 0xbb1acdc6 */
+pa1  =  4.1485610604e-01, /* 0x3ed46805 */
+pa2  = -3.7220788002e-01, /* 0xbebe9208 */
+pa3  =  3.1834661961e-01, /* 0x3ea2fe54 */
+pa4  = -1.1089469492e-01, /* 0xbde31cc2 */
+pa5  =  3.5478305072e-02, /* 0x3d1151b3 */
+pa6  = -2.1663755178e-03, /* 0xbb0df9c0 */
+qa1  =  1.0642088205e-01, /* 0x3dd9f331 */
+qa2  =  5.4039794207e-01, /* 0x3f0a5785 */
+qa3  =  7.1828655899e-02, /* 0x3d931ae7 */
+qa4  =  1.2617121637e-01, /* 0x3e013307 */
+qa5  =  1.3637083583e-02, /* 0x3c5f6e13 */
+qa6  =  1.1984500103e-02, /* 0x3c445aa3 */
+/*
+ * Coefficients for approximation to  erfc in [1.25,1/0.35]
+ */
+ra0  = -9.8649440333e-03, /* 0xbc21a093 */
+ra1  = -6.9385856390e-01, /* 0xbf31a0b7 */
+ra2  = -1.0558626175e+01, /* 0xc128f022 */
+ra3  = -6.2375331879e+01, /* 0xc2798057 */
+ra4  = -1.6239666748e+02, /* 0xc322658c */
+ra5  = -1.8460508728e+02, /* 0xc3389ae7 */
+ra6  = -8.1287437439e+01, /* 0xc2a2932b */
+ra7  = -9.8143291473e+00, /* 0xc11d077e */
+sa1  =  1.9651271820e+01, /* 0x419d35ce */
+sa2  =  1.3765776062e+02, /* 0x4309a863 */
+sa3  =  4.3456588745e+02, /* 0x43d9486f */
+sa4  =  6.4538726807e+02, /* 0x442158c9 */
+sa5  =  4.2900814819e+02, /* 0x43d6810b */
+sa6  =  1.0863500214e+02, /* 0x42d9451f */
+sa7  =  6.5702495575e+00, /* 0x40d23f7c */
+sa8  = -6.0424413532e-02, /* 0xbd777f97 */
+/*
+ * Coefficients for approximation to  erfc in [1/.35,28]
+ */
+rb0  = -9.8649431020e-03, /* 0xbc21a092 */
+rb1  = -7.9928326607e-01, /* 0xbf4c9dd4 */
+rb2  = -1.7757955551e+01, /* 0xc18e104b */
+rb3  = -1.6063638306e+02, /* 0xc320a2ea */
+rb4  = -6.3756646729e+02, /* 0xc41f6441 */
+rb5  = -1.0250950928e+03, /* 0xc480230b */
+rb6  = -4.8351919556e+02, /* 0xc3f1c275 */
+sb1  =  3.0338060379e+01, /* 0x41f2b459 */
+sb2  =  3.2579251099e+02, /* 0x43a2e571 */
+sb3  =  1.5367296143e+03, /* 0x44c01759 */
+sb4  =  3.1998581543e+03, /* 0x4547fdbb */
+sb5  =  2.5530502930e+03, /* 0x451f90ce */
+sb6  =  4.7452853394e+02, /* 0x43ed43a7 */
+sb7  = -2.2440952301e+01; /* 0xc1b38712 */
+
+float __erff(float x)
+{
+	int32_t hx,ix,i;
+	float R,S,P,Q,s,y,z,r;
+	GET_FLOAT_WORD(hx,x);
+	ix = hx&0x7fffffff;
+	if(ix>=0x7f800000) {		/* erf(nan)=nan */
+	    i = ((u_int32_t)hx>>31)<<1;
+	    return (float)(1-i)+one/x;	/* erf(+-inf)=+-1 */
+	}
+
+	if(ix < 0x3f580000) {		/* |x|<0.84375 */
+	    if(ix < 0x31800000) { 	/* |x|<2**-28 */
+	        if (ix < 0x04000000)
+		  {
+		    /* Avoid spurious underflow.  */
+		    float ret = 0.0625f * (16.0f * x + (16.0f * efx) * x);
+		    math_check_force_underflow (ret);
+		    return ret;
+		  }
+		return x + efx*x;
+	    }
+	    z = x*x;
+	    r = pp0+z*(pp1+z*(pp2+z*(pp3+z*pp4)));
+	    s = one+z*(qq1+z*(qq2+z*(qq3+z*(qq4+z*qq5))));
+	    y = r/s;
+	    return x + x*y;
+	}
+	if(ix < 0x3fa00000) {		/* 0.84375 <= |x| < 1.25 */
+	    s = fabsf(x)-one;
+	    P = pa0+s*(pa1+s*(pa2+s*(pa3+s*(pa4+s*(pa5+s*pa6)))));
+	    Q = one+s*(qa1+s*(qa2+s*(qa3+s*(qa4+s*(qa5+s*qa6)))));
+	    if(hx>=0) return erx + P/Q; else return -erx - P/Q;
+	}
+	if (ix >= 0x40c00000) {		/* inf>|x|>=6 */
+	    if(hx>=0) return one-tiny; else return tiny-one;
+	}
+	x = fabsf(x);
+ 	s = one/(x*x);
+	if(ix< 0x4036DB6E) {	/* |x| < 1/0.35 */
+	    R=ra0+s*(ra1+s*(ra2+s*(ra3+s*(ra4+s*(
+				ra5+s*(ra6+s*ra7))))));
+	    S=one+s*(sa1+s*(sa2+s*(sa3+s*(sa4+s*(
+				sa5+s*(sa6+s*(sa7+s*sa8)))))));
+	} else {	/* |x| >= 1/0.35 */
+	    R=rb0+s*(rb1+s*(rb2+s*(rb3+s*(rb4+s*(
+				rb5+s*rb6)))));
+	    S=one+s*(sb1+s*(sb2+s*(sb3+s*(sb4+s*(
+				sb5+s*(sb6+s*sb7))))));
+	}
+	GET_FLOAT_WORD(ix,x);
+	SET_FLOAT_WORD(z,ix&0xfffff000);
+	r  =  __ieee754_expf(-z*z-(float)0.5625)*__ieee754_expf((z-x)*(z+x)+R/S);
+	if(hx>=0) return one-r/x; else return  r/x-one;
+}
+weak_alias (__erff, erff)
+
+float __erfcf(float x)
+{
+	int32_t hx,ix;
+	float R,S,P,Q,s,y,z,r;
+	GET_FLOAT_WORD(hx,x);
+	ix = hx&0x7fffffff;
+	if(ix>=0x7f800000) {			/* erfc(nan)=nan */
+						/* erfc(+-inf)=0,2 */
+	    float ret = (float)(((u_int32_t)hx>>31)<<1)+one/x;
+	    if (FIX_INT_FP_CONVERT_ZERO && ret == 0.0f)
+	      return 0.0f;
+	    return ret;
+	}
+
+	if(ix < 0x3f580000) {		/* |x|<0.84375 */
+	    if(ix < 0x32800000)  	/* |x|<2**-26 */
+		return one-x;
+	    z = x*x;
+	    r = pp0+z*(pp1+z*(pp2+z*(pp3+z*pp4)));
+	    s = one+z*(qq1+z*(qq2+z*(qq3+z*(qq4+z*qq5))));
+	    y = r/s;
+	    if(hx < 0x3e800000) {  	/* x<1/4 */
+		return one-(x+x*y);
+	    } else {
+		r = x*y;
+		r += (x-half);
+	        return half - r ;
+	    }
+	}
+	if(ix < 0x3fa00000) {		/* 0.84375 <= |x| < 1.25 */
+	    s = fabsf(x)-one;
+	    P = pa0+s*(pa1+s*(pa2+s*(pa3+s*(pa4+s*(pa5+s*pa6)))));
+	    Q = one+s*(qa1+s*(qa2+s*(qa3+s*(qa4+s*(qa5+s*qa6)))));
+	    if(hx>=0) {
+	        z  = one-erx; return z - P/Q;
+	    } else {
+		z = erx+P/Q; return one+z;
+	    }
+	}
+	if (ix < 0x41e00000) {		/* |x|<28 */
+	    x = fabsf(x);
+ 	    s = one/(x*x);
+	    if(ix< 0x4036DB6D) {	/* |x| < 1/.35 ~ 2.857143*/
+	        R=ra0+s*(ra1+s*(ra2+s*(ra3+s*(ra4+s*(
+				ra5+s*(ra6+s*ra7))))));
+	        S=one+s*(sa1+s*(sa2+s*(sa3+s*(sa4+s*(
+				sa5+s*(sa6+s*(sa7+s*sa8)))))));
+	    } else {			/* |x| >= 1/.35 ~ 2.857143 */
+		if(hx<0&&ix>=0x40c00000) return two-tiny;/* x < -6 */
+	        R=rb0+s*(rb1+s*(rb2+s*(rb3+s*(rb4+s*(
+				rb5+s*rb6)))));
+	        S=one+s*(sb1+s*(sb2+s*(sb3+s*(sb4+s*(
+				sb5+s*(sb6+s*sb7))))));
+	    }
+	    GET_FLOAT_WORD(ix,x);
+	    SET_FLOAT_WORD(z,ix&0xffffe000);
+	    r  =  __ieee754_expf(-z*z-(float)0.5625)*
+			__ieee754_expf((z-x)*(z+x)+R/S);
+	    if(hx>0) {
+		float ret = math_narrow_eval (r/x);
+		if (ret == 0)
+		    __set_errno (ERANGE);
+		return ret;
+	    } else
+		return two-r/x;
+	} else {
+	    if(hx>0) {
+		__set_errno (ERANGE);
+		return tiny*tiny;
+	    } else
+		return two-tiny;
+	}
+}
+weak_alias (__erfcf, erfcf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_expm1f.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_expm1f.c
new file mode 100644
index 0000000000..c515d25e28
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_expm1f.c
@@ -0,0 +1,130 @@
+/* s_expm1f.c -- float version of s_expm1.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <errno.h>
+#include <float.h>
+#include <math.h>
+#include <math_private.h>
+
+static const float huge = 1.0e+30;
+static const float tiny = 1.0e-30;
+
+static const float
+one		= 1.0,
+o_threshold	= 8.8721679688e+01,/* 0x42b17180 */
+ln2_hi		= 6.9313812256e-01,/* 0x3f317180 */
+ln2_lo		= 9.0580006145e-06,/* 0x3717f7d1 */
+invln2		= 1.4426950216e+00,/* 0x3fb8aa3b */
+	/* scaled coefficients related to expm1 */
+Q1  =  -3.3333335072e-02, /* 0xbd088889 */
+Q2  =   1.5873016091e-03, /* 0x3ad00d01 */
+Q3  =  -7.9365076090e-05, /* 0xb8a670cd */
+Q4  =   4.0082177293e-06, /* 0x36867e54 */
+Q5  =  -2.0109921195e-07; /* 0xb457edbb */
+
+float
+__expm1f(float x)
+{
+	float y,hi,lo,c,t,e,hxs,hfx,r1;
+	int32_t k,xsb;
+	u_int32_t hx;
+
+	GET_FLOAT_WORD(hx,x);
+	xsb = hx&0x80000000;		/* sign bit of x */
+	if(xsb==0) y=x; else y= -x;	/* y = |x| */
+	hx &= 0x7fffffff;		/* high word of |x| */
+
+    /* filter out huge and non-finite argument */
+	if(hx >= 0x4195b844) {			/* if |x|>=27*ln2 */
+	    if(hx >= 0x42b17218) {		/* if |x|>=88.721... */
+		if(hx>0x7f800000)
+		    return x+x;		 /* NaN */
+		if(hx==0x7f800000)
+		    return (xsb==0)? x:-1.0;/* exp(+-inf)={inf,-1} */
+		if(x > o_threshold) {
+		  __set_errno (ERANGE);
+		  return huge*huge; /* overflow */
+		}
+	    }
+	    if(xsb!=0) { /* x < -27*ln2, return -1.0 with inexact */
+		math_force_eval(x+tiny);/* raise inexact */
+		return tiny-one;	/* return -1 */
+	    }
+	}
+
+    /* argument reduction */
+	if(hx > 0x3eb17218) {		/* if  |x| > 0.5 ln2 */
+	    if(hx < 0x3F851592) {	/* and |x| < 1.5 ln2 */
+		if(xsb==0)
+		    {hi = x - ln2_hi; lo =  ln2_lo;  k =  1;}
+		else
+		    {hi = x + ln2_hi; lo = -ln2_lo;  k = -1;}
+	    } else {
+		k  = invln2*x+((xsb==0)?(float)0.5:(float)-0.5);
+		t  = k;
+		hi = x - t*ln2_hi;	/* t*ln2_hi is exact here */
+		lo = t*ln2_lo;
+	    }
+	    x  = hi - lo;
+	    c  = (hi-x)-lo;
+	}
+	else if(hx < 0x33000000) {	/* when |x|<2**-25, return x */
+	    math_check_force_underflow (x);
+	    t = huge+x;	/* return x with inexact flags when x!=0 */
+	    return x - (t-(huge+x));
+	}
+	else k = 0;
+
+    /* x is now in primary range */
+	hfx = (float)0.5*x;
+	hxs = x*hfx;
+	r1 = one+hxs*(Q1+hxs*(Q2+hxs*(Q3+hxs*(Q4+hxs*Q5))));
+	t  = (float)3.0-r1*hfx;
+	e  = hxs*((r1-t)/((float)6.0 - x*t));
+	if(k==0) return x - (x*e-hxs);		/* c is 0 */
+	else {
+	    e  = (x*(e-c)-c);
+	    e -= hxs;
+	    if(k== -1) return (float)0.5*(x-e)-(float)0.5;
+	    if(k==1) {
+		if(x < (float)-0.25) return -(float)2.0*(e-(x+(float)0.5));
+		else	      return  one+(float)2.0*(x-e);
+	    }
+	    if (k <= -2 || k>56) {   /* suffice to return exp(x)-1 */
+		int32_t i;
+		y = one-(e-x);
+		GET_FLOAT_WORD(i,y);
+		SET_FLOAT_WORD(y,i+(k<<23));	/* add k to y's exponent */
+		return y-one;
+	    }
+	    t = one;
+	    if(k<23) {
+		int32_t i;
+		SET_FLOAT_WORD(t,0x3f800000 - (0x1000000>>k)); /* t=1-2^-k */
+		y = t-(e-x);
+		GET_FLOAT_WORD(i,y);
+		SET_FLOAT_WORD(y,i+(k<<23));	/* add k to y's exponent */
+	   } else {
+		int32_t i;
+		SET_FLOAT_WORD(t,((0x7f-k)<<23));	/* 2^-k */
+		y = x-(e+t);
+		y += one;
+		GET_FLOAT_WORD(i,y);
+		SET_FLOAT_WORD(y,i+(k<<23));	/* add k to y's exponent */
+	    }
+	}
+	return y;
+}
+weak_alias (__expm1f, expm1f)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_fabsf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_fabsf.c
new file mode 100644
index 0000000000..297abe64bd
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_fabsf.c
@@ -0,0 +1,30 @@
+/* s_fabsf.c -- float version of s_fabs.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: s_fabsf.c,v 1.4 1995/05/10 20:47:15 jtc Exp $";
+#endif
+
+/*
+ * fabsf(x) returns the absolute value of x.
+ */
+
+#include <math.h>
+
+float __fabsf(float x)
+{
+  return __builtin_fabsf (x);
+}
+weak_alias (__fabsf, fabsf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_finitef.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_finitef.c
new file mode 100644
index 0000000000..4c5b339235
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_finitef.c
@@ -0,0 +1,41 @@
+/* s_finitef.c -- float version of s_finite.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: s_finitef.c,v 1.4 1995/05/10 20:47:18 jtc Exp $";
+#endif
+
+/*
+ * finitef(x) returns 1 is x is finite, else 0;
+ * no branching!
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+#undef __finitef
+
+#ifndef FINITEF
+# define FINITEF __finitef
+#endif
+
+int FINITEF(float x)
+{
+	int32_t ix;
+	GET_FLOAT_WORD(ix,x);
+	return (int)((u_int32_t)((ix&0x7f800000)-0x7f800000)>>31);
+}
+hidden_def (__finitef)
+weak_alias (__finitef, finitef)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_floorf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_floorf.c
new file mode 100644
index 0000000000..69160e5e10
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_floorf.c
@@ -0,0 +1,54 @@
+/* s_floorf.c -- float version of s_floor.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+/*
+ * floorf(x)
+ * Return x rounded toward -inf to integral value
+ * Method:
+ *	Bit twiddling.
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+float
+__floorf(float x)
+{
+	int32_t i0,j0;
+	u_int32_t i;
+	GET_FLOAT_WORD(i0,x);
+	j0 = ((i0>>23)&0xff)-0x7f;
+	if(j0<23) {
+	    if(j0<0) {
+		/* return 0*sign(x) if |x|<1 */
+		if(i0>=0) {i0=0;}
+		else if((i0&0x7fffffff)!=0)
+		  { i0=0xbf800000;}
+	    } else {
+		i = (0x007fffff)>>j0;
+		if((i0&i)==0) return x; /* x is integral */
+		if(i0<0) i0 += (0x00800000)>>j0;
+		i0 &= (~i);
+	    }
+	} else {
+	    if(__builtin_expect(j0==0x80, 0)) return x+x; /* inf or NaN */
+	    else return x;		/* x is integral */
+	}
+	SET_FLOAT_WORD(x,i0);
+	return x;
+}
+#ifndef __floorf
+weak_alias (__floorf, floorf)
+#endif
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_fpclassifyf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_fpclassifyf.c
new file mode 100644
index 0000000000..8a67c6fc0e
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_fpclassifyf.c
@@ -0,0 +1,42 @@
+/* Return classification value corresponding to argument.
+   Copyright (C) 1997-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math.h>
+
+#include <math_private.h>
+
+
+int
+__fpclassifyf (float x)
+{
+  u_int32_t wx;
+  int retval = FP_NORMAL;
+
+  GET_FLOAT_WORD (wx, x);
+  wx &= 0x7fffffff;
+  if (wx == 0)
+    retval = FP_ZERO;
+  else if (wx < 0x800000)
+    retval = FP_SUBNORMAL;
+  else if (wx >= 0x7f800000)
+    retval = wx > 0x7f800000 ? FP_NAN : FP_INFINITE;
+
+  return retval;
+}
+libm_hidden_def (__fpclassifyf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_frexpf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_frexpf.c
new file mode 100644
index 0000000000..005367cf58
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_frexpf.c
@@ -0,0 +1,44 @@
+/* s_frexpf.c -- float version of s_frexp.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: s_frexpf.c,v 1.5 1995/05/10 20:47:26 jtc Exp $";
+#endif
+
+#include <math.h>
+#include <math_private.h>
+
+static const float
+two25 =  3.3554432000e+07; /* 0x4c000000 */
+
+float __frexpf(float x, int *eptr)
+{
+	int32_t hx,ix;
+	GET_FLOAT_WORD(hx,x);
+	ix = 0x7fffffff&hx;
+	*eptr = 0;
+	if(ix>=0x7f800000||(ix==0)) return x + x;	/* 0,inf,nan */
+	if (ix<0x00800000) {		/* subnormal */
+	    x *= two25;
+	    GET_FLOAT_WORD(hx,x);
+	    ix = hx&0x7fffffff;
+	    *eptr = -25;
+	}
+	*eptr += (ix>>23)-126;
+	hx = (hx&0x807fffff)|0x3f000000;
+	SET_FLOAT_WORD(x,hx);
+	return x;
+}
+weak_alias (__frexpf, frexpf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_fromfpf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_fromfpf.c
new file mode 100644
index 0000000000..68d4c80a17
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_fromfpf.c
@@ -0,0 +1,4 @@
+#define UNSIGNED 0
+#define INEXACT 0
+#define FUNC fromfpf
+#include <s_fromfpf_main.c>
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_fromfpf_main.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_fromfpf_main.c
new file mode 100644
index 0000000000..3a4ad80e55
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_fromfpf_main.c
@@ -0,0 +1,82 @@
+/* Round to integer type.  flt-32 version.
+   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <errno.h>
+#include <fenv.h>
+#include <math.h>
+#include <math_private.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#define BIAS 0x7f
+#define MANT_DIG 24
+
+#if UNSIGNED
+# define RET_TYPE uintmax_t
+#else
+# define RET_TYPE intmax_t
+#endif
+
+#include <fromfp.h>
+
+RET_TYPE
+FUNC (float x, int round, unsigned int width)
+{
+  if (width > INTMAX_WIDTH)
+    width = INTMAX_WIDTH;
+  uint32_t ix;
+  GET_FLOAT_WORD (ix, x);
+  bool negative = (ix & 0x80000000) != 0;
+  if (width == 0)
+    return fromfp_domain_error (negative, width);
+  ix &= 0x7fffffff;
+  if (ix == 0)
+    return 0;
+  int exponent = ix >> (MANT_DIG - 1);
+  exponent -= BIAS;
+  int max_exponent = fromfp_max_exponent (negative, width);
+  if (exponent > max_exponent)
+    return fromfp_domain_error (negative, width);
+
+  ix &= ((1U << (MANT_DIG - 1)) - 1);
+  ix |= 1U << (MANT_DIG - 1);
+  uintmax_t uret;
+  bool half_bit, more_bits;
+  if (exponent >= MANT_DIG - 1)
+    {
+      uret = ix;
+      uret <<= exponent - (MANT_DIG - 1);
+      half_bit = false;
+      more_bits = false;
+    }
+  else if (exponent >= -1)
+    {
+      uint32_t h = 1U << (MANT_DIG - 2 - exponent);
+      half_bit = (ix & h) != 0;
+      more_bits = (ix & (h - 1)) != 0;
+      uret = ix >> (MANT_DIG - 1 - exponent);
+    }
+  else
+    {
+      uret = 0;
+      half_bit = false;
+      more_bits = true;
+    }
+  return fromfp_round_and_return (negative, uret, half_bit, more_bits, round,
+				  exponent, max_exponent, width);
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_fromfpxf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_fromfpxf.c
new file mode 100644
index 0000000000..9d0fcbc8cc
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_fromfpxf.c
@@ -0,0 +1,4 @@
+#define UNSIGNED 0
+#define INEXACT 1
+#define FUNC fromfpxf
+#include <s_fromfpf_main.c>
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_getpayloadf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_getpayloadf.c
new file mode 100644
index 0000000000..90cfcc53b9
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_getpayloadf.c
@@ -0,0 +1,33 @@
+/* Get NaN payload.  flt-32 version.
+   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <fix-int-fp-convert-zero.h>
+#include <math.h>
+#include <math_private.h>
+#include <stdint.h>
+
+float
+getpayloadf (const float *x)
+{
+  uint32_t ix;
+  GET_FLOAT_WORD (ix, *x);
+  ix &= 0x3fffff;
+  if (FIX_INT_FP_CONVERT_ZERO && ix == 0)
+    return 0.0f;
+  return (float) ix;
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_isinff.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_isinff.c
new file mode 100644
index 0000000000..6eec050bb5
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_isinff.c
@@ -0,0 +1,29 @@
+/*
+ * Written by J.T. Conklin <jtc@netbsd.org>.
+ * Public domain.
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: s_isinff.c,v 1.3 1995/05/11 23:20:21 jtc Exp $";
+#endif
+
+/*
+ * isinff(x) returns 1 if x is inf, -1 if x is -inf, else 0;
+ * no branching!
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+int
+__isinff (float x)
+{
+	int32_t ix,t;
+	GET_FLOAT_WORD(ix,x);
+	t = ix & 0x7fffffff;
+	t ^= 0x7f800000;
+	t |= -t;
+	return ~(t >> 31) & (ix >> 30);
+}
+hidden_def (__isinff)
+weak_alias (__isinff, isinff)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_isnanf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_isnanf.c
new file mode 100644
index 0000000000..820b31a2b4
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_isnanf.c
@@ -0,0 +1,38 @@
+/* s_isnanf.c -- float version of s_isnan.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993, 2011 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: s_isnanf.c,v 1.4 1995/05/10 20:47:38 jtc Exp $";
+#endif
+
+/*
+ * isnanf(x) returns 1 is x is nan, else 0;
+ * no branching!
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+#undef __isnanf
+int __isnanf(float x)
+{
+	int32_t ix;
+	GET_FLOAT_WORD(ix,x);
+	ix &= 0x7fffffff;
+	ix = 0x7f800000 - ix;
+	return (int)(((u_int32_t)(ix))>>31);
+}
+hidden_def (__isnanf)
+weak_alias (__isnanf, isnanf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_issignalingf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_issignalingf.c
new file mode 100644
index 0000000000..cd9830eae2
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_issignalingf.c
@@ -0,0 +1,43 @@
+/* Test for signaling NaN.
+   Copyright (C) 2013-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math.h>
+#include <math_private.h>
+#include <nan-high-order-bit.h>
+
+int
+__issignalingf (float x)
+{
+  u_int32_t xi;
+  GET_FLOAT_WORD (xi, x);
+#if HIGH_ORDER_BIT_IS_SET_FOR_SNAN
+  /* We only have to care about the high-order bit of x's significand, because
+     having it set (sNaN) already makes the significand different from that
+     used to designate infinity.  */
+  return (xi & 0x7fc00000) == 0x7fc00000;
+#else
+  /* To keep the following comparison simple, toggle the quiet/signaling bit,
+     so that it is set for sNaNs.  This is inverse to IEEE 754-2008 (as well as
+     common practice for IEEE 754-1985).  */
+  xi ^= 0x00400000;
+  /* We have to compare for greater (instead of greater or equal), because x's
+     significand being all-zero designates infinity not NaN.  */
+  return (xi & 0x7fffffff) > 0x7fc00000;
+#endif
+}
+libm_hidden_def (__issignalingf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_llrintf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_llrintf.c
new file mode 100644
index 0000000000..e0ffbfee82
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_llrintf.c
@@ -0,0 +1,86 @@
+/* Round argument to nearest integral value according to current rounding
+   direction.
+   Copyright (C) 1997-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <fenv.h>
+#include <limits.h>
+#include <math.h>
+
+#include <math_private.h>
+#include <fix-fp-int-convert-overflow.h>
+
+static const float two23[2] =
+{
+  8.3886080000e+06, /* 0x4B000000 */
+ -8.3886080000e+06, /* 0xCB000000 */
+};
+
+
+long long int
+__llrintf (float x)
+{
+  int32_t j0;
+  u_int32_t i0;
+  float w;
+  float t;
+  long long int result;
+  int sx;
+
+  GET_FLOAT_WORD (i0, x);
+
+  sx = i0 >> 31;
+  j0 = ((i0 >> 23) & 0xff) - 0x7f;
+  i0 &= 0x7fffff;
+  i0 |= 0x800000;
+
+  if (j0 < (int32_t) (sizeof (long long int) * 8) - 1)
+    {
+      if (j0 >= 23)
+	result = (long long int) i0 << (j0 - 23);
+      else
+	{
+	  w = math_narrow_eval (two23[sx] + x);
+	  t = w - two23[sx];
+	  GET_FLOAT_WORD (i0, t);
+	  j0 = ((i0 >> 23) & 0xff) - 0x7f;
+	  i0 &= 0x7fffff;
+	  i0 |= 0x800000;
+
+	  result = (j0 < 0 ? 0 : i0 >> (23 - j0));
+	}
+    }
+  else
+    {
+#ifdef FE_INVALID
+      /* The number is too large.  Unless it rounds to LLONG_MIN,
+	 FE_INVALID must be raised and the return value is
+	 unspecified.  */
+      if (FIX_FLT_LLONG_CONVERT_OVERFLOW && x != (float) LLONG_MIN)
+	{
+	  feraiseexcept (FE_INVALID);
+	  return sx == 0 ? LLONG_MAX : LLONG_MIN;
+	}
+#endif
+      return (long long int) x;
+    }
+
+  return sx ? -result : result;
+}
+
+weak_alias (__llrintf, llrintf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_llroundf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_llroundf.c
new file mode 100644
index 0000000000..faee87b879
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_llroundf.c
@@ -0,0 +1,73 @@
+/* Round float value to long long int.
+   Copyright (C) 1997-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <fenv.h>
+#include <limits.h>
+#include <math.h>
+
+#include <math_private.h>
+#include <fix-fp-int-convert-overflow.h>
+
+
+long long int
+__llroundf (float x)
+{
+  int32_t j0;
+  u_int32_t i;
+  long long int result;
+  int sign;
+
+  GET_FLOAT_WORD (i, x);
+  j0 = ((i >> 23) & 0xff) - 0x7f;
+  sign = (i & 0x80000000) != 0 ? -1 : 1;
+  i &= 0x7fffff;
+  i |= 0x800000;
+
+  if (j0 < (int32_t) (8 * sizeof (long long int)) - 1)
+    {
+      if (j0 < 0)
+	return j0 < -1 ? 0 : sign;
+      else if (j0 >= 23)
+	result = (long long int) i << (j0 - 23);
+      else
+	{
+	  i += 0x400000 >> j0;
+
+	  result = i >> (23 - j0);
+	}
+    }
+  else
+    {
+#ifdef FE_INVALID
+      /* The number is too large.  Unless it rounds to LLONG_MIN,
+	 FE_INVALID must be raised and the return value is
+	 unspecified.  */
+      if (FIX_FLT_LLONG_CONVERT_OVERFLOW && x != (float) LLONG_MIN)
+	{
+	  feraiseexcept (FE_INVALID);
+	  return sign == 1 ? LLONG_MAX : LLONG_MIN;
+	}
+#endif
+      return (long long int) x;
+    }
+
+  return sign * result;
+}
+
+weak_alias (__llroundf, llroundf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_log1pf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_log1pf.c
new file mode 100644
index 0000000000..ade60a2e27
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_log1pf.c
@@ -0,0 +1,102 @@
+/* s_log1pf.c -- float version of s_log1p.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <float.h>
+#include <math.h>
+#include <math_private.h>
+
+static const float
+ln2_hi =   6.9313812256e-01,	/* 0x3f317180 */
+ln2_lo =   9.0580006145e-06,	/* 0x3717f7d1 */
+two25 =    3.355443200e+07,	/* 0x4c000000 */
+Lp1 = 6.6666668653e-01,	/* 3F2AAAAB */
+Lp2 = 4.0000000596e-01,	/* 3ECCCCCD */
+Lp3 = 2.8571429849e-01, /* 3E924925 */
+Lp4 = 2.2222198546e-01, /* 3E638E29 */
+Lp5 = 1.8183572590e-01, /* 3E3A3325 */
+Lp6 = 1.5313838422e-01, /* 3E1CD04F */
+Lp7 = 1.4798198640e-01; /* 3E178897 */
+
+static const float zero = 0.0;
+
+float
+__log1pf(float x)
+{
+	float hfsq,f,c,s,z,R,u;
+	int32_t k,hx,hu,ax;
+
+	GET_FLOAT_WORD(hx,x);
+	ax = hx&0x7fffffff;
+
+	k = 1;
+	if (hx < 0x3ed413d7) {			/* x < 0.41422  */
+	    if(ax>=0x3f800000) {		/* x <= -1.0 */
+		if(x==(float)-1.0) return -two25/zero; /* log1p(-1)=-inf */
+		else return (x-x)/(x-x);	/* log1p(x<-1)=NaN */
+	    }
+	    if(ax<0x31000000) {			/* |x| < 2**-29 */
+		math_force_eval(two25+x);	/* raise inexact */
+		if (ax<0x24800000)		/* |x| < 2**-54 */
+		  {
+		    math_check_force_underflow (x);
+		    return x;
+		  }
+		else
+		    return x - x*x*(float)0.5;
+	    }
+	    if(hx>0||hx<=((int32_t)0xbe95f61f)) {
+		k=0;f=x;hu=1;}	/* -0.2929<x<0.41422 */
+	}
+	if (hx >= 0x7f800000) return x+x;
+	if(k!=0) {
+	    if(hx<0x5a000000) {
+		u  = (float)1.0+x;
+		GET_FLOAT_WORD(hu,u);
+		k  = (hu>>23)-127;
+		/* correction term */
+		c  = (k>0)? (float)1.0-(u-x):x-(u-(float)1.0);
+		c /= u;
+	    } else {
+		u  = x;
+		GET_FLOAT_WORD(hu,u);
+		k  = (hu>>23)-127;
+		c  = 0;
+	    }
+	    hu &= 0x007fffff;
+	    if(hu<0x3504f7) {
+		SET_FLOAT_WORD(u,hu|0x3f800000);/* normalize u */
+	    } else {
+		k += 1;
+		SET_FLOAT_WORD(u,hu|0x3f000000);	/* normalize u/2 */
+		hu = (0x00800000-hu)>>2;
+	    }
+	    f = u-(float)1.0;
+	}
+	hfsq=(float)0.5*f*f;
+	if(hu==0) {	/* |f| < 2**-20 */
+	    if(f==zero) {
+		if(k==0) return zero;
+		else {c += k*ln2_lo; return k*ln2_hi+c;}
+	    }
+	    R = hfsq*((float)1.0-(float)0.66666666666666666*f);
+	    if(k==0) return f-R; else
+		     return k*ln2_hi-((R-(k*ln2_lo+c))-f);
+	}
+	s = f/((float)2.0+f);
+	z = s*s;
+	R = z*(Lp1+z*(Lp2+z*(Lp3+z*(Lp4+z*(Lp5+z*(Lp6+z*Lp7))))));
+	if(k==0) return f-(hfsq-s*(hfsq+R)); else
+		 return k*ln2_hi-((hfsq-(s*(hfsq+R)+(k*ln2_lo+c)))-f);
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_logbf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_logbf.c
new file mode 100644
index 0000000000..9ae20e332a
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_logbf.c
@@ -0,0 +1,41 @@
+/* s_logbf.c -- float version of s_logb.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+#include <fix-int-fp-convert-zero.h>
+
+float
+__logbf (float x)
+{
+  int32_t ix, rix;
+
+  GET_FLOAT_WORD (ix, x);
+  ix &= 0x7fffffff;		/* high |x| */
+  if (ix == 0)
+    return (float) -1.0 / fabsf (x);
+  if (ix >= 0x7f800000)
+    return x * x;
+  if (__glibc_unlikely ((rix = ix >> 23) == 0))
+    {
+      /* POSIX specifies that denormal number is treated as
+         though it were normalized.  */
+      rix -= __builtin_clz (ix) - 9;
+    }
+  if (FIX_INT_FP_CONVERT_ZERO && rix == 127)
+    return 0.0f;
+  return (float) (rix - 127);
+}
+weak_alias (__logbf, logbf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_lrintf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_lrintf.c
new file mode 100644
index 0000000000..a1ed720c0f
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_lrintf.c
@@ -0,0 +1,86 @@
+/* Round argument to nearest integral value according to current rounding
+   direction.
+   Copyright (C) 1997-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <fenv.h>
+#include <limits.h>
+#include <math.h>
+
+#include <math_private.h>
+#include <fix-fp-int-convert-overflow.h>
+
+static const float two23[2] =
+{
+  8.3886080000e+06, /* 0x4B000000 */
+ -8.3886080000e+06, /* 0xCB000000 */
+};
+
+
+long int
+__lrintf (float x)
+{
+  int32_t j0;
+  u_int32_t i0;
+  float w;
+  float t;
+  long int result;
+  int sx;
+
+  GET_FLOAT_WORD (i0, x);
+
+  sx = i0 >> 31;
+  j0 = ((i0 >> 23) & 0xff) - 0x7f;
+  i0 &= 0x7fffff;
+  i0 |= 0x800000;
+
+  if (j0 < (int32_t) (sizeof (long int) * 8) - 1)
+    {
+      if (j0 >= 23)
+	result = (long int) i0 << (j0 - 23);
+      else
+	{
+	  w = math_narrow_eval (two23[sx] + x);
+	  t = w - two23[sx];
+	  GET_FLOAT_WORD (i0, t);
+	  j0 = ((i0 >> 23) & 0xff) - 0x7f;
+	  i0 &= 0x7fffff;
+	  i0 |= 0x800000;
+
+	  result = (j0 < 0 ? 0 : i0 >> (23 - j0));
+	}
+    }
+  else
+    {
+#ifdef FE_INVALID
+      /* The number is too large.  Unless it rounds to LONG_MIN,
+	 FE_INVALID must be raised and the return value is
+	 unspecified.  */
+      if (FIX_FLT_LONG_CONVERT_OVERFLOW && x != (float) LONG_MIN)
+	{
+	  feraiseexcept (FE_INVALID);
+	  return sx == 0 ? LONG_MAX : LONG_MIN;
+	}
+#endif
+      return (long int) x;
+    }
+
+  return sx ? -result : result;
+}
+
+weak_alias (__lrintf, lrintf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_lroundf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_lroundf.c
new file mode 100644
index 0000000000..81cb7ab10f
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_lroundf.c
@@ -0,0 +1,73 @@
+/* Round float value to long int.
+   Copyright (C) 1997-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <fenv.h>
+#include <limits.h>
+#include <math.h>
+
+#include <math_private.h>
+#include <fix-fp-int-convert-overflow.h>
+
+
+long int
+__lroundf (float x)
+{
+  int32_t j0;
+  u_int32_t i;
+  long int result;
+  int sign;
+
+  GET_FLOAT_WORD (i, x);
+  j0 = ((i >> 23) & 0xff) - 0x7f;
+  sign = (i & 0x80000000) != 0 ? -1 : 1;
+  i &= 0x7fffff;
+  i |= 0x800000;
+
+  if (j0 < (int32_t) (8 * sizeof (long int)) - 1)
+    {
+      if (j0 < 0)
+	return j0 < -1 ? 0 : sign;
+      else if (j0 >= 23)
+	result = (long int) i << (j0 - 23);
+      else
+	{
+	  i += 0x400000 >> j0;
+
+	  result = i >> (23 - j0);
+	}
+    }
+  else
+    {
+#ifdef FE_INVALID
+      /* The number is too large.  Unless it rounds to LONG_MIN,
+	 FE_INVALID must be raised and the return value is
+	 unspecified.  */
+      if (FIX_FLT_LONG_CONVERT_OVERFLOW && x != (float) LONG_MIN)
+	{
+	  feraiseexcept (FE_INVALID);
+	  return sign == 1 ? LONG_MAX : LONG_MIN;
+	}
+#endif
+      return (long int) x;
+    }
+
+  return sign * result;
+}
+
+weak_alias (__lroundf, lroundf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_modff.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_modff.c
new file mode 100644
index 0000000000..23f6a902b3
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_modff.c
@@ -0,0 +1,54 @@
+/* s_modff.c -- float version of s_modf.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+static const float one = 1.0;
+
+float
+__modff(float x, float *iptr)
+{
+	int32_t i0,j0;
+	u_int32_t i;
+	GET_FLOAT_WORD(i0,x);
+	j0 = ((i0>>23)&0xff)-0x7f;	/* exponent of x */
+	if(__builtin_expect(j0<23, 1)) {		/* integer part in x */
+	    if(j0<0) {			/* |x|<1 */
+		SET_FLOAT_WORD(*iptr,i0&0x80000000);	/* *iptr = +-0 */
+		return x;
+	    } else {
+		i = (0x007fffff)>>j0;
+		if((i0&i)==0) {			/* x is integral */
+		    u_int32_t ix;
+		    *iptr = x;
+		    GET_FLOAT_WORD(ix,x);
+		    SET_FLOAT_WORD(x,ix&0x80000000);	/* return +-0 */
+		    return x;
+		} else {
+		    SET_FLOAT_WORD(*iptr,i0&(~i));
+		    return x - *iptr;
+		}
+	    }
+	} else {			/* no fraction part */
+	    *iptr = x*one;
+	    /* We must handle NaNs separately.  */
+	    if (j0 == 0x80 && (i0 & 0x7fffff))
+	      return x*one;
+	    SET_FLOAT_WORD(x,i0&0x80000000);	/* return +-0 */
+	    return x;
+	}
+}
+weak_alias (__modff, modff)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_nearbyintf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_nearbyintf.c
new file mode 100644
index 0000000000..5aebefafcf
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_nearbyintf.c
@@ -0,0 +1,59 @@
+/* s_rintf.c -- float version of s_rint.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+/* Adapted for use as nearbyint by Ulrich Drepper <drepper@cygnus.com>.  */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+
+#include <fenv.h>
+#include <math.h>
+#include <math_private.h>
+
+static const float
+TWO23[2]={
+  8.3886080000e+06, /* 0x4b000000 */
+ -8.3886080000e+06, /* 0xcb000000 */
+};
+
+float
+__nearbyintf(float x)
+{
+	fenv_t env;
+	int32_t i0,j0,sx;
+	float w,t;
+	GET_FLOAT_WORD(i0,x);
+	sx = (i0>>31)&1;
+	j0 = ((i0>>23)&0xff)-0x7f;
+	if(j0<23) {
+	    if(j0<0) {
+		libc_feholdexceptf (&env);
+		w = TWO23[sx]+x;
+		t =  w-TWO23[sx];
+		math_force_eval (t);
+		libc_fesetenvf (&env);
+		GET_FLOAT_WORD(i0,t);
+		SET_FLOAT_WORD(t,(i0&0x7fffffff)|(sx<<31));
+		return t;
+	    }
+	} else {
+	    if(__builtin_expect(j0==0x80, 0)) return x+x;	/* inf or NaN */
+	    else return x;		/* x is integral */
+	}
+	libc_feholdexceptf (&env);
+	w = TWO23[sx]+x;
+	t = w-TWO23[sx];
+	math_force_eval (t);
+	libc_fesetenvf (&env);
+	return t;
+}
+weak_alias (__nearbyintf, nearbyintf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_nextafterf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_nextafterf.c
new file mode 100644
index 0000000000..625d54b768
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_nextafterf.c
@@ -0,0 +1,73 @@
+/* s_nextafterf.c -- float version of s_nextafter.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: s_nextafterf.c,v 1.4 1995/05/10 20:48:01 jtc Exp $";
+#endif
+
+#include <errno.h>
+#include <math.h>
+#include <math_private.h>
+#include <float.h>
+
+float __nextafterf(float x, float y)
+{
+	int32_t hx,hy,ix,iy;
+
+	GET_FLOAT_WORD(hx,x);
+	GET_FLOAT_WORD(hy,y);
+	ix = hx&0x7fffffff;		/* |x| */
+	iy = hy&0x7fffffff;		/* |y| */
+
+	if((ix>0x7f800000) ||   /* x is nan */
+	   (iy>0x7f800000))     /* y is nan */
+	   return x+y;
+	if(x==y) return y;		/* x=y, return y */
+	if(ix==0) {				/* x == 0 */
+	    float u;
+	    SET_FLOAT_WORD(x,(hy&0x80000000)|1);/* return +-minsubnormal */
+	    u = math_opt_barrier (x);
+	    u = u*u;
+	    math_force_eval (u);		/* raise underflow flag */
+	    return x;
+	}
+	if(hx>=0) {				/* x > 0 */
+	    if(hx>hy) {				/* x > y, x -= ulp */
+		hx -= 1;
+	    } else {				/* x < y, x += ulp */
+		hx += 1;
+	    }
+	} else {				/* x < 0 */
+	    if(hy>=0||hx>hy){			/* x < y, x -= ulp */
+		hx -= 1;
+	    } else {				/* x > y, x += ulp */
+		hx += 1;
+	    }
+	}
+	hy = hx&0x7f800000;
+	if(hy>=0x7f800000) {
+	  float u = x+x;	/* overflow  */
+	  math_force_eval (u);
+	  __set_errno (ERANGE);
+	}
+	if(hy<0x00800000) {
+	    float u = x*x;			/* underflow */
+	    math_force_eval (u);		/* raise underflow flag */
+	    __set_errno (ERANGE);
+	}
+	SET_FLOAT_WORD(x,hx);
+	return x;
+}
+weak_alias (__nextafterf, nextafterf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_nextupf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_nextupf.c
new file mode 100644
index 0000000000..bbabdf1bd6
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_nextupf.c
@@ -0,0 +1,46 @@
+/* Return the least floating-point number greater than X.
+   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math.h>
+#include <math_private.h>
+
+/* Return the least floating-point number greater than X.  */
+float
+__nextupf (float x)
+{
+  int32_t hx, ix;
+
+  GET_FLOAT_WORD (hx, x);
+  ix = hx & 0x7fffffff;
+  if (ix == 0)
+    return FLT_TRUE_MIN;
+  if (ix > 0x7f800000)		/* x is nan.  */
+    return x + x;
+  if (hx >= 0)
+    {				/* x > 0.  */
+      if (isinf (x))
+        return x;
+      hx += 1;
+    }
+  else
+    hx -= 1;
+  SET_FLOAT_WORD (x, hx);
+  return x;
+}
+
+weak_alias (__nextupf, nextupf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_remquof.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_remquof.c
new file mode 100644
index 0000000000..8e398dc6c5
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_remquof.c
@@ -0,0 +1,110 @@
+/* Compute remainder and a congruent to the quotient.
+   Copyright (C) 1997-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math.h>
+
+#include <math_private.h>
+
+
+static const float zero = 0.0;
+
+
+float
+__remquof (float x, float y, int *quo)
+{
+  int32_t hx,hy;
+  u_int32_t sx;
+  int cquo, qs;
+
+  GET_FLOAT_WORD (hx, x);
+  GET_FLOAT_WORD (hy, y);
+  sx = hx & 0x80000000;
+  qs = sx ^ (hy & 0x80000000);
+  hy &= 0x7fffffff;
+  hx &= 0x7fffffff;
+
+  /* Purge off exception values.  */
+  if (hy == 0)
+    return (x * y) / (x * y); 			/* y = 0 */
+  if ((hx >= 0x7f800000)			/* x not finite */
+      || (hy > 0x7f800000))			/* y is NaN */
+    return (x * y) / (x * y);
+
+  if (hy <= 0x7dffffff)
+    x = __ieee754_fmodf (x, 8 * y);		/* now x < 8y */
+
+  if ((hx - hy) == 0)
+    {
+      *quo = qs ? -1 : 1;
+      return zero * x;
+    }
+
+  x  = fabsf (x);
+  y  = fabsf (y);
+  cquo = 0;
+
+  if (hy <= 0x7e7fffff && x >= 4 * y)
+    {
+      x -= 4 * y;
+      cquo += 4;
+    }
+  if (hy <= 0x7effffff && x >= 2 * y)
+    {
+      x -= 2 * y;
+      cquo += 2;
+    }
+
+  if (hy < 0x01000000)
+    {
+      if (x + x > y)
+	{
+	  x -= y;
+	  ++cquo;
+	  if (x + x >= y)
+	    {
+	      x -= y;
+	      ++cquo;
+	    }
+	}
+    }
+  else
+    {
+      float y_half = 0.5 * y;
+      if (x > y_half)
+	{
+	  x -= y;
+	  ++cquo;
+	  if (x >= y_half)
+	    {
+	      x -= y;
+	      ++cquo;
+	    }
+	}
+    }
+
+  *quo = qs ? -cquo : cquo;
+
+  /* Ensure correct sign of zero result in round-downward mode.  */
+  if (x == 0.0f)
+    x = 0.0f;
+  if (sx)
+    x = -x;
+  return x;
+}
+weak_alias (__remquof, remquof)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_rintf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_rintf.c
new file mode 100644
index 0000000000..8a907488f7
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_rintf.c
@@ -0,0 +1,50 @@
+/* s_rintf.c -- float version of s_rint.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+static const float
+TWO23[2]={
+  8.3886080000e+06, /* 0x4b000000 */
+ -8.3886080000e+06, /* 0xcb000000 */
+};
+
+float
+__rintf(float x)
+{
+	int32_t i0,j0,sx;
+	float w,t;
+	GET_FLOAT_WORD(i0,x);
+	sx = (i0>>31)&1;
+	j0 = ((i0>>23)&0xff)-0x7f;
+	if(j0<23) {
+	    if(j0<0) {
+		w = TWO23[sx]+x;
+		t =  w-TWO23[sx];
+		GET_FLOAT_WORD(i0,t);
+		SET_FLOAT_WORD(t,(i0&0x7fffffff)|(sx<<31));
+		return t;
+	    }
+	} else {
+	    if(j0==0x80) return x+x;	/* inf or NaN */
+	    else return x;		/* x is integral */
+	}
+	w = TWO23[sx]+x;
+	return w-TWO23[sx];
+}
+#ifndef __rintf
+weak_alias (__rintf, rintf)
+#endif
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_roundevenf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_roundevenf.c
new file mode 100644
index 0000000000..4a8c2624bb
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_roundevenf.c
@@ -0,0 +1,68 @@
+/* Round to nearest integer value, rounding halfway cases to even.
+   flt-32 version.
+   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math.h>
+#include <math_private.h>
+#include <stdint.h>
+
+#define BIAS 0x7f
+#define MANT_DIG 24
+#define MAX_EXP (2 * BIAS + 1)
+
+float
+roundevenf (float x)
+{
+  uint32_t ix, ux;
+  GET_FLOAT_WORD (ix, x);
+  ux = ix & 0x7fffffff;
+  int exponent = ux >> (MANT_DIG - 1);
+  if (exponent >= BIAS + MANT_DIG - 1)
+    {
+      /* Integer, infinity or NaN.  */
+      if (exponent == MAX_EXP)
+	/* Infinity or NaN; quiet signaling NaNs.  */
+	return x + x;
+      else
+	return x;
+    }
+  else if (exponent >= BIAS)
+    {
+      /* At least 1; not necessarily an integer.  Locate the bits with
+	 exponents 0 and -1 (when the unbiased exponent is 0, the bit
+	 with exponent 0 is implicit, but as the bias is odd it is OK
+	 to take it from the low bit of the exponent).  */
+      int int_pos = (BIAS + MANT_DIG - 1) - exponent;
+      int half_pos = int_pos - 1;
+      uint32_t half_bit = 1U << half_pos;
+      uint32_t int_bit = 1U << int_pos;
+      if ((ix & (int_bit | (half_bit - 1))) != 0)
+	/* Carry into the exponent works correctly.  No need to test
+	   whether HALF_BIT is set.  */
+	ix += half_bit;
+      ix &= ~(int_bit - 1);
+    }
+  else if (exponent == BIAS - 1 && ux > 0x3f000000)
+    /* Interval (0.5, 1).  */
+    ix = (ix & 0x80000000) | 0x3f800000;
+  else
+    /* Rounds to 0.  */
+    ix &= 0x80000000;
+  SET_FLOAT_WORD (x, ix);
+  return x;
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_roundf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_roundf.c
new file mode 100644
index 0000000000..7ea0d97756
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_roundf.c
@@ -0,0 +1,63 @@
+/* Round float to integer away from zero.
+   Copyright (C) 1997-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math.h>
+
+#include <math_private.h>
+
+
+float
+__roundf (float x)
+{
+  int32_t i0, j0;
+
+  GET_FLOAT_WORD (i0, x);
+  j0 = ((i0 >> 23) & 0xff) - 0x7f;
+  if (j0 < 23)
+    {
+      if (j0 < 0)
+	{
+	  i0 &= 0x80000000;
+	  if (j0 == -1)
+	    i0 |= 0x3f800000;
+	}
+      else
+	{
+	  u_int32_t i = 0x007fffff >> j0;
+	  if ((i0 & i) == 0)
+	    /* X is integral.  */
+	    return x;
+
+	  i0 += 0x00400000 >> j0;
+	  i0 &= ~i;
+	}
+    }
+  else
+    {
+      if (j0 == 0x80)
+	/* Inf or NaN.  */
+	return x + x;
+      else
+	return x;
+    }
+
+  SET_FLOAT_WORD (x, i0);
+  return x;
+}
+weak_alias (__roundf, roundf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_scalblnf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_scalblnf.c
new file mode 100644
index 0000000000..ad3c586b33
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_scalblnf.c
@@ -0,0 +1,52 @@
+/* s_scalbnf.c -- float version of s_scalbn.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+static const float
+two25   =  3.355443200e+07,	/* 0x4c000000 */
+twom25  =  2.9802322388e-08,	/* 0x33000000 */
+huge   = 1.0e+30,
+tiny   = 1.0e-30;
+
+float
+__scalblnf (float x, long int n)
+{
+	int32_t k,ix;
+	GET_FLOAT_WORD(ix,x);
+	k = (ix&0x7f800000)>>23;		/* extract exponent */
+	if (__builtin_expect(k==0, 0)) {	/* 0 or subnormal x */
+	    if ((ix&0x7fffffff)==0) return x; /* +-0 */
+	    x *= two25;
+	    GET_FLOAT_WORD(ix,x);
+	    k = ((ix&0x7f800000)>>23) - 25;
+	    }
+	if (__builtin_expect(k==0xff, 0)) return x+x;	/* NaN or Inf */
+	if (__builtin_expect(n< -50000, 0))
+	  return tiny*copysignf(tiny,x);	/*underflow*/
+	if (__builtin_expect(n> 50000 || k+n > 0xfe, 0))
+	  return huge*copysignf(huge,x); /* overflow  */
+	/* Now k and n are bounded we know that k = k+n does not
+	   overflow.  */
+	k = k+n;
+	if (__builtin_expect(k > 0, 1))		/* normal result */
+	    {SET_FLOAT_WORD(x,(ix&0x807fffff)|(k<<23)); return x;}
+	if (k <= -25)
+	    return tiny*copysignf(tiny,x);	/*underflow*/
+	k += 25;				/* subnormal result */
+	SET_FLOAT_WORD(x,(ix&0x807fffff)|(k<<23));
+	return x*twom25;
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_scalbnf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_scalbnf.c
new file mode 100644
index 0000000000..f36ae241b2
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_scalbnf.c
@@ -0,0 +1,52 @@
+/* s_scalbnf.c -- float version of s_scalbn.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#include <math.h>
+#include <math_private.h>
+
+static const float
+two25   =  3.355443200e+07,	/* 0x4c000000 */
+twom25  =  2.9802322388e-08,	/* 0x33000000 */
+huge   = 1.0e+30,
+tiny   = 1.0e-30;
+
+float
+__scalbnf (float x, int n)
+{
+	int32_t k,ix;
+	GET_FLOAT_WORD(ix,x);
+	k = (ix&0x7f800000)>>23;		/* extract exponent */
+	if (__builtin_expect(k==0, 0)) {	/* 0 or subnormal x */
+	    if ((ix&0x7fffffff)==0) return x; /* +-0 */
+	    x *= two25;
+	    GET_FLOAT_WORD(ix,x);
+	    k = ((ix&0x7f800000)>>23) - 25;
+	    }
+	if (__builtin_expect(k==0xff, 0)) return x+x;	/* NaN or Inf */
+	if (__builtin_expect(n< -50000, 0))
+	  return tiny*__copysignf(tiny,x);	/*underflow*/
+	if (__builtin_expect(n> 50000 || k+n > 0xfe, 0))
+	  return huge*__copysignf(huge,x); /* overflow  */
+	/* Now k and n are bounded we know that k = k+n does not
+	   overflow.  */
+	k = k+n;
+	if (__builtin_expect(k > 0, 1))		/* normal result */
+	    {SET_FLOAT_WORD(x,(ix&0x807fffff)|(k<<23)); return x;}
+	if (k <= -25)
+	    return tiny*__copysignf(tiny,x);	/*underflow*/
+	k += 25;				/* subnormal result */
+	SET_FLOAT_WORD(x,(ix&0x807fffff)|(k<<23));
+	return x*twom25;
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_setpayloadf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_setpayloadf.c
new file mode 100644
index 0000000000..86dfda9aa6
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_setpayloadf.c
@@ -0,0 +1,3 @@
+#define SIG 0
+#define FUNC setpayloadf
+#include <s_setpayloadf_main.c>
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_setpayloadf_main.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_setpayloadf_main.c
new file mode 100644
index 0000000000..8b046d6547
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_setpayloadf_main.c
@@ -0,0 +1,53 @@
+/* Set NaN payload.  flt-32 version.
+   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math.h>
+#include <math_private.h>
+#include <nan-high-order-bit.h>
+#include <stdint.h>
+
+#define SET_HIGH_BIT (HIGH_ORDER_BIT_IS_SET_FOR_SNAN ? SIG : !SIG)
+#define BIAS 0x7f
+#define PAYLOAD_DIG 22
+#define EXPLICIT_MANT_DIG 23
+
+int
+FUNC (float *x, float payload)
+{
+  uint32_t ix;
+  GET_FLOAT_WORD (ix, payload);
+  int exponent = ix >> EXPLICIT_MANT_DIG;
+  /* Test if argument is (a) negative or too large; (b) too small,
+     except for 0 when allowed; (c) not an integer.  */
+  if (exponent >= BIAS + PAYLOAD_DIG
+      || (exponent < BIAS && !(SET_HIGH_BIT && ix == 0))
+      || (ix & ((1U << (BIAS + EXPLICIT_MANT_DIG - exponent)) - 1)) != 0)
+    {
+      SET_FLOAT_WORD (*x, 0);
+      return 1;
+    }
+  if (ix != 0)
+    {
+      ix &= (1U << EXPLICIT_MANT_DIG) - 1;
+      ix |= 1U << EXPLICIT_MANT_DIG;
+      ix >>= BIAS + EXPLICIT_MANT_DIG - exponent;
+    }
+  ix |= 0x7f800000 | (SET_HIGH_BIT ? 0x400000 : 0);
+  SET_FLOAT_WORD (*x, ix);
+  return 0;
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_setpayloadsigf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_setpayloadsigf.c
new file mode 100644
index 0000000000..f7b335dac7
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_setpayloadsigf.c
@@ -0,0 +1,3 @@
+#define SIG 1
+#define FUNC setpayloadsigf
+#include <s_setpayloadf_main.c>
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_signbitf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_signbitf.c
new file mode 100644
index 0000000000..0f7e23d7f9
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_signbitf.c
@@ -0,0 +1,26 @@
+/* Return nonzero value if number is negative.
+   Copyright (C) 1997-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math.h>
+
+int
+__signbitf (float x)
+{
+  return __builtin_signbitf (x);
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_sincosf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_sincosf.c
new file mode 100644
index 0000000000..3ab92ee0ba
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_sincosf.c
@@ -0,0 +1,84 @@
+/* Compute sine and cosine of argument.
+   Copyright (C) 1997-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <errno.h>
+#include <math.h>
+
+#include <math_private.h>
+
+#ifndef SINCOSF
+# define SINCOSF_FUNC __sincosf
+#else
+# define SINCOSF_FUNC SINCOSF
+#endif
+
+void
+SINCOSF_FUNC (float x, float *sinx, float *cosx)
+{
+  int32_t ix;
+
+  /* High word of x. */
+  GET_FLOAT_WORD (ix, x);
+
+  /* |x| ~< pi/4 */
+  ix &= 0x7fffffff;
+  if (ix <= 0x3f490fd8)
+    {
+      *sinx = __kernel_sinf (x, 0.0, 0);
+      *cosx = __kernel_cosf (x, 0.0);
+    }
+  else if (ix>=0x7f800000)
+    {
+      /* sin(Inf or NaN) is NaN */
+      *sinx = *cosx = x - x;
+      if (ix == 0x7f800000)
+	__set_errno (EDOM);
+    }
+  else
+    {
+      /* Argument reduction needed.  */
+      float y[2];
+      int n;
+
+      n = __ieee754_rem_pio2f (x, y);
+      switch (n & 3)
+	{
+	case 0:
+	  *sinx = __kernel_sinf (y[0], y[1], 1);
+	  *cosx = __kernel_cosf (y[0], y[1]);
+	  break;
+	case 1:
+	  *sinx = __kernel_cosf (y[0], y[1]);
+	  *cosx = -__kernel_sinf (y[0], y[1], 1);
+	  break;
+	case 2:
+	  *sinx = -__kernel_sinf (y[0], y[1], 1);
+	  *cosx = -__kernel_cosf (y[0], y[1]);
+	  break;
+	default:
+	  *sinx = -__kernel_cosf (y[0], y[1]);
+	  *cosx = __kernel_sinf (y[0], y[1], 1);
+	  break;
+	}
+    }
+}
+
+#ifndef SINCOSF
+weak_alias (__sincosf, sincosf)
+#endif
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_sinf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_sinf.c
new file mode 100644
index 0000000000..916e345571
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_sinf.c
@@ -0,0 +1,63 @@
+/* s_sinf.c -- float version of s_sin.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: s_sinf.c,v 1.4 1995/05/10 20:48:16 jtc Exp $";
+#endif
+
+#include <errno.h>
+#include <math.h>
+#include <math_private.h>
+
+#ifndef SINF
+# define SINF_FUNC __sinf
+#else
+# define SINF_FUNC SINF
+#endif
+
+float SINF_FUNC(float x)
+{
+	float y[2],z=0.0;
+	int32_t n, ix;
+
+	GET_FLOAT_WORD(ix,x);
+
+    /* |x| ~< pi/4 */
+	ix &= 0x7fffffff;
+	if(ix <= 0x3f490fd8) return __kernel_sinf(x,z,0);
+
+    /* sin(Inf or NaN) is NaN */
+	else if (ix>=0x7f800000) {
+	  if (ix == 0x7f800000)
+	    __set_errno (EDOM);
+	  return x-x;
+	}
+
+    /* argument reduction needed */
+	else {
+	    n = __ieee754_rem_pio2f(x,y);
+	    switch(n&3) {
+		case 0: return  __kernel_sinf(y[0],y[1],1);
+		case 1: return  __kernel_cosf(y[0],y[1]);
+		case 2: return -__kernel_sinf(y[0],y[1],1);
+		default:
+			return -__kernel_cosf(y[0],y[1]);
+	    }
+	}
+}
+
+#ifndef SINF
+weak_alias (__sinf, sinf)
+#endif
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_tanf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_tanf.c
new file mode 100644
index 0000000000..685df8fa35
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_tanf.c
@@ -0,0 +1,49 @@
+/* s_tanf.c -- float version of s_tan.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: s_tanf.c,v 1.4 1995/05/10 20:48:20 jtc Exp $";
+#endif
+
+#include <errno.h>
+#include <math.h>
+#include <math_private.h>
+
+float __tanf(float x)
+{
+	float y[2],z=0.0;
+	int32_t n, ix;
+
+	GET_FLOAT_WORD(ix,x);
+
+    /* |x| ~< pi/4 */
+	ix &= 0x7fffffff;
+	if(ix <= 0x3f490fda) return __kernel_tanf(x,z,1);
+
+    /* tan(Inf or NaN) is NaN */
+	else if (ix>=0x7f800000) {
+	  if (ix==0x7f800000)
+	    __set_errno (EDOM);
+	  return x-x;		/* NaN */
+	}
+
+    /* argument reduction needed */
+	else {
+	    n = __ieee754_rem_pio2f(x,y);
+	    return __kernel_tanf(y[0],y[1],1-((n&1)<<1)); /*   1 -- n even
+							      -1 -- n odd */
+	}
+}
+weak_alias (__tanf, tanf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_tanhf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_tanhf.c
new file mode 100644
index 0000000000..f70702b29c
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_tanhf.c
@@ -0,0 +1,62 @@
+/* s_tanhf.c -- float version of s_tanh.c.
+ * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: s_tanhf.c,v 1.4 1995/05/10 20:48:24 jtc Exp $";
+#endif
+
+#include <float.h>
+#include <math.h>
+#include <math_private.h>
+
+static const float one=1.0, two=2.0, tiny = 1.0e-30;
+
+float __tanhf(float x)
+{
+	float t,z;
+	int32_t jx,ix;
+
+	GET_FLOAT_WORD(jx,x);
+	ix = jx&0x7fffffff;
+
+    /* x is INF or NaN */
+	if(ix>=0x7f800000) {
+	    if (jx>=0) return one/x+one;    /* tanh(+-inf)=+-1 */
+	    else       return one/x-one;    /* tanh(NaN) = NaN */
+	}
+
+    /* |x| < 22 */
+	if (ix < 0x41b00000) {		/* |x|<22 */
+	    if (ix == 0)
+		return x;		/* x == +-0 */
+	    if (ix<0x24000000) 		/* |x|<2**-55 */
+	      {
+		math_check_force_underflow (x);
+		return x*(one+x);    	/* tanh(small) = small */
+	      }
+	    if (ix>=0x3f800000) {	/* |x|>=1  */
+		t = __expm1f(two*fabsf(x));
+		z = one - two/(t+two);
+	    } else {
+	        t = __expm1f(-two*fabsf(x));
+	        z= -t/(t+two);
+	    }
+    /* |x| > 22, return +-1 */
+	} else {
+	    z = one - tiny;		/* raised inexact flag */
+	}
+	return (jx>=0)? z: -z;
+}
+weak_alias (__tanhf, tanhf)
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_totalorderf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_totalorderf.c
new file mode 100644
index 0000000000..f592b051db
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_totalorderf.c
@@ -0,0 +1,46 @@
+/* Total order operation.  flt-32 version.
+   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math.h>
+#include <math_private.h>
+#include <nan-high-order-bit.h>
+#include <stdint.h>
+
+int
+totalorderf (float x, float y)
+{
+  int32_t ix, iy;
+  GET_FLOAT_WORD (ix, x);
+  GET_FLOAT_WORD (iy, y);
+#if HIGH_ORDER_BIT_IS_SET_FOR_SNAN
+  /* For the preferred quiet NaN convention, this operation is a
+     comparison of the representations of the arguments interpreted as
+     sign-magnitude integers.  If both arguments are NaNs, invert the
+     quiet/signaling bit so comparing that way works.  */
+  if ((ix & 0x7fffffff) > 0x7f800000 && (iy & 0x7fffffff) > 0x7f800000)
+    {
+      ix ^= 0x00400000;
+      iy ^= 0x00400000;
+    }
+#endif
+  uint32_t ix_sign = ix >> 31;
+  uint32_t iy_sign = iy >> 31;
+  ix ^= ix_sign >> 1;
+  iy ^= iy_sign >> 1;
+  return ix <= iy;
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_totalordermagf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_totalordermagf.c
new file mode 100644
index 0000000000..cac7601e12
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_totalordermagf.c
@@ -0,0 +1,44 @@
+/* Total order operation on absolute values.  flt-32 version.
+   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math.h>
+#include <math_private.h>
+#include <nan-high-order-bit.h>
+#include <stdint.h>
+
+int
+totalordermagf (float x, float y)
+{
+  uint32_t ix, iy;
+  GET_FLOAT_WORD (ix, x);
+  GET_FLOAT_WORD (iy, y);
+  ix &= 0x7fffffff;
+  iy &= 0x7fffffff;
+#if HIGH_ORDER_BIT_IS_SET_FOR_SNAN
+  /* For the preferred quiet NaN convention, this operation is a
+     comparison of the representations of the absolute values of the
+     arguments.  If both arguments are NaNs, invert the
+     quiet/signaling bit so comparing that way works.  */
+  if (ix > 0x7f800000 && iy > 0x7f800000)
+    {
+      ix ^= 0x00400000;
+      iy ^= 0x00400000;
+    }
+#endif
+  return ix <= iy;
+}
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_truncf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_truncf.c
new file mode 100644
index 0000000000..2edb03c16f
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_truncf.c
@@ -0,0 +1,53 @@
+/* Truncate argument to nearest integral value not larger than the argument.
+   Copyright (C) 1997-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math.h>
+
+#include <math_private.h>
+
+
+float
+__truncf (float x)
+{
+  int32_t i0, j0;
+  int sx;
+
+  GET_FLOAT_WORD (i0, x);
+  sx = i0 & 0x80000000;
+  j0 = ((i0 >> 23) & 0xff) - 0x7f;
+  if (j0 < 23)
+    {
+      if (j0 < 0)
+	/* The magnitude of the number is < 1 so the result is +-0.  */
+	SET_FLOAT_WORD (x, sx);
+      else
+	SET_FLOAT_WORD (x, sx | (i0 & ~(0x007fffff >> j0)));
+    }
+  else
+    {
+      if (j0 == 0x80)
+	/* x is inf or NaN.  */
+	return x + x;
+    }
+
+  return x;
+}
+#ifndef __truncf
+weak_alias (__truncf, truncf)
+#endif
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_ufromfpf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_ufromfpf.c
new file mode 100644
index 0000000000..e6ffdf3374
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_ufromfpf.c
@@ -0,0 +1,4 @@
+#define UNSIGNED 1
+#define INEXACT 0
+#define FUNC ufromfpf
+#include <s_fromfpf_main.c>
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/s_ufromfpxf.c b/REORG.TODO/sysdeps/ieee754/flt-32/s_ufromfpxf.c
new file mode 100644
index 0000000000..97aa6890f0
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/s_ufromfpxf.c
@@ -0,0 +1,4 @@
+#define UNSIGNED 1
+#define INEXACT 1
+#define FUNC ufromfpxf
+#include <s_fromfpf_main.c>
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/t_exp2f.h b/REORG.TODO/sysdeps/ieee754/flt-32/t_exp2f.h
new file mode 100644
index 0000000000..aecabcc372
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/t_exp2f.h
@@ -0,0 +1,351 @@
+/* Accurate tables for exp2f().
+   Copyright (C) 1998-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Geoffrey Keating <geoffk@ozemail.com.au>
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+/* This table has the property that, for all integers -128 <= i <= 127,
+   exp(i/256.0 + __exp2f_deltatable[i-128]) == __exp2f_atable[i+128] + r
+   for some -2^-35 < r < 2^-35 (abs(r) < 2^-36 if i <= 0); and that
+   __exp2f_deltatable[i+128] == t * 2^-30
+   for integer t so that abs(t) <= 43447 * 2^0.  */
+
+#define W30 (9.31322575e-10)
+static const float __exp2f_deltatable[256] = {
+      -810*W30,       283*W30,     -1514*W30,      1304*W30,
+     -1148*W30,       -98*W30,      -744*W30,      -156*W30,
+      -419*W30,      -155*W30,       474*W30,       167*W30,
+     -1984*W30,      -826*W30,       692*W30,       781*W30,
+      -578*W30,      -411*W30,      -129*W30,     -1500*W30,
+       654*W30,      -141*W30,      -816*W30,       -53*W30,
+       148*W30,       493*W30,     -2214*W30,       760*W30,
+       260*W30,       750*W30,     -1300*W30,      1424*W30,
+     -1445*W30,      -339*W30,      -680*W30,      -349*W30,
+      -922*W30,       531*W30,       193*W30,     -2892*W30,
+       290*W30,     -2145*W30,      -276*W30,       485*W30,
+      -695*W30,       215*W30,     -7093*W30,       412*W30,
+     -4596*W30,       367*W30,       592*W30,      -615*W30,
+       -97*W30,     -1066*W30,       972*W30,      -226*W30,
+      -625*W30,      -374*W30,     -5647*W30,      -180*W30,
+     20349*W30,      -447*W30,       111*W30,     -4164*W30,
+       -87*W30,       -21*W30,      -251*W30,        66*W30,
+      -517*W30,      2093*W30,      -263*W30,       182*W30,
+      -601*W30,       475*W30,      -483*W30,     -1251*W30,
+      -373*W30,      1471*W30,       -92*W30,      -215*W30,
+       -97*W30,      -190*W30,         0*W30,      -290*W30,
+     -2647*W30,      1940*W30,      -582*W30,        28*W30,
+       833*W30,      1493*W30,        34*W30,       321*W30,
+      3327*W30,       -35*W30,       177*W30,      -135*W30,
+      -796*W30,      -428*W30,       129*W30,      9332*W30,
+       -12*W30,       -69*W30,     -1743*W30,      6508*W30,
+       -60*W30,       359*W30,     43447*W30,        15*W30,
+       -23*W30,      -305*W30,      -375*W30,      -652*W30,
+       667*W30,       269*W30,     -1575*W30,       185*W30,
+      -329*W30,       200*W30,      6002*W30,       163*W30,
+      -647*W30,        19*W30,      -603*W30,      -755*W30,
+       742*W30,      -438*W30,      3587*W30,      2560*W30,
+         0*W30,      -520*W30,      -241*W30,      -299*W30,
+     -1270*W30,      -991*W30,     -1138*W30,       255*W30,
+     -1192*W30,      1722*W30,      1023*W30,      3700*W30,
+     -1388*W30,     -1551*W30,     -2549*W30,        27*W30,
+       282*W30,       673*W30,       113*W30,      1561*W30,
+        72*W30,       873*W30,        87*W30,      -395*W30,
+      -433*W30,       629*W30,      3440*W30,      -284*W30,
+      -592*W30,      -103*W30,       -46*W30,     -3844*W30,
+      1712*W30,       303*W30,      1555*W30,      -631*W30,
+     -1400*W30,      -961*W30,      -854*W30,      -276*W30,
+       407*W30,       833*W30,      -345*W30,     -1501*W30,
+       121*W30,     -1581*W30,       400*W30,       150*W30,
+      1224*W30,      -139*W30,      -563*W30,       879*W30,
+       933*W30,      2939*W30,       788*W30,       211*W30,
+       530*W30,      -192*W30,       706*W30,    -13347*W30,
+      1065*W30,         3*W30,       111*W30,      -208*W30,
+      -360*W30,      -532*W30,      -291*W30,       483*W30,
+       987*W30,       -33*W30,     -1373*W30,      -166*W30,
+     -1174*W30,     -3955*W30,      1601*W30,      -280*W30,
+      1405*W30,       600*W30,     -1659*W30,       -23*W30,
+       390*W30,       449*W30,       570*W30,    -13143*W30,
+        -9*W30,     -1646*W30,      1201*W30,       294*W30,
+      2181*W30,     -1173*W30,      1388*W30,     -4504*W30,
+       190*W30,     -2304*W30,       211*W30,       239*W30,
+        48*W30,      -817*W30,      1018*W30,      1828*W30,
+      -663*W30,      1408*W30,       408*W30,       -36*W30,
+      1295*W30,      -230*W30,      1341*W30,         9*W30,
+        40*W30,       705*W30,       186*W30,       376*W30,
+       557*W30,      5866*W30,       363*W30,     -1558*W30,
+       718*W30,       669*W30,      1369*W30,     -2972*W30,
+      -468*W30,      -121*W30,      -219*W30,       667*W30,
+     29954*W30,       366*W30,        48*W30,      -203*W30
+};
+
+static const float __exp2f_atable[256] /* __attribute__((mode(SF))) */ = {
+ 0.707106411447, /* 0x0.b504ecfff */
+ 0.709024071690, /* 0x0.b58299fff */
+ 0.710945606239, /* 0x0.b60088000 */
+ 0.712874472142, /* 0x0.b67ef1000 */
+ 0.714806139464, /* 0x0.b6fd88fff */
+ 0.716744661340, /* 0x0.b77c94000 */
+ 0.718687653549, /* 0x0.b7fbea000 */
+ 0.720636486992, /* 0x0.b87ba1fff */
+ 0.722590208040, /* 0x0.b8fbabfff */
+ 0.724549472323, /* 0x0.b97c12fff */
+ 0.726514220228, /* 0x0.b9fcd5fff */
+ 0.728483855735, /* 0x0.ba7deb000 */
+ 0.730457961549, /* 0x0.baff4afff */
+ 0.732438981522, /* 0x0.bb811efff */
+ 0.734425544748, /* 0x0.bc0350000 */
+ 0.736416816713, /* 0x0.bc85d0000 */
+ 0.738412797450, /* 0x0.bd089efff */
+ 0.740414917465, /* 0x0.bd8bd4fff */
+ 0.742422521111, /* 0x0.be0f66fff */
+ 0.744434773914, /* 0x0.be9346fff */
+ 0.746454179287, /* 0x0.bf179f000 */
+ 0.748477637755, /* 0x0.bf9c3afff */
+ 0.750506639473, /* 0x0.c02133fff */
+ 0.752541840064, /* 0x0.c0a694fff */
+ 0.754582285889, /* 0x0.c12c4e000 */
+ 0.756628334525, /* 0x0.c1b265000 */
+ 0.758678436269, /* 0x0.c238bffff */
+ 0.760736882681, /* 0x0.c2bfa6fff */
+ 0.762799203401, /* 0x0.c346cf000 */
+ 0.764867603790, /* 0x0.c3ce5d000 */
+ 0.766940355298, /* 0x0.c45633fff */
+ 0.769021093841, /* 0x0.c4de90fff */
+ 0.771104693409, /* 0x0.c5671dfff */
+ 0.773195922364, /* 0x0.c5f02afff */
+ 0.775292098512, /* 0x0.c6798afff */
+ 0.777394294745, /* 0x0.c70350000 */
+ 0.779501736166, /* 0x0.c78d6d000 */
+ 0.781615912910, /* 0x0.c817fafff */
+ 0.783734917628, /* 0x0.c8a2d9fff */
+ 0.785858273516, /* 0x0.c92e02000 */
+ 0.787990570071, /* 0x0.c9b9c0000 */
+ 0.790125787245, /* 0x0.ca45aefff */
+ 0.792268991467, /* 0x0.cad223fff */
+ 0.794417440881, /* 0x0.cb5ef0fff */
+ 0.796570718287, /* 0x0.cbec0efff */
+ 0.798730909811, /* 0x0.cc79a0fff */
+ 0.800892710672, /* 0x0.cd074dfff */
+ 0.803068041795, /* 0x0.cd95ddfff */
+ 0.805242776881, /* 0x0.ce2464000 */
+ 0.807428598393, /* 0x0.ceb3a3fff */
+ 0.809617877002, /* 0x0.cf431dfff */
+ 0.811812341211, /* 0x0.cfd2eefff */
+ 0.814013659956, /* 0x0.d06333000 */
+ 0.816220164311, /* 0x0.d0f3ce000 */
+ 0.818434238424, /* 0x0.d184e7fff */
+ 0.820652604094, /* 0x0.d21649fff */
+ 0.822877407074, /* 0x0.d2a818000 */
+ 0.825108587751, /* 0x0.d33a51000 */
+ 0.827342867839, /* 0x0.d3ccbdfff */
+ 0.829588949684, /* 0x0.d45ff1000 */
+ 0.831849217401, /* 0x0.d4f411fff */
+ 0.834093391880, /* 0x0.d58724fff */
+ 0.836355149750, /* 0x0.d61b5f000 */
+ 0.838620424257, /* 0x0.d6afd3fff */
+ 0.840896368027, /* 0x0.d744fc000 */
+ 0.843176305293, /* 0x0.d7da66fff */
+ 0.845462262643, /* 0x0.d87037000 */
+ 0.847754716864, /* 0x0.d90673fff */
+ 0.850052893157, /* 0x0.d99d10fff */
+ 0.852359056469, /* 0x0.da3433fff */
+ 0.854668736446, /* 0x0.dacb91fff */
+ 0.856986224651, /* 0x0.db6373000 */
+ 0.859309315673, /* 0x0.dbfbb1fff */
+ 0.861639738080, /* 0x0.dc946bfff */
+ 0.863975346095, /* 0x0.dd2d7d000 */
+ 0.866317391394, /* 0x0.ddc6f9fff */
+ 0.868666708472, /* 0x0.de60f1000 */
+ 0.871022939695, /* 0x0.defb5c000 */
+ 0.873383641229, /* 0x0.df9611fff */
+ 0.875751554968, /* 0x0.e03141000 */
+ 0.878126025200, /* 0x0.e0ccde000 */
+ 0.880506813521, /* 0x0.e168e4fff */
+ 0.882894217966, /* 0x0.e2055afff */
+ 0.885287821299, /* 0x0.e2a239000 */
+ 0.887686729423, /* 0x0.e33f6ffff */
+ 0.890096127973, /* 0x0.e3dd56fff */
+ 0.892507970338, /* 0x0.e47b67000 */
+ 0.894928157336, /* 0x0.e51a03000 */
+ 0.897355020043, /* 0x0.e5b90efff */
+ 0.899788379682, /* 0x0.e65888000 */
+ 0.902227103705, /* 0x0.e6f85afff */
+ 0.904673457151, /* 0x0.e798ae000 */
+ 0.907128036008, /* 0x0.e8398afff */
+ 0.909585535528, /* 0x0.e8da99000 */
+ 0.912051796915, /* 0x0.e97c3a000 */
+ 0.914524436003, /* 0x0.ea1e46000 */
+ 0.917003571999, /* 0x0.eac0bf000 */
+ 0.919490039339, /* 0x0.eb63b2fff */
+ 0.921983361257, /* 0x0.ec071a000 */
+ 0.924488604054, /* 0x0.ecab48fff */
+ 0.926989555360, /* 0x0.ed4f30000 */
+ 0.929502844812, /* 0x0.edf3e6000 */
+ 0.932021975503, /* 0x0.ee98fdfff */
+ 0.934553921208, /* 0x0.ef3eecfff */
+ 0.937083780759, /* 0x0.efe4b8fff */
+ 0.939624726786, /* 0x0.f08b3f000 */
+ 0.942198514924, /* 0x0.f133ebfff */
+ 0.944726586343, /* 0x0.f1d99a000 */
+ 0.947287976728, /* 0x0.f28176fff */
+ 0.949856162070, /* 0x0.f329c5fff */
+ 0.952431440345, /* 0x0.f3d28bfff */
+ 0.955013573175, /* 0x0.f47bc5000 */
+ 0.957603693021, /* 0x0.f52584000 */
+ 0.960199773321, /* 0x0.f5cfa7000 */
+ 0.962801992906, /* 0x0.f67a31000 */
+ 0.965413510788, /* 0x0.f72556fff */
+ 0.968030691152, /* 0x0.f7d0dc000 */
+ 0.970655620084, /* 0x0.f87ce2fff */
+ 0.973290979849, /* 0x0.f92998fff */
+ 0.975926160805, /* 0x0.f9d64bfff */
+ 0.978571653370, /* 0x0.fa83ac000 */
+ 0.981225252139, /* 0x0.fb3193fff */
+ 0.983885228626, /* 0x0.fbdfe6fff */
+ 0.986552715296, /* 0x0.fc8eb7fff */
+ 0.989228487027, /* 0x0.fd3e14000 */
+ 0.991909801964, /* 0x0.fdedcd000 */
+ 0.994601726545, /* 0x0.fe9e38000 */
+ 0.997297704209, /* 0x0.ff4ee6fff */
+ 1.000000000000, /* 0x1.000000000 */
+ 1.002710938457, /* 0x1.00b1aa000 */
+ 1.005429744692, /* 0x1.0163d7ffe */
+ 1.008155703526, /* 0x1.02167dffe */
+ 1.010888457284, /* 0x1.02c995fff */
+ 1.013629436498, /* 0x1.037d38000 */
+ 1.016377568250, /* 0x1.043152000 */
+ 1.019134163841, /* 0x1.04e5f9ffe */
+ 1.021896362316, /* 0x1.059b00000 */
+ 1.024668931945, /* 0x1.0650b3ffe */
+ 1.027446627635, /* 0x1.0706be001 */
+ 1.030234098408, /* 0x1.07bd6bffe */
+ 1.033023953416, /* 0x1.087441ffe */
+ 1.035824656494, /* 0x1.092bce000 */
+ 1.038632392900, /* 0x1.09e3d0001 */
+ 1.041450142840, /* 0x1.0a9c79ffe */
+ 1.044273972530, /* 0x1.0b558a001 */
+ 1.047105550795, /* 0x1.0c0f1c001 */
+ 1.049944162390, /* 0x1.0cc924001 */
+ 1.052791833895, /* 0x1.0d83c4001 */
+ 1.055645227426, /* 0x1.0e3ec3fff */
+ 1.058507919326, /* 0x1.0efa60001 */
+ 1.061377286898, /* 0x1.0fb66bfff */
+ 1.064254641510, /* 0x1.1072fdffe */
+ 1.067140102389, /* 0x1.113018000 */
+ 1.070034146304, /* 0x1.11edc1fff */
+ 1.072937250162, /* 0x1.12ac04001 */
+ 1.075843691823, /* 0x1.136a7dfff */
+ 1.078760385496, /* 0x1.1429a3ffe */
+ 1.081685543070, /* 0x1.14e958000 */
+ 1.084618330005, /* 0x1.15a98c000 */
+ 1.087556362176, /* 0x1.166a18001 */
+ 1.090508937863, /* 0x1.172b98001 */
+ 1.093464612954, /* 0x1.17ed4bfff */
+ 1.096430182434, /* 0x1.18afa5ffe */
+ 1.099401354802, /* 0x1.19725e000 */
+ 1.102381587017, /* 0x1.1a35adfff */
+ 1.105370759965, /* 0x1.1af994000 */
+ 1.108367800686, /* 0x1.1bbdfdffe */
+ 1.111373305331, /* 0x1.1c82f6000 */
+ 1.114387035385, /* 0x1.1d4878001 */
+ 1.117408752440, /* 0x1.1e0e7ffff */
+ 1.120437502874, /* 0x1.1ed4fe000 */
+ 1.123474478729, /* 0x1.1f9c06000 */
+ 1.126521706601, /* 0x1.2063ba001 */
+ 1.129574775716, /* 0x1.212bd0001 */
+ 1.132638812065, /* 0x1.21f49e000 */
+ 1.135709524130, /* 0x1.22bddbffe */
+ 1.138789534565, /* 0x1.2387b5fff */
+ 1.141876101508, /* 0x1.2451fe000 */
+ 1.144971728301, /* 0x1.251cddffe */
+ 1.148077130296, /* 0x1.25e861ffe */
+ 1.151189923305, /* 0x1.26b462001 */
+ 1.154312610610, /* 0x1.278107ffe */
+ 1.157440662410, /* 0x1.284e08001 */
+ 1.160578370109, /* 0x1.291baa001 */
+ 1.163725256932, /* 0x1.29e9e6000 */
+ 1.166879892324, /* 0x1.2ab8a3ffe */
+ 1.170044302935, /* 0x1.2b8805fff */
+ 1.173205971694, /* 0x1.2c5739ffe */
+ 1.176397800428, /* 0x1.2d2867ffe */
+ 1.179586529747, /* 0x1.2df962001 */
+ 1.182784795737, /* 0x1.2ecafbffe */
+ 1.185991406414, /* 0x1.2f9d21ffe */
+ 1.189206838636, /* 0x1.306fdc001 */
+ 1.192430973067, /* 0x1.314328000 */
+ 1.195664167430, /* 0x1.32170c001 */
+ 1.198906540890, /* 0x1.32eb8a001 */
+ 1.202157497408, /* 0x1.33c098000 */
+ 1.205416083326, /* 0x1.349625fff */
+ 1.208683252332, /* 0x1.356c43fff */
+ 1.211961269402, /* 0x1.364318001 */
+ 1.215246438983, /* 0x1.371a64000 */
+ 1.218539118740, /* 0x1.37f22dffe */
+ 1.221847295770, /* 0x1.38cafc000 */
+ 1.225158572187, /* 0x1.39a3fdfff */
+ 1.228481650325, /* 0x1.3a7dc5ffe */
+ 1.231811761846, /* 0x1.3b5803fff */
+ 1.235149741144, /* 0x1.3c32c5ffe */
+ 1.238499879811, /* 0x1.3d0e53ffe */
+ 1.241858124726, /* 0x1.3dea69fff */
+ 1.245225191102, /* 0x1.3ec713fff */
+ 1.248601436624, /* 0x1.3fa458000 */
+ 1.251975655584, /* 0x1.40817a001 */
+ 1.255380749731, /* 0x1.4160a2001 */
+ 1.258783102010, /* 0x1.423f9bffe */
+ 1.262198328973, /* 0x1.431f6e000 */
+ 1.265619754780, /* 0x1.43ffa7fff */
+ 1.269052743928, /* 0x1.44e0a4001 */
+ 1.272490739830, /* 0x1.45c1f4000 */
+ 1.275942921659, /* 0x1.46a432001 */
+ 1.279397487615, /* 0x1.478697ffe */
+ 1.282870173427, /* 0x1.486a2dffe */
+ 1.286346316319, /* 0x1.494dfdffe */
+ 1.289836049094, /* 0x1.4a32b2001 */
+ 1.293333172770, /* 0x1.4b17e1ffe */
+ 1.296839594835, /* 0x1.4bfdadfff */
+ 1.300354957560, /* 0x1.4ce40fffe */
+ 1.303882122055, /* 0x1.4dcb38001 */
+ 1.307417988757, /* 0x1.4eb2f1ffe */
+ 1.310960650439, /* 0x1.4f9b1dfff */
+ 1.314516782746, /* 0x1.50842bfff */
+ 1.318079948424, /* 0x1.516daffff */
+ 1.321653246888, /* 0x1.5257de000 */
+ 1.325237751030, /* 0x1.5342c8001 */
+ 1.328829526907, /* 0x1.542e2c000 */
+ 1.332433700535, /* 0x1.551a5fffe */
+ 1.336045145966, /* 0x1.56070dffe */
+ 1.339667558645, /* 0x1.56f473ffe */
+ 1.343300342533, /* 0x1.57e287ffe */
+ 1.346941947961, /* 0x1.58d130001 */
+ 1.350594043714, /* 0x1.59c087ffe */
+ 1.354256033883, /* 0x1.5ab085fff */
+ 1.357932448365, /* 0x1.5ba175ffe */
+ 1.361609339707, /* 0x1.5c926dfff */
+ 1.365299344044, /* 0x1.5d8441ffe */
+ 1.369003057507, /* 0x1.5e76fc001 */
+ 1.372714757920, /* 0x1.5f6a3c000 */
+ 1.376437187179, /* 0x1.605e2fffe */
+ 1.380165219333, /* 0x1.615282001 */
+ 1.383909463864, /* 0x1.6247e3ffe */
+ 1.387661933907, /* 0x1.633dd0000 */
+ 1.391424179060, /* 0x1.64345fffe */
+ 1.395197510706, /* 0x1.652ba9fff */
+ 1.399006724329, /* 0x1.66254dffe */
+ 1.402773022651, /* 0x1.671c22000 */
+ 1.406576037403, /* 0x1.68155dfff */
+ 1.410389423392, /* 0x1.690f48001 */
+};
diff --git a/REORG.TODO/sysdeps/ieee754/flt-32/w_expf_compat.c b/REORG.TODO/sysdeps/ieee754/flt-32/w_expf_compat.c
new file mode 100644
index 0000000000..b2be6aa7e1
--- /dev/null
+++ b/REORG.TODO/sysdeps/ieee754/flt-32/w_expf_compat.c
@@ -0,0 +1,34 @@
+/* Copyright (C) 2011-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@gmail.com>, 2011.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <math.h>
+#include <math_private.h>
+
+/* wrapper expf */
+float
+__expf (float x)
+{
+  float z = __ieee754_expf (x);
+  if (__builtin_expect (!isfinite (z) || z == 0, 0)
+      && isfinite (x) && _LIB_VERSION != _IEEE_)
+    return __kernel_standard_f (x, x, 106 + !!signbit (x));
+
+  return z;
+}
+hidden_def (__expf)
+weak_alias (__expf, expf)