diff --git a/release/c/wuffs-v0.3.c b/release/c/wuffs-v0.3.c
index d2be780..a5a893f 100644
--- a/release/c/wuffs-v0.3.c
+++ b/release/c/wuffs-v0.3.c
@@ -65,15 +65,15 @@
 // each major.minor branch, the commit count should increase monotonically.
 //
 // WUFFS_VERSION was overridden by "wuffs gen -version" based on revision
-// d377dcaea826f12b47492cced1b75450a440f6c1 committed on 2020-06-17.
+// c94ccef400cd94a23bef9e2a3d824358147ea121 committed on 2020-07-01.
 #define WUFFS_VERSION 0x000030000
 #define WUFFS_VERSION_MAJOR 0
 #define WUFFS_VERSION_MINOR 3
 #define WUFFS_VERSION_PATCH 0
-#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.4"
-#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 2514
-#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20200617
-#define WUFFS_VERSION_STRING "0.3.0-alpha.4+2514.20200617"
+#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.5"
+#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 2523
+#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20200701
+#define WUFFS_VERSION_STRING "0.3.0-alpha.5+2523.20200701"
 
 // Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have
 // static storage. The motivation is discussed in the "ALLOW STATIC
@@ -111,7 +111,9 @@
 #define WUFFS_BASE__WARN_UNUSED_RESULT
 #endif
 
-// Flags for wuffs_foo__bar__initialize functions.
+// --------
+
+// Options (bitwise or'ed together) for wuffs_foo__bar__initialize functions.
 
 #define WUFFS_INITIALIZE__DEFAULT_OPTIONS ((uint32_t)0x00000000)
 
@@ -193,36 +195,36 @@
 
 } wuffs_base__status;
 
-extern const char* wuffs_base__note__i_o_redirect;
-extern const char* wuffs_base__note__end_of_data;
-extern const char* wuffs_base__note__metadata_reported;
-extern const char* wuffs_base__suspension__even_more_information;
-extern const char* wuffs_base__suspension__mispositioned_read;
-extern const char* wuffs_base__suspension__mispositioned_write;
-extern const char* wuffs_base__suspension__short_read;
-extern const char* wuffs_base__suspension__short_write;
-extern const char* wuffs_base__error__bad_i_o_position;
-extern const char* wuffs_base__error__bad_argument_length_too_short;
-extern const char* wuffs_base__error__bad_argument;
-extern const char* wuffs_base__error__bad_call_sequence;
-extern const char* wuffs_base__error__bad_receiver;
-extern const char* wuffs_base__error__bad_restart;
-extern const char* wuffs_base__error__bad_sizeof_receiver;
-extern const char* wuffs_base__error__bad_vtable;
-extern const char* wuffs_base__error__bad_workbuf_length;
-extern const char* wuffs_base__error__bad_wuffs_version;
-extern const char* wuffs_base__error__cannot_return_a_suspension;
-extern const char* wuffs_base__error__disabled_by_previous_error;
-extern const char* wuffs_base__error__initialize_falsely_claimed_already_zeroed;
-extern const char* wuffs_base__error__initialize_not_called;
-extern const char* wuffs_base__error__interleaved_coroutine_calls;
-extern const char* wuffs_base__error__no_more_information;
-extern const char* wuffs_base__error__not_enough_data;
-extern const char* wuffs_base__error__out_of_bounds;
-extern const char* wuffs_base__error__unsupported_method;
-extern const char* wuffs_base__error__unsupported_option;
-extern const char* wuffs_base__error__unsupported_pixel_swizzler_option;
-extern const char* wuffs_base__error__too_much_data;
+extern const char wuffs_base__note__i_o_redirect[];
+extern const char wuffs_base__note__end_of_data[];
+extern const char wuffs_base__note__metadata_reported[];
+extern const char wuffs_base__suspension__even_more_information[];
+extern const char wuffs_base__suspension__mispositioned_read[];
+extern const char wuffs_base__suspension__mispositioned_write[];
+extern const char wuffs_base__suspension__short_read[];
+extern const char wuffs_base__suspension__short_write[];
+extern const char wuffs_base__error__bad_i_o_position[];
+extern const char wuffs_base__error__bad_argument_length_too_short[];
+extern const char wuffs_base__error__bad_argument[];
+extern const char wuffs_base__error__bad_call_sequence[];
+extern const char wuffs_base__error__bad_receiver[];
+extern const char wuffs_base__error__bad_restart[];
+extern const char wuffs_base__error__bad_sizeof_receiver[];
+extern const char wuffs_base__error__bad_vtable[];
+extern const char wuffs_base__error__bad_workbuf_length[];
+extern const char wuffs_base__error__bad_wuffs_version[];
+extern const char wuffs_base__error__cannot_return_a_suspension[];
+extern const char wuffs_base__error__disabled_by_previous_error[];
+extern const char wuffs_base__error__initialize_falsely_claimed_already_zeroed[];
+extern const char wuffs_base__error__initialize_not_called[];
+extern const char wuffs_base__error__interleaved_coroutine_calls[];
+extern const char wuffs_base__error__no_more_information[];
+extern const char wuffs_base__error__not_enough_data[];
+extern const char wuffs_base__error__out_of_bounds[];
+extern const char wuffs_base__error__unsupported_method[];
+extern const char wuffs_base__error__unsupported_option[];
+extern const char wuffs_base__error__unsupported_pixel_swizzler_option[];
+extern const char wuffs_base__error__too_much_data[];
 
 static inline wuffs_base__status  //
 wuffs_base__make_status(const char* repr) {
@@ -353,6 +355,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;
@@ -3865,43 +3907,49 @@
 
 // ---------------- String Conversions
 
-// wuffs_base__parse_number_i64 parses the ASCII integer in s. For example, if
-// s contains the bytes "-123" then it will return the int64_t -123.
-//
-// It returns an error if s does not contain an integer or if the integer
-// within would overflow an int64_t.
-//
-// It is similar to wuffs_base__parse_number_u64 but it returns a signed
-// integer, not an unsigned integer. It also allows a leading '+' or '-'.
-WUFFS_BASE__MAYBE_STATIC wuffs_base__result_i64  //
-wuffs_base__parse_number_i64(wuffs_base__slice_u8 s);
+// 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.
 
-// wuffs_base__parse_number_u64 parses the ASCII integer in s. For example, if
-// s contains the bytes "123" then it will return the uint64_t 123.
+#define WUFFS_BASE__RENDER_NUMBER_XXX__DEFAULT_OPTIONS ((uint32_t)0x00000000)
+
+// 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_XXX__ALIGN_RIGHT ((uint32_t)0x00000001)
+
+// 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".
 //
-// It returns an error if s does not contain an integer or if the integer
-// within would overflow a uint64_t.
+// 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.
 //
-// It is similar to the C standard library's strtoull function, but:
-//  - Errors are returned in-band (in a result type), not out-of-band (errno).
-//  - It takes a slice (a pointer and length), not a NUL-terminated C string.
-//  - It does not take an optional endptr argument. It does not allow a partial
-//    parse: it returns an error unless all of s is consumed.
-//  - It does not allow whitespace, leading or otherwise.
-//  - It does not allow a leading '+' or '-'.
-//  - It does not allow unnecessary leading zeroes ("0" is valid and its sole
-//    zero is necessary). All of "00", "0644" and "007" are invalid.
-//  - It does not take a base argument (e.g. base 10 vs base 16). Instead, it
-//    always accepts both decimal (e.g "1234", "0d5678") and hexadecimal (e.g.
-//    "0x9aBC"). The caller is responsible for prior filtering of e.g. hex
-//    numbers if they are unwanted. For example, Wuffs' JSON decoder will only
-//    produce a wuffs_base__token for decimal numbers, not hexadecimal.
-//  - It is not affected by i18n / l10n settings such as environment variables.
-//  - It does allow arbitrary underscores, except inside the optional 2-byte
-//    opening "0d" or "0X" that denotes base-10 or base-16. For example,
-//    "__0D_1_002" would successfully parse as "one thousand and two".
-WUFFS_BASE__MAYBE_STATIC wuffs_base__result_u64  //
-wuffs_base__parse_number_u64(wuffs_base__slice_u8 s);
+// 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
 
@@ -3944,6 +3992,8 @@
 WUFFS_BASE__MAYBE_STATIC wuffs_base__result_f64  //
 wuffs_base__parse_number_f64(wuffs_base__slice_u8 s);
 
+// --------
+
 // wuffs_base__ieee_754_bit_representation__etc converts between a double
 // precision numerical value and its IEEE 754 64-bit representation (1 sign
 // bit, 11 exponent bits, 52 explicit significand bits).
@@ -3973,6 +4023,105 @@
   return f;
 }
 
+// ---------------- Integer
+
+// wuffs_base__parse_number_i64 parses the ASCII integer in s. For example, if
+// s contains the bytes "-123" then it will return the int64_t -123.
+//
+// It returns an error if s does not contain an integer or if the integer
+// within would overflow an int64_t.
+//
+// It is similar to wuffs_base__parse_number_u64 but it returns a signed
+// integer, not an unsigned integer. It also allows a leading '+' or '-'.
+WUFFS_BASE__MAYBE_STATIC wuffs_base__result_i64  //
+wuffs_base__parse_number_i64(wuffs_base__slice_u8 s);
+
+// wuffs_base__parse_number_u64 parses the ASCII integer in s. For example, if
+// s contains the bytes "123" then it will return the uint64_t 123.
+//
+// It returns an error if s does not contain an integer or if the integer
+// within would overflow a uint64_t.
+//
+// It is similar to the C standard library's strtoull function, but:
+//  - Errors are returned in-band (in a result type), not out-of-band (errno).
+//  - It takes a slice (a pointer and length), not a NUL-terminated C string.
+//  - It does not take an optional endptr argument. It does not allow a partial
+//    parse: it returns an error unless all of s is consumed.
+//  - It does not allow whitespace, leading or otherwise.
+//  - It does not allow a leading '+' or '-'.
+//  - It does not allow unnecessary leading zeroes ("0" is valid and its sole
+//    zero is necessary). All of "00", "0644" and "007" are invalid.
+//  - It does not take a base argument (e.g. base 10 vs base 16). Instead, it
+//    always accepts both decimal (e.g "1234", "0d5678") and hexadecimal (e.g.
+//    "0x9aBC"). The caller is responsible for prior filtering of e.g. hex
+//    numbers if they are unwanted. For example, Wuffs' JSON decoder will only
+//    produce a wuffs_base__token for decimal numbers, not hexadecimal.
+//  - It is not affected by i18n / l10n settings such as environment variables.
+//  - It does allow arbitrary underscores, except inside the optional 2-byte
+//    opening "0d" or "0X" that denotes base-10 or base-16. For example,
+//    "__0D_1_002" would successfully parse as "one thousand and two".
+WUFFS_BASE__MAYBE_STATIC wuffs_base__result_u64  //
+wuffs_base__parse_number_u64(wuffs_base__slice_u8 s);
+
+// --------
+
+#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).
+//
+// dst will never be too short if its length is at least 20, also known as
+// WUFFS_BASE__I64__BYTE_LENGTH__MAX_INCL.
+WUFFS_BASE__MAYBE_STATIC size_t  //
+wuffs_base__render_number_i64(wuffs_base__slice_u8 dst,
+                              int64_t x,
+                              uint32_t options);
+
+// wuffs_base__render_number_u64 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).
+//
+// dst will never be too short if its length is at least 21, also known as
+// WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL.
+WUFFS_BASE__MAYBE_STATIC size_t  //
+wuffs_base__render_number_u64(wuffs_base__slice_u8 dst,
+                              uint64_t x,
+                              uint32_t options);
+
 // ---------------- Hexadecimal
 
 // wuffs_base__hexadecimal__decode2 converts "6A6b" to "jk", where e.g. 'j' is
@@ -4141,7 +4290,7 @@
 
 // --------
 
