const float inf = *(const float *)&a_inf;
const float inf = a_inf.value;
__sqrtf(float x){  const float inf = *(const float *)&a_inf;  /* x = f_washf(x); *//* This ensures only one exception for SNaN. */  if (x > 0)    {      if (x != inf)	{	  /* Variables named starting with 's' exist in the	     argument-reduced space, so that 2 > sx >= 0.5,	     1.41... > sg >= 0.70.., 0.70.. >= sy > 0.35... .	     Variables named ending with 'i' are integer versions of	     floating-point values.  */	  float sx;   /* The value of which we're trying to find the square			 root.  */	  float sg,g; /* Guess of the square root of x.  */	  float sd,d; /* Difference between the square of the guess and x.  */	  float sy;   /* Estimate of 1/2g (overestimated by 1ulp).  */	  float sy2;  /* 2*sy */	  float e;    /* Difference between y*g and 1/2 (note that e==se).  */	  float shx;  /* == sx * fsg */	  float fsg;  /* sg*fsg == g.  */	  fenv_t fe;  /* Saved floating-point environment (stores rounding			 mode and whether the inexact exception is			 enabled).  */	  uint32_t xi, sxi, fsgi;	  const float *t_sqrt;	  GET_FLOAT_WORD (xi, x);	  fe = fegetenv_register ();	  relax_fenv_state ();	  sxi = (xi & 0x3fffffff) | 0x3f000000;	  SET_FLOAT_WORD (sx, sxi);	  t_sqrt = __t_sqrt + (xi >> (23-8-1)  & 0x3fe);	  sg = t_sqrt[0];	  sy = t_sqrt[1];	  	  /* Here we have three Newton-Rhapson iterations each of a	     division and a square root and the remainder of the	     argument reduction, all interleaved.   */	  sd  = -(sg*sg - sx);	  fsgi = (xi + 0x40000000) >> 1 & 0x7f800000;	  sy2 = sy + sy;	  sg  = sy*sd + sg;  /* 16-bit approximation to sqrt(sx). */	  e   = -(sy*sg - almost_half);	  SET_FLOAT_WORD (fsg, fsgi);	  sd  = -(sg*sg - sx);	  sy  = sy + e*sy2;	  if ((xi & 0x7f800000) == 0)	    goto denorm;	  shx = sx * fsg;	  sg  = sg + sy*sd;  /* 32-bit approximation to sqrt(sx),				but perhaps rounded incorrectly.  */	  sy2 = sy + sy;	  g   = sg * fsg;	  e   = -(sy*sg - almost_half);	  d   = -(g*sg - shx);	  sy  = sy + e*sy2;	  fesetenv_register (fe);	  return g + sy*d;	denorm:	  /* For denormalised numbers, we normalise, calculate the	     square root, and return an adjusted result.  */	  fesetenv_register (fe);	  return __sqrtf(x * two48) * twom24;	}    }  else if (x < 0)    {#ifdef FE_INVALID_SQRT      feraiseexcept (FE_INVALID_SQRT);      /* For some reason, some PowerPC processors don't implement	 FE_INVALID_SQRT.  I guess no-one ever thought they'd be	 used for square roots... :-) */      if (!fetestexcept (FE_INVALID))#endif	feraiseexcept (FE_INVALID);#ifndef _IEEE_LIBM      if (_LIB_VERSION != _IEEE_)	x = __kernel_standard(x,x,126);      else#endif      x = *(const float*)&a_nan;    }  return f_washf(x);}