diff -Naurd mpfr-3.1.2-a/PATCHES mpfr-3.1.2-b/PATCHES
--- mpfr-3.1.2-a/PATCHES	2013-09-26 10:56:55.000000000 +0000
+++ mpfr-3.1.2-b/PATCHES	2013-09-26 10:56:55.000000000 +0000
@@ -0,0 +1 @@
+fits-smallneg
diff -Naurd mpfr-3.1.2-a/VERSION mpfr-3.1.2-b/VERSION
--- mpfr-3.1.2-a/VERSION	2013-09-26 10:52:52.000000000 +0000
+++ mpfr-3.1.2-b/VERSION	2013-09-26 10:56:55.000000000 +0000
@@ -1 +1 @@
-3.1.2-p1
+3.1.2-p2
diff -Naurd mpfr-3.1.2-a/src/fits_u.h mpfr-3.1.2-b/src/fits_u.h
--- mpfr-3.1.2-a/src/fits_u.h	2013-03-13 15:37:35.000000000 +0000
+++ mpfr-3.1.2-b/src/fits_u.h	2013-09-26 10:56:55.000000000 +0000
@@ -32,17 +32,20 @@
   int res;
 
   if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (f)))
-    /* Zero always fit */
-    return MPFR_IS_ZERO (f) ? 1 : 0;
-  else if (MPFR_IS_NEG (f))
-    /* Negative numbers don't fit */
-    return 0;
-  /* now it fits if
-     (a) f <= MAXIMUM
-     (b) round(f, prec(slong), rnd) <= MAXIMUM */
+    return MPFR_IS_ZERO (f) ? 1 : 0;  /* Zero always fits */
 
   e = MPFR_GET_EXP (f);
 
+  if (MPFR_IS_NEG (f))
+    return e >= 1 ? 0  /* f <= -1 does not fit */
+      : rnd != MPFR_RNDN ? MPFR_IS_LIKE_RNDU (rnd, -1)  /* directed mode */
+      : e < 0 ? 1  /* f > -1/2 fits in MPFR_RNDN */
+      : mpfr_powerof2_raw(f);  /* -1/2 fits, -1 < f < -1/2 don't */
+
+  /* Now it fits if
+     (a) f <= MAXIMUM
+     (b) round(f, prec(slong), rnd) <= MAXIMUM */
+
   /* first compute prec(MAXIMUM); fits in an int */
   for (s = MAXIMUM, prec = 0; s != 0; s /= 2, prec ++);
 
diff -Naurd mpfr-3.1.2-a/src/fits_uintmax.c mpfr-3.1.2-b/src/fits_uintmax.c
--- mpfr-3.1.2-a/src/fits_uintmax.c	2013-03-13 15:37:33.000000000 +0000
+++ mpfr-3.1.2-b/src/fits_uintmax.c	2013-09-26 10:56:55.000000000 +0000
@@ -27,51 +27,19 @@
 #include "mpfr-intmax.h"
 #include "mpfr-impl.h"
 
-#ifdef _MPFR_H_HAVE_INTMAX_T
-
-/* We can't use fits_u.h <= mpfr_cmp_ui */
-int
-mpfr_fits_uintmax_p (mpfr_srcptr f, mpfr_rnd_t rnd)
-{
-  mpfr_exp_t e;
-  int prec;
-  uintmax_t s;
-  mpfr_t x;
-  int res;
-
-  if (MPFR_UNLIKELY (MPFR_IS_SINGULAR (f)))
-    /* Zero always fit */
-    return MPFR_IS_ZERO (f) ? 1 : 0;
-  else if (MPFR_IS_NEG (f))
-    /* Negative numbers don't fit */
-    return 0;
-  /* now it fits if
-     (a) f <= MAXIMUM
-     (b) round(f, prec(slong), rnd) <= MAXIMUM */
-
-  e = MPFR_GET_EXP (f);
-
-  /* first compute prec(MAXIMUM); fits in an int */
-  for (s = MPFR_UINTMAX_MAX, prec = 0; s != 0; s /= 2, prec ++);
-
-  /* MAXIMUM needs prec bits, i.e. MAXIMUM = 2^prec - 1 */
-
-  /* if e <= prec - 1, then f < 2^(prec-1) < MAXIMUM */
-  if (e <= prec - 1)
-    return 1;
+/* Note: though mpfr-impl.h is included in fits_u.h, we also include it
+   above so that it gets included even when _MPFR_H_HAVE_INTMAX_T is not
+   defined; this is necessary to avoid an empty translation unit, which
+   is forbidden by ISO C. Without this, a failing test can be reproduced
+   by creating an invalid stdint.h somewhere in the default include path
+   and by compiling MPFR with "gcc -ansi -pedantic-errors". */
 
-  /* if e >= prec + 1, then f >= 2^prec > MAXIMUM */
-  if (e >= prec + 1)
-    return 0;
+#ifdef _MPFR_H_HAVE_INTMAX_T
 
-  MPFR_ASSERTD (e == prec);
+#define FUNCTION   mpfr_fits_uintmax_p
+#define MAXIMUM    MPFR_UINTMAX_MAX
+#define TYPE       uintmax_t
 
-  /* hard case: first round to prec bits, then check */
-  mpfr_init2 (x, prec);
-  mpfr_set (x, f, rnd);
-  res = MPFR_GET_EXP (x) == e;
-  mpfr_clear (x);
-  return res;
-}
+#include "fits_u.h"
 
 #endif