-extern const char* wuffs_base__hasher_u32__vtable_name;
+extern const char wuffs_base__hasher_u32__vtable_name[];
 
 typedef struct {
   wuffs_base__empty_struct (*set_quirk_enabled)(
@@ -4202,7 +4351,7 @@
 
 // --------
 
-extern const char* wuffs_base__image_decoder__vtable_name;
+extern const char wuffs_base__image_decoder__vtable_name[];
 
 typedef struct {
   wuffs_base__status (*decode_frame)(
@@ -4423,7 +4572,7 @@
 
 // --------
 
-extern const char* wuffs_base__io_transformer__vtable_name;
+extern const char wuffs_base__io_transformer__vtable_name[];
 
 typedef struct {
   wuffs_base__empty_struct (*set_quirk_enabled)(
@@ -4501,7 +4650,7 @@
 
 // --------
 
-extern const char* wuffs_base__token_decoder__vtable_name;
+extern const char wuffs_base__token_decoder__vtable_name[];
 
 typedef struct {
   wuffs_base__status (*decode_tokens)(
@@ -4601,14 +4750,14 @@
 // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)".
 //
 // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.
-// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags.
+// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
 
 wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
 wuffs_adler32__hasher__initialize(
     wuffs_adler32__hasher* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags);
+    uint32_t options);
 
 size_t
 sizeof__wuffs_adler32__hasher();
@@ -4727,9 +4876,9 @@
   initialize(
       size_t sizeof_star_self,
       uint64_t wuffs_version,
-      uint32_t initialize_flags) {
+      uint32_t options) {
     return wuffs_adler32__hasher__initialize(
-        this, sizeof_star_self, wuffs_version, initialize_flags);
+        this, sizeof_star_self, wuffs_version, options);
   }
 
   inline wuffs_base__hasher_u32*
@@ -4765,8 +4914,8 @@
 
 // ---------------- Status Codes
 
-extern const char* wuffs_bmp__error__bad_header;
-extern const char* wuffs_bmp__error__unsupported_bmp_file;
+extern const char wuffs_bmp__error__bad_header[];
+extern const char wuffs_bmp__error__unsupported_bmp_file[];
 
 // ---------------- Public Consts
 
@@ -4782,14 +4931,14 @@
 // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)".
 //
 // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.
-// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags.
+// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
 
 wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
 wuffs_bmp__decoder__initialize(
     wuffs_bmp__decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags);
+    uint32_t options);
 
 size_t
 sizeof__wuffs_bmp__decoder();
@@ -5002,9 +5151,9 @@
   initialize(
       size_t sizeof_star_self,
       uint64_t wuffs_version,
-      uint32_t initialize_flags) {
+      uint32_t options) {
     return wuffs_bmp__decoder__initialize(
-        this, sizeof_star_self, wuffs_version, initialize_flags);
+        this, sizeof_star_self, wuffs_version, options);
   }
 
   inline wuffs_base__image_decoder*
@@ -5117,14 +5266,14 @@
 // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)".
 //
 // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.
-// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags.
+// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
 
 wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
 wuffs_crc32__ieee_hasher__initialize(
     wuffs_crc32__ieee_hasher* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags);
+    uint32_t options);
 
 size_t
 sizeof__wuffs_crc32__ieee_hasher();
@@ -5242,9 +5391,9 @@
   initialize(
       size_t sizeof_star_self,
       uint64_t wuffs_version,
-      uint32_t initialize_flags) {
+      uint32_t options) {
     return wuffs_crc32__ieee_hasher__initialize(
-        this, sizeof_star_self, wuffs_version, initialize_flags);
+        this, sizeof_star_self, wuffs_version, options);
   }
 
   inline wuffs_base__hasher_u32*
@@ -5280,19 +5429,19 @@
 
 // ---------------- Status Codes
 
-extern const char* wuffs_deflate__error__bad_huffman_code_over_subscribed;
-extern const char* wuffs_deflate__error__bad_huffman_code_under_subscribed;
-extern const char* wuffs_deflate__error__bad_huffman_code_length_count;
-extern const char* wuffs_deflate__error__bad_huffman_code_length_repetition;
-extern const char* wuffs_deflate__error__bad_huffman_code;
-extern const char* wuffs_deflate__error__bad_huffman_minimum_code_length;
-extern const char* wuffs_deflate__error__bad_block;
-extern const char* wuffs_deflate__error__bad_distance;
-extern const char* wuffs_deflate__error__bad_distance_code_count;
-extern const char* wuffs_deflate__error__bad_literal_length_code_count;
-extern const char* wuffs_deflate__error__inconsistent_stored_block_length;
-extern const char* wuffs_deflate__error__missing_end_of_block_code;
-extern const char* wuffs_deflate__error__no_huffman_codes;
+extern const char wuffs_deflate__error__bad_huffman_code_over_subscribed[];
+extern const char wuffs_deflate__error__bad_huffman_code_under_subscribed[];
+extern const char wuffs_deflate__error__bad_huffman_code_length_count[];
+extern const char wuffs_deflate__error__bad_huffman_code_length_repetition[];
+extern const char wuffs_deflate__error__bad_huffman_code[];
+extern const char wuffs_deflate__error__bad_huffman_minimum_code_length[];
+extern const char wuffs_deflate__error__bad_block[];
+extern const char wuffs_deflate__error__bad_distance[];
+extern const char wuffs_deflate__error__bad_distance_code_count[];
+extern const char wuffs_deflate__error__bad_literal_length_code_count[];
+extern const char wuffs_deflate__error__inconsistent_stored_block_length[];
+extern const char wuffs_deflate__error__missing_end_of_block_code[];
+extern const char wuffs_deflate__error__no_huffman_codes[];
 
 // ---------------- Public Consts
 
@@ -5308,14 +5457,14 @@
 // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)".
 //
 // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.
-// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags.
+// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
 
 wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
 wuffs_deflate__decoder__initialize(
     wuffs_deflate__decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags);
+    uint32_t options);
 
 size_t
 sizeof__wuffs_deflate__decoder();
@@ -5496,9 +5645,9 @@
   initialize(
       size_t sizeof_star_self,
       uint64_t wuffs_version,
-      uint32_t initialize_flags) {
+      uint32_t options) {
     return wuffs_deflate__decoder__initialize(
-        this, sizeof_star_self, wuffs_version, initialize_flags);
+        this, sizeof_star_self, wuffs_version, options);
   }
 
   inline wuffs_base__io_transformer*
@@ -5547,7 +5696,7 @@
 
 // ---------------- Status Codes
 
-extern const char* wuffs_lzw__error__bad_code;
+extern const char wuffs_lzw__error__bad_code[];
 
 // ---------------- Public Consts
 
@@ -5563,14 +5712,14 @@
 // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)".
 //
 // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.
-// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags.
+// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
 
 wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
 wuffs_lzw__decoder__initialize(
     wuffs_lzw__decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags);
+    uint32_t options);
 
 size_t
 sizeof__wuffs_lzw__decoder();
@@ -5724,9 +5873,9 @@
   initialize(
       size_t sizeof_star_self,
       uint64_t wuffs_version,
-      uint32_t initialize_flags) {
+      uint32_t options) {
     return wuffs_lzw__decoder__initialize(
-        this, sizeof_star_self, wuffs_version, initialize_flags);
+        this, sizeof_star_self, wuffs_version, options);
   }
 
   inline wuffs_base__io_transformer*
@@ -5780,12 +5929,12 @@
 
 // ---------------- Status Codes
 
-extern const char* wuffs_gif__error__bad_extension_label;
-extern const char* wuffs_gif__error__bad_frame_size;
-extern const char* wuffs_gif__error__bad_graphic_control;
-extern const char* wuffs_gif__error__bad_header;
-extern const char* wuffs_gif__error__bad_literal_width;
-extern const char* wuffs_gif__error__bad_palette;
+extern const char wuffs_gif__error__bad_extension_label[];
+extern const char wuffs_gif__error__bad_frame_size[];
+extern const char wuffs_gif__error__bad_graphic_control[];
+extern const char wuffs_gif__error__bad_header[];
+extern const char wuffs_gif__error__bad_literal_width[];
+extern const char wuffs_gif__error__bad_palette[];
 
 // ---------------- Public Consts
 
@@ -5817,14 +5966,14 @@
 // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)".
 //
 // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.
-// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags.
+// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
 
 wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
 wuffs_gif__config_decoder__initialize(
     wuffs_gif__config_decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags);
+    uint32_t options);
 
 size_t
 sizeof__wuffs_gif__config_decoder();
@@ -5834,7 +5983,7 @@
     wuffs_gif__decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags);
+    uint32_t options);
 
 size_t
 sizeof__wuffs_gif__decoder();
@@ -6168,9 +6317,9 @@
   initialize(
       size_t sizeof_star_self,
       uint64_t wuffs_version,
-      uint32_t initialize_flags) {
+      uint32_t options) {
     return wuffs_gif__config_decoder__initialize(
-        this, sizeof_star_self, wuffs_version, initialize_flags);
+        this, sizeof_star_self, wuffs_version, options);
   }
 
   inline wuffs_base__image_decoder*
@@ -6431,9 +6580,9 @@
   initialize(
       size_t sizeof_star_self,
       uint64_t wuffs_version,
-      uint32_t initialize_flags) {
+      uint32_t options) {
     return wuffs_gif__decoder__initialize(
-        this, sizeof_star_self, wuffs_version, initialize_flags);
+        this, sizeof_star_self, wuffs_version, options);
   }
 
   inline wuffs_base__image_decoder*
@@ -6534,10 +6683,10 @@
 
 // ---------------- Status Codes
 
-extern const char* wuffs_gzip__error__bad_checksum;
-extern const char* wuffs_gzip__error__bad_compression_method;
-extern const char* wuffs_gzip__error__bad_encoding_flags;
-extern const char* wuffs_gzip__error__bad_header;
+extern const char wuffs_gzip__error__bad_checksum[];
+extern const char wuffs_gzip__error__bad_compression_method[];
+extern const char wuffs_gzip__error__bad_encoding_flags[];
+extern const char wuffs_gzip__error__bad_header[];
 
 // ---------------- Public Consts
 
@@ -6553,14 +6702,14 @@
 // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)".
 //
 // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.
-// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags.
+// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
 
 wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
 wuffs_gzip__decoder__initialize(
     wuffs_gzip__decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags);
+    uint32_t options);
 
 size_t
 sizeof__wuffs_gzip__decoder();
@@ -6704,9 +6853,9 @@
   initialize(
       size_t sizeof_star_self,
       uint64_t wuffs_version,
-      uint32_t initialize_flags) {
+      uint32_t options) {
     return wuffs_gzip__decoder__initialize(
-        this, sizeof_star_self, wuffs_version, initialize_flags);
+        this, sizeof_star_self, wuffs_version, options);
   }
 
   inline wuffs_base__io_transformer*
@@ -6755,12 +6904,12 @@
 
 // ---------------- Status Codes
 
-extern const char* wuffs_json__error__bad_c0_control_code;
-extern const char* wuffs_json__error__bad_utf_8;
-extern const char* wuffs_json__error__bad_backslash_escape;
-extern const char* wuffs_json__error__bad_input;
-extern const char* wuffs_json__error__unsupported_number_length;
-extern const char* wuffs_json__error__unsupported_recursion_depth;
+extern const char wuffs_json__error__bad_c0_control_code[];
+extern const char wuffs_json__error__bad_utf_8[];
+extern const char wuffs_json__error__bad_backslash_escape[];
+extern const char wuffs_json__error__bad_input[];
+extern const char wuffs_json__error__unsupported_number_length[];
+extern const char wuffs_json__error__unsupported_recursion_depth[];
 
 // ---------------- Public Consts
 
@@ -6818,14 +6967,14 @@
 // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)".
 //
 // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.
-// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags.
+// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
 
 wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
 wuffs_json__decoder__initialize(
     wuffs_json__decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags);
+    uint32_t options);
 
 size_t
 sizeof__wuffs_json__decoder();
