#define _GNU_SOURCE
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int
main (void)
{
  int i;
  union { long double l; long long x[2]; } u, u2;
  char buf[128], buf2[128], buf3[128];
  int result = 0;
  for (i = 0; i < 10000000; i++)
    {
      long long v[4];
      int expon, expon2, flags = random () & 3;
      int im = 1, im2;
      int ulp_shift = 3;
      v[0] = (random () & 0xfffffffLL) << 28;
      v[0] |= random () & 0xfffffffLL;
      v[1] = (random () & 0xffffffLL) << 28;
      v[1] |= random () & 0xffffff8LL;
      expon = (((unsigned long) random ()) % 2047) - 1023;
      if (expon == -1023)
	{
	  im = 0;
	  expon = -1022;
	  ulp_shift = 56;
	  v[1] = 0;
	  v[0] &= 0xfffffffffffff0LL;
	}
      else if (expon < -1018)
	{
	  v[1] = 0;
	  v[0] &= 0xffffffffffffffLL << (-1018 - expon);
	  ulp_shift = 52 + (-1018 - expon);
	}
      else if (expon < -969)
	{
	  ulp_shift = (-969 + 3 - expon);
	  v[1] &= 0xffffffffffffLL << ulp_shift;
	}
      else if (expon == 1023 && v[0] >= 0xfffffffffffff7LL)
	{
	  if (v[0] > 0xfffffffffffff7LL
	      || (v[1] == 0xffffffffffff8LL && (flags == 2 || flags == 1)))
	    /* Special cases, test separately.  */
	    continue;
	}
      int n = sprintf (buf, "%s0x%d.%014Lx%013Lx", (flags & 1) ? "-" : "",
		       im, v[0], v[1]);
      while (buf[n - 1] == '0')
	n--;
      if (buf[n - 1] == '.')
	n--;
      if (expon == -1022 && n == 3 && memcmp (buf, "0x0", 3) == 0)
	strcpy (buf + n, "p+0");
      else
	sprintf (buf + n, "p%s%d", expon >= 0 ? "+" : "", expon);
      if (sscanf (buf, "%La", &u.l) != 1)
	return 4;
      v[3] = v[1];
      v[2] = v[0];
      expon2 = expon;
      im2 = im;
      if (flags & 2)
	{
	  if (ulp_shift > 52)
	    {
	      v[2] += (1LL << (ulp_shift - 52));
	      goto test_inc;
	    }
	  v[3] += (1LL << ulp_shift);
	  if (v[3] & ~0xffffffffffff8LL)
	    {
	      v[3] &= 0xffffffffffff8LL;
	      v[2]++;
	    test_inc:
	      if (v[2] & ~0xffffffffffffffLL)
		{
		  v[2] &= 0xffffffffffffffLL;
		  if (im == 0)
		    im = 1;
		  else
		    expon2++;
		}
	    }
	}
      else
	{
	  if (ulp_shift > 52)
	    {
	      v[2] -= (1LL << (ulp_shift - 52));
	      goto test_dec;
	    }
	  v[3] -= (1LL << ulp_shift);
	  if (v[3] & ~0xffffffffffff8LL)
	    {
	      v[3] &= 0xffffffffffff8LL;
	      v[2]--;
	    test_dec:
	      if (v[2] & ~0xffffffffffffffLL)
		{
		  v[2] &= 0xffffffffffffffLL;
		  if (expon2 == -1022)
		    im = 0;
		  else
		    expon2--;
		}
	    }
	}
      n = sprintf (buf2, "%s0x%d.%014Lx%013Lx", (flags & 1) ? "-" : "",
		   im2, v[2], v[3]);
      while (buf2[n - 1] == '0')
	n--;
      if (buf2[n - 1] == '.')
	n--;
      if (expon2 == -1022 && n == 3 && memcmp (buf2, "0x0", 3) == 0)
	strcpy (buf2 + n, "p+0");
      else
	sprintf (buf2 + n, "p%s%d", expon2 >= 0 ? "+" : "", expon2);
      u2.l = nextafterl (u.l, (flags == 2 || flags == 1)
			 ? __builtin_infl () : -__builtin_infl ());
      sprintf (buf3, "%La", u2.l);
      if (strcmp (buf2, buf3) != 0)
	{
	  printf ("buf is %s u.l %La buf2 %s u2.l %La buf3 %s "
		  "%016Lx %016Lx - %016Lx %016Lx\n", buf, u.l, buf2,
		  u2.l, buf3, u.x[0], u.x[1], u2.x[0], u2.x[1]);
	  result = 1;
	}
    }

  if (sscanf ("+Inf", "%La", &u.l) != 1)
    return 4;
  u2.l = nextafterl (u.l, -__builtin_infl ());
  sprintf (buf3, "%La", u2.l);
  if (strcmp ("0x1.fffffffffffff7ffffffffffff8p+1023", buf3) != 0)
    {
      puts ("Special case 1 failed");
      result = 1;
    }
  if (sscanf ("-Inf", "%La", &u.l) != 1)
    return 4;
  u2.l = nextafterl (u.l, __builtin_infl ());
  sprintf (buf3, "%La", u2.l);
  if (strcmp ("-0x1.fffffffffffff7ffffffffffff8p+1023", buf3) != 0)
    {
      puts ("Special case 2 failed");
      result = 1;
    }
  if (sscanf ("0x1.fffffffffffff7ffffffffffff8p+1023", "%La", &u.l) != 1)
    return 4;
  u2.l = nextafterl (u.l, __builtin_infl ());
  if (fpclassify (u2.l) != FP_INFINITE || u2.l <= 0)
    {
      puts ("Special case 3 failed");
      result = 1;
    }
  if (sscanf ("-0x1.fffffffffffff7ffffffffffff8p+1023", "%La", &u.l) != 1)
    return 4;
  u2.l = nextafterl (u.l, -__builtin_infl ());
  if (fpclassify (u2.l) != FP_INFINITE || u2.l >= 0)
    {
      puts ("Special case 4 failed");
      result = 1;
    }

  return result;
}