diff -Naurd mpfr-3.1.2-a/src/mpfr.h mpfr-3.1.2-b/src/mpfr.h
--- mpfr-3.1.2-a/src/mpfr.h	2013-09-26 10:52:52.000000000 +0000
+++ mpfr-3.1.2-b/src/mpfr.h	2013-09-26 10:56:55.000000000 +0000
@@ -27,7 +27,7 @@
 #define MPFR_VERSION_MAJOR 3
 #define MPFR_VERSION_MINOR 1
 #define MPFR_VERSION_PATCHLEVEL 2
-#define MPFR_VERSION_STRING "3.1.2-p1"
+#define MPFR_VERSION_STRING "3.1.2-p2"
 
 /* Macros dealing with MPFR VERSION */
 #define MPFR_VERSION_NUM(a,b,c) (((a) << 16L) | ((b) << 8) | (c))
diff -Naurd mpfr-3.1.2-a/src/version.c mpfr-3.1.2-b/src/version.c
--- mpfr-3.1.2-a/src/version.c	2013-09-26 10:52:52.000000000 +0000
+++ mpfr-3.1.2-b/src/version.c	2013-09-26 10:56:55.000000000 +0000
@@ -25,5 +25,5 @@
 const char *
 mpfr_get_version (void)
 {
-  return "3.1.2-p1";
+  return "3.1.2-p2";
 }
diff -Naurd mpfr-3.1.2-a/tests/tfits.c mpfr-3.1.2-b/tests/tfits.c
--- mpfr-3.1.2-a/tests/tfits.c	2013-03-13 15:37:45.000000000 +0000
+++ mpfr-3.1.2-b/tests/tfits.c	2013-09-26 10:56:55.000000000 +0000
@@ -33,155 +33,176 @@
 #include "mpfr-intmax.h"
 #include "mpfr-test.h"
 