@@ -6971,9 +7120,9 @@
   initialize(
       size_t sizeof_star_self,
       uint64_t wuffs_version,
-      uint32_t initialize_flags) {
+      uint32_t options) {
     return wuffs_json__decoder__initialize(
-        this, sizeof_star_self, wuffs_version, initialize_flags);
+        this, sizeof_star_self, wuffs_version, options);
   }
 
   inline wuffs_base__token_decoder*
@@ -7016,7 +7165,7 @@
 
 // ---------------- Status Codes
 
-extern const char* wuffs_wbmp__error__bad_header;
+extern const char wuffs_wbmp__error__bad_header[];
 
 // ---------------- Public Consts
 
@@ -7032,14 +7181,14 @@
 // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)".
 //
 // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.
-// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags.
+// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
 
 wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
 wuffs_wbmp__decoder__initialize(
     wuffs_wbmp__decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags);
+    uint32_t options);
 
 size_t
 sizeof__wuffs_wbmp__decoder();
@@ -7238,9 +7387,9 @@
   initialize(
       size_t sizeof_star_self,
       uint64_t wuffs_version,
-      uint32_t initialize_flags) {
+      uint32_t options) {
     return wuffs_wbmp__decoder__initialize(
-        this, sizeof_star_self, wuffs_version, initialize_flags);
+        this, sizeof_star_self, wuffs_version, options);
   }
 
   inline wuffs_base__image_decoder*
@@ -7341,12 +7490,12 @@
 
 // ---------------- Status Codes
 
-extern const char* wuffs_zlib__note__dictionary_required;
-extern const char* wuffs_zlib__error__bad_checksum;
-extern const char* wuffs_zlib__error__bad_compression_method;
-extern const char* wuffs_zlib__error__bad_compression_window_size;
-extern const char* wuffs_zlib__error__bad_parity_check;
-extern const char* wuffs_zlib__error__incorrect_dictionary;
+extern const char wuffs_zlib__note__dictionary_required[];
+extern const char wuffs_zlib__error__bad_checksum[];
+extern const char wuffs_zlib__error__bad_compression_method[];
+extern const char wuffs_zlib__error__bad_compression_window_size[];
+extern const char wuffs_zlib__error__bad_parity_check[];
+extern const char wuffs_zlib__error__incorrect_dictionary[];
 
 // ---------------- Public Consts
 
@@ -7362,14 +7511,14 @@
 // etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)".
 //
 // Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.
-// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for initialize_flags.
+// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
 
 wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
 wuffs_zlib__decoder__initialize(
     wuffs_zlib__decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags);
+    uint32_t options);
 
 size_t
 sizeof__wuffs_zlib__decoder();
@@ -7526,9 +7675,9 @@
   initialize(
       size_t sizeof_star_self,
       uint64_t wuffs_version,
-      uint32_t initialize_flags) {
+      uint32_t options) {
     return wuffs_zlib__decoder__initialize(
-        this, sizeof_star_self, wuffs_version, initialize_flags);
+        this, sizeof_star_self, wuffs_version, options);
   }
 
   inline wuffs_base__io_transformer*
@@ -8154,548 +8303,41 @@
     0x08, 0x0A, 0x0C, 0x10, 0x18, 0x20, 0x30, 0x40,
 };
 
-const char* wuffs_base__note__i_o_redirect = "@base: I/O redirect";
-const char* wuffs_base__note__end_of_data = "@base: end of data";
-const char* wuffs_base__note__metadata_reported = "@base: metadata reported";
-const char* wuffs_base__suspension__even_more_information = "$base: even more information";
-const char* wuffs_base__suspension__mispositioned_read = "$base: mispositioned read";
-const char* wuffs_base__suspension__mispositioned_write = "$base: mispositioned write";
-const char* wuffs_base__suspension__short_read = "$base: short read";
-const char* wuffs_base__suspension__short_write = "$base: short write";
-const char* wuffs_base__error__bad_i_o_position = "#base: bad I/O position";
-const char* wuffs_base__error__bad_argument_length_too_short = "#base: bad argument (length too short)";
-const char* wuffs_base__error__bad_argument = "#base: bad argument";
-const char* wuffs_base__error__bad_call_sequence = "#base: bad call sequence";
-const char* wuffs_base__error__bad_receiver = "#base: bad receiver";
-const char* wuffs_base__error__bad_restart = "#base: bad restart";
-const char* wuffs_base__error__bad_sizeof_receiver = "#base: bad sizeof receiver";
-const char* wuffs_base__error__bad_vtable = "#base: bad vtable";
-const char* wuffs_base__error__bad_workbuf_length = "#base: bad workbuf length";
-const char* wuffs_base__error__bad_wuffs_version = "#base: bad wuffs version";
-const char* wuffs_base__error__cannot_return_a_suspension = "#base: cannot return a suspension";
-const char* wuffs_base__error__disabled_by_previous_error = "#base: disabled by previous error";
-const char* wuffs_base__error__initialize_falsely_claimed_already_zeroed = "#base: initialize falsely claimed already zeroed";
-const char* wuffs_base__error__initialize_not_called = "#base: initialize not called";
-const char* wuffs_base__error__interleaved_coroutine_calls = "#base: interleaved coroutine calls";
-const char* wuffs_base__error__no_more_information = "#base: no more information";
-const char* wuffs_base__error__not_enough_data = "#base: not enough data";
-const char* wuffs_base__error__out_of_bounds = "#base: out of bounds";
-const char* wuffs_base__error__unsupported_method = "#base: unsupported method";
-const char* wuffs_base__error__unsupported_option = "#base: unsupported option";
-const char* wuffs_base__error__unsupported_pixel_swizzler_option = "#base: unsupported pixel swizzler option";
-const char* wuffs_base__error__too_much_data = "#base: too much data";
+const char wuffs_base__note__i_o_redirect[] = "@base: I/O redirect";
+const char wuffs_base__note__end_of_data[] = "@base: end of data";
+const char wuffs_base__note__metadata_reported[] = "@base: metadata reported";
+const char wuffs_base__suspension__even_more_information[] = "$base: even more information";
+const char wuffs_base__suspension__mispositioned_read[] = "$base: mispositioned read";
+const char wuffs_base__suspension__mispositioned_write[] = "$base: mispositioned write";
+const char wuffs_base__suspension__short_read[] = "$base: short read";
+const char wuffs_base__suspension__short_write[] = "$base: short write";
+const char wuffs_base__error__bad_i_o_position[] = "#base: bad I/O position";
+const char wuffs_base__error__bad_argument_length_too_short[] = "#base: bad argument (length too short)";
+const char wuffs_base__error__bad_argument[] = "#base: bad argument";
+const char wuffs_base__error__bad_call_sequence[] = "#base: bad call sequence";
+const char wuffs_base__error__bad_receiver[] = "#base: bad receiver";
+const char wuffs_base__error__bad_restart[] = "#base: bad restart";
+const char wuffs_base__error__bad_sizeof_receiver[] = "#base: bad sizeof receiver";
+const char wuffs_base__error__bad_vtable[] = "#base: bad vtable";
+const char wuffs_base__error__bad_workbuf_length[] = "#base: bad workbuf length";
+const char wuffs_base__error__bad_wuffs_version[] = "#base: bad wuffs version";
+const char wuffs_base__error__cannot_return_a_suspension[] = "#base: cannot return a suspension";
+const char wuffs_base__error__disabled_by_previous_error[] = "#base: disabled by previous error";
+const char wuffs_base__error__initialize_falsely_claimed_already_zeroed[] = "#base: initialize falsely claimed already zeroed";
+const char wuffs_base__error__initialize_not_called[] = "#base: initialize not called";
+const char wuffs_base__error__interleaved_coroutine_calls[] = "#base: interleaved coroutine calls";
+const char wuffs_base__error__no_more_information[] = "#base: no more information";
+const char wuffs_base__error__not_enough_data[] = "#base: not enough data";
+const char wuffs_base__error__out_of_bounds[] = "#base: out of bounds";
+const char wuffs_base__error__unsupported_method[] = "#base: unsupported method";
+const char wuffs_base__error__unsupported_option[] = "#base: unsupported option";
+const char wuffs_base__error__unsupported_pixel_swizzler_option[] = "#base: unsupported pixel swizzler option";
+const char wuffs_base__error__too_much_data[] = "#base: too much data";
 
