rename packages/ to recipes/ per earlier agreement

See links below for more details:
http://thread.gmane.org/gmane.comp.handhelds.openembedded/21326
http://thread.gmane.org/gmane.comp.handhelds.openembedded/21816

Signed-off-by: Denys Dmytriyenko <denis@denix.org>
Acked-by: Mike Westerhof <mwester@dls.net>
Acked-by: Philip Balister <philip@balister.org>
Acked-by: Khem Raj <raj.khem@gmail.com>
Acked-by: Marcin Juszkiewicz <hrw@openembedded.org>
Acked-by: Koen Kooi <koen@openembedded.org>
Acked-by: Frans Meulenbroeks <fransmeulenbroeks@gmail.com>

1 files changed, 4271 insertions, 0 deletions

diff --git a/recipes/gcc/gcc-4.1.1/ppc-sfp-long-double-gcc411-7.patch b/recipes/gcc/gcc-4.1.1/ppc-sfp-long-double-gcc411-7.patch
new file mode 100644
index 0000000000..e3a87c87d0
--- /dev/null
+++ b/recipes/gcc/gcc-4.1.1/ppc-sfp-long-double-gcc411-7.patch
@@ -0,0 +1,4271 @@
+	* config/rs6000/darwin-ldouble.c: Build file for SOFT_FLOAT.
+	(strong_alias): Define.
+	(__gcc_qmul): Provide non-FMA for soft-float.
+	(__gcc_qdiv): Same.
+	(__gcc_qneg): New.
+	(__gcc_qeq): New.
+	(__gcc_qle): New.
+	(__gcc_qge): New.
+	(__gcc_qunord): New.
+	(__gcc_stoq): New.
+	(__gcc_dtoq): New.
+	(__gcc_qtos): New.
+	(__gcc_qtod): New.
+	(__gcc_qtoi): New.
+	(__gcc_qtou): New.
+	(__gcc_itoq): New.
+	(__gcc_utoq): New.
+	(fmsub): New.
+	* config/rs6000/rs6000.c (rs6000_emit_move): Handle TFmode
+	constant for soft-float.
+	(rs6000_init_libfuncs): Initialize soft-float functions.
+	* config/rs6000/libgcc-ppc-glibc.ver: Version soft-float symbols.
+	* config/rs6000/rs6000.md (movtf): Allow soft-float.
+	(movtf_softfloat): New.
+	* config/rs6000/t-ppccomm (TARGET_LIBGCC2_CFLAGS): Add
+	-mlong-double-128.
+	(ldblspecs): Remove.
+	* config/rs6000/sysv4.h (SUBTARGET_OVERRIDE_OPTIONS): Do not warn
+	about long double soft float.
+
+diff -urN gcc-4.1.1/gcc/config/rs6000/darwin-ldouble.c gcc-4.1.1-patched/gcc/config/rs6000/darwin-ldouble.c
+--- gcc-4.1.1/gcc/config/rs6000/darwin-ldouble.c	2006-03-23 16:23:58.000000000 -0600
++++ gcc-4.1.1-patched/gcc/config/rs6000/darwin-ldouble.c	2006-09-12 14:30:16.000000000 -0500
+@@ -49,7 +49,8 @@
+ 
+    This code currently assumes big-endian.  */
+ 
+-#if (!defined (__NO_FPRS__) && !defined (__LITTLE_ENDIAN__) \
++#if ((!defined (__NO_FPRS__) || defined (_SOFT_FLOAT)) \
++     && !defined (__LITTLE_ENDIAN__) \
+      && (defined (__MACH__) || defined (__powerpc__) || defined (_AIX)))
+ 
+ #define fabs(x) __builtin_fabs(x)
+@@ -60,14 +61,19 @@
+ 
+ #define nonfinite(a) unlikely (! isless (fabs (a), inf ()))
+ 
++/* Define ALIASNAME as a strong alias for NAME.  */
++# define strong_alias(name, aliasname) _strong_alias(name, aliasname)
++# define _strong_alias(name, aliasname) \
++  extern __typeof (name) aliasname __attribute__ ((alias (#name)));
++
+ /* All these routines actually take two long doubles as parameters,
+    but GCC currently generates poor code when a union is used to turn
+    a long double into a pair of doubles.  */
+ 
+-extern long double __gcc_qadd (double, double, double, double);
+-extern long double __gcc_qsub (double, double, double, double);
+-extern long double __gcc_qmul (double, double, double, double);
+-extern long double __gcc_qdiv (double, double, double, double);
++long double __gcc_qadd (double, double, double, double);
++long double __gcc_qsub (double, double, double, double);
++long double __gcc_qmul (double, double, double, double);
++long double __gcc_qdiv (double, double, double, double);
+ 
+ #if defined __ELF__ && defined SHARED \
+     && (defined __powerpc64__ || !(defined __linux__ || defined __gnu_hurd__))
+@@ -139,6 +145,10 @@
+   return __gcc_qadd (a, b, -c, -d);
+ }
+ 
++#ifdef _SOFT_FLOAT
++static double fmsub (double, double, double);
++#endif
++
+ long double
+ __gcc_qmul (double a, double b, double c, double d)
+ {
+@@ -154,7 +164,11 @@
+   /* Sum terms of two highest orders. */
+   
+   /* Use fused multiply-add to get low part of a * c.  */
++#ifndef _SOFT_FLOAT
+   asm ("fmsub %0,%1,%2,%3" : "=f"(tau) : "f"(a), "f"(c), "f"(t));
++#else
++  tau = fmsub (a, c, t);
++#endif
+   v = a*d;
+   w = b*c;
+   tau += v + w;	    /* Add in other second-order terms.	 */
+@@ -187,7 +201,11 @@
+ 			   numerically necessary.  */
+   
+   /* Use fused multiply-add to get low part of c * t.	 */
++#ifndef _SOFT_FLOAT
+   asm ("fmsub %0,%1,%2,%3" : "=f"(sigma) : "f"(c), "f"(t), "f"(s));
++#else
++  sigma = fmsub (c, t, s);
++#endif
+   v = a - s;
+   
+   tau = ((v-sigma)+w)/c;   /* Correction to t.  */
+@@ -201,4 +219,3959 @@
+   return z.ldval;
+ }
+ 
++#ifdef _SOFT_FLOAT
++
++long double __gcc_qneg (double, double);
++int __gcc_qeq (double, double, double, double);
++int __gcc_qne (double, double, double, double);
++int __gcc_qge (double, double, double, double);
++int __gcc_qle (double, double, double, double);
++int __gcc_qunord (double, double, double, double);
++long double __gcc_stoq (float);
++long double __gcc_dtoq (double);
++float __gcc_qtos (double, double);
++double __gcc_qtod (double, double);
++int __gcc_qtoi (double, double);
++unsigned int __gcc_qtou (double, double);
++long double __gcc_itoq (int);
++long double __gcc_utoq (unsigned int);
++
++extern int __eqdf2 (double, double);
++extern int __ledf2 (double, double);
++extern int __gedf2 (double, double);
++extern int __unorddf2 (double, double);
++
++/* Negate 'long double' value and return the result.	*/
++long double
++__gcc_qneg (double a, double aa)
++{
++  longDblUnion x;
++
++  x.dval[0] = -a;
++  x.dval[1] = -aa;
++  return x.ldval;
++}
++
++/* Compare two 'long double' values for equality.  */
++int
++__gcc_qeq (double a, double aa, double c, double cc)
++{
++  if (__eqdf2 (a, c) == 0)
++    return __eqdf2 (aa, cc);
++  return 1;
++}
++
++strong_alias (__gcc_qeq, __gcc_qne);
++
++/* Compare two 'long double' values for less than or equal.  */
++int
++__gcc_qle (double a, double aa, double c, double cc)
++{
++  if (__eqdf2 (a, c) == 0)
++    return __ledf2 (aa, cc);
++  return __ledf2 (a, c);
++}
++
++strong_alias (__gcc_qle, __gcc_qlt);
++
++/* Compare two 'long double' values for greater than or equal.  */
++int
++__gcc_qge (double a, double aa, double c, double cc)
++{
++  if (__eqdf2 (a, c) == 0)
++    return __gedf2 (aa, cc);
++  return __gedf2 (a, c);
++}
++
++strong_alias (__gcc_qge, __gcc_qgt);
++
++/* Compare two 'long double' values for unordered.  */
++int
++__gcc_qunord (double a, double aa, double c, double cc)
++{
++  if (__eqdf2 (a, c) == 0)
++    return __unorddf2 (aa, cc);
++  return __unorddf2 (a, c);
++}
++
++/* Convert single to long double.  */
++long double
++__gcc_stoq (float a)
++{
++  longDblUnion x;
++
++  x.dval[0] = (double) a;
++  x.dval[1] = 0.0;
++
++  return x.ldval;
++}
++
++/* Convert double to long double.  */
++long double
++__gcc_dtoq (double a)
++{
++  longDblUnion x;
++
++  x.dval[0] = a;
++  x.dval[1] = 0.0;
++
++  return x.ldval;
++}
++
++/* Convert long double to single.  */
++float
++__gcc_qtos (double a, double aa __attribute__ ((__unused__)))
++{
++  return (float) a;
++}
++
++/* Convert long double to double.  */
++double
++__gcc_qtod (double a, double aa __attribute__ ((__unused__)))
++{
++  return a;
++}
++
++/* Convert long double to int.  */
++int
++__gcc_qtoi (double a, double aa)
++{
++  double z = a + aa;
++  return (int) z;
++}
++
++/* Convert long double to unsigned int.  */
++unsigned int
++__gcc_qtou (double a, double aa)
++{
++  double z = a + aa;
++  return (unsigned int) z;
++}
++
++/* Convert int to long double.  */
++long double
++__gcc_itoq (int a)
++{
++  return __gcc_dtoq ((double) a);
++}
++
++/* Convert unsigned int to long double.  */
++long double
++__gcc_utoq (unsigned int a)
++{
++  return __gcc_dtoq ((double) a);
++}
++
++typedef int QItype __attribute__ ((mode (QI)));
++typedef int SItype __attribute__ ((mode (SI)));
++typedef int DItype __attribute__ ((mode (DI)));
++typedef unsigned int UQItype __attribute__ ((mode (QI)));
++typedef unsigned int USItype __attribute__ ((mode (SI)));
++typedef unsigned int UDItype __attribute__ ((mode (DI)));
++
++typedef unsigned int UHWtype __attribute__ ((mode (HI)));
++extern const UQItype __clz_tab[256];
++extern void abort (void);
++typedef float DFtype __attribute__ ((mode (DF)));
++
++union _FP_UNION_D
++{
++  DFtype flt;
++  struct
++  {
++
++    unsigned sign:1;
++    unsigned exp:11;
++    unsigned frac1:53 - (((unsigned long) 1 << (53 - 1) % 32) != 0) - 32;
++    unsigned frac0:32;
++  } bits __attribute__ ((packed));
++};
++typedef float TFtype __attribute__ ((mode (TF)));
++
++union _FP_UNION_Q
++{
++  TFtype flt;
++  struct
++  {
++
++    unsigned sign:1;
++    unsigned exp:15;
++    unsigned long frac3:113 - (((unsigned long) 1 << (113 - 1) % 32) !=
++			       0) - (32 * 3);
++    unsigned long frac2:32;
++    unsigned long frac1:32;
++    unsigned long frac0:32;
++  } bits __attribute__ ((packed));
++};
++
++static double
++fmsub (double a, double b, double c)
++{
++  int _fex = 0;
++  long A_c __attribute__ ((unused)), A_s, A_e;
++  unsigned long A_f0, A_f1;
++  long B_c __attribute__ ((unused)), B_s, B_e;
++  unsigned long B_f0, B_f1;
++  long C_c __attribute__ ((unused)), C_s, C_e;
++  unsigned long C_f0, C_f1;
++  long X_c __attribute__ ((unused)), X_s, X_e;
++  unsigned long X_f[4];
++  long Y_c __attribute__ ((unused)), Y_s, Y_e;
++  unsigned long Y_f[4];
++  long Z_c __attribute__ ((unused)), Z_s, Z_e;
++  unsigned long Z_f[4];
++  long U_c __attribute__ ((unused)), U_s, U_e;
++  unsigned long U_f[4];
++  long V_c __attribute__ ((unused)), V_s, V_e;
++  unsigned long V_f[4];
++  long R_c __attribute__ ((unused)), R_s, R_e;
++  unsigned long R_f0, R_f1;
++  double r;
++  long double u, v, x, y, z;
++
++/*  FP_INIT_ROUNDMODE */
++  do
++    {
++    }
++  while (0);
++
++/*  FP_UNPACK_RAW_D (A, a) */
++  do
++    {
++      union _FP_UNION_D _flo;
++      _flo.flt = (a);
++      A_f0 = _flo.bits.frac0;
++      A_f1 = _flo.bits.frac1;
++      A_e = _flo.bits.exp;
++      A_s = _flo.bits.sign;
++    }
++  while (0);
++
++/*  FP_UNPACK_RAW_D (B, b) */
++  do
++    {
++      union _FP_UNION_D _flo;
++      _flo.flt = (b);
++      B_f0 = _flo.bits.frac0;
++      B_f1 = _flo.bits.frac1;
++      B_e = _flo.bits.exp;
++      B_s = _flo.bits.sign;
++    }
++  while (0);
++
++/*  FP_UNPACK_RAW_D (C, c) */
++  do
++    {
++      union _FP_UNION_D _flo;
++      _flo.flt = (c);
++      C_f0 = _flo.bits.frac0;
++      C_f1 = _flo.bits.frac1;
++      C_e = _flo.bits.exp;
++      C_s = _flo.bits.sign;
++    }
++  while (0);
++
++  /* Extend double to quad.  */
++/*  FP_EXTEND(Q,D,4,2,X,A) */
++  do
++    {
++      if (113 < 53 || (32767 - 16383 < 2047 - 1023) || 16383 < 1023 + 53 - 1)
++	abort ();
++      X_s = A_s;
++      do
++	{
++	  X_f[0] = A_f0;
++	  X_f[1] = A_f1;
++	  X_f[2] = X_f[3] = 0;
++	}
++      while (0);
++      if ((((A_e + 1) & 2047) > 1))
++	{
++	  X_e = A_e + 16383 - 1023;
++	  do
++	    {
++	      long _up, _down, _skip, _i;
++	      _skip = ((113 - 53)) / 32;
++	      _up = ((113 - 53)) % 32;
++	      _down = 32 - _up;
++	      if (!_up)
++		for (_i = 3; _i >= _skip; --_i)
++		  X_f[_i] = X_f[_i - _skip];
++	      else
++		{
++		  for (_i = 3; _i > _skip; --_i)
++		    X_f[_i] =
++		      X_f[_i - _skip] << _up | X_f[_i - _skip - 1] >> _down;
++		  X_f[_i--] = X_f[0] << _up;
++		}
++	      for (; _i >= 0; --_i)
++		X_f[_i] = 0;
++	    }
++	  while (0);
++	}
++      else
++	{
++	  if (A_e == 0)
++	    {
++	      if (((A_f1 | A_f0) == 0))
++		X_e = 0;
++	      else
++		{
++		  int _lz;
++		  _fex |= (0);
++		  do
++		    {
++		      if (A_f1)
++			do
++			  {
++			    if (sizeof (unsigned long) ==
++				sizeof (unsigned int))
++			      _lz = __builtin_clz (A_f1);
++			    else if (sizeof (unsigned long) ==
++				     sizeof (unsigned long))
++			      _lz = __builtin_clzl (A_f1);
++			    else if (sizeof (unsigned long) ==
++				     sizeof (unsigned long long))
++			      _lz = __builtin_clzll (A_f1);
++			    else
++			      abort ();
++			  }
++			while (0);
++		      else
++			{
++			  do
++			    {
++			      if (sizeof (unsigned long) ==
++				  sizeof (unsigned int))
++				_lz = __builtin_clz (A_f0);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long))
++				_lz = __builtin_clzl (A_f0);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long long))
++				_lz = __builtin_clzll (A_f0);
++			      else
++				abort ();
++			    }
++			  while (0);
++			  _lz += 32;
++			}
++		    }
++		  while (0);
++		  do
++		    {
++		      long _up, _down, _skip, _i;
++		      _skip = (_lz + 113 - (2 * 32)) / 32;
++		      _up = (_lz + 113 - (2 * 32)) % 32;
++		      _down = 32 - _up;
++		      if (!_up)
++			for (_i = 3; _i >= _skip; --_i)
++			  X_f[_i] = X_f[_i - _skip];
++		      else
++			{
++			  for (_i = 3; _i > _skip; --_i)
++			    X_f[_i] =
++			      X_f[_i - _skip] << _up | X_f[_i - _skip -
++							   1] >> _down;
++			  X_f[_i--] = X_f[0] << _up;
++			}
++		      for (; _i >= 0; --_i)
++			X_f[_i] = 0;
++		    }
++		  while (0);
++		  X_e = (16383 - 1023 + 1 + ((2 * 32) - 53) - _lz);
++		}
++	    }
++	  else
++	    {
++	      X_e = 32767;
++	      if (!((A_f1 | A_f0) == 0))
++		{
++		  if (!((A_f1) & ((unsigned long) 1 << (53 - 2) % 32)))
++		    _fex |= (0);
++		  do
++		    {
++		      long _up, _down, _skip, _i;
++		      _skip = ((113 - 53)) / 32;
++		      _up = ((113 - 53)) % 32;
++		      _down = 32 - _up;
++		      if (!_up)
++			for (_i = 3; _i >= _skip; --_i)
++			  X_f[_i] = X_f[_i - _skip];
++		      else
++			{
++			  for (_i = 3; _i > _skip; --_i)
++			    X_f[_i] =
++			      X_f[_i - _skip] << _up | X_f[_i - _skip -
++							   1] >> _down;
++			  X_f[_i--] = X_f[0] << _up;
++			}
++		      for (; _i >= 0; --_i)
++			X_f[_i] = 0;
++		    }
++		  while (0);
++		}
++	    }
++	}
++    }
++  while (0);
++
++/*  FP_EXTEND(Q,D,4,2,Y,B) */
++  do
++    {
++      if (113 < 53 || (32767 - 16383 < 2047 - 1023) || 16383 < 1023 + 53 - 1)
++	abort ();
++      Y_s = B_s;
++      do
++	{
++	  Y_f[0] = B_f0;
++	  Y_f[1] = B_f1;
++	  Y_f[2] = Y_f[3] = 0;
++	}
++      while (0);
++      if ((((B_e + 1) & 2047) > 1))
++	{
++	  Y_e = B_e + 16383 - 1023;
++	  do
++	    {
++	      long _up, _down, _skip, _i;
++	      _skip = ((113 - 53)) / 32;
++	      _up = ((113 - 53)) % 32;
++	      _down = 32 - _up;
++	      if (!_up)
++		for (_i = 3; _i >= _skip; --_i)
++		  Y_f[_i] = Y_f[_i - _skip];
++	      else
++		{
++		  for (_i = 3; _i > _skip; --_i)
++		    Y_f[_i] =
++		      Y_f[_i - _skip] << _up | Y_f[_i - _skip - 1] >> _down;
++		  Y_f[_i--] = Y_f[0] << _up;
++		}
++	      for (; _i >= 0; --_i)
++		Y_f[_i] = 0;
++	    }
++	  while (0);
++	}
++      else
++	{
++	  if (B_e == 0)
++	    {
++	      if (((B_f1 | B_f0) == 0))
++		Y_e = 0;
++	      else
++		{
++		  int _lz;
++		  _fex |= (0);
++		  do
++		    {
++		      if (B_f1)
++			do
++			  {
++			    if (sizeof (unsigned long) ==
++				sizeof (unsigned int))
++			      _lz = __builtin_clz (B_f1);
++			    else if (sizeof (unsigned long) ==
++				     sizeof (unsigned long))
++			      _lz = __builtin_clzl (B_f1);
++			    else if (sizeof (unsigned long) ==
++				     sizeof (unsigned long long))
++			      _lz = __builtin_clzll (B_f1);
++			    else
++			      abort ();
++			  }
++			while (0);
++		      else
++			{
++			  do
++			    {
++			      if (sizeof (unsigned long) ==
++				  sizeof (unsigned int))
++				_lz = __builtin_clz (B_f0);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long))
++				_lz = __builtin_clzl (B_f0);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long long))
++				_lz = __builtin_clzll (B_f0);
++			      else
++				abort ();
++			    }
++			  while (0);
++			  _lz += 32;
++			}
++		    }
++		  while (0);
++		  do
++		    {
++		      long _up, _down, _skip, _i;
++		      _skip = (_lz + 113 - (2 * 32)) / 32;
++		      _up = (_lz + 113 - (2 * 32)) % 32;
++		      _down = 32 - _up;
++		      if (!_up)
++			for (_i = 3; _i >= _skip; --_i)
++			  Y_f[_i] = Y_f[_i - _skip];
++		      else
++			{
++			  for (_i = 3; _i > _skip; --_i)
++			    Y_f[_i] =
++			      Y_f[_i - _skip] << _up | Y_f[_i - _skip -
++							   1] >> _down;
++			  Y_f[_i--] = Y_f[0] << _up;
++			}
++		      for (; _i >= 0; --_i)
++			Y_f[_i] = 0;
++		    }
++		  while (0);
++		  Y_e = (16383 - 1023 + 1 + ((2 * 32) - 53) - _lz);
++		}
++	    }
++	  else
++	    {
++	      Y_e = 32767;
++	      if (!((B_f1 | B_f0) == 0))
++		{
++		  if (!((B_f1) & ((unsigned long) 1 << (53 - 2) % 32)))
++		    _fex |= (0);
++		  do
++		    {
++		      long _up, _down, _skip, _i;
++		      _skip = ((113 - 53)) / 32;
++		      _up = ((113 - 53)) % 32;
++		      _down = 32 - _up;
++		      if (!_up)
++			for (_i = 3; _i >= _skip; --_i)
++			  Y_f[_i] = Y_f[_i - _skip];
++		      else
++			{
++			  for (_i = 3; _i > _skip; --_i)
++			    Y_f[_i] =
++			      Y_f[_i - _skip] << _up | Y_f[_i - _skip -
++							   1] >> _down;
++			  Y_f[_i--] = Y_f[0] << _up;
++			}
++		      for (; _i >= 0; --_i)
++			Y_f[_i] = 0;
++		    }
++		  while (0);
++		}
++	    }
++	}
++    }
++  while (0);
++
++/*  FP_EXTEND(Q,D,4,2,Z,C) */
++  do
++    {
++      if (113 < 53 || (32767 - 16383 < 2047 - 1023) || 16383 < 1023 + 53 - 1)
++	abort ();
++      Z_s = C_s;
++      do
++	{
++	  Z_f[0] = C_f0;
++	  Z_f[1] = C_f1;
++	  Z_f[2] = Z_f[3] = 0;
++	}
++      while (0);
++      if ((((C_e + 1) & 2047) > 1))
++	{
++	  Z_e = C_e + 16383 - 1023;
++	  do
++	    {
++	      long _up, _down, _skip, _i;
++	      _skip = ((113 - 53)) / 32;
++	      _up = ((113 - 53)) % 32;
++	      _down = 32 - _up;
++	      if (!_up)
++		for (_i = 3; _i >= _skip; --_i)
++		  Z_f[_i] = Z_f[_i - _skip];
++	      else
++		{
++		  for (_i = 3; _i > _skip; --_i)
++		    Z_f[_i] =
++		      Z_f[_i - _skip] << _up | Z_f[_i - _skip - 1] >> _down;
++		  Z_f[_i--] = Z_f[0] << _up;
++		}
++	      for (; _i >= 0; --_i)
++		Z_f[_i] = 0;
++	    }
++	  while (0);
++	}
++      else
++	{
++	  if (C_e == 0)
++	    {
++	      if (((C_f1 | C_f0) == 0))
++		Z_e = 0;
++	      else
++		{
++		  int _lz;
++		  _fex |= (0);
++		  do
++		    {
++		      if (C_f1)
++			do
++			  {
++			    if (sizeof (unsigned long) ==
++				sizeof (unsigned int))
++			      _lz = __builtin_clz (C_f1);
++			    else if (sizeof (unsigned long) ==
++				     sizeof (unsigned long))
++			      _lz = __builtin_clzl (C_f1);
++			    else if (sizeof (unsigned long) ==
++				     sizeof (unsigned long long))
++			      _lz = __builtin_clzll (C_f1);
++			    else
++			      abort ();
++			  }
++			while (0);
++		      else
++			{
++			  do
++			    {
++			      if (sizeof (unsigned long) ==
++				  sizeof (unsigned int))
++				_lz = __builtin_clz (C_f0);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long))
++				_lz = __builtin_clzl (C_f0);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long long))
++				_lz = __builtin_clzll (C_f0);
++			      else
++				abort ();
++			    }
++			  while (0);
++			  _lz += 32;
++			}
++		    }
++		  while (0);
++		  do
++		    {
++		      long _up, _down, _skip, _i;
++		      _skip = (_lz + 113 - (2 * 32)) / 32;
++		      _up = (_lz + 113 - (2 * 32)) % 32;
++		      _down = 32 - _up;
++		      if (!_up)
++			for (_i = 3; _i >= _skip; --_i)
++			  Z_f[_i] = Z_f[_i - _skip];
++		      else
++			{
++			  for (_i = 3; _i > _skip; --_i)
++			    Z_f[_i] =
++			      Z_f[_i - _skip] << _up | Z_f[_i - _skip -
++							   1] >> _down;
++			  Z_f[_i--] = Z_f[0] << _up;
++			}
++		      for (; _i >= 0; --_i)
++			Z_f[_i] = 0;
++		    }
++		  while (0);
++		  Z_e = (16383 - 1023 + 1 + ((2 * 32) - 53) - _lz);
++		}
++	    }
++	  else
++	    {
++	      Z_e = 32767;
++	      if (!((C_f1 | C_f0) == 0))
++		{
++		  if (!((C_f1) & ((unsigned long) 1 << (53 - 2) % 32)))
++		    _fex |= (0);
++		  do
++		    {
++		      long _up, _down, _skip, _i;
++		      _skip = ((113 - 53)) / 32;
++		      _up = ((113 - 53)) % 32;
++		      _down = 32 - _up;
++		      if (!_up)
++			for (_i = 3; _i >= _skip; --_i)
++			  Z_f[_i] = Z_f[_i - _skip];
++		      else
++			{
++			  for (_i = 3; _i > _skip; --_i)
++			    Z_f[_i] =
++			      Z_f[_i - _skip] << _up | Z_f[_i - _skip -
++							   1] >> _down;
++			  Z_f[_i--] = Z_f[0] << _up;
++			}
++		      for (; _i >= 0; --_i)
++			Z_f[_i] = 0;
++		    }
++		  while (0);
++		}
++	    }
++	}
++    }
++  while (0);
++
++/*  FP_PACK_RAW_Q(x,X) */
++  do
++    {
++      union _FP_UNION_Q _flo;
++      _flo.bits.frac0 = X_f[0];
++      _flo.bits.frac1 = X_f[1];
++      _flo.bits.frac2 = X_f[2];
++      _flo.bits.frac3 = X_f[3];
++      _flo.bits.exp = X_e;
++      _flo.bits.sign = X_s;
++      (x) = _flo.flt;
++    }
++  while (0);
++
++/*  FP_PACK_RAW_Q(y,Y) */
++  do
++    {
++      union _FP_UNION_Q _flo;
++      _flo.bits.frac0 = Y_f[0];
++      _flo.bits.frac1 = Y_f[1];
++      _flo.bits.frac2 = Y_f[2];
++      _flo.bits.frac3 = Y_f[3];
++      _flo.bits.exp = Y_e;
++      _flo.bits.sign = Y_s;
++      (y) = _flo.flt;
++    }
++  while (0);
++
++/*  FP_PACK_RAW_Q(z,Z) */
++  do
++    {
++      union _FP_UNION_Q _flo;
++      _flo.bits.frac0 = Z_f[0];
++      _flo.bits.frac1 = Z_f[1];
++      _flo.bits.frac2 = Z_f[2];
++      _flo.bits.frac3 = Z_f[3];
++      _flo.bits.exp = Z_e;
++      _flo.bits.sign = Z_s;
++      (z) = _flo.flt;
++    }
++  while (0);
++
++/*  FP_HANDLE_EXCEPTIONS */
++  do
++    {
++    }
++  while (0);
++
++  /* Multiply.  */
++/*  FP_INIT_ROUNDMODE */
++  do
++    {
++    }
++  while (0);
++
++/*  FP_UNPACK_Q(X,x) */
++  do
++    {
++      do
++	{
++	  union _FP_UNION_Q _flo;
++	  _flo.flt = (x);
++	  X_f[0] = _flo.bits.frac0;
++	  X_f[1] = _flo.bits.frac1;
++	  X_f[2] = _flo.bits.frac2;
++	  X_f[3] = _flo.bits.frac3;
++	  X_e = _flo.bits.exp;
++	  X_s = _flo.bits.sign;
++	}
++      while (0);
++      do
++	{
++	  switch (X_e)
++	    {
++	    default:
++	      (X_f[3]) |= ((unsigned long) 1 << (113 - 1) % 32);
++	      do
++		{
++		  long _up, _down, _skip, _i;
++		  _skip = (3) / 32;
++		  _up = (3) % 32;
++		  _down = 32 - _up;
++		  if (!_up)
++		    for (_i = 3; _i >= _skip; --_i)
++		      X_f[_i] = X_f[_i - _skip];
++		  else
++		    {
++		      for (_i = 3; _i > _skip; --_i)
++			X_f[_i] =
++			  X_f[_i - _skip] << _up | X_f[_i - _skip -
++						       1] >> _down;
++		      X_f[_i--] = X_f[0] << _up;
++		    }
++		  for (; _i >= 0; --_i)
++		    X_f[_i] = 0;
++		}
++	      while (0);
++	      X_e -= 16383;
++	      X_c = 0;
++	      break;
++	    case 0:
++	      if (((X_f[0] | X_f[1] | X_f[2] | X_f[3]) == 0))
++		X_c = 1;
++	      else
++		{
++		  long _shift;
++		  do
++		    {
++		      if (X_f[3])
++			{
++			  do
++			    {
++			      if (sizeof (unsigned long) ==
++				  sizeof (unsigned int))
++				_shift = __builtin_clz (X_f[3]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long))
++				_shift = __builtin_clzl (X_f[3]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long long))
++				_shift = __builtin_clzll (X_f[3]);
++			      else
++				abort ();
++			    }
++			  while (0);
++			}
++		      else if (X_f[2])
++			{
++			  do
++			    {
++			      if (sizeof (unsigned long) ==
++				  sizeof (unsigned int))
++				_shift = __builtin_clz (X_f[2]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long))
++				_shift = __builtin_clzl (X_f[2]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long long))
++				_shift = __builtin_clzll (X_f[2]);
++			      else
++				abort ();
++			    }
++			  while (0);
++			  _shift += 32;
++			}
++		      else if (X_f[1])
++			{
++			  do
++			    {
++			      if (sizeof (unsigned long) ==
++				  sizeof (unsigned int))
++				_shift = __builtin_clz (X_f[1]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long))
++				_shift = __builtin_clzl (X_f[1]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long long))
++				_shift = __builtin_clzll (X_f[1]);
++			      else
++				abort ();
++			    }
++			  while (0);
++			  _shift += 32 * 2;
++			}
++		      else
++			{
++			  do
++			    {
++			      if (sizeof (unsigned long) ==
++				  sizeof (unsigned int))
++				_shift = __builtin_clz (X_f[0]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long))
++				_shift = __builtin_clzl (X_f[0]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long long))
++				_shift = __builtin_clzll (X_f[0]);
++			      else
++				abort ();
++			    }
++			  while (0);
++			  _shift += 32 * 3;
++			}
++		    }
++		  while (0);
++		  _shift -= ((4 * 32) - 113);
++		  do
++		    {
++		      long _up, _down, _skip, _i;
++		      _skip = ((_shift + 3)) / 32;
++		      _up = ((_shift + 3)) % 32;
++		      _down = 32 - _up;
++		      if (!_up)
++			for (_i = 3; _i >= _skip; --_i)
++			  X_f[_i] = X_f[_i - _skip];
++		      else
++			{
++			  for (_i = 3; _i > _skip; --_i)
++			    X_f[_i] =
++			      X_f[_i - _skip] << _up | X_f[_i - _skip -
++							   1] >> _down;
++			  X_f[_i--] = X_f[0] << _up;
++			}
++		      for (; _i >= 0; --_i)
++			X_f[_i] = 0;
++		    }
++		  while (0);
++		  X_e -= 16383 - 1 + _shift;
++		  X_c = 0;
++		  _fex |= (0);
++		}
++	      break;
++	    case 32767:
++	      if (((X_f[0] | X_f[1] | X_f[2] | X_f[3]) == 0))
++		X_c = 2;
++	      else
++		{
++		  X_c = 3;
++		  if (!((X_f[3]) & ((unsigned long) 1 << (113 - 2) % 32)))
++		    _fex |= (0);
++		} break;
++	    }
++	}
++      while (0);
++    }
++  while (0);
++
++/*  FP_UNPACK_Q(Y,y) */
++  do
++    {
++      do
++	{
++	  union _FP_UNION_Q _flo;
++	  _flo.flt = (y);
++	  Y_f[0] = _flo.bits.frac0;
++	  Y_f[1] = _flo.bits.frac1;
++	  Y_f[2] = _flo.bits.frac2;
++	  Y_f[3] = _flo.bits.frac3;
++	  Y_e = _flo.bits.exp;
++	  Y_s = _flo.bits.sign;
++	}
++      while (0);
++      do
++	{
++	  switch (Y_e)
++	    {
++	    default:
++	      (Y_f[3]) |= ((unsigned long) 1 << (113 - 1) % 32);
++	      do
++		{
++		  long _up, _down, _skip, _i;
++		  _skip = (3) / 32;
++		  _up = (3) % 32;
++		  _down = 32 - _up;
++		  if (!_up)
++		    for (_i = 3; _i >= _skip; --_i)
++		      Y_f[_i] = Y_f[_i - _skip];
++		  else
++		    {
++		      for (_i = 3; _i > _skip; --_i)
++			Y_f[_i] =
++			  Y_f[_i - _skip] << _up | Y_f[_i - _skip -
++						       1] >> _down;
++		      Y_f[_i--] = Y_f[0] << _up;
++		    }
++		  for (; _i >= 0; --_i)
++		    Y_f[_i] = 0;
++		}
++	      while (0);
++	      Y_e -= 16383;
++	      Y_c = 0;
++	      break;
++	    case 0:
++	      if (((Y_f[0] | Y_f[1] | Y_f[2] | Y_f[3]) == 0))
++		Y_c = 1;
++	      else
++		{
++		  long _shift;
++		  do
++		    {
++		      if (Y_f[3])
++			{
++			  do
++			    {
++			      if (sizeof (unsigned long) ==
++				  sizeof (unsigned int))
++				_shift = __builtin_clz (Y_f[3]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long))
++				_shift = __builtin_clzl (Y_f[3]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long long))
++				_shift = __builtin_clzll (Y_f[3]);
++			      else
++				abort ();
++			    }
++			  while (0);
++			}
++		      else if (Y_f[2])
++			{
++			  do
++			    {
++			      if (sizeof (unsigned long) ==
++				  sizeof (unsigned int))
++				_shift = __builtin_clz (Y_f[2]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long))
++				_shift = __builtin_clzl (Y_f[2]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long long))
++				_shift = __builtin_clzll (Y_f[2]);
++			      else
++				abort ();
++			    }
++			  while (0);
++			  _shift += 32;
++			}
++		      else if (Y_f[1])
++			{
++			  do
++			    {
++			      if (sizeof (unsigned long) ==
++				  sizeof (unsigned int))
++				_shift = __builtin_clz (Y_f[1]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long))
++				_shift = __builtin_clzl (Y_f[1]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long long))
++				_shift = __builtin_clzll (Y_f[1]);
++			      else
++				abort ();
++			    }
++			  while (0);
++			  _shift += 32 * 2;
++			}
++		      else
++			{
++			  do
++			    {
++			      if (sizeof (unsigned long) ==
++				  sizeof (unsigned int))
++				_shift = __builtin_clz (Y_f[0]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long))
++				_shift = __builtin_clzl (Y_f[0]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long long))
++				_shift = __builtin_clzll (Y_f[0]);
++			      else
++				abort ();
++			    }
++			  while (0);
++			  _shift += 32 * 3;
++			}
++		    }
++		  while (0);
++		  _shift -= ((4 * 32) - 113);
++		  do
++		    {
++		      long _up, _down, _skip, _i;
++		      _skip = ((_shift + 3)) / 32;
++		      _up = ((_shift + 3)) % 32;
++		      _down = 32 - _up;
++		      if (!_up)
++			for (_i = 3; _i >= _skip; --_i)
++			  Y_f[_i] = Y_f[_i - _skip];
++		      else
++			{
++			  for (_i = 3; _i > _skip; --_i)
++			    Y_f[_i] =
++			      Y_f[_i - _skip] << _up | Y_f[_i - _skip -
++							   1] >> _down;
++			  Y_f[_i--] = Y_f[0] << _up;
++			}
++		      for (; _i >= 0; --_i)
++			Y_f[_i] = 0;
++		    }
++		  while (0);
++		  Y_e -= 16383 - 1 + _shift;
++		  Y_c = 0;
++		  _fex |= (0);
++		}
++	      break;
++	    case 32767:
++	      if (((Y_f[0] | Y_f[1] | Y_f[2] | Y_f[3]) == 0))
++		Y_c = 2;
++	      else
++		{
++		  Y_c = 3;
++		  if (!((Y_f[3]) & ((unsigned long) 1 << (113 - 2) % 32)))
++		    _fex |= (0);
++		} break;
++	    }
++	}
++      while (0);
++    }
++  while (0);
++
++/*  FP_MUL_Q(U,X,Y) */
++  do
++    {
++      U_s = X_s ^ Y_s;
++      switch ((((X_c) << 2) | (Y_c)))
++	{
++	case (((0) << 2) | (0)):
++	  U_c = 0;
++	  U_e = X_e + Y_e + 1;
++	  do
++	    {
++	      unsigned long _z_f[8];
++	      unsigned long _b_f0, _b_f1;
++	      unsigned long _c_f0, _c_f1;
++	      unsigned long _d_f0, _d_f1;
++	      unsigned long _e_f0, _e_f1;
++	      unsigned long _f_f0, _f_f1;
++	      do
++		{
++		  USItype __m0 = (X_f[0]), __m1 = (Y_f[0]);
++		__asm__ ("mulhwu %0,%1,%2": "=r" ((_z_f[1])):"%r" (X_f[0]),
++			   "r" (Y_f
++				[0]));
++		  ((_z_f[0])) = __m0 * __m1;
++		}
++	      while (0);
++	      do
++		{
++		  USItype __m0 = (X_f[0]), __m1 = (Y_f[1]);
++		__asm__ ("mulhwu %0,%1,%2": "=r" (_b_f1):"%r" (X_f[0]),
++			   "r" (Y_f
++				[1]));
++		  (_b_f0) = __m0 * __m1;
++		}
++	      while (0);
++	      do
++		{
++		  USItype __m0 = (X_f[1]), __m1 = (Y_f[0]);
++		__asm__ ("mulhwu %0,%1,%2": "=r" (_c_f1):"%r" (X_f[1]),
++			   "r" (Y_f
++				[0]));
++		  (_c_f0) = __m0 * __m1;
++		}
++	      while (0);
++	      do
++		{
++		  USItype __m0 = (X_f[1]), __m1 = (Y_f[1]);
++		__asm__ ("mulhwu %0,%1,%2": "=r" (_d_f1):"%r" (X_f[1]),
++			   "r" (Y_f
++				[1]));
++		  (_d_f0) = __m0 * __m1;
++		}
++	      while (0);
++	      do
++		{
++		  USItype __m0 = (X_f[0]), __m1 = (Y_f[2]);
++		__asm__ ("mulhwu %0,%1,%2": "=r" (_e_f1):"%r" (X_f[0]),
++			   "r" (Y_f
++				[2]));
++		  (_e_f0) = __m0 * __m1;
++		}
++	      while (0);
++	      do
++		{
++		  USItype __m0 = (X_f[2]), __m1 = (Y_f[0]);
++		__asm__ ("mulhwu %0,%1,%2": "=r" (_f_f1):"%r" (X_f[2]),
++			   "r" (Y_f
++				[0]));
++		  (_f_f0) = __m0 * __m1;
++		}
++	      while (0);
++	      do
++		{
++		  unsigned long _c1, _c2;
++		  (_z_f[1]) = _b_f0 + (_z_f[1]);
++		  _c1 = (_z_f[1]) < _b_f0;
++		  (_z_f[2]) = _b_f1 + 0;
++		  _c2 = (_z_f[2]) < _b_f1;
++		  (_z_f[2]) += _c1;
++		  _c2 |= (_z_f[2]) < _c1;
++		  (_z_f[3]) = 0 + 0 + _c2;
++		}
++	      while (0);
++	      do
++		{
++		  unsigned long _c1, _c2;
++		  (_z_f[1]) = _c_f0 + (_z_f[1]);
++		  _c1 = (_z_f[1]) < _c_f0;
++		  (_z_f[2]) = _c_f1 + (_z_f[2]);
++		  _c2 = (_z_f[2]) < _c_f1;
++		  (_z_f[2]) += _c1;
++		  _c2 |= (_z_f[2]) < _c1;
++		  (_z_f[3]) = 0 + (_z_f[3]) + _c2;
++		}
++	      while (0);
++	      do
++		{
++		  unsigned long _c1, _c2;
++		  (_z_f[2]) = _d_f0 + (_z_f[2]);
++		  _c1 = (_z_f[2]) < _d_f0;
++		  (_z_f[3]) = _d_f1 + (_z_f[3]);
++		  _c2 = (_z_f[3]) < _d_f1;
++		  (_z_f[3]) += _c1;
++		  _c2 |= (_z_f[3]) < _c1;
++		  (_z_f[4]) = 0 + 0 + _c2;
++		}
++	      while (0);
++	      do
++		{
++		  unsigned long _c1, _c2;
++		  (_z_f[2]) = _e_f0 + (_z_f[2]);
++		  _c1 = (_z_f[2]) < _e_f0;
++		  (_z_f[3]) = _e_f1 + (_z_f[3]);
++		  _c2 = (_z_f[3]) < _e_f1;
++		  (_z_f[3]) += _c1;
++		  _c2 |= (_z_f[3]) < _c1;
++		  (_z_f[4]) = 0 + (_z_f[4]) + _c2;
++		}
++	      while (0);
++	      do
++		{
++		  unsigned long _c1, _c2;
++		  (_z_f[2]) = _f_f0 + (_z_f[2]);
++		  _c1 = (_z_f[2]) < _f_f0;
++		  (_z_f[3]) = _f_f1 + (_z_f[3]);
++		  _c2 = (_z_f[3]) < _f_f1;
++		  (_z_f[3]) += _c1;
++		  _c2 |= (_z_f[3]) < _c1;
++		  (_z_f[4]) = 0 + (_z_f[4]) + _c2;
++		}
++	      while (0);
++	      do
++		{
++		  USItype __m0 = (X_f[0]), __m1 = (Y_f[3]);
++		__asm__ ("mulhwu %0,%1,%2": "=r" (_b_f1):"%r" (X_f[0]),
++			   "r" (Y_f
++				[3]));
++		  (_b_f0) = __m0 * __m1;
++		}
++	      while (0);
++	      do
++		{
++		  USItype __m0 = (X_f[3]), __m1 = (Y_f[0]);
++		__asm__ ("mulhwu %0,%1,%2": "=r" (_c_f1):"%r" (X_f[3]),
++			   "r" (Y_f
++				[0]));
++		  (_c_f0) = __m0 * __m1;
++		}
++	      while (0);
++	      do
++		{
++		  USItype __m0 = (X_f[1]), __m1 = (Y_f[2]);
++		__asm__ ("mulhwu %0,%1,%2": "=r" (_d_f1):"%r" (X_f[1]),
++			   "r" (Y_f
++				[2]));
++		  (_d_f0) = __m0 * __m1;
++		}
++	      while (0);
++	      do
++		{
++		  USItype __m0 = (X_f[2]), __m1 = (Y_f[1]);
++		__asm__ ("mulhwu %0,%1,%2": "=r" (_e_f1):"%r" (X_f[2]),
++			   "r" (Y_f
++				[1]));
++		  (_e_f0) = __m0 * __m1;
++		}
++	      while (0);
++	      do
++		{
++		  unsigned long _c1, _c2;
++		  (_z_f[3]) = _b_f0 + (_z_f[3]);
++		  _c1 = (_z_f[3]) < _b_f0;
++		  (_z_f[4]) = _b_f1 + (_z_f[4]);
++		  _c2 = (_z_f[4]) < _b_f1;
++		  (_z_f[4]) += _c1;
++		  _c2 |= (_z_f[4]) < _c1;
++		  (_z_f[5]) = 0 + 0 + _c2;
++		}
++	      while (0);
++	      do
++		{
++		  unsigned long _c1, _c2;
++		  (_z_f[3]) = _c_f0 + (_z_f[3]);
++		  _c1 = (_z_f[3]) < _c_f0;
++		  (_z_f[4]) = _c_f1 + (_z_f[4]);
++		  _c2 = (_z_f[4]) < _c_f1;
++		  (_z_f[4]) += _c1;
++		  _c2 |= (_z_f[4]) < _c1;
++		  (_z_f[5]) = 0 + (_z_f[5]) + _c2;
++		}
++	      while (0);
++	      do
++		{
++		  unsigned long _c1, _c2;
++		  (_z_f[3]) = _d_f0 + (_z_f[3]);
++		  _c1 = (_z_f[3]) < _d_f0;
++		  (_z_f[4]) = _d_f1 + (_z_f[4]);
++		  _c2 = (_z_f[4]) < _d_f1;
++		  (_z_f[4]) += _c1;
++		  _c2 |= (_z_f[4]) < _c1;
++		  (_z_f[5]) = 0 + (_z_f[5]) + _c2;
++		}
++	      while (0);
++	      do
++		{
++		  unsigned long _c1, _c2;
++		  (_z_f[3]) = _e_f0 + (_z_f[3]);
++		  _c1 = (_z_f[3]) < _e_f0;
++		  (_z_f[4]) = _e_f1 + (_z_f[4]);
++		  _c2 = (_z_f[4]) < _e_f1;
++		  (_z_f[4]) += _c1;
++		  _c2 |= (_z_f[4]) < _c1;
++		  (_z_f[5]) = 0 + (_z_f[5]) + _c2;
++		}
++	      while (0);
++	      do
++		{
++		  USItype __m0 = (X_f[2]), __m1 = (Y_f[2]);
++		__asm__ ("mulhwu %0,%1,%2": "=r" (_b_f1):"%r" (X_f[2]),
++			   "r" (Y_f
++				[2]));
++		  (_b_f0) = __m0 * __m1;
++		}
++	      while (0);
++	      do
++		{
++		  USItype __m0 = (X_f[1]), __m1 = (Y_f[3]);
++		__asm__ ("mulhwu %0,%1,%2": "=r" (_c_f1):"%r" (X_f[1]),
++			   "r" (Y_f
++				[3]));
++		  (_c_f0) = __m0 * __m1;
++		}
++	      while (0);
++	      do
++		{
++		  USItype __m0 = (X_f[3]), __m1 = (Y_f[1]);
++		__asm__ ("mulhwu %0,%1,%2": "=r" (_d_f1):"%r" (X_f[3]),
++			   "r" (Y_f
++				[1]));
++		  (_d_f0) = __m0 * __m1;
++		}
++	      while (0);
++	      do
++		{
++		  USItype __m0 = (X_f[2]), __m1 = (Y_f[3]);
++		__asm__ ("mulhwu %0,%1,%2": "=r" (_e_f1):"%r" (X_f[2]),
++			   "r" (Y_f
++				[3]));
++		  (_e_f0) = __m0 * __m1;
++		}
++	      while (0);
++	      do
++		{
++		  USItype __m0 = (X_f[3]), __m1 = (Y_f[2]);
++		__asm__ ("mulhwu %0,%1,%2": "=r" (_f_f1):"%r" (X_f[3]),
++			   "r" (Y_f
++				[2]));
++		  (_f_f0) = __m0 * __m1;
++		}
++	      while (0);
++	      do
++		{
++		  unsigned long _c1, _c2;
++		  (_z_f[4]) = _b_f0 + (_z_f[4]);
++		  _c1 = (_z_f[4]) < _b_f0;
++		  (_z_f[5]) = _b_f1 + (_z_f[5]);
++		  _c2 = (_z_f[5]) < _b_f1;
++		  (_z_f[5]) += _c1;
++		  _c2 |= (_z_f[5]) < _c1;
++		  (_z_f[6]) = 0 + 0 + _c2;
++		}
++	      while (0);
++	      do
++		{
++		  unsigned long _c1, _c2;
++		  (_z_f[4]) = _c_f0 + (_z_f[4]);
++		  _c1 = (_z_f[4]) < _c_f0;
++		  (_z_f[5]) = _c_f1 + (_z_f[5]);
++		  _c2 = (_z_f[5]) < _c_f1;
++		  (_z_f[5]) += _c1;
++		  _c2 |= (_z_f[5]) < _c1;
++		  (_z_f[6]) = 0 + (_z_f[6]) + _c2;
++		}
++	      while (0);
++	      do
++		{
++		  unsigned long _c1, _c2;
++		  (_z_f[4]) = _d_f0 + (_z_f[4]);
++		  _c1 = (_z_f[4]) < _d_f0;
++		  (_z_f[5]) = _d_f1 + (_z_f[5]);
++		  _c2 = (_z_f[5]) < _d_f1;
++		  (_z_f[5]) += _c1;
++		  _c2 |= (_z_f[5]) < _c1;
++		  (_z_f[6]) = 0 + (_z_f[6]) + _c2;
++		}
++	      while (0);
++	      do
++		{
++		  unsigned long _c1, _c2;
++		  (_z_f[5]) = _e_f0 + (_z_f[5]);
++		  _c1 = (_z_f[5]) < _e_f0;
++		  (_z_f[6]) = _e_f1 + (_z_f[6]);
++		  _c2 = (_z_f[6]) < _e_f1;
++		  (_z_f[6]) += _c1;
++		  _c2 |= (_z_f[6]) < _c1;
++		  (_z_f[7]) = 0 + 0 + _c2;
++		}
++	      while (0);
++	      do
++		{
++		  unsigned long _c1, _c2;
++		  (_z_f[5]) = _f_f0 + (_z_f[5]);
++		  _c1 = (_z_f[5]) < _f_f0;
++		  (_z_f[6]) = _f_f1 + (_z_f[6]);
++		  _c2 = (_z_f[6]) < _f_f1;
++		  (_z_f[6]) += _c1;
++		  _c2 |= (_z_f[6]) < _c1;
++		  (_z_f[7]) = 0 + (_z_f[7]) + _c2;
++		}
++	      while (0);
++	      do
++		{
++		  USItype __m0 = (X_f[3]), __m1 = (Y_f[3]);
++		__asm__ ("mulhwu %0,%1,%2": "=r" (_b_f1):"%r" (X_f[3]),
++			   "r" (Y_f
++				[3]));
++		  (_b_f0) = __m0 * __m1;
++		}
++	      while (0);
++	      do
++		{
++		  if (__builtin_constant_p ((_z_f[7])) && ((_z_f[7])) == 0)
++		  __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{aze|addze} %0,%2": "=r" ((_z_f[7])), "=&r" ((_z_f[6])):"r" (_b_f1), "%r" (_b_f0),
++			     "rI" ((_z_f
++				    [6])));
++		  else if (__builtin_constant_p ((_z_f[7]))
++			   && ((_z_f[7])) == ~(USItype) 0)
++		  __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{ame|addme} %0,%2": "=r" ((_z_f[7])), "=&r" ((_z_f[6])):"r" (_b_f1), "%r" (_b_f0),
++			     "rI" ((_z_f
++				    [6])));
++		  else
++		  __asm__ ("{a%I5|add%I5c} %1,%4,%5\n\t{ae|adde} %0,%2,%3": "=r" ((_z_f[7])), "=&r" ((_z_f[6])):"%r" (_b_f1), "r" ((_z_f[7])), "%r" (_b_f0),
++			     "rI" ((_z_f
++				    [6])));
++		}
++	      while (0);
++	      do
++		{
++		  long _up, _down, _skip, _i;
++		  unsigned long _s;
++		  _skip = ((3 + 113) - 1) / 32;
++		  _down = ((3 + 113) - 1) % 32;
++		  _up = 32 - _down;
++		  for (_s = _i = 0; _i < _skip; ++_i)
++		    _s |= _z_f[_i];
++		  if (!_down)
++		    for (_i = 0; _i <= 7 - _skip; ++_i)
++		      _z_f[_i] = _z_f[_i + _skip];
++		  else
++		    {
++		      _s |= _z_f[_i] << _up;
++		      for (_i = 0; _i < 7 - _skip; ++_i)
++			_z_f[_i] =
++			  _z_f[_i + _skip] >> _down | _z_f[_i + _skip +
++							   1] << _up;
++		      _z_f[_i++] = _z_f[7] >> _down;
++		    }
++		  for (; _i < 8; ++_i)
++		    _z_f[_i] = 0;
++		  _z_f[0] |= (_s != 0);
++		}
++	      while (0);
++	      (U_f[3] = (_z_f[3]), U_f[2] = (_z_f[2]), U_f[1] =
++	       (_z_f[1]), U_f[0] = (_z_f[0]));
++	    }
++	  while (0);
++	  if (((U_f[3]) & ((unsigned long) 1 << ((3 + 113) % 32))))
++	    do
++	      {
++		int _sticky;
++		do
++		  {
++		    long _up, _down, _skip, _i;
++		    unsigned long _s;
++		    _skip = (1) / 32;
++		    _down = (1) % 32;
++		    _up = 32 - _down;
++		    for (_s = _i = 0; _i < _skip; ++_i)
++		      _s |= U_f[_i];
++		    if (!_down)
++		      for (_i = 0; _i <= 3 - _skip; ++_i)
++			U_f[_i] = U_f[_i + _skip];
++		    else
++		      {
++			_s |= U_f[_i] << _up;
++			for (_i = 0; _i < 3 - _skip; ++_i)
++			  U_f[_i] =
++			    U_f[_i + _skip] >> _down | U_f[_i + _skip +
++							   1] << _up;
++			U_f[_i++] = U_f[3] >> _down;
++		      }
++		    for (; _i < 4; ++_i)
++		      U_f[_i] = 0;
++		    _sticky = (_s != 0);
++		  }
++		while (0);
++		U_f[0] |= _sticky;
++	      }
++	    while (0);
++	  else
++	    U_e--;
++	  break;
++	case (((3) << 2) | (3)):
++	  do
++	    {
++	      if (((X_f[3]) & ((unsigned long) 1 << (113 - 2) % 32))
++		  && !((Y_f[3]) & ((unsigned long) 1 << (113 - 2) % 32)))
++		{
++		  U_s = Y_s;
++		  (U_f[0] = Y_f[0], U_f[1] = Y_f[1], U_f[2] = Y_f[2], U_f[3] =
++		   Y_f[3]);
++		}
++	      else
++		{
++		  U_s = X_s;
++		  (U_f[0] = X_f[0], U_f[1] = X_f[1], U_f[2] = X_f[2], U_f[3] =
++		   X_f[3]);
++		}
++	      U_c = 3;
++	    }
++	  while (0);
++	  break;
++	case (((3) << 2) | (0)):
++	case (((3) << 2) | (2)):
++	case (((3) << 2) | (1)):
++	  U_s = X_s;
++	case (((2) << 2) | (2)):
++	case (((2) << 2) | (0)):
++	case (((1) << 2) | (0)):
++	case (((1) << 2) | (1)):
++	  (U_f[0] = X_f[0], U_f[1] = X_f[1], U_f[2] = X_f[2], U_f[3] =
++	   X_f[3]);
++	  U_c = X_c;
++	  break;
++	case (((0) << 2) | (3)):
++	case (((2) << 2) | (3)):
++	case (((1) << 2) | (3)):
++	  U_s = Y_s;
++	case (((0) << 2) | (2)):
++	case (((0) << 2) | (1)):
++	  (U_f[0] = Y_f[0], U_f[1] = Y_f[1], U_f[2] = Y_f[2], U_f[3] =
++	   Y_f[3]);
++	  U_c = Y_c;
++	  break;
++	case (((2) << 2) | (1)):
++	case (((1) << 2) | (2)):
++	  U_s = 0;
++	  U_c = 3;
++	  (U_f[3] =
++	   ((((unsigned long) 1 << (113 - 2) % 32) << 1) - 1), U_f[2] =
++	   -1, U_f[1] = -1, U_f[0] = -1);
++	  _fex |= (0);
++	  break;
++	default:
++	  abort ();
++	}
++    }
++  while (0);
++
++/*  FP_PACK_Q(u,U) */
++  do
++    {
++      do
++	{
++	  switch (U_c)
++	    {
++	    case 0:
++	      U_e += 16383;
++	      if (U_e > 0)
++		{
++		  do
++		    {
++		      if ((U_f[0]) & 7)
++			_fex |= (0);
++		      switch (0)
++			{
++			case 0:
++			  do
++			    {
++			      if (((U_f[0]) & 15) != ((unsigned long) 1 << 2))
++				do
++				  {
++				    unsigned long _t;
++				    _t =
++				      ((U_f[0] +=
++					((unsigned long) 1 << 2)) <
++				       ((unsigned long) 1 << 2));
++				    U_f[1] += _t;
++				    _t = (U_f[1] < _t);
++				    U_f[2] += _t;
++				    _t = (U_f[2] < _t);
++				    U_f[3] += _t;
++				  }
++				while (0);
++			    }
++			  while (0);
++			  break;
++			case 1:
++			  (void) 0;
++			  break;
++			case 2:
++			  do
++			    {
++			      if (!U_s && ((U_f[0]) & 7))
++				do
++				  {
++				    unsigned long _t;
++				    _t =
++				      ((U_f[0] +=
++					((unsigned long) 1 << 3)) <
++				       ((unsigned long) 1 << 3));
++				    U_f[1] += _t;
++				    _t = (U_f[1] < _t);
++				    U_f[2] += _t;
++				    _t = (U_f[2] < _t);
++				    U_f[3] += _t;
++				  }
++				while (0);
++			    }
++			  while (0);
++			  break;
++			case 3:
++			  do
++			    {
++			      if (U_s && ((U_f[0]) & 7))
++				do
++				  {
++				    unsigned long _t;
++				    _t =
++				      ((U_f[0] +=
++					((unsigned long) 1 << 3)) <
++				       ((unsigned long) 1 << 3));
++				    U_f[1] += _t;
++				    _t = (U_f[1] < _t);
++				    U_f[2] += _t;
++				    _t = (U_f[2] < _t);
++				    U_f[3] += _t;
++				  }
++				while (0);
++			    }
++			  while (0);
++			  break;
++			}
++		    }
++		  while (0);
++		  if (((U_f[3]) & ((unsigned long) 1 << ((3 + 113) % 32))))
++		    {
++		      ((U_f[3]) &= ~((unsigned long) 1 << ((3 + 113) % 32)));
++		      U_e++;
++		    }
++		  do
++		    {
++		      long _up, _down, _skip, _i;
++		      _skip = (3) / 32;
++		      _down = (3) % 32;
++		      _up = 32 - _down;
++		      if (!_down)
++			for (_i = 0; _i <= 3 - _skip; ++_i)
++			  U_f[_i] = U_f[_i + _skip];
++		      else
++			{
++			  for (_i = 0; _i < 3 - _skip; ++_i)
++			    U_f[_i] =
++			      U_f[_i + _skip] >> _down | U_f[_i + _skip +
++							     1] << _up;
++			  U_f[_i++] = U_f[3] >> _down;
++			}
++		      for (; _i < 4; ++_i)
++			U_f[_i] = 0;
++		    }
++		  while (0);
++		  if (U_e >= 32767)
++		    {
++		      switch (0)
++			{
++			case 0:
++			  U_c = 2;
++			  break;
++			case 2:
++			  if (!U_s)
++			    U_c = 2;
++			  break;
++			case 3:
++			  if (U_s)
++			    U_c = 2;
++			  break;
++			}
++		      if (U_c == 2)
++			{
++			  U_e = 32767;
++			  (U_f[3] = 0, U_f[2] = 0, U_f[1] = 0, U_f[0] = 0);
++			}
++		      else
++			{
++			  U_e = 32767 - 1;
++			  (U_f[3] = (~(signed long) 0), U_f[2] =
++			   (~(signed long) 0), U_f[1] =
++			   (~(signed long) 0), U_f[0] = (~(signed long) 0));
++			} _fex |= (0);
++		      _fex |= (0);
++		    }
++		}
++	      else
++		{
++		  U_e = -U_e + 1;
++		  if (U_e <= (3 + 113))
++		    {
++		      do
++			{
++			  int _sticky;
++			  do
++			    {
++			      long _up, _down, _skip, _i;
++			      unsigned long _s;
++			      _skip = (U_e) / 32;
++			      _down = (U_e) % 32;
++			      _up = 32 - _down;
++			      for (_s = _i = 0; _i < _skip; ++_i)
++				_s |= U_f[_i];
++			      if (!_down)
++				for (_i = 0; _i <= 3 - _skip; ++_i)
++				  U_f[_i] = U_f[_i + _skip];
++			      else
++				{
++				  _s |= U_f[_i] << _up;
++				  for (_i = 0; _i < 3 - _skip; ++_i)
++				    U_f[_i] =
++				      U_f[_i + _skip] >> _down | U_f[_i +
++								     _skip +
++								     1] <<
++				      _up;
++				  U_f[_i++] = U_f[3] >> _down;
++				}
++			      for (; _i < 4; ++_i)
++				U_f[_i] = 0;
++			      _sticky = (_s != 0);
++			    }
++			  while (0);
++			  U_f[0] |= _sticky;
++			}
++		      while (0);
++		      do
++			{
++			  if ((U_f[0]) & 7)
++			    _fex |= (0);
++			  switch (0)
++			    {
++			    case 0:
++			      do
++				{
++				  if (((U_f[0]) & 15) !=
++				      ((unsigned long) 1 << 2))
++				    do
++				      {
++					unsigned long _t;
++					_t =
++					  ((U_f[0] +=
++					    ((unsigned long) 1 << 2)) <
++					   ((unsigned long) 1 << 2));
++					U_f[1] += _t;
++					_t = (U_f[1] < _t);
++					U_f[2] += _t;
++					_t = (U_f[2] < _t);
++					U_f[3] += _t;
++				      }
++				    while (0);
++				}
++			      while (0);
++			      break;
++			    case 1:
++			      (void) 0;
++			      break;
++			    case 2:
++			      do
++				{
++				  if (!U_s && ((U_f[0]) & 7))
++				    do
++				      {
++					unsigned long _t;
++					_t =
++					  ((U_f[0] +=
++					    ((unsigned long) 1 << 3)) <
++					   ((unsigned long) 1 << 3));
++					U_f[1] += _t;
++					_t = (U_f[1] < _t);
++					U_f[2] += _t;
++					_t = (U_f[2] < _t);
++					U_f[3] += _t;
++				      }
++				    while (0);
++				}
++			      while (0);
++			      break;
++			    case 3:
++			      do
++				{
++				  if (U_s && ((U_f[0]) & 7))
++				    do
++				      {
++					unsigned long _t;
++					_t =
++					  ((U_f[0] +=
++					    ((unsigned long) 1 << 3)) <
++					   ((unsigned long) 1 << 3));
++					U_f[1] += _t;
++					_t = (U_f[1] < _t);
++					U_f[2] += _t;
++					_t = (U_f[2] < _t);
++					U_f[3] += _t;
++				      }
++				    while (0);
++				}
++			      while (0);
++			      break;
++			    }
++			}
++		      while (0);
++		      if ((U_f[3]) &
++			  (((unsigned long) 1 << ((3 + 113) % 32)) >> 1))
++			{
++			  U_e = 1;
++			  (U_f[3] = 0, U_f[2] = 0, U_f[1] = 0, U_f[0] = 0);
++			}
++		      else
++			{
++			  U_e = 0;
++			  do
++			    {
++			      long _up, _down, _skip, _i;
++			      _skip = (3) / 32;
++			      _down = (3) % 32;
++			      _up = 32 - _down;
++			      if (!_down)
++				for (_i = 0; _i <= 3 - _skip; ++_i)
++				  U_f[_i] = U_f[_i + _skip];
++			      else
++				{
++				  for (_i = 0; _i < 3 - _skip; ++_i)
++				    U_f[_i] =
++				      U_f[_i + _skip] >> _down | U_f[_i +
++								     _skip +
++								     1] <<
++				      _up;
++				  U_f[_i++] = U_f[3] >> _down;
++				}
++			      for (; _i < 4; ++_i)
++				U_f[_i] = 0;
++			    }
++			  while (0);
++			  _fex |= (0);
++			}
++		    }
++		  else
++		    {
++		      U_e = 0;
++		      if (!((U_f[0] | U_f[1] | U_f[2] | U_f[3]) == 0))
++			{
++			  (U_f[3] = 0, U_f[2] = 0, U_f[1] = 0, U_f[0] = 1);
++			  do
++			    {
++			      if ((U_f[0]) & 7)
++				_fex |= (0);
++			      switch (0)
++				{
++				case 0:
++				  do
++				    {
++				      if (((U_f[0]) & 15) !=
++					  ((unsigned long) 1 << 2))
++					do
++					  {
++					    unsigned long _t;
++					    _t =
++					      ((U_f[0] +=
++						((unsigned long) 1 << 2)) <
++					       ((unsigned long) 1 << 2));
++					    U_f[1] += _t;
++					    _t = (U_f[1] < _t);
++					    U_f[2] += _t;
++					    _t = (U_f[2] < _t);
++					    U_f[3] += _t;
++					  }
++					while (0);
++				    }
++				  while (0);
++				  break;
++				case 1:
++				  (void) 0;
++				  break;
++				case 2:
++				  do
++				    {
++				      if (!U_s && ((U_f[0]) & 7))
++					do
++					  {
++					    unsigned long _t;
++					    _t =
++					      ((U_f[0] +=
++						((unsigned long) 1 << 3)) <
++					       ((unsigned long) 1 << 3));
++					    U_f[1] += _t;
++					    _t = (U_f[1] < _t);
++					    U_f[2] += _t;
++					    _t = (U_f[2] < _t);
++					    U_f[3] += _t;
++					  }
++					while (0);
++				    }
++				  while (0);
++				  break;
++				case 3:
++				  do
++				    {
++				      if (U_s && ((U_f[0]) & 7))
++					do
++					  {
++					    unsigned long _t;
++					    _t =
++					      ((U_f[0] +=
++						((unsigned long) 1 << 3)) <
++					       ((unsigned long) 1 << 3));
++					    U_f[1] += _t;
++					    _t = (U_f[1] < _t);
++					    U_f[2] += _t;
++					    _t = (U_f[2] < _t);
++					    U_f[3] += _t;
++					  }
++					while (0);
++				    }
++				  while (0);
++				  break;
++				}
++			    }
++			  while (0);
++			  (U_f[0]) >>= (3);
++			}
++		      _fex |= (0);
++		    }
++		}
++	      break;
++	    case 1:
++	      U_e = 0;
++	      (U_f[3] = 0, U_f[2] = 0, U_f[1] = 0, U_f[0] = 0);
++	      break;
++	    case 2:
++	      U_e = 32767;
++	      (U_f[3] = 0, U_f[2] = 0, U_f[1] = 0, U_f[0] = 0);
++	      break;
++	    case 3:
++	      U_e = 32767;
++	      if (!1)
++		{
++		  (U_f[3] =
++		   ((((unsigned long) 1 << (113 - 2) % 32) << 1) - 1),
++		   U_f[2] = -1, U_f[1] = -1, U_f[0] = -1);
++		  U_s = 0;
++		}
++	      else
++		(U_f[3]) |= ((unsigned long) 1 << (113 - 2) % 32);
++	      break;
++	    }
++	}
++      while (0);
++      do
++	{
++	  union _FP_UNION_Q _flo;
++	  _flo.bits.frac0 = U_f[0];
++	  _flo.bits.frac1 = U_f[1];
++	  _flo.bits.frac2 = U_f[2];
++	  _flo.bits.frac3 = U_f[3];
++	  _flo.bits.exp = U_e;
++	  _flo.bits.sign = U_s;
++	  (u) = _flo.flt;
++	}
++      while (0);
++    }
++  while (0);
++
++/*  FP_HANDLE_EXCEPTIONS */
++  do
++    {
++    }
++  while (0);
++
++  /* Subtract.  */
++/*  FP_INIT_ROUNDMODE */
++  do
++    {
++    }
++  while (0);
++
++/*  FP_UNPACK_SEMIRAW_Q(U,u) */
++  do
++    {
++      do
++	{
++	  union _FP_UNION_Q _flo;
++	  _flo.flt = (u);
++	  U_f[0] = _flo.bits.frac0;
++	  U_f[1] = _flo.bits.frac1;
++	  U_f[2] = _flo.bits.frac2;
++	  U_f[3] = _flo.bits.frac3;
++	  U_e = _flo.bits.exp;
++	  U_s = _flo.bits.sign;
++	}
++      while (0);
++      do
++	{
++	  long _up, _down, _skip, _i;
++	  _skip = (3) / 32;
++	  _up = (3) % 32;
++	  _down = 32 - _up;
++	  if (!_up)
++	    for (_i = 3; _i >= _skip; --_i)
++	      U_f[_i] = U_f[_i - _skip];
++	  else
++	    {
++	      for (_i = 3; _i > _skip; --_i)
++		U_f[_i] =
++		  U_f[_i - _skip] << _up | U_f[_i - _skip - 1] >> _down;
++	      U_f[_i--] = U_f[0] << _up;
++	    }
++	  for (; _i >= 0; --_i)
++	    U_f[_i] = 0;
++	}
++      while (0);
++    }
++  while (0);
++
++/*  FP_UNPACK_SEMIRAW_Q(Z,z) */
++  do
++    {
++      do
++	{
++	  union _FP_UNION_Q _flo;
++	  _flo.flt = (z);
++	  Z_f[0] = _flo.bits.frac0;
++	  Z_f[1] = _flo.bits.frac1;
++	  Z_f[2] = _flo.bits.frac2;
++	  Z_f[3] = _flo.bits.frac3;
++	  Z_e = _flo.bits.exp;
++	  Z_s = _flo.bits.sign;
++	}
++      while (0);
++      do
++	{
++	  long _up, _down, _skip, _i;
++	  _skip = (3) / 32;
++	  _up = (3) % 32;
++	  _down = 32 - _up;
++	  if (!_up)
++	    for (_i = 3; _i >= _skip; --_i)
++	      Z_f[_i] = Z_f[_i - _skip];
++	  else
++	    {
++	      for (_i = 3; _i > _skip; --_i)
++		Z_f[_i] =
++		  Z_f[_i - _skip] << _up | Z_f[_i - _skip - 1] >> _down;
++	      Z_f[_i--] = Z_f[0] << _up;
++	    }
++	  for (; _i >= 0; --_i)
++	    Z_f[_i] = 0;
++	}
++      while (0);
++    }
++  while (0);
++
++/*  FP_SUB_Q(V,U,Z) */
++  do
++    {
++      if (!(Z_e == 32767 && !((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) == 0)))
++	Z_s ^= 1;
++      do
++	{
++	  if (U_s == Z_s)
++	    {
++	      V_s = U_s;
++	      int ediff = U_e - Z_e;
++	      if (ediff > 0)
++		{
++		  V_e = U_e;
++		  if (Z_e == 0)
++		    {
++		      if (((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) == 0))
++			{
++			  do
++			    {
++			      if (U_e == 32767
++				  && !((U_f[0] | U_f[1] | U_f[2] | U_f[3]) ==
++				       0)
++				  && !((U_f[3]) &
++				       ((unsigned long) 1 << (113 - 2 + 3) %
++					32)))
++				_fex |= (0);
++			    }
++			  while (0);
++			  (V_f[0] = U_f[0], V_f[1] = U_f[1], V_f[2] =
++			   U_f[2], V_f[3] = U_f[3]);
++			  goto add_done;
++			}
++		      else
++			{
++			  _fex |= (0);
++			  ediff--;
++			  if (ediff == 0)
++			    {
++			      do
++				{
++				  unsigned long _c1, _c2, _c3;
++				  V_f[0] = U_f[0] + Z_f[0];
++				  _c1 = V_f[0] < U_f[0];
++				  V_f[1] = U_f[1] + Z_f[1];
++				  _c2 = V_f[1] < U_f[1];
++				  V_f[1] += _c1;
++				  _c2 |= V_f[1] < _c1;
++				  V_f[2] = U_f[2] + Z_f[2];
++				  _c3 = V_f[2] < U_f[2];
++				  V_f[2] += _c2;
++				  _c3 |= V_f[2] < _c2;
++				  V_f[3] = U_f[3] + Z_f[3] + _c3;
++				}
++			      while (0);
++			      goto add3;
++			    }
++			  if (U_e == 32767)
++			    {
++			      do
++				{
++				  if (U_e == 32767
++				      && !((U_f[0] | U_f[1] | U_f[2] | U_f[3])
++					   == 0)
++				      && !((U_f[3]) &
++					   ((unsigned long) 1 << (113 - 2 + 3)
++					    % 32)))
++				    _fex |= (0);
++				}
++			      while (0);
++			      (V_f[0] = U_f[0], V_f[1] = U_f[1], V_f[2] =
++			       U_f[2], V_f[3] = U_f[3]);
++			      goto add_done;
++			    }
++			  goto add1;
++			}
++		    }
++		  else if (U_e == 32767)
++		    {
++		      do
++			{
++			  if (U_e == 32767
++			      && !((U_f[0] | U_f[1] | U_f[2] | U_f[3]) == 0)
++			      && !((U_f[3]) &
++				   ((unsigned long) 1 << (113 - 2 + 3) % 32)))
++			    _fex |= (0);
++			}
++		      while (0);
++		      (V_f[0] = U_f[0], V_f[1] = U_f[1], V_f[2] =
++		       U_f[2], V_f[3] = U_f[3]);
++		      goto add_done;
++		    }
++		  (Z_f[3]) |= ((unsigned long) 1 << (113 - 1 + 3) % 32);
++		add1:if (ediff <= (3 + 113))
++		    do
++		      {
++			int _sticky;
++			do
++			  {
++			    long _up, _down, _skip, _i;
++			    unsigned long _s;
++			    _skip = (ediff) / 32;
++			    _down = (ediff) % 32;
++			    _up = 32 - _down;
++			    for (_s = _i = 0; _i < _skip; ++_i)
++			      _s |= Z_f[_i];
++			    if (!_down)
++			      for (_i = 0; _i <= 3 - _skip; ++_i)
++				Z_f[_i] = Z_f[_i + _skip];
++			    else
++			      {
++				_s |= Z_f[_i] << _up;
++				for (_i = 0; _i < 3 - _skip; ++_i)
++				  Z_f[_i] =
++				    Z_f[_i + _skip] >> _down | Z_f[_i +
++								   _skip +
++								   1] << _up;
++				Z_f[_i++] = Z_f[3] >> _down;
++			      }
++			    for (; _i < 4; ++_i)
++			      Z_f[_i] = 0;
++			    _sticky = (_s != 0);
++			  }
++			while (0);
++			Z_f[0] |= _sticky;
++		      }
++		    while (0);
++		  else if (!((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) == 0))
++		    (Z_f[3] = 0, Z_f[2] = 0, Z_f[1] = 0, Z_f[0] = 1);
++		  do
++		    {
++		      unsigned long _c1, _c2, _c3;
++		      V_f[0] = U_f[0] + Z_f[0];
++		      _c1 = V_f[0] < U_f[0];
++		      V_f[1] = U_f[1] + Z_f[1];
++		      _c2 = V_f[1] < U_f[1];
++		      V_f[1] += _c1;
++		      _c2 |= V_f[1] < _c1;
++		      V_f[2] = U_f[2] + Z_f[2];
++		      _c3 = V_f[2] < U_f[2];
++		      V_f[2] += _c2;
++		      _c3 |= V_f[2] < _c2;
++		      V_f[3] = U_f[3] + Z_f[3] + _c3;
++		    }
++		  while (0);
++		}
++	      else if (ediff < 0)
++		{
++		  ediff = -ediff;
++		  V_e = Z_e;
++		  if (U_e == 0)
++		    {
++		      if (((U_f[0] | U_f[1] | U_f[2] | U_f[3]) == 0))
++			{
++			  do
++			    {
++			      if (Z_e == 32767
++				  && !((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) ==
++				       0)
++				  && !((Z_f[3]) &
++				       ((unsigned long) 1 << (113 - 2 + 3) %
++					32)))
++				_fex |= (0);
++			    }
++			  while (0);
++			  (V_f[0] = Z_f[0], V_f[1] = Z_f[1], V_f[2] =
++			   Z_f[2], V_f[3] = Z_f[3]);
++			  goto add_done;
++			}
++		      else
++			{
++			  _fex |= (0);
++			  ediff--;
++			  if (ediff == 0)
++			    {
++			      do
++				{
++				  unsigned long _c1, _c2, _c3;
++				  V_f[0] = Z_f[0] + U_f[0];
++				  _c1 = V_f[0] < Z_f[0];
++				  V_f[1] = Z_f[1] + U_f[1];
++				  _c2 = V_f[1] < Z_f[1];
++				  V_f[1] += _c1;
++				  _c2 |= V_f[1] < _c1;
++				  V_f[2] = Z_f[2] + U_f[2];
++				  _c3 = V_f[2] < Z_f[2];
++				  V_f[2] += _c2;
++				  _c3 |= V_f[2] < _c2;
++				  V_f[3] = Z_f[3] + U_f[3] + _c3;
++				}
++			      while (0);
++			      goto add3;
++			    }
++			  if (Z_e == 32767)
++			    {
++			      do
++				{
++				  if (Z_e == 32767
++				      && !((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3])
++					   == 0)
++				      && !((Z_f[3]) &
++					   ((unsigned long) 1 << (113 - 2 + 3)
++					    % 32)))
++				    _fex |= (0);
++				}
++			      while (0);
++			      (V_f[0] = Z_f[0], V_f[1] = Z_f[1], V_f[2] =
++			       Z_f[2], V_f[3] = Z_f[3]);
++			      goto add_done;
++			    }
++			  goto add2;
++			}
++		    }
++		  else if (Z_e == 32767)
++		    {
++		      do
++			{
++			  if (Z_e == 32767
++			      && !((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) == 0)
++			      && !((Z_f[3]) &
++				   ((unsigned long) 1 << (113 - 2 + 3) % 32)))
++			    _fex |= (0);
++			}
++		      while (0);
++		      (V_f[0] = Z_f[0], V_f[1] = Z_f[1], V_f[2] =
++		       Z_f[2], V_f[3] = Z_f[3]);
++		      goto add_done;
++		    }
++		  (U_f[3]) |= ((unsigned long) 1 << (113 - 1 + 3) % 32);
++		add2:if (ediff <= (3 + 113))
++		    do
++		      {
++			int _sticky;
++			do
++			  {
++			    long _up, _down, _skip, _i;
++			    unsigned long _s;
++			    _skip = (ediff) / 32;
++			    _down = (ediff) % 32;
++			    _up = 32 - _down;
++			    for (_s = _i = 0; _i < _skip; ++_i)
++			      _s |= U_f[_i];
++			    if (!_down)
++			      for (_i = 0; _i <= 3 - _skip; ++_i)
++				U_f[_i] = U_f[_i + _skip];
++			    else
++			      {
++				_s |= U_f[_i] << _up;
++				for (_i = 0; _i < 3 - _skip; ++_i)
++				  U_f[_i] =
++				    U_f[_i + _skip] >> _down | U_f[_i +
++								   _skip +
++								   1] << _up;
++				U_f[_i++] = U_f[3] >> _down;
++			      }
++			    for (; _i < 4; ++_i)
++			      U_f[_i] = 0;
++			    _sticky = (_s != 0);
++			  }
++			while (0);
++			U_f[0] |= _sticky;
++		      }
++		    while (0);
++		  else if (!((U_f[0] | U_f[1] | U_f[2] | U_f[3]) == 0))
++		    (U_f[3] = 0, U_f[2] = 0, U_f[1] = 0, U_f[0] = 1);
++		  do
++		    {
++		      unsigned long _c1, _c2, _c3;
++		      V_f[0] = Z_f[0] + U_f[0];
++		      _c1 = V_f[0] < Z_f[0];
++		      V_f[1] = Z_f[1] + U_f[1];
++		      _c2 = V_f[1] < Z_f[1];
++		      V_f[1] += _c1;
++		      _c2 |= V_f[1] < _c1;
++		      V_f[2] = Z_f[2] + U_f[2];
++		      _c3 = V_f[2] < Z_f[2];
++		      V_f[2] += _c2;
++		      _c3 |= V_f[2] < _c2;
++		      V_f[3] = Z_f[3] + U_f[3] + _c3;
++		    }
++		  while (0);
++		}
++	      else
++		{
++		  if (!(((U_e + 1) & 32767) > 1))
++		    {
++		      if (U_e == 0)
++			{
++			  V_e = 0;
++			  if (((U_f[0] | U_f[1] | U_f[2] | U_f[3]) == 0))
++			    {
++			      if (!((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) == 0))
++				_fex |= (0);
++			      (V_f[0] = Z_f[0], V_f[1] = Z_f[1], V_f[2] =
++			       Z_f[2], V_f[3] = Z_f[3]);
++			      goto add_done;
++			    }
++			  else if (((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) == 0))
++			    {
++			      _fex |= (0);
++			      (V_f[0] = U_f[0], V_f[1] = U_f[1], V_f[2] =
++			       U_f[2], V_f[3] = U_f[3]);
++			      goto add_done;
++			    }
++			  else
++			    {
++			      _fex |= (0);
++			      do
++				{
++				  unsigned long _c1, _c2, _c3;
++				  V_f[0] = U_f[0] + Z_f[0];
++				  _c1 = V_f[0] < U_f[0];
++				  V_f[1] = U_f[1] + Z_f[1];
++				  _c2 = V_f[1] < U_f[1];
++				  V_f[1] += _c1;
++				  _c2 |= V_f[1] < _c1;
++				  V_f[2] = U_f[2] + Z_f[2];
++				  _c3 = V_f[2] < U_f[2];
++				  V_f[2] += _c2;
++				  _c3 |= V_f[2] < _c2;
++				  V_f[3] = U_f[3] + Z_f[3] + _c3;
++				}
++			      while (0);
++			      if ((V_f[3]) &
++				  ((unsigned long) 1 << (113 - 1 + 3) % 32))
++				{
++				  (V_f[3]) &=
++				    ~(unsigned long) ((unsigned long) 1 <<
++						      (113 - 1 + 3) % 32);
++				  V_e = 1;
++				}
++			      goto add_done;
++			    }
++			}
++		      else
++			{
++			  do
++			    {
++			      if (U_e == 32767
++				  && !((U_f[0] | U_f[1] | U_f[2] | U_f[3]) ==
++				       0)
++				  && !((U_f[3]) &
++				       ((unsigned long) 1 << (113 - 2 + 3) %
++					32)))
++				_fex |= (0);
++			    }
++			  while (0);
++			  do
++			    {
++			      if (Z_e == 32767
++				  && !((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) ==
++				       0)
++				  && !((Z_f[3]) &
++				       ((unsigned long) 1 << (113 - 2 + 3) %
++					32)))
++				_fex |= (0);
++			    }
++			  while (0);
++			  V_e = 32767;
++			  if (((U_f[0] | U_f[1] | U_f[2] | U_f[3]) == 0))
++			    (V_f[0] = Z_f[0], V_f[1] = Z_f[1], V_f[2] =
++			     Z_f[2], V_f[3] = Z_f[3]);
++			  else if (((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) == 0))
++			    (V_f[0] = U_f[0], V_f[1] = U_f[1], V_f[2] =
++			     U_f[2], V_f[3] = U_f[3]);
++			  else
++			    do
++			      {
++				do
++				  {
++				    long _up, _down, _skip, _i;
++				    _skip = (3) / 32;
++				    _down = (3) % 32;
++				    _up = 32 - _down;
++				    if (!_down)
++				      for (_i = 0; _i <= 3 - _skip; ++_i)
++					U_f[_i] = U_f[_i + _skip];
++				    else
++				      {
++					for (_i = 0; _i < 3 - _skip; ++_i)
++					  U_f[_i] =
++					    U_f[_i +
++						_skip] >> _down | U_f[_i +
++								      _skip +
++								      1] <<
++					    _up;
++					U_f[_i++] = U_f[3] >> _down;
++				      }
++				    for (; _i < 4; ++_i)
++				      U_f[_i] = 0;
++				  }
++				while (0);
++				do
++				  {
++				    long _up, _down, _skip, _i;
++				    _skip = (3) / 32;
++				    _down = (3) % 32;
++				    _up = 32 - _down;
++				    if (!_down)
++				      for (_i = 0; _i <= 3 - _skip; ++_i)
++					Z_f[_i] = Z_f[_i + _skip];
++				    else
++				      {
++					for (_i = 0; _i < 3 - _skip; ++_i)
++					  Z_f[_i] =
++					    Z_f[_i +
++						_skip] >> _down | Z_f[_i +
++								      _skip +
++								      1] <<
++					    _up;
++					Z_f[_i++] = Z_f[3] >> _down;
++				      }
++				    for (; _i < 4; ++_i)
++				      Z_f[_i] = 0;
++				  }
++				while (0);
++				do
++				  {
++				    if (((U_f[3]) &
++					 ((unsigned long) 1 << (113 - 2) %
++					  32))
++					&& !((Z_f[3]) &
++					     ((unsigned long) 1 << (113 - 2) %
++					      32)))
++				      {
++					V_s = Z_s;
++					(V_f[0] = Z_f[0], V_f[1] =
++					 Z_f[1], V_f[2] = Z_f[2], V_f[3] =
++					 Z_f[3]);
++				      }
++				    else
++				      {
++					V_s = U_s;
++					(V_f[0] = U_f[0], V_f[1] =
++					 U_f[1], V_f[2] = U_f[2], V_f[3] =
++					 U_f[3]);
++				      }
++				    V_c = 3;
++				  }
++				while (0);
++				do
++				  {
++				    long _up, _down, _skip, _i;
++				    _skip = (3) / 32;
++				    _up = (3) % 32;
++				    _down = 32 - _up;
++				    if (!_up)
++				      for (_i = 3; _i >= _skip; --_i)
++					V_f[_i] = V_f[_i - _skip];
++				    else
++				      {
++					for (_i = 3; _i > _skip; --_i)
++					  V_f[_i] =
++					    V_f[_i - _skip] << _up | V_f[_i -
++									 _skip
++									 -
++									 1] >>
++					    _down;
++					V_f[_i--] = V_f[0] << _up;
++				      }
++				    for (; _i >= 0; --_i)
++				      V_f[_i] = 0;
++				  }
++				while (0);
++			      }
++			    while (0);
++			  goto add_done;
++			}
++		    }
++		  do
++		    {
++		      unsigned long _c1, _c2, _c3;
++		      V_f[0] = U_f[0] + Z_f[0];
++		      _c1 = V_f[0] < U_f[0];
++		      V_f[1] = U_f[1] + Z_f[1];
++		      _c2 = V_f[1] < U_f[1];
++		      V_f[1] += _c1;
++		      _c2 |= V_f[1] < _c1;
++		      V_f[2] = U_f[2] + Z_f[2];
++		      _c3 = V_f[2] < U_f[2];
++		      V_f[2] += _c2;
++		      _c3 |= V_f[2] < _c2;
++		      V_f[3] = U_f[3] + Z_f[3] + _c3;
++		    }
++		  while (0);
++		  V_e = U_e + 1;
++		  do
++		    {
++		      int _sticky;
++		      do
++			{
++			  long _up, _down, _skip, _i;
++			  unsigned long _s;
++			  _skip = (1) / 32;
++			  _down = (1) % 32;
++			  _up = 32 - _down;
++			  for (_s = _i = 0; _i < _skip; ++_i)
++			    _s |= V_f[_i];
++			  if (!_down)
++			    for (_i = 0; _i <= 3 - _skip; ++_i)
++			      V_f[_i] = V_f[_i + _skip];
++			  else
++			    {
++			      _s |= V_f[_i] << _up;
++			      for (_i = 0; _i < 3 - _skip; ++_i)
++				V_f[_i] =
++				  V_f[_i + _skip] >> _down | V_f[_i + _skip +
++								 1] << _up;
++			      V_f[_i++] = V_f[3] >> _down;
++			    }
++			  for (; _i < 4; ++_i)
++			    V_f[_i] = 0;
++			  _sticky = (_s != 0);
++			}
++		      while (0);
++		      V_f[0] |= _sticky;
++		    }
++		  while (0);
++		  if (V_e == 32767)
++		    do
++		      {
++			if (0 == 0 || (0 == 2 && !V_s) || (0 == 3 && V_s))
++			  {
++			    V_e = 32767;
++			    (V_f[3] = 0, V_f[2] = 0, V_f[1] = 0, V_f[0] = 0);
++			  }
++			else
++			  {
++			    V_e = 32767 - 1;
++			    _fex |= (0);
++			    _fex |= (0);
++			    (V_f[3] = (~(signed long) 0), V_f[2] =
++			     (~(signed long) 0), V_f[1] =
++			     (~(signed long) 0), V_f[0] = (~(signed long) 0));
++			  }
++		      }
++		    while (0);
++		  goto add_done;
++		}
++	    add3:if ((V_f[3]) &
++		  ((unsigned long) 1 << (113 - 1 + 3) % 32))
++		{
++		  (V_f[3]) &=
++		    ~(unsigned long) ((unsigned long) 1 << (113 - 1 + 3) %
++				      32);
++		  V_e++;
++		  do
++		    {
++		      int _sticky;
++		      do
++			{
++			  long _up, _down, _skip, _i;
++			  unsigned long _s;
++			  _skip = (1) / 32;
++			  _down = (1) % 32;
++			  _up = 32 - _down;
++			  for (_s = _i = 0; _i < _skip; ++_i)
++			    _s |= V_f[_i];
++			  if (!_down)
++			    for (_i = 0; _i <= 3 - _skip; ++_i)
++			      V_f[_i] = V_f[_i + _skip];
++			  else
++			    {
++			      _s |= V_f[_i] << _up;
++			      for (_i = 0; _i < 3 - _skip; ++_i)
++				V_f[_i] =
++				  V_f[_i + _skip] >> _down | V_f[_i + _skip +
++								 1] << _up;
++			      V_f[_i++] = V_f[3] >> _down;
++			    }
++			  for (; _i < 4; ++_i)
++			    V_f[_i] = 0;
++			  _sticky = (_s != 0);
++			}
++		      while (0);
++		      V_f[0] |= _sticky;
++		    }
++		  while (0);
++		  if (V_e == 32767)
++		    do
++		      {
++			if (0 == 0 || (0 == 2 && !V_s) || (0 == 3 && V_s))
++			  {
++			    V_e = 32767;
++			    (V_f[3] = 0, V_f[2] = 0, V_f[1] = 0, V_f[0] = 0);
++			  }
++			else
++			  {
++			    V_e = 32767 - 1;
++			    _fex |= (0);
++			    _fex |= (0);
++			    (V_f[3] = (~(signed long) 0), V_f[2] =
++			     (~(signed long) 0), V_f[1] =
++			     (~(signed long) 0), V_f[0] = (~(signed long) 0));
++			  }
++		      }
++		    while (0);
++		}
++	    add_done:;
++	    }
++	  else
++	    {
++	      int ediff = U_e - Z_e;
++	      if (ediff > 0)
++		{
++		  V_e = U_e;
++		  V_s = U_s;
++		  if (Z_e == 0)
++		    {
++		      if (((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) == 0))
++			{
++			  do
++			    {
++			      if (U_e == 32767
++				  && !((U_f[0] | U_f[1] | U_f[2] | U_f[3]) ==
++				       0)
++				  && !((U_f[3]) &
++				       ((unsigned long) 1 << (113 - 2 + 3) %
++					32)))
++				_fex |= (0);
++			    }
++			  while (0);
++			  (V_f[0] = U_f[0], V_f[1] = U_f[1], V_f[2] =
++			   U_f[2], V_f[3] = U_f[3]);
++			  goto sub_done;
++			}
++		      else
++			{
++			  _fex |= (0);
++			  ediff--;
++			  if (ediff == 0)
++			    {
++			      do
++				{
++				  unsigned long _c1, _c2, _c3;
++				  V_f[0] = U_f[0] - Z_f[0];
++				  _c1 = V_f[0] > U_f[0];
++				  V_f[1] = U_f[1] - Z_f[1];
++				  _c2 = V_f[1] > U_f[1];
++				  V_f[1] -= _c1;
++				  _c2 |= _c1 && (Z_f[1] == U_f[1]);
++				  V_f[2] = U_f[2] - Z_f[2];
++				  _c3 = V_f[2] > U_f[2];
++				  V_f[2] -= _c2;
++				  _c3 |= _c2 && (Z_f[2] == U_f[2]);
++				  V_f[3] = U_f[3] - Z_f[3] - _c3;
++				}
++			      while (0);
++			      goto sub3;
++			    }
++			  if (U_e == 32767)
++			    {
++			      do
++				{
++				  if (U_e == 32767
++				      && !((U_f[0] | U_f[1] | U_f[2] | U_f[3])
++					   == 0)
++				      && !((U_f[3]) &
++					   ((unsigned long) 1 << (113 - 2 + 3)
++					    % 32)))
++				    _fex |= (0);
++				}
++			      while (0);
++			      (V_f[0] = U_f[0], V_f[1] = U_f[1], V_f[2] =
++			       U_f[2], V_f[3] = U_f[3]);
++			      goto sub_done;
++			    }
++			  goto sub1;
++			}
++		    }
++		  else if (U_e == 32767)
++		    {
++		      do
++			{
++			  if (U_e == 32767
++			      && !((U_f[0] | U_f[1] | U_f[2] | U_f[3]) == 0)
++			      && !((U_f[3]) &
++				   ((unsigned long) 1 << (113 - 2 + 3) % 32)))
++			    _fex |= (0);
++			}
++		      while (0);
++		      (V_f[0] = U_f[0], V_f[1] = U_f[1], V_f[2] =
++		       U_f[2], V_f[3] = U_f[3]);
++		      goto sub_done;
++		    }
++		  (Z_f[3]) |= ((unsigned long) 1 << (113 - 1 + 3) % 32);
++		sub1:if (ediff <= (3 + 113))
++		    do
++		      {
++			int _sticky;
++			do
++			  {
++			    long _up, _down, _skip, _i;
++			    unsigned long _s;
++			    _skip = (ediff) / 32;
++			    _down = (ediff) % 32;
++			    _up = 32 - _down;
++			    for (_s = _i = 0; _i < _skip; ++_i)
++			      _s |= Z_f[_i];
++			    if (!_down)
++			      for (_i = 0; _i <= 3 - _skip; ++_i)
++				Z_f[_i] = Z_f[_i + _skip];
++			    else
++			      {
++				_s |= Z_f[_i] << _up;
++				for (_i = 0; _i < 3 - _skip; ++_i)
++				  Z_f[_i] =
++				    Z_f[_i + _skip] >> _down | Z_f[_i +
++								   _skip +
++								   1] << _up;
++				Z_f[_i++] = Z_f[3] >> _down;
++			      }
++			    for (; _i < 4; ++_i)
++			      Z_f[_i] = 0;
++			    _sticky = (_s != 0);
++			  }
++			while (0);
++			Z_f[0] |= _sticky;
++		      }
++		    while (0);
++		  else if (!((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) == 0))
++		    (Z_f[3] = 0, Z_f[2] = 0, Z_f[1] = 0, Z_f[0] = 1);
++		  do
++		    {
++		      unsigned long _c1, _c2, _c3;
++		      V_f[0] = U_f[0] - Z_f[0];
++		      _c1 = V_f[0] > U_f[0];
++		      V_f[1] = U_f[1] - Z_f[1];
++		      _c2 = V_f[1] > U_f[1];
++		      V_f[1] -= _c1;
++		      _c2 |= _c1 && (Z_f[1] == U_f[1]);
++		      V_f[2] = U_f[2] - Z_f[2];
++		      _c3 = V_f[2] > U_f[2];
++		      V_f[2] -= _c2;
++		      _c3 |= _c2 && (Z_f[2] == U_f[2]);
++		      V_f[3] = U_f[3] - Z_f[3] - _c3;
++		    }
++		  while (0);
++		}
++	      else if (ediff < 0)
++		{
++		  ediff = -ediff;
++		  V_e = Z_e;
++		  V_s = Z_s;
++		  if (U_e == 0)
++		    {
++		      if (((U_f[0] | U_f[1] | U_f[2] | U_f[3]) == 0))
++			{
++			  do
++			    {
++			      if (Z_e == 32767
++				  && !((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) ==
++				       0)
++				  && !((Z_f[3]) &
++				       ((unsigned long) 1 << (113 - 2 + 3) %
++					32)))
++				_fex |= (0);
++			    }
++			  while (0);
++			  (V_f[0] = Z_f[0], V_f[1] = Z_f[1], V_f[2] =
++			   Z_f[2], V_f[3] = Z_f[3]);
++			  goto sub_done;
++			}
++		      else
++			{
++			  _fex |= (0);
++			  ediff--;
++			  if (ediff == 0)
++			    {
++			      do
++				{
++				  unsigned long _c1, _c2, _c3;
++				  V_f[0] = Z_f[0] - U_f[0];
++				  _c1 = V_f[0] > Z_f[0];
++				  V_f[1] = Z_f[1] - U_f[1];
++				  _c2 = V_f[1] > Z_f[1];
++				  V_f[1] -= _c1;
++				  _c2 |= _c1 && (U_f[1] == Z_f[1]);
++				  V_f[2] = Z_f[2] - U_f[2];
++				  _c3 = V_f[2] > Z_f[2];
++				  V_f[2] -= _c2;
++				  _c3 |= _c2 && (U_f[2] == Z_f[2]);
++				  V_f[3] = Z_f[3] - U_f[3] - _c3;
++				}
++			      while (0);
++			      goto sub3;
++			    }
++			  if (Z_e == 32767)
++			    {
++			      do
++				{
++				  if (Z_e == 32767
++				      && !((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3])
++					   == 0)
++				      && !((Z_f[3]) &
++					   ((unsigned long) 1 << (113 - 2 + 3)
++					    % 32)))
++				    _fex |= (0);
++				}
++			      while (0);
++			      (V_f[0] = Z_f[0], V_f[1] = Z_f[1], V_f[2] =
++			       Z_f[2], V_f[3] = Z_f[3]);
++			      goto sub_done;
++			    }
++			  goto sub2;
++			}
++		    }
++		  else if (Z_e == 32767)
++		    {
++		      do
++			{
++			  if (Z_e == 32767
++			      && !((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) == 0)
++			      && !((Z_f[3]) &
++				   ((unsigned long) 1 << (113 - 2 + 3) % 32)))
++			    _fex |= (0);
++			}
++		      while (0);
++		      (V_f[0] = Z_f[0], V_f[1] = Z_f[1], V_f[2] =
++		       Z_f[2], V_f[3] = Z_f[3]);
++		      goto sub_done;
++		    }
++		  (U_f[3]) |= ((unsigned long) 1 << (113 - 1 + 3) % 32);
++		sub2:if (ediff <= (3 + 113))
++		    do
++		      {
++			int _sticky;
++			do
++			  {
++			    long _up, _down, _skip, _i;
++			    unsigned long _s;
++			    _skip = (ediff) / 32;
++			    _down = (ediff) % 32;
++			    _up = 32 - _down;
++			    for (_s = _i = 0; _i < _skip; ++_i)
++			      _s |= U_f[_i];
++			    if (!_down)
++			      for (_i = 0; _i <= 3 - _skip; ++_i)
++				U_f[_i] = U_f[_i + _skip];
++			    else
++			      {
++				_s |= U_f[_i] << _up;
++				for (_i = 0; _i < 3 - _skip; ++_i)
++				  U_f[_i] =
++				    U_f[_i + _skip] >> _down | U_f[_i +
++								   _skip +
++								   1] << _up;
++				U_f[_i++] = U_f[3] >> _down;
++			      }
++			    for (; _i < 4; ++_i)
++			      U_f[_i] = 0;
++			    _sticky = (_s != 0);
++			  }
++			while (0);
++			U_f[0] |= _sticky;
++		      }
++		    while (0);
++		  else if (!((U_f[0] | U_f[1] | U_f[2] | U_f[3]) == 0))
++		    (U_f[3] = 0, U_f[2] = 0, U_f[1] = 0, U_f[0] = 1);
++		  do
++		    {
++		      unsigned long _c1, _c2, _c3;
++		      V_f[0] = Z_f[0] - U_f[0];
++		      _c1 = V_f[0] > Z_f[0];
++		      V_f[1] = Z_f[1] - U_f[1];
++		      _c2 = V_f[1] > Z_f[1];
++		      V_f[1] -= _c1;
++		      _c2 |= _c1 && (U_f[1] == Z_f[1]);
++		      V_f[2] = Z_f[2] - U_f[2];
++		      _c3 = V_f[2] > Z_f[2];
++		      V_f[2] -= _c2;
++		      _c3 |= _c2 && (U_f[2] == Z_f[2]);
++		      V_f[3] = Z_f[3] - U_f[3] - _c3;
++		    }
++		  while (0);
++		}
++	      else
++		{
++		  if (!(((U_e + 1) & 32767) > 1))
++		    {
++		      if (U_e == 0)
++			{
++			  V_e = 0;
++			  if (((U_f[0] | U_f[1] | U_f[2] | U_f[3]) == 0))
++			    {
++			      (V_f[0] = Z_f[0], V_f[1] = Z_f[1], V_f[2] =
++			       Z_f[2], V_f[3] = Z_f[3]);
++			      if (((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) == 0))
++				V_s = (0 == 3);
++			      else
++				{
++				  _fex |= (0);
++				  V_s = Z_s;
++				}
++			      goto sub_done;
++			    }
++			  else if (((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) == 0))
++			    {
++			      _fex |= (0);
++			      (V_f[0] = U_f[0], V_f[1] = U_f[1], V_f[2] =
++			       U_f[2], V_f[3] = U_f[3]);
++			      V_s = U_s;
++			      goto sub_done;
++			    }
++			  else
++			    {
++			      _fex |= (0);
++			      do
++				{
++				  unsigned long _c1, _c2, _c3;
++				  V_f[0] = U_f[0] - Z_f[0];
++				  _c1 = V_f[0] > U_f[0];
++				  V_f[1] = U_f[1] - Z_f[1];
++				  _c2 = V_f[1] > U_f[1];
++				  V_f[1] -= _c1;
++				  _c2 |= _c1 && (Z_f[1] == U_f[1]);
++				  V_f[2] = U_f[2] - Z_f[2];
++				  _c3 = V_f[2] > U_f[2];
++				  V_f[2] -= _c2;
++				  _c3 |= _c2 && (Z_f[2] == U_f[2]);
++				  V_f[3] = U_f[3] - Z_f[3] - _c3;
++				}
++			      while (0);
++			      V_s = U_s;
++			      if ((V_f[3]) &
++				  ((unsigned long) 1 << (113 - 1 + 3) % 32))
++				{
++				  do
++				    {
++				      unsigned long _c1, _c2, _c3;
++				      V_f[0] = Z_f[0] - U_f[0];
++				      _c1 = V_f[0] > Z_f[0];
++				      V_f[1] = Z_f[1] - U_f[1];
++				      _c2 = V_f[1] > Z_f[1];
++				      V_f[1] -= _c1;
++				      _c2 |= _c1 && (U_f[1] == Z_f[1]);
++				      V_f[2] = Z_f[2] - U_f[2];
++				      _c3 = V_f[2] > Z_f[2];
++				      V_f[2] -= _c2;
++				      _c3 |= _c2 && (U_f[2] == Z_f[2]);
++				      V_f[3] = Z_f[3] - U_f[3] - _c3;
++				    }
++				  while (0);
++				  V_s = Z_s;
++				}
++			      else
++				if (((V_f[0] | V_f[1] | V_f[2] | V_f[3]) ==
++				     0))
++				V_s = (0 == 3);
++			      goto sub_done;
++			    }
++			}
++		      else
++			{
++			  do
++			    {
++			      if (U_e == 32767
++				  && !((U_f[0] | U_f[1] | U_f[2] | U_f[3]) ==
++				       0)
++				  && !((U_f[3]) &
++				       ((unsigned long) 1 << (113 - 2 + 3) %
++					32)))
++				_fex |= (0);
++			    }
++			  while (0);
++			  do
++			    {
++			      if (Z_e == 32767
++				  && !((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) ==
++				       0)
++				  && !((Z_f[3]) &
++				       ((unsigned long) 1 << (113 - 2 + 3) %
++					32)))
++				_fex |= (0);
++			    }
++			  while (0);
++			  V_e = 32767;
++			  if (((U_f[0] | U_f[1] | U_f[2] | U_f[3]) == 0))
++			    {
++			      if (((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) == 0))
++				{
++				  V_s = 0;
++				  (V_f[3] =
++				   ((((unsigned long) 1 << (113 - 2) %
++				      32) << 1) - 1), V_f[2] = -1, V_f[1] =
++				   -1, V_f[0] = -1);
++				  do
++				    {
++				      long _up, _down, _skip, _i;
++				      _skip = (3) / 32;
++				      _up = (3) % 32;
++				      _down = 32 - _up;
++				      if (!_up)
++					for (_i = 3; _i >= _skip; --_i)
++					  V_f[_i] = V_f[_i - _skip];
++				      else
++					{
++					  for (_i = 3; _i > _skip; --_i)
++					    V_f[_i] =
++					      V_f[_i -
++						  _skip] << _up | V_f[_i -
++								      _skip -
++								      1] >>
++					      _down;
++					  V_f[_i--] = V_f[0] << _up;
++					}
++				      for (; _i >= 0; --_i)
++					V_f[_i] = 0;
++				    }
++				  while (0);
++				  _fex |= (0);
++				}
++			      else
++				{
++				  V_s = Z_s;
++				  (V_f[0] = Z_f[0], V_f[1] = Z_f[1], V_f[2] =
++				   Z_f[2], V_f[3] = Z_f[3]);
++				}
++			    }
++			  else
++			    {
++			      if (((Z_f[0] | Z_f[1] | Z_f[2] | Z_f[3]) == 0))
++				{
++				  V_s = U_s;
++				  (V_f[0] = U_f[0], V_f[1] = U_f[1], V_f[2] =
++				   U_f[2], V_f[3] = U_f[3]);
++				}
++			      else
++				{
++				  do
++				    {
++				      do
++					{
++					  long _up, _down, _skip, _i;
++					  _skip = (3) / 32;
++					  _down = (3) % 32;
++					  _up = 32 - _down;
++					  if (!_down)
++					    for (_i = 0; _i <= 3 - _skip;
++						 ++_i)
++					      U_f[_i] = U_f[_i + _skip];
++					  else
++					    {
++					      for (_i = 0; _i < 3 - _skip;
++						   ++_i)
++						U_f[_i] =
++						  U_f[_i +
++						      _skip] >> _down | U_f[_i
++									    +
++									    _skip
++									    +
++									    1]
++						  << _up;
++					      U_f[_i++] = U_f[3] >> _down;
++					    }
++					  for (; _i < 4; ++_i)
++					    U_f[_i] = 0;
++					}
++				      while (0);
++				      do
++					{
++					  long _up, _down, _skip, _i;
++					  _skip = (3) / 32;
++					  _down = (3) % 32;
++					  _up = 32 - _down;
++					  if (!_down)
++					    for (_i = 0; _i <= 3 - _skip;
++						 ++_i)
++					      Z_f[_i] = Z_f[_i + _skip];
++					  else
++					    {
++					      for (_i = 0; _i < 3 - _skip;
++						   ++_i)
++						Z_f[_i] =
++						  Z_f[_i +
++						      _skip] >> _down | Z_f[_i
++									    +
++									    _skip
++									    +
++									    1]
++						  << _up;
++					      Z_f[_i++] = Z_f[3] >> _down;
++					    }
++					  for (; _i < 4; ++_i)
++					    Z_f[_i] = 0;
++					}
++				      while (0);
++				      do
++					{
++					  if (((U_f[3]) &
++					       ((unsigned long) 1 << (113 - 2)
++						% 32))
++					      && !((Z_f[3]) &
++						   ((unsigned long) 1 <<
++						    (113 - 2) % 32)))
++					    {
++					      V_s = Z_s;
++					      (V_f[0] = Z_f[0], V_f[1] =
++					       Z_f[1], V_f[2] =
++					       Z_f[2], V_f[3] = Z_f[3]);
++					    }
++					  else
++					    {
++					      V_s = U_s;
++					      (V_f[0] = U_f[0], V_f[1] =
++					       U_f[1], V_f[2] =
++					       U_f[2], V_f[3] = U_f[3]);
++					    }
++					  V_c = 3;
++					}
++				      while (0);
++				      do
++					{
++					  long _up, _down, _skip, _i;
++					  _skip = (3) / 32;
++					  _up = (3) % 32;
++					  _down = 32 - _up;
++					  if (!_up)
++					    for (_i = 3; _i >= _skip; --_i)
++					      V_f[_i] = V_f[_i - _skip];
++					  else
++					    {
++					      for (_i = 3; _i > _skip; --_i)
++						V_f[_i] =
++						  V_f[_i -
++						      _skip] << _up | V_f[_i -
++									  _skip
++									  -
++									  1]
++						  >> _down;
++					      V_f[_i--] = V_f[0] << _up;
++					    }
++					  for (; _i >= 0; --_i)
++					    V_f[_i] = 0;
++					}
++				      while (0);
++				    }
++				  while (0);
++				}
++			    }
++			  goto sub_done;
++			}
++		    }
++		  V_e = U_e;
++		  do
++		    {
++		      unsigned long _c1, _c2, _c3;
++		      V_f[0] = U_f[0] - Z_f[0];
++		      _c1 = V_f[0] > U_f[0];
++		      V_f[1] = U_f[1] - Z_f[1];
++		      _c2 = V_f[1] > U_f[1];
++		      V_f[1] -= _c1;
++		      _c2 |= _c1 && (Z_f[1] == U_f[1]);
++		      V_f[2] = U_f[2] - Z_f[2];
++		      _c3 = V_f[2] > U_f[2];
++		      V_f[2] -= _c2;
++		      _c3 |= _c2 && (Z_f[2] == U_f[2]);
++		      V_f[3] = U_f[3] - Z_f[3] - _c3;
++		    }
++		  while (0);
++		  V_s = U_s;
++		  if ((V_f[3]) & ((unsigned long) 1 << (113 - 1 + 3) % 32))
++		    {
++		      do
++			{
++			  unsigned long _c1, _c2, _c3;
++			  V_f[0] = Z_f[0] - U_f[0];
++			  _c1 = V_f[0] > Z_f[0];
++			  V_f[1] = Z_f[1] - U_f[1];
++			  _c2 = V_f[1] > Z_f[1];
++			  V_f[1] -= _c1;
++			  _c2 |= _c1 && (U_f[1] == Z_f[1]);
++			  V_f[2] = Z_f[2] - U_f[2];
++			  _c3 = V_f[2] > Z_f[2];
++			  V_f[2] -= _c2;
++			  _c3 |= _c2 && (U_f[2] == Z_f[2]);
++			  V_f[3] = Z_f[3] - U_f[3] - _c3;
++			}
++		      while (0);
++		      V_s = Z_s;
++		    }
++		  else if (((V_f[0] | V_f[1] | V_f[2] | V_f[3]) == 0))
++		    {
++		      V_e = 0;
++		      V_s = (0 == 3);
++		      goto sub_done;
++		    }
++		  goto norm;
++		}
++	    sub3:if ((V_f[3]) &
++		  ((unsigned long) 1 << (113 - 1 + 3) % 32))
++		{
++		  int diff;
++		  (V_f[3]) &= ((unsigned long) 1 << (113 - 1 + 3) % 32) - 1;
++		norm:do
++		    {
++		      if (V_f[3])
++			{
++			  do
++			    {
++			      if (sizeof (unsigned long) ==
++				  sizeof (unsigned int))
++				diff = __builtin_clz (V_f[3]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long))
++				diff = __builtin_clzl (V_f[3]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long long))
++				diff = __builtin_clzll (V_f[3]);
++			      else
++				abort ();
++			    }
++			  while (0);
++			}
++		      else if (V_f[2])
++			{
++			  do
++			    {
++			      if (sizeof (unsigned long) ==
++				  sizeof (unsigned int))
++				diff = __builtin_clz (V_f[2]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long))
++				diff = __builtin_clzl (V_f[2]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long long))
++				diff = __builtin_clzll (V_f[2]);
++			      else
++				abort ();
++			    }
++			  while (0);
++			  diff += 32;
++			}
++		      else if (V_f[1])
++			{
++			  do
++			    {
++			      if (sizeof (unsigned long) ==
++				  sizeof (unsigned int))
++				diff = __builtin_clz (V_f[1]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long))
++				diff = __builtin_clzl (V_f[1]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long long))
++				diff = __builtin_clzll (V_f[1]);
++			      else
++				abort ();
++			    }
++			  while (0);
++			  diff += 32 * 2;
++			}
++		      else
++			{
++			  do
++			    {
++			      if (sizeof (unsigned long) ==
++				  sizeof (unsigned int))
++				diff = __builtin_clz (V_f[0]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long))
++				diff = __builtin_clzl (V_f[0]);
++			      else if (sizeof (unsigned long) ==
++				       sizeof (unsigned long long))
++				diff = __builtin_clzll (V_f[0]);
++			      else
++				abort ();
++			    }
++			  while (0);
++			  diff += 32 * 3;
++			}
++		    }
++		  while (0);
++		  diff -= ((4 * 32) - (3 + 113));
++		  do
++		    {
++		      long _up, _down, _skip, _i;
++		      _skip = (diff) / 32;
++		      _up = (diff) % 32;
++		      _down = 32 - _up;
++		      if (!_up)
++			for (_i = 3; _i >= _skip; --_i)
++			  V_f[_i] = V_f[_i - _skip];
++		      else
++			{
++			  for (_i = 3; _i > _skip; --_i)
++			    V_f[_i] =
++			      V_f[_i - _skip] << _up | V_f[_i - _skip -
++							   1] >> _down;
++			  V_f[_i--] = V_f[0] << _up;
++			}
++		      for (; _i >= 0; --_i)
++			V_f[_i] = 0;
++		    }
++		  while (0);
++		  if (V_e <= diff)
++		    {
++		      diff = diff - V_e + 1;
++		      do
++			{
++			  int _sticky;
++			  do
++			    {
++			      long _up, _down, _skip, _i;
++			      unsigned long _s;
++			      _skip = (diff) / 32;
++			      _down = (diff) % 32;
++			      _up = 32 - _down;
++			      for (_s = _i = 0; _i < _skip; ++_i)
++				_s |= V_f[_i];
++			      if (!_down)
++				for (_i = 0; _i <= 3 - _skip; ++_i)
++				  V_f[_i] = V_f[_i + _skip];
++			      else
++				{
++				  _s |= V_f[_i] << _up;
++				  for (_i = 0; _i < 3 - _skip; ++_i)
++				    V_f[_i] =
++				      V_f[_i + _skip] >> _down | V_f[_i +
++								     _skip +
++								     1] <<
++				      _up;
++				  V_f[_i++] = V_f[3] >> _down;
++				}
++			      for (; _i < 4; ++_i)
++				V_f[_i] = 0;
++			      _sticky = (_s != 0);
++			    }
++			  while (0);
++			  V_f[0] |= _sticky;
++			}
++		      while (0);
++		      V_e = 0;
++		    }
++		  else
++		    {
++		      V_e -= diff;
++		      (V_f[3]) &=
++			~(unsigned long) ((unsigned long) 1 << (113 - 1 + 3) %
++					  32);
++		    }
++		}
++	    sub_done:;
++	    }
++	}
++      while (0);
++    }
++  while (0);
++
++/*  FP_PACK_SEMIRAW_Q(v,V) */
++  do
++    {
++      do
++	{
++	  do
++	    {
++	      if ((V_f[0]) & 7)
++		_fex |= (0);
++	      switch (0)
++		{
++		case 0:
++		  do
++		    {
++		      if (((V_f[0]) & 15) != ((unsigned long) 1 << 2))
++			do
++			  {
++			    unsigned long _t;
++			    _t =
++			      ((V_f[0] +=
++				((unsigned long) 1 << 2)) <
++			       ((unsigned long) 1 << 2));
++			    V_f[1] += _t;
++			    _t = (V_f[1] < _t);
++			    V_f[2] += _t;
++			    _t = (V_f[2] < _t);
++			    V_f[3] += _t;
++			  }
++			while (0);
++		    }
++		  while (0);
++		  break;
++		case 1:
++		  (void) 0;
++		  break;
++		case 2:
++		  do
++		    {
++		      if (!V_s && ((V_f[0]) & 7))
++			do
++			  {
++			    unsigned long _t;
++			    _t =
++			      ((V_f[0] +=
++				((unsigned long) 1 << 3)) <
++			       ((unsigned long) 1 << 3));
++			    V_f[1] += _t;
++			    _t = (V_f[1] < _t);
++			    V_f[2] += _t;
++			    _t = (V_f[2] < _t);
++			    V_f[3] += _t;
++			  }
++			while (0);
++		    }
++		  while (0);
++		  break;
++		case 3:
++		  do
++		    {
++		      if (V_s && ((V_f[0]) & 7))
++			do
++			  {
++			    unsigned long _t;
++			    _t =
++			      ((V_f[0] +=
++				((unsigned long) 1 << 3)) <
++			       ((unsigned long) 1 << 3));
++			    V_f[1] += _t;
++			    _t = (V_f[1] < _t);
++			    V_f[2] += _t;
++			    _t = (V_f[2] < _t);
++			    V_f[3] += _t;
++			  }
++			while (0);
++		    }
++		  while (0);
++		  break;
++		}
++	    }
++	  while (0);
++	  if ((V_f[3]) & (((unsigned long) 1 << ((3 + 113) % 32)) >> 1))
++	    {
++	      (V_f[3]) &= ~(((unsigned long) 1 << ((3 + 113) % 32)) >> 1);
++	      V_e++;
++	      if (V_e == 32767)
++		do
++		  {
++		    if (0 == 0 || (0 == 2 && !V_s) || (0 == 3 && V_s))
++		      {
++			V_e = 32767;
++			(V_f[3] = 0, V_f[2] = 0, V_f[1] = 0, V_f[0] = 0);
++		      }
++		    else
++		      {
++			V_e = 32767 - 1;
++			_fex |= (0);
++			_fex |= (0);
++			(V_f[3] = (~(signed long) 0), V_f[2] =
++			 (~(signed long) 0), V_f[1] =
++			 (~(signed long) 0), V_f[0] = (~(signed long) 0));
++		      }
++		  }
++		while (0);
++	    }
++	  do
++	    {
++	      long _up, _down, _skip, _i;
++	      _skip = (3) / 32;
++	      _down = (3) % 32;
++	      _up = 32 - _down;
++	      if (!_down)
++		for (_i = 0; _i <= 3 - _skip; ++_i)
++		  V_f[_i] = V_f[_i + _skip];
++	      else
++		{
++		  for (_i = 0; _i < 3 - _skip; ++_i)
++		    V_f[_i] =
++		      V_f[_i + _skip] >> _down | V_f[_i + _skip + 1] << _up;
++		  V_f[_i++] = V_f[3] >> _down;
++		}
++	      for (; _i < 4; ++_i)
++		V_f[_i] = 0;
++	    }
++	  while (0);
++	  if (!(((V_e + 1) & 32767) > 1)
++	      && !((V_f[0] | V_f[1] | V_f[2] | V_f[3]) == 0))
++	    {
++	      if (V_e == 0)
++		_fex |= (0);
++	      else
++		{
++		  if (!1)
++		    {
++		      (V_f[3] =
++		       ((((unsigned long) 1 << (113 - 2) % 32) << 1) - 1),
++		       V_f[2] = -1, V_f[1] = -1, V_f[0] = -1);
++		      V_s = 0;
++		    }
++		  else
++		    (V_f[3]) |= ((unsigned long) 1 << (113 - 2) % 32);
++		}
++	    }
++	}
++      while (0);
++      do
++	{
++	  union _FP_UNION_Q _flo;
++	  _flo.bits.frac0 = V_f[0];
++	  _flo.bits.frac1 = V_f[1];
++	  _flo.bits.frac2 = V_f[2];
++	  _flo.bits.frac3 = V_f[3];
++	  _flo.bits.exp = V_e;
++	  _flo.bits.sign = V_s;
++	  (v) = _flo.flt;
++	}
++      while (0);
++    }
++  while (0);
++
++/*  FP_HANDLE_EXCEPTIONS */
++  do
++    {
++    }
++  while (0);
++
++  /* Truncate quad to double.  */
++/*  FP_INIT_ROUNDMODE */
++  do
++    {
++    }
++  while (0);
++
++/*  FP_UNPACK_SEMIRAW_Q(V,v) */
++  do
++    {
++      do
++	{
++	  union _FP_UNION_Q _flo;
++	  _flo.flt = (v);
++	  V_f[0] = _flo.bits.frac0;
++	  V_f[1] = _flo.bits.frac1;
++	  V_f[2] = _flo.bits.frac2;
++	  V_f[3] = _flo.bits.frac3;
++	  V_e = _flo.bits.exp;
++	  V_s = _flo.bits.sign;
++	}
++      while (0);
++      do
++	{
++	  long _up, _down, _skip, _i;
++	  _skip = (3) / 32;
++	  _up = (3) % 32;
++	  _down = 32 - _up;
++	  if (!_up)
++	    for (_i = 3; _i >= _skip; --_i)
++	      V_f[_i] = V_f[_i - _skip];
++	  else
++	    {
++	      for (_i = 3; _i > _skip; --_i)
++		V_f[_i] =
++		  V_f[_i - _skip] << _up | V_f[_i - _skip - 1] >> _down;
++	      V_f[_i--] = V_f[0] << _up;
++	    }
++	  for (; _i >= 0; --_i)
++	    V_f[_i] = 0;
++	}
++      while (0);
++    }
++  while (0);
++
++/*  FP_TRUNC(D,Q,2,4,R,V) */
++  do
++    {
++      if (113 < 53 || 16383 < 1023 + 53 - 1)
++	abort ();
++      R_s = V_s;
++      if ((((V_e + 1) & 32767) > 1))
++	{
++	  R_e = V_e + 1023 - 16383;
++	  if (R_e >= 2047)
++	    do
++	      {
++		if (0 == 0 || (0 == 2 && !R_s) || (0 == 3 && R_s))
++		  {
++		    R_e = 2047;
++		    (R_f0 = 0, R_f1 = 0);
++		  }
++		else
++		  {
++		    R_e = 2047 - 1;
++		    _fex |= (0);
++		    _fex |= (0);
++		    (R_f0 = (~(signed long) 0), R_f1 = (~(signed long) 0));
++		  }
++	      }
++	    while (0);
++	  else
++	    {
++	      if (R_e <= 0)
++		{
++		  if (R_e <= 1 - 53)
++		    (V_f[3] = 0, V_f[2] = 0, V_f[1] = 0, V_f[0] = 0);
++		  else
++		    {
++		      (V_f[3]) |= ((unsigned long) 1 << (113 - 1 + 3) % 32);
++		      do
++			{
++			  int _sticky;
++			  do
++			    {
++			      long _up, _down, _skip, _i;
++			      unsigned long _s;
++			      _skip = (((3 + 113) - (3 + 53) + 1 - R_e)) / 32;
++			      _down = (((3 + 113) - (3 + 53) + 1 - R_e)) % 32;
++			      _up = 32 - _down;
++			      for (_s = _i = 0; _i < _skip; ++_i)
++				_s |= V_f[_i];
++			      if (!_down)
++				for (_i = 0; _i <= 3 - _skip; ++_i)
++				  V_f[_i] = V_f[_i + _skip];
++			      else
++				{
++				  _s |= V_f[_i] << _up;
++				  for (_i = 0; _i < 3 - _skip; ++_i)
++				    V_f[_i] =
++				      V_f[_i + _skip] >> _down | V_f[_i +
++								     _skip +
++								     1] <<
++				      _up;
++				  V_f[_i++] = V_f[3] >> _down;
++				}
++			      for (; _i < 4; ++_i)
++				V_f[_i] = 0;
++			      _sticky = (_s != 0);
++			    }
++			  while (0);
++			  V_f[0] |= _sticky;
++			}
++		      while (0);
++		    }
++		  R_e = 0;
++		}
++	      else
++		do
++		  {
++		    int _sticky;
++		    do
++		      {
++			long _up, _down, _skip, _i;
++			unsigned long _s;
++			_skip = (((3 + 113) - (3 + 53))) / 32;
++			_down = (((3 + 113) - (3 + 53))) % 32;
++			_up = 32 - _down;
++			for (_s = _i = 0; _i < _skip; ++_i)
++			  _s |= V_f[_i];
++			if (!_down)
++			  for (_i = 0; _i <= 3 - _skip; ++_i)
++			    V_f[_i] = V_f[_i + _skip];
++			else
++			  {
++			    _s |= V_f[_i] << _up;
++			    for (_i = 0; _i < 3 - _skip; ++_i)
++			      V_f[_i] =
++				V_f[_i + _skip] >> _down | V_f[_i + _skip +
++							       1] << _up;
++			    V_f[_i++] = V_f[3] >> _down;
++			  }
++			for (; _i < 4; ++_i)
++			  V_f[_i] = 0;
++			_sticky = (_s != 0);
++		      }
++		    while (0);
++		    V_f[0] |= _sticky;
++		  }
++		while (0);
++	      do
++		{
++		  R_f0 = V_f[0];
++		  R_f1 = V_f[1];
++		}
++	      while (0);
++	    }
++	}
++      else
++	{
++	  if (V_e == 0)
++	    {
++	      R_e = 0;
++	      (R_f0 = 0, R_f1 = 0);
++	      if (!((V_f[0] | V_f[1] | V_f[2] | V_f[3]) == 0))
++		{
++		  _fex |= (0);
++		  _fex |= (0);
++		}
++	    }
++	  else
++	    {
++	      R_e = 2047;
++	      if (((V_f[0] | V_f[1] | V_f[2] | V_f[3]) == 0))
++		(R_f0 = 0, R_f1 = 0);
++	      else
++		{
++		  do
++		    {
++		      if (V_e == 32767
++			  && !((V_f[0] | V_f[1] | V_f[2] | V_f[3]) == 0)
++			  && !((V_f[3]) &
++			       ((unsigned long) 1 << (113 - 2 + 3) % 32)))
++			_fex |= (0);
++		    }
++		  while (0);
++		  do
++		    {
++		      long _up, _down, _skip, _i;
++		      _skip = (((3 + 113) - (3 + 53))) / 32;
++		      _down = (((3 + 113) - (3 + 53))) % 32;
++		      _up = 32 - _down;
++		      if (!_down)
++			for (_i = 0; _i <= 3 - _skip; ++_i)
++			  V_f[_i] = V_f[_i + _skip];
++		      else
++			{
++			  for (_i = 0; _i < 3 - _skip; ++_i)
++			    V_f[_i] =
++			      V_f[_i + _skip] >> _down | V_f[_i + _skip +
++							     1] << _up;
++			  V_f[_i++] = V_f[3] >> _down;
++			}
++		      for (; _i < 4; ++_i)
++			V_f[_i] = 0;
++		    }
++		  while (0);
++		  do
++		    {
++		      R_f0 = V_f[0];
++		      R_f1 = V_f[1];
++		    }
++		  while (0);
++		  (R_f1) |= ((unsigned long) 1 << (53 - 2 + 3) % 32);
++		}
++	    }
++	}
++    }
++  while (0);
++
++/*  FP_PACK_SEMIRAW_D(r,R) */
++  do
++    {
++      do
++	{
++	  do
++	    {
++	      if ((R_f0) & 7)
++		_fex |= (0);
++	      switch (0)
++		{
++		case 0:
++		  do
++		    {
++		      if (((R_f0) & 15) != ((unsigned long) 1 << 2))
++			do
++			  {
++			    if (__builtin_constant_p (0) && (0) == 0)
++			    __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{aze|addze} %0,%2": "=r" (R_f1), "=&r" (R_f0):"r" (R_f1), "%r" (R_f0),
++				       "rI" (((unsigned long) 1 <<
++					      2)));
++			    else if (__builtin_constant_p (0)
++				     && (0) == ~(USItype) 0)
++			    __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{ame|addme} %0,%2": "=r" (R_f1), "=&r" (R_f0):"r" (R_f1), "%r" (R_f0),
++				       "rI" (((unsigned long) 1 <<
++					      2)));
++			    else
++			    __asm__ ("{a%I5|add%I5c} %1,%4,%5\n\t{ae|adde} %0,%2,%3": "=r" (R_f1), "=&r" (R_f0):"%r" (R_f1), "r" (0), "%r" (R_f0),
++				       "rI" (((unsigned long) 1 <<
++					      2)));
++			  }
++			while (0);
++		    }
++		  while (0);
++		  break;
++		case 1:
++		  (void) 0;
++		  break;
++		case 2:
++		  do
++		    {
++		      if (!R_s && ((R_f0) & 7))
++			do
++			  {
++			    if (__builtin_constant_p (0) && (0) == 0)
++			    __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{aze|addze} %0,%2": "=r" (R_f1), "=&r" (R_f0):"r" (R_f1), "%r" (R_f0),
++				       "rI" (((unsigned long) 1 <<
++					      3)));
++			    else if (__builtin_constant_p (0)
++				     && (0) == ~(USItype) 0)
++			    __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{ame|addme} %0,%2": "=r" (R_f1), "=&r" (R_f0):"r" (R_f1), "%r" (R_f0),
++				       "rI" (((unsigned long) 1 <<
++					      3)));
++			    else
++			    __asm__ ("{a%I5|add%I5c} %1,%4,%5\n\t{ae|adde} %0,%2,%3": "=r" (R_f1), "=&r" (R_f0):"%r" (R_f1), "r" (0), "%r" (R_f0),
++				       "rI" (((unsigned long) 1 <<
++					      3)));
++			  }
++			while (0);
++		    }
++		  while (0);
++		  break;
++		case 3:
++		  do
++		    {
++		      if (R_s && ((R_f0) & 7))
++			do
++			  {
++			    if (__builtin_constant_p (0) && (0) == 0)
++			    __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{aze|addze} %0,%2": "=r" (R_f1), "=&r" (R_f0):"r" (R_f1), "%r" (R_f0),
++				       "rI" (((unsigned long) 1 <<
++					      3)));
++			    else if (__builtin_constant_p (0)
++				     && (0) == ~(USItype) 0)
++			    __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{ame|addme} %0,%2": "=r" (R_f1), "=&r" (R_f0):"r" (R_f1), "%r" (R_f0),
++				       "rI" (((unsigned long) 1 <<
++					      3)));
++			    else
++			    __asm__ ("{a%I5|add%I5c} %1,%4,%5\n\t{ae|adde} %0,%2,%3": "=r" (R_f1), "=&r" (R_f0):"%r" (R_f1), "r" (0), "%r" (R_f0),
++				       "rI" (((unsigned long) 1 <<
++					      3)));
++			  }
++			while (0);
++		    }
++		  while (0);
++		  break;
++		}
++	    }
++	  while (0);
++	  if ((R_f1) & (((unsigned long) 1 << (3 + 53) % 32) >> 1))
++	    {
++	      (R_f1) &= ~(((unsigned long) 1 << (3 + 53) % 32) >> 1);
++	      R_e++;
++	      if (R_e == 2047)
++		do
++		  {
++		    if (0 == 0 || (0 == 2 && !R_s) || (0 == 3 && R_s))
++		      {
++			R_e = 2047;
++			(R_f0 = 0, R_f1 = 0);
++		      }
++		    else
++		      {
++			R_e = 2047 - 1;
++			_fex |= (0);
++			_fex |= (0);
++			(R_f0 = (~(signed long) 0), R_f1 =
++			 (~(signed long) 0));
++		      }
++		  }
++		while (0);
++	    }
++	  (void) (((3) < 32) ? (
++				 {
++	R_f0 = R_f0 >> (3) | R_f1 << (32 - (3)); R_f1 >>= (3);}):(
++				   {
++				   R_f0 = R_f1 >> ((3) - 32); R_f1 = 0;}));
++	  if (!(((R_e + 1) & 2047) > 1) && !((R_f1 | R_f0) == 0))
++	    {
++	      if (R_e == 0)
++		_fex |= (0);
++	      else
++		{
++		  if (!1)
++		    {
++		      (R_f0 = -1, R_f1 =
++		       ((((unsigned long) 1 << (53 - 2) % 32) << 1) - 1));
++		      R_s = 0;
++		    }
++		  else
++		    (R_f1) |= ((unsigned long) 1 << (53 - 2) % 32);
++		}
++	    }
++	}
++      while (0);
++      do
++	{
++	  union _FP_UNION_D _flo;
++	  _flo.bits.frac0 = R_f0;
++	  _flo.bits.frac1 = R_f1;
++	  _flo.bits.exp = R_e;
++	  _flo.bits.sign = R_s;
++	  (r) = _flo.flt;
++	}
++      while (0);
++    }
++  while (0);
++
++/*  FP_HANDLE_EXCEPTIONS */
++  do
++    {
++    }
++  while (0);
++
++  return r;
++}
++
++
++#endif
++
+ #endif
+diff -urN gcc42-trunc-20060802/gcc/config/rs6000/libgcc-ppc-glibc.ver gcc42-patched-20060802/gcc/config/rs6000/libgcc-ppc-glibc.ver
+--- gcc42-trunc-20060802/gcc/config/rs6000/libgcc-ppc-glibc.ver	2006-08-02 11:07:16.000000000 -0500
++++ gcc42-patched-20060802/gcc/config/rs6000/libgcc-ppc-glibc.ver	2006-09-01 08:28:29.000000000 -0500
+@@ -21,11 +21,32 @@
+ %else
+ GCC_3.4.4 {
+ %endif
++%else
++GCC_4.2.0 {
++%endif
+ 
+   # long double support
+   __gcc_qadd
+   __gcc_qsub
+   __gcc_qmul
+   __gcc_qdiv
+-}
++
++%ifdef _SOFT_FLOAT
++  __gcc_qneg
++  __gcc_qeq
++  __gcc_qne
++  __gcc_ggt
++  __gcc_qge
++  __gcc_qlt
++  __gcc_qle
++  __gcc_qunord
++  __gcc_stoq
++  __gcc_dtoq
++  __gcc_qtos
++  __gcc_qtod
++  __gcc_qtoi
++  __gcc_qtou
++  __gcc_itoq
++  __gcc_utoq
+ %endif
++}
+diff -urN gcc42-trunc-20060802/gcc/config/rs6000/rs6000.c gcc42-patched-20060802/gcc/config/rs6000/rs6000.c
+--- gcc42-trunc-20060802/gcc/config/rs6000/rs6000.c	2006-08-02 11:07:16.000000000 -0500
++++ gcc42-patched-20060802/gcc/config/rs6000/rs6000.c	2006-09-01 08:28:29.000000000 -0500
+@@ -4016,8 +4016,7 @@
+ 
+   /* 128-bit constant floating-point values on Darwin should really be
+      loaded as two parts.  */
+-  if (!TARGET_IEEEQUAD
+-      && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128
++  if (!TARGET_IEEEQUAD && TARGET_LONG_DOUBLE_128
+       && mode == TFmode && GET_CODE (operands[1]) == CONST_DOUBLE)
+     {
+       /* DImode is used, not DFmode, because simplify_gen_subreg doesn't
+@@ -9175,9 +9174,6 @@
+ static void
+ rs6000_init_libfuncs (void)
+ {
+-  if (!TARGET_HARD_FLOAT)
+-    return;
+-
+   if (DEFAULT_ABI != ABI_V4 && TARGET_XCOFF
+       && !TARGET_POWER2 && !TARGET_POWERPC)
+     {
+@@ -9196,6 +9192,27 @@
+ 	set_optab_libfunc (sub_optab, TFmode, "__gcc_qsub");
+ 	set_optab_libfunc (smul_optab, TFmode, "__gcc_qmul");
+ 	set_optab_libfunc (sdiv_optab, TFmode, "__gcc_qdiv");
++
++	if (TARGET_SOFT_FLOAT)
++	  {
++	    set_optab_libfunc (neg_optab, TFmode, "__gcc_qneg");
++	    set_optab_libfunc (eq_optab, TFmode, "__gcc_qeq");
++	    set_optab_libfunc (ne_optab, TFmode, "__gcc_qne");
++	    set_optab_libfunc (gt_optab, TFmode, "__gcc_qgt");
++	    set_optab_libfunc (ge_optab, TFmode, "__gcc_qge");
++	    set_optab_libfunc (lt_optab, TFmode, "__gcc_qlt");
++	    set_optab_libfunc (le_optab, TFmode, "__gcc_qle");
++	    set_optab_libfunc (unord_optab, TFmode, "__gcc_qunord");
++
++	    set_conv_libfunc (sext_optab, TFmode, SFmode, "__gcc_stoq");
++	    set_conv_libfunc (sext_optab, TFmode, DFmode, "__gcc_dtoq");
++	    set_conv_libfunc (trunc_optab, SFmode, TFmode, "__gcc_qtos");
++	    set_conv_libfunc (trunc_optab, DFmode, TFmode, "__gcc_qtod");
++	    set_conv_libfunc (sfix_optab, SImode, TFmode, "__gcc_qtoi");
++	    set_conv_libfunc (ufix_optab, SImode, TFmode, "__gcc_qtou");
++	    set_conv_libfunc (sfloat_optab, TFmode, SImode, "__gcc_itoq");
++	    set_conv_libfunc (ufloat_optab, TFmode, SImode, "__gcc_utoq");
++	  }
+       }
+     else
+       {
+diff -urN gcc42-trunc-20060802/gcc/config/rs6000/rs6000.md gcc42-patched-20060802/gcc/config/rs6000/rs6000.md
+--- gcc42-trunc-20060802/gcc/config/rs6000/rs6000.md	2006-08-02 11:07:16.000000000 -0500
++++ gcc42-patched-20060802/gcc/config/rs6000/rs6000.md	2006-09-01 08:28:29.000000000 -0500
+@@ -7920,42 +7920,44 @@
+   "")
+ 
+ (define_insn "*movcc_internal1"
+-  [(set (match_operand:CC 0 "nonimmediate_operand" "=y,x,?y,r,r,r,r,q,cl,r,m")
+-	(match_operand:CC 1 "nonimmediate_operand" "y,r,r,x,y,r,h,r,r,m,r"))]
++  [(set (match_operand:CC 0 "nonimmediate_operand" "=y,x,?y,y,r,r,r,r,r,q,cl,r,m")
++	(match_operand:CC 1 "general_operand" "y,r,r,O,x,y,r,I,h,r,r,m,r"))]
+   "register_operand (operands[0], CCmode)
+    || register_operand (operands[1], CCmode)"
+   "@
+    mcrf %0,%1
+    mtcrf 128,%1
+    {rlinm|rlwinm} %1,%1,%F0,0xffffffff\;mtcrf %R0,%1\;{rlinm|rlwinm} %1,%1,%f0,0xffffffff
++   crxor %0,%0,%0
+    mfcr %0%Q1
+    mfcr %0%Q1\;{rlinm|rlwinm} %0,%0,%f1,0xf0000000
+    mr %0,%1
++   {lil|li} %0,%1
+    mf%1 %0
+    mt%0 %1
+    mt%0 %1
+    {l%U1%X1|lwz%U1%X1} %0,%1
+    {st%U0%U1|stw%U0%U1} %1,%0"
+   [(set (attr "type")
+-     (cond [(eq_attr "alternative" "0")
++     (cond [(eq_attr "alternative" "0,3")
+ 		(const_string "cr_logical")
+ 	    (eq_attr "alternative" "1,2")
+ 		(const_string "mtcr")
+-	    (eq_attr "alternative" "5,7")
++	    (eq_attr "alternative" "6,7,9")
+ 		(const_string "integer")
+-	    (eq_attr "alternative" "6")
+-		(const_string "mfjmpr")
+ 	    (eq_attr "alternative" "8")
++		(const_string "mfjmpr")
++	    (eq_attr "alternative" "10")
+ 		(const_string "mtjmpr")
+-	    (eq_attr "alternative" "9")
++	    (eq_attr "alternative" "11")
+ 		(const_string "load")
+-	    (eq_attr "alternative" "10")
++	    (eq_attr "alternative" "12")
+ 		(const_string "store")
+ 	    (ne (symbol_ref "TARGET_MFCRF") (const_int 0))
+ 		(const_string "mfcrf")
+ 	   ]
+ 	(const_string "mfcr")))
+-   (set_attr "length" "4,4,12,4,8,4,4,4,4,4,4")])
++   (set_attr "length" "4,4,12,4,4,8,4,4,4,4,4,4,4")])
+ 
+ ;; For floating-point, we normally deal with the floating-point registers
+ ;; unless -msoft-float is used.  The sole exception is that parameter passing
+@@ -8313,8 +8315,7 @@
+ (define_expand "movtf"
+   [(set (match_operand:TF 0 "general_operand" "")
+ 	(match_operand:TF 1 "any_operand" ""))]
+-  "!TARGET_IEEEQUAD
+-   && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128"
++  "!TARGET_IEEEQUAD && TARGET_LONG_DOUBLE_128"
+   "{ rs6000_emit_move (operands[0], operands[1], TFmode); DONE; }")
+ 
+ ; It's important to list the o->f and f->o moves before f->f because
+@@ -8333,6 +8334,19 @@
+ { rs6000_split_multireg_move (operands[0], operands[1]); DONE; }
+   [(set_attr "length" "8,8,8,20,20,16")])
+ 
++(define_insn_and_split "*movtf_softfloat"
++  [(set (match_operand:TF 0 "nonimmediate_operand" "=r,Y,r")
++	(match_operand:TF 1 "input_operand"         "YGHF,r,r"))]
++  "!TARGET_IEEEQUAD
++   && (TARGET_SOFT_FLOAT || !TARGET_FPRS) && TARGET_LONG_DOUBLE_128
++   && (gpc_reg_operand (operands[0], TFmode)
++       || gpc_reg_operand (operands[1], TFmode))"
++  "#"
++  "&& reload_completed"
++  [(pc)]
++{ rs6000_split_multireg_move (operands[0], operands[1]); DONE; }
++  [(set_attr "length" "20,20,16")])
++
+ (define_expand "extenddftf2"
+   [(parallel [(set (match_operand:TF 0 "nonimmediate_operand" "")
+ 		   (float_extend:TF (match_operand:DF 1 "input_operand" "")))
+diff -urN gcc42-trunc-20060802/gcc/config/rs6000/sysv4.h gcc42-patched-20060802/gcc/config/rs6000/sysv4.h
+--- gcc42-trunc-20060802/gcc/config/rs6000/sysv4.h	2006-08-02 11:07:16.000000000 -0500
++++ gcc42-patched-20060802/gcc/config/rs6000/sysv4.h	2006-09-01 08:28:29.000000000 -0500
+@@ -215,10 +215,6 @@
+       error ("-msecure-plt not supported by your assembler");		\
+     }									\
+ 									\
+-  if (TARGET_SOFT_FLOAT && TARGET_LONG_DOUBLE_128			\
+-      && rs6000_explicit_options.long_double)				\
+-    warning (0, "-msoft-float and -mlong-double-128 not supported");	\
+-									\
+   /* Treat -fPIC the same as -mrelocatable.  */				\
+   if (flag_pic > 1 && DEFAULT_ABI != ABI_AIX)				\
+     {									\
+diff -urN gcc42-trunc-20060802/gcc/config/rs6000/t-ppccomm gcc42-patched-20060802/gcc/config/rs6000/t-ppccomm
+--- gcc42-trunc-20060802/gcc/config/rs6000/t-ppccomm	2006-08-02 11:07:16.000000000 -0500
++++ gcc42-patched-20060802/gcc/config/rs6000/t-ppccomm	2006-09-01 08:28:29.000000000 -0500
+@@ -12,15 +12,8 @@
+ 	cat $(srcdir)/config/rs6000/tramp.asm > tramp.S
+ 
+ ifneq (,$findstring gnu,$(target))
+-TARGET_LIBGCC2_CFLAGS += -specs=ldblspecs
+-
++TARGET_LIBGCC2_CFLAGS += -mlong-double-128
+ SHLIB_MAPFILES += $(srcdir)/config/rs6000/libgcc-ppc-glibc.ver
+-
+-# Hack to use -mlong-double-128 only when not compiling nof libgcc
+-mklibgcc: ldblspecs
+-
+-ldblspecs: specs
+-	sed -e '/cc1_options/{ n; s/$$/ %{!msoft-float:-mlong-double-128}/; }' < specs > $@
+ endif
+ 
+ # Switch synonyms