diff --git a/internal/cgen/base/f64conv-submodule.c b/internal/cgen/base/f64conv-submodule.c
index e0b79d7..5e48340 100644
--- a/internal/cgen/base/f64conv-submodule.c
+++ b/internal/cgen/base/f64conv-submodule.c
@@ -16,8 +16,8 @@
 
 // ---------------- IEEE 754 Floating Point
 
-#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE 1023
-#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION 500
+#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE 2047
+#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION 800
 
 // WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL is the largest N
 // such that ((10 << N) < (1 << 64)).
@@ -27,14 +27,14 @@
 // fixed precision floating point decimal number, augmented with ±infinity
 // values, but it cannot represent NaN (Not a Number).
 //
-// "High precision" means that the mantissa holds 500 decimal digits. 500 is
+// "High precision" means that the mantissa holds 800 decimal digits. 800 is
 // WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION.
 //
 // An HPD isn't for general purpose arithmetic, only for conversions to and
 // from IEEE 754 double-precision floating point, where the largest and
 // smallest positive, finite values are approximately 1.8e+308 and 4.9e-324.
-// HPD exponents above +1023 mean infinity, below -1023 mean zero. The ±1023
-// bounds are further away from zero than ±(324 + 500), where 500 and 1023 is
+// HPD exponents above +2047 mean infinity, below -2047 mean zero. The ±2047
+// bounds are further away from zero than ±(324 + 800), where 800 and 2047 is
 // WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION and
 // WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.
 //
@@ -56,8 +56,8 @@
 //   - A decimal_point of +4 means "7890."
 //   - A decimal_point of +5 means "78900."
 //
-// As above, a decimal_point higher than +1023 means that the overall value is
-// infinity, lower than -1023 means zero.
+// As above, a decimal_point higher than +2047 means that the overall value is
+// infinity, lower than -2047 means zero.
 //
 // negative is a sign bit. An HPD can distinguish positive and negative zero.
 //
@@ -89,6 +89,48 @@
   }
 }
 