-const char* wuffs_base__hasher_u32__vtable_name = "{vtable}wuffs_base__hasher_u32";
-const char* wuffs_base__image_decoder__vtable_name = "{vtable}wuffs_base__image_decoder";
-const char* wuffs_base__io_transformer__vtable_name = "{vtable}wuffs_base__io_transformer";
-const char* wuffs_base__token_decoder__vtable_name = "{vtable}wuffs_base__token_decoder";
-
-// ---------------- String Conversions
-
-// wuffs_base__parse_number__foo_digits entries are 0x00 for invalid digits,
-// and (0x80 | v) for valid digits, where v is the 4 bit value.
-
-static const uint8_t wuffs_base__parse_number__decimal_digits[256] = {
-    // 0     1     2     3     4     5     6     7
-    // 8     9     A     B     C     D     E     F
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x00 ..= 0x07.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x08 ..= 0x0F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x10 ..= 0x17.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x18 ..= 0x1F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x20 ..= 0x27.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x28 ..= 0x2F.
-    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,  // 0x30 ..= 0x37. '0'-'7'.
-    0x88, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x38 ..= 0x3F. '8'-'9'.
-
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x40 ..= 0x47.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x48 ..= 0x4F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x50 ..= 0x57.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x58 ..= 0x5F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x60 ..= 0x67.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x68 ..= 0x6F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x70 ..= 0x77.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x78 ..= 0x7F.
-
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x80 ..= 0x87.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x88 ..= 0x8F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x90 ..= 0x97.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x98 ..= 0x9F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xA0 ..= 0xA7.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xA8 ..= 0xAF.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xB0 ..= 0xB7.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xB8 ..= 0xBF.
-
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xC0 ..= 0xC7.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xC8 ..= 0xCF.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xD0 ..= 0xD7.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xD8 ..= 0xDF.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xE0 ..= 0xE7.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xE8 ..= 0xEF.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xF0 ..= 0xF7.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xF8 ..= 0xFF.
-    // 0     1     2     3     4     5     6     7
-    // 8     9     A     B     C     D     E     F
-};
-
-static const uint8_t wuffs_base__parse_number__hexadecimal_digits[256] = {
-    // 0     1     2     3     4     5     6     7
-    // 8     9     A     B     C     D     E     F
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x00 ..= 0x07.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x08 ..= 0x0F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x10 ..= 0x17.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x18 ..= 0x1F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x20 ..= 0x27.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x28 ..= 0x2F.
-    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,  // 0x30 ..= 0x37. '0'-'7'.
-    0x88, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x38 ..= 0x3F. '8'-'9'.
-
-    0x00, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x00,  // 0x40 ..= 0x47. 'A'-'F'.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x48 ..= 0x4F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x50 ..= 0x57.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x58 ..= 0x5F.
-    0x00, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x00,  // 0x60 ..= 0x67. 'a'-'f'.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x68 ..= 0x6F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x70 ..= 0x77.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x78 ..= 0x7F.
-
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x80 ..= 0x87.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x88 ..= 0x8F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x90 ..= 0x97.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x98 ..= 0x9F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xA0 ..= 0xA7.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xA8 ..= 0xAF.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xB0 ..= 0xB7.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xB8 ..= 0xBF.
-
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xC0 ..= 0xC7.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xC8 ..= 0xCF.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xD0 ..= 0xD7.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xD8 ..= 0xDF.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xE0 ..= 0xE7.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xE8 ..= 0xEF.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xF0 ..= 0xF7.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xF8 ..= 0xFF.
-    // 0     1     2     3     4     5     6     7
-    // 8     9     A     B     C     D     E     F
-};
-
-// --------
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__result_i64  //
-wuffs_base__parse_number_i64(wuffs_base__slice_u8 s) {
-  uint8_t* p = s.ptr;
-  uint8_t* q = s.ptr + s.len;
-
-  for (; (p < q) && (*p == '_'); p++) {
-  }
-
-  bool negative = false;
-  if (p >= q) {
-    goto fail_bad_argument;
-  } else if (*p == '-') {
-    p++;
-    negative = true;
-  } else if (*p == '+') {
-    p++;
-  }
-
-  do {
-    wuffs_base__result_u64 r = wuffs_base__parse_number_u64(
-        wuffs_base__make_slice_u8(p, (size_t)(q - p)));
-    if (r.status.repr != NULL) {
-      wuffs_base__result_i64 ret;
-      ret.status.repr = r.status.repr;
-      ret.value = 0;
-      return ret;
-    } else if (negative) {
-      if (r.value > 0x8000000000000000) {
-        goto fail_out_of_bounds;
-      }
-      wuffs_base__result_i64 ret;
-      ret.status.repr = NULL;
-      ret.value = -(int64_t)(r.value);
-      return ret;
-    } else if (r.value > 0x7FFFFFFFFFFFFFFF) {
-      goto fail_out_of_bounds;
-    } else {
-      wuffs_base__result_i64 ret;
-      ret.status.repr = NULL;
-      ret.value = +(int64_t)(r.value);
-      return ret;
-    }
-  } while (0);
-
-fail_bad_argument:
-  do {
-    wuffs_base__result_i64 ret;
-    ret.status.repr = wuffs_base__error__bad_argument;
-    ret.value = 0;
-    return ret;
-  } while (0);
-
-fail_out_of_bounds:
-  do {
-    wuffs_base__result_i64 ret;
-    ret.status.repr = wuffs_base__error__out_of_bounds;
-    ret.value = 0;
-    return ret;
-  } while (0);
-}
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__result_u64  //
-wuffs_base__parse_number_u64(wuffs_base__slice_u8 s) {
-  uint8_t* p = s.ptr;
-  uint8_t* q = s.ptr + s.len;
-
-  for (; (p < q) && (*p == '_'); p++) {
-  }
-
-  if (p >= q) {
-    goto fail_bad_argument;
-
-  } else if (*p == '0') {
-    p++;
-    if (p >= q) {
-      goto ok_zero;
-    }
-    if (*p == '_') {
-      p++;
-      for (; p < q; p++) {
-        if (*p != '_') {
-          goto fail_bad_argument;
-        }
-      }
-      goto ok_zero;
-    }
-
-    if ((*p == 'x') || (*p == 'X')) {
-      p++;
-      for (; (p < q) && (*p == '_'); p++) {
-      }
-      if (p < q) {
-        goto hexadecimal;
-      }
-
-    } else if ((*p == 'd') || (*p == 'D')) {
-      p++;
-      for (; (p < q) && (*p == '_'); p++) {
-      }
-      if (p < q) {
-        goto decimal;
-      }
-    }
-
-    goto fail_bad_argument;
-  }
-
-decimal:
-  do {
-    uint64_t v = wuffs_base__parse_number__decimal_digits[*p++];
-    if (v == 0) {
-      goto fail_bad_argument;
-    }
-    v &= 0x0F;
-
-    // UINT64_MAX is 18446744073709551615, which is ((10 * max10) + max1).
-    const uint64_t max10 = 1844674407370955161u;
-    const uint8_t max1 = 5;
-
-    for (; p < q; p++) {
-      if (*p == '_') {
-        continue;
-      }
-      uint8_t digit = wuffs_base__parse_number__decimal_digits[*p];
-      if (digit == 0) {
-        goto fail_bad_argument;
-      }
-      digit &= 0x0F;
-      if ((v > max10) || ((v == max10) && (digit > max1))) {
-        goto fail_out_of_bounds;
-      }
-      v = (10 * v) + ((uint64_t)(digit));
-    }
-
-    wuffs_base__result_u64 ret;
-    ret.status.repr = NULL;
-    ret.value = v;
-    return ret;
-  } while (0);
-
-hexadecimal:
-  do {
-    uint64_t v = wuffs_base__parse_number__hexadecimal_digits[*p++];
-    if (v == 0) {
-      goto fail_bad_argument;
-    }
-    v &= 0x0F;
-
-    for (; p < q; p++) {
-      if (*p == '_') {
-        continue;
-      }
-      uint8_t digit = wuffs_base__parse_number__hexadecimal_digits[*p];
-      if (digit == 0) {
-        goto fail_bad_argument;
-      }
-      digit &= 0x0F;
-      if ((v >> 60) != 0) {
-        goto fail_out_of_bounds;
-      }
-      v = (v << 4) | ((uint64_t)(digit));
-    }
-
-    wuffs_base__result_u64 ret;
-    ret.status.repr = NULL;
-    ret.value = v;
-    return ret;
-  } while (0);
-
-ok_zero:
-  do {
-    wuffs_base__result_u64 ret;
-    ret.status.repr = NULL;
-    ret.value = 0;
-    return ret;
-  } while (0);
-
-fail_bad_argument:
-  do {
-    wuffs_base__result_u64 ret;
-    ret.status.repr = wuffs_base__error__bad_argument;
-    ret.value = 0;
-    return ret;
-  } while (0);
-
-fail_out_of_bounds:
-  do {
-    wuffs_base__result_u64 ret;
-    ret.status.repr = wuffs_base__error__out_of_bounds;
-    ret.value = 0;
-    return ret;
-  } while (0);
-}
-
-// ---------------- Hexadecimal
-
-WUFFS_BASE__MAYBE_STATIC size_t  //
-wuffs_base__hexadecimal__decode2(wuffs_base__slice_u8 dst,
-                                 wuffs_base__slice_u8 src) {
-  size_t src_len2 = src.len / 2;
-  size_t len = dst.len < src_len2 ? dst.len : src_len2;
-  uint8_t* d = dst.ptr;
-  uint8_t* s = src.ptr;
-  size_t n = len;
-
-  while (n--) {
-    *d = (uint8_t)((wuffs_base__parse_number__hexadecimal_digits[s[0]] << 4) |
-                   (wuffs_base__parse_number__hexadecimal_digits[s[1]] & 0x0F));
-    d += 1;
-    s += 2;
-  }
-
-  return len;
-}
-
-WUFFS_BASE__MAYBE_STATIC size_t  //
-wuffs_base__hexadecimal__decode4(wuffs_base__slice_u8 dst,
-                                 wuffs_base__slice_u8 src) {
-  size_t src_len4 = src.len / 4;
-  size_t len = dst.len < src_len4 ? dst.len : src_len4;
-  uint8_t* d = dst.ptr;
-  uint8_t* s = src.ptr;
-  size_t n = len;
-
-  while (n--) {
-    *d = (uint8_t)((wuffs_base__parse_number__hexadecimal_digits[s[2]] << 4) |
-                   (wuffs_base__parse_number__hexadecimal_digits[s[3]] & 0x0F));
-    d += 1;
-    s += 4;
-  }
-
-  return len;
-}
-
-// ---------------- Unicode and UTF-8
-
-WUFFS_BASE__MAYBE_STATIC size_t  //
-wuffs_base__utf_8__encode(wuffs_base__slice_u8 dst, uint32_t code_point) {
-  if (code_point <= 0x7F) {
-    if (dst.len >= 1) {
-      dst.ptr[0] = (uint8_t)(code_point);
-      return 1;
-    }
-
-  } else if (code_point <= 0x07FF) {
-    if (dst.len >= 2) {
-      dst.ptr[0] = (uint8_t)(0xC0 | ((code_point >> 6)));
-      dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));
-      return 2;
-    }
-
-  } else if (code_point <= 0xFFFF) {
-    if ((dst.len >= 3) && ((code_point < 0xD800) || (0xDFFF < code_point))) {
-      dst.ptr[0] = (uint8_t)(0xE0 | ((code_point >> 12)));
-      dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 6) & 0x3F));
-      dst.ptr[2] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));
-      return 3;
-    }
-
-  } else if (code_point <= 0x10FFFF) {
-    if (dst.len >= 4) {
-      dst.ptr[0] = (uint8_t)(0xF0 | ((code_point >> 18)));
-      dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 12) & 0x3F));
-      dst.ptr[2] = (uint8_t)(0x80 | ((code_point >> 6) & 0x3F));
-      dst.ptr[3] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));
-      return 4;
-    }
-  }
-
-  return 0;
-}
-
-// wuffs_base__utf_8__byte_length_minus_1 is the byte length (minus 1) of a
-// UTF-8 encoded code point, based on the encoding's initial byte.
-//  - 0x00 is 1-byte UTF-8 (ASCII).
-//  - 0x01 is the start of 2-byte UTF-8.
-//  - 0x02 is the start of 3-byte UTF-8.
-//  - 0x03 is the start of 4-byte UTF-8.
-//  - 0x40 is a UTF-8 tail byte.
-//  - 0x80 is invalid UTF-8.
-//
-// RFC 3629 (UTF-8) gives this grammar for valid UTF-8:
-//    UTF8-1      = %x00-7F
-//    UTF8-2      = %xC2-DF UTF8-tail
-//    UTF8-3      = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) /
-//                  %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail )
-//    UTF8-4      = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) /
-//                  %xF4 %x80-8F 2( UTF8-tail )
-//    UTF8-tail   = %x80-BF
-static const uint8_t wuffs_base__utf_8__byte_length_minus_1[256] = {
-    // 0     1     2     3     4     5     6     7
-    // 8     9     A     B     C     D     E     F
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x00 ..= 0x07.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x08 ..= 0x0F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x10 ..= 0x17.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x18 ..= 0x1F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x20 ..= 0x27.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x28 ..= 0x2F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x30 ..= 0x37.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x38 ..= 0x3F.
-
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x40 ..= 0x47.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x48 ..= 0x4F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x50 ..= 0x57.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x58 ..= 0x5F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x60 ..= 0x67.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x68 ..= 0x6F.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x70 ..= 0x77.
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x78 ..= 0x7F.
-
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0x80 ..= 0x87.
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0x88 ..= 0x8F.
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0x90 ..= 0x97.
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0x98 ..= 0x9F.
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0xA0 ..= 0xA7.
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0xA8 ..= 0xAF.
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0xB0 ..= 0xB7.
-    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0xB8 ..= 0xBF.
-
-    0x80, 0x80, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,  // 0xC0 ..= 0xC7.
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,  // 0xC8 ..= 0xCF.
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,  // 0xD0 ..= 0xD7.
-    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,  // 0xD8 ..= 0xDF.
-    0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,  // 0xE0 ..= 0xE7.
-    0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,  // 0xE8 ..= 0xEF.
-    0x03, 0x03, 0x03, 0x03, 0x03, 0x80, 0x80, 0x80,  // 0xF0 ..= 0xF7.
-    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,  // 0xF8 ..= 0xFF.
-    // 0     1     2     3     4     5     6     7
-    // 8     9     A     B     C     D     E     F
-};
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__utf_8__next__output  //
-wuffs_base__utf_8__next(wuffs_base__slice_u8 s) {
-  if (s.len == 0) {
-    return wuffs_base__make_utf_8__next__output(0, 0);
-  }
-  uint32_t c = s.ptr[0];
-  switch (wuffs_base__utf_8__byte_length_minus_1[c & 0xFF]) {
-    case 0:
-      return wuffs_base__make_utf_8__next__output(c, 1);
-
-    case 1:
-      if (s.len < 2) {
-        break;
-      }
-      c = wuffs_base__load_u16le__no_bounds_check(s.ptr);
-      if ((c & 0xC000) != 0x8000) {
-        break;
-      }
-      c = (0x0007C0 & (c << 6)) | (0x00003F & (c >> 8));
-      return wuffs_base__make_utf_8__next__output(c, 2);
-
-    case 2:
-      if (s.len < 3) {
-        break;
-      }
-      c = wuffs_base__load_u24le__no_bounds_check(s.ptr);
-      if ((c & 0xC0C000) != 0x808000) {
-        break;
-      }
-      c = (0x00F000 & (c << 12)) | (0x000FC0 & (c >> 2)) |
-          (0x00003F & (c >> 16));
-      if ((c <= 0x07FF) || ((0xD800 <= c) && (c <= 0xDFFF))) {
-        break;
-      }
-      return wuffs_base__make_utf_8__next__output(c, 3);
-
-    case 3:
-      if (s.len < 4) {
-        break;
-      }
-      c = wuffs_base__load_u32le__no_bounds_check(s.ptr);
-      if ((c & 0xC0C0C000) != 0x80808000) {
-        break;
-      }
-      c = (0x1C0000 & (c << 18)) | (0x03F000 & (c << 4)) |
-          (0x000FC0 & (c >> 10)) | (0x00003F & (c >> 24));
-      if ((c <= 0xFFFF) || (0x110000 <= c)) {
-        break;
-      }
-      return wuffs_base__make_utf_8__next__output(c, 4);
-  }
-
-  return wuffs_base__make_utf_8__next__output(
-      WUFFS_BASE__UNICODE_REPLACEMENT_CHARACTER, 1);
-}
-
-WUFFS_BASE__MAYBE_STATIC size_t  //
-wuffs_base__utf_8__longest_valid_prefix(wuffs_base__slice_u8 s) {
-  // TODO: possibly optimize the all-ASCII case (4 or 8 bytes at a time).
-  //
-  // TODO: possibly optimize this by manually inlining the
-  // wuffs_base__utf_8__next calls.
-  size_t original_len = s.len;
-  while (s.len > 0) {
-    wuffs_base__utf_8__next__output o = wuffs_base__utf_8__next(s);
-    if ((o.code_point > 0x7F) && (o.byte_length == 1)) {
-      break;
-    }
-    s.ptr += o.byte_length;
-    s.len -= o.byte_length;
-  }
-  return original_len - s.len;
-}
-
-WUFFS_BASE__MAYBE_STATIC size_t  //
-wuffs_base__ascii__longest_valid_prefix(wuffs_base__slice_u8 s) {
-  // TODO: possibly optimize this by checking 4 or 8 bytes at a time.
-  uint8_t* original_ptr = s.ptr;
-  uint8_t* p = s.ptr;
-  uint8_t* q = s.ptr + s.len;
-  for (; (p != q) && ((*p & 0x80) == 0); p++) {
-  }
-  return (size_t)(p - original_ptr);
-}
+const char wuffs_base__hasher_u32__vtable_name[] = "{vtable}wuffs_base__hasher_u32";
+const char wuffs_base__image_decoder__vtable_name[] = "{vtable}wuffs_base__image_decoder";
+const char wuffs_base__io_transformer__vtable_name[] = "{vtable}wuffs_base__io_transformer";
+const char wuffs_base__token_decoder__vtable_name[] = "{vtable}wuffs_base__token_decoder";
 
 #endif  // !defined(WUFFS_CONFIG__MODULES) ||
         // defined(WUFFS_CONFIG__MODULE__BASE)  ||