-#define ERROR1 { printf("Initial error for x="); mpfr_dump(x); exit(1); }
-#define ERROR2 { printf("Error for x="); mpfr_dump(x); exit(1); }
+#define ERROR1(N)                                               \
+  do                                                            \
+    {                                                           \
+      printf("Error %d for rnd = %s and x = ", N,               \
+             mpfr_print_rnd_mode ((mpfr_rnd_t) r));             \
+      mpfr_dump(x);                                             \
+      exit(1);                                                  \
+    }                                                           \
+  while (0)
 
 static void check_intmax (void);
 
 int
 main (void)
 {
-  mpfr_t x;
+  mpfr_t x, y;
+  int i, r;
 
   tests_start_mpfr ();
 
   mpfr_init2 (x, 256);
+  mpfr_init2 (y, 8);
 
-  /* Check NAN */
-  mpfr_set_nan (x);
-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_slong_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_uint_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_ushort_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR1;
+  RND_LOOP (r)
+    {
 
-  /* Check INF */
-  mpfr_set_inf (x, 1);
-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_slong_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_uint_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_ushort_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR1;
+      /* Check NAN */
+      mpfr_set_nan (x);
+      if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (1);
+      if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (2);
+      if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (3);
+      if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (4);
+      if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (5);
+      if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (6);
 
-  /* Check Zero */
-  MPFR_SET_ZERO (x);
-  if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_uint_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR2;
+      /* Check INF */
+      mpfr_set_inf (x, 1);
+      if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (7);
+      if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (8);
+      if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (9);
+      if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (10);
+      if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (11);
+      if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (12);
 
-  /* Check small op */
-  mpfr_set_str1 (x, "1@-1");
-  if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_uint_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR2;
+      /* Check Zero */
+      MPFR_SET_ZERO (x);
+      if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (13);
+      if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (14);
+      if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (15);
+      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (16);
+      if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (17);
+      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (18);
 
-  /* Check 17 */
-  mpfr_set_ui (x, 17, MPFR_RNDN);
-  if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_uint_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR2;
+      /* Check small positive op */
+      mpfr_set_str1 (x, "1@-1");
+      if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (19);
+      if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (20);
+      if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (21);
+      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (22);
+      if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (23);
+      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (24);
 
-  /* Check all other values */
-  mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
-  mpfr_mul_2exp (x, x, 1, MPFR_RNDN);
-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_slong_p (x, MPFR_RNDN))
-    ERROR1;
-  mpfr_mul_2exp (x, x, 40, MPFR_RNDN);
-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_uint_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_ushort_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR1;
+      /* Check 17 */
+      mpfr_set_ui (x, 17, MPFR_RNDN);
+      if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (25);
+      if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (26);
+      if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (27);
+      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (28);
+      if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (29);
+      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (30);
 
-  mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
-  if (!mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR2;
-  mpfr_set_ui (x, LONG_MAX, MPFR_RNDN);
-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
-    ERROR2;
-  mpfr_set_ui (x, UINT_MAX, MPFR_RNDN);
-  if (!mpfr_fits_uint_p (x, MPFR_RNDN))
-    ERROR2;
-  mpfr_set_ui (x, INT_MAX, MPFR_RNDN);
-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR2;
-  mpfr_set_ui (x, USHRT_MAX, MPFR_RNDN);
-  if (!mpfr_fits_ushort_p (x, MPFR_RNDN))
-    ERROR2;
-  mpfr_set_ui (x, SHRT_MAX, MPFR_RNDN);
-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR2;
+      /* Check all other values */
+      mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
+      mpfr_mul_2exp (x, x, 1, MPFR_RNDN);
+      if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (31);
+      if (mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (32);
+      mpfr_mul_2exp (x, x, 40, MPFR_RNDN);
+      if (mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (33);
+      if (mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (34);
+      if (mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (35);
+      if (mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (36);
+      if (mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (37);
 
-  mpfr_set_si (x, 1, MPFR_RNDN);
-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR2;
+      mpfr_set_ui (x, ULONG_MAX, MPFR_RNDN);
+      if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (38);
+      mpfr_set_ui (x, LONG_MAX, MPFR_RNDN);
+      if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+        ERROR1 (39);
+      mpfr_set_ui (x, UINT_MAX, MPFR_RNDN);
+      if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (40);
+      mpfr_set_ui (x, INT_MAX, MPFR_RNDN);
+      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (41);
+      mpfr_set_ui (x, USHRT_MAX, MPFR_RNDN);
+      if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (42);
+      mpfr_set_ui (x, SHRT_MAX, MPFR_RNDN);
+      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (43);
 
-  /* Check negative value */
-  mpfr_set_si (x, -1, MPFR_RNDN);
-  if (!mpfr_fits_sint_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_sshort_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_slong_p (x, MPFR_RNDN))
-    ERROR2;
-  if (mpfr_fits_uint_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_ushort_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_ulong_p (x, MPFR_RNDN))
-    ERROR1;
+      mpfr_set_si (x, 1, MPFR_RNDN);
+      if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+        ERROR1 (44);
+      if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+        ERROR1 (45);
+
+      /* Check negative op */
+      for (i = 1; i <= 4; i++)
+        {
+          int inv;
+
+          mpfr_set_si_2exp (x, -i, -2, MPFR_RNDN);
+          mpfr_rint (y, x, (mpfr_rnd_t) r);
+          inv = MPFR_NOTZERO (y);
+          if (!mpfr_fits_ulong_p (x, (mpfr_rnd_t) r) ^ inv)
+            ERROR1 (46);
+          if (!mpfr_fits_slong_p (x, (mpfr_rnd_t) r))
+            ERROR1 (47);
+          if (!mpfr_fits_uint_p (x, (mpfr_rnd_t) r) ^ inv)
+            ERROR1 (48);
+          if (!mpfr_fits_sint_p (x, (mpfr_rnd_t) r))
+            ERROR1 (49);
+          if (!mpfr_fits_ushort_p (x, (mpfr_rnd_t) r) ^ inv)
+            ERROR1 (50);
+          if (!mpfr_fits_sshort_p (x, (mpfr_rnd_t) r))
+            ERROR1 (51);
+        }
+    }
 
   mpfr_clear (x);
+  mpfr_clear (y);
 
   check_intmax ();
 
@@ -189,85 +210,98 @@
   return 0;
 }
 
-static void check_intmax (void)
+static void
+check_intmax (void)
 {
 #ifdef _MPFR_H_HAVE_INTMAX_T
-  mpfr_t x;
+  mpfr_t x, y;
+  int i, r;
 
-  mpfr_init2 (x, sizeof (uintmax_t)*CHAR_BIT);
+  mpfr_init2 (x, sizeof (uintmax_t) * CHAR_BIT);
+  mpfr_init2 (y, 8);
 
-  /* Check NAN */
-  mpfr_set_nan (x);
-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR1;
+  RND_LOOP (r)
+    {
+      /* Check NAN */
+      mpfr_set_nan (x);
+      if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (52);
+      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (53);
 
-  /* Check INF */
-  mpfr_set_inf (x, 1);
-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR1;
+      /* Check INF */
+      mpfr_set_inf (x, 1);
+      if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (54);
+      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (55);
 
-  /* Check Zero */
-  MPFR_SET_ZERO (x);
-  if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR2;
+      /* Check Zero */
+      MPFR_SET_ZERO (x);
+      if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (56);
+      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (57);
 
-  /* Check small op */
-  mpfr_set_str1 (x, "1@-1");
-  if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR2;
+      /* Check positive small op */
+      mpfr_set_str1 (x, "1@-1");
+      if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (58);
+      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (59);
 
-  /* Check 17 */
-  mpfr_set_ui (x, 17, MPFR_RNDN);
-  if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR2;
-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR2;
+      /* Check 17 */
+      mpfr_set_ui (x, 17, MPFR_RNDN);
+      if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (60);
+      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (61);
 
-  /* Check hugest */
-  mpfr_set_ui_2exp (x, 42, sizeof (uintmax_t) * 32, MPFR_RNDN);
-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR1;
-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR1;
+      /* Check hugest */
+      mpfr_set_ui_2exp (x, 42, sizeof (uintmax_t) * 32, MPFR_RNDN);
+      if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (62);
+      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (63);
 
-  /* Check all other values */
-  mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
-  mpfr_add_ui (x, x, 1, MPFR_RNDN);
-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR1;
-  mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
-  if (!mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR2;
-  mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
-  mpfr_add_ui (x, x, 1, MPFR_RNDN);
-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR1;
-  mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR2;
-  mpfr_set_sj (x, MPFR_INTMAX_MIN, MPFR_RNDN);
-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR2;
-  mpfr_sub_ui (x, x, 1, MPFR_RNDN);
-  if (mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR1;
+      /* Check all other values */
+      mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
+      mpfr_add_ui (x, x, 1, MPFR_RNDN);
+      if (mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (64);
+      mpfr_set_uj (x, MPFR_UINTMAX_MAX, MPFR_RNDN);
+      if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (65);
+      mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
+      mpfr_add_ui (x, x, 1, MPFR_RNDN);
+      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (66);
+      mpfr_set_sj (x, MPFR_INTMAX_MAX, MPFR_RNDN);
+      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (67);
+      mpfr_set_sj (x, MPFR_INTMAX_MIN, MPFR_RNDN);
+      if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (68);
+      mpfr_sub_ui (x, x, 1, MPFR_RNDN);
+      if (mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+        ERROR1 (69);
 
-  /* Check negative value */
-  mpfr_set_si (x, -1, MPFR_RNDN);
-  if (!mpfr_fits_intmax_p (x, MPFR_RNDN))
-    ERROR2;
-  if (mpfr_fits_uintmax_p (x, MPFR_RNDN))
-    ERROR1;
+      /* Check negative op */
+      for (i = 1; i <= 4; i++)
+        {
+          int inv;
+
+          mpfr_set_si_2exp (x, -i, -2, MPFR_RNDN);
+          mpfr_rint (y, x, (mpfr_rnd_t) r);
+          inv = MPFR_NOTZERO (y);
+          if (!mpfr_fits_uintmax_p (x, (mpfr_rnd_t) r) ^ inv)
+            ERROR1 (70);
+          if (!mpfr_fits_intmax_p (x, (mpfr_rnd_t) r))
+            ERROR1 (71);
+        }
+    }
 
   mpfr_clear (x);
+  mpfr_clear (y);
 #endif
 }
-