+// wuffs_base__private_implementation__high_prec_dec__assign sets h to
+// represent the number x.
+//
+// Preconditions:
+//  - h is non-NULL.
+static void  //
+wuffs_base__private_implementation__high_prec_dec__assign(
+    wuffs_base__private_implementation__high_prec_dec* h,
+    uint64_t x,
+    bool negative) {
+  uint32_t n = 0;
+
+  // Set h->digits.
+  if (x > 0) {
+    // Calculate the digits, working right-to-left. After we determine n (how
+    // many digits there are), copy from buf to h->digits.
+    //
+    // UINT64_MAX, 18446744073709551615, is 20 digits long. It can be faster to
+    // copy a constant number of bytes than a variable number (20 instead of
+    // n). Make buf large enough (and start writing to it from the middle) so
+    // that can we always copy 20 bytes: the slice buf[(20-n) .. (40-n)].
+    uint8_t buf[40] = {0};
+    uint8_t* ptr = &buf[20];
+    do {
+      uint64_t remaining = x / 10;
+      x -= remaining * 10;
+      ptr--;
+      *ptr = (uint8_t)x;
+      n++;
+      x = remaining;
+    } while (x > 0);
+    memcpy(h->digits, ptr, 20);
+  }
+
+  // Set h's other fields.
+  h->num_digits = n;
+  h->decimal_point = (int32_t)n;
+  h->negative = negative;
+  h->truncated = false;
+  wuffs_base__private_implementation__high_prec_dec__trim(h);
+}
+
 static wuffs_base__status  //
 wuffs_base__private_implementation__high_prec_dec__parse(
     wuffs_base__private_implementation__high_prec_dec* h,
@@ -464,6 +506,11 @@
 // wuffs_base__private_implementation__high_prec_dec__rounded_integer and
 // wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits
 // have the same preconditions.
+//
+// wuffs_base__private_implementation__high_prec_dec__lshift keeps the first
+// two preconditions but not the last two. Its shift argument is signed and
+// does not need to be "small": zero is a no-op, positive means left shift and
+// negative means right shift.
 
 static void  //
 wuffs_base__private_implementation__high_prec_dec__small_lshift(
@@ -577,6 +624,254 @@
   wuffs_base__private_implementation__high_prec_dec__trim(h);
 }
 
+static void  //
+wuffs_base__private_implementation__high_prec_dec__lshift(
+    wuffs_base__private_implementation__high_prec_dec* h,
+    int32_t shift) {
+  if (shift > 0) {
+    while (shift > +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {
+      wuffs_base__private_implementation__high_prec_dec__small_lshift(
+          h, WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL);
+      shift -= WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;
+    }
+    wuffs_base__private_implementation__high_prec_dec__small_lshift(
+        h, ((uint32_t)(+shift)));
+  } else if (shift < 0) {
+    while (shift < -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {
+      wuffs_base__private_implementation__high_prec_dec__small_rshift(
+          h, WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL);
+      shift += WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;
+    }
+    wuffs_base__private_implementation__high_prec_dec__small_rshift(
+        h, ((uint32_t)(-shift)));
+  }
+}
+
+// --------
+
+// wuffs_base__private_implementation__high_prec_dec__round_etc rounds h's
+// number. For those functions that take an n argument, rounding produces at
+// most n digits (which is not necessarily at most n decimal places). Negative
+// n values are ignored, as well as any n greater than or equal to h's number
+// of digits. The etc__round_just_enough function implicitly chooses an n to
+// implement WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION.
+//
+// Preconditions:
+//  - h is non-NULL.
+//  - h->decimal_point is "not extreme".
+//
+// "Not extreme" means within
+// ±WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.
+
+static void  //
+wuffs_base__private_implementation__high_prec_dec__round_down(
+    wuffs_base__private_implementation__high_prec_dec* h,
+    int32_t n) {
+  if ((n < 0) || (h->num_digits <= (uint32_t)n)) {
+    return;
+  }
+  h->num_digits = (uint32_t)(n);
+  wuffs_base__private_implementation__high_prec_dec__trim(h);
+}
+
+static void  //
+wuffs_base__private_implementation__high_prec_dec__round_up(
+    wuffs_base__private_implementation__high_prec_dec* h,
+    int32_t n) {
+  if ((n < 0) || (h->num_digits <= (uint32_t)n)) {
+    return;
+  }
+
+  for (n--; n >= 0; n--) {
+    if (h->digits[n] < 9) {
+      h->digits[n]++;
+      h->num_digits = (uint32_t)(n + 1);
+      return;
+    }
+  }
+
+  // The number is all 9s. Change to a single 1 and adjust the decimal point.
+  h->digits[0] = 1;
+  h->num_digits = 1;
+  h->decimal_point++;
+}
+
+static void  //
+wuffs_base__private_implementation__high_prec_dec__round_nearest(
+    wuffs_base__private_implementation__high_prec_dec* h,
+    int32_t n) {
+  if ((n < 0) || (h->num_digits <= (uint32_t)n)) {
+    return;
+  }
+  bool up = h->digits[n] >= 5;
+  if ((h->digits[n] == 5) && ((n + 1) == ((int32_t)(h->num_digits)))) {
+    up = h->truncated ||  //
+         ((n > 0) && ((h->digits[n - 1] & 1) != 0));
+  }
+
+  if (up) {
+    wuffs_base__private_implementation__high_prec_dec__round_up(h, n);
+  } else {
+    wuffs_base__private_implementation__high_prec_dec__round_down(h, n);
+  }
+}
+
+static void  //
+wuffs_base__private_implementation__high_prec_dec__round_just_enough(
+    wuffs_base__private_implementation__high_prec_dec* h,
+    int32_t exp2,
+    uint64_t mantissa) {
+  // The magic numbers 52 and 53 in this function are because IEEE 754 double
+  // precision has 52 mantissa bits.
+  //
+  // Let f be the floating point number represented by exp2 and mantissa (and
+  // also the number in h): the number (mantissa * (2 ** (exp2 - 52))).
+  //
+  // If f is zero, we can return early.
+  if (mantissa == 0) {
+    return;
+  }
+
+  // The smallest normal f has an exp2 of -1022 and a mantissa of (1 << 52).
+  // Subnormal numbers have the same exp2 but a smaller mantissa.
+  static const int32_t min_incl_normal_exp2 = -1022;
+  static const uint64_t min_incl_normal_mantissa = 0x0010000000000000ul;
+
+  // Compute lower and upper bounds such that any number between them (possibly
+  // inclusive) will round to f. First, the lower bound. Our number f is:
+  //   ((mantissa + 0)         * (2 ** (  exp2 - 52)))
+  //
+  // The next lowest floating point number is:
+  //   ((mantissa - 1)         * (2 ** (  exp2 - 52)))
+  // unless (mantissa - 1) drops the (1 << 52) bit and exp2 is not the
+  // min_incl_normal_exp2. Either way, call it:
+  //   ((l_mantissa)           * (2 ** (l_exp2 - 52)))
+  //
+  // The lower bound is halfway between them (noting that 52 became 53):
+  //   (((2 * l_mantissa) + 1) * (2 ** (l_exp2 - 53)))
+  int32_t l_exp2 = exp2;
+  uint64_t l_mantissa = mantissa - 1;
+  if ((exp2 > min_incl_normal_exp2) && (mantissa <= min_incl_normal_mantissa)) {
+    l_exp2 = exp2 - 1;
+    l_mantissa = (2 * mantissa) - 1;
+  }
+  wuffs_base__private_implementation__high_prec_dec lower;
+  wuffs_base__private_implementation__high_prec_dec__assign(
+      &lower, (2 * l_mantissa) + 1, false);
+  wuffs_base__private_implementation__high_prec_dec__lshift(&lower,
+                                                            l_exp2 - 53);
+
+  // Next, the upper bound. Our number f is:
+  //   ((mantissa + 0)       * (2 ** (exp2 - 52)))
+  //
+  // The next highest floating point number is:
+  //   ((mantissa + 1)       * (2 ** (exp2 - 52)))
+  //
+  // The upper bound is halfway between them (noting that 52 became 53):
+  //   (((2 * mantissa) + 1) * (2 ** (exp2 - 53)))
+  wuffs_base__private_implementation__high_prec_dec upper;
+  wuffs_base__private_implementation__high_prec_dec__assign(
+      &upper, (2 * mantissa) + 1, false);
+  wuffs_base__private_implementation__high_prec_dec__lshift(&upper, exp2 - 53);
+
+  // The lower and upper bounds are possible outputs only if the original
+  // mantissa is even, so that IEEE round-to-even would round to the original
+  // mantissa and not its neighbors.
+  bool inclusive = (mantissa & 1) == 0;
+
+  // As we walk the digits, we want to know whether rounding up would fall
+  // within the upper bound. This is tracked by upper_delta:
+  //  - When -1, the digits of h and upper are the same so far.
+  //  - When +0, we saw a difference of 1 between h and upper on a previous
+  //    digit and subsequently only 9s for h and 0s for upper. Thus, rounding
+  //    up may fall outside of the bound if !inclusive.
+  //  - When +1, the difference is greater than 1 and we know that rounding up
+  //    falls within the bound.
+  //
+  // This is a state machine with three states. The numerical value for each
+  // state (-1, +0 or +1) isn't important, other than their order.
+  int upper_delta = -1;
+
+  // We can now figure out the shortest number of digits required. Walk the
+  // digits until h has distinguished itself from lower or upper.
+  //
+  // The zi and zd variables are indexes and digits, for z in l (lower), h (the
+  // number) and u (upper).
+  //
+  // The lower, h and upper numbers may have their decimal points at different
+  // places. In this case, upper is the longest, so we iterate ui starting from
+  // 0 and iterate li and hi starting from either 0 or -1.
+  int32_t ui = 0;
+  for (;; ui++) {
+    // Calculate hd, the middle number's digit.
+    int32_t hi = ui - upper.decimal_point + h->decimal_point;
+    if (hi >= ((int32_t)(h->num_digits))) {
+      break;
+    }
+    uint8_t hd = (((uint32_t)hi) < h->num_digits) ? h->digits[hi] : 0;
+
+    // Calculate ld, the lower bound's digit.
+    int32_t li = ui - upper.decimal_point + lower.decimal_point;
+    uint8_t ld = (((uint32_t)li) < lower.num_digits) ? lower.digits[li] : 0;
+
+    // We can round down (truncate) if lower has a different digit than h or if
+    // lower is inclusive and is exactly the result of rounding down (i.e. we
+    // have reached the final digit of lower).
+    bool can_round_down =
+        (ld != hd) ||  //
+        (inclusive && ((li + 1) == ((int32_t)(lower.num_digits))));
+
+    // Calculate ud, the upper bound's digit, and update upper_delta.
+    uint8_t ud = (((uint32_t)ui) < upper.num_digits) ? upper.digits[ui] : 0;
+    if (upper_delta < 0) {
+      if ((hd + 1) < ud) {
+        // For example:
+        // h     = 12345???
+        // upper = 12347???
+        upper_delta = +1;
+      } else if (hd != ud) {
+        // For example:
+        // h     = 12345???
+        // upper = 12346???
+        upper_delta = +0;
+      }
+    } else if (upper_delta == 0) {
+      if ((hd != 9) || (ud != 0)) {
+        // For example:
+        // h     = 1234598?
+        // upper = 1234600?
+        upper_delta = +1;
+      }
+    }
+
+    // We can round up if upper has a different digit than h and either upper
+    // is inclusive or upper is bigger than the result of rounding up.
+    bool can_round_up =
+        (upper_delta > 0) ||    //
+        ((upper_delta == 0) &&  //
+         (inclusive || ((ui + 1) < ((int32_t)(upper.num_digits)))));
+
+    // If we can round either way, round to nearest. If we can round only one
+    // way, do it. If we can't round, continue the loop.
+    if (can_round_down) {
+      if (can_round_up) {
+        wuffs_base__private_implementation__high_prec_dec__round_nearest(
+            h, hi + 1);
+        return;
+      } else {
+        wuffs_base__private_implementation__high_prec_dec__round_down(h,
+                                                                      hi + 1);
+        return;
+      }
+    } else {
+      if (can_round_up) {
+        wuffs_base__private_implementation__high_prec_dec__round_up(h, hi + 1);
+        return;
+      }
+    }
+  }
+}
+
 // --------
 
 // The wuffs_base__private_implementation__etc_powers_of_10 tables were printed
@@ -1262,3 +1557,300 @@
     return ret;
   } while (0);
 }
+
+// --------
+
+static inline size_t  //
+wuffs_base__private_implementation__render_inf(wuffs_base__slice_u8 dst,
+                                               bool neg,
+                                               uint32_t options) {
+  if (neg) {
+    if (dst.len < 4) {
+      return 0;
+    }
+    wuffs_base__store_u32le__no_bounds_check(dst.ptr, 0x666E492D);  // '-Inf'le.
+    return 4;
+  }
+
+  if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {
+    if (dst.len < 4) {
+      return 0;
+    }
+    wuffs_base__store_u32le__no_bounds_check(dst.ptr, 0x666E492B);  // '+Inf'le.
+    return 4;
+  }
+
+  if (dst.len < 3) {
+    return 0;
+  }
+  wuffs_base__store_u24le__no_bounds_check(dst.ptr, 0x666E49);  // 'Inf'le.
+  return 3;
+}
+
+static inline size_t  //
+wuffs_base__private_implementation__render_nan(wuffs_base__slice_u8 dst) {
+  if (dst.len < 3) {
+    return 0;
+  }
+  wuffs_base__store_u24le__no_bounds_check(dst.ptr, 0x4E614E);  // 'NaN'le.
+  return 3;
+}
+
+static size_t  //
+wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(
+    wuffs_base__slice_u8 dst,
+    wuffs_base__private_implementation__high_prec_dec* h,
+    uint32_t precision,
+    uint32_t options) {
+  size_t n = (h->negative ||
+              (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN))
+                 ? 1
+                 : 0;
+  if (h->decimal_point <= 0) {
+    n += 1;
+  } else {
+    n += (size_t)(h->decimal_point);
+  }
+  if (precision > 0) {
+    n += precision + 1;  // +1 for the '.'.
+  }
+
+  // Don't modify dst if the formatted number won't fit.
+  if (n > dst.len) {
+    return 0;
+  }
+
+  // Align-left or align-right.
+  uint8_t* ptr = (options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)
+                     ? &dst.ptr[dst.len - n]
+                     : &dst.ptr[0];
+
+  // Leading "±".
+  if (h->negative) {
+    *ptr++ = '-';
+  } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {
+    *ptr++ = '+';
+  }
+
+  // Integral digits.
+  if (h->decimal_point <= 0) {
+    *ptr++ = '0';
+  } else {
+    uint32_t m =
+        wuffs_base__u32__min(h->num_digits, (uint32_t)(h->decimal_point));
+    uint32_t i = 0;
+    for (; i < m; i++) {
+      *ptr++ = (uint8_t)('0' | h->digits[i]);
+    }
+    for (; i < (uint32_t)(h->decimal_point); i++) {
+      *ptr++ = '0';
+    }
+  }
+
+  // Separator and then fractional digits.
+  if (precision > 0) {
+    *ptr++ =
+        (options & WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)
+            ? ','
+            : '.';
+    uint32_t i = 0;
+    for (; i < precision; i++) {
+      uint32_t j = ((uint32_t)(h->decimal_point)) + i;
+      *ptr++ = (uint8_t)('0' | ((j < h->num_digits) ? h->digits[j] : 0));
+    }
+  }
+
+  return n;
+}
+
+static size_t  //
+wuffs_base__private_implementation__high_prec_dec__render_exponent_present(
+    wuffs_base__slice_u8 dst,
+    wuffs_base__private_implementation__high_prec_dec* h,
+    uint32_t precision,
+    uint32_t options) {
+  int32_t exp = 0;
+  if (h->num_digits > 0) {
+    exp = h->decimal_point - 1;
+  }
+  bool negative_exp = exp < 0;
+  if (negative_exp) {
+    exp = -exp;
+  }
+
+  size_t n = (h->negative ||
+              (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN))
+                 ? 4
+                 : 3;  // Mininum 3 bytes: first digit and then "e±".
+  if (precision > 0) {
+    n += precision + 1;  // +1 for the '.'.
+  }
+  n += (exp < 100) ? 2 : 3;
+
+  // Don't modify dst if the formatted number won't fit.
+  if (n > dst.len) {
+    return 0;
+  }
+
+  // Align-left or align-right.
+  uint8_t* ptr = (options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)
+                     ? &dst.ptr[dst.len - n]
+                     : &dst.ptr[0];
+
+  // Leading "±".
+  if (h->negative) {
+    *ptr++ = '-';
+  } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {
+    *ptr++ = '+';
+  }
+
+  // Integral digit.
+  if (h->num_digits > 0) {
+    *ptr++ = (uint8_t)('0' | h->digits[0]);
+  } else {
+    *ptr++ = '0';
+  }
+
+  // Separator and then fractional digits.
+  if (precision > 0) {
+    *ptr++ =
+        (options & WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)
+            ? ','
+            : '.';
+    uint32_t i = 1;
+    uint32_t j = wuffs_base__u32__min(h->num_digits, precision + 1);
+    for (; i < j; i++) {
+      *ptr++ = (uint8_t)('0' | h->digits[i]);
+    }
+    for (; i <= precision; i++) {
+      *ptr++ = '0';
+    }
+  }
+
+  // Exponent: "e±" and then 2 or 3 digits.
+  *ptr++ = 'e';
+  *ptr++ = negative_exp ? '-' : '+';
+  if (exp < 10) {
+    *ptr++ = '0';
+    *ptr++ = (uint8_t)('0' | exp);
+  } else if (exp < 100) {
+    *ptr++ = (uint8_t)('0' | (exp / 10));
+    *ptr++ = (uint8_t)('0' | (exp % 10));
+  } else {
+    int32_t e = exp / 100;
+    exp -= e * 100;
+    *ptr++ = (uint8_t)('0' | e);
+    *ptr++ = (uint8_t)('0' | (exp / 10));
+    *ptr++ = (uint8_t)('0' | (exp % 10));
+  }
+
+  return n;
+}
+
+WUFFS_BASE__MAYBE_STATIC size_t  //
+wuffs_base__render_number_f64(wuffs_base__slice_u8 dst,
+                              double x,
+                              uint32_t precision,
+                              uint32_t options) {
+  // Decompose x (64 bits) into negativity (1 bit), base-2 exponent (11 bits
+  // with a -1023 bias) and mantissa (52 bits).
+  uint64_t bits = wuffs_base__ieee_754_bit_representation__from_f64(x);
+  bool neg = (bits >> 63) != 0;
+  int32_t exp2 = ((int32_t)(bits >> 52)) & 0x7FF;
+  uint64_t man = bits & 0x000FFFFFFFFFFFFFul;
+
+  // Apply the exponent bias and set the implicit top bit of the mantissa,
+  // unless x is subnormal. Also take care of Inf and NaN.
+  if (exp2 == 0x7FF) {
+    if (man != 0) {
+      return wuffs_base__private_implementation__render_nan(dst);
+    }
+    return wuffs_base__private_implementation__render_inf(dst, neg, options);
+  } else if (exp2 == 0) {
+    exp2 = -1022;
+  } else {
+    exp2 -= 1023;
+    man |= 0x0010000000000000ul;
+  }
+
+  // Ensure that precision isn't too large.
+  if (precision > 4095) {
+    precision = 4095;
+  }
+
+  // Convert from the (neg, exp2, man) tuple to an HPD.
+  wuffs_base__private_implementation__high_prec_dec h;
+  wuffs_base__private_implementation__high_prec_dec__assign(&h, man, neg);
+  if (h.num_digits > 0) {
+    wuffs_base__private_implementation__high_prec_dec__lshift(
+        &h, exp2 - 52);  // 52 mantissa bits.
+  }
+
+  // Handle the "%e" and "%f" formats.
+  switch (options & (WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT |
+                     WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT)) {
+    case WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT:  // The "%"f" format.
+      if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {
+        wuffs_base__private_implementation__high_prec_dec__round_just_enough(
+            &h, exp2, man);
+        int32_t p = ((int32_t)(h.num_digits)) - h.decimal_point;
+        precision = ((uint32_t)(wuffs_base__i32__max(0, p)));
+      } else {
+        wuffs_base__private_implementation__high_prec_dec__round_nearest(
+            &h, ((int32_t)precision) + h.decimal_point);
+      }
+      return wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(
+          dst, &h, precision, options);
+
+    case WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT:  // The "%e" format.
+      if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {
+        wuffs_base__private_implementation__high_prec_dec__round_just_enough(
+            &h, exp2, man);
+        precision = (h.num_digits > 0) ? (h.num_digits - 1) : 0;
+      } else {
+        wuffs_base__private_implementation__high_prec_dec__round_nearest(
+            &h, ((int32_t)precision) + 1);
+      }
+      return wuffs_base__private_implementation__high_prec_dec__render_exponent_present(
+          dst, &h, precision, options);
+  }
+
+  // We have the "%g" format and so precision means the number of significant
+  // digits, not the number of digits after the decimal separator. Perform
+  // rounding and determine whether to use "%e" or "%f".
+  int32_t e_threshold = 0;
+  if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {
+    wuffs_base__private_implementation__high_prec_dec__round_just_enough(
+        &h, exp2, man);
+    precision = h.num_digits;
+    e_threshold = 6;
+  } else {
+    if (precision == 0) {
+      precision = 1;
+    }
+    wuffs_base__private_implementation__high_prec_dec__round_nearest(
+        &h, ((int32_t)precision));
+    e_threshold = ((int32_t)precision);
+    int32_t nd = ((int32_t)(h.num_digits));
+    if ((e_threshold > nd) && (nd >= h.decimal_point)) {
+      e_threshold = nd;
+    }
+  }
+
+  // Use the "%e" format if the exponent is large.
+  int32_t e = h.decimal_point - 1;
+  if ((e < -4) || (e_threshold <= e)) {
+    uint32_t p = wuffs_base__u32__min(precision, h.num_digits);
+    return wuffs_base__private_implementation__high_prec_dec__render_exponent_present(
+        dst, &h, (p > 0) ? (p - 1) : 0, options);
+  }
+
+  // Use the "%f" format otherwise.
+  int32_t p = ((int32_t)precision);
+  if (p > h.decimal_point) {
+    p = ((int32_t)(h.num_digits));
+  }
+  precision = ((uint32_t)(wuffs_base__i32__max(0, p - h.decimal_point)));
+  return wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(
+      dst, &h, precision, options);
+}
diff --git a/internal/cgen/base/fundamental-public.h b/internal/cgen/base/fundamental-public.h
index f69e2e4..55c0d40 100644
--- a/internal/cgen/base/fundamental-public.h
+++ b/internal/cgen/base/fundamental-public.h
@@ -281,6 +281,46 @@
 // inline attribute to guide optimizations such as inlining, to avoid the
 // -Wunused-function warning, and we like to compile with -Wall -Werror.
 
+static inline int8_t  //
+wuffs_base__i8__min(int8_t x, int8_t y) {
+  return x < y ? x : y;
+}
+
+static inline int8_t  //
+wuffs_base__i8__max(int8_t x, int8_t y) {
+  return x > y ? x : y;
+}
+
+static inline int16_t  //
+wuffs_base__i16__min(int16_t x, int16_t y) {
+  return x < y ? x : y;
+}
+
+static inline int16_t  //
+wuffs_base__i16__max(int16_t x, int16_t y) {
+  return x > y ? x : y;
+}
+
+static inline int32_t  //
+wuffs_base__i32__min(int32_t x, int32_t y) {
+  return x < y ? x : y;
+}
+
+static inline int32_t  //
+wuffs_base__i32__max(int32_t x, int32_t y) {
+  return x > y ? x : y;
+}
+
+static inline int64_t  //
+wuffs_base__i64__min(int64_t x, int64_t y) {
+  return x < y ? x : y;
+}
+
+static inline int64_t  //
+wuffs_base__i64__max(int64_t x, int64_t y) {
+  return x > y ? x : y;
+}
+
 static inline uint8_t  //
 wuffs_base__u8__min(uint8_t x, uint8_t y) {
   return x < y ? x : y;
diff --git a/internal/cgen/base/i64conv-submodule.c b/internal/cgen/base/i64conv-submodule.c
index 86335d2..6c43523 100644
--- a/internal/cgen/base/i64conv-submodule.c
+++ b/internal/cgen/base/i64conv-submodule.c
@@ -359,7 +359,7 @@
   if (neg) {
     ptr -= 1;
     ptr[0] = '-';
-  } else if (options & WUFFS_BASE__RENDER_NUMBER__LEADING_PLUS_SIGN) {
+  } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {
     ptr -= 1;
     ptr[0] = '+';
   }
@@ -368,7 +368,7 @@
   if (n > dst.len) {
     return 0;
   }
-  memcpy(dst.ptr + ((options & WUFFS_BASE__RENDER_NUMBER__ALIGN_RIGHT)
+  memcpy(dst.ptr + ((options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)
                         ? (dst.len - n)
                         : 0),
          ptr, n);
diff --git a/internal/cgen/base/strconv-public.h b/internal/cgen/base/strconv-public.h
index 4f80c2a..734d60c 100644
--- a/internal/cgen/base/strconv-public.h
+++ b/internal/cgen/base/strconv-public.h
@@ -16,20 +16,49 @@
 
 // ---------------- String Conversions
 
-// Options (bitwise or'ed together) for wuffs_base__render_number_etc
-// functions.
+// Options (bitwise or'ed together) for wuffs_base__render_number_xxx
+// functions. The XXX options apply to both integer and floating point. The FXX
+// options apply only to floating point.
 
-#define WUFFS_BASE__RENDER_NUMBER__DEFAULT_OPTIONS ((uint32_t)0x00000000)
+#define WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS ((uint32_t)0x00000000)
 
-// WUFFS_BASE__RENDER_NUMBER__ALIGN_RIGHT means to render to the right side
+// WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT means to render to the right side
 // (higher indexes) of the destination slice, leaving any untouched bytes on
 // the left side (lower indexes). The default is vice versa: rendering on the
 // left with slack on the right.
-#define WUFFS_BASE__RENDER_NUMBER__ALIGN_RIGHT ((uint32_t)0x00000001)
+#define WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT ((uint32_t)0x00000001)
 
-// WUFFS_BASE__RENDER_NUMBER__LEADING_PLUS_SIGN means to render the unnecessary
-// leading "+" for non-negative numbers: "+0" and "+123", not "0" and "123".
-#define WUFFS_BASE__RENDER_NUMBER__LEADING_PLUS_SIGN ((uint32_t)0x00000002)
+// WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN means to render the leading
+// "+" for non-negative numbers: "+0" and "+12.3" instead of "0" and "12.3".
+#define WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN ((uint32_t)0x00000002)
+
+// WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA means to render
+// one-and-a-half as "1,5" instead of "1.5".
+#define WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA \
+  ((uint32_t)0x00000100)
+
+// WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ETC means whether to never
+// (EXPONENT_ABSENT, equivalent to printf's "%f") or to always
+// (EXPONENT_PRESENT, equivalent to printf's "%e") render a floating point
+// number as "1.23e+05" instead of "123000".
+//
+// Having both bits set is the same has having neither bit set, where the
+// notation used depends on whether the exponent is sufficiently large: "0.5"
+// is preferred over "5e-01" but "5e-09" is preferred over "0.000000005".
+#define WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT ((uint32_t)0x00000200)
+#define WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT ((uint32_t)0x00000400)
+
+// WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION means to render the
+// smallest number of digits so that parsing the resultant string will recover
+// the same double-precision floating point number.
+//
+// For example, double-precision cannot distinguish between 0.3 and
+// 0.299999999999999988897769753748434595763683319091796875, so when this bit
+// is set, rendering the latter will produce "0.3" but rendering
+// 0.3000000000000000444089209850062616169452667236328125 will produce
+// "0.30000000000000004".
+#define WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION \
+  ((uint32_t)0x00000800)
 
 // ---------------- IEEE 754 Floating Point
 
@@ -148,6 +177,38 @@
 #define WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL 20
 #define WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL 21
 
+// wuffs_base__render_number_f64 writes the decimal encoding of x to dst and
+// returns the number of bytes written. If dst is shorter than the entire
+// encoding, it returns 0 (and no bytes are written).
+//
+// For those familiar with C's printf or Go's fmt.Printf functions:
+//  - "%e" means the WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT option.
+//  - "%f" means the WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT  option.
+//  - "%g" means neither or both bits are set.
+//
+// The precision argument controls the number of digits rendered, excluding the
+// exponent (the "e+05" in "1.23e+05"):
+//  - for "%e" and "%f" it is the number of digits after the decimal separator,
+//  - for "%g" it is the number of significant digits (and trailing zeroes are
+//    removed).
+//
+// A precision of 6 gives similar output to printf's defaults.
+//
+// A precision greater than 4095 is equivalent to 4095.
+//
+// The precision argument is ignored when the
+// WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION option is set. This is
+// similar to Go's strconv.FormatFloat with a negative (i.e. non-sensical)
+// precision, but there is no corresponding feature in C's printf.
+//
+// Extreme values of x will be rendered as "NaN", "Inf" (or "+Inf" if the
+// WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN option is set) or "-Inf".
+WUFFS_BASE__MAYBE_STATIC size_t  //
+wuffs_base__render_number_f64(wuffs_base__slice_u8 dst,
+                              double x,
+                              uint32_t precision,
+                              uint32_t options);
+
 // wuffs_base__render_number_i64 writes the decimal encoding of x to dst and
 // returns the number of bytes written. If dst is shorter than the entire
 // encoding, it returns 0 (and no bytes are written).
diff --git a/internal/cgen/data/data.go b/internal/cgen/data/data.go
index e39b9c6..ae40721 100644
--- a/internal/cgen/data/data.go
+++ b/internal/cgen/data/data.go
@@ -29,14 +29,15 @@
 	""
 
 const BaseF64ConvSubmoduleC = "" +
-	"// ---------------- IEEE 754 Floating Point\n\n#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE 1023\n#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION 500\n\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL is the largest N\n// such that ((10 << N) < (1 << 64)).\n#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL 60\n\n// wuffs_base__private_implementation__high_prec_dec (abbreviated as HPD) is a\n// fixed precision floating point decimal number, augmented with ±infinity\n// values, but it cannot represent NaN (Not a Number).\n//\n// \"High precision\" means that the mantissa holds 500 decimal digits. 500 is\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION.\n//\n// An HPD isn't for general purpose arithmetic, only for conversions to and\n// from IEEE 754 double-precision floating point, where the largest and\n// smallest positive, finite values are approximately 1.8e+308 and 4.9e-324.\n// HPD exponents above +1023 mean infinity, below -1023 mean zero. Th" +
-	"e ±1023\n// bounds are further away from zero than ±(324 + 500), where 500 and 1023 is\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION and\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.\n//\n// digits[.. num_digits] are the number's digits in big-endian order. The\n// uint8_t values are in the range [0 ..= 9], not ['0' ..= '9'], where e.g. '7'\n// is the ASCII value 0x37.\n//\n// decimal_point is the index (within digits) of the decimal point. It may be\n// negative or be larger than num_digits, in which case the explicit digits are\n// padded with implicit zeroes.\n//\n// For example, if num_digits is 3 and digits is \"\\x07\\x08\\x09\":\n//   - A decimal_point of -2 means \".00789\"\n//   - A decimal_point of -1 means \".0789\"\n//   - A decimal_point of +0 means \".789\"\n//   - A decimal_point of +1 means \"7.89\"\n//   - A decimal_point of +2 means \"78.9\"\n//   - A decimal_point of +3 means \"789.\"\n//   - A decimal_point of +4 means \"7890.\"\n//   - A decimal_point of +5 means \"78900.\"\n//\n// As above, a" +
-	" decimal_point higher than +1023 means that the overall value is\n// infinity, lower than -1023 means zero.\n//\n// negative is a sign bit. An HPD can distinguish positive and negative zero.\n//\n// truncated is whether there are more than\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION digits, and at\n// least one of those extra digits are non-zero. The existence of long-tail\n// digits can affect rounding.\n//\n// The \"all fields are zero\" value is valid, and represents the number +0.\ntypedef struct {\n  uint32_t num_digits;\n  int32_t decimal_point;\n  bool negative;\n  bool truncated;\n  uint8_t digits[WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION];\n} wuffs_base__private_implementation__high_prec_dec;\n\n// wuffs_base__private_implementation__high_prec_dec__trim trims trailing\n// zeroes from the h->digits[.. h->num_digits] slice. They have no benefit,\n// since we explicitly track h->decimal_point.\n//\n// Preconditions:\n//  - h is non-NULL.\nstatic inline void  //\nwuffs_base__private_implementation_" +
-	"_high_prec_dec__trim(\n    wuffs_base__private_implementation__high_prec_dec* h) {\n  while ((h->num_digits > 0) && (h->digits[h->num_digits - 1] == 0)) {\n    h->num_digits--;\n  }\n}\n\nstatic wuffs_base__status  //\nwuffs_base__private_implementation__high_prec_dec__parse(\n    wuffs_base__private_implementation__high_prec_dec* h,\n    wuffs_base__slice_u8 s) {\n  if (!h) {\n    return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n  }\n  h->num_digits = 0;\n  h->decimal_point = 0;\n  h->negative = false;\n  h->truncated = false;\n\n  uint8_t* p = s.ptr;\n  uint8_t* q = s.ptr + s.len;\n\n  for (; (p < q) && (*p == '_'); p++) {\n  }\n  if (p >= q) {\n    return wuffs_base__make_status(wuffs_base__error__bad_argument);\n  }\n\n  // Parse sign.\n  do {\n    if (*p == '+') {\n      p++;\n    } else if (*p == '-') {\n      h->negative = true;\n      p++;\n    } else {\n      break;\n    }\n    for (; (p < q) && (*p == '_'); p++) {\n    }\n  } while (0);\n\n  // Parse digits.\n  uint32_t nd = 0;\n  int32_t dp = 0;\n  bool saw_digits = false;\n  " +
-	"bool saw_non_zero_digits = false;\n  bool saw_dot = false;\n  for (; p < q; p++) {\n    if (*p == '_') {\n      // No-op.\n\n    } else if ((*p == '.') || (*p == ',')) {\n      // As per https://en.wikipedia.org/wiki/Decimal_separator, both '.' or\n      // ',' are commonly used. We just parse either, regardless of LOCALE.\n      if (saw_dot) {\n        return wuffs_base__make_status(wuffs_base__error__bad_argument);\n      }\n      saw_dot = true;\n      dp = (int32_t)nd;\n\n    } else if ('0' == *p) {\n      if (!saw_dot && !saw_non_zero_digits && saw_digits) {\n        // We don't allow unnecessary leading zeroes: \"000123\" or \"0644\".\n        return wuffs_base__make_status(wuffs_base__error__bad_argument);\n      }\n      saw_digits = true;\n      if (nd == 0) {\n        // Track leading zeroes implicitly.\n        dp--;\n      } else if (nd <\n                 WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n        h->digits[nd++] = 0;\n      } else {\n        // Long-tail zeroes are ignored.\n      }\n\n    } else if (('" +
-	"0' < *p) && (*p <= '9')) {\n      if (!saw_dot && !saw_non_zero_digits && saw_digits) {\n        // We don't allow unnecessary leading zeroes: \"000123\" or \"0644\".\n        return wuffs_base__make_status(wuffs_base__error__bad_argument);\n      }\n      saw_digits = true;\n      saw_non_zero_digits = true;\n      if (nd < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n        h->digits[nd++] = (uint8_t)(*p - '0');\n      } else {\n        // Long-tail non-zeroes set the truncated bit.\n        h->truncated = true;\n      }\n\n    } else {\n      break;\n    }\n  }\n\n  if (!saw_digits) {\n    return wuffs_base__make_status(wuffs_base__error__bad_argument);\n  }\n  if (!saw_dot) {\n    dp = (int32_t)nd;\n  }\n\n  // Parse exponent.\n  if ((p < q) && ((*p == 'E') || (*p == 'e'))) {\n    p++;\n    for (; (p < q) && (*p == '_'); p++) {\n    }\n    if (p >= q) {\n      return wuffs_base__make_status(wuffs_base__error__bad_argument);\n    }\n\n    int32_t exp_sign = +1;\n    if (*p == '+') {\n      p++;\n    } else if (*p == '-') {\n      " +
-	"exp_sign = -1;\n      p++;\n    }\n\n    int32_t exp = 0;\n    const int32_t exp_large =\n        WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE +\n        WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION;\n    bool saw_exp_digits = false;\n    for (; p < q; p++) {\n      if (*p == '_') {\n        // No-op.\n      } else if (('0' <= *p) && (*p <= '9')) {\n        saw_exp_digits = true;\n        if (exp < exp_large) {\n          exp = (10 * exp) + ((int32_t)(*p - '0'));\n        }\n      } else {\n        break;\n      }\n    }\n    if (!saw_exp_digits) {\n      return wuffs_base__make_status(wuffs_base__error__bad_argument);\n    }\n    dp += exp_sign * exp;\n  }\n\n  // Finish.\n  if (p != q) {\n    return wuffs_base__make_status(wuffs_base__error__bad_argument);\n  }\n  h->num_digits = nd;\n  if (nd == 0) {\n    h->decimal_point = 0;\n  } else if (dp <\n             -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n    h->decimal_point =\n        -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__" +
-	"RANGE - 1;\n  } else if (dp >\n             +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n    h->decimal_point =\n        +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE + 1;\n  } else {\n    h->decimal_point = dp;\n  }\n  wuffs_base__private_implementation__high_prec_dec__trim(h);\n  return wuffs_base__make_status(NULL);\n}\n\n" +
+	"// ---------------- IEEE 754 Floating Point\n\n#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE 2047\n#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION 800\n\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL is the largest N\n// such that ((10 << N) < (1 << 64)).\n#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL 60\n\n// wuffs_base__private_implementation__high_prec_dec (abbreviated as HPD) is a\n// fixed precision floating point decimal number, augmented with ±infinity\n// values, but it cannot represent NaN (Not a Number).\n//\n// \"High precision\" means that the mantissa holds 800 decimal digits. 800 is\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION.\n//\n// An HPD isn't for general purpose arithmetic, only for conversions to and\n// from IEEE 754 double-precision floating point, where the largest and\n// smallest positive, finite values are approximately 1.8e+308 and 4.9e-324.\n// HPD exponents above +2047 mean infinity, below -2047 mean zero. Th" +
+	"e ±2047\n// bounds are further away from zero than ±(324 + 800), where 800 and 2047 is\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION and\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.\n//\n// digits[.. num_digits] are the number's digits in big-endian order. The\n// uint8_t values are in the range [0 ..= 9], not ['0' ..= '9'], where e.g. '7'\n// is the ASCII value 0x37.\n//\n// decimal_point is the index (within digits) of the decimal point. It may be\n// negative or be larger than num_digits, in which case the explicit digits are\n// padded with implicit zeroes.\n//\n// For example, if num_digits is 3 and digits is \"\\x07\\x08\\x09\":\n//   - A decimal_point of -2 means \".00789\"\n//   - A decimal_point of -1 means \".0789\"\n//   - A decimal_point of +0 means \".789\"\n//   - A decimal_point of +1 means \"7.89\"\n//   - A decimal_point of +2 means \"78.9\"\n//   - A decimal_point of +3 means \"789.\"\n//   - A decimal_point of +4 means \"7890.\"\n//   - A decimal_point of +5 means \"78900.\"\n//\n// As above, a" +
+	" decimal_point higher than +2047 means that the overall value is\n// infinity, lower than -2047 means zero.\n//\n// negative is a sign bit. An HPD can distinguish positive and negative zero.\n//\n// truncated is whether there are more than\n// WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION digits, and at\n// least one of those extra digits are non-zero. The existence of long-tail\n// digits can affect rounding.\n//\n// The \"all fields are zero\" value is valid, and represents the number +0.\ntypedef struct {\n  uint32_t num_digits;\n  int32_t decimal_point;\n  bool negative;\n  bool truncated;\n  uint8_t digits[WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION];\n} wuffs_base__private_implementation__high_prec_dec;\n\n// wuffs_base__private_implementation__high_prec_dec__trim trims trailing\n// zeroes from the h->digits[.. h->num_digits] slice. They have no benefit,\n// since we explicitly track h->decimal_point.\n//\n// Preconditions:\n//  - h is non-NULL.\nstatic inline void  //\nwuffs_base__private_implementation_" +
+	"_high_prec_dec__trim(\n    wuffs_base__private_implementation__high_prec_dec* h) {\n  while ((h->num_digits > 0) && (h->digits[h->num_digits - 1] == 0)) {\n    h->num_digits--;\n  }\n}\n\n// wuffs_base__private_implementation__high_prec_dec__assign sets h to\n// represent the number x.\n//\n// Preconditions:\n//  - h is non-NULL.\nstatic void  //\nwuffs_base__private_implementation__high_prec_dec__assign(\n    wuffs_base__private_implementation__high_prec_dec* h,\n    uint64_t x,\n    bool negative) {\n  uint32_t n = 0;\n\n  // Set h->digits.\n  if (x > 0) {\n    // Calculate the digits, working right-to-left. After we determine n (how\n    // many digits there are), copy from buf to h->digits.\n    //\n    // UINT64_MAX, 18446744073709551615, is 20 digits long. It can be faster to\n    // copy a constant number of bytes than a variable number (20 instead of\n    // n). Make buf large enough (and start writing to it from the middle) so\n    // that can we always copy 20 bytes: the slice buf[(20-n) .. (40-n)].\n    uint8_t buf[40] = {0};" +
+	"\n    uint8_t* ptr = &buf[20];\n    do {\n      uint64_t remaining = x / 10;\n      x -= remaining * 10;\n      ptr--;\n      *ptr = (uint8_t)x;\n      n++;\n      x = remaining;\n    } while (x > 0);\n    memcpy(h->digits, ptr, 20);\n  }\n\n  // Set h's other fields.\n  h->num_digits = n;\n  h->decimal_point = (int32_t)n;\n  h->negative = negative;\n  h->truncated = false;\n  wuffs_base__private_implementation__high_prec_dec__trim(h);\n}\n\nstatic wuffs_base__status  //\nwuffs_base__private_implementation__high_prec_dec__parse(\n    wuffs_base__private_implementation__high_prec_dec* h,\n    wuffs_base__slice_u8 s) {\n  if (!h) {\n    return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n  }\n  h->num_digits = 0;\n  h->decimal_point = 0;\n  h->negative = false;\n  h->truncated = false;\n\n  uint8_t* p = s.ptr;\n  uint8_t* q = s.ptr + s.len;\n\n  for (; (p < q) && (*p == '_'); p++) {\n  }\n  if (p >= q) {\n    return wuffs_base__make_status(wuffs_base__error__bad_argument);\n  }\n\n  // Parse sign.\n  do {\n    if (*p == '+') {\n      p++;\n  " +
+	"  } else if (*p == '-') {\n      h->negative = true;\n      p++;\n    } else {\n      break;\n    }\n    for (; (p < q) && (*p == '_'); p++) {\n    }\n  } while (0);\n\n  // Parse digits.\n  uint32_t nd = 0;\n  int32_t dp = 0;\n  bool saw_digits = false;\n  bool saw_non_zero_digits = false;\n  bool saw_dot = false;\n  for (; p < q; p++) {\n    if (*p == '_') {\n      // No-op.\n\n    } else if ((*p == '.') || (*p == ',')) {\n      // As per https://en.wikipedia.org/wiki/Decimal_separator, both '.' or\n      // ',' are commonly used. We just parse either, regardless of LOCALE.\n      if (saw_dot) {\n        return wuffs_base__make_status(wuffs_base__error__bad_argument);\n      }\n      saw_dot = true;\n      dp = (int32_t)nd;\n\n    } else if ('0' == *p) {\n      if (!saw_dot && !saw_non_zero_digits && saw_digits) {\n        // We don't allow unnecessary leading zeroes: \"000123\" or \"0644\".\n        return wuffs_base__make_status(wuffs_base__error__bad_argument);\n      }\n      saw_digits = true;\n      if (nd == 0) {\n        // Track leading " +
+	"zeroes implicitly.\n        dp--;\n      } else if (nd <\n                 WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n        h->digits[nd++] = 0;\n      } else {\n        // Long-tail zeroes are ignored.\n      }\n\n    } else if (('0' < *p) && (*p <= '9')) {\n      if (!saw_dot && !saw_non_zero_digits && saw_digits) {\n        // We don't allow unnecessary leading zeroes: \"000123\" or \"0644\".\n        return wuffs_base__make_status(wuffs_base__error__bad_argument);\n      }\n      saw_digits = true;\n      saw_non_zero_digits = true;\n      if (nd < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n        h->digits[nd++] = (uint8_t)(*p - '0');\n      } else {\n        // Long-tail non-zeroes set the truncated bit.\n        h->truncated = true;\n      }\n\n    } else {\n      break;\n    }\n  }\n\n  if (!saw_digits) {\n    return wuffs_base__make_status(wuffs_base__error__bad_argument);\n  }\n  if (!saw_dot) {\n    dp = (int32_t)nd;\n  }\n\n  // Parse exponent.\n  if ((p < q) && ((*p == 'E') || (*p == 'e'))) {\n  " +
+	"  p++;\n    for (; (p < q) && (*p == '_'); p++) {\n    }\n    if (p >= q) {\n      return wuffs_base__make_status(wuffs_base__error__bad_argument);\n    }\n\n    int32_t exp_sign = +1;\n    if (*p == '+') {\n      p++;\n    } else if (*p == '-') {\n      exp_sign = -1;\n      p++;\n    }\n\n    int32_t exp = 0;\n    const int32_t exp_large =\n        WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE +\n        WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION;\n    bool saw_exp_digits = false;\n    for (; p < q; p++) {\n      if (*p == '_') {\n        // No-op.\n      } else if (('0' <= *p) && (*p <= '9')) {\n        saw_exp_digits = true;\n        if (exp < exp_large) {\n          exp = (10 * exp) + ((int32_t)(*p - '0'));\n        }\n      } else {\n        break;\n      }\n    }\n    if (!saw_exp_digits) {\n      return wuffs_base__make_status(wuffs_base__error__bad_argument);\n    }\n    dp += exp_sign * exp;\n  }\n\n  // Finish.\n  if (p != q) {\n    return wuffs_base__make_status(wuffs_base__error__bad_argument);\n  }\n  h->n" +
+	"um_digits = nd;\n  if (nd == 0) {\n    h->decimal_point = 0;\n  } else if (dp <\n             -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n    h->decimal_point =\n        -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE - 1;\n  } else if (dp >\n             +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n    h->decimal_point =\n        +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE + 1;\n  } else {\n    h->decimal_point = dp;\n  }\n  wuffs_base__private_implementation__high_prec_dec__trim(h);\n  return wuffs_base__make_status(NULL);\n}\n\n" +
 	"" +
 	"// --------\n\n// The etc__hpd_left_shift and etc__powers_of_5 tables were printed by\n// script/print-hpd-left-shift.go. That script has an optional -comments flag,\n// whose output is not copied here, which prints further detail.\n//\n// These tables are used in\n// wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits.\n\n// wuffs_base__private_implementation__hpd_left_shift[i] encodes the number of\n// new digits created after multiplying a positive integer by (1 << i): the\n// additional length in the decimal representation. For example, shifting \"234\"\n// by 3 (equivalent to multiplying by 8) will produce \"1872\". Going from a\n// 3-length string to a 4-length string means that 1 new digit was added (and\n// existing digits may have changed).\n//\n// Shifting by i can add either N or N-1 new digits, depending on whether the\n// original positive integer compares >= or < to the i'th power of 5 (as 10\n// equals 2 * 5). Comparison is lexicographic, not numerical.\n//\n// For example, shifting by 4 (i.e. mul" +
 	"tiplying by 16) can add 1 or 2 new\n// digits, depending on a lexicographic comparison to (5 ** 4), i.e. \"625\":\n//  - (\"1\"      << 4) is \"16\",       which adds 1 new digit.\n//  - (\"5678\"   << 4) is \"90848\",    which adds 1 new digit.\n//  - (\"624\"    << 4) is \"9984\",     which adds 1 new digit.\n//  - (\"62498\"  << 4) is \"999968\",   which adds 1 new digit.\n//  - (\"625\"    << 4) is \"10000\",    which adds 2 new digits.\n//  - (\"625001\" << 4) is \"10000016\", which adds 2 new digits.\n//  - (\"7008\"   << 4) is \"112128\",   which adds 2 new digits.\n//  - (\"99\"     << 4) is \"1584\",     which adds 2 new digits.\n//\n// Thus, when i is 4, N is 2 and (5 ** i) is \"625\". This etc__hpd_left_shift\n// array encodes this as:\n//  - etc__hpd_left_shift[4] is 0x1006 = (2 << 11) | 0x0006.\n//  - etc__hpd_left_shift[5] is 0x1009 = (? << 11) | 0x0009.\n// where the ? isn't relevant for i == 4.\n//\n// The high 5 bits of etc__hpd_left_shift[i] is N, the higher of the two\n// possible number of new digits. The low 11 bits are an offset into the\n//" +
@@ -50,10 +51,21 @@
 	"" +
 	"// --------\n\n// wuffs_base__private_implementation__high_prec_dec__rounded_integer returns\n// the integral (non-fractional) part of h, provided that it is 18 or fewer\n// decimal digits. For 19 or more digits, it returns UINT64_MAX. Note that:\n//   - (1 << 53) is    9007199254740992, which has 16 decimal digits.\n//   - (1 << 56) is   72057594037927936, which has 17 decimal digits.\n//   - (1 << 59) is  576460752303423488, which has 18 decimal digits.\n//   - (1 << 63) is 9223372036854775808, which has 19 decimal digits.\n// and that IEEE 754 double precision has 52 mantissa bits.\n//\n// That integral part is rounded-to-even: rounding 7.5 or 8.5 both give 8.\n//\n// h's negative bit is ignored: rounding -8.6 returns 9.\n//\n// See below for preconditions.\nstatic uint64_t  //\nwuffs_base__private_implementation__high_prec_dec__rounded_integer(\n    wuffs_base__private_implementation__high_prec_dec* h) {\n  if ((h->num_digits == 0) || (h->decimal_point < 0)) {\n    return 0;\n  } else if (h->decimal_point > 18) {\n    return U" +
 	"INT64_MAX;\n  }\n\n  uint32_t dp = (uint32_t)(h->decimal_point);\n  uint64_t n = 0;\n  uint32_t i = 0;\n  for (; i < dp; i++) {\n    n = (10 * n) + ((i < h->num_digits) ? h->digits[i] : 0);\n  }\n\n  bool round_up = false;\n  if (dp < h->num_digits) {\n    round_up = h->digits[dp] >= 5;\n    if ((h->digits[dp] == 5) && (dp + 1 == h->num_digits)) {\n      // We are exactly halfway. If we're truncated, round up, otherwise round\n      // to even.\n      round_up = h->truncated ||  //\n                 ((dp > 0) && (1 & h->digits[dp - 1]));\n    }\n  }\n  if (round_up) {\n    n++;\n  }\n\n  return n;\n}\n\n// wuffs_base__private_implementation__high_prec_dec__small_xshift shifts h's\n// number (where 'x' is 'l' or 'r' for left or right) by a small shift value.\n//\n// Preconditions:\n//  - h is non-NULL.\n//  - h->decimal_point is \"not extreme\".\n//  - shift is non-zero.\n//  - shift is \"a small shift\".\n//\n// \"Not extreme\" means within\n// ±WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.\n//\n// \"A small shift\" means not more than\n/" +
-	"/ WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL.\n//\n// wuffs_base__private_implementation__high_prec_dec__rounded_integer and\n// wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits\n// have the same preconditions.\n\nstatic void  //\nwuffs_base__private_implementation__high_prec_dec__small_lshift(\n    wuffs_base__private_implementation__high_prec_dec* h,\n    uint32_t shift) {\n  if (h->num_digits == 0) {\n    return;\n  }\n  uint32_t num_new_digits =\n      wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits(\n          h, shift);\n  uint32_t rx = h->num_digits - 1;                   // Read  index.\n  uint32_t wx = h->num_digits - 1 + num_new_digits;  // Write index.\n  uint64_t n = 0;\n\n  // Repeat: pick up a digit, put down a digit, right to left.\n  while (((int32_t)rx) >= 0) {\n    n += ((uint64_t)(h->digits[rx])) << shift;\n    uint64_t quo = n / 10;\n    uint64_t rem = n - (10 * quo);\n    if (wx < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n      h->d" +
-	"igits[wx] = (uint8_t)rem;\n    } else if (rem > 0) {\n      h->truncated = true;\n    }\n    n = quo;\n    wx--;\n    rx--;\n  }\n\n  // Put down leading digits, right to left.\n  while (n > 0) {\n    uint64_t quo = n / 10;\n    uint64_t rem = n - (10 * quo);\n    if (wx < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n      h->digits[wx] = (uint8_t)rem;\n    } else if (rem > 0) {\n      h->truncated = true;\n    }\n    n = quo;\n    wx--;\n  }\n\n  // Finish.\n  h->num_digits += num_new_digits;\n  if (h->num_digits >\n      WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n    h->num_digits = WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION;\n  }\n  h->decimal_point += (int32_t)num_new_digits;\n  wuffs_base__private_implementation__high_prec_dec__trim(h);\n}\n\nstatic void  //\nwuffs_base__private_implementation__high_prec_dec__small_rshift(\n    wuffs_base__private_implementation__high_prec_dec* h,\n    uint32_t shift) {\n  uint32_t rx = 0;  // Read  index.\n  uint32_t wx = 0;  // Write index.\n  uint64_t n =" +
-	" 0;\n\n  // Pick up enough leading digits to cover the first shift.\n  while ((n >> shift) == 0) {\n    if (rx < h->num_digits) {\n      // Read a digit.\n      n = (10 * n) + h->digits[rx++];\n    } else if (n == 0) {\n      // h's number used to be zero and remains zero.\n      return;\n    } else {\n      // Read sufficient implicit trailing zeroes.\n      while ((n >> shift) == 0) {\n        n = 10 * n;\n        rx++;\n      }\n      break;\n    }\n  }\n  h->decimal_point -= ((int32_t)(rx - 1));\n  if (h->decimal_point <\n      -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n    // After the shift, h's number is effectively zero.\n    h->num_digits = 0;\n    h->decimal_point = 0;\n    h->negative = false;\n    h->truncated = false;\n    return;\n  }\n\n  // Repeat: pick up a digit, put down a digit, left to right.\n  uint64_t mask = (((uint64_t)(1)) << shift) - 1;\n  while (rx < h->num_digits) {\n    uint8_t new_digit = ((uint8_t)(n >> shift));\n    n = (10 * (n & mask)) + h->digits[rx++];\n    h->digits[wx++] = new_digi" +
-	"t;\n  }\n\n  // Put down trailing digits, left to right.\n  while (n > 0) {\n    uint8_t new_digit = ((uint8_t)(n >> shift));\n    n = 10 * (n & mask);\n    if (wx < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n      h->digits[wx++] = new_digit;\n    } else if (new_digit > 0) {\n      h->truncated = true;\n    }\n  }\n\n  // Finish.\n  h->num_digits = wx;\n  wuffs_base__private_implementation__high_prec_dec__trim(h);\n}\n\n" +
+	"/ WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL.\n//\n// wuffs_base__private_implementation__high_prec_dec__rounded_integer and\n// wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits\n// have the same preconditions.\n//\n// wuffs_base__private_implementation__high_prec_dec__lshift keeps the first\n// two preconditions but not the last two. Its shift argument is signed and\n// does not need to be \"small\": zero is a no-op, positive means left shift and\n// negative means right shift.\n\nstatic void  //\nwuffs_base__private_implementation__high_prec_dec__small_lshift(\n    wuffs_base__private_implementation__high_prec_dec* h,\n    uint32_t shift) {\n  if (h->num_digits == 0) {\n    return;\n  }\n  uint32_t num_new_digits =\n      wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits(\n          h, shift);\n  uint32_t rx = h->num_digits - 1;                   // Read  index.\n  uint32_t wx = h->num_digits - 1 + num_new_digits;  // Write index.\n  uint64_t n = 0;\n\n  // Repeat: pick up " +
+	"a digit, put down a digit, right to left.\n  while (((int32_t)rx) >= 0) {\n    n += ((uint64_t)(h->digits[rx])) << shift;\n    uint64_t quo = n / 10;\n    uint64_t rem = n - (10 * quo);\n    if (wx < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n      h->digits[wx] = (uint8_t)rem;\n    } else if (rem > 0) {\n      h->truncated = true;\n    }\n    n = quo;\n    wx--;\n    rx--;\n  }\n\n  // Put down leading digits, right to left.\n  while (n > 0) {\n    uint64_t quo = n / 10;\n    uint64_t rem = n - (10 * quo);\n    if (wx < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n      h->digits[wx] = (uint8_t)rem;\n    } else if (rem > 0) {\n      h->truncated = true;\n    }\n    n = quo;\n    wx--;\n  }\n\n  // Finish.\n  h->num_digits += num_new_digits;\n  if (h->num_digits >\n      WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n    h->num_digits = WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION;\n  }\n  h->decimal_point += (int32_t)num_new_digits;\n  wuffs_base__private_implementation__high_pre" +
+	"c_dec__trim(h);\n}\n\nstatic void  //\nwuffs_base__private_implementation__high_prec_dec__small_rshift(\n    wuffs_base__private_implementation__high_prec_dec* h,\n    uint32_t shift) {\n  uint32_t rx = 0;  // Read  index.\n  uint32_t wx = 0;  // Write index.\n  uint64_t n = 0;\n\n  // Pick up enough leading digits to cover the first shift.\n  while ((n >> shift) == 0) {\n    if (rx < h->num_digits) {\n      // Read a digit.\n      n = (10 * n) + h->digits[rx++];\n    } else if (n == 0) {\n      // h's number used to be zero and remains zero.\n      return;\n    } else {\n      // Read sufficient implicit trailing zeroes.\n      while ((n >> shift) == 0) {\n        n = 10 * n;\n        rx++;\n      }\n      break;\n    }\n  }\n  h->decimal_point -= ((int32_t)(rx - 1));\n  if (h->decimal_point <\n      -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n    // After the shift, h's number is effectively zero.\n    h->num_digits = 0;\n    h->decimal_point = 0;\n    h->negative = false;\n    h->truncated = false;\n    return;\n  }\n\n  " +
+	"// Repeat: pick up a digit, put down a digit, left to right.\n  uint64_t mask = (((uint64_t)(1)) << shift) - 1;\n  while (rx < h->num_digits) {\n    uint8_t new_digit = ((uint8_t)(n >> shift));\n    n = (10 * (n & mask)) + h->digits[rx++];\n    h->digits[wx++] = new_digit;\n  }\n\n  // Put down trailing digits, left to right.\n  while (n > 0) {\n    uint8_t new_digit = ((uint8_t)(n >> shift));\n    n = 10 * (n & mask);\n    if (wx < WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION) {\n      h->digits[wx++] = new_digit;\n    } else if (new_digit > 0) {\n      h->truncated = true;\n    }\n  }\n\n  // Finish.\n  h->num_digits = wx;\n  wuffs_base__private_implementation__high_prec_dec__trim(h);\n}\n\nstatic void  //\nwuffs_base__private_implementation__high_prec_dec__lshift(\n    wuffs_base__private_implementation__high_prec_dec* h,\n    int32_t shift) {\n  if (shift > 0) {\n    while (shift > +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {\n      wuffs_base__private_implementation__high_prec_dec__small_lshift(\n         " +
+	" h, WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL);\n      shift -= WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;\n    }\n    wuffs_base__private_implementation__high_prec_dec__small_lshift(\n        h, ((uint32_t)(+shift)));\n  } else if (shift < 0) {\n    while (shift < -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {\n      wuffs_base__private_implementation__high_prec_dec__small_rshift(\n          h, WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL);\n      shift += WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;\n    }\n    wuffs_base__private_implementation__high_prec_dec__small_rshift(\n        h, ((uint32_t)(-shift)));\n  }\n}\n\n" +
+	"" +
+	"// --------\n\n// wuffs_base__private_implementation__high_prec_dec__round_etc rounds h's\n// number. For those functions that take an n argument, rounding produces at\n// most n digits (which is not necessarily at most n decimal places). Negative\n// n values are ignored, as well as any n greater than or equal to h's number\n// of digits. The etc__round_just_enough function implicitly chooses an n to\n// implement WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION.\n//\n// Preconditions:\n//  - h is non-NULL.\n//  - h->decimal_point is \"not extreme\".\n//\n// \"Not extreme\" means within\n// ±WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.\n\nstatic void  //\nwuffs_base__private_implementation__high_prec_dec__round_down(\n    wuffs_base__private_implementation__high_prec_dec* h,\n    int32_t n) {\n  if ((n < 0) || (h->num_digits <= (uint32_t)n)) {\n    return;\n  }\n  h->num_digits = (uint32_t)(n);\n  wuffs_base__private_implementation__high_prec_dec__trim(h);\n}\n\nstatic void  //\nwuffs_base__private_implementation__hi" +
+	"gh_prec_dec__round_up(\n    wuffs_base__private_implementation__high_prec_dec* h,\n    int32_t n) {\n  if ((n < 0) || (h->num_digits <= (uint32_t)n)) {\n    return;\n  }\n\n  for (n--; n >= 0; n--) {\n    if (h->digits[n] < 9) {\n      h->digits[n]++;\n      h->num_digits = (uint32_t)(n + 1);\n      return;\n    }\n  }\n\n  // The number is all 9s. Change to a single 1 and adjust the decimal point.\n  h->digits[0] = 1;\n  h->num_digits = 1;\n  h->decimal_point++;\n}\n\nstatic void  //\nwuffs_base__private_implementation__high_prec_dec__round_nearest(\n    wuffs_base__private_implementation__high_prec_dec* h,\n    int32_t n) {\n  if ((n < 0) || (h->num_digits <= (uint32_t)n)) {\n    return;\n  }\n  bool up = h->digits[n] >= 5;\n  if ((h->digits[n] == 5) && ((n + 1) == ((int32_t)(h->num_digits)))) {\n    up = h->truncated ||  //\n         ((n > 0) && ((h->digits[n - 1] & 1) != 0));\n  }\n\n  if (up) {\n    wuffs_base__private_implementation__high_prec_dec__round_up(h, n);\n  } else {\n    wuffs_base__private_implementation__high_prec_dec__round_do" +
+	"wn(h, n);\n  }\n}\n\nstatic void  //\nwuffs_base__private_implementation__high_prec_dec__round_just_enough(\n    wuffs_base__private_implementation__high_prec_dec* h,\n    int32_t exp2,\n    uint64_t mantissa) {\n  // The magic numbers 52 and 53 in this function are because IEEE 754 double\n  // precision has 52 mantissa bits.\n  //\n  // Let f be the floating point number represented by exp2 and mantissa (and\n  // also the number in h): the number (mantissa * (2 ** (exp2 - 52))).\n  //\n  // If f is zero, we can return early.\n  if (mantissa == 0) {\n    return;\n  }\n\n  // The smallest normal f has an exp2 of -1022 and a mantissa of (1 << 52).\n  // Subnormal numbers have the same exp2 but a smaller mantissa.\n  static const int32_t min_incl_normal_exp2 = -1022;\n  static const uint64_t min_incl_normal_mantissa = 0x0010000000000000ul;\n\n  // Compute lower and upper bounds such that any number between them (possibly\n  // inclusive) will round to f. First, the lower bound. Our number f is:\n  //   ((mantissa + 0)         * (2 ** ( " +
+	" exp2 - 52)))\n  //\n  // The next lowest floating point number is:\n  //   ((mantissa - 1)         * (2 ** (  exp2 - 52)))\n  // unless (mantissa - 1) drops the (1 << 52) bit and exp2 is not the\n  // min_incl_normal_exp2. Either way, call it:\n  //   ((l_mantissa)           * (2 ** (l_exp2 - 52)))\n  //\n  // The lower bound is halfway between them (noting that 52 became 53):\n  //   (((2 * l_mantissa) + 1) * (2 ** (l_exp2 - 53)))\n  int32_t l_exp2 = exp2;\n  uint64_t l_mantissa = mantissa - 1;\n  if ((exp2 > min_incl_normal_exp2) && (mantissa <= min_incl_normal_mantissa)) {\n    l_exp2 = exp2 - 1;\n    l_mantissa = (2 * mantissa) - 1;\n  }\n  wuffs_base__private_implementation__high_prec_dec lower;\n  wuffs_base__private_implementation__high_prec_dec__assign(\n      &lower, (2 * l_mantissa) + 1, false);\n  wuffs_base__private_implementation__high_prec_dec__lshift(&lower,\n                                                            l_exp2 - 53);\n\n  // Next, the upper bound. Our number f is:\n  //   ((mantissa + 0)       * (2 **" +
+	" (exp2 - 52)))\n  //\n  // The next highest floating point number is:\n  //   ((mantissa + 1)       * (2 ** (exp2 - 52)))\n  //\n  // The upper bound is halfway between them (noting that 52 became 53):\n  //   (((2 * mantissa) + 1) * (2 ** (exp2 - 53)))\n  wuffs_base__private_implementation__high_prec_dec upper;\n  wuffs_base__private_implementation__high_prec_dec__assign(\n      &upper, (2 * mantissa) + 1, false);\n  wuffs_base__private_implementation__high_prec_dec__lshift(&upper, exp2 - 53);\n\n  // The lower and upper bounds are possible outputs only if the original\n  // mantissa is even, so that IEEE round-to-even would round to the original\n  // mantissa and not its neighbors.\n  bool inclusive = (mantissa & 1) == 0;\n\n  // As we walk the digits, we want to know whether rounding up would fall\n  // within the upper bound. This is tracked by upper_delta:\n  //  - When -1, the digits of h and upper are the same so far.\n  //  - When +0, we saw a difference of 1 between h and upper on a previous\n  //    digit and subsequen" +
+	"tly only 9s for h and 0s for upper. Thus, rounding\n  //    up may fall outside of the bound if !inclusive.\n  //  - When +1, the difference is greater than 1 and we know that rounding up\n  //    falls within the bound.\n  //\n  // This is a state machine with three states. The numerical value for each\n  // state (-1, +0 or +1) isn't important, other than their order.\n  int upper_delta = -1;\n\n  // We can now figure out the shortest number of digits required. Walk the\n  // digits until h has distinguished itself from lower or upper.\n  //\n  // The zi and zd variables are indexes and digits, for z in l (lower), h (the\n  // number) and u (upper).\n  //\n  // The lower, h and upper numbers may have their decimal points at different\n  // places. In this case, upper is the longest, so we iterate ui starting from\n  // 0 and iterate li and hi starting from either 0 or -1.\n  int32_t ui = 0;\n  for (;; ui++) {\n    // Calculate hd, the middle number's digit.\n    int32_t hi = ui - upper.decimal_point + h->decimal_point;\n    if (" +
+	"hi >= ((int32_t)(h->num_digits))) {\n      break;\n    }\n    uint8_t hd = (((uint32_t)hi) < h->num_digits) ? h->digits[hi] : 0;\n\n    // Calculate ld, the lower bound's digit.\n    int32_t li = ui - upper.decimal_point + lower.decimal_point;\n    uint8_t ld = (((uint32_t)li) < lower.num_digits) ? lower.digits[li] : 0;\n\n    // We can round down (truncate) if lower has a different digit than h or if\n    // lower is inclusive and is exactly the result of rounding down (i.e. we\n    // have reached the final digit of lower).\n    bool can_round_down =\n        (ld != hd) ||  //\n        (inclusive && ((li + 1) == ((int32_t)(lower.num_digits))));\n\n    // Calculate ud, the upper bound's digit, and update upper_delta.\n    uint8_t ud = (((uint32_t)ui) < upper.num_digits) ? upper.digits[ui] : 0;\n    if (upper_delta < 0) {\n      if ((hd + 1) < ud) {\n        // For example:\n        // h     = 12345???\n        // upper = 12347???\n        upper_delta = +1;\n      } else if (hd != ud) {\n        // For example:\n        // h     = 123" +
+	"45???\n        // upper = 12346???\n        upper_delta = +0;\n      }\n    } else if (upper_delta == 0) {\n      if ((hd != 9) || (ud != 0)) {\n        // For example:\n        // h     = 1234598?\n        // upper = 1234600?\n        upper_delta = +1;\n      }\n    }\n\n    // We can round up if upper has a different digit than h and either upper\n    // is inclusive or upper is bigger than the result of rounding up.\n    bool can_round_up =\n        (upper_delta > 0) ||    //\n        ((upper_delta == 0) &&  //\n         (inclusive || ((ui + 1) < ((int32_t)(upper.num_digits)))));\n\n    // If we can round either way, round to nearest. If we can round only one\n    // way, do it. If we can't round, continue the loop.\n    if (can_round_down) {\n      if (can_round_up) {\n        wuffs_base__private_implementation__high_prec_dec__round_nearest(\n            h, hi + 1);\n        return;\n      } else {\n        wuffs_base__private_implementation__high_prec_dec__round_down(h,\n                                                              " +
+	"        hi + 1);\n        return;\n      }\n    } else {\n      if (can_round_up) {\n        wuffs_base__private_implementation__high_prec_dec__round_up(h, hi + 1);\n        return;\n      }\n    }\n  }\n}\n\n" +
 	"" +
 	"// --------\n\n// The wuffs_base__private_implementation__etc_powers_of_10 tables were printed\n// by script/print-mpb-powers-of-10.go. That script has an optional -comments\n// flag, whose output is not copied here, which prints further detail.\n//\n// These tables are used in\n// wuffs_base__private_implementation__medium_prec_bin__assign_from_hpd.\n\n// wuffs_base__private_implementation__big_powers_of_10 contains approximations\n// to the powers of 10, ranging from 1e-348 to 1e+340, with the exponent\n// stepping by 8: -348, -340, -332, ..., -12, -4, +4, +12, ..., +340. Each step\n// consists of three uint32_t elements. There are 87 triples, 87 * 3 = 261.\n//\n// For example, the third approximation, for 1e-332, consists of the uint32_t\n// triple (0x3055AC76, 0x8B16FB20, 0xFFFFFB72). The first two of that triple\n// are a little-endian uint64_t value: 0x8B16FB203055AC76. The last one is an\n// int32_t value: -1166. Together, they represent the approximation:\n//   1e-332 ≈ 0x8B16FB203055AC76 * (2 ** -1166)\n// Similarly," +
 	" the (0x00000000, 0x9C400000, 0xFFFFFFCE) uint32_t triple means:\n//   1e+4   ≈ 0x9C40000000000000 * (2 **   -50)  // This approx'n is exact.\n// Similarly, the (0xD4C4FB27, 0xED63A231, 0x000000A2) uint32_t triple means:\n//   1e+68  ≈ 0xED63A231D4C4FB27 * (2 **   162)\nstatic const uint32_t\n    wuffs_base__private_implementation__big_powers_of_10[261] = {\n        0x081C0288, 0xFA8FD5A0, 0xFFFFFB3C, 0xA23EBF76, 0xBAAEE17F, 0xFFFFFB57,\n        0x3055AC76, 0x8B16FB20, 0xFFFFFB72, 0x5DCE35EA, 0xCF42894A, 0xFFFFFB8C,\n        0x55653B2D, 0x9A6BB0AA, 0xFFFFFBA7, 0x3D1A45DF, 0xE61ACF03, 0xFFFFFBC1,\n        0xC79AC6CA, 0xAB70FE17, 0xFFFFFBDC, 0xBEBCDC4F, 0xFF77B1FC, 0xFFFFFBF6,\n        0x416BD60C, 0xBE5691EF, 0xFFFFFC11, 0x907FFC3C, 0x8DD01FAD, 0xFFFFFC2C,\n        0x31559A83, 0xD3515C28, 0xFFFFFC46, 0xADA6C9B5, 0x9D71AC8F, 0xFFFFFC61,\n        0x23EE8BCB, 0xEA9C2277, 0xFFFFFC7B, 0x4078536D, 0xAECC4991, 0xFFFFFC96,\n        0x5DB6CE57, 0x823C1279, 0xFFFFFCB1, 0x4DFB5637, 0xC2109436, 0xFFFFFCCB,\n        0x3848984F, 0x909" +
@@ -84,7 +96,17 @@
 	".decimal_point);\n      uint32_t shift =\n          (n < num_powers)\n              ? powers[n]\n              : WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;\n\n      wuffs_base__private_implementation__high_prec_dec__small_rshift(&h,\n                                                                      shift);\n      if (h.decimal_point <\n          -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n        goto zero;\n      }\n      exp2 += (int32_t)shift;\n    }\n    // ...then we shift left, putting us in [½ .. 1].\n    while (h.decimal_point <= 0) {\n      uint32_t shift;\n      if (h.decimal_point == 0) {\n        if (h.digits[0] >= 5) {\n          break;\n        }\n        shift = (h.digits[0] <= 2) ? 2 : 1;\n      } else {\n        uint32_t n = (uint32_t)(-h.decimal_point);\n        shift = (n < num_powers)\n                    ? powers[n]\n                    : WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;\n      }\n\n      wuffs_base__private_implementation__high_prec_dec__small_lshif" +
 	"t(&h,\n                                                                      shift);\n      if (h.decimal_point >\n          +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE) {\n        goto infinity;\n      }\n      exp2 -= (int32_t)shift;\n    }\n\n    // We're in the range [½ .. 1] but f64 uses [1 .. 2].\n    exp2--;\n\n    // The minimum normal exponent is (f64_bias + 1).\n    while ((f64_bias + 1) > exp2) {\n      uint32_t n = (uint32_t)((f64_bias + 1) - exp2);\n      if (n > WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {\n        n = WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;\n      }\n      wuffs_base__private_implementation__high_prec_dec__small_rshift(&h, n);\n      exp2 += (int32_t)n;\n    }\n\n    // Check for overflow.\n    if ((exp2 - f64_bias) >= 0x07FF) {  // (1 << 11) - 1.\n      goto infinity;\n    }\n\n    // Extract 53 bits for the mantissa (in base-2).\n    wuffs_base__private_implementation__high_prec_dec__small_lshift(&h, 53);\n    uint64_t man2 =\n        wuffs_base__privat" +
 	"e_implementation__high_prec_dec__rounded_integer(&h);\n\n    // Rounding might have added one bit. If so, shift and re-check overflow.\n    if ((man2 >> 53) != 0) {\n      man2 >>= 1;\n      exp2++;\n      if ((exp2 - f64_bias) >= 0x07FF) {  // (1 << 11) - 1.\n        goto infinity;\n      }\n    }\n\n    // Handle subnormal numbers.\n    if ((man2 >> 52) == 0) {\n      exp2 = f64_bias;\n    }\n\n    // Pack the bits and return.\n    uint64_t exp2_bits =\n        (uint64_t)((exp2 - f64_bias) & 0x07FF);             // (1 << 11) - 1.\n    uint64_t bits = (man2 & 0x000FFFFFFFFFFFFF) |           // (1 << 52) - 1.\n                    (exp2_bits << 52) |                     //\n                    (h.negative ? 0x8000000000000000 : 0);  // (1 << 63).\n\n    wuffs_base__result_f64 ret;\n    ret.status.repr = NULL;\n    ret.value = wuffs_base__ieee_754_bit_representation__to_f64(bits);\n    return ret;\n  } while (0);\n\nzero:\n  do {\n    uint64_t bits = h.negative ? 0x8000000000000000 : 0;\n\n    wuffs_base__result_f64 ret;\n    ret.status.repr = " +
-	"NULL;\n    ret.value = wuffs_base__ieee_754_bit_representation__to_f64(bits);\n    return ret;\n  } while (0);\n\ninfinity:\n  do {\n    uint64_t bits = h.negative ? 0xFFF0000000000000 : 0x7FF0000000000000;\n\n    wuffs_base__result_f64 ret;\n    ret.status.repr = NULL;\n    ret.value = wuffs_base__ieee_754_bit_representation__to_f64(bits);\n    return ret;\n  } while (0);\n}\n" +
+	"NULL;\n    ret.value = wuffs_base__ieee_754_bit_representation__to_f64(bits);\n    return ret;\n  } while (0);\n\ninfinity:\n  do {\n    uint64_t bits = h.negative ? 0xFFF0000000000000 : 0x7FF0000000000000;\n\n    wuffs_base__result_f64 ret;\n    ret.status.repr = NULL;\n    ret.value = wuffs_base__ieee_754_bit_representation__to_f64(bits);\n    return ret;\n  } while (0);\n}\n\n" +
+	"" +
+	"// --------\n\nstatic inline size_t  //\nwuffs_base__private_implementation__render_inf(wuffs_base__slice_u8 dst,\n                                               bool neg,\n                                               uint32_t options) {\n  if (neg) {\n    if (dst.len < 4) {\n      return 0;\n    }\n    wuffs_base__store_u32le__no_bounds_check(dst.ptr, 0x666E492D);  // '-Inf'le.\n    return 4;\n  }\n\n  if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {\n    if (dst.len < 4) {\n      return 0;\n    }\n    wuffs_base__store_u32le__no_bounds_check(dst.ptr, 0x666E492B);  // '+Inf'le.\n    return 4;\n  }\n\n  if (dst.len < 3) {\n    return 0;\n  }\n  wuffs_base__store_u24le__no_bounds_check(dst.ptr, 0x666E49);  // 'Inf'le.\n  return 3;\n}\n\nstatic inline size_t  //\nwuffs_base__private_implementation__render_nan(wuffs_base__slice_u8 dst) {\n  if (dst.len < 3) {\n    return 0;\n  }\n  wuffs_base__store_u24le__no_bounds_check(dst.ptr, 0x4E614E);  // 'NaN'le.\n  return 3;\n}\n\nstatic size_t  //\nwuffs_base__private_implementation__high" +
+	"_prec_dec__render_exponent_absent(\n    wuffs_base__slice_u8 dst,\n    wuffs_base__private_implementation__high_prec_dec* h,\n    uint32_t precision,\n    uint32_t options) {\n  size_t n = (h->negative ||\n              (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN))\n                 ? 1\n                 : 0;\n  if (h->decimal_point <= 0) {\n    n += 1;\n  } else {\n    n += (size_t)(h->decimal_point);\n  }\n  if (precision > 0) {\n    n += precision + 1;  // +1 for the '.'.\n  }\n\n  // Don't modify dst if the formatted number won't fit.\n  if (n > dst.len) {\n    return 0;\n  }\n\n  // Align-left or align-right.\n  uint8_t* ptr = (options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)\n                     ? &dst.ptr[dst.len - n]\n                     : &dst.ptr[0];\n\n  // Leading \"±\".\n  if (h->negative) {\n    *ptr++ = '-';\n  } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {\n    *ptr++ = '+';\n  }\n\n  // Integral digits.\n  if (h->decimal_point <= 0) {\n    *ptr++ = '0';\n  } else {\n    uint32_t m =\n" +
+	"        wuffs_base__u32__min(h->num_digits, (uint32_t)(h->decimal_point));\n    uint32_t i = 0;\n    for (; i < m; i++) {\n      *ptr++ = (uint8_t)('0' | h->digits[i]);\n    }\n    for (; i < (uint32_t)(h->decimal_point); i++) {\n      *ptr++ = '0';\n    }\n  }\n\n  // Separator and then fractional digits.\n  if (precision > 0) {\n    *ptr++ =\n        (options & WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)\n            ? ','\n            : '.';\n    uint32_t i = 0;\n    for (; i < precision; i++) {\n      uint32_t j = ((uint32_t)(h->decimal_point)) + i;\n      *ptr++ = (uint8_t)('0' | ((j < h->num_digits) ? h->digits[j] : 0));\n    }\n  }\n\n  return n;\n}\n\nstatic size_t  //\nwuffs_base__private_implementation__high_prec_dec__render_exponent_present(\n    wuffs_base__slice_u8 dst,\n    wuffs_base__private_implementation__high_prec_dec* h,\n    uint32_t precision,\n    uint32_t options) {\n  int32_t exp = 0;\n  if (h->num_digits > 0) {\n    exp = h->decimal_point - 1;\n  }\n  bool negative_exp = exp < 0;\n  if (negative_exp) {\n" +
+	"    exp = -exp;\n  }\n\n  size_t n = (h->negative ||\n              (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN))\n                 ? 4\n                 : 3;  // Mininum 3 bytes: first digit and then \"e±\".\n  if (precision > 0) {\n    n += precision + 1;  // +1 for the '.'.\n  }\n  n += (exp < 100) ? 2 : 3;\n\n  // Don't modify dst if the formatted number won't fit.\n  if (n > dst.len) {\n    return 0;\n  }\n\n  // Align-left or align-right.\n  uint8_t* ptr = (options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)\n                     ? &dst.ptr[dst.len - n]\n                     : &dst.ptr[0];\n\n  // Leading \"±\".\n  if (h->negative) {\n    *ptr++ = '-';\n  } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {\n    *ptr++ = '+';\n  }\n\n  // Integral digit.\n  if (h->num_digits > 0) {\n    *ptr++ = (uint8_t)('0' | h->digits[0]);\n  } else {\n    *ptr++ = '0';\n  }\n\n  // Separator and then fractional digits.\n  if (precision > 0) {\n    *ptr++ =\n        (options & WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPA" +
+	"RATOR_IS_A_COMMA)\n            ? ','\n            : '.';\n    uint32_t i = 1;\n    uint32_t j = wuffs_base__u32__min(h->num_digits, precision + 1);\n    for (; i < j; i++) {\n      *ptr++ = (uint8_t)('0' | h->digits[i]);\n    }\n    for (; i <= precision; i++) {\n      *ptr++ = '0';\n    }\n  }\n\n  // Exponent: \"e±\" and then 2 or 3 digits.\n  *ptr++ = 'e';\n  *ptr++ = negative_exp ? '-' : '+';\n  if (exp < 10) {\n    *ptr++ = '0';\n    *ptr++ = (uint8_t)('0' | exp);\n  } else if (exp < 100) {\n    *ptr++ = (uint8_t)('0' | (exp / 10));\n    *ptr++ = (uint8_t)('0' | (exp % 10));\n  } else {\n    int32_t e = exp / 100;\n    exp -= e * 100;\n    *ptr++ = (uint8_t)('0' | e);\n    *ptr++ = (uint8_t)('0' | (exp / 10));\n    *ptr++ = (uint8_t)('0' | (exp % 10));\n  }\n\n  return n;\n}\n\nWUFFS_BASE__MAYBE_STATIC size_t  //\nwuffs_base__render_number_f64(wuffs_base__slice_u8 dst,\n                              double x,\n                              uint32_t precision,\n                              uint32_t options) {\n  // Decompose x (64 bits) into " +
+	"negativity (1 bit), base-2 exponent (11 bits\n  // with a -1023 bias) and mantissa (52 bits).\n  uint64_t bits = wuffs_base__ieee_754_bit_representation__from_f64(x);\n  bool neg = (bits >> 63) != 0;\n  int32_t exp2 = ((int32_t)(bits >> 52)) & 0x7FF;\n  uint64_t man = bits & 0x000FFFFFFFFFFFFFul;\n\n  // Apply the exponent bias and set the implicit top bit of the mantissa,\n  // unless x is subnormal. Also take care of Inf and NaN.\n  if (exp2 == 0x7FF) {\n    if (man != 0) {\n      return wuffs_base__private_implementation__render_nan(dst);\n    }\n    return wuffs_base__private_implementation__render_inf(dst, neg, options);\n  } else if (exp2 == 0) {\n    exp2 = -1022;\n  } else {\n    exp2 -= 1023;\n    man |= 0x0010000000000000ul;\n  }\n\n  // Ensure that precision isn't too large.\n  if (precision > 4095) {\n    precision = 4095;\n  }\n\n  // Convert from the (neg, exp2, man) tuple to an HPD.\n  wuffs_base__private_implementation__high_prec_dec h;\n  wuffs_base__private_implementation__high_prec_dec__assign(&h, man, neg);\n  if (h.n" +
+	"um_digits > 0) {\n    wuffs_base__private_implementation__high_prec_dec__lshift(\n        &h, exp2 - 52);  // 52 mantissa bits.\n  }\n\n  // Handle the \"%e\" and \"%f\" formats.\n  switch (options & (WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT |\n                     WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT)) {\n    case WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT:  // The \"%\"f\" format.\n      if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {\n        wuffs_base__private_implementation__high_prec_dec__round_just_enough(\n            &h, exp2, man);\n        int32_t p = ((int32_t)(h.num_digits)) - h.decimal_point;\n        precision = ((uint32_t)(wuffs_base__i32__max(0, p)));\n      } else {\n        wuffs_base__private_implementation__high_prec_dec__round_nearest(\n            &h, ((int32_t)precision) + h.decimal_point);\n      }\n      return wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(\n          dst, &h, precision, options);\n\n    case WUFFS_BASE__RENDER_NUMBER_FXX__" +
+	"EXPONENT_PRESENT:  // The \"%e\" format.\n      if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {\n        wuffs_base__private_implementation__high_prec_dec__round_just_enough(\n            &h, exp2, man);\n        precision = (h.num_digits > 0) ? (h.num_digits - 1) : 0;\n      } else {\n        wuffs_base__private_implementation__high_prec_dec__round_nearest(\n            &h, ((int32_t)precision) + 1);\n      }\n      return wuffs_base__private_implementation__high_prec_dec__render_exponent_present(\n          dst, &h, precision, options);\n  }\n\n  // We have the \"%g\" format and so precision means the number of significant\n  // digits, not the number of digits after the decimal separator. Perform\n  // rounding and determine whether to use \"%e\" or \"%f\".\n  int32_t e_threshold = 0;\n  if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {\n    wuffs_base__private_implementation__high_prec_dec__round_just_enough(\n        &h, exp2, man);\n    precision = h.num_digits;\n    e_threshold = 6;\n  } el" +
+	"se {\n    if (precision == 0) {\n      precision = 1;\n    }\n    wuffs_base__private_implementation__high_prec_dec__round_nearest(\n        &h, ((int32_t)precision));\n    e_threshold = ((int32_t)precision);\n    int32_t nd = ((int32_t)(h.num_digits));\n    if ((e_threshold > nd) && (nd >= h.decimal_point)) {\n      e_threshold = nd;\n    }\n  }\n\n  // Use the \"%e\" format if the exponent is large.\n  int32_t e = h.decimal_point - 1;\n  if ((e < -4) || (e_threshold <= e)) {\n    uint32_t p = wuffs_base__u32__min(precision, h.num_digits);\n    return wuffs_base__private_implementation__high_prec_dec__render_exponent_present(\n        dst, &h, (p > 0) ? (p - 1) : 0, options);\n  }\n\n  // Use the \"%f\" format otherwise.\n  int32_t p = ((int32_t)precision);\n  if (p > h.decimal_point) {\n    p = ((int32_t)(h.num_digits));\n  }\n  precision = ((uint32_t)(wuffs_base__i32__max(0, p - h.decimal_point)));\n  return wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(\n      dst, &h, precision, options);\n}\n" +
 	""
 
 const BaseI64ConvSubmoduleC = "" +
@@ -103,8 +125,8 @@
 	"" +
 	"// --------\n\n// wuffs_base__render_number__first_hundred contains the decimal encodings of\n// the first one hundred numbers [0 ..= 99].\nstatic const uint8_t wuffs_base__render_number__first_hundred[200] = {\n    '0', '0', '0', '1', '0', '2', '0', '3', '0', '4',  //\n    '0', '5', '0', '6', '0', '7', '0', '8', '0', '9',  //\n    '1', '0', '1', '1', '1', '2', '1', '3', '1', '4',  //\n    '1', '5', '1', '6', '1', '7', '1', '8', '1', '9',  //\n    '2', '0', '2', '1', '2', '2', '2', '3', '2', '4',  //\n    '2', '5', '2', '6', '2', '7', '2', '8', '2', '9',  //\n    '3', '0', '3', '1', '3', '2', '3', '3', '3', '4',  //\n    '3', '5', '3', '6', '3', '7', '3', '8', '3', '9',  //\n    '4', '0', '4', '1', '4', '2', '4', '3', '4', '4',  //\n    '4', '5', '4', '6', '4', '7', '4', '8', '4', '9',  //\n    '5', '0', '5', '1', '5', '2', '5', '3', '5', '4',  //\n    '5', '5', '5', '6', '5', '7', '5', '8', '5', '9',  //\n    '6', '0', '6', '1', '6', '2', '6', '3', '6', '4',  //\n    '6', '5', '6', '6', '6', '7', '6', '8', '6', '9',  //\n    '" +
 	"7', '0', '7', '1', '7', '2', '7', '3', '7', '4',  //\n    '7', '5', '7', '6', '7', '7', '7', '8', '7', '9',  //\n    '8', '0', '8', '1', '8', '2', '8', '3', '8', '4',  //\n    '8', '5', '8', '6', '8', '7', '8', '8', '8', '9',  //\n    '9', '0', '9', '1', '9', '2', '9', '3', '9', '4',  //\n    '9', '5', '9', '6', '9', '7', '9', '8', '9', '9',  //\n};\n\nstatic size_t  //\nwuffs_base__private_implementation__render_number_u64(wuffs_base__slice_u8 dst,\n                                                      uint64_t x,\n                                                      uint32_t options,\n                                                      bool neg) {\n  uint8_t buf[WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL];\n  uint8_t* ptr = &buf[0] + sizeof(buf);\n\n  while (x >= 100) {\n    size_t index = (x % 100) * 2;\n    x /= 100;\n    uint8_t s0 = wuffs_base__render_number__first_hundred[index + 0];\n    uint8_t s1 = wuffs_base__render_number__first_hundred[index + 1];\n    ptr -= 2;\n    ptr[0] = s0;\n    ptr[1] = s1;\n  }\n\n  if (x < 10) {\n " +
-	"   ptr -= 1;\n    ptr[0] = (uint8_t)('0' + x);\n  } else {\n    size_t index = x * 2;\n    uint8_t s0 = wuffs_base__render_number__first_hundred[index + 0];\n    uint8_t s1 = wuffs_base__render_number__first_hundred[index + 1];\n    ptr -= 2;\n    ptr[0] = s0;\n    ptr[1] = s1;\n  }\n\n  if (neg) {\n    ptr -= 1;\n    ptr[0] = '-';\n  } else if (options & WUFFS_BASE__RENDER_NUMBER__LEADING_PLUS_SIGN) {\n    ptr -= 1;\n    ptr[0] = '+';\n  }\n\n  size_t n = sizeof(buf) - ((size_t)(ptr - &buf[0]));\n  if (n > dst.len) {\n    return 0;\n  }\n  memcpy(dst.ptr + ((options & WUFFS_BASE__RENDER_NUMBER__ALIGN_RIGHT)\n                        ? (dst.len - n)\n                        : 0),\n         ptr, n);\n  return n;\n}\n\nWUFFS_BASE__MAYBE_STATIC size_t  //\nwuffs_base__render_number_i64(wuffs_base__slice_u8 dst,\n                              int64_t x,\n                              uint32_t options) {\n  uint64_t u = (uint64_t)x;\n  bool neg = x < 0;\n  if (neg) {\n    u = 1 + ~u;\n  }\n  return wuffs_base__private_implementation__render_number_u64(d" +
-	"st, u, options,\n                                                               neg);\n}\n\nWUFFS_BASE__MAYBE_STATIC size_t  //\nwuffs_base__render_number_u64(wuffs_base__slice_u8 dst,\n                              uint64_t x,\n                              uint32_t options) {\n  return wuffs_base__private_implementation__render_number_u64(dst, x, options,\n                                                               false);\n}\n\n" +
+	"   ptr -= 1;\n    ptr[0] = (uint8_t)('0' + x);\n  } else {\n    size_t index = x * 2;\n    uint8_t s0 = wuffs_base__render_number__first_hundred[index + 0];\n    uint8_t s1 = wuffs_base__render_number__first_hundred[index + 1];\n    ptr -= 2;\n    ptr[0] = s0;\n    ptr[1] = s1;\n  }\n\n  if (neg) {\n    ptr -= 1;\n    ptr[0] = '-';\n  } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {\n    ptr -= 1;\n    ptr[0] = '+';\n  }\n\n  size_t n = sizeof(buf) - ((size_t)(ptr - &buf[0]));\n  if (n > dst.len) {\n    return 0;\n  }\n  memcpy(dst.ptr + ((options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)\n                        ? (dst.len - n)\n                        : 0),\n         ptr, n);\n  return n;\n}\n\nWUFFS_BASE__MAYBE_STATIC size_t  //\nwuffs_base__render_number_i64(wuffs_base__slice_u8 dst,\n                              int64_t x,\n                              uint32_t options) {\n  uint64_t u = (uint64_t)x;\n  bool neg = x < 0;\n  if (neg) {\n    u = 1 + ~u;\n  }\n  return wuffs_base__private_implementation__render_numb" +
+	"er_u64(dst, u, options,\n                                                               neg);\n}\n\nWUFFS_BASE__MAYBE_STATIC size_t  //\nwuffs_base__render_number_u64(wuffs_base__slice_u8 dst,\n                              uint64_t x,\n                              uint32_t options) {\n  return wuffs_base__private_implementation__render_number_u64(dst, x, options,\n                                                               false);\n}\n\n" +
 	"" +
 	"// ---------------- Hexadecimal\n\nWUFFS_BASE__MAYBE_STATIC size_t  //\nwuffs_base__hexadecimal__decode2(wuffs_base__slice_u8 dst,\n                                 wuffs_base__slice_u8 src) {\n  size_t src_len2 = src.len / 2;\n  size_t len = dst.len < src_len2 ? dst.len : src_len2;\n  uint8_t* d = dst.ptr;\n  uint8_t* s = src.ptr;\n  size_t n = len;\n\n  while (n--) {\n    *d = (uint8_t)((wuffs_base__parse_number__hexadecimal_digits[s[0]] << 4) |\n                   (wuffs_base__parse_number__hexadecimal_digits[s[1]] & 0x0F));\n    d += 1;\n    s += 2;\n  }\n\n  return len;\n}\n\nWUFFS_BASE__MAYBE_STATIC size_t  //\nwuffs_base__hexadecimal__decode4(wuffs_base__slice_u8 dst,\n                                 wuffs_base__slice_u8 src) {\n  size_t src_len4 = src.len / 4;\n  size_t len = dst.len < src_len4 ? dst.len : src_len4;\n  uint8_t* d = dst.ptr;\n  uint8_t* s = src.ptr;\n  size_t n = len;\n\n  while (n--) {\n    *d = (uint8_t)((wuffs_base__parse_number__hexadecimal_digits[s[2]] << 4) |\n                   (wuffs_base__parse_number__hexa" +
 	"decimal_digits[s[3]] & 0x0F));\n    d += 1;\n    s += 4;\n  }\n\n  return len;\n}\n" +
@@ -231,8 +253,9 @@
 	"" +
 	"// --------\n\n// Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a\n// second. See https://github.com/OculusVR/Flicks\ntypedef int64_t wuffs_base__flicks;\n\n#define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000)\n#define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600)\n\n" +
 	"" +
-	"// ---------------- Numeric Types\n\n// The helpers below are functions, instead of macros, because their arguments\n// can be an expression that we shouldn't evaluate more than once.\n//\n// They are static, so that linking multiple wuffs .o files won't complain about\n// duplicate function definitions.\n//\n// They are explicitly marked inline, even if modern compilers don't use the\n// inline attribute to guide optimizations such as inlining, to avoid the\n// -Wunused-function warning, and we like to compile with -Wall -Werror.\n\nstatic inline uint8_t  //\nwuffs_base__u8__min(uint8_t x, uint8_t y) {\n  return x < y ? x : y;\n}\n\nstatic inline uint8_t  //\nwuffs_base__u8__max(uint8_t x, uint8_t y) {\n  return x > y ? x : y;\n}\n\nstatic inline uint16_t  //\nwuffs_base__u16__min(uint16_t x, uint16_t y) {\n  return x < y ? x : y;\n}\n\nstatic inline uint16_t  //\nwuffs_base__u16__max(uint16_t x, uint16_t y) {\n  return x > y ? x : y;\n}\n\nstatic inline uint32_t  //\nwuffs_base__u32__min(uint32_t x, uint32_t y) {\n  return x < y ? x : y;\n}\n" +
-	"\nstatic inline uint32_t  //\nwuffs_base__u32__max(uint32_t x, uint32_t y) {\n  return x > y ? x : y;\n}\n\nstatic inline uint64_t  //\nwuffs_base__u64__min(uint64_t x, uint64_t y) {\n  return x < y ? x : y;\n}\n\nstatic inline uint64_t  //\nwuffs_base__u64__max(uint64_t x, uint64_t y) {\n  return x > y ? x : y;\n}\n\n" +
+	"// ---------------- Numeric Types\n\n// The helpers below are functions, instead of macros, because their arguments\n// can be an expression that we shouldn't evaluate more than once.\n//\n// They are static, so that linking multiple wuffs .o files won't complain about\n// duplicate function definitions.\n//\n// They are explicitly marked inline, even if modern compilers don't use the\n// inline attribute to guide optimizations such as inlining, to avoid the\n// -Wunused-function warning, and we like to compile with -Wall -Werror.\n\nstatic inline int8_t  //\nwuffs_base__i8__min(int8_t x, int8_t y) {\n  return x < y ? x : y;\n}\n\nstatic inline int8_t  //\nwuffs_base__i8__max(int8_t x, int8_t y) {\n  return x > y ? x : y;\n}\n\nstatic inline int16_t  //\nwuffs_base__i16__min(int16_t x, int16_t y) {\n  return x < y ? x : y;\n}\n\nstatic inline int16_t  //\nwuffs_base__i16__max(int16_t x, int16_t y) {\n  return x > y ? x : y;\n}\n\nstatic inline int32_t  //\nwuffs_base__i32__min(int32_t x, int32_t y) {\n  return x < y ? x : y;\n}\n\nstatic inline " +
+	"int32_t  //\nwuffs_base__i32__max(int32_t x, int32_t y) {\n  return x > y ? x : y;\n}\n\nstatic inline int64_t  //\nwuffs_base__i64__min(int64_t x, int64_t y) {\n  return x < y ? x : y;\n}\n\nstatic inline int64_t  //\nwuffs_base__i64__max(int64_t x, int64_t y) {\n  return x > y ? x : y;\n}\n\nstatic inline uint8_t  //\nwuffs_base__u8__min(uint8_t x, uint8_t y) {\n  return x < y ? x : y;\n}\n\nstatic inline uint8_t  //\nwuffs_base__u8__max(uint8_t x, uint8_t y) {\n  return x > y ? x : y;\n}\n\nstatic inline uint16_t  //\nwuffs_base__u16__min(uint16_t x, uint16_t y) {\n  return x < y ? x : y;\n}\n\nstatic inline uint16_t  //\nwuffs_base__u16__max(uint16_t x, uint16_t y) {\n  return x > y ? x : y;\n}\n\nstatic inline uint32_t  //\nwuffs_base__u32__min(uint32_t x, uint32_t y) {\n  return x < y ? x : y;\n}\n\nstatic inline uint32_t  //\nwuffs_base__u32__max(uint32_t x, uint32_t y) {\n  return x > y ? x : y;\n}\n\nstatic inline uint64_t  //\nwuffs_base__u64__min(uint64_t x, uint64_t y) {\n  return x < y ? x : y;\n}\n\nstatic inline uint64_t  //\nwuffs_base__u64__m" +
+	"ax(uint64_t x, uint64_t y) {\n  return x > y ? x : y;\n}\n\n" +
 	"" +
 	"// --------\n\n// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms\n// are per https://locklessinc.com/articles/sat_arithmetic/\n//\n// It is important that the underlying types are unsigned integers, as signed\n// integer arithmetic overflow is undefined behavior in C.\n\nstatic inline uint8_t  //\nwuffs_base__u8__sat_add(uint8_t x, uint8_t y) {\n  uint8_t res = (uint8_t)(x + y);\n  res |= (uint8_t)(-(res < x));\n  return res;\n}\n\nstatic inline uint8_t  //\nwuffs_base__u8__sat_sub(uint8_t x, uint8_t y) {\n  uint8_t res = (uint8_t)(x - y);\n  res &= (uint8_t)(-(res <= x));\n  return res;\n}\n\nstatic inline uint16_t  //\nwuffs_base__u16__sat_add(uint16_t x, uint16_t y) {\n  uint16_t res = (uint16_t)(x + y);\n  res |= (uint16_t)(-(res < x));\n  return res;\n}\n\nstatic inline uint16_t  //\nwuffs_base__u16__sat_sub(uint16_t x, uint16_t y) {\n  uint16_t res = (uint16_t)(x - y);\n  res &= (uint16_t)(-(res <= x));\n  return res;\n}\n\nstatic inline uint32_t  //\nwuffs_base__u32__sat_add(uint32_t x, uint32_t y) {\n  uint32" +
 	"_t res = (uint32_t)(x + y);\n  res |= (uint32_t)(-(res < x));\n  return res;\n}\n\nstatic inline uint32_t  //\nwuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {\n  uint32_t res = (uint32_t)(x - y);\n  res &= (uint32_t)(-(res <= x));\n  return res;\n}\n\nstatic inline uint64_t  //\nwuffs_base__u64__sat_add(uint64_t x, uint64_t y) {\n  uint64_t res = (uint64_t)(x + y);\n  res |= (uint64_t)(-(res < x));\n  return res;\n}\n\nstatic inline uint64_t  //\nwuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {\n  uint64_t res = (uint64_t)(x - y);\n  res &= (uint64_t)(-(res <= x));\n  return res;\n}\n\n" +
@@ -417,7 +440,9 @@
 	""
 
 const BaseStrConvPublicH = "" +
-	"// ---------------- String Conversions\n\n// Options (bitwise or'ed together) for wuffs_base__render_number_etc\n// functions.\n\n#define WUFFS_BASE__RENDER_NUMBER__DEFAULT_OPTIONS ((uint32_t)0x00000000)\n\n// WUFFS_BASE__RENDER_NUMBER__ALIGN_RIGHT means to render to the right side\n// (higher indexes) of the destination slice, leaving any untouched bytes on\n// the left side (lower indexes). The default is vice versa: rendering on the\n// left with slack on the right.\n#define WUFFS_BASE__RENDER_NUMBER__ALIGN_RIGHT ((uint32_t)0x00000001)\n\n// WUFFS_BASE__RENDER_NUMBER__LEADING_PLUS_SIGN means to render the unnecessary\n// leading \"+\" for non-negative numbers: \"+0\" and \"+123\", not \"0\" and \"123\".\n#define WUFFS_BASE__RENDER_NUMBER__LEADING_PLUS_SIGN ((uint32_t)0x00000002)\n\n" +
+	"// ---------------- String Conversions\n\n// Options (bitwise or'ed together) for wuffs_base__render_number_xxx\n// functions. The XXX options apply to both integer and floating point. The FXX\n// options apply only to floating point.\n\n#define WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS ((uint32_t)0x00000000)\n\n// WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT means to render to the right side\n// (higher indexes) of the destination slice, leaving any untouched bytes on\n// the left side (lower indexes). The default is vice versa: rendering on the\n// left with slack on the right.\n#define WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT ((uint32_t)0x00000001)\n\n// WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN means to render the leading\n// \"+\" for non-negative numbers: \"+0\" and \"+12.3\" instead of \"0\" and \"12.3\".\n#define WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN ((uint32_t)0x00000002)\n\n// WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA means to render\n// one-and-a-half as \"1,5\" instead of \"1.5\".\n#define " +
+	"WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA \\\n  ((uint32_t)0x00000100)\n\n// WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ETC means whether to never\n// (EXPONENT_ABSENT, equivalent to printf's \"%f\") or to always\n// (EXPONENT_PRESENT, equivalent to printf's \"%e\") render a floating point\n// number as \"1.23e+05\" instead of \"123000\".\n//\n// Having both bits set is the same has having neither bit set, where the\n// notation used depends on whether the exponent is sufficiently large: \"0.5\"\n// is preferred over \"5e-01\" but \"5e-09\" is preferred over \"0.000000005\".\n#define WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT ((uint32_t)0x00000200)\n#define WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT ((uint32_t)0x00000400)\n\n// WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION means to render the\n// smallest number of digits so that parsing the resultant string will recover\n// the same double-precision floating point number.\n//\n// For example, double-precision cannot distinguish between 0.3 and\n// 0.2999999999999" +
+	"99988897769753748434595763683319091796875, so when this bit\n// is set, rendering the latter will produce \"0.3\" but rendering\n// 0.3000000000000000444089209850062616169452667236328125 will produce\n// \"0.30000000000000004\".\n#define WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION \\\n  ((uint32_t)0x00000800)\n\n" +
 	"" +
 	"// ---------------- IEEE 754 Floating Point\n\n// wuffs_base__parse_number_f64 parses the floating point number in s. For\n// example, if s contains the bytes \"1.5\" then it will return the double 1.5.\n//\n// It returns an error if s does not contain a floating point number.\n//\n// It does not necessarily return an error if the conversion is lossy, e.g. if\n// s is \"0.3\", which double-precision floating point cannot represent exactly.\n//\n// Similarly, the returned value may be infinite (and no error returned) even\n// if s was not \"inf\", when the input is nominally finite but sufficiently\n// larger than DBL_MAX, about 1.8e+308.\n//\n// It is similar to the C standard library's strtod function, but:\n//  - Errors are returned in-band (in a result type), not out-of-band (errno).\n//  - It takes a slice (a pointer and length), not a NUL-terminated C string.\n//  - It does not take an optional endptr argument. It does not allow a partial\n//    parse: it returns an error unless all of s is consumed.\n//  - It does not allow whi" +
 	"tespace, leading or otherwise.\n//  - It does not allow unnecessary leading zeroes (\"0\" is valid and its sole\n//    zero is necessary). All of \"00\", \"0644\" and \"00.7\" are invalid.\n//  - It is not affected by i18n / l10n settings such as environment variables.\n//  - Conversely, it always accepts either ',' or '.' as a decimal separator.\n//    In particular, \"3,141,592\" is always invalid but \"3,141\" is always valid\n//    (and approximately π). The caller is responsible for e.g. previously\n//    rejecting or filtering s if it contains a comma, if that is unacceptable\n//    to the caller. For example, JSON numbers always use a dot '.' and never a\n//    comma ',', regardless of the LOCALE environment variable.\n//  - It does allow arbitrary underscores. For example, \"_3.141_592\" would\n//    successfully parse, again approximately π.\n//  - It does allow \"inf\", \"+Infinity\" and \"-NAN\", case insensitive, but it\n//    does not permit \"nan\" to be followed by an integer mantissa.\n//  - It does not allow hexadecimal float" +
@@ -429,8 +454,9 @@
 	"ted C string.\n//  - It does not take an optional endptr argument. It does not allow a partial\n//    parse: it returns an error unless all of s is consumed.\n//  - It does not allow whitespace, leading or otherwise.\n//  - It does not allow a leading '+' or '-'.\n//  - It does not allow unnecessary leading zeroes (\"0\" is valid and its sole\n//    zero is necessary). All of \"00\", \"0644\" and \"007\" are invalid.\n//  - It does not take a base argument (e.g. base 10 vs base 16). Instead, it\n//    always accepts both decimal (e.g \"1234\", \"0d5678\") and hexadecimal (e.g.\n//    \"0x9aBC\"). The caller is responsible for prior filtering of e.g. hex\n//    numbers if they are unwanted. For example, Wuffs' JSON decoder will only\n//    produce a wuffs_base__token for decimal numbers, not hexadecimal.\n//  - It is not affected by i18n / l10n settings such as environment variables.\n//  - It does allow arbitrary underscores, except inside the optional 2-byte\n//    opening \"0d\" or \"0X\" that denotes base-10 or base-16. For example,\n//  " +
 	"  \"__0D_1_002\" would successfully parse as \"one thousand and two\".\nWUFFS_BASE__MAYBE_STATIC wuffs_base__result_u64  //\nwuffs_base__parse_number_u64(wuffs_base__slice_u8 s);\n\n" +
 	"" +
-	"// --------\n\n#define WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL 20\n#define WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL 21\n\n// wuffs_base__render_number_i64 writes the decimal encoding of x to dst and\n// returns the number of bytes written. If dst is shorter than the entire\n// encoding, it returns 0 (and no bytes are written).\n//\n// dst will never be too short if its length is at least 20, also known as\n// WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL.\nWUFFS_BASE__MAYBE_STATIC size_t  //\nwuffs_base__render_number_i64(wuffs_base__slice_u8 dst,\n                              int64_t x,\n                              uint32_t options);\n\n// wuffs_base__render_number_u64 writes the decimal encoding of x to dst and\n// returns the number of bytes written. If dst is shorter than the entire\n// encoding, it returns 0 (and no bytes are written).\n//\n// dst will never be too short if its length is at least 21, also known as\n// WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL.\nWUFFS_BASE__MAYBE_STATIC size_t  //\nwuffs_base__render_number_u64(wuffs_bas" +
-	"e__slice_u8 dst,\n                              uint64_t x,\n                              uint32_t options);\n\n" +
+	"// --------\n\n#define WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL 20\n#define WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL 21\n\n// wuffs_base__render_number_f64 writes the decimal encoding of x to dst and\n// returns the number of bytes written. If dst is shorter than the entire\n// encoding, it returns 0 (and no bytes are written).\n//\n// For those familiar with C's printf or Go's fmt.Printf functions:\n//  - \"%e\" means the WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT option.\n//  - \"%f\" means the WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT  option.\n//  - \"%g\" means neither or both bits are set.\n//\n// The precision argument controls the number of digits rendered, excluding the\n// exponent (the \"e+05\" in \"1.23e+05\"):\n//  - for \"%e\" and \"%f\" it is the number of digits after the decimal separator,\n//  - for \"%g\" it is the number of significant digits (and trailing zeroes are\n//    removed).\n//\n// A precision of 6 gives similar output to printf's defaults.\n//\n// A precision greater than 4095 is equivalent to 4095.\n//\n// The " +
+	"precision argument is ignored when the\n// WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION option is set. This is\n// similar to Go's strconv.FormatFloat with a negative (i.e. non-sensical)\n// precision, but there is no corresponding feature in C's printf.\n//\n// Extreme values of x will be rendered as \"NaN\", \"Inf\" (or \"+Inf\" if the\n// WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN option is set) or \"-Inf\".\nWUFFS_BASE__MAYBE_STATIC size_t  //\nwuffs_base__render_number_f64(wuffs_base__slice_u8 dst,\n                              double x,\n                              uint32_t precision,\n                              uint32_t options);\n\n// wuffs_base__render_number_i64 writes the decimal encoding of x to dst and\n// returns the number of bytes written. If dst is shorter than the entire\n// encoding, it returns 0 (and no bytes are written).\n//\n// dst will never be too short if its length is at least 20, also known as\n// WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL.\nWUFFS_BASE__MAYBE_STATIC size_t  //\nwuffs_base__ren" +
+	"der_number_i64(wuffs_base__slice_u8 dst,\n                              int64_t x,\n                              uint32_t options);\n\n// wuffs_base__render_number_u64 writes the decimal encoding of x to dst and\n// returns the number of bytes written. If dst is shorter than the entire\n// encoding, it returns 0 (and no bytes are written).\n//\n// dst will never be too short if its length is at least 21, also known as\n// WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL.\nWUFFS_BASE__MAYBE_STATIC size_t  //\nwuffs_base__render_number_u64(wuffs_base__slice_u8 dst,\n                              uint64_t x,\n                              uint32_t options);\n\n" +
 	"" +
 	"// ---------------- Hexadecimal\n\n// wuffs_base__hexadecimal__decode2 converts \"6A6b\" to \"jk\", where e.g. 'j' is\n// U+006A. There are 2 source bytes for every destination byte.\n//\n// It returns the number of dst bytes written: the minimum of dst.len and\n// (src.len / 2). Excess source bytes are ignored.\n//\n// It assumes that the src bytes are two hexadecimal digits (0-9, A-F, a-f),\n// repeated. It may write nonsense bytes if not, although it will not read or\n// write out of bounds.\nWUFFS_BASE__MAYBE_STATIC size_t  //\nwuffs_base__hexadecimal__decode2(wuffs_base__slice_u8 dst,\n                                 wuffs_base__slice_u8 src);\n\n// wuffs_base__hexadecimal__decode4 converts \"\\\\x6A\\\\x6b\" to \"jk\", where e.g.\n// 'j' is U+006A. There are 4 source bytes for every destination byte.\n//\n// It returns the number of dst bytes written: the minimum of dst.len and\n// (src.len / 4). Excess source bytes are ignored.\n//\n// It assumes that the src bytes are two ignored bytes and then two hexadecimal\n// digits (0-9, A-F, a" +
 	"-f), repeated. It may write nonsense bytes if not,\n// although it will not read or write out of bounds.\nWUFFS_BASE__MAYBE_STATIC size_t  //\nwuffs_base__hexadecimal__decode4(wuffs_base__slice_u8 dst,\n                                 wuffs_base__slice_u8 src);\n\n" +
diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c
index c4db729..e0161ee 100644
--- a/release/c/wuffs-unsupported-snapshot.c
+++ b/release/c/wuffs-unsupported-snapshot.c
@@ -354,6 +354,46 @@
 // inline attribute to guide optimizations such as inlining, to avoid the
 // -Wunused-function warning, and we like to compile with -Wall -Werror.
 
+static inline int8_t  //
+wuffs_base__i8__min(int8_t x, int8_t y) {
+  return x < y ? x : y;
+}
+
+static inline int8_t  //
+wuffs_base__i8__max(int8_t x, int8_t y) {
+  return x > y ? x : y;
+}
+
+static inline int16_t  //
+wuffs_base__i16__min(int16_t x, int16_t y) {
+  return x < y ? x : y;
+}
+
+static inline int16_t  //
+wuffs_base__i16__max(int16_t x, int16_t y) {
+  return x > y ? x : y;
+}
+
+static inline int32_t  //
+wuffs_base__i32__min(int32_t x, int32_t y) {
+  return x < y ? x : y;
+}
+
+static inline int32_t  //
+wuffs_base__i32__max(int32_t x, int32_t y) {
+  return x > y ? x : y;
+}
+
+static inline int64_t  //
+wuffs_base__i64__min(int64_t x, int64_t y) {
+  return x < y ? x : y;
+}
+
+static inline int64_t  //
+wuffs_base__i64__max(int64_t x, int64_t y) {
+  return x > y ? x : y;
+}
+
 static inline uint8_t  //
 wuffs_base__u8__min(uint8_t x, uint8_t y) {
   return x < y ? x : y;
@@ -3866,20 +3906,49 @@
 
 // ---------------- String Conversions
 
-// Options (bitwise or'ed together) for wuffs_base__render_number_etc
-// functions.
+// Options (bitwise or'ed together) for wuffs_base__render_number_xxx
+// functions. The XXX options apply to both integer and floating point. The FXX
+// options apply only to floating point.
 
-#define WUFFS_BASE__RENDER_NUMBER__DEFAULT_OPTIONS ((uint32_t)0x00000000)
+#define WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS ((uint32_t)0x00000000)
 
-// WUFFS_BASE__RENDER_NUMBER__ALIGN_RIGHT means to render to the right side
+// WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT means to render to the right side
 // (higher indexes) of the destination slice, leaving any untouched bytes on
 // the left side (lower indexes). The default is vice versa: rendering on the
 // left with slack on the right.
-#define WUFFS_BASE__RENDER_NUMBER__ALIGN_RIGHT ((uint32_t)0x00000001)
+#define WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT ((uint32_t)0x00000001)
 
-// WUFFS_BASE__RENDER_NUMBER__LEADING_PLUS_SIGN means to render the unnecessary
-// leading "+" for non-negative numbers: "+0" and "+123", not "0" and "123".
-#define WUFFS_BASE__RENDER_NUMBER__LEADING_PLUS_SIGN ((uint32_t)0x00000002)
+// WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN means to render the leading
+// "+" for non-negative numbers: "+0" and "+12.3" instead of "0" and "12.3".
+#define WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN ((uint32_t)0x00000002)
+
+// WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA means to render
+// one-and-a-half as "1,5" instead of "1.5".
+#define WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA \
+  ((uint32_t)0x00000100)
+
+// WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ETC means whether to never
+// (EXPONENT_ABSENT, equivalent to printf's "%f") or to always
+// (EXPONENT_PRESENT, equivalent to printf's "%e") render a floating point
+// number as "1.23e+05" instead of "123000".
+//
+// Having both bits set is the same has having neither bit set, where the
+// notation used depends on whether the exponent is sufficiently large: "0.5"
+// is preferred over "5e-01" but "5e-09" is preferred over "0.000000005".
+#define WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT ((uint32_t)0x00000200)
+#define WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT ((uint32_t)0x00000400)
+
+// WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION means to render the
+// smallest number of digits so that parsing the resultant string will recover
+// the same double-precision floating point number.
+//
+// For example, double-precision cannot distinguish between 0.3 and
+// 0.299999999999999988897769753748434595763683319091796875, so when this bit
+// is set, rendering the latter will produce "0.3" but rendering
+// 0.3000000000000000444089209850062616169452667236328125 will produce
+// "0.30000000000000004".
+#define WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION \
+  ((uint32_t)0x00000800)
 
 // ---------------- IEEE 754 Floating Point
 
@@ -3998,6 +4067,38 @@
 #define WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL 20
 #define WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL 21
 
+// wuffs_base__render_number_f64 writes the decimal encoding of x to dst and
+// returns the number of bytes written. If dst is shorter than the entire
+// encoding, it returns 0 (and no bytes are written).
+//
+// For those familiar with C's printf or Go's fmt.Printf functions:
+//  - "%e" means the WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT option.
+//  - "%f" means the WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT  option.
+//  - "%g" means neither or both bits are set.
+//
+// The precision argument controls the number of digits rendered, excluding the
+// exponent (the "e+05" in "1.23e+05"):
+//  - for "%e" and "%f" it is the number of digits after the decimal separator,
+//  - for "%g" it is the number of significant digits (and trailing zeroes are
+//    removed).
+//
+// A precision of 6 gives similar output to printf's defaults.
+//
+// A precision greater than 4095 is equivalent to 4095.
+//
+// The precision argument is ignored when the
+// WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION option is set. This is
+// similar to Go's strconv.FormatFloat with a negative (i.e. non-sensical)
+// precision, but there is no corresponding feature in C's printf.
+//
+// Extreme values of x will be rendered as "NaN", "Inf" (or "+Inf" if the
+// WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN option is set) or "-Inf".
+WUFFS_BASE__MAYBE_STATIC size_t  //
+wuffs_base__render_number_f64(wuffs_base__slice_u8 dst,
+                              double x,
+                              uint32_t precision,
+                              uint32_t options);
+
 // wuffs_base__render_number_i64 writes the decimal encoding of x to dst and
 // returns the number of bytes written. If dst is shorter than the entire
 // encoding, it returns 0 (and no bytes are written).
@@ -8840,8 +8941,8 @@
 
 // ---------------- IEEE 754 Floating Point
 
-#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE 1023
-#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION 500
+#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE 2047
+#define WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION 800
 
 // WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL is the largest N
 // such that ((10 << N) < (1 << 64)).
@@ -8851,14 +8952,14 @@
 // fixed precision floating point decimal number, augmented with ±infinity
 // values, but it cannot represent NaN (Not a Number).
 //
-// "High precision" means that the mantissa holds 500 decimal digits. 500 is
+// "High precision" means that the mantissa holds 800 decimal digits. 800 is
 // WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION.
 //
 // An HPD isn't for general purpose arithmetic, only for conversions to and
 // from IEEE 754 double-precision floating point, where the largest and
 // smallest positive, finite values are approximately 1.8e+308 and 4.9e-324.
-// HPD exponents above +1023 mean infinity, below -1023 mean zero. The ±1023
-// bounds are further away from zero than ±(324 + 500), where 500 and 1023 is
+// HPD exponents above +2047 mean infinity, below -2047 mean zero. The ±2047
+// bounds are further away from zero than ±(324 + 800), where 800 and 2047 is
 // WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DIGITS_PRECISION and
 // WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.
 //
@@ -8880,8 +8981,8 @@
 //   - A decimal_point of +4 means "7890."
 //   - A decimal_point of +5 means "78900."
 //
-// As above, a decimal_point higher than +1023 means that the overall value is
-// infinity, lower than -1023 means zero.
+// As above, a decimal_point higher than +2047 means that the overall value is
+// infinity, lower than -2047 means zero.
 //
 // negative is a sign bit. An HPD can distinguish positive and negative zero.
 //
@@ -8913,6 +9014,48 @@
   }
 }
 
+// wuffs_base__private_implementation__high_prec_dec__assign sets h to
+// represent the number x.
+//
+// Preconditions:
+//  - h is non-NULL.
+static void  //
+wuffs_base__private_implementation__high_prec_dec__assign(
+    wuffs_base__private_implementation__high_prec_dec* h,
+    uint64_t x,
+    bool negative) {
+  uint32_t n = 0;
+
+  // Set h->digits.
+  if (x > 0) {
+    // Calculate the digits, working right-to-left. After we determine n (how
+    // many digits there are), copy from buf to h->digits.
+    //
+    // UINT64_MAX, 18446744073709551615, is 20 digits long. It can be faster to
+    // copy a constant number of bytes than a variable number (20 instead of
+    // n). Make buf large enough (and start writing to it from the middle) so
+    // that can we always copy 20 bytes: the slice buf[(20-n) .. (40-n)].
+    uint8_t buf[40] = {0};
+    uint8_t* ptr = &buf[20];
+    do {
+      uint64_t remaining = x / 10;
+      x -= remaining * 10;
+      ptr--;
+      *ptr = (uint8_t)x;
+      n++;
+      x = remaining;
+    } while (x > 0);
+    memcpy(h->digits, ptr, 20);
+  }
+
+  // Set h's other fields.
+  h->num_digits = n;
+  h->decimal_point = (int32_t)n;
+  h->negative = negative;
+  h->truncated = false;
+  wuffs_base__private_implementation__high_prec_dec__trim(h);
+}
+
 static wuffs_base__status  //
 wuffs_base__private_implementation__high_prec_dec__parse(
     wuffs_base__private_implementation__high_prec_dec* h,
@@ -9288,6 +9431,11 @@
 // wuffs_base__private_implementation__high_prec_dec__rounded_integer and
 // wuffs_base__private_implementation__high_prec_dec__lshift_num_new_digits
 // have the same preconditions.
+//
+// wuffs_base__private_implementation__high_prec_dec__lshift keeps the first
+// two preconditions but not the last two. Its shift argument is signed and
+// does not need to be "small": zero is a no-op, positive means left shift and
+// negative means right shift.
 
 static void  //
 wuffs_base__private_implementation__high_prec_dec__small_lshift(
@@ -9401,6 +9549,254 @@
   wuffs_base__private_implementation__high_prec_dec__trim(h);
 }
 
+static void  //
+wuffs_base__private_implementation__high_prec_dec__lshift(
+    wuffs_base__private_implementation__high_prec_dec* h,
+    int32_t shift) {
+  if (shift > 0) {
+    while (shift > +WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {
+      wuffs_base__private_implementation__high_prec_dec__small_lshift(
+          h, WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL);
+      shift -= WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;
+    }
+    wuffs_base__private_implementation__high_prec_dec__small_lshift(
+        h, ((uint32_t)(+shift)));
+  } else if (shift < 0) {
+    while (shift < -WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL) {
+      wuffs_base__private_implementation__high_prec_dec__small_rshift(
+          h, WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL);
+      shift += WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__SHIFT__MAX_INCL;
+    }
+    wuffs_base__private_implementation__high_prec_dec__small_rshift(
+        h, ((uint32_t)(-shift)));
+  }
+}
+
+// --------
+
+// wuffs_base__private_implementation__high_prec_dec__round_etc rounds h's
+// number. For those functions that take an n argument, rounding produces at
+// most n digits (which is not necessarily at most n decimal places). Negative
+// n values are ignored, as well as any n greater than or equal to h's number
+// of digits. The etc__round_just_enough function implicitly chooses an n to
+// implement WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION.
+//
+// Preconditions:
+//  - h is non-NULL.
+//  - h->decimal_point is "not extreme".
+//
+// "Not extreme" means within
+// ±WUFFS_BASE__PRIVATE_IMPLEMENTATION__HPD__DECIMAL_POINT__RANGE.
+
+static void  //
+wuffs_base__private_implementation__high_prec_dec__round_down(
+    wuffs_base__private_implementation__high_prec_dec* h,
+    int32_t n) {
+  if ((n < 0) || (h->num_digits <= (uint32_t)n)) {
+    return;
+  }
+  h->num_digits = (uint32_t)(n);
+  wuffs_base__private_implementation__high_prec_dec__trim(h);
+}
+
+static void  //
+wuffs_base__private_implementation__high_prec_dec__round_up(
+    wuffs_base__private_implementation__high_prec_dec* h,
+    int32_t n) {
+  if ((n < 0) || (h->num_digits <= (uint32_t)n)) {
+    return;
+  }
+
+  for (n--; n >= 0; n--) {
+    if (h->digits[n] < 9) {
+      h->digits[n]++;
+      h->num_digits = (uint32_t)(n + 1);
+      return;
+    }
+  }
+
+  // The number is all 9s. Change to a single 1 and adjust the decimal point.
+  h->digits[0] = 1;
+  h->num_digits = 1;
+  h->decimal_point++;
+}
+
+static void  //
+wuffs_base__private_implementation__high_prec_dec__round_nearest(
+    wuffs_base__private_implementation__high_prec_dec* h,
+    int32_t n) {
+  if ((n < 0) || (h->num_digits <= (uint32_t)n)) {
+    return;
+  }
+  bool up = h->digits[n] >= 5;
+  if ((h->digits[n] == 5) && ((n + 1) == ((int32_t)(h->num_digits)))) {
+    up = h->truncated ||  //
+         ((n > 0) && ((h->digits[n - 1] & 1) != 0));
+  }
+
+  if (up) {
+    wuffs_base__private_implementation__high_prec_dec__round_up(h, n);
+  } else {
+    wuffs_base__private_implementation__high_prec_dec__round_down(h, n);
+  }
+}
+
+static void  //
+wuffs_base__private_implementation__high_prec_dec__round_just_enough(
+    wuffs_base__private_implementation__high_prec_dec* h,
+    int32_t exp2,
+    uint64_t mantissa) {
+  // The magic numbers 52 and 53 in this function are because IEEE 754 double
+  // precision has 52 mantissa bits.
+  //
+  // Let f be the floating point number represented by exp2 and mantissa (and
+  // also the number in h): the number (mantissa * (2 ** (exp2 - 52))).
+  //
+  // If f is zero, we can return early.
+  if (mantissa == 0) {
+    return;
+  }
+
+  // The smallest normal f has an exp2 of -1022 and a mantissa of (1 << 52).
+  // Subnormal numbers have the same exp2 but a smaller mantissa.
+  static const int32_t min_incl_normal_exp2 = -1022;
+  static const uint64_t min_incl_normal_mantissa = 0x0010000000000000ul;
+
+  // Compute lower and upper bounds such that any number between them (possibly
+  // inclusive) will round to f. First, the lower bound. Our number f is:
+  //   ((mantissa + 0)         * (2 ** (  exp2 - 52)))
+  //
+  // The next lowest floating point number is:
+  //   ((mantissa - 1)         * (2 ** (  exp2 - 52)))
+  // unless (mantissa - 1) drops the (1 << 52) bit and exp2 is not the
+  // min_incl_normal_exp2. Either way, call it:
+  //   ((l_mantissa)           * (2 ** (l_exp2 - 52)))
+  //
+  // The lower bound is halfway between them (noting that 52 became 53):
+  //   (((2 * l_mantissa) + 1) * (2 ** (l_exp2 - 53)))
+  int32_t l_exp2 = exp2;
+  uint64_t l_mantissa = mantissa - 1;
+  if ((exp2 > min_incl_normal_exp2) && (mantissa <= min_incl_normal_mantissa)) {
+    l_exp2 = exp2 - 1;
+    l_mantissa = (2 * mantissa) - 1;
+  }
+  wuffs_base__private_implementation__high_prec_dec lower;
+  wuffs_base__private_implementation__high_prec_dec__assign(
+      &lower, (2 * l_mantissa) + 1, false);
+  wuffs_base__private_implementation__high_prec_dec__lshift(&lower,
+                                                            l_exp2 - 53);
+
+  // Next, the upper bound. Our number f is:
+  //   ((mantissa + 0)       * (2 ** (exp2 - 52)))
+  //
+  // The next highest floating point number is:
+  //   ((mantissa + 1)       * (2 ** (exp2 - 52)))
+  //
+  // The upper bound is halfway between them (noting that 52 became 53):
+  //   (((2 * mantissa) + 1) * (2 ** (exp2 - 53)))
+  wuffs_base__private_implementation__high_prec_dec upper;
+  wuffs_base__private_implementation__high_prec_dec__assign(
+      &upper, (2 * mantissa) + 1, false);
+  wuffs_base__private_implementation__high_prec_dec__lshift(&upper, exp2 - 53);
+
+  // The lower and upper bounds are possible outputs only if the original
+  // mantissa is even, so that IEEE round-to-even would round to the original
+  // mantissa and not its neighbors.
+  bool inclusive = (mantissa & 1) == 0;
+
+  // As we walk the digits, we want to know whether rounding up would fall
+  // within the upper bound. This is tracked by upper_delta:
+  //  - When -1, the digits of h and upper are the same so far.
+  //  - When +0, we saw a difference of 1 between h and upper on a previous
+  //    digit and subsequently only 9s for h and 0s for upper. Thus, rounding
+  //    up may fall outside of the bound if !inclusive.
+  //  - When +1, the difference is greater than 1 and we know that rounding up
+  //    falls within the bound.
+  //
+  // This is a state machine with three states. The numerical value for each
+  // state (-1, +0 or +1) isn't important, other than their order.
+  int upper_delta = -1;
+
+  // We can now figure out the shortest number of digits required. Walk the
+  // digits until h has distinguished itself from lower or upper.
+  //
+  // The zi and zd variables are indexes and digits, for z in l (lower), h (the
+  // number) and u (upper).
+  //
+  // The lower, h and upper numbers may have their decimal points at different
+  // places. In this case, upper is the longest, so we iterate ui starting from
+  // 0 and iterate li and hi starting from either 0 or -1.
+  int32_t ui = 0;
+  for (;; ui++) {
+    // Calculate hd, the middle number's digit.
+    int32_t hi = ui - upper.decimal_point + h->decimal_point;
+    if (hi >= ((int32_t)(h->num_digits))) {
+      break;
+    }
+    uint8_t hd = (((uint32_t)hi) < h->num_digits) ? h->digits[hi] : 0;
+
+    // Calculate ld, the lower bound's digit.
+    int32_t li = ui - upper.decimal_point + lower.decimal_point;
+    uint8_t ld = (((uint32_t)li) < lower.num_digits) ? lower.digits[li] : 0;
+
+    // We can round down (truncate) if lower has a different digit than h or if
+    // lower is inclusive and is exactly the result of rounding down (i.e. we
+    // have reached the final digit of lower).
+    bool can_round_down =
+        (ld != hd) ||  //
+        (inclusive && ((li + 1) == ((int32_t)(lower.num_digits))));
+
+    // Calculate ud, the upper bound's digit, and update upper_delta.
+    uint8_t ud = (((uint32_t)ui) < upper.num_digits) ? upper.digits[ui] : 0;
+    if (upper_delta < 0) {
+      if ((hd + 1) < ud) {
+        // For example:
+        // h     = 12345???
+        // upper = 12347???
+        upper_delta = +1;
+      } else if (hd != ud) {
+        // For example:
+        // h     = 12345???
+        // upper = 12346???
+        upper_delta = +0;
+      }
+    } else if (upper_delta == 0) {
+      if ((hd != 9) || (ud != 0)) {
+        // For example:
+        // h     = 1234598?
+        // upper = 1234600?
+        upper_delta = +1;
+      }
+    }
+
+    // We can round up if upper has a different digit than h and either upper
+    // is inclusive or upper is bigger than the result of rounding up.
+    bool can_round_up =
+        (upper_delta > 0) ||    //
+        ((upper_delta == 0) &&  //
+         (inclusive || ((ui + 1) < ((int32_t)(upper.num_digits)))));
+
+    // If we can round either way, round to nearest. If we can round only one
+    // way, do it. If we can't round, continue the loop.
+    if (can_round_down) {
+      if (can_round_up) {
+        wuffs_base__private_implementation__high_prec_dec__round_nearest(
+            h, hi + 1);
+        return;
+      } else {
+        wuffs_base__private_implementation__high_prec_dec__round_down(h,
+                                                                      hi + 1);
+        return;
+      }
+    } else {
+      if (can_round_up) {
+        wuffs_base__private_implementation__high_prec_dec__round_up(h, hi + 1);
+        return;
+      }
+    }
+  }
+}
+
 // --------
 
 // The wuffs_base__private_implementation__etc_powers_of_10 tables were printed
@@ -10087,6 +10483,303 @@
   } while (0);
 }
 
+// --------
+
+static inline size_t  //
+wuffs_base__private_implementation__render_inf(wuffs_base__slice_u8 dst,
+                                               bool neg,
+                                               uint32_t options) {
+  if (neg) {
+    if (dst.len < 4) {
+      return 0;
+    }
+    wuffs_base__store_u32le__no_bounds_check(dst.ptr, 0x666E492D);  // '-Inf'le.
+    return 4;
+  }
+
+  if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {
+    if (dst.len < 4) {
+      return 0;
+    }
+    wuffs_base__store_u32le__no_bounds_check(dst.ptr, 0x666E492B);  // '+Inf'le.
+    return 4;
+  }
+
+  if (dst.len < 3) {
+    return 0;
+  }
+  wuffs_base__store_u24le__no_bounds_check(dst.ptr, 0x666E49);  // 'Inf'le.
+  return 3;
+}
+
+static inline size_t  //
+wuffs_base__private_implementation__render_nan(wuffs_base__slice_u8 dst) {
+  if (dst.len < 3) {
+    return 0;
+  }
+  wuffs_base__store_u24le__no_bounds_check(dst.ptr, 0x4E614E);  // 'NaN'le.
+  return 3;
+}
+
+static size_t  //
+wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(
+    wuffs_base__slice_u8 dst,
+    wuffs_base__private_implementation__high_prec_dec* h,
+    uint32_t precision,
+    uint32_t options) {
+  size_t n = (h->negative ||
+              (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN))
+                 ? 1
+                 : 0;
+  if (h->decimal_point <= 0) {
+    n += 1;
+  } else {
+    n += (size_t)(h->decimal_point);
+  }
+  if (precision > 0) {
+    n += precision + 1;  // +1 for the '.'.
+  }
+
+  // Don't modify dst if the formatted number won't fit.
+  if (n > dst.len) {
+    return 0;
+  }
+
+  // Align-left or align-right.
+  uint8_t* ptr = (options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)
+                     ? &dst.ptr[dst.len - n]
+                     : &dst.ptr[0];
+
+  // Leading "±".
+  if (h->negative) {
+    *ptr++ = '-';
+  } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {
+    *ptr++ = '+';
+  }
+
+  // Integral digits.
+  if (h->decimal_point <= 0) {
+    *ptr++ = '0';
+  } else {
+    uint32_t m =
+        wuffs_base__u32__min(h->num_digits, (uint32_t)(h->decimal_point));
+    uint32_t i = 0;
+    for (; i < m; i++) {
+      *ptr++ = (uint8_t)('0' | h->digits[i]);
+    }
+    for (; i < (uint32_t)(h->decimal_point); i++) {
+      *ptr++ = '0';
+    }
+  }
+
+  // Separator and then fractional digits.
+  if (precision > 0) {
+    *ptr++ =
+        (options & WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)
+            ? ','
+            : '.';
+    uint32_t i = 0;
+    for (; i < precision; i++) {
+      uint32_t j = ((uint32_t)(h->decimal_point)) + i;
+      *ptr++ = (uint8_t)('0' | ((j < h->num_digits) ? h->digits[j] : 0));
+    }
+  }
+
+  return n;
+}
+
+static size_t  //
+wuffs_base__private_implementation__high_prec_dec__render_exponent_present(
+    wuffs_base__slice_u8 dst,
+    wuffs_base__private_implementation__high_prec_dec* h,
+    uint32_t precision,
+    uint32_t options) {
+  int32_t exp = 0;
+  if (h->num_digits > 0) {
+    exp = h->decimal_point - 1;
+  }
+  bool negative_exp = exp < 0;
+  if (negative_exp) {
+    exp = -exp;
+  }
+
+  size_t n = (h->negative ||
+              (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN))
+                 ? 4
+                 : 3;  // Mininum 3 bytes: first digit and then "e±".
+  if (precision > 0) {
+    n += precision + 1;  // +1 for the '.'.
+  }
+  n += (exp < 100) ? 2 : 3;
+
+  // Don't modify dst if the formatted number won't fit.
+  if (n > dst.len) {
+    return 0;
+  }
+
+  // Align-left or align-right.
+  uint8_t* ptr = (options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)
+                     ? &dst.ptr[dst.len - n]
+                     : &dst.ptr[0];
+
+  // Leading "±".
+  if (h->negative) {
+    *ptr++ = '-';
+  } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {
+    *ptr++ = '+';
+  }
+
+  // Integral digit.
+  if (h->num_digits > 0) {
+    *ptr++ = (uint8_t)('0' | h->digits[0]);
+  } else {
+    *ptr++ = '0';
+  }
+
+  // Separator and then fractional digits.
+  if (precision > 0) {
+    *ptr++ =
+        (options & WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA)
+            ? ','
+            : '.';
+    uint32_t i = 1;
+    uint32_t j = wuffs_base__u32__min(h->num_digits, precision + 1);
+    for (; i < j; i++) {
+      *ptr++ = (uint8_t)('0' | h->digits[i]);
+    }
+    for (; i <= precision; i++) {
+      *ptr++ = '0';
+    }
+  }
+
+  // Exponent: "e±" and then 2 or 3 digits.
+  *ptr++ = 'e';
+  *ptr++ = negative_exp ? '-' : '+';
+  if (exp < 10) {
+    *ptr++ = '0';
+    *ptr++ = (uint8_t)('0' | exp);
+  } else if (exp < 100) {
+    *ptr++ = (uint8_t)('0' | (exp / 10));
+    *ptr++ = (uint8_t)('0' | (exp % 10));
+  } else {
+    int32_t e = exp / 100;
+    exp -= e * 100;
+    *ptr++ = (uint8_t)('0' | e);
+    *ptr++ = (uint8_t)('0' | (exp / 10));
+    *ptr++ = (uint8_t)('0' | (exp % 10));
+  }
+
+  return n;
+}
+
+WUFFS_BASE__MAYBE_STATIC size_t  //
+wuffs_base__render_number_f64(wuffs_base__slice_u8 dst,
+                              double x,
+                              uint32_t precision,
+                              uint32_t options) {
+  // Decompose x (64 bits) into negativity (1 bit), base-2 exponent (11 bits
+  // with a -1023 bias) and mantissa (52 bits).
+  uint64_t bits = wuffs_base__ieee_754_bit_representation__from_f64(x);
+  bool neg = (bits >> 63) != 0;
+  int32_t exp2 = ((int32_t)(bits >> 52)) & 0x7FF;
+  uint64_t man = bits & 0x000FFFFFFFFFFFFFul;
+
+  // Apply the exponent bias and set the implicit top bit of the mantissa,
+  // unless x is subnormal. Also take care of Inf and NaN.
+  if (exp2 == 0x7FF) {
+    if (man != 0) {
+      return wuffs_base__private_implementation__render_nan(dst);
+    }
+    return wuffs_base__private_implementation__render_inf(dst, neg, options);
+  } else if (exp2 == 0) {
+    exp2 = -1022;
+  } else {
+    exp2 -= 1023;
+    man |= 0x0010000000000000ul;
+  }
+
+  // Ensure that precision isn't too large.
+  if (precision > 4095) {
+    precision = 4095;
+  }
+
+  // Convert from the (neg, exp2, man) tuple to an HPD.
+  wuffs_base__private_implementation__high_prec_dec h;
+  wuffs_base__private_implementation__high_prec_dec__assign(&h, man, neg);
+  if (h.num_digits > 0) {
+    wuffs_base__private_implementation__high_prec_dec__lshift(
+        &h, exp2 - 52);  // 52 mantissa bits.
+  }
+
+  // Handle the "%e" and "%f" formats.
+  switch (options & (WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT |
+                     WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT)) {
+    case WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT:  // The "%"f" format.
+      if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {
+        wuffs_base__private_implementation__high_prec_dec__round_just_enough(
+            &h, exp2, man);
+        int32_t p = ((int32_t)(h.num_digits)) - h.decimal_point;
+        precision = ((uint32_t)(wuffs_base__i32__max(0, p)));
+      } else {
+        wuffs_base__private_implementation__high_prec_dec__round_nearest(
+            &h, ((int32_t)precision) + h.decimal_point);
+      }
+      return wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(
+          dst, &h, precision, options);
+
+    case WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT:  // The "%e" format.
+      if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {
+        wuffs_base__private_implementation__high_prec_dec__round_just_enough(
+            &h, exp2, man);
+        precision = (h.num_digits > 0) ? (h.num_digits - 1) : 0;
+      } else {
+        wuffs_base__private_implementation__high_prec_dec__round_nearest(
+            &h, ((int32_t)precision) + 1);
+      }
+      return wuffs_base__private_implementation__high_prec_dec__render_exponent_present(
+          dst, &h, precision, options);
+  }
+
+  // We have the "%g" format and so precision means the number of significant
+  // digits, not the number of digits after the decimal separator. Perform
+  // rounding and determine whether to use "%e" or "%f".
+  int32_t e_threshold = 0;
+  if (options & WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION) {
+    wuffs_base__private_implementation__high_prec_dec__round_just_enough(
+        &h, exp2, man);
+    precision = h.num_digits;
+    e_threshold = 6;
+  } else {
+    if (precision == 0) {
+      precision = 1;
+    }
+    wuffs_base__private_implementation__high_prec_dec__round_nearest(
+        &h, ((int32_t)precision));
+    e_threshold = ((int32_t)precision);
+    int32_t nd = ((int32_t)(h.num_digits));
+    if ((e_threshold > nd) && (nd >= h.decimal_point)) {
+      e_threshold = nd;
+    }
+  }
+
+  // Use the "%e" format if the exponent is large.
+  int32_t e = h.decimal_point - 1;
+  if ((e < -4) || (e_threshold <= e)) {
+    uint32_t p = wuffs_base__u32__min(precision, h.num_digits);
+    return wuffs_base__private_implementation__high_prec_dec__render_exponent_present(
+        dst, &h, (p > 0) ? (p - 1) : 0, options);
+  }
+
+  // Use the "%f" format otherwise.
+  int32_t p = ((int32_t)precision);
+  if (p > h.decimal_point) {
+    p = ((int32_t)(h.num_digits));
+  }
+  precision = ((uint32_t)(wuffs_base__i32__max(0, p - h.decimal_point)));
+  return wuffs_base__private_implementation__high_prec_dec__render_exponent_absent(
+      dst, &h, precision, options);
+}
+
 #endif  // !defined(WUFFS_CONFIG__MODULES) ||
         // defined(WUFFS_CONFIG__MODULE__BASE) ||
         // defined(WUFFS_CONFIG__MODULE__BASE__F64CONV)
@@ -10439,7 +11132,7 @@
   if (neg) {
     ptr -= 1;
     ptr[0] = '-';
-  } else if (options & WUFFS_BASE__RENDER_NUMBER__LEADING_PLUS_SIGN) {
+  } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {
     ptr -= 1;
     ptr[0] = '+';
   }
@@ -10448,7 +11141,7 @@
   if (n > dst.len) {
     return 0;
   }
-  memcpy(dst.ptr + ((options & WUFFS_BASE__RENDER_NUMBER__ALIGN_RIGHT)
+  memcpy(dst.ptr + ((options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)
                         ? (dst.len - n)
                         : 0),
          ptr, n);
diff --git a/script/print-render-number-f64-tests.go b/script/print-render-number-f64-tests.go
new file mode 100644
index 0000000..b4aec2b
--- /dev/null
+++ b/script/print-render-number-f64-tests.go
@@ -0,0 +1,176 @@
+// Copyright 2020 The Wuffs Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build ignore
+
+package main
+
+// print-render-number-f64-tests.go prints the
+// test_wuffs_strconv_render_number_f64 test cases.
+//
+// Usage: go run print-render-number-f64-tests.go
+
+import (
+	"fmt"
+	"math"
+	"os"
+	"sort"
+	"strconv"
+)
+
+func main() {
+	if err := main1(); err != nil {
+		os.Stderr.WriteString(err.Error() + "\n")
+		os.Exit(1)
+	}
+}
+
+func main1() error {
+	testCases := append([]uint64(nil), u64TestCases...)
+	for _, f := range f64TestCases {
+		testCases = append(testCases, math.Float64bits(f))
+	}
+
+	sort.Slice(testCases, func(i int, j int) bool {
+		return testCases[i] < testCases[j]
+	})
+
+	for i, tc := range testCases {
+		f := math.Float64frombits(tc)
+
+		if (i > 0) && (tc == testCases[i-1]) {
+			return fmt.Errorf("duplicate test case (f=%g, tc=0x%X)", f, tc)
+		}
+
+		// Check that calling strconv.FormatFloat with a precision of -1 (round
+		// to shortest) does indeed return a string that, when parsed, recovers
+		// the original number.
+		shortest := strconv.FormatFloat(f, 'g', -1, 64)
+		g, err := strconv.ParseFloat(shortest, 64)
+		if err != nil {
+			return fmt.Errorf("ParseFloat failed (f=%g, tc=0x%X): %v", f, tc, err)
+		}
+		equal := tc == math.Float64bits(g)
+		if math.IsNaN(f) {
+			equal = math.IsNaN(g)
+		}
+		if !equal {
+			return fmt.Errorf("round-trip failed (f=%g, tc=0x%X)", f, tc)
+		}
+	}
+
+	for _, tc := range testCases {
+		f := math.Float64frombits(tc)
+		fmt.Printf(`{
+	.x = 0x%016X,
+	.want__e = %s,
+	.want__f = %s,
+	.want_0g = %s,
+	.want_2e = %s,
+	.want_3f = %s,
+	.want_4g = %s,
+},`+"\n",
+			tc,
+			do(f, -1, 'e'),
+			do(f, -1, 'f'),
+			do(f, +0, 'g'),
+			do(f, +2, 'e'),
+			do(f, +3, 'f'),
+			do(f, +4, 'g'),
+		)
+	}
+	return nil
+}
+
+func do(f float64, precision int, format byte) (ret string) {
+	s := strconv.FormatFloat(f, format, precision, 64)
+	for ; len(s) > 50; s = s[50:] {
+		ret += fmt.Sprintf("%q\n\t\t", s[:50])
+	}
+	ret += fmt.Sprintf("%q", s)
+	if ret == `"+Inf"` {
+		ret = `"Inf"`
+	}
+	return ret
+}
+
+var f64TestCases = []float64{
+	// Approximations of e, the base of the natural logarithm.
+	2.7,
+	2.72,
+	2.718,
+	2.7183,
+	2.71828,
+	2.718282,
+	2.7182818,
+	2.71828183,
+
+	// Approximations of N_A, the Avogadro constant.
+	6.0e23,
+	6.02e23,
+	6.022e23,
+	6.0221e23,
+	6.02214e23,
+	6.022141e23,
+	6.0221408e23,
+	6.02214076e23,
+}
+
+var u64TestCases = []uint64{
+	0x0000000000000000,
+	0x0000000000000001,
+	0x0000000000000002,
+	0x0000000000000003,
+	0x000FFFFFFFFFFFFF,
+	0x0010000000000000,
+	0x369C314ABE948EB1,
+	0x3F88000000000000,
+	0x3FD0000000000000,
+	0x3FD3333333333333,
+	0x3FD3333333333334,
+	0x3FD5555555555555,
+	0x3FEFFFFFFFFFFFFF,
+	0x3FF0000000000000,
+	0x3FF0000000000001,
+	0x3FF0000000000002,
+	0x3FF4000000000000,
+	0x3FF8000000000000,
+	0x4008000000000000,
+	0x400921F9F01B866E,
+	0x400921FB54442D11,
+	0x400921FB54442D18,
+	0x400C000000000000,
+	0x4014000000000000,
+	0x4036000000000000,
+	0x4037000000000000,
+	0x4038000000000000,
+	0x40FE240C9FCB0C02,
+	0x4202A05F20000000,
+	0x4330000000000000,
+	0x4330000000000001,
+	0x4330000000000002,
+	0x4340000000000000,
+	0x4340000000000001,
+	0x4340000000000002,
+	0x4415AF1D78B58C40,
+	0x46293E5939A08CEA,
+	0x54B249AD2594C37D,
+	0x7FEFFFFFFFFFFFFF,
+	0x7FF0000000000000,
+	0x7FFFFFFFFFFFFFFF,
+	0x8000000000000000,
+	0xC008000000000000,
+	0xFFF0000000000000,
+	0xFFFFFFFFFFFFFFFF,
+}
diff --git a/test/c/std/json.c b/test/c/std/json.c
index bb5d967..4bd4834 100644
--- a/test/c/std/json.c
+++ b/test/c/std/json.c
@@ -607,11 +607,16 @@
     uint64_t want;
     const char* str;
   } test_cases[] = {
+      // If adding new cases, consider updating u64TestCases in
+      // script/print-render-number-f64-tests.go
+
       {.want = 0x0000000000000000, .str = "+0.0"},
       {.want = 0x0000000000000000, .str = "0"},
       {.want = 0x0000000000000000, .str = "0e0"},
       {.want = 0x0000000000000000, .str = "1e-332"},
       {.want = 0x0000000000000001, .str = "4.9406564584124654e-324"},
+      {.want = 0x0000000000000002, .str = "9.8813129168249309e-324"},
+      {.want = 0x0000000000000003, .str = "1.4821969375237396e-323"},
       {.want = 0x000FFFFFFFFFFFFF, .str = "2.2250738585072009E-308"},
       {.want = 0x0010000000000000, .str = "2.2250738585072014E-308"},
       {.want = 0x369C314ABE948EB1,
@@ -679,6 +684,9 @@
       {.want = 0xFFF0000000000000, .str = "-inf"},
       {.want = 0xFFFFFFFFFFFFFFFF, .str = "-NAN"},
 
+      // If adding new cases, consider updating u64TestCases in
+      // script/print-render-number-f64-tests.go
+
       // We accept either ',' or '.'.
       {.want = 0x3FFC000000000000, .str = "1,75"},
       {.want = 0x3FFC000000000000, .str = "1.75"},
@@ -859,6 +867,702 @@
 }
 
 const char*  //
+test_wuffs_strconv_render_number_f64() {
+  CHECK_FOCUS(__func__);
+
+  struct {
+    uint64_t x;
+    // These want strings come from Go's strconv.FormatFloat.
+    const char* want__e;  // FormatFloat(etc, 'e', -1, etc)
+    const char* want__f;  // FormatFloat(etc, 'f', -1, etc)
+    const char* want_0g;  // FormatFloat(etc, 'g', +0, etc)
+    const char* want_2e;  // FormatFloat(etc, 'e', +2, etc)
+    const char* want_3f;  // FormatFloat(etc, 'f', +3, etc)
+    const char* want_4g;  // FormatFloat(etc, 'g', +4, etc)
+  } test_cases[] = {
+      // These test cases were generated by
+      // script/print-render-number-f64-tests.go
+
+      {
+          .x = 0x0000000000000000,
+          .want__e = "0e+00",
+          .want__f = "0",
+          .want_0g = "0",
+          .want_2e = "0.00e+00",
+          .want_3f = "0.000",
+          .want_4g = "0",
+      },
+      {
+          .x = 0x0000000000000001,
+          .want__e = "5e-324",
+          .want__f = "0.000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000005",
+          .want_0g = "5e-324",
+          .want_2e = "4.94e-324",
+          .want_3f = "0.000",
+          .want_4g = "4.941e-324",
+      },
+      {
+          .x = 0x0000000000000002,
+          .want__e = "1e-323",
+          .want__f = "0.000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "0000000000000000000000001",
+          .want_0g = "1e-323",
+          .want_2e = "9.88e-324",
+          .want_3f = "0.000",
+          .want_4g = "9.881e-324",
+      },
+      {
+          .x = 0x0000000000000003,
+          .want__e = "1.5e-323",
+          .want__f = "0.000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000015",
+          .want_0g = "1e-323",
+          .want_2e = "1.48e-323",
+          .want_3f = "0.000",
+          .want_4g = "1.482e-323",
+      },
+      {
+          .x = 0x000FFFFFFFFFFFFF,
+          .want__e = "2.225073858507201e-308",
+          .want__f = "0.000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "0000000002225073858507201",
+          .want_0g = "2e-308",
+          .want_2e = "2.23e-308",
+          .want_3f = "0.000",
+          .want_4g = "2.225e-308",
+      },
+      {
+          .x = 0x0010000000000000,
+          .want__e = "2.2250738585072014e-308",
+          .want__f = "0.000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000022250738585072014",
+          .want_0g = "2e-308",
+          .want_2e = "2.23e-308",
+          .want_3f = "0.000",
+          .want_4g = "2.225e-308",
+      },
+      {
+          .x = 0x369C314ABE948EB1,
+          .want__e = "1.23456789e-45",
+          .want__f = "0.000000000000000000000000000000000000000000001234"
+                     "56789",
+          .want_0g = "1e-45",
+          .want_2e = "1.23e-45",
+          .want_3f = "0.000",
+          .want_4g = "1.235e-45",
+      },
+      {
+          .x = 0x3F88000000000000,
+          .want__e = "1.171875e-02",
+          .want__f = "0.01171875",
+          .want_0g = "0.01",
+          .want_2e = "1.17e-02",
+          .want_3f = "0.012",
+          .want_4g = "0.01172",
+      },
+      {
+          .x = 0x3FD0000000000000,
+          .want__e = "2.5e-01",
+          .want__f = "0.25",
+          .want_0g = "0.2",
+          .want_2e = "2.50e-01",
+          .want_3f = "0.250",
+          .want_4g = "0.25",
+      },
+      {
+          .x = 0x3FD3333333333333,
+          .want__e = "3e-01",
+          .want__f = "0.3",
+          .want_0g = "0.3",
+          .want_2e = "3.00e-01",
+          .want_3f = "0.300",
+          .want_4g = "0.3",
+      },
+      {
+          .x = 0x3FD3333333333334,
+          .want__e = "3.0000000000000004e-01",
+          .want__f = "0.30000000000000004",
+          .want_0g = "0.3",
+          .want_2e = "3.00e-01",
+          .want_3f = "0.300",
+          .want_4g = "0.3",
+      },
+      {
+          .x = 0x3FD5555555555555,
+          .want__e = "3.333333333333333e-01",
+          .want__f = "0.3333333333333333",
+          .want_0g = "0.3",
+          .want_2e = "3.33e-01",
+          .want_3f = "0.333",
+          .want_4g = "0.3333",
+      },
+      {
+          .x = 0x3FEFFFFFFFFFFFFF,
+          .want__e = "9.999999999999999e-01",
+          .want__f = "0.9999999999999999",
+          .want_0g = "1",
+          .want_2e = "1.00e+00",
+          .want_3f = "1.000",
+          .want_4g = "1",
+      },
+      {
+          .x = 0x3FF0000000000000,
+          .want__e = "1e+00",
+          .want__f = "1",
+          .want_0g = "1",
+          .want_2e = "1.00e+00",
+          .want_3f = "1.000",
+          .want_4g = "1",
+      },
+      {
+          .x = 0x3FF0000000000001,
+          .want__e = "1.0000000000000002e+00",
+          .want__f = "1.0000000000000002",
+          .want_0g = "1",
+          .want_2e = "1.00e+00",
+          .want_3f = "1.000",
+          .want_4g = "1",
+      },
+      {
+          .x = 0x3FF0000000000002,
+          .want__e = "1.0000000000000004e+00",
+          .want__f = "1.0000000000000004",
+          .want_0g = "1",
+          .want_2e = "1.00e+00",
+          .want_3f = "1.000",
+          .want_4g = "1",
+      },
+      {
+          .x = 0x3FF4000000000000,
+          .want__e = "1.25e+00",
+          .want__f = "1.25",
+          .want_0g = "1",
+          .want_2e = "1.25e+00",
+          .want_3f = "1.250",
+          .want_4g = "1.25",
+      },
+      {
+          .x = 0x3FF8000000000000,
+          .want__e = "1.5e+00",
+          .want__f = "1.5",
+          .want_0g = "2",
+          .want_2e = "1.50e+00",
+          .want_3f = "1.500",
+          .want_4g = "1.5",
+      },
+      {
+          .x = 0x400599999999999A,
+          .want__e = "2.7e+00",
+          .want__f = "2.7",
+          .want_0g = "3",
+          .want_2e = "2.70e+00",
+          .want_3f = "2.700",
+          .want_4g = "2.7",
+      },
+      {
+          .x = 0x4005BE76C8B43958,
+          .want__e = "2.718e+00",
+          .want__f = "2.718",
+          .want_0g = "3",
+          .want_2e = "2.72e+00",
+          .want_3f = "2.718",
+          .want_4g = "2.718",
+      },
+      {
+          .x = 0x4005BF0995AAF790,
+          .want__e = "2.71828e+00",
+          .want__f = "2.71828",
+          .want_0g = "3",
+          .want_2e = "2.72e+00",
+          .want_3f = "2.718",
+          .want_4g = "2.718",
+      },
+      {
+          .x = 0x4005BF0A87427F01,
+          .want__e = "2.7182818e+00",
+          .want__f = "2.7182818",
+          .want_0g = "3",
+          .want_2e = "2.72e+00",
+          .want_3f = "2.718",
+          .want_4g = "2.718",
+      },
+      {
+          .x = 0x4005BF0A8B4949CB,
+          .want__e = "2.71828183e+00",
+          .want__f = "2.71828183",
+          .want_0g = "3",
+          .want_2e = "2.72e+00",
+          .want_3f = "2.718",
+          .want_4g = "2.718",
+      },
+      {
+          .x = 0x4005BF0AA21A719B,
+          .want__e = "2.718282e+00",
+          .want__f = "2.718282",
+          .want_0g = "3",
+          .want_2e = "2.72e+00",
+          .want_3f = "2.718",
+          .want_4g = "2.718",
+      },
+      {
+          .x = 0x4005BF141205BC02,
+          .want__e = "2.7183e+00",
+          .want__f = "2.7183",
+          .want_0g = "3",
+          .want_2e = "2.72e+00",
+          .want_3f = "2.718",
+          .want_4g = "2.718",
+      },
+      {
+          .x = 0x4005C28F5C28F5C3,
+          .want__e = "2.72e+00",
+          .want__f = "2.72",
+          .want_0g = "3",
+          .want_2e = "2.72e+00",
+          .want_3f = "2.720",
+          .want_4g = "2.72",
+      },
+      {
+          .x = 0x4008000000000000,
+          .want__e = "3e+00",
+          .want__f = "3",
+          .want_0g = "3",
+          .want_2e = "3.00e+00",
+          .want_3f = "3.000",
+          .want_4g = "3",
+      },
+      {
+          .x = 0x400921F9F01B866E,
+          .want__e = "3.14159e+00",
+          .want__f = "3.14159",
+          .want_0g = "3",
+          .want_2e = "3.14e+00",
+          .want_3f = "3.142",
+          .want_4g = "3.142",
+      },
+      {
+          .x = 0x400921FB54442D11,
+          .want__e = "3.14159265358979e+00",
+          .want__f = "3.14159265358979",
+          .want_0g = "3",
+          .want_2e = "3.14e+00",
+          .want_3f = "3.142",
+          .want_4g = "3.142",
+      },
+      {
+          .x = 0x400921FB54442D18,
+          .want__e = "3.141592653589793e+00",
+          .want__f = "3.141592653589793",
+          .want_0g = "3",
+          .want_2e = "3.14e+00",
+          .want_3f = "3.142",
+          .want_4g = "3.142",
+      },
+      {
+          .x = 0x400C000000000000,
+          .want__e = "3.5e+00",
+          .want__f = "3.5",
+          .want_0g = "4",
+          .want_2e = "3.50e+00",
+          .want_3f = "3.500",
+          .want_4g = "3.5",
+      },
+      {
+          .x = 0x4014000000000000,
+          .want__e = "5e+00",
+          .want__f = "5",
+          .want_0g = "5",
+          .want_2e = "5.00e+00",
+          .want_3f = "5.000",
+          .want_4g = "5",
+      },
+      {
+          .x = 0x4036000000000000,
+          .want__e = "2.2e+01",
+          .want__f = "22",
+          .want_0g = "2e+01",
+          .want_2e = "2.20e+01",
+          .want_3f = "22.000",
+          .want_4g = "22",
+      },
+      {
+          .x = 0x4037000000000000,
+          .want__e = "2.3e+01",
+          .want__f = "23",
+          .want_0g = "2e+01",
+          .want_2e = "2.30e+01",
+          .want_3f = "23.000",
+          .want_4g = "23",
+      },
+      {
+          .x = 0x4038000000000000,
+          .want__e = "2.4e+01",
+          .want__f = "24",
+          .want_0g = "2e+01",
+          .want_2e = "2.40e+01",
+          .want_3f = "24.000",
+          .want_4g = "24",
+      },
+      {
+          .x = 0x40FE240C9FCB0C02,
+          .want__e = "1.23456789012e+05",
+          .want__f = "123456.789012",
+          .want_0g = "1e+05",
+          .want_2e = "1.23e+05",
+          .want_3f = "123456.789",
+          .want_4g = "1.235e+05",
+      },
+      {
+          .x = 0x4202A05F20000000,
+          .want__e = "1e+10",
+          .want__f = "10000000000",
+          .want_0g = "1e+10",
+          .want_2e = "1.00e+10",
+          .want_3f = "10000000000.000",
+          .want_4g = "1e+10",
+      },
+      {
+          .x = 0x4330000000000000,
+          .want__e = "4.503599627370496e+15",
+          .want__f = "4503599627370496",
+          .want_0g = "5e+15",
+          .want_2e = "4.50e+15",
+          .want_3f = "4503599627370496.000",
+          .want_4g = "4.504e+15",
+      },
+      {
+          .x = 0x4330000000000001,
+          .want__e = "4.503599627370497e+15",
+          .want__f = "4503599627370497",
+          .want_0g = "5e+15",
+          .want_2e = "4.50e+15",
+          .want_3f = "4503599627370497.000",
+          .want_4g = "4.504e+15",
+      },
+      {
+          .x = 0x4330000000000002,
+          .want__e = "4.503599627370498e+15",
+          .want__f = "4503599627370498",
+          .want_0g = "5e+15",
+          .want_2e = "4.50e+15",
+          .want_3f = "4503599627370498.000",
+          .want_4g = "4.504e+15",
+      },
+      {
+          .x = 0x4340000000000000,
+          .want__e = "9.007199254740992e+15",
+          .want__f = "9007199254740992",
+          .want_0g = "9e+15",
+          .want_2e = "9.01e+15",
+          .want_3f = "9007199254740992.000",
+          .want_4g = "9.007e+15",
+      },
+      {
+          .x = 0x4340000000000001,
+          .want__e = "9.007199254740994e+15",
+          .want__f = "9007199254740994",
+          .want_0g = "9e+15",
+          .want_2e = "9.01e+15",
+          .want_3f = "9007199254740994.000",
+          .want_4g = "9.007e+15",
+      },
+      {
+          .x = 0x4340000000000002,
+          .want__e = "9.007199254740996e+15",
+          .want__f = "9007199254740996",
+          .want_0g = "9e+15",
+          .want_2e = "9.01e+15",
+          .want_3f = "9007199254740996.000",
+          .want_4g = "9.007e+15",
+      },
+      {
+          .x = 0x4415AF1D78B58C40,
+          .want__e = "1e+20",
+          .want__f = "100000000000000000000",
+          .want_0g = "1e+20",
+          .want_2e = "1.00e+20",
+          .want_3f = "100000000000000000000.000",
+          .want_4g = "1e+20",
+      },
+      {
+          .x = 0x44DFC3842BD1F072,
+          .want__e = "6e+23",
+          .want__f = "600000000000000000000000",
+          .want_0g = "6e+23",
+          .want_2e = "6.00e+23",
+          .want_3f = "600000000000000016777216.000",
+          .want_4g = "6e+23",
+      },
+      {
+          .x = 0x44DFDE9F10A8D361,
+          .want__e = "6.02e+23",
+          .want__f = "602000000000000000000000",
+          .want_0g = "6e+23",
+          .want_2e = "6.02e+23",
+          .want_3f = "601999999999999995805696.000",
+          .want_4g = "6.02e+23",
+      },
+      {
+          .x = 0x44DFE154F457EA13,
+          .want__e = "6.022e+23",
+          .want__f = "602200000000000000000000",
+          .want_0g = "6e+23",
+          .want_2e = "6.02e+23",
+          .want_3f = "602200000000000027262976.000",
+          .want_4g = "6.022e+23",
+      },
+      {
+          .x = 0x44DFE177A620AB35,
+          .want__e = "6.0221e+23",
+          .want__f = "602210000000000000000000",
+          .want_0g = "6e+23",
+          .want_2e = "6.02e+23",
+          .want_3f = "602209999999999995281408.000",
+          .want_4g = "6.022e+23",
+      },
+      {
+          .x = 0x44DFE18586D75EDC,
+          .want__e = "6.02214e+23",
+          .want__f = "602214000000000000000000",
+          .want_0g = "6e+23",
+          .want_2e = "6.02e+23",
+          .want_3f = "602213999999999969067008.000",
+          .want_4g = "6.022e+23",
+      },
+      {
+          .x = 0x44DFE185CA57C517,
+          .want__e = "6.02214076e+23",
+          .want__f = "602214076000000000000000",
+          .want_0g = "6e+23",
+          .want_2e = "6.02e+23",
+          .want_3f = "602214075999999987023872.000",
+          .want_4g = "6.022e+23",
+      },
+      {
+          .x = 0x44DFE185CDE543BC,
+          .want__e = "6.0221408e+23",
+          .want__f = "602214080000000000000000",
+          .want_0g = "6e+23",
+          .want_2e = "6.02e+23",
+          .want_3f = "602214080000000002097152.000",
+          .want_4g = "6.022e+23",
+      },
+      {
+          .x = 0x44DFE185DFA8BCF4,
+          .want__e = "6.022141e+23",
+          .want__f = "602214100000000000000000",
+          .want_0g = "6e+23",
+          .want_2e = "6.02e+23",
+          .want_3f = "602214100000000010354688.000",
+          .want_4g = "6.022e+23",
+      },
+      {
+          .x = 0x46293E5939A08CEA,
+          .want__e = "1e+30",
+          .want__f = "1000000000000000000000000000000",
+          .want_0g = "1e+30",
+          .want_2e = "1.00e+30",
+          .want_3f = "1000000000000000019884624838656.000",
+          .want_4g = "1e+30",
+      },
+      {
+          .x = 0x54B249AD2594C37D,
+          .want__e = "1e+100",
+          .want__f = "10000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "0",
+          .want_0g = "1e+100",
+          .want_2e = "1.00e+100",
+          .want_3f = "10000000000000000159028911097599180468360808563945"
+                     "28138978132755774783877217038106081346998585681510"
+                     "4.000",
+          .want_4g = "1e+100",
+      },
+      {
+          .x = 0x7FEFFFFFFFFFFFFF,
+          .want__e = "1.7976931348623157e+308",
+          .want__f = "17976931348623157000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "00000000000000000000000000000000000000000000000000"
+                     "000000000",
+          .want_0g = "2e+308",
+          .want_2e = "1.80e+308",
+          .want_3f = "17976931348623157081452742373170435679807056752584"
+                     "49965989174768031572607800285387605895586327668781"
+                     "71540458953514382464234321326889464182768467546703"
+                     "53751698604991057655128207624549009038932894407586"
+                     "85084551339423045832369032229481658085593321233482"
+                     "74797826204144723168738177180919299881250404026184"
+                     "124858368.000",
+          .want_4g = "1.798e+308",
+      },
+      {
+          .x = 0x7FF0000000000000,
+          .want__e = "Inf",
+          .want__f = "Inf",
+          .want_0g = "Inf",
+          .want_2e = "Inf",
+          .want_3f = "Inf",
+          .want_4g = "Inf",
+      },
+      {
+          .x = 0x7FFFFFFFFFFFFFFF,
+          .want__e = "NaN",
+          .want__f = "NaN",
+          .want_0g = "NaN",
+          .want_2e = "NaN",
+          .want_3f = "NaN",
+          .want_4g = "NaN",
+      },
+      {
+          .x = 0x8000000000000000,
+          .want__e = "-0e+00",
+          .want__f = "-0",
+          .want_0g = "-0",
+          .want_2e = "-0.00e+00",
+          .want_3f = "-0.000",
+          .want_4g = "-0",
+      },
+      {
+          .x = 0xC008000000000000,
+          .want__e = "-3e+00",
+          .want__f = "-3",
+          .want_0g = "-3",
+          .want_2e = "-3.00e+00",
+          .want_3f = "-3.000",
+          .want_4g = "-3",
+      },
+      {
+          .x = 0xFFF0000000000000,
+          .want__e = "-Inf",
+          .want__f = "-Inf",
+          .want_0g = "-Inf",
+          .want_2e = "-Inf",
+          .want_3f = "-Inf",
+          .want_4g = "-Inf",
+      },
+      {
+          .x = 0xFFFFFFFFFFFFFFFF,
+          .want__e = "NaN",
+          .want__f = "NaN",
+          .want_0g = "NaN",
+          .want_2e = "NaN",
+          .want_3f = "NaN",
+          .want_4g = "NaN",
+      },
+  };
+
+  int tc;
+  for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
+    double f64 =
+        wuffs_base__ieee_754_bit_representation__to_f64(test_cases[tc].x);
+    int o;
+    for (o = 0; o < 6; o++) {
+      uint32_t precision = 0;
+      uint32_t options = 0;
+      const char* want = NULL;
+      if (o == 0) {
+        options = WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT |
+                  WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION;
+        want = test_cases[tc].want__e;
+      } else if (o == 1) {
+        options = WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT |
+                  WUFFS_BASE__RENDER_NUMBER_FXX__JUST_ENOUGH_PRECISION;
+        want = test_cases[tc].want__f;
+      } else if (o == 2) {
+        precision = 0;
+        options = 0;
+        want = test_cases[tc].want_0g;
+      } else if (o == 3) {
+        precision = 2;
+        options = WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_PRESENT;
+        want = test_cases[tc].want_2e;
+      } else if (o == 4) {
+        precision = 3;
+        options = WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT;
+        want = test_cases[tc].want_3f;
+      } else if (o == 5) {
+        precision = 4;
+        options = 0;
+        want = test_cases[tc].want_4g;
+      }
+
+      size_t n = wuffs_base__render_number_f64(g_have_slice_u8, f64, precision,
+                                               options);
+      if (n == 0) {
+        RETURN_FAIL("x=0x%016" PRIX64 ", o=%d: could not render",
+                    test_cases[tc].x, o);
+      } else if (n >= g_have_slice_u8.len) {
+        RETURN_FAIL("x=0x%016" PRIX64 ", o=%d: n is too large",
+                    test_cases[tc].x, o);
+      }
+      g_have_slice_u8.ptr[n] = 0x00;
+      if (strcmp((const char*)(g_have_slice_u8.ptr), want) != 0) {
+        RETURN_FAIL("x=0x%016" PRIX64 ", o=%d: have \"%s\", want \"%s\"",
+                    test_cases[tc].x, o, g_have_slice_u8.ptr, want);
+      }
+    }
+  }
+
+  // Test WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA.
+  {
+    int o;
+    for (o = 0; o < 2; o++) {
+      uint8_t dst[8] = {0};
+      const double f64 = 1.75;
+      const uint32_t precision = 2;
+      size_t n = wuffs_base__render_number_f64(
+          wuffs_base__make_slice_u8(&dst[0], WUFFS_TESTLIB_ARRAY_SIZE(dst)),
+          f64, precision,
+          WUFFS_BASE__RENDER_NUMBER_FXX__EXPONENT_ABSENT |
+              (o ? WUFFS_BASE__RENDER_NUMBER_FXX__DECIMAL_SEPARATOR_IS_A_COMMA
+                 : 0));
+      if (n != 4) {
+        RETURN_FAIL("DECIMAL_SEPARATOR_IS_A_COMMA, o=%d: n != 4", o);
+      }
+      uint8_t have = dst[1];
+      uint8_t want = o ? ',' : '.';
+      if (have != want) {
+        RETURN_FAIL(
+            "DECIMAL_SEPARATOR_IS_A_COMMA, o=%d: have 0x%02X, want 0x%02X", o,
+            (int)have, (int)want);
+      }
+    }
+  }
+
+  return NULL;
+}
+
+const char*  //
 test_wuffs_strconv_render_number_i64() {
   CHECK_FOCUS(__func__);
 
@@ -909,7 +1613,7 @@
   for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
     size_t n = wuffs_base__render_number_i64(
         g_have_slice_u8, test_cases[tc].x,
-        WUFFS_BASE__RENDER_NUMBER__DEFAULT_OPTIONS);
+        WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS);
     if (n == 0) {
       RETURN_FAIL("%" PRId64 ": could not render", test_cases[tc].x);
     } else if (n >= g_have_slice_u8.len) {
@@ -964,7 +1668,7 @@
   for (tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
     size_t n = wuffs_base__render_number_u64(
         g_have_slice_u8, test_cases[tc].x,
-        WUFFS_BASE__RENDER_NUMBER__DEFAULT_OPTIONS);
+        WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS);
     if (n == 0) {
       RETURN_FAIL("%" PRIu64 ": could not render", test_cases[tc].x);
     } else if (n >= g_have_slice_u8.len) {
@@ -982,7 +1686,7 @@
     uint8_t dst[5];
     size_t n = wuffs_base__render_number_u64(
         wuffs_base__make_slice_u8(&dst[0], sizeof(dst)), 123456,
-        WUFFS_BASE__RENDER_NUMBER__DEFAULT_OPTIONS);
+        WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS);
     if (n != 0) {
       RETURN_FAIL("dst too short: have %zu, want 0", n);
     }
@@ -994,8 +1698,8 @@
     memcpy(&dst[0], "ABCDEFG\x00", 8);
     size_t n = wuffs_base__render_number_u64(
         wuffs_base__make_slice_u8(&dst[0], sizeof(dst) - 1), 1234,
-        WUFFS_BASE__RENDER_NUMBER__ALIGN_RIGHT |
-            WUFFS_BASE__RENDER_NUMBER__LEADING_PLUS_SIGN);
+        WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT |
+            WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN);
     if (n != 5) {
       RETURN_FAIL("ALIGN_RIGHT | LEADING_PLUS_SIGN: have %zu, want 5", n);
     }
@@ -2634,6 +3338,7 @@
     test_wuffs_strconv_parse_number_f64,
     test_wuffs_strconv_parse_number_i64,
     test_wuffs_strconv_parse_number_u64,
+    test_wuffs_strconv_render_number_f64,
     test_wuffs_strconv_render_number_i64,
     test_wuffs_strconv_render_number_u64,
     test_wuffs_strconv_utf_8_next,