@@ -9300,8 +8942,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)).
@@ -9311,14 +8953,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.
 //
@@ -9340,8 +8982,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.
 //
@@ -9373,6 +9015,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,
@@ -9748,6 +9432,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(
@@ -9861,6 +9550,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
@@ -10547,11 +10484,737 @@
   } 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)
 
 #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \
+    defined(WUFFS_CONFIG__MODULE__BASE__I64CONV)
+
+// ---------------- Integer
+
+// wuffs_base__parse_number__foo_digits entries are 0x00 for invalid digits,
+// and (0x80 | v) for valid digits, where v is the 4 bit value.
+
+static const uint8_t wuffs_base__parse_number__decimal_digits[256] = {
+    // 0     1     2     3     4     5     6     7
+    // 8     9     A     B     C     D     E     F
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x00 ..= 0x07.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x08 ..= 0x0F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x10 ..= 0x17.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x18 ..= 0x1F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x20 ..= 0x27.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x28 ..= 0x2F.
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,  // 0x30 ..= 0x37. '0'-'7'.
+    0x88, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x38 ..= 0x3F. '8'-'9'.
+
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x40 ..= 0x47.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x48 ..= 0x4F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x50 ..= 0x57.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x58 ..= 0x5F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x60 ..= 0x67.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x68 ..= 0x6F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x70 ..= 0x77.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x78 ..= 0x7F.
+
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x80 ..= 0x87.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x88 ..= 0x8F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x90 ..= 0x97.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x98 ..= 0x9F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xA0 ..= 0xA7.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xA8 ..= 0xAF.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xB0 ..= 0xB7.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xB8 ..= 0xBF.
+
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xC0 ..= 0xC7.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xC8 ..= 0xCF.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xD0 ..= 0xD7.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xD8 ..= 0xDF.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xE0 ..= 0xE7.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xE8 ..= 0xEF.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xF0 ..= 0xF7.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xF8 ..= 0xFF.
+    // 0     1     2     3     4     5     6     7
+    // 8     9     A     B     C     D     E     F
+};
+
+static const uint8_t wuffs_base__parse_number__hexadecimal_digits[256] = {
+    // 0     1     2     3     4     5     6     7
+    // 8     9     A     B     C     D     E     F
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x00 ..= 0x07.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x08 ..= 0x0F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x10 ..= 0x17.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x18 ..= 0x1F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x20 ..= 0x27.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x28 ..= 0x2F.
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,  // 0x30 ..= 0x37. '0'-'7'.
+    0x88, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x38 ..= 0x3F. '8'-'9'.
+
+    0x00, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x00,  // 0x40 ..= 0x47. 'A'-'F'.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x48 ..= 0x4F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x50 ..= 0x57.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x58 ..= 0x5F.
+    0x00, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x00,  // 0x60 ..= 0x67. 'a'-'f'.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x68 ..= 0x6F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x70 ..= 0x77.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x78 ..= 0x7F.
+
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x80 ..= 0x87.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x88 ..= 0x8F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x90 ..= 0x97.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x98 ..= 0x9F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xA0 ..= 0xA7.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xA8 ..= 0xAF.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xB0 ..= 0xB7.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xB8 ..= 0xBF.
+
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xC0 ..= 0xC7.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xC8 ..= 0xCF.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xD0 ..= 0xD7.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xD8 ..= 0xDF.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xE0 ..= 0xE7.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xE8 ..= 0xEF.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xF0 ..= 0xF7.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0xF8 ..= 0xFF.
+    // 0     1     2     3     4     5     6     7
+    // 8     9     A     B     C     D     E     F
+};
+
+// --------
+
+WUFFS_BASE__MAYBE_STATIC wuffs_base__result_i64  //
+wuffs_base__parse_number_i64(wuffs_base__slice_u8 s) {
+  uint8_t* p = s.ptr;
+  uint8_t* q = s.ptr + s.len;
+
+  for (; (p < q) && (*p == '_'); p++) {
+  }
+
+  bool negative = false;
+  if (p >= q) {
+    goto fail_bad_argument;
+  } else if (*p == '-') {
+    p++;
+    negative = true;
+  } else if (*p == '+') {
+    p++;
+  }
+
+  do {
+    wuffs_base__result_u64 r = wuffs_base__parse_number_u64(
+        wuffs_base__make_slice_u8(p, (size_t)(q - p)));
+    if (r.status.repr != NULL) {
+      wuffs_base__result_i64 ret;
+      ret.status.repr = r.status.repr;
+      ret.value = 0;
+      return ret;
+    } else if (negative) {
+      if (r.value > 0x8000000000000000) {
+        goto fail_out_of_bounds;
+      }
+      wuffs_base__result_i64 ret;
+      ret.status.repr = NULL;
+      ret.value = -(int64_t)(r.value);
+      return ret;
+    } else if (r.value > 0x7FFFFFFFFFFFFFFF) {
+      goto fail_out_of_bounds;
+    } else {
+      wuffs_base__result_i64 ret;
+      ret.status.repr = NULL;
+      ret.value = +(int64_t)(r.value);
+      return ret;
+    }
+  } while (0);
+
+fail_bad_argument:
+  do {
+    wuffs_base__result_i64 ret;
+    ret.status.repr = wuffs_base__error__bad_argument;
+    ret.value = 0;
+    return ret;
+  } while (0);
+
+fail_out_of_bounds:
+  do {
+    wuffs_base__result_i64 ret;
+    ret.status.repr = wuffs_base__error__out_of_bounds;
+    ret.value = 0;
+    return ret;
+  } while (0);
+}
+
+WUFFS_BASE__MAYBE_STATIC wuffs_base__result_u64  //
+wuffs_base__parse_number_u64(wuffs_base__slice_u8 s) {
+  uint8_t* p = s.ptr;
+  uint8_t* q = s.ptr + s.len;
+
+  for (; (p < q) && (*p == '_'); p++) {
+  }
+
+  if (p >= q) {
+    goto fail_bad_argument;
+
+  } else if (*p == '0') {
+    p++;
+    if (p >= q) {
+      goto ok_zero;
+    }
+    if (*p == '_') {
+      p++;
+      for (; p < q; p++) {
+        if (*p != '_') {
+          goto fail_bad_argument;
+        }
+      }
+      goto ok_zero;
+    }
+
+    if ((*p == 'x') || (*p == 'X')) {
+      p++;
+      for (; (p < q) && (*p == '_'); p++) {
+      }
+      if (p < q) {
+        goto hexadecimal;
+      }
+
+    } else if ((*p == 'd') || (*p == 'D')) {
+      p++;
+      for (; (p < q) && (*p == '_'); p++) {
+      }
+      if (p < q) {
+        goto decimal;
+      }
+    }
+
+    goto fail_bad_argument;
+  }
+
+decimal:
+  do {
+    uint64_t v = wuffs_base__parse_number__decimal_digits[*p++];
+    if (v == 0) {
+      goto fail_bad_argument;
+    }
+    v &= 0x0F;
+
+    // UINT64_MAX is 18446744073709551615, which is ((10 * max10) + max1).
+    const uint64_t max10 = 1844674407370955161u;
+    const uint8_t max1 = 5;
+
+    for (; p < q; p++) {
+      if (*p == '_') {
+        continue;
+      }
+      uint8_t digit = wuffs_base__parse_number__decimal_digits[*p];
+      if (digit == 0) {
+        goto fail_bad_argument;
+      }
+      digit &= 0x0F;
+      if ((v > max10) || ((v == max10) && (digit > max1))) {
+        goto fail_out_of_bounds;
+      }
+      v = (10 * v) + ((uint64_t)(digit));
+    }
+
+    wuffs_base__result_u64 ret;
+    ret.status.repr = NULL;
+    ret.value = v;
+    return ret;
+  } while (0);
+
+hexadecimal:
+  do {
+    uint64_t v = wuffs_base__parse_number__hexadecimal_digits[*p++];
+    if (v == 0) {
+      goto fail_bad_argument;
+    }
+    v &= 0x0F;
+
+    for (; p < q; p++) {
+      if (*p == '_') {
+        continue;
+      }
+      uint8_t digit = wuffs_base__parse_number__hexadecimal_digits[*p];
+      if (digit == 0) {
+        goto fail_bad_argument;
+      }
+      digit &= 0x0F;
+      if ((v >> 60) != 0) {
+        goto fail_out_of_bounds;
+      }
+      v = (v << 4) | ((uint64_t)(digit));
+    }
+
+    wuffs_base__result_u64 ret;
+    ret.status.repr = NULL;
+    ret.value = v;
+    return ret;
+  } while (0);
+
+ok_zero:
+  do {
+    wuffs_base__result_u64 ret;
+    ret.status.repr = NULL;
+    ret.value = 0;
+    return ret;
+  } while (0);
+
+fail_bad_argument:
+  do {
+    wuffs_base__result_u64 ret;
+    ret.status.repr = wuffs_base__error__bad_argument;
+    ret.value = 0;
+    return ret;
+  } while (0);
+
+fail_out_of_bounds:
+  do {
+    wuffs_base__result_u64 ret;
+    ret.status.repr = wuffs_base__error__out_of_bounds;
+    ret.value = 0;
+    return ret;
+  } while (0);
+}
+
+// --------
+
+// wuffs_base__render_number__first_hundred contains the decimal encodings of
+// the first one hundred numbers [0 ..= 99].
+static const uint8_t wuffs_base__render_number__first_hundred[200] = {
+    '0', '0', '0', '1', '0', '2', '0', '3', '0', '4',  //
+    '0', '5', '0', '6', '0', '7', '0', '8', '0', '9',  //
+    '1', '0', '1', '1', '1', '2', '1', '3', '1', '4',  //
+    '1', '5', '1', '6', '1', '7', '1', '8', '1', '9',  //
+    '2', '0', '2', '1', '2', '2', '2', '3', '2', '4',  //
+    '2', '5', '2', '6', '2', '7', '2', '8', '2', '9',  //
+    '3', '0', '3', '1', '3', '2', '3', '3', '3', '4',  //
+    '3', '5', '3', '6', '3', '7', '3', '8', '3', '9',  //
+    '4', '0', '4', '1', '4', '2', '4', '3', '4', '4',  //
+    '4', '5', '4', '6', '4', '7', '4', '8', '4', '9',  //
+    '5', '0', '5', '1', '5', '2', '5', '3', '5', '4',  //
+    '5', '5', '5', '6', '5', '7', '5', '8', '5', '9',  //
+    '6', '0', '6', '1', '6', '2', '6', '3', '6', '4',  //
+    '6', '5', '6', '6', '6', '7', '6', '8', '6', '9',  //
+    '7', '0', '7', '1', '7', '2', '7', '3', '7', '4',  //
+    '7', '5', '7', '6', '7', '7', '7', '8', '7', '9',  //
+    '8', '0', '8', '1', '8', '2', '8', '3', '8', '4',  //
+    '8', '5', '8', '6', '8', '7', '8', '8', '8', '9',  //
+    '9', '0', '9', '1', '9', '2', '9', '3', '9', '4',  //
+    '9', '5', '9', '6', '9', '7', '9', '8', '9', '9',  //
+};
+
+static size_t  //
+wuffs_base__private_implementation__render_number_u64(wuffs_base__slice_u8 dst,
+                                                      uint64_t x,
+                                                      uint32_t options,
+                                                      bool neg) {
+  uint8_t buf[WUFFS_BASE__U64__BYTE_LENGTH__MAX_INCL];
+  uint8_t* ptr = &buf[0] + sizeof(buf);
+
+  while (x >= 100) {
+    size_t index = (x % 100) * 2;
+    x /= 100;
+    uint8_t s0 = wuffs_base__render_number__first_hundred[index + 0];
+    uint8_t s1 = wuffs_base__render_number__first_hundred[index + 1];
+    ptr -= 2;
+    ptr[0] = s0;
+    ptr[1] = s1;
+  }
+
+  if (x < 10) {
+    ptr -= 1;
+    ptr[0] = (uint8_t)('0' + x);
+  } else {
+    size_t index = x * 2;
+    uint8_t s0 = wuffs_base__render_number__first_hundred[index + 0];
+    uint8_t s1 = wuffs_base__render_number__first_hundred[index + 1];
+    ptr -= 2;
+    ptr[0] = s0;
+    ptr[1] = s1;
+  }
+
+  if (neg) {
+    ptr -= 1;
+    ptr[0] = '-';
+  } else if (options & WUFFS_BASE__RENDER_NUMBER_XXX__LEADING_PLUS_SIGN) {
+    ptr -= 1;
+    ptr[0] = '+';
+  }
+
+  size_t n = sizeof(buf) - ((size_t)(ptr - &buf[0]));
+  if (n > dst.len) {
+    return 0;
+  }
+  memcpy(dst.ptr + ((options & WUFFS_BASE__RENDER_NUMBER_XXX__ALIGN_RIGHT)
+                        ? (dst.len - n)
+                        : 0),
+         ptr, n);
+  return n;
+}
+
+WUFFS_BASE__MAYBE_STATIC size_t  //
+wuffs_base__render_number_i64(wuffs_base__slice_u8 dst,
+                              int64_t x,
+                              uint32_t options) {
+  uint64_t u = (uint64_t)x;
+  bool neg = x < 0;
+  if (neg) {
+    u = 1 + ~u;
+  }
+  return wuffs_base__private_implementation__render_number_u64(dst, u, options,
+                                                               neg);
+}
+
+WUFFS_BASE__MAYBE_STATIC size_t  //
+wuffs_base__render_number_u64(wuffs_base__slice_u8 dst,
+                              uint64_t x,
+                              uint32_t options) {
+  return wuffs_base__private_implementation__render_number_u64(dst, x, options,
+                                                               false);
+}
+
+// ---------------- Hexadecimal
+
+WUFFS_BASE__MAYBE_STATIC size_t  //
+wuffs_base__hexadecimal__decode2(wuffs_base__slice_u8 dst,
+                                 wuffs_base__slice_u8 src) {
+  size_t src_len2 = src.len / 2;
+  size_t len = dst.len < src_len2 ? dst.len : src_len2;
+  uint8_t* d = dst.ptr;
+  uint8_t* s = src.ptr;
+  size_t n = len;
+
+  while (n--) {
+    *d = (uint8_t)((wuffs_base__parse_number__hexadecimal_digits[s[0]] << 4) |
+                   (wuffs_base__parse_number__hexadecimal_digits[s[1]] & 0x0F));
+    d += 1;
+    s += 2;
+  }
+
+  return len;
+}
+
+WUFFS_BASE__MAYBE_STATIC size_t  //
+wuffs_base__hexadecimal__decode4(wuffs_base__slice_u8 dst,
+                                 wuffs_base__slice_u8 src) {
+  size_t src_len4 = src.len / 4;
+  size_t len = dst.len < src_len4 ? dst.len : src_len4;
+  uint8_t* d = dst.ptr;
+  uint8_t* s = src.ptr;
+  size_t n = len;
+
+  while (n--) {
+    *d = (uint8_t)((wuffs_base__parse_number__hexadecimal_digits[s[2]] << 4) |
+                   (wuffs_base__parse_number__hexadecimal_digits[s[3]] & 0x0F));
+    d += 1;
+    s += 4;
+  }
+
+  return len;
+}
+
+#endif  // !defined(WUFFS_CONFIG__MODULES) ||
+        // defined(WUFFS_CONFIG__MODULE__BASE) ||
+        // defined(WUFFS_CONFIG__MODULE__BASE__I64CONV)
+
+#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \
     defined(WUFFS_CONFIG__MODULE__BASE__PIXCONV)
 
 // ---------------- Pixel Swizzler
@@ -12063,6 +12726,195 @@
         // defined(WUFFS_CONFIG__MODULE__BASE) ||
         // defined(WUFFS_CONFIG__MODULE__BASE__PIXCONV)
 
+#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE) || \
+    defined(WUFFS_CONFIG__MODULE__BASE__UTF8)
+
+// ---------------- Unicode and UTF-8
+
+WUFFS_BASE__MAYBE_STATIC size_t  //
+wuffs_base__utf_8__encode(wuffs_base__slice_u8 dst, uint32_t code_point) {
+  if (code_point <= 0x7F) {
+    if (dst.len >= 1) {
+      dst.ptr[0] = (uint8_t)(code_point);
+      return 1;
+    }
+
+  } else if (code_point <= 0x07FF) {
+    if (dst.len >= 2) {
+      dst.ptr[0] = (uint8_t)(0xC0 | ((code_point >> 6)));
+      dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));
+      return 2;
+    }
+
+  } else if (code_point <= 0xFFFF) {
+    if ((dst.len >= 3) && ((code_point < 0xD800) || (0xDFFF < code_point))) {
+      dst.ptr[0] = (uint8_t)(0xE0 | ((code_point >> 12)));
+      dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 6) & 0x3F));
+      dst.ptr[2] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));
+      return 3;
+    }
+
+  } else if (code_point <= 0x10FFFF) {
+    if (dst.len >= 4) {
+      dst.ptr[0] = (uint8_t)(0xF0 | ((code_point >> 18)));
+      dst.ptr[1] = (uint8_t)(0x80 | ((code_point >> 12) & 0x3F));
+      dst.ptr[2] = (uint8_t)(0x80 | ((code_point >> 6) & 0x3F));
+      dst.ptr[3] = (uint8_t)(0x80 | ((code_point >> 0) & 0x3F));
+      return 4;
+    }
+  }
+
+  return 0;
+}
+
+// wuffs_base__utf_8__byte_length_minus_1 is the byte length (minus 1) of a
+// UTF-8 encoded code point, based on the encoding's initial byte.
+//  - 0x00 is 1-byte UTF-8 (ASCII).
+//  - 0x01 is the start of 2-byte UTF-8.
+//  - 0x02 is the start of 3-byte UTF-8.
+//  - 0x03 is the start of 4-byte UTF-8.
+//  - 0x40 is a UTF-8 tail byte.
+//  - 0x80 is invalid UTF-8.
+//
+// RFC 3629 (UTF-8) gives this grammar for valid UTF-8:
+//    UTF8-1      = %x00-7F
+//    UTF8-2      = %xC2-DF UTF8-tail
+//    UTF8-3      = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) /
+//                  %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail )
+//    UTF8-4      = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) /
+//                  %xF4 %x80-8F 2( UTF8-tail )
+//    UTF8-tail   = %x80-BF
+static const uint8_t wuffs_base__utf_8__byte_length_minus_1[256] = {
+    // 0     1     2     3     4     5     6     7
+    // 8     9     A     B     C     D     E     F
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x00 ..= 0x07.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x08 ..= 0x0F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x10 ..= 0x17.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x18 ..= 0x1F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x20 ..= 0x27.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x28 ..= 0x2F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x30 ..= 0x37.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x38 ..= 0x3F.
+
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x40 ..= 0x47.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x48 ..= 0x4F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x50 ..= 0x57.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x58 ..= 0x5F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x60 ..= 0x67.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x68 ..= 0x6F.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x70 ..= 0x77.
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // 0x78 ..= 0x7F.
+
+    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0x80 ..= 0x87.
+    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0x88 ..= 0x8F.
+    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0x90 ..= 0x97.
+    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0x98 ..= 0x9F.
+    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0xA0 ..= 0xA7.
+    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0xA8 ..= 0xAF.
+    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0xB0 ..= 0xB7.
+    0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,  // 0xB8 ..= 0xBF.
+
+    0x80, 0x80, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,  // 0xC0 ..= 0xC7.
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,  // 0xC8 ..= 0xCF.
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,  // 0xD0 ..= 0xD7.
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,  // 0xD8 ..= 0xDF.
+    0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,  // 0xE0 ..= 0xE7.
+    0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,  // 0xE8 ..= 0xEF.
+    0x03, 0x03, 0x03, 0x03, 0x03, 0x80, 0x80, 0x80,  // 0xF0 ..= 0xF7.
+    0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,  // 0xF8 ..= 0xFF.
+    // 0     1     2     3     4     5     6     7
+    // 8     9     A     B     C     D     E     F
+};
+
+WUFFS_BASE__MAYBE_STATIC wuffs_base__utf_8__next__output  //
+wuffs_base__utf_8__next(wuffs_base__slice_u8 s) {
+  if (s.len == 0) {
+    return wuffs_base__make_utf_8__next__output(0, 0);
+  }
+  uint32_t c = s.ptr[0];
+  switch (wuffs_base__utf_8__byte_length_minus_1[c & 0xFF]) {
+    case 0:
+      return wuffs_base__make_utf_8__next__output(c, 1);
+
+    case 1:
+      if (s.len < 2) {
+        break;
+      }
+      c = wuffs_base__load_u16le__no_bounds_check(s.ptr);
+      if ((c & 0xC000) != 0x8000) {
+        break;
+      }
+      c = (0x0007C0 & (c << 6)) | (0x00003F & (c >> 8));
+      return wuffs_base__make_utf_8__next__output(c, 2);
+
+    case 2:
+      if (s.len < 3) {
+        break;
+      }
+      c = wuffs_base__load_u24le__no_bounds_check(s.ptr);
+      if ((c & 0xC0C000) != 0x808000) {
+        break;
+      }
+      c = (0x00F000 & (c << 12)) | (0x000FC0 & (c >> 2)) |
+          (0x00003F & (c >> 16));
+      if ((c <= 0x07FF) || ((0xD800 <= c) && (c <= 0xDFFF))) {
+        break;
+      }
+      return wuffs_base__make_utf_8__next__output(c, 3);
+
+    case 3:
+      if (s.len < 4) {
+        break;
+      }
+      c = wuffs_base__load_u32le__no_bounds_check(s.ptr);
+      if ((c & 0xC0C0C000) != 0x80808000) {
+        break;
+      }
+      c = (0x1C0000 & (c << 18)) | (0x03F000 & (c << 4)) |
+          (0x000FC0 & (c >> 10)) | (0x00003F & (c >> 24));
+      if ((c <= 0xFFFF) || (0x110000 <= c)) {
+        break;
+      }
+      return wuffs_base__make_utf_8__next__output(c, 4);
+  }
+
+  return wuffs_base__make_utf_8__next__output(
+      WUFFS_BASE__UNICODE_REPLACEMENT_CHARACTER, 1);
+}
+
+WUFFS_BASE__MAYBE_STATIC size_t  //
+wuffs_base__utf_8__longest_valid_prefix(wuffs_base__slice_u8 s) {
+  // TODO: possibly optimize the all-ASCII case (4 or 8 bytes at a time).
+  //
+  // TODO: possibly optimize this by manually inlining the
+  // wuffs_base__utf_8__next calls.
+  size_t original_len = s.len;
+  while (s.len > 0) {
+    wuffs_base__utf_8__next__output o = wuffs_base__utf_8__next(s);
+    if ((o.code_point > 0x7F) && (o.byte_length == 1)) {
+      break;
+    }
+    s.ptr += o.byte_length;
+    s.len -= o.byte_length;
+  }
+  return original_len - s.len;
+}
+
+WUFFS_BASE__MAYBE_STATIC size_t  //
+wuffs_base__ascii__longest_valid_prefix(wuffs_base__slice_u8 s) {
+  // TODO: possibly optimize this by checking 4 or 8 bytes at a time.
+  uint8_t* original_ptr = s.ptr;
+  uint8_t* p = s.ptr;
+  uint8_t* q = s.ptr + s.len;
+  for (; (p != q) && ((*p & 0x80) == 0); p++) {
+  }
+  return (size_t)(p - original_ptr);
+}
+
+#endif  // !defined(WUFFS_CONFIG__MODULES) ||
+        // defined(WUFFS_CONFIG__MODULE__BASE) ||
+        // defined(WUFFS_CONFIG__MODULE__BASE__UTF8)
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif
@@ -12095,7 +12947,7 @@
     wuffs_adler32__hasher* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags){
+    uint32_t options){
   if (!self) {
     return wuffs_base__make_status(wuffs_base__error__bad_receiver);
   }
@@ -12107,7 +12959,7 @@
     return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
   }
 
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+  if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
     // The whole point of this if-check is to detect an uninitialized *self.
     // We disable the warning on GCC. Clang-5.0 does not have this warning.
 #if !defined(__clang__) && defined(__GNUC__)
@@ -12121,9 +12973,9 @@
 #pragma GCC diagnostic pop
 #endif
   } else {
-    if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+    if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
       memset(self, 0, sizeof(*self));
-      initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+      options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
     } else {
       memset(&(self->private_impl), 0, sizeof(self->private_impl));
     }
@@ -12252,9 +13104,9 @@
 
 // ---------------- Status Codes Implementations
 
-const char* wuffs_bmp__error__bad_header = "#bmp: bad header";
-const char* wuffs_bmp__error__unsupported_bmp_file = "#bmp: unsupported BMP file";
-const char* wuffs_bmp__note__internal_note_short_read = "@bmp: internal note: short read";
+const char wuffs_bmp__error__bad_header[] = "#bmp: bad header";
+const char wuffs_bmp__error__unsupported_bmp_file[] = "#bmp: unsupported BMP file";
+const char wuffs_bmp__note__internal_note_short_read[] = "@bmp: internal note: short read";
 
 // ---------------- Private Consts
 
@@ -12316,7 +13168,7 @@
     wuffs_bmp__decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags){
+    uint32_t options){
   if (!self) {
     return wuffs_base__make_status(wuffs_base__error__bad_receiver);
   }
@@ -12328,7 +13180,7 @@
     return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
   }
 
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+  if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
     // The whole point of this if-check is to detect an uninitialized *self.
     // We disable the warning on GCC. Clang-5.0 does not have this warning.
 #if !defined(__clang__) && defined(__GNUC__)
@@ -12342,9 +13194,9 @@
 #pragma GCC diagnostic pop
 #endif
   } else {
-    if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+    if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
       memset(self, 0, sizeof(*self));
-      initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+      options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
     } else {
       memset(&(self->private_impl), 0, sizeof(self->private_impl));
     }
@@ -14114,7 +14966,7 @@
     wuffs_crc32__ieee_hasher* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags){
+    uint32_t options){
   if (!self) {
     return wuffs_base__make_status(wuffs_base__error__bad_receiver);
   }
@@ -14126,7 +14978,7 @@
     return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
   }
 
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+  if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
     // The whole point of this if-check is to detect an uninitialized *self.
     // We disable the warning on GCC. Clang-5.0 does not have this warning.
 #if !defined(__clang__) && defined(__GNUC__)
@@ -14140,9 +14992,9 @@
 #pragma GCC diagnostic pop
 #endif
   } else {
-    if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+    if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
       memset(self, 0, sizeof(*self));
-      initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+      options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
     } else {
       memset(&(self->private_impl), 0, sizeof(self->private_impl));
     }
@@ -14296,23 +15148,23 @@
 
 // ---------------- Status Codes Implementations
 
-const char* wuffs_deflate__error__bad_huffman_code_over_subscribed = "#deflate: bad Huffman code (over-subscribed)";
-const char* wuffs_deflate__error__bad_huffman_code_under_subscribed = "#deflate: bad Huffman code (under-subscribed)";
-const char* wuffs_deflate__error__bad_huffman_code_length_count = "#deflate: bad Huffman code length count";
-const char* wuffs_deflate__error__bad_huffman_code_length_repetition = "#deflate: bad Huffman code length repetition";
-const char* wuffs_deflate__error__bad_huffman_code = "#deflate: bad Huffman code";
-const char* wuffs_deflate__error__bad_huffman_minimum_code_length = "#deflate: bad Huffman minimum code length";
-const char* wuffs_deflate__error__bad_block = "#deflate: bad block";
-const char* wuffs_deflate__error__bad_distance = "#deflate: bad distance";
-const char* wuffs_deflate__error__bad_distance_code_count = "#deflate: bad distance code count";
-const char* wuffs_deflate__error__bad_literal_length_code_count = "#deflate: bad literal/length code count";
-const char* wuffs_deflate__error__inconsistent_stored_block_length = "#deflate: inconsistent stored block length";
-const char* wuffs_deflate__error__missing_end_of_block_code = "#deflate: missing end-of-block code";
-const char* wuffs_deflate__error__no_huffman_codes = "#deflate: no Huffman codes";
-const char* wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state = "#deflate: internal error: inconsistent Huffman decoder state";
-const char* wuffs_deflate__error__internal_error_inconsistent_i_o = "#deflate: internal error: inconsistent I/O";
-const char* wuffs_deflate__error__internal_error_inconsistent_distance = "#deflate: internal error: inconsistent distance";
-const char* wuffs_deflate__error__internal_error_inconsistent_n_bits = "#deflate: internal error: inconsistent n_bits";
+const char wuffs_deflate__error__bad_huffman_code_over_subscribed[] = "#deflate: bad Huffman code (over-subscribed)";
+const char wuffs_deflate__error__bad_huffman_code_under_subscribed[] = "#deflate: bad Huffman code (under-subscribed)";
+const char wuffs_deflate__error__bad_huffman_code_length_count[] = "#deflate: bad Huffman code length count";
+const char wuffs_deflate__error__bad_huffman_code_length_repetition[] = "#deflate: bad Huffman code length repetition";
+const char wuffs_deflate__error__bad_huffman_code[] = "#deflate: bad Huffman code";
+const char wuffs_deflate__error__bad_huffman_minimum_code_length[] = "#deflate: bad Huffman minimum code length";
+const char wuffs_deflate__error__bad_block[] = "#deflate: bad block";
+const char wuffs_deflate__error__bad_distance[] = "#deflate: bad distance";
+const char wuffs_deflate__error__bad_distance_code_count[] = "#deflate: bad distance code count";
+const char wuffs_deflate__error__bad_literal_length_code_count[] = "#deflate: bad literal/length code count";
+const char wuffs_deflate__error__inconsistent_stored_block_length[] = "#deflate: inconsistent stored block length";
+const char wuffs_deflate__error__missing_end_of_block_code[] = "#deflate: missing end-of-block code";
+const char wuffs_deflate__error__no_huffman_codes[] = "#deflate: no Huffman codes";
+const char wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state[] = "#deflate: internal error: inconsistent Huffman decoder state";
+const char wuffs_deflate__error__internal_error_inconsistent_i_o[] = "#deflate: internal error: inconsistent I/O";
+const char wuffs_deflate__error__internal_error_inconsistent_distance[] = "#deflate: internal error: inconsistent distance";
+const char wuffs_deflate__error__internal_error_inconsistent_n_bits[] = "#deflate: internal error: inconsistent n_bits";
 
 // ---------------- Private Consts
 
@@ -14445,7 +15297,7 @@
     wuffs_deflate__decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags){
+    uint32_t options){
   if (!self) {
     return wuffs_base__make_status(wuffs_base__error__bad_receiver);
   }
@@ -14457,7 +15309,7 @@
     return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
   }
 
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+  if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
     // The whole point of this if-check is to detect an uninitialized *self.
     // We disable the warning on GCC. Clang-5.0 does not have this warning.
 #if !defined(__clang__) && defined(__GNUC__)
@@ -14471,9 +15323,9 @@
 #pragma GCC diagnostic pop
 #endif
   } else {
-    if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+    if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
       memset(self, 0, sizeof(*self));
-      initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+      options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
     } else {
       memset(&(self->private_impl), 0, sizeof(self->private_impl));
     }
@@ -16123,8 +16975,8 @@
 
 // ---------------- Status Codes Implementations
 
-const char* wuffs_lzw__error__bad_code = "#lzw: bad code";
-const char* wuffs_lzw__error__internal_error_inconsistent_i_o = "#lzw: internal error: inconsistent I/O";
+const char wuffs_lzw__error__bad_code[] = "#lzw: bad code";
+const char wuffs_lzw__error__internal_error_inconsistent_i_o[] = "#lzw: internal error: inconsistent I/O";
 
 // ---------------- Private Consts
 
@@ -16163,7 +17015,7 @@
     wuffs_lzw__decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags){
+    uint32_t options){
   if (!self) {
     return wuffs_base__make_status(wuffs_base__error__bad_receiver);
   }
@@ -16175,7 +17027,7 @@
     return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
   }
 
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+  if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
     // The whole point of this if-check is to detect an uninitialized *self.
     // We disable the warning on GCC. Clang-5.0 does not have this warning.
 #if !defined(__clang__) && defined(__GNUC__)
@@ -16189,9 +17041,9 @@
 #pragma GCC diagnostic pop
 #endif
   } else {
-    if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+    if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
       memset(self, 0, sizeof(*self));
-      initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+      options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
     } else {
       memset(&(self->private_impl), 0, sizeof(self->private_impl));
     }
@@ -16649,13 +17501,13 @@
 
 // ---------------- Status Codes Implementations
 
-const char* wuffs_gif__error__bad_extension_label = "#gif: bad extension label";
-const char* wuffs_gif__error__bad_frame_size = "#gif: bad frame size";
-const char* wuffs_gif__error__bad_graphic_control = "#gif: bad graphic control";
-const char* wuffs_gif__error__bad_header = "#gif: bad header";
-const char* wuffs_gif__error__bad_literal_width = "#gif: bad literal width";
-const char* wuffs_gif__error__bad_palette = "#gif: bad palette";
-const char* wuffs_gif__error__internal_error_inconsistent_ri_wi = "#gif: internal error: inconsistent ri/wi";
+const char wuffs_gif__error__bad_extension_label[] = "#gif: bad extension label";
+const char wuffs_gif__error__bad_frame_size[] = "#gif: bad frame size";
+const char wuffs_gif__error__bad_graphic_control[] = "#gif: bad graphic control";
+const char wuffs_gif__error__bad_header[] = "#gif: bad header";
+const char wuffs_gif__error__bad_literal_width[] = "#gif: bad literal width";
+const char wuffs_gif__error__bad_palette[] = "#gif: bad palette";
+const char wuffs_gif__error__internal_error_inconsistent_ri_wi[] = "#gif: internal error: inconsistent ri/wi";
 
 // ---------------- Private Consts
 
@@ -16901,7 +17753,7 @@
     wuffs_gif__config_decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags){
+    uint32_t options){
   if (!self) {
     return wuffs_base__make_status(wuffs_base__error__bad_receiver);
   }
@@ -16913,7 +17765,7 @@
     return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
   }
 
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+  if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
     // The whole point of this if-check is to detect an uninitialized *self.
     // We disable the warning on GCC. Clang-5.0 does not have this warning.
 #if !defined(__clang__) && defined(__GNUC__)
@@ -16927,9 +17779,9 @@
 #pragma GCC diagnostic pop
 #endif
   } else {
-    if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+    if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
       memset(self, 0, sizeof(*self));
-      initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+      options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
     } else {
       memset(&(self->private_impl), 0, sizeof(self->private_impl));
     }
@@ -16968,7 +17820,7 @@
     wuffs_gif__decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags){
+    uint32_t options){
   if (!self) {
     return wuffs_base__make_status(wuffs_base__error__bad_receiver);
   }
@@ -16980,7 +17832,7 @@
     return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
   }
 
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+  if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
     // The whole point of this if-check is to detect an uninitialized *self.
     // We disable the warning on GCC. Clang-5.0 does not have this warning.
 #if !defined(__clang__) && defined(__GNUC__)
@@ -16994,9 +17846,9 @@
 #pragma GCC diagnostic pop
 #endif
   } else {
-    if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+    if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
       memset(self, 0, sizeof(*self));
-      initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+      options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
     } else {
       memset(&(self->private_impl), 0, sizeof(self->private_impl));
     }
@@ -17004,7 +17856,7 @@
 
   {
     wuffs_base__status z = wuffs_lzw__decoder__initialize(
-        &self->private_data.f_lzw, sizeof(self->private_data.f_lzw), WUFFS_VERSION, initialize_flags);
+        &self->private_data.f_lzw, sizeof(self->private_data.f_lzw), WUFFS_VERSION, options);
     if (z.repr) {
       return z;
     }
@@ -21129,10 +21981,10 @@
 
 // ---------------- Status Codes Implementations
 
-const char* wuffs_gzip__error__bad_checksum = "#gzip: bad checksum";
-const char* wuffs_gzip__error__bad_compression_method = "#gzip: bad compression method";
-const char* wuffs_gzip__error__bad_encoding_flags = "#gzip: bad encoding flags";
-const char* wuffs_gzip__error__bad_header = "#gzip: bad header";
+const char wuffs_gzip__error__bad_checksum[] = "#gzip: bad checksum";
+const char wuffs_gzip__error__bad_compression_method[] = "#gzip: bad compression method";
+const char wuffs_gzip__error__bad_encoding_flags[] = "#gzip: bad encoding flags";
+const char wuffs_gzip__error__bad_header[] = "#gzip: bad header";
 
 // ---------------- Private Consts
 
@@ -21161,7 +22013,7 @@
     wuffs_gzip__decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags){
+    uint32_t options){
   if (!self) {
     return wuffs_base__make_status(wuffs_base__error__bad_receiver);
   }
@@ -21173,7 +22025,7 @@
     return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
   }
 
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+  if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
     // The whole point of this if-check is to detect an uninitialized *self.
     // We disable the warning on GCC. Clang-5.0 does not have this warning.
 #if !defined(__clang__) && defined(__GNUC__)
@@ -21187,9 +22039,9 @@
 #pragma GCC diagnostic pop
 #endif
   } else {
-    if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+    if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
       memset(self, 0, sizeof(*self));
-      initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+      options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
     } else {
       memset(&(self->private_impl), 0, sizeof(self->private_impl));
     }
@@ -21197,14 +22049,14 @@
 
   {
     wuffs_base__status z = wuffs_crc32__ieee_hasher__initialize(
-        &self->private_data.f_checksum, sizeof(self->private_data.f_checksum), WUFFS_VERSION, initialize_flags);
+        &self->private_data.f_checksum, sizeof(self->private_data.f_checksum), WUFFS_VERSION, options);
     if (z.repr) {
       return z;
     }
   }
   {
     wuffs_base__status z = wuffs_deflate__decoder__initialize(
-        &self->private_data.f_flate, sizeof(self->private_data.f_flate), WUFFS_VERSION, initialize_flags);
+        &self->private_data.f_flate, sizeof(self->private_data.f_flate), WUFFS_VERSION, options);
     if (z.repr) {
       return z;
     }
@@ -21629,13 +22481,13 @@
 
 // ---------------- Status Codes Implementations
 
-const char* wuffs_json__error__bad_c0_control_code = "#json: bad C0 control code";
-const char* wuffs_json__error__bad_utf_8 = "#json: bad UTF-8";
-const char* wuffs_json__error__bad_backslash_escape = "#json: bad backslash-escape";
-const char* wuffs_json__error__bad_input = "#json: bad input";
-const char* wuffs_json__error__unsupported_number_length = "#json: unsupported number length";
-const char* wuffs_json__error__unsupported_recursion_depth = "#json: unsupported recursion depth";
-const char* wuffs_json__error__internal_error_inconsistent_i_o = "#json: internal error: inconsistent I/O";
+const char wuffs_json__error__bad_c0_control_code[] = "#json: bad C0 control code";
+const char wuffs_json__error__bad_utf_8[] = "#json: bad UTF-8";
+const char wuffs_json__error__bad_backslash_escape[] = "#json: bad backslash-escape";
+const char wuffs_json__error__bad_input[] = "#json: bad input";
+const char wuffs_json__error__unsupported_number_length[] = "#json: unsupported number length";
+const char wuffs_json__error__unsupported_recursion_depth[] = "#json: unsupported recursion depth";
+const char wuffs_json__error__internal_error_inconsistent_i_o[] = "#json: internal error: inconsistent I/O";
 
 // ---------------- Private Consts
 
@@ -21937,7 +22789,7 @@
     wuffs_json__decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags){
+    uint32_t options){
   if (!self) {
     return wuffs_base__make_status(wuffs_base__error__bad_receiver);
   }
@@ -21949,7 +22801,7 @@
     return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
   }
 
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+  if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
     // The whole point of this if-check is to detect an uninitialized *self.
     // We disable the warning on GCC. Clang-5.0 does not have this warning.
 #if !defined(__clang__) && defined(__GNUC__)
@@ -21963,9 +22815,9 @@
 #pragma GCC diagnostic pop
 #endif
   } else {
-    if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+    if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
       memset(self, 0, sizeof(*self));
-      initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+      options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
     } else {
       memset(&(self->private_impl), 0, sizeof(self->private_impl));
     }
@@ -23827,7 +24679,7 @@
 
 // ---------------- Status Codes Implementations
 
-const char* wuffs_wbmp__error__bad_header = "#wbmp: bad header";
+const char wuffs_wbmp__error__bad_header[] = "#wbmp: bad header";
 
 // ---------------- Private Consts
 
@@ -23883,7 +24735,7 @@
     wuffs_wbmp__decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags){
+    uint32_t options){
   if (!self) {
     return wuffs_base__make_status(wuffs_base__error__bad_receiver);
   }
@@ -23895,7 +24747,7 @@
     return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
   }
 
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+  if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
     // The whole point of this if-check is to detect an uninitialized *self.
     // We disable the warning on GCC. Clang-5.0 does not have this warning.
 #if !defined(__clang__) && defined(__GNUC__)
@@ -23909,9 +24761,9 @@
 #pragma GCC diagnostic pop
 #endif
   } else {
-    if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+    if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
       memset(self, 0, sizeof(*self));
-      initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+      options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
     } else {
       memset(&(self->private_impl), 0, sizeof(self->private_impl));
     }
@@ -24623,12 +25475,12 @@
 
 // ---------------- Status Codes Implementations
 
-const char* wuffs_zlib__note__dictionary_required = "@zlib: dictionary required";
-const char* wuffs_zlib__error__bad_checksum = "#zlib: bad checksum";
-const char* wuffs_zlib__error__bad_compression_method = "#zlib: bad compression method";
-const char* wuffs_zlib__error__bad_compression_window_size = "#zlib: bad compression window size";
-const char* wuffs_zlib__error__bad_parity_check = "#zlib: bad parity check";
-const char* wuffs_zlib__error__incorrect_dictionary = "#zlib: incorrect dictionary";
+const char wuffs_zlib__note__dictionary_required[] = "@zlib: dictionary required";
+const char wuffs_zlib__error__bad_checksum[] = "#zlib: bad checksum";
+const char wuffs_zlib__error__bad_compression_method[] = "#zlib: bad compression method";
+const char wuffs_zlib__error__bad_compression_window_size[] = "#zlib: bad compression window size";
+const char wuffs_zlib__error__bad_parity_check[] = "#zlib: bad parity check";
+const char wuffs_zlib__error__incorrect_dictionary[] = "#zlib: incorrect dictionary";
 
 // ---------------- Private Consts
 
@@ -24657,7 +25509,7 @@
     wuffs_zlib__decoder* self,
     size_t sizeof_star_self,
     uint64_t wuffs_version,
-    uint32_t initialize_flags){
+    uint32_t options){
   if (!self) {
     return wuffs_base__make_status(wuffs_base__error__bad_receiver);
   }
@@ -24669,7 +25521,7 @@
     return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
   }
 
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+  if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
     // The whole point of this if-check is to detect an uninitialized *self.
     // We disable the warning on GCC. Clang-5.0 does not have this warning.
 #if !defined(__clang__) && defined(__GNUC__)
@@ -24683,9 +25535,9 @@
 #pragma GCC diagnostic pop
 #endif
   } else {
-    if ((initialize_flags & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+    if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
       memset(self, 0, sizeof(*self));
-      initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+      options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
     } else {
       memset(&(self->private_impl), 0, sizeof(self->private_impl));
     }
@@ -24693,21 +25545,21 @@
 
   {
     wuffs_base__status z = wuffs_adler32__hasher__initialize(
-        &self->private_data.f_checksum, sizeof(self->private_data.f_checksum), WUFFS_VERSION, initialize_flags);
+        &self->private_data.f_checksum, sizeof(self->private_data.f_checksum), WUFFS_VERSION, options);
     if (z.repr) {
       return z;
     }
   }
   {
     wuffs_base__status z = wuffs_adler32__hasher__initialize(
-        &self->private_data.f_dict_id_hasher, sizeof(self->private_data.f_dict_id_hasher), WUFFS_VERSION, initialize_flags);
+        &self->private_data.f_dict_id_hasher, sizeof(self->private_data.f_dict_id_hasher), WUFFS_VERSION, options);
     if (z.repr) {
       return z;
     }
   }
   {
     wuffs_base__status z = wuffs_deflate__decoder__initialize(
-        &self->private_data.f_flate, sizeof(self->private_data.f_flate), WUFFS_VERSION, initialize_flags);
+        &self->private_data.f_flate, sizeof(self->private_data.f_flate), WUFFS_VERSION, options);
     if (z.repr) {
       return z;
     }