diff --git a/cmd/wuffs-c/internal/cgen/base/core-private.h b/cmd/wuffs-c/internal/cgen/base/core-private.h
index a48f55f..6c09940 100644
--- a/cmd/wuffs-c/internal/cgen/base/core-private.h
+++ b/cmd/wuffs-c/internal/cgen/base/core-private.h
@@ -83,7 +83,7 @@
 
 static inline wuffs_base__empty_struct  //
 wuffs_base__return_empty_struct() {
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 // ---------------- Numeric Types
@@ -420,14 +420,14 @@
         .len = t.width,
     });
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 // ---------------- Slices and Tables (Utility)
 
 static inline wuffs_base__slice_u8  //
 wuffs_base__utility__null_slice_u8() {
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 // ---------------- Bureaucracy re -Wunused-function
diff --git a/cmd/wuffs-c/internal/cgen/base/core-public.h b/cmd/wuffs-c/internal/cgen/base/core-public.h
index 0f09e04..8b3d438 100644
--- a/cmd/wuffs-c/internal/cgen/base/core-public.h
+++ b/cmd/wuffs-c/internal/cgen/base/core-public.h
@@ -317,7 +317,7 @@
         .len = s.len - i,
     });
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 // wuffs_base__slice_u8__subslice_j returns s[:j].
@@ -331,7 +331,7 @@
         .len = j,
     });
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 // wuffs_base__slice_u8__subslice_ij returns s[i:j].
@@ -347,7 +347,7 @@
         .len = j - i,
     });
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 // ---------------- Bureaucracy re -Wunused-function
diff --git a/cmd/wuffs-c/internal/cgen/base/image-public.h b/cmd/wuffs-c/internal/cgen/base/image-public.h
index 55ccc66..92632e4 100644
--- a/cmd/wuffs-c/internal/cgen/base/image-public.h
+++ b/cmd/wuffs-c/internal/cgen/base/image-public.h
@@ -374,13 +374,17 @@
       return;
     }
   }
-  *c = ((wuffs_base__pixel_config){});
+  *c = ((wuffs_base__pixel_config){
+      .private_impl = {0},
+  });
 }
 
 static inline void  //
 wuffs_base__pixel_config__invalidate(wuffs_base__pixel_config* c) {
   if (c) {
-    *c = ((wuffs_base__pixel_config){});
+    *c = ((wuffs_base__pixel_config){
+        .private_impl = {0},
+    });
   }
 }
 
@@ -407,7 +411,7 @@
                  .max_excl_x = c->private_impl.width,
                  .max_excl_y = c->private_impl.height,
              })
-           : ((wuffs_base__rect_ie_u32){});
+           : ((wuffs_base__rect_ie_u32){0});
 }
 
 static inline uint32_t  //
@@ -566,13 +570,19 @@
     c->private_impl.first_frame_is_opaque = first_frame_is_opaque;
     return;
   }
-  *c = ((wuffs_base__image_config){});
+  *c = ((wuffs_base__image_config){
+      .pixcfg = {.private_impl = {0}},
+      .private_impl = {0},
+  });
 }
 
 static inline void  //
 wuffs_base__image_config__invalidate(wuffs_base__image_config* c) {
   if (c) {
-    *c = ((wuffs_base__image_config){});
+    *c = ((wuffs_base__image_config){
+        .pixcfg = {.private_impl = {0}},
+        .private_impl = {0},
+    });
   }
 }
 
@@ -719,7 +729,7 @@
 
 static inline wuffs_base__rect_ie_u32  //
 wuffs_base__frame_config__bounds(wuffs_base__frame_config* c) {
-  return c ? c->private_impl.bounds : ((wuffs_base__rect_ie_u32){});
+  return c ? c->private_impl.bounds : ((wuffs_base__rect_ie_u32){0});
 }
 
 static inline uint32_t  //
@@ -851,7 +861,7 @@
   if (!b) {
     return wuffs_base__error__bad_receiver;
   }
-  *b = ((wuffs_base__pixel_buffer){});
+  memset(b, 0, sizeof(*b));
   if (!pixcfg) {
     return wuffs_base__error__bad_argument;
   }
@@ -923,7 +933,7 @@
       });
     }
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 static inline wuffs_base__pixel_format  //
@@ -938,7 +948,7 @@
 wuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) {
   return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))
              ? b->private_impl.planes[p]
-             : ((wuffs_base__table_u8){});
+             : ((wuffs_base__table_u8){0});
 }
 
 #ifdef __cplusplus
diff --git a/cmd/wuffs-c/internal/cgen/base/io-private.h b/cmd/wuffs-c/internal/cgen/base/io-private.h
index e532381..a2d9d14 100644
--- a/cmd/wuffs-c/internal/cgen/base/io-private.h
+++ b/cmd/wuffs-c/internal/cgen/base/io-private.h
@@ -205,7 +205,7 @@
   o->private_impl.limit = data.ptr + data.len;
   *ptr_iop_r = data.ptr;
   *ptr_io1_r = data.ptr + data.len;
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 static inline wuffs_base__empty_struct  //
@@ -215,13 +215,13 @@
   if (o && (((size_t)(o->private_impl.limit - iop_r)) > limit)) {
     o->private_impl.limit = iop_r + limit;
   }
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 static inline wuffs_base__empty_struct  //
 wuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) {
   o->private_impl.mark = mark;
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 static inline wuffs_base__slice_u8  //
@@ -234,7 +234,7 @@
         .len = n,
     });
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 static inline wuffs_base__empty_struct  //
@@ -254,25 +254,25 @@
   o->private_impl.limit = data.ptr + data.len;
   *ptr_iop_w = data.ptr;
   *ptr_io1_w = data.ptr + data.len;
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 static inline wuffs_base__empty_struct  //
 wuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) {
   o->private_impl.mark = mark;
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 // ---------------- I/O (Utility)
 
 static inline wuffs_base__io_reader  //
 wuffs_base__utility__null_io_reader() {
-  return ((wuffs_base__io_reader){});
+  return ((wuffs_base__io_reader){.private_impl = {0}});
 }
 
 static inline wuffs_base__io_writer  //
 wuffs_base__utility__null_io_writer() {
-  return ((wuffs_base__io_writer){});
+  return ((wuffs_base__io_writer){.private_impl = {0}});
 }
 
 // ---------------- Bureaucracy re -Wunused-function
diff --git a/cmd/wuffs-c/internal/cgen/base/io-public.h b/cmd/wuffs-c/internal/cgen/base/io-public.h
index 61affe2..fef9548 100644
--- a/cmd/wuffs-c/internal/cgen/base/io-public.h
+++ b/cmd/wuffs-c/internal/cgen/base/io-public.h
@@ -89,14 +89,14 @@
 
 static inline wuffs_base__io_reader  //
 wuffs_base__io_buffer__reader(wuffs_base__io_buffer* buf) {
-  wuffs_base__io_reader ret = ((wuffs_base__io_reader){});
+  wuffs_base__io_reader ret = ((wuffs_base__io_reader){.private_impl = {0}});
   ret.private_impl.buf = buf;
   return ret;
 }
 
 static inline wuffs_base__io_writer  //
 wuffs_base__io_buffer__writer(wuffs_base__io_buffer* buf) {
-  wuffs_base__io_writer ret = ((wuffs_base__io_writer){});
+  wuffs_base__io_writer ret = ((wuffs_base__io_writer){.private_impl = {0}});
   ret.private_impl.buf = buf;
   return ret;
 }
diff --git a/cmd/wuffs-c/internal/cgen/base/memory-public.h b/cmd/wuffs-c/internal/cgen/base/memory-public.h
index 0d8c662..111115e 100644
--- a/cmd/wuffs-c/internal/cgen/base/memory-public.h
+++ b/cmd/wuffs-c/internal/cgen/base/memory-public.h
@@ -40,7 +40,7 @@
       });
     }
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 static inline wuffs_base__slice_u16  //
@@ -54,7 +54,7 @@
       });
     }
   }
-  return ((wuffs_base__slice_u16){});
+  return ((wuffs_base__slice_u16){0});
 }
 
 static inline wuffs_base__slice_u32  //
@@ -68,7 +68,7 @@
       });
     }
   }
-  return ((wuffs_base__slice_u32){});
+  return ((wuffs_base__slice_u32){0});
 }
 
 static inline wuffs_base__slice_u64  //
@@ -82,7 +82,7 @@
       });
     }
   }
-  return ((wuffs_base__slice_u64){});
+  return ((wuffs_base__slice_u64){0});
 }
 
 // ---------------- Bureaucracy re -Wunused-function
diff --git a/cmd/wuffs-c/internal/cgen/cgen.go b/cmd/wuffs-c/internal/cgen/cgen.go
index c05446b..7452ff9 100644
--- a/cmd/wuffs-c/internal/cgen/cgen.go
+++ b/cmd/wuffs-c/internal/cgen/cgen.go
@@ -1057,7 +1057,7 @@
 		if err := g.writeSizeofSignature(b, n); err != nil {
 			return err
 		}
-		b.printf("{ return sizeof((%s%s){}); }\n\n", g.pkgPrefix, n.QID().Str(g.tm))
+		b.printf("{ return sizeof (%s%s); }\n\n", g.pkgPrefix, n.QID().Str(g.tm))
 	}
 	return nil
 }
diff --git a/cmd/wuffs-c/internal/cgen/data.go b/cmd/wuffs-c/internal/cgen/data.go
index f7f2c35..f04421e 100644
--- a/cmd/wuffs-c/internal/cgen/data.go
+++ b/cmd/wuffs-c/internal/cgen/data.go
@@ -34,7 +34,7 @@
 const baseCorePrivateH = "" +
 	"static inline void  //\nwuffs_base__ignore_status(wuffs_base__status z) {}\n\n// WUFFS_BASE__MAGIC is a magic number to check that initializers are called.\n// It's not foolproof, given C doesn't automatically zero memory before use,\n// but it should catch 99.99% of cases.\n//\n// Its (non-zero) value is arbitrary, based on md5sum(\"wuffs\").\n#define WUFFS_BASE__MAGIC ((uint32_t)0x3CCB6C71)\n\n// WUFFS_BASE__DISABLED is a magic number to indicate that a non-recoverable\n// error was previously encountered.\n//\n// Its (non-zero) value is arbitrary, based on md5sum(\"disabled\").\n#define WUFFS_BASE__DISABLED ((uint32_t)0x075AE3D2)\n\n// Denote intentional fallthroughs for -Wimplicit-fallthrough.\n//\n// The order matters here. Clang also defines \"__GNUC__\".\n#if defined(__clang__) && __cplusplus >= 201103L\n#define WUFFS_BASE__FALLTHROUGH [[clang::fallthrough]]\n#elif !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 7)\n#define WUFFS_BASE__FALLTHROUGH __attribute__((fallthrough))\n#else\n#define WUFFS_BASE__FALLTHROUGH\n#endif\n" +
 	"\n// Use switch cases for coroutine suspension points, similar to the technique\n// in https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html\n//\n// We use trivial macros instead of an explicit assignment and case statement\n// so that clang-format doesn't get confused by the unusual \"case\"s.\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0 case 0:;\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT(n) \\\n  coro_susp_point = n;                            \\\n  WUFFS_BASE__FALLTHROUGH;                        \\\n  case n:;\n\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \\\n  if (!status) {                                                \\\n    goto ok;                                                    \\\n  } else if (*status != '$') {                                  \\\n    goto exit;                                                  \\\n  }                                                             \\\n  coro_susp_point = n;                                          \\\n  goto suspend;                         " +
-	"                        \\\n  case n:;\n\n// Clang also defines \"__GNUC__\".\n#if defined(__GNUC__)\n#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))\n#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))\n#else\n#define WUFFS_BASE__LIKELY(expr) (expr)\n#define WUFFS_BASE__UNLIKELY(expr) (expr)\n#endif\n\n// The helpers below are functions, instead of macros, because their arguments\n// can be an expression that we shouldn't evaluate more than once.\n//\n// They are static, so that linking multiple wuffs .o files won't complain about\n// duplicate function definitions.\n//\n// They are explicitly marked inline, even if modern compilers don't use the\n// inline attribute to guide optimizations such as inlining, to avoid the\n// -Wunused-function warning, and we like to compile with -Wall -Werror.\n\nstatic inline wuffs_base__empty_struct  //\nwuffs_base__return_empty_struct() {\n  return ((wuffs_base__empty_struct){});\n}\n\n" +
+	"                        \\\n  case n:;\n\n// Clang also defines \"__GNUC__\".\n#if defined(__GNUC__)\n#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))\n#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))\n#else\n#define WUFFS_BASE__LIKELY(expr) (expr)\n#define WUFFS_BASE__UNLIKELY(expr) (expr)\n#endif\n\n// The helpers below are functions, instead of macros, because their arguments\n// can be an expression that we shouldn't evaluate more than once.\n//\n// They are static, so that linking multiple wuffs .o files won't complain about\n// duplicate function definitions.\n//\n// They are explicitly marked inline, even if modern compilers don't use the\n// inline attribute to guide optimizations such as inlining, to avoid the\n// -Wunused-function warning, and we like to compile with -Wall -Werror.\n\nstatic inline wuffs_base__empty_struct  //\nwuffs_base__return_empty_struct() {\n  return ((wuffs_base__empty_struct){0});\n}\n\n" +
 	"" +
 	"// ---------------- Numeric Types\n\nstatic inline uint8_t  //\nwuffs_base__load_u8be(uint8_t* p) {\n  return p[0];\n}\n\nstatic inline uint16_t  //\nwuffs_base__load_u16be(uint8_t* p) {\n  return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0);\n}\n\nstatic inline uint16_t  //\nwuffs_base__load_u16le(uint8_t* p) {\n  return ((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8);\n}\n\nstatic inline uint32_t  //\nwuffs_base__load_u24be(uint8_t* p) {\n  return ((uint32_t)(p[0]) << 16) | ((uint32_t)(p[1]) << 8) |\n         ((uint32_t)(p[2]) << 0);\n}\n\nstatic inline uint32_t  //\nwuffs_base__load_u24le(uint8_t* p) {\n  return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n         ((uint32_t)(p[2]) << 16);\n}\n\nstatic inline uint32_t  //\nwuffs_base__load_u32be(uint8_t* p) {\n  return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) |\n         ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0);\n}\n\nstatic inline uint32_t  //\nwuffs_base__load_u32le(uint8_t* p) {\n  return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n         ((uin" +
 	"t32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);\n}\n\nstatic inline uint64_t  //\nwuffs_base__load_u40be(uint8_t* p) {\n  return ((uint64_t)(p[0]) << 32) | ((uint64_t)(p[1]) << 24) |\n         ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 8) |\n         ((uint64_t)(p[4]) << 0);\n}\n\nstatic inline uint64_t  //\nwuffs_base__load_u40le(uint8_t* p) {\n  return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n         ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n         ((uint64_t)(p[4]) << 32);\n}\n\nstatic inline uint64_t  //\nwuffs_base__load_u48be(uint8_t* p) {\n  return ((uint64_t)(p[0]) << 40) | ((uint64_t)(p[1]) << 32) |\n         ((uint64_t)(p[2]) << 24) | ((uint64_t)(p[3]) << 16) |\n         ((uint64_t)(p[4]) << 8) | ((uint64_t)(p[5]) << 0);\n}\n\nstatic inline uint64_t  //\nwuffs_base__load_u48le(uint8_t* p) {\n  return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n         ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n         ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40);\n}\n\nstatic inline u" +
@@ -52,9 +52,9 @@
 	"// ---------------- Slices and Tables\n\n// wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s.\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__slice_u8__prefix(wuffs_base__slice_u8 s, uint64_t up_to) {\n  if ((uint64_t)(s.len) > up_to) {\n    s.len = up_to;\n  }\n  return s;\n}\n\n// wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s.\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__slice_u8__suffix(wuffs_base__slice_u8 s, uint64_t up_to) {\n  if ((uint64_t)(s.len) > up_to) {\n    s.ptr += (uint64_t)(s.len) - up_to;\n    s.len = up_to;\n  }\n  return s;\n}\n\n// wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr, len)\n// where len is the minimum of dst.len and src.len.\n//\n// Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty\n// slice) is valid and results in a no-op.\nstatic inline uint64_t  //\nwuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst,\n                                      wuffs_base__slice_u8 src) {\n  size_t len = dst.l" +
 	"en < src.len ? dst.len : src.len;\n  if (len > 0) {\n    memmove(dst.ptr, src.ptr, len);\n  }\n  return len;\n}\n\n" +
 	"" +
-	"// --------\n\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) {\n  if (y < t.height) {\n    return ((wuffs_base__slice_u8){\n        .ptr = t.ptr + (t.stride * y),\n        .len = t.width,\n    });\n  }\n  return ((wuffs_base__slice_u8){});\n}\n\n" +
+	"// --------\n\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) {\n  if (y < t.height) {\n    return ((wuffs_base__slice_u8){\n        .ptr = t.ptr + (t.stride * y),\n        .len = t.width,\n    });\n  }\n  return ((wuffs_base__slice_u8){0});\n}\n\n" +
 	"" +
-	"// ---------------- Slices and Tables (Utility)\n\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__utility__null_slice_u8() {\n  return ((wuffs_base__slice_u8){});\n}\n\n" +
+	"// ---------------- Slices and Tables (Utility)\n\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__utility__null_slice_u8() {\n  return ((wuffs_base__slice_u8){0});\n}\n\n" +
 	"" +
 	"// ---------------- Bureaucracy re -Wunused-function\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__core_private()\n    WUFFS_BASE__POTENTIALLY_UNUSED;\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__core_private() {\n  (void)(wuffs_base__ignore_status);\n  (void)(wuffs_base__load_u16be);\n  (void)(wuffs_base__load_u16le);\n  (void)(wuffs_base__load_u24be);\n  (void)(wuffs_base__load_u24le);\n  (void)(wuffs_base__load_u32be);\n  (void)(wuffs_base__load_u32le);\n  (void)(wuffs_base__load_u40be);\n  (void)(wuffs_base__load_u40le);\n  (void)(wuffs_base__load_u48be);\n  (void)(wuffs_base__load_u48le);\n  (void)(wuffs_base__load_u56be);\n  (void)(wuffs_base__load_u56le);\n  (void)(wuffs_base__load_u64be);\n  (void)(wuffs_base__load_u64le);\n  (void)(wuffs_base__load_u8be);\n  (void)(wuffs_base__return_empty_struct);\n  (void)(wuffs_base__slice_u8__copy_from_slice);\n  (void)(wuffs_base__slice_u8__prefix);\n  (void)(wuffs_base__slice_u8__suffix);\n  (void)(wuffs_base__store_u16be);\n  " +
 	"(void)(wuffs_base__store_u16le);\n  (void)(wuffs_base__store_u24be);\n  (void)(wuffs_base__store_u24le);\n  (void)(wuffs_base__store_u32be);\n  (void)(wuffs_base__store_u32le);\n  (void)(wuffs_base__store_u40be);\n  (void)(wuffs_base__store_u40le);\n  (void)(wuffs_base__store_u48be);\n  (void)(wuffs_base__store_u48le);\n  (void)(wuffs_base__store_u56be);\n  (void)(wuffs_base__store_u56le);\n  (void)(wuffs_base__store_u64be);\n  (void)(wuffs_base__store_u64le);\n  (void)(wuffs_base__store_u8be);\n  (void)(wuffs_base__table_u8__row);\n  (void)(wuffs_base__u16__sat_add_indirect);\n  (void)(wuffs_base__u16__sat_sub_indirect);\n  (void)(wuffs_base__u32__sat_add_indirect);\n  (void)(wuffs_base__u32__sat_sub_indirect);\n  (void)(wuffs_base__u64__sat_add_indirect);\n  (void)(wuffs_base__u64__sat_sub_indirect);\n  (void)(wuffs_base__u8__sat_add_indirect);\n  (void)(wuffs_base__u8__sat_sub_indirect);\n  (void)(wuffs_base__utility__null_slice_u8);\n}\n" +
@@ -79,8 +79,8 @@
 	"_u32__sat_sub(uint32_t x, uint32_t y) {\n  uint32_t res = x - y;\n  res &= -(res <= x);\n  return res;\n}\n\nstatic inline uint64_t  //\nwuffs_base__u64__sat_add(uint64_t x, uint64_t y) {\n  uint64_t res = x + y;\n  res |= -(res < x);\n  return res;\n}\n\nstatic inline uint64_t  //\nwuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {\n  uint64_t res = x - y;\n  res &= -(res <= x);\n  return res;\n}\n\n" +
 	"" +
 	"// ---------------- Slices and Tables\n\n// WUFFS_BASE__SLICE is a 1-dimensional buffer.\n//\n// len measures a number of elements, not necessarily a size in bytes.\n//\n// A value with all fields NULL or zero is a valid, empty slice.\n#define WUFFS_BASE__SLICE(T) \\\n  struct {                   \\\n    T* ptr;                  \\\n    size_t len;              \\\n  }\n\n// WUFFS_BASE__TABLE is a 2-dimensional buffer.\n//\n// width height, and stride measure a number of elements, not necessarily a\n// size in bytes.\n//\n// A value with all fields NULL or zero is a valid, empty table.\n#define WUFFS_BASE__TABLE(T) \\\n  struct {                   \\\n    T* ptr;                  \\\n    size_t width;            \\\n    size_t height;           \\\n    size_t stride;           \\\n  }\n\ntypedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8;\ntypedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16;\ntypedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32;\ntypedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64;\n\ntypedef WUFFS_BASE__TABLE(u" +
-	"int8_t) wuffs_base__table_u8;\ntypedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16;\ntypedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32;\ntypedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;\n\n// wuffs_base__slice_u8__subslice_i returns s[i:].\n//\n// It returns an empty slice if i is out of bounds.\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) {\n  if ((i <= SIZE_MAX) && (i <= s.len)) {\n    return ((wuffs_base__slice_u8){\n        .ptr = s.ptr + i,\n        .len = s.len - i,\n    });\n  }\n  return ((wuffs_base__slice_u8){});\n}\n\n// wuffs_base__slice_u8__subslice_j returns s[:j].\n//\n// It returns an empty slice if j is out of bounds.\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__slice_u8__subslice_j(wuffs_base__slice_u8 s, uint64_t j) {\n  if ((j <= SIZE_MAX) && (j <= s.len)) {\n    return ((wuffs_base__slice_u8){\n        .ptr = s.ptr,\n        .len = j,\n    });\n  }\n  return ((wuffs_base__slice_u8){});\n}\n\n// wuffs_base__slice_u8__subslice_" +
-	"ij returns s[i:j].\n//\n// It returns an empty slice if i or j is out of bounds.\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,\n                                  uint64_t i,\n                                  uint64_t j) {\n  if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) {\n    return ((wuffs_base__slice_u8){\n        .ptr = s.ptr + i,\n        .len = j - i,\n    });\n  }\n  return ((wuffs_base__slice_u8){});\n}\n\n" +
+	"int8_t) wuffs_base__table_u8;\ntypedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16;\ntypedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32;\ntypedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;\n\n// wuffs_base__slice_u8__subslice_i returns s[i:].\n//\n// It returns an empty slice if i is out of bounds.\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) {\n  if ((i <= SIZE_MAX) && (i <= s.len)) {\n    return ((wuffs_base__slice_u8){\n        .ptr = s.ptr + i,\n        .len = s.len - i,\n    });\n  }\n  return ((wuffs_base__slice_u8){0});\n}\n\n// wuffs_base__slice_u8__subslice_j returns s[:j].\n//\n// It returns an empty slice if j is out of bounds.\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__slice_u8__subslice_j(wuffs_base__slice_u8 s, uint64_t j) {\n  if ((j <= SIZE_MAX) && (j <= s.len)) {\n    return ((wuffs_base__slice_u8){\n        .ptr = s.ptr,\n        .len = j,\n    });\n  }\n  return ((wuffs_base__slice_u8){0});\n}\n\n// wuffs_base__slice_u8__subslic" +
+	"e_ij returns s[i:j].\n//\n// It returns an empty slice if i or j is out of bounds.\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,\n                                  uint64_t i,\n                                  uint64_t j) {\n  if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) {\n    return ((wuffs_base__slice_u8){\n        .ptr = s.ptr + i,\n        .len = j - i,\n    });\n  }\n  return ((wuffs_base__slice_u8){0});\n}\n\n" +
 	"" +
 	"// ---------------- Bureaucracy re -Wunused-function\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__core_public()\n    WUFFS_BASE__POTENTIALLY_UNUSED;\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__core_public() {\n  (void)(wuffs_base__slice_u8__subslice_i);\n  (void)(wuffs_base__slice_u8__subslice_ij);\n  (void)(wuffs_base__slice_u8__subslice_j);\n  (void)(wuffs_base__status__is_complete);\n  (void)(wuffs_base__status__is_error);\n  (void)(wuffs_base__status__is_ok);\n  (void)(wuffs_base__status__is_suspension);\n  (void)(wuffs_base__status__is_warning);\n  (void)(wuffs_base__u16__max);\n  (void)(wuffs_base__u16__min);\n  (void)(wuffs_base__u16__sat_add);\n  (void)(wuffs_base__u16__sat_sub);\n  (void)(wuffs_base__u32__max);\n  (void)(wuffs_base__u32__min);\n  (void)(wuffs_base__u32__sat_add);\n  (void)(wuffs_base__u32__sat_sub);\n  (void)(wuffs_base__u64__max);\n  (void)(wuffs_base__u64__min);\n  (void)(wuffs_base__u64__sat_add);\n  (void)(wuffs_base__u64__sat_sub);\n  (void)(" +
 	"wuffs_base__u8__max);\n  (void)(wuffs_base__u8__min);\n  (void)(wuffs_base__u8__sat_add);\n  (void)(wuffs_base__u8__sat_sub);\n}\n" +
@@ -91,9 +91,9 @@
 	""
 
 const baseMemoryPublicH = "" +
-	"// ---------------- Memory Allocation\n\n// The memory allocation related functions in this section aren't used by Wuffs\n// per se, but they may be helpful to the code that uses Wuffs.\n\n// wuffs_base__malloc_slice_uxx wraps calling a malloc-like function, except\n// that it takes a uint64_t number of elements instead of a size_t size in\n// bytes, and it returns a slice (a pointer and a length) instead of just a\n// pointer.\n//\n// You can pass the C stdlib's malloc as the malloc_func.\n//\n// It returns an empty slice (containing a NULL ptr field) if (num_uxx *\n// sizeof(uintxx_t)) would overflow SIZE_MAX.\n\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__malloc_slice_u8(void* (*malloc_func)(size_t), uint64_t num_u8) {\n  if (malloc_func && (num_u8 <= (SIZE_MAX / sizeof(uint8_t)))) {\n    void* p = (*malloc_func)(num_u8 * sizeof(uint8_t));\n    if (p) {\n      return ((wuffs_base__slice_u8){\n          .ptr = (uint8_t*)(p),\n          .len = num_u8,\n      });\n    }\n  }\n  return ((wuffs_base__slice_u8){});\n}\n\nstatic inli" +
-	"ne wuffs_base__slice_u16  //\nwuffs_base__malloc_slice_u16(void* (*malloc_func)(size_t), uint64_t num_u16) {\n  if (malloc_func && (num_u16 <= (SIZE_MAX / sizeof(uint16_t)))) {\n    void* p = (*malloc_func)(num_u16 * sizeof(uint16_t));\n    if (p) {\n      return ((wuffs_base__slice_u16){\n          .ptr = (uint16_t*)(p),\n          .len = num_u16,\n      });\n    }\n  }\n  return ((wuffs_base__slice_u16){});\n}\n\nstatic inline wuffs_base__slice_u32  //\nwuffs_base__malloc_slice_u32(void* (*malloc_func)(size_t), uint64_t num_u32) {\n  if (malloc_func && (num_u32 <= (SIZE_MAX / sizeof(uint32_t)))) {\n    void* p = (*malloc_func)(num_u32 * sizeof(uint32_t));\n    if (p) {\n      return ((wuffs_base__slice_u32){\n          .ptr = (uint32_t*)(p),\n          .len = num_u32,\n      });\n    }\n  }\n  return ((wuffs_base__slice_u32){});\n}\n\nstatic inline wuffs_base__slice_u64  //\nwuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) {\n  if (malloc_func && (num_u64 <= (SIZE_MAX / sizeof(uint64_t)))) {\n    void* p = (*m" +
-	"alloc_func)(num_u64 * sizeof(uint64_t));\n    if (p) {\n      return ((wuffs_base__slice_u64){\n          .ptr = (uint64_t*)(p),\n          .len = num_u64,\n      });\n    }\n  }\n  return ((wuffs_base__slice_u64){});\n}\n\n" +
+	"// ---------------- Memory Allocation\n\n// The memory allocation related functions in this section aren't used by Wuffs\n// per se, but they may be helpful to the code that uses Wuffs.\n\n// wuffs_base__malloc_slice_uxx wraps calling a malloc-like function, except\n// that it takes a uint64_t number of elements instead of a size_t size in\n// bytes, and it returns a slice (a pointer and a length) instead of just a\n// pointer.\n//\n// You can pass the C stdlib's malloc as the malloc_func.\n//\n// It returns an empty slice (containing a NULL ptr field) if (num_uxx *\n// sizeof(uintxx_t)) would overflow SIZE_MAX.\n\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__malloc_slice_u8(void* (*malloc_func)(size_t), uint64_t num_u8) {\n  if (malloc_func && (num_u8 <= (SIZE_MAX / sizeof(uint8_t)))) {\n    void* p = (*malloc_func)(num_u8 * sizeof(uint8_t));\n    if (p) {\n      return ((wuffs_base__slice_u8){\n          .ptr = (uint8_t*)(p),\n          .len = num_u8,\n      });\n    }\n  }\n  return ((wuffs_base__slice_u8){0});\n}\n\nstatic inl" +
+	"ine wuffs_base__slice_u16  //\nwuffs_base__malloc_slice_u16(void* (*malloc_func)(size_t), uint64_t num_u16) {\n  if (malloc_func && (num_u16 <= (SIZE_MAX / sizeof(uint16_t)))) {\n    void* p = (*malloc_func)(num_u16 * sizeof(uint16_t));\n    if (p) {\n      return ((wuffs_base__slice_u16){\n          .ptr = (uint16_t*)(p),\n          .len = num_u16,\n      });\n    }\n  }\n  return ((wuffs_base__slice_u16){0});\n}\n\nstatic inline wuffs_base__slice_u32  //\nwuffs_base__malloc_slice_u32(void* (*malloc_func)(size_t), uint64_t num_u32) {\n  if (malloc_func && (num_u32 <= (SIZE_MAX / sizeof(uint32_t)))) {\n    void* p = (*malloc_func)(num_u32 * sizeof(uint32_t));\n    if (p) {\n      return ((wuffs_base__slice_u32){\n          .ptr = (uint32_t*)(p),\n          .len = num_u32,\n      });\n    }\n  }\n  return ((wuffs_base__slice_u32){0});\n}\n\nstatic inline wuffs_base__slice_u64  //\nwuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) {\n  if (malloc_func && (num_u64 <= (SIZE_MAX / sizeof(uint64_t)))) {\n    void* p = " +
+	"(*malloc_func)(num_u64 * sizeof(uint64_t));\n    if (p) {\n      return ((wuffs_base__slice_u64){\n          .ptr = (uint64_t*)(p),\n          .len = num_u64,\n      });\n    }\n  }\n  return ((wuffs_base__slice_u64){0});\n}\n\n" +
 	"" +
 	"// ---------------- Bureaucracy re -Wunused-function\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__memory_public()\n    WUFFS_BASE__POTENTIALLY_UNUSED;\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__memory_public() {\n  (void)(wuffs_base__malloc_slice_u16);\n  (void)(wuffs_base__malloc_slice_u32);\n  (void)(wuffs_base__malloc_slice_u64);\n  (void)(wuffs_base__malloc_slice_u8);\n}\n" +
 	""
@@ -122,33 +122,33 @@
 	"  uint32_t plane) {\n  uint32_t shift = ((plane & 0x03) * 8) + 2;\n  return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t  //\nwuffs_base__pixel_subsampling__shift_y(wuffs_base__pixel_subsampling s,\n                                       uint32_t plane) {\n  uint32_t shift = ((plane & 0x03) * 8) + 0;\n  return (s >> shift) & 0x03;\n}\n\n" +
 	"" +
 	"// --------\n\ntypedef struct {\n  // Do not access the private_impl's fields directly. There is no API/ABI\n  // compatibility or safety guarantee if you do so.\n  struct {\n    wuffs_base__pixel_format pixfmt;\n    wuffs_base__pixel_subsampling pixsub;\n    uint32_t width;\n    uint32_t height;\n  } private_impl;\n\n#ifdef __cplusplus\n  // TODO: deprecated. This is for transitioning pre-v0.2 code.\n  inline void initialize(wuffs_base__pixel_format pixfmt,\n                         wuffs_base__pixel_subsampling pixsub,\n                         uint32_t width,\n                         uint32_t height);\n\n  inline void set(wuffs_base__pixel_format pixfmt,\n                  wuffs_base__pixel_subsampling pixsub,\n                  uint32_t width,\n                  uint32_t height);\n  inline void invalidate();\n  inline bool is_valid();\n  inline wuffs_base__pixel_format pixel_format();\n  inline wuffs_base__pixel_subsampling pixel_subsampling();\n  inline wuffs_base__rect_ie_u32 bounds();\n  inline uint32_t width();\n  inline uint32_" +
-	"t height();\n  inline uint64_t pixbuf_len();\n#endif  // __cplusplus\n\n} wuffs_base__pixel_config;\n\n// TODO: Should this function return bool? An error type?\nstatic inline void  //\nwuffs_base__pixel_config__set(wuffs_base__pixel_config* c,\n                              wuffs_base__pixel_format pixfmt,\n                              wuffs_base__pixel_subsampling pixsub,\n                              uint32_t width,\n                              uint32_t height) {\n  if (!c) {\n    return;\n  }\n  if (pixfmt) {\n    uint64_t wh = ((uint64_t)width) * ((uint64_t)height);\n    // TODO: handle things other than 1 byte per pixel.\n    if (wh <= ((uint64_t)SIZE_MAX)) {\n      c->private_impl.pixfmt = pixfmt;\n      c->private_impl.pixsub = pixsub;\n      c->private_impl.width = width;\n      c->private_impl.height = height;\n      return;\n    }\n  }\n  *c = ((wuffs_base__pixel_config){});\n}\n\nstatic inline void  //\nwuffs_base__pixel_config__invalidate(wuffs_base__pixel_config* c) {\n  if (c) {\n    *c = ((wuffs_base__pixel_config){});\n  " +
-	"}\n}\n\nstatic inline bool  //\nwuffs_base__pixel_config__is_valid(wuffs_base__pixel_config* c) {\n  return c && c->private_impl.pixfmt;\n}\n\nstatic inline wuffs_base__pixel_format  //\nwuffs_base__pixel_config__pixel_format(wuffs_base__pixel_config* c) {\n  return c ? c->private_impl.pixfmt : 0;\n}\n\nstatic inline wuffs_base__pixel_subsampling  //\nwuffs_base__pixel_config__pixel_subsampling(wuffs_base__pixel_config* c) {\n  return c ? c->private_impl.pixsub : 0;\n}\n\nstatic inline wuffs_base__rect_ie_u32  //\nwuffs_base__pixel_config__bounds(wuffs_base__pixel_config* c) {\n  return c ? ((wuffs_base__rect_ie_u32){\n                 .min_incl_x = 0,\n                 .min_incl_y = 0,\n                 .max_excl_x = c->private_impl.width,\n                 .max_excl_y = c->private_impl.height,\n             })\n           : ((wuffs_base__rect_ie_u32){});\n}\n\nstatic inline uint32_t  //\nwuffs_base__pixel_config__width(wuffs_base__pixel_config* c) {\n  return c ? c->private_impl.width : 0;\n}\n\nstatic inline uint32_t  //\nwuffs_base__pixel_" +
-	"config__height(wuffs_base__pixel_config* c) {\n  return c ? c->private_impl.height : 0;\n}\n\n// TODO: this is the right API for planar (not packed) pixbufs? Should it allow\n// decoding into a color model different from the format's intrinsic one? For\n// example, decoding a JPEG image straight to RGBA instead of to YCbCr?\nstatic inline uint64_t  //\nwuffs_base__pixel_config__pixbuf_len(wuffs_base__pixel_config* c) {\n  if (!c) {\n    return 0;\n  }\n  if (wuffs_base__pixel_format__is_planar(c->private_impl.pixfmt)) {\n    // TODO: support planar pixel formats, concious of pixel subsampling.\n    return 0;\n  }\n  uint32_t bits_per_pixel =\n      wuffs_base__pixel_format__bits_per_pixel(c->private_impl.pixfmt);\n  if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n    // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n    return 0;\n  }\n  uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n  uint64_t n =\n      ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n  if (n > (UINT64_MAX / byt" +
-	"es_per_pixel)) {\n    return 0;\n  }\n  n *= bytes_per_pixel;\n\n  if (wuffs_base__pixel_format__is_indexed(c->private_impl.pixfmt)) {\n    if (n > (UINT64_MAX - 1024)) {\n      return 0;\n    }\n    n += 1024;\n  }\n\n  return n;\n}\n\n#ifdef __cplusplus\n\n// TODO: deprecated. This is for transitioning pre-v0.2 code.\ninline void  //\nwuffs_base__pixel_config::initialize(wuffs_base__pixel_format pixfmt,\n                                     wuffs_base__pixel_subsampling pixsub,\n                                     uint32_t width,\n                                     uint32_t height) {\n  wuffs_base__pixel_config__set(this, pixfmt, pixsub, width, height);\n}\n\ninline void  //\nwuffs_base__pixel_config::set(wuffs_base__pixel_format pixfmt,\n                              wuffs_base__pixel_subsampling pixsub,\n                              uint32_t width,\n                              uint32_t height) {\n  wuffs_base__pixel_config__set(this, pixfmt, pixsub, width, height);\n}\n\ninline void  //\nwuffs_base__pixel_config::invalidate() {\n  wuf" +
-	"fs_base__pixel_config__invalidate(this);\n}\n\ninline bool  //\nwuffs_base__pixel_config::is_valid() {\n  return wuffs_base__pixel_config__is_valid(this);\n}\n\ninline wuffs_base__pixel_format  //\nwuffs_base__pixel_config::pixel_format() {\n  return wuffs_base__pixel_config__pixel_format(this);\n}\n\ninline wuffs_base__pixel_subsampling  //\nwuffs_base__pixel_config::pixel_subsampling() {\n  return wuffs_base__pixel_config__pixel_subsampling(this);\n}\n\ninline wuffs_base__rect_ie_u32  //\nwuffs_base__pixel_config::bounds() {\n  return wuffs_base__pixel_config__bounds(this);\n}\n\ninline uint32_t  //\nwuffs_base__pixel_config::width() {\n  return wuffs_base__pixel_config__width(this);\n}\n\ninline uint32_t  //\nwuffs_base__pixel_config::height() {\n  return wuffs_base__pixel_config__height(this);\n}\n\ninline uint64_t  //\nwuffs_base__pixel_config::pixbuf_len() {\n  return wuffs_base__pixel_config__pixbuf_len(this);\n}\n\n#endif  // __cplusplus\n\n" +
+	"t height();\n  inline uint64_t pixbuf_len();\n#endif  // __cplusplus\n\n} wuffs_base__pixel_config;\n\n// TODO: Should this function return bool? An error type?\nstatic inline void  //\nwuffs_base__pixel_config__set(wuffs_base__pixel_config* c,\n                              wuffs_base__pixel_format pixfmt,\n                              wuffs_base__pixel_subsampling pixsub,\n                              uint32_t width,\n                              uint32_t height) {\n  if (!c) {\n    return;\n  }\n  if (pixfmt) {\n    uint64_t wh = ((uint64_t)width) * ((uint64_t)height);\n    // TODO: handle things other than 1 byte per pixel.\n    if (wh <= ((uint64_t)SIZE_MAX)) {\n      c->private_impl.pixfmt = pixfmt;\n      c->private_impl.pixsub = pixsub;\n      c->private_impl.width = width;\n      c->private_impl.height = height;\n      return;\n    }\n  }\n  *c = ((wuffs_base__pixel_config){\n      .private_impl = {0},\n  });\n}\n\nstatic inline void  //\nwuffs_base__pixel_config__invalidate(wuffs_base__pixel_config* c) {\n  if (c) {\n    *c = ((wu" +
+	"ffs_base__pixel_config){\n        .private_impl = {0},\n    });\n  }\n}\n\nstatic inline bool  //\nwuffs_base__pixel_config__is_valid(wuffs_base__pixel_config* c) {\n  return c && c->private_impl.pixfmt;\n}\n\nstatic inline wuffs_base__pixel_format  //\nwuffs_base__pixel_config__pixel_format(wuffs_base__pixel_config* c) {\n  return c ? c->private_impl.pixfmt : 0;\n}\n\nstatic inline wuffs_base__pixel_subsampling  //\nwuffs_base__pixel_config__pixel_subsampling(wuffs_base__pixel_config* c) {\n  return c ? c->private_impl.pixsub : 0;\n}\n\nstatic inline wuffs_base__rect_ie_u32  //\nwuffs_base__pixel_config__bounds(wuffs_base__pixel_config* c) {\n  return c ? ((wuffs_base__rect_ie_u32){\n                 .min_incl_x = 0,\n                 .min_incl_y = 0,\n                 .max_excl_x = c->private_impl.width,\n                 .max_excl_y = c->private_impl.height,\n             })\n           : ((wuffs_base__rect_ie_u32){0});\n}\n\nstatic inline uint32_t  //\nwuffs_base__pixel_config__width(wuffs_base__pixel_config* c) {\n  return c ? c->private" +
+	"_impl.width : 0;\n}\n\nstatic inline uint32_t  //\nwuffs_base__pixel_config__height(wuffs_base__pixel_config* c) {\n  return c ? c->private_impl.height : 0;\n}\n\n// TODO: this is the right API for planar (not packed) pixbufs? Should it allow\n// decoding into a color model different from the format's intrinsic one? For\n// example, decoding a JPEG image straight to RGBA instead of to YCbCr?\nstatic inline uint64_t  //\nwuffs_base__pixel_config__pixbuf_len(wuffs_base__pixel_config* c) {\n  if (!c) {\n    return 0;\n  }\n  if (wuffs_base__pixel_format__is_planar(c->private_impl.pixfmt)) {\n    // TODO: support planar pixel formats, concious of pixel subsampling.\n    return 0;\n  }\n  uint32_t bits_per_pixel =\n      wuffs_base__pixel_format__bits_per_pixel(c->private_impl.pixfmt);\n  if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n    // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n    return 0;\n  }\n  uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n  uint64_t n =\n      ((uint64_t)c->private_impl.width) " +
+	"* ((uint64_t)c->private_impl.height);\n  if (n > (UINT64_MAX / bytes_per_pixel)) {\n    return 0;\n  }\n  n *= bytes_per_pixel;\n\n  if (wuffs_base__pixel_format__is_indexed(c->private_impl.pixfmt)) {\n    if (n > (UINT64_MAX - 1024)) {\n      return 0;\n    }\n    n += 1024;\n  }\n\n  return n;\n}\n\n#ifdef __cplusplus\n\n// TODO: deprecated. This is for transitioning pre-v0.2 code.\ninline void  //\nwuffs_base__pixel_config::initialize(wuffs_base__pixel_format pixfmt,\n                                     wuffs_base__pixel_subsampling pixsub,\n                                     uint32_t width,\n                                     uint32_t height) {\n  wuffs_base__pixel_config__set(this, pixfmt, pixsub, width, height);\n}\n\ninline void  //\nwuffs_base__pixel_config::set(wuffs_base__pixel_format pixfmt,\n                              wuffs_base__pixel_subsampling pixsub,\n                              uint32_t width,\n                              uint32_t height) {\n  wuffs_base__pixel_config__set(this, pixfmt, pixsub, width, height);\n" +
+	"}\n\ninline void  //\nwuffs_base__pixel_config::invalidate() {\n  wuffs_base__pixel_config__invalidate(this);\n}\n\ninline bool  //\nwuffs_base__pixel_config::is_valid() {\n  return wuffs_base__pixel_config__is_valid(this);\n}\n\ninline wuffs_base__pixel_format  //\nwuffs_base__pixel_config::pixel_format() {\n  return wuffs_base__pixel_config__pixel_format(this);\n}\n\ninline wuffs_base__pixel_subsampling  //\nwuffs_base__pixel_config::pixel_subsampling() {\n  return wuffs_base__pixel_config__pixel_subsampling(this);\n}\n\ninline wuffs_base__rect_ie_u32  //\nwuffs_base__pixel_config::bounds() {\n  return wuffs_base__pixel_config__bounds(this);\n}\n\ninline uint32_t  //\nwuffs_base__pixel_config::width() {\n  return wuffs_base__pixel_config__width(this);\n}\n\ninline uint32_t  //\nwuffs_base__pixel_config::height() {\n  return wuffs_base__pixel_config__height(this);\n}\n\ninline uint64_t  //\nwuffs_base__pixel_config::pixbuf_len() {\n  return wuffs_base__pixel_config__pixbuf_len(this);\n}\n\n#endif  // __cplusplus\n\n" +
 	"" +
 	"// --------\n\ntypedef struct {\n  wuffs_base__pixel_config pixcfg;\n\n  // Do not access the private_impl's fields directly. There is no API/ABI\n  // compatibility or safety guarantee if you do so.\n  struct {\n    uint64_t first_frame_io_position;\n    bool first_frame_is_opaque;\n  } private_impl;\n\n#ifdef __cplusplus\n  inline void set(wuffs_base__pixel_format pixfmt,\n                  wuffs_base__pixel_subsampling pixsub,\n                  uint32_t width,\n                  uint32_t height,\n                  uint64_t first_frame_io_position,\n                  bool first_frame_is_opaque);\n  inline void invalidate();\n  inline bool is_valid();\n  inline uint64_t first_frame_io_position();\n  inline bool first_frame_is_opaque();\n#endif  // __cplusplus\n\n} wuffs_base__image_config;\n\n// TODO: Should this function return bool? An error type?\nstatic inline void  //\nwuffs_base__image_config__set(wuffs_base__image_config* c,\n                              wuffs_base__pixel_format pixfmt,\n                              wuffs_base__" +
-	"pixel_subsampling pixsub,\n                              uint32_t width,\n                              uint32_t height,\n                              uint64_t first_frame_io_position,\n                              bool first_frame_is_opaque) {\n  if (!c) {\n    return;\n  }\n  if (wuffs_base__pixel_format__is_valid(pixfmt)) {\n    c->pixcfg.private_impl.pixfmt = pixfmt;\n    c->pixcfg.private_impl.pixsub = pixsub;\n    c->pixcfg.private_impl.width = width;\n    c->pixcfg.private_impl.height = height;\n    c->private_impl.first_frame_io_position = first_frame_io_position;\n    c->private_impl.first_frame_is_opaque = first_frame_is_opaque;\n    return;\n  }\n  *c = ((wuffs_base__image_config){});\n}\n\nstatic inline void  //\nwuffs_base__image_config__invalidate(wuffs_base__image_config* c) {\n  if (c) {\n    *c = ((wuffs_base__image_config){});\n  }\n}\n\nstatic inline bool  //\nwuffs_base__image_config__is_valid(wuffs_base__image_config* c) {\n  return c && wuffs_base__pixel_config__is_valid(&(c->pixcfg));\n}\n\nstatic inline uint64_t  /" +
-	"/\nwuffs_base__image_config__first_frame_io_position(wuffs_base__image_config* c) {\n  return c ? c->private_impl.first_frame_io_position : 0;\n}\n\nstatic inline bool  //\nwuffs_base__image_config__first_frame_is_opaque(wuffs_base__image_config* c) {\n  return c ? c->private_impl.first_frame_is_opaque : false;\n}\n\n#ifdef __cplusplus\n\ninline void  //\nwuffs_base__image_config::set(wuffs_base__pixel_format pixfmt,\n                              wuffs_base__pixel_subsampling pixsub,\n                              uint32_t width,\n                              uint32_t height,\n                              uint64_t first_frame_io_position,\n                              bool first_frame_is_opaque) {\n  wuffs_base__image_config__set(this, pixfmt, pixsub, width, height,\n                                first_frame_io_position, first_frame_is_opaque);\n}\n\ninline void  //\nwuffs_base__image_config::invalidate() {\n  wuffs_base__image_config__invalidate(this);\n}\n\ninline bool  //\nwuffs_base__image_config::is_valid() {\n  return wuffs_ba" +
-	"se__image_config__is_valid(this);\n}\n\ninline uint64_t  //\nwuffs_base__image_config::first_frame_io_position() {\n  return wuffs_base__image_config__first_frame_io_position(this);\n}\n\ninline bool  //\nwuffs_base__image_config::first_frame_is_opaque() {\n  return wuffs_base__image_config__first_frame_is_opaque(this);\n}\n\n#endif  // __cplusplus\n\n" +
+	"pixel_subsampling pixsub,\n                              uint32_t width,\n                              uint32_t height,\n                              uint64_t first_frame_io_position,\n                              bool first_frame_is_opaque) {\n  if (!c) {\n    return;\n  }\n  if (wuffs_base__pixel_format__is_valid(pixfmt)) {\n    c->pixcfg.private_impl.pixfmt = pixfmt;\n    c->pixcfg.private_impl.pixsub = pixsub;\n    c->pixcfg.private_impl.width = width;\n    c->pixcfg.private_impl.height = height;\n    c->private_impl.first_frame_io_position = first_frame_io_position;\n    c->private_impl.first_frame_is_opaque = first_frame_is_opaque;\n    return;\n  }\n  *c = ((wuffs_base__image_config){\n      .pixcfg = {.private_impl = {0}},\n      .private_impl = {0},\n  });\n}\n\nstatic inline void  //\nwuffs_base__image_config__invalidate(wuffs_base__image_config* c) {\n  if (c) {\n    *c = ((wuffs_base__image_config){\n        .pixcfg = {.private_impl = {0}},\n        .private_impl = {0},\n    });\n  }\n}\n\nstatic inline bool  //\nwuffs_base__im" +
+	"age_config__is_valid(wuffs_base__image_config* c) {\n  return c && wuffs_base__pixel_config__is_valid(&(c->pixcfg));\n}\n\nstatic inline uint64_t  //\nwuffs_base__image_config__first_frame_io_position(wuffs_base__image_config* c) {\n  return c ? c->private_impl.first_frame_io_position : 0;\n}\n\nstatic inline bool  //\nwuffs_base__image_config__first_frame_is_opaque(wuffs_base__image_config* c) {\n  return c ? c->private_impl.first_frame_is_opaque : false;\n}\n\n#ifdef __cplusplus\n\ninline void  //\nwuffs_base__image_config::set(wuffs_base__pixel_format pixfmt,\n                              wuffs_base__pixel_subsampling pixsub,\n                              uint32_t width,\n                              uint32_t height,\n                              uint64_t first_frame_io_position,\n                              bool first_frame_is_opaque) {\n  wuffs_base__image_config__set(this, pixfmt, pixsub, width, height,\n                                first_frame_io_position, first_frame_is_opaque);\n}\n\ninline void  //\nwuffs_base__image_" +
+	"config::invalidate() {\n  wuffs_base__image_config__invalidate(this);\n}\n\ninline bool  //\nwuffs_base__image_config::is_valid() {\n  return wuffs_base__image_config__is_valid(this);\n}\n\ninline uint64_t  //\nwuffs_base__image_config::first_frame_io_position() {\n  return wuffs_base__image_config__first_frame_io_position(this);\n}\n\ninline bool  //\nwuffs_base__image_config::first_frame_is_opaque() {\n  return wuffs_base__image_config__first_frame_is_opaque(this);\n}\n\n#endif  // __cplusplus\n\n" +
 	"" +
 	"// --------\n\n// wuffs_base__animation_blend encodes, for an animated image, how to blend the\n// transparent pixels of this frame with the existing canvas. In Porter-Duff\n// compositing operator terminology:\n//  - 0 means the frame may be transparent, and should be blended \"src over\n//    dst\", also known as just \"over\".\n//  - 1 means the frame may be transparent, and should be blended \"src\".\n//  - 2 means the frame is completely opaque, so that \"src over dst\" and \"src\"\n//    are equivalent.\n//\n// These semantics are conservative. It is valid for a completely opaque frame\n// to have a blend value other than 2.\ntypedef uint8_t wuffs_base__animation_blend;\n\n#define WUFFS_BASE__ANIMATION_BLEND__SRC_OVER_DST \\\n  ((wuffs_base__animation_blend)0)\n#define WUFFS_BASE__ANIMATION_BLEND__SRC ((wuffs_base__animation_blend)1)\n#define WUFFS_BASE__ANIMATION_BLEND__OPAQUE ((wuffs_base__animation_blend)2)\n\n" +
 	"" +
 	"// --------\n\n// wuffs_base__animation_disposal encodes, for an animated image, how to\n// dispose of a frame after displaying it:\n//  - None means to draw the next frame on top of this one.\n//  - Restore Background means to clear the frame's dirty rectangle to \"the\n//    background color\" (in practice, this means transparent black) before\n//    drawing the next frame.\n//  - Restore Previous means to undo the current frame, so that the next frame\n//    is drawn on top of the previous one.\ntypedef uint8_t wuffs_base__animation_disposal;\n\n#define WUFFS_BASE__ANIMATION_DISPOSAL__NONE ((wuffs_base__animation_disposal)0)\n#define WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND \\\n  ((wuffs_base__animation_disposal)1)\n#define WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS \\\n  ((wuffs_base__animation_disposal)2)\n\n" +
 	"" +
 	"// --------\n\ntypedef struct {\n  // Do not access the private_impl's fields directly. There is no API/ABI\n  // compatibility or safety guarantee if you do so.\n  struct {\n    wuffs_base__rect_ie_u32 bounds;\n    wuffs_base__flicks duration;\n    uint64_t index;\n    uint64_t io_position;\n    wuffs_base__animation_blend blend;\n    wuffs_base__animation_disposal disposal;\n  } private_impl;\n\n#ifdef __cplusplus\n  inline void update(wuffs_base__rect_ie_u32 bounds,\n                     wuffs_base__flicks duration,\n                     uint64_t index,\n                     uint64_t io_position,\n                     wuffs_base__animation_blend blend,\n                     wuffs_base__animation_disposal disposal);\n  inline wuffs_base__rect_ie_u32 bounds();\n  inline uint32_t width();\n  inline uint32_t height();\n  inline wuffs_base__flicks duration();\n  inline uint64_t index();\n  inline uint64_t io_position();\n  inline wuffs_base__animation_blend blend();\n  inline wuffs_base__animation_disposal disposal();\n#endif  // __cpluspl" +
-	"us\n\n} wuffs_base__frame_config;\n\nstatic inline void  //\nwuffs_base__frame_config__update(wuffs_base__frame_config* c,\n                                 wuffs_base__rect_ie_u32 bounds,\n                                 wuffs_base__flicks duration,\n                                 uint64_t index,\n                                 uint64_t io_position,\n                                 wuffs_base__animation_blend blend,\n                                 wuffs_base__animation_disposal disposal) {\n  if (!c) {\n    return;\n  }\n\n  c->private_impl.bounds = bounds;\n  c->private_impl.duration = duration;\n  c->private_impl.index = index;\n  c->private_impl.io_position = io_position;\n  c->private_impl.blend = blend;\n  c->private_impl.disposal = disposal;\n}\n\nstatic inline wuffs_base__rect_ie_u32  //\nwuffs_base__frame_config__bounds(wuffs_base__frame_config* c) {\n  return c ? c->private_impl.bounds : ((wuffs_base__rect_ie_u32){});\n}\n\nstatic inline uint32_t  //\nwuffs_base__frame_config__width(wuffs_base__frame_config* c) {\n  retur" +
-	"n c ? wuffs_base__rect_ie_u32__width(&c->private_impl.bounds) : 0;\n}\n\nstatic inline uint32_t  //\nwuffs_base__frame_config__height(wuffs_base__frame_config* c) {\n  return c ? wuffs_base__rect_ie_u32__height(&c->private_impl.bounds) : 0;\n}\n\n// wuffs_base__frame_config__duration returns the amount of time to display\n// this frame. Zero means to display forever - a still (non-animated) image.\nstatic inline wuffs_base__flicks  //\nwuffs_base__frame_config__duration(wuffs_base__frame_config* c) {\n  return c ? c->private_impl.duration : 0;\n}\n\n// wuffs_base__frame_config__index returns the index of this frame. The first\n// frame in an image has index 0, the second frame has index 1, and so on.\nstatic inline uint64_t  //\nwuffs_base__frame_config__index(wuffs_base__frame_config* c) {\n  return c ? c->private_impl.index : 0;\n}\n\n// wuffs_base__frame_config__io_position returns the I/O stream position before\n// the frame config.\nstatic inline uint64_t  //\nwuffs_base__frame_config__io_position(wuffs_base__frame_config* c) {\n" +
-	"  return c ? c->private_impl.io_position : 0;\n}\n\n// wuffs_base__frame_config__blend returns, for an animated image, how to blend\n// the transparent pixels of this frame with the existing canvas.\nstatic inline wuffs_base__animation_blend  //\nwuffs_base__frame_config__blend(wuffs_base__frame_config* c) {\n  return c ? c->private_impl.blend : 0;\n}\n\n// wuffs_base__frame_config__disposal returns, for an animated image, how to\n// dispose of this frame after displaying it.\nstatic inline wuffs_base__animation_disposal  //\nwuffs_base__frame_config__disposal(wuffs_base__frame_config* c) {\n  return c ? c->private_impl.disposal : 0;\n}\n\n#ifdef __cplusplus\n\ninline void  //\nwuffs_base__frame_config::update(wuffs_base__rect_ie_u32 bounds,\n                                 wuffs_base__flicks duration,\n                                 uint64_t index,\n                                 uint64_t io_position,\n                                 wuffs_base__animation_blend blend,\n                                 wuffs_base__animation_dis" +
-	"posal disposal) {\n  wuffs_base__frame_config__update(this, bounds, duration, index, io_position,\n                                   blend, disposal);\n}\n\ninline wuffs_base__rect_ie_u32  //\nwuffs_base__frame_config::bounds() {\n  return wuffs_base__frame_config__bounds(this);\n}\n\ninline uint32_t  //\nwuffs_base__frame_config::width() {\n  return wuffs_base__frame_config__width(this);\n}\n\ninline uint32_t  //\nwuffs_base__frame_config::height() {\n  return wuffs_base__frame_config__height(this);\n}\n\ninline wuffs_base__flicks  //\nwuffs_base__frame_config::duration() {\n  return wuffs_base__frame_config__duration(this);\n}\n\ninline uint64_t  //\nwuffs_base__frame_config::index() {\n  return wuffs_base__frame_config__index(this);\n}\n\ninline uint64_t  //\nwuffs_base__frame_config::io_position() {\n  return wuffs_base__frame_config__io_position(this);\n}\n\ninline wuffs_base__animation_blend  //\nwuffs_base__frame_config::blend() {\n  return wuffs_base__frame_config__blend(this);\n}\n\ninline wuffs_base__animation_disposal  //\nwuffs_base__fr" +
-	"ame_config::disposal() {\n  return wuffs_base__frame_config__disposal(this);\n}\n\n#endif  // __cplusplus\n\n" +
+	"us\n\n} wuffs_base__frame_config;\n\nstatic inline void  //\nwuffs_base__frame_config__update(wuffs_base__frame_config* c,\n                                 wuffs_base__rect_ie_u32 bounds,\n                                 wuffs_base__flicks duration,\n                                 uint64_t index,\n                                 uint64_t io_position,\n                                 wuffs_base__animation_blend blend,\n                                 wuffs_base__animation_disposal disposal) {\n  if (!c) {\n    return;\n  }\n\n  c->private_impl.bounds = bounds;\n  c->private_impl.duration = duration;\n  c->private_impl.index = index;\n  c->private_impl.io_position = io_position;\n  c->private_impl.blend = blend;\n  c->private_impl.disposal = disposal;\n}\n\nstatic inline wuffs_base__rect_ie_u32  //\nwuffs_base__frame_config__bounds(wuffs_base__frame_config* c) {\n  return c ? c->private_impl.bounds : ((wuffs_base__rect_ie_u32){0});\n}\n\nstatic inline uint32_t  //\nwuffs_base__frame_config__width(wuffs_base__frame_config* c) {\n  retu" +
+	"rn c ? wuffs_base__rect_ie_u32__width(&c->private_impl.bounds) : 0;\n}\n\nstatic inline uint32_t  //\nwuffs_base__frame_config__height(wuffs_base__frame_config* c) {\n  return c ? wuffs_base__rect_ie_u32__height(&c->private_impl.bounds) : 0;\n}\n\n// wuffs_base__frame_config__duration returns the amount of time to display\n// this frame. Zero means to display forever - a still (non-animated) image.\nstatic inline wuffs_base__flicks  //\nwuffs_base__frame_config__duration(wuffs_base__frame_config* c) {\n  return c ? c->private_impl.duration : 0;\n}\n\n// wuffs_base__frame_config__index returns the index of this frame. The first\n// frame in an image has index 0, the second frame has index 1, and so on.\nstatic inline uint64_t  //\nwuffs_base__frame_config__index(wuffs_base__frame_config* c) {\n  return c ? c->private_impl.index : 0;\n}\n\n// wuffs_base__frame_config__io_position returns the I/O stream position before\n// the frame config.\nstatic inline uint64_t  //\nwuffs_base__frame_config__io_position(wuffs_base__frame_config* c) {" +
+	"\n  return c ? c->private_impl.io_position : 0;\n}\n\n// wuffs_base__frame_config__blend returns, for an animated image, how to blend\n// the transparent pixels of this frame with the existing canvas.\nstatic inline wuffs_base__animation_blend  //\nwuffs_base__frame_config__blend(wuffs_base__frame_config* c) {\n  return c ? c->private_impl.blend : 0;\n}\n\n// wuffs_base__frame_config__disposal returns, for an animated image, how to\n// dispose of this frame after displaying it.\nstatic inline wuffs_base__animation_disposal  //\nwuffs_base__frame_config__disposal(wuffs_base__frame_config* c) {\n  return c ? c->private_impl.disposal : 0;\n}\n\n#ifdef __cplusplus\n\ninline void  //\nwuffs_base__frame_config::update(wuffs_base__rect_ie_u32 bounds,\n                                 wuffs_base__flicks duration,\n                                 uint64_t index,\n                                 uint64_t io_position,\n                                 wuffs_base__animation_blend blend,\n                                 wuffs_base__animation_di" +
+	"sposal disposal) {\n  wuffs_base__frame_config__update(this, bounds, duration, index, io_position,\n                                   blend, disposal);\n}\n\ninline wuffs_base__rect_ie_u32  //\nwuffs_base__frame_config::bounds() {\n  return wuffs_base__frame_config__bounds(this);\n}\n\ninline uint32_t  //\nwuffs_base__frame_config::width() {\n  return wuffs_base__frame_config__width(this);\n}\n\ninline uint32_t  //\nwuffs_base__frame_config::height() {\n  return wuffs_base__frame_config__height(this);\n}\n\ninline wuffs_base__flicks  //\nwuffs_base__frame_config::duration() {\n  return wuffs_base__frame_config__duration(this);\n}\n\ninline uint64_t  //\nwuffs_base__frame_config::index() {\n  return wuffs_base__frame_config__index(this);\n}\n\ninline uint64_t  //\nwuffs_base__frame_config::io_position() {\n  return wuffs_base__frame_config__io_position(this);\n}\n\ninline wuffs_base__animation_blend  //\nwuffs_base__frame_config::blend() {\n  return wuffs_base__frame_config__blend(this);\n}\n\ninline wuffs_base__animation_disposal  //\nwuffs_base__f" +
+	"rame_config::disposal() {\n  return wuffs_base__frame_config__disposal(this);\n}\n\n#endif  // __cplusplus\n\n" +
 	"" +
-	"// --------\n\ntypedef struct {\n  wuffs_base__pixel_config pixcfg;\n\n  // Do not access the private_impl's fields directly. There is no API/ABI\n  // compatibility or safety guarantee if you do so.\n  struct {\n    wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n    // TODO: color spaces.\n  } private_impl;\n\n#ifdef __cplusplus\n  inline wuffs_base__status set_from_slice(wuffs_base__pixel_config* pixcfg,\n                                           wuffs_base__slice_u8 pixbuf_memory);\n  inline wuffs_base__slice_u8 palette();\n  inline wuffs_base__pixel_format pixel_format();\n  inline wuffs_base__table_u8 plane(uint32_t p);\n#endif  // __cplusplus\n\n} wuffs_base__pixel_buffer;\n\nstatic inline wuffs_base__status  //\nwuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,\n                                         wuffs_base__pixel_config* pixcfg,\n                                         wuffs_base__slice_u8 pixbuf_memory) {\n  if (!b) {\n    return wuffs_base__error__bad_receiver;\n  }\n  *b = (" +
-	"(wuffs_base__pixel_buffer){});\n  if (!pixcfg) {\n    return wuffs_base__error__bad_argument;\n  }\n  if (wuffs_base__pixel_format__is_planar(pixcfg->private_impl.pixfmt)) {\n    // TODO: support planar pixel formats, concious of pixel subsampling.\n    return wuffs_base__error__bad_argument;\n  }\n  uint32_t bits_per_pixel =\n      wuffs_base__pixel_format__bits_per_pixel(pixcfg->private_impl.pixfmt);\n  if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n    return wuffs_base__error__bad_argument;\n  }\n  uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n  uint8_t* ptr = pixbuf_memory.ptr;\n  uint64_t len = pixbuf_memory.len;\n  if (wuffs_base__pixel_format__is_indexed(pixcfg->private_impl.pixfmt)) {\n    // Split a 1024 byte chunk (256 palette entries × 4 bytes per entry) from\n    // the start of pixbuf_memory. We split from the start, not the end, so\n    // that the both chunks' pointers have the same alignment as the original\n    // pointer, up to an alignment of 1024.\n    if (len < 1024) {\n      return wuffs_ba" +
-	"se__error__bad_argument_length_too_short;\n    }\n    wuffs_base__table_u8* tab =\n        &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n    tab->ptr = ptr;\n    tab->width = 1024;\n    tab->height = 1;\n    tab->stride = 1024;\n    ptr += 1024;\n    len -= 1024;\n  }\n\n  uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *\n                ((uint64_t)pixcfg->private_impl.height);\n  size_t width = (size_t)(pixcfg->private_impl.width);\n  if ((wh > (UINT64_MAX / bytes_per_pixel)) ||\n      (width > (SIZE_MAX / bytes_per_pixel))) {\n    return wuffs_base__error__bad_argument;\n  }\n  wh *= bytes_per_pixel;\n  width *= bytes_per_pixel;\n  if (wh > len) {\n    return wuffs_base__error__bad_argument_length_too_short;\n  }\n\n  b->pixcfg = *pixcfg;\n  wuffs_base__table_u8* tab = &b->private_impl.planes[0];\n  tab->ptr = ptr;\n  tab->width = width;\n  tab->height = pixcfg->private_impl.height;\n  tab->stride = width;\n  return NULL;\n}\n\n// wuffs_base__pixel_buffer__palette returns the palette color data. If\n// non-e" +
-	"mpty, it will have length 1024.\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) {\n  if (b &&\n      wuffs_base__pixel_format__is_indexed(b->pixcfg.private_impl.pixfmt)) {\n    wuffs_base__table_u8* tab =\n        &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n    if ((tab->width == 1024) && (tab->height == 1)) {\n      return ((wuffs_base__slice_u8){\n          .ptr = tab->ptr,\n          .len = 1024,\n      });\n    }\n  }\n  return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__pixel_format  //\nwuffs_base__pixel_buffer__pixel_format(wuffs_base__pixel_buffer* b) {\n  if (b) {\n    return b->pixcfg.private_impl.pixfmt;\n  }\n  return WUFFS_BASE__PIXEL_FORMAT__INVALID;\n}\n\nstatic inline wuffs_base__table_u8  //\nwuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) {\n  return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))\n             ? b->private_impl.planes[p]\n             : ((wuffs_base__table_u8){});\n}\n\n#ifd" +
-	"ef __cplusplus\n\ninline wuffs_base__status  //\nwuffs_base__pixel_buffer::set_from_slice(wuffs_base__pixel_config* pixcfg,\n                                         wuffs_base__slice_u8 pixbuf_memory) {\n  return wuffs_base__pixel_buffer__set_from_slice(this, pixcfg, pixbuf_memory);\n}\n\ninline wuffs_base__slice_u8  //\nwuffs_base__pixel_buffer::palette() {\n  return wuffs_base__pixel_buffer__palette(this);\n}\n\ninline wuffs_base__pixel_format  //\nwuffs_base__pixel_buffer::pixel_format() {\n  return wuffs_base__pixel_buffer__pixel_format(this);\n}\n\ninline wuffs_base__table_u8  //\nwuffs_base__pixel_buffer::plane(uint32_t p) {\n  return wuffs_base__pixel_buffer__plane(this, p);\n}\n\n#endif  // __cplusplus\n\n" +
+	"// --------\n\ntypedef struct {\n  wuffs_base__pixel_config pixcfg;\n\n  // Do not access the private_impl's fields directly. There is no API/ABI\n  // compatibility or safety guarantee if you do so.\n  struct {\n    wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n    // TODO: color spaces.\n  } private_impl;\n\n#ifdef __cplusplus\n  inline wuffs_base__status set_from_slice(wuffs_base__pixel_config* pixcfg,\n                                           wuffs_base__slice_u8 pixbuf_memory);\n  inline wuffs_base__slice_u8 palette();\n  inline wuffs_base__pixel_format pixel_format();\n  inline wuffs_base__table_u8 plane(uint32_t p);\n#endif  // __cplusplus\n\n} wuffs_base__pixel_buffer;\n\nstatic inline wuffs_base__status  //\nwuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,\n                                         wuffs_base__pixel_config* pixcfg,\n                                         wuffs_base__slice_u8 pixbuf_memory) {\n  if (!b) {\n    return wuffs_base__error__bad_receiver;\n  }\n  memset" +
+	"(b, 0, sizeof(*b));\n  if (!pixcfg) {\n    return wuffs_base__error__bad_argument;\n  }\n  if (wuffs_base__pixel_format__is_planar(pixcfg->private_impl.pixfmt)) {\n    // TODO: support planar pixel formats, concious of pixel subsampling.\n    return wuffs_base__error__bad_argument;\n  }\n  uint32_t bits_per_pixel =\n      wuffs_base__pixel_format__bits_per_pixel(pixcfg->private_impl.pixfmt);\n  if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n    return wuffs_base__error__bad_argument;\n  }\n  uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n  uint8_t* ptr = pixbuf_memory.ptr;\n  uint64_t len = pixbuf_memory.len;\n  if (wuffs_base__pixel_format__is_indexed(pixcfg->private_impl.pixfmt)) {\n    // Split a 1024 byte chunk (256 palette entries × 4 bytes per entry) from\n    // the start of pixbuf_memory. We split from the start, not the end, so\n    // that the both chunks' pointers have the same alignment as the original\n    // pointer, up to an alignment of 1024.\n    if (len < 1024) {\n      return wuffs_base__error__" +
+	"bad_argument_length_too_short;\n    }\n    wuffs_base__table_u8* tab =\n        &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n    tab->ptr = ptr;\n    tab->width = 1024;\n    tab->height = 1;\n    tab->stride = 1024;\n    ptr += 1024;\n    len -= 1024;\n  }\n\n  uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *\n                ((uint64_t)pixcfg->private_impl.height);\n  size_t width = (size_t)(pixcfg->private_impl.width);\n  if ((wh > (UINT64_MAX / bytes_per_pixel)) ||\n      (width > (SIZE_MAX / bytes_per_pixel))) {\n    return wuffs_base__error__bad_argument;\n  }\n  wh *= bytes_per_pixel;\n  width *= bytes_per_pixel;\n  if (wh > len) {\n    return wuffs_base__error__bad_argument_length_too_short;\n  }\n\n  b->pixcfg = *pixcfg;\n  wuffs_base__table_u8* tab = &b->private_impl.planes[0];\n  tab->ptr = ptr;\n  tab->width = width;\n  tab->height = pixcfg->private_impl.height;\n  tab->stride = width;\n  return NULL;\n}\n\n// wuffs_base__pixel_buffer__palette returns the palette color data. If\n// non-empty, it wi" +
+	"ll have length 1024.\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) {\n  if (b &&\n      wuffs_base__pixel_format__is_indexed(b->pixcfg.private_impl.pixfmt)) {\n    wuffs_base__table_u8* tab =\n        &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n    if ((tab->width == 1024) && (tab->height == 1)) {\n      return ((wuffs_base__slice_u8){\n          .ptr = tab->ptr,\n          .len = 1024,\n      });\n    }\n  }\n  return ((wuffs_base__slice_u8){0});\n}\n\nstatic inline wuffs_base__pixel_format  //\nwuffs_base__pixel_buffer__pixel_format(wuffs_base__pixel_buffer* b) {\n  if (b) {\n    return b->pixcfg.private_impl.pixfmt;\n  }\n  return WUFFS_BASE__PIXEL_FORMAT__INVALID;\n}\n\nstatic inline wuffs_base__table_u8  //\nwuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) {\n  return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))\n             ? b->private_impl.planes[p]\n             : ((wuffs_base__table_u8){0});\n}\n\n#ifdef __cplu" +
+	"splus\n\ninline wuffs_base__status  //\nwuffs_base__pixel_buffer::set_from_slice(wuffs_base__pixel_config* pixcfg,\n                                         wuffs_base__slice_u8 pixbuf_memory) {\n  return wuffs_base__pixel_buffer__set_from_slice(this, pixcfg, pixbuf_memory);\n}\n\ninline wuffs_base__slice_u8  //\nwuffs_base__pixel_buffer::palette() {\n  return wuffs_base__pixel_buffer__palette(this);\n}\n\ninline wuffs_base__pixel_format  //\nwuffs_base__pixel_buffer::pixel_format() {\n  return wuffs_base__pixel_buffer__pixel_format(this);\n}\n\ninline wuffs_base__table_u8  //\nwuffs_base__pixel_buffer::plane(uint32_t p) {\n  return wuffs_base__pixel_buffer__plane(this, p);\n}\n\n#endif  // __cplusplus\n\n" +
 	"" +
 	"// --------\n\ntypedef struct {\n  // Do not access the private_impl's fields directly. There is no API/ABI\n  // compatibility or safety guarantee if you do so.\n  struct {\n    uint8_t TODO;\n  } private_impl;\n\n#ifdef __cplusplus\n#endif  // __cplusplus\n\n} wuffs_base__decode_frame_options;\n\n#ifdef __cplusplus\n\n#endif  // __cplusplus\n\n" +
 	"" +
@@ -168,10 +168,10 @@
 	"y, have a sloppy_copy_n_from_history method\n  // that copies 8 bytes at a time, possibly writing more than length bytes?\n  for (; n >= 3; n -= 3) {\n    *p++ = *q++;\n    *p++ = *q++;\n    *p++ = *q++;\n  }\n  for (; n; n--) {\n    *p++ = *q++;\n  }\n  *ptr_iop_w = p;\n  return length;\n}\n\n// wuffs_base__io_writer__copy_n_from_history_fast is like the\n// wuffs_base__io_writer__copy_n_from_history function above, but has stronger\n// pre-conditions. The caller needs to prove that:\n//  - distance >  0\n//  - distance <= (*ptr_iop_w - io0_w)\n//  - length   <= (io1_w      - *ptr_iop_w)\nstatic inline uint32_t  //\nwuffs_base__io_writer__copy_n_from_history_fast(uint8_t** ptr_iop_w,\n                                                uint8_t* io0_w,\n                                                uint8_t* io1_w,\n                                                uint32_t length,\n                                                uint32_t distance) {\n  uint8_t* p = *ptr_iop_w;\n  uint8_t* q = p - distance;\n  uint32_t n = length;\n  for (; n" +
 	" >= 3; n -= 3) {\n    *p++ = *q++;\n    *p++ = *q++;\n    *p++ = *q++;\n  }\n  for (; n; n--) {\n    *p++ = *q++;\n  }\n  *ptr_iop_w = p;\n  return length;\n}\n\nstatic inline uint32_t  //\nwuffs_base__io_writer__copy_n_from_reader(uint8_t** ptr_iop_w,\n                                          uint8_t* io1_w,\n                                          uint32_t length,\n                                          uint8_t** ptr_iop_r,\n                                          uint8_t* io1_r) {\n  uint8_t* iop_w = *ptr_iop_w;\n  size_t n = length;\n  if (n > ((size_t)(io1_w - iop_w))) {\n    n = io1_w - iop_w;\n  }\n  uint8_t* iop_r = *ptr_iop_r;\n  if (n > ((size_t)(io1_r - iop_r))) {\n    n = io1_r - iop_r;\n  }\n  if (n > 0) {\n    memmove(iop_w, iop_r, n);\n    *ptr_iop_w += n;\n    *ptr_iop_r += n;\n  }\n  return n;\n}\n\nstatic inline uint64_t  //\nwuffs_base__io_writer__copy_from_slice(uint8_t** ptr_iop_w,\n                                       uint8_t* io1_w,\n                                       wuffs_base__slice_u8 src) {\n  uint8_t* iop" +
 	"_w = *ptr_iop_w;\n  size_t n = src.len;\n  if (n > ((size_t)(io1_w - iop_w))) {\n    n = io1_w - iop_w;\n  }\n  if (n > 0) {\n    memmove(iop_w, src.ptr, n);\n    *ptr_iop_w += n;\n  }\n  return n;\n}\n\nstatic inline uint32_t  //\nwuffs_base__io_writer__copy_n_from_slice(uint8_t** ptr_iop_w,\n                                         uint8_t* io1_w,\n                                         uint32_t length,\n                                         wuffs_base__slice_u8 src) {\n  uint8_t* iop_w = *ptr_iop_w;\n  size_t n = src.len;\n  if (n > length) {\n    n = length;\n  }\n  if (n > ((size_t)(io1_w - iop_w))) {\n    n = io1_w - iop_w;\n  }\n  if (n > 0) {\n    memmove(iop_w, src.ptr, n);\n    *ptr_iop_w += n;\n  }\n  return n;\n}\n\nstatic inline wuffs_base__empty_struct  //\nwuffs_base__io_reader__set(wuffs_base__io_reader* o,\n                           wuffs_base__io_buffer* b,\n                           uint8_t** ptr_iop_r,\n                           uint8_t** ptr_io1_r,\n                           wuffs_base__slice_u8 data) {\n  b->data = " +
-	"data;\n  b->meta.wi = data.len;\n  b->meta.ri = 0;\n  b->meta.pos = 0;\n  b->meta.closed = false;\n\n  o->private_impl.buf = b;\n  o->private_impl.mark = data.ptr;\n  o->private_impl.limit = data.ptr + data.len;\n  *ptr_iop_r = data.ptr;\n  *ptr_io1_r = data.ptr + data.len;\n  return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct  //\nwuffs_base__io_reader__set_limit(wuffs_base__io_reader* o,\n                                 uint8_t* iop_r,\n                                 uint64_t limit) {\n  if (o && (((size_t)(o->private_impl.limit - iop_r)) > limit)) {\n    o->private_impl.limit = iop_r + limit;\n  }\n  return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct  //\nwuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) {\n  o->private_impl.mark = mark;\n  return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__io_reader__take(uint8_t** ptr_iop_r, uint8_t* io1_r, uint64_t n) {\n  if (n <= ((size_t)(io1_r - *ptr_iop_r))) {\n" +
-	"    uint8_t* p = *ptr_iop_r;\n    *ptr_iop_r += n;\n    return ((wuffs_base__slice_u8){\n        .ptr = p,\n        .len = n,\n    });\n  }\n  return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__empty_struct  //\nwuffs_base__io_writer__set(wuffs_base__io_writer* o,\n                           wuffs_base__io_buffer* b,\n                           uint8_t** ptr_iop_w,\n                           uint8_t** ptr_io1_w,\n                           wuffs_base__slice_u8 data) {\n  b->data = data;\n  b->meta.wi = 0;\n  b->meta.ri = 0;\n  b->meta.pos = 0;\n  b->meta.closed = false;\n\n  o->private_impl.buf = b;\n  o->private_impl.mark = data.ptr;\n  o->private_impl.limit = data.ptr + data.len;\n  *ptr_iop_w = data.ptr;\n  *ptr_io1_w = data.ptr + data.len;\n  return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct  //\nwuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) {\n  o->private_impl.mark = mark;\n  return ((wuffs_base__empty_struct){});\n}\n\n" +
+	"data;\n  b->meta.wi = data.len;\n  b->meta.ri = 0;\n  b->meta.pos = 0;\n  b->meta.closed = false;\n\n  o->private_impl.buf = b;\n  o->private_impl.mark = data.ptr;\n  o->private_impl.limit = data.ptr + data.len;\n  *ptr_iop_r = data.ptr;\n  *ptr_io1_r = data.ptr + data.len;\n  return ((wuffs_base__empty_struct){0});\n}\n\nstatic inline wuffs_base__empty_struct  //\nwuffs_base__io_reader__set_limit(wuffs_base__io_reader* o,\n                                 uint8_t* iop_r,\n                                 uint64_t limit) {\n  if (o && (((size_t)(o->private_impl.limit - iop_r)) > limit)) {\n    o->private_impl.limit = iop_r + limit;\n  }\n  return ((wuffs_base__empty_struct){0});\n}\n\nstatic inline wuffs_base__empty_struct  //\nwuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) {\n  o->private_impl.mark = mark;\n  return ((wuffs_base__empty_struct){0});\n}\n\nstatic inline wuffs_base__slice_u8  //\nwuffs_base__io_reader__take(uint8_t** ptr_iop_r, uint8_t* io1_r, uint64_t n) {\n  if (n <= ((size_t)(io1_r - *ptr_iop_r)))" +
+	" {\n    uint8_t* p = *ptr_iop_r;\n    *ptr_iop_r += n;\n    return ((wuffs_base__slice_u8){\n        .ptr = p,\n        .len = n,\n    });\n  }\n  return ((wuffs_base__slice_u8){0});\n}\n\nstatic inline wuffs_base__empty_struct  //\nwuffs_base__io_writer__set(wuffs_base__io_writer* o,\n                           wuffs_base__io_buffer* b,\n                           uint8_t** ptr_iop_w,\n                           uint8_t** ptr_io1_w,\n                           wuffs_base__slice_u8 data) {\n  b->data = data;\n  b->meta.wi = 0;\n  b->meta.ri = 0;\n  b->meta.pos = 0;\n  b->meta.closed = false;\n\n  o->private_impl.buf = b;\n  o->private_impl.mark = data.ptr;\n  o->private_impl.limit = data.ptr + data.len;\n  *ptr_iop_w = data.ptr;\n  *ptr_io1_w = data.ptr + data.len;\n  return ((wuffs_base__empty_struct){0});\n}\n\nstatic inline wuffs_base__empty_struct  //\nwuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) {\n  o->private_impl.mark = mark;\n  return ((wuffs_base__empty_struct){0});\n}\n\n" +
 	"" +
-	"// ---------------- I/O (Utility)\n\nstatic inline wuffs_base__io_reader  //\nwuffs_base__utility__null_io_reader() {\n  return ((wuffs_base__io_reader){});\n}\n\nstatic inline wuffs_base__io_writer  //\nwuffs_base__utility__null_io_writer() {\n  return ((wuffs_base__io_writer){});\n}\n\n" +
+	"// ---------------- I/O (Utility)\n\nstatic inline wuffs_base__io_reader  //\nwuffs_base__utility__null_io_reader() {\n  return ((wuffs_base__io_reader){.private_impl = {0}});\n}\n\nstatic inline wuffs_base__io_writer  //\nwuffs_base__utility__null_io_writer() {\n  return ((wuffs_base__io_writer){.private_impl = {0}});\n}\n\n" +
 	"" +
 	"// ---------------- Bureaucracy re -Wunused-function\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__io_private()\n    WUFFS_BASE__POTENTIALLY_UNUSED;\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__io_private() {\n  (void)(wuffs_base__io_buffer__is_valid);\n  (void)(wuffs_base__io_reader__is_eof);\n  (void)(wuffs_base__io_reader__is_valid);\n  (void)(wuffs_base__io_reader__set);\n  (void)(wuffs_base__io_reader__set_limit);\n  (void)(wuffs_base__io_reader__set_mark);\n  (void)(wuffs_base__io_reader__take);\n  (void)(wuffs_base__io_writer__copy_from_slice);\n  (void)(wuffs_base__io_writer__copy_n_from_history);\n  (void)(wuffs_base__io_writer__copy_n_from_history_fast);\n  (void)(wuffs_base__io_writer__copy_n_from_reader);\n  (void)(wuffs_base__io_writer__copy_n_from_slice);\n  (void)(wuffs_base__io_writer__is_valid);\n  (void)(wuffs_base__io_writer__set);\n  (void)(wuffs_base__io_writer__set_mark);\n  (void)(wuffs_base__utility__null_io_reader);\n  (void)(wuffs_base__utility_" +
 	"_null_io_writer);\n}\n" +
@@ -180,8 +180,8 @@
 const baseIOPublicH = "" +
 	"// ---------------- I/O\n\nstruct wuffs_base__io_buffer__struct;\n\ntypedef struct {\n  // Do not access the private_impl's fields directly. There is no API/ABI\n  // compatibility or safety guarantee if you do so.\n  struct {\n    struct wuffs_base__io_buffer__struct* buf;\n    // The bounds values are typically NULL, when created by the Wuffs public\n    // API. NULL means that the callee substitutes the implicit bounds derived\n    // from buf.\n    uint8_t* mark;\n    uint8_t* limit;\n  } private_impl;\n} wuffs_base__io_reader;\n\ntypedef struct {\n  // Do not access the private_impl's fields directly. There is no API/ABI\n  // compatibility or safety guarantee if you do so.\n  struct {\n    struct wuffs_base__io_buffer__struct* buf;\n    // The bounds values are typically NULL, when created by the Wuffs public\n    // API. NULL means that the callee substitutes the implicit bounds derived\n    // from buf.\n    uint8_t* mark;\n    uint8_t* limit;\n  } private_impl;\n} wuffs_base__io_writer;\n\n// wuffs_base__io_buffer_meta is the met" +
 	"adata for a wuffs_base__io_buffer's\n// data.\ntypedef struct {\n  size_t wi;     // Write index. Invariant: wi <= len.\n  size_t ri;     // Read  index. Invariant: ri <= wi.\n  uint64_t pos;  // Position of the buffer start relative to the stream start.\n  bool closed;   // No further writes are expected.\n} wuffs_base__io_buffer_meta;\n\n// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length) plus\n// additional metadata.\n//\n// A value with all fields zero is a valid, empty buffer.\ntypedef struct wuffs_base__io_buffer__struct {\n  wuffs_base__slice_u8 data;\n  wuffs_base__io_buffer_meta meta;\n\n#ifdef __cplusplus\n  inline void compact();\n  inline wuffs_base__io_reader reader();\n  inline wuffs_base__io_writer writer();\n  inline uint64_t reader_io_position();\n  inline uint64_t writer_io_position();\n#endif  // __cplusplus\n\n} wuffs_base__io_buffer;\n\n// wuffs_base__io_buffer__compact moves any written but unread bytes to the\n// start of the buffer.\nstatic inline void  //\nwuffs_base__io_buffer__compact(wuffs" +
-	"_base__io_buffer* buf) {\n  if (!buf || (buf->meta.ri == 0)) {\n    return;\n  }\n  buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri);\n  size_t n = buf->meta.wi - buf->meta.ri;\n  if (n != 0) {\n    memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri, n);\n  }\n  buf->meta.wi = n;\n  buf->meta.ri = 0;\n}\n\nstatic inline wuffs_base__io_reader  //\nwuffs_base__io_buffer__reader(wuffs_base__io_buffer* buf) {\n  wuffs_base__io_reader ret = ((wuffs_base__io_reader){});\n  ret.private_impl.buf = buf;\n  return ret;\n}\n\nstatic inline wuffs_base__io_writer  //\nwuffs_base__io_buffer__writer(wuffs_base__io_buffer* buf) {\n  wuffs_base__io_writer ret = ((wuffs_base__io_writer){});\n  ret.private_impl.buf = buf;\n  return ret;\n}\n\nstatic inline uint64_t  //\nwuffs_base__io_buffer__reader_io_position(wuffs_base__io_buffer* buf) {\n  return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri) : 0;\n}\n\nstatic inline uint64_t  //\nwuffs_base__io_buffer__writer_io_position(wuffs_base__io_buffer* buf) {\n  return buf ? wuffs" +
-	"_base__u64__sat_add(buf->meta.pos, buf->meta.wi) : 0;\n}\n\n#ifdef __cplusplus\n\ninline void  //\nwuffs_base__io_buffer__struct::compact() {\n  wuffs_base__io_buffer__compact(this);\n}\n\ninline wuffs_base__io_reader  //\nwuffs_base__io_buffer__struct::reader() {\n  return wuffs_base__io_buffer__reader(this);\n}\n\ninline wuffs_base__io_writer  //\nwuffs_base__io_buffer__struct::writer() {\n  return wuffs_base__io_buffer__writer(this);\n}\n\ninline uint64_t  //\nwuffs_base__io_buffer__struct::reader_io_position() {\n  return wuffs_base__io_buffer__reader_io_position(this);\n}\n\ninline uint64_t  //\nwuffs_base__io_buffer__struct::writer_io_position() {\n  return wuffs_base__io_buffer__writer_io_position(this);\n}\n\n#endif  // __cplusplus\n\n" +
+	"_base__io_buffer* buf) {\n  if (!buf || (buf->meta.ri == 0)) {\n    return;\n  }\n  buf->meta.pos = wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri);\n  size_t n = buf->meta.wi - buf->meta.ri;\n  if (n != 0) {\n    memmove(buf->data.ptr, buf->data.ptr + buf->meta.ri, n);\n  }\n  buf->meta.wi = n;\n  buf->meta.ri = 0;\n}\n\nstatic inline wuffs_base__io_reader  //\nwuffs_base__io_buffer__reader(wuffs_base__io_buffer* buf) {\n  wuffs_base__io_reader ret = ((wuffs_base__io_reader){.private_impl = {0}});\n  ret.private_impl.buf = buf;\n  return ret;\n}\n\nstatic inline wuffs_base__io_writer  //\nwuffs_base__io_buffer__writer(wuffs_base__io_buffer* buf) {\n  wuffs_base__io_writer ret = ((wuffs_base__io_writer){.private_impl = {0}});\n  ret.private_impl.buf = buf;\n  return ret;\n}\n\nstatic inline uint64_t  //\nwuffs_base__io_buffer__reader_io_position(wuffs_base__io_buffer* buf) {\n  return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.ri) : 0;\n}\n\nstatic inline uint64_t  //\nwuffs_base__io_buffer__writer_io_position(wuffs_base__" +
+	"io_buffer* buf) {\n  return buf ? wuffs_base__u64__sat_add(buf->meta.pos, buf->meta.wi) : 0;\n}\n\n#ifdef __cplusplus\n\ninline void  //\nwuffs_base__io_buffer__struct::compact() {\n  wuffs_base__io_buffer__compact(this);\n}\n\ninline wuffs_base__io_reader  //\nwuffs_base__io_buffer__struct::reader() {\n  return wuffs_base__io_buffer__reader(this);\n}\n\ninline wuffs_base__io_writer  //\nwuffs_base__io_buffer__struct::writer() {\n  return wuffs_base__io_buffer__writer(this);\n}\n\ninline uint64_t  //\nwuffs_base__io_buffer__struct::reader_io_position() {\n  return wuffs_base__io_buffer__reader_io_position(this);\n}\n\ninline uint64_t  //\nwuffs_base__io_buffer__struct::writer_io_position() {\n  return wuffs_base__io_buffer__writer_io_position(this);\n}\n\n#endif  // __cplusplus\n\n" +
 	"" +
 	"// ---------------- Bureaucracy re -Wunused-function\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__io_public()\n    WUFFS_BASE__POTENTIALLY_UNUSED;\n\nstatic inline void\nwuffs_base__acknowledge_potentially_unused_functions__io_public() {\n  (void)(wuffs_base__io_buffer__compact);\n  (void)(wuffs_base__io_buffer__reader);\n  (void)(wuffs_base__io_buffer__reader_io_position);\n  (void)(wuffs_base__io_buffer__writer);\n  (void)(wuffs_base__io_buffer__writer_io_position);\n}\n" +
 	""
diff --git a/cmd/wuffs-c/internal/cgen/expr.go b/cmd/wuffs-c/internal/cgen/expr.go
index 84d26e0..c9f48b5 100644
--- a/cmd/wuffs-c/internal/cgen/expr.go
+++ b/cmd/wuffs-c/internal/cgen/expr.go
@@ -123,7 +123,7 @@
 			if err := g.writeExpr(b, recv, depth); err != nil {
 				return err
 			}
-			b.printf(", 0, sizeof ((%s%s){}))", g.packagePrefix(qid), qid[1].Str(g.tm))
+			b.printf(", 0, sizeof (%s%s))", g.packagePrefix(qid), qid[1].Str(g.tm))
 
 			if !isBaseRangeType(qid) {
 				b.printf(", wuffs_base__ignore_status("+
@@ -131,7 +131,7 @@
 				if err := g.writeExpr(b, recv, depth); err != nil {
 					return err
 				}
-				b.printf(", sizeof ((%s%s){}), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED))",
+				b.printf(", sizeof (%s%s), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED))",
 					g.packagePrefix(qid), qid[1].Str(g.tm))
 			}
 
diff --git a/cmd/wuffs-c/internal/cgen/func.go b/cmd/wuffs-c/internal/cgen/func.go
index 865cab7..7809567 100644
--- a/cmd/wuffs-c/internal/cgen/func.go
+++ b/cmd/wuffs-c/internal/cgen/func.go
@@ -218,7 +218,7 @@
 
 func (g *gen) writeOutParamZeroValue(b *buffer, typ *a.TypeExpr) error {
 	if typ == nil {
-		b.writes("((wuffs_base__empty_struct){})")
+		b.writes("((wuffs_base__empty_struct){0})")
 	} else if typ.IsNumType() {
 		b.writes("0")
 	} else {
@@ -226,7 +226,7 @@
 		if err := g.writeCTypeName(b, typ, "", ""); err != nil {
 			return err
 		}
-		b.writes("){})")
+		b.writes("){0})")
 	}
 	return nil
 }
@@ -379,7 +379,7 @@
 		}
 		b.writes("return status;\n")
 	} else if g.currFunk.astFunc.Out() == nil {
-		b.writes("return ((wuffs_base__empty_struct){});\n")
+		b.writes("return ((wuffs_base__empty_struct){0});\n")
 	}
 	return nil
 }
@@ -448,7 +448,7 @@
 		b.writes("return wuffs_base__error__bad_argument;\n\n")
 	} else {
 		// TODO: don't assume that the return type is empty.
-		b.printf("return ((wuffs_base__empty_struct){});\n")
+		b.printf("return ((wuffs_base__empty_struct){0});\n")
 	}
 	b.writes("}\n")
 	return nil
diff --git a/cmd/wuffs-c/internal/cgen/statement.go b/cmd/wuffs-c/internal/cgen/statement.go
index 64f65ea..e567514 100644
--- a/cmd/wuffs-c/internal/cgen/statement.go
+++ b/cmd/wuffs-c/internal/cgen/statement.go
@@ -446,7 +446,7 @@
 
 	b.writes("return ")
 	if g.currFunk.astFunc.Out() == nil {
-		b.writes("((wuffs_base__empty_struct){})")
+		b.writes("((wuffs_base__empty_struct){0})")
 	} else if err := g.writeExpr(b, retExpr, depth); err != nil {
 		return err
 	}
diff --git a/cmd/wuffs-c/internal/cgen/var.go b/cmd/wuffs-c/internal/cgen/var.go
index d92b3ff..25030f6 100644
--- a/cmd/wuffs-c/internal/cgen/var.go
+++ b/cmd/wuffs-c/internal/cgen/var.go
@@ -289,12 +289,17 @@
 			b.writes(" = false;\n")
 		} else if typ.IsStatus() {
 			b.writes(" = NULL;\n")
+		} else if typ.IsIOType() {
+			b.writes(" = {.private_impl = {0}};\n")
 		} else {
-			b.writes(" = {};\n")
+			b.writes(" = {0};\n")
 		}
 
 		if typ.IsIOType() {
-			b.printf("wuffs_base__io_buffer %s%s WUFFS_BASE__POTENTIALLY_UNUSED = {};\n", uPrefix, name)
+			b.printf("wuffs_base__io_buffer %s%s WUFFS_BASE__POTENTIALLY_UNUSED = {"+
+				".data = ((wuffs_base__slice_u8){0}),\n"+
+				".meta = ((wuffs_base__io_buffer_meta){0}),\n"+
+				"};\n", uPrefix, name)
 			preName := vPrefix + name
 			// TODO: io0_etc variables?
 			b.printf("uint8_t* %s%s WUFFS_BASE__POTENTIALLY_UNUSED = NULL;\n", iopPrefix, preName)
diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c
index 8f79c9b..eb9e5b7 100644
--- a/release/c/wuffs-unsupported-snapshot.c
+++ b/release/c/wuffs-unsupported-snapshot.c
@@ -348,7 +348,7 @@
         .len = s.len - i,
     });
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 // wuffs_base__slice_u8__subslice_j returns s[:j].
@@ -362,7 +362,7 @@
         .len = j,
     });
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 // wuffs_base__slice_u8__subslice_ij returns s[i:j].
@@ -378,7 +378,7 @@
         .len = j - i,
     });
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 // ---------------- Bureaucracy re -Wunused-function
@@ -1266,14 +1266,14 @@
 
 static inline wuffs_base__io_reader  //
 wuffs_base__io_buffer__reader(wuffs_base__io_buffer* buf) {
-  wuffs_base__io_reader ret = ((wuffs_base__io_reader){});
+  wuffs_base__io_reader ret = ((wuffs_base__io_reader){.private_impl = {0}});
   ret.private_impl.buf = buf;
   return ret;
 }
 
 static inline wuffs_base__io_writer  //
 wuffs_base__io_buffer__writer(wuffs_base__io_buffer* buf) {
-  wuffs_base__io_writer ret = ((wuffs_base__io_writer){});
+  wuffs_base__io_writer ret = ((wuffs_base__io_writer){.private_impl = {0}});
   ret.private_impl.buf = buf;
   return ret;
 }
@@ -1358,7 +1358,7 @@
       });
     }
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 static inline wuffs_base__slice_u16  //
@@ -1372,7 +1372,7 @@
       });
     }
   }
-  return ((wuffs_base__slice_u16){});
+  return ((wuffs_base__slice_u16){0});
 }
 
 static inline wuffs_base__slice_u32  //
@@ -1386,7 +1386,7 @@
       });
     }
   }
-  return ((wuffs_base__slice_u32){});
+  return ((wuffs_base__slice_u32){0});
 }
 
 static inline wuffs_base__slice_u64  //
@@ -1400,7 +1400,7 @@
       });
     }
   }
-  return ((wuffs_base__slice_u64){});
+  return ((wuffs_base__slice_u64){0});
 }
 
 // ---------------- Bureaucracy re -Wunused-function
@@ -1777,13 +1777,17 @@
       return;
     }
   }
-  *c = ((wuffs_base__pixel_config){});
+  *c = ((wuffs_base__pixel_config){
+      .private_impl = {0},
+  });
 }
 
 static inline void  //
 wuffs_base__pixel_config__invalidate(wuffs_base__pixel_config* c) {
   if (c) {
-    *c = ((wuffs_base__pixel_config){});
+    *c = ((wuffs_base__pixel_config){
+        .private_impl = {0},
+    });
   }
 }
 
@@ -1810,7 +1814,7 @@
                  .max_excl_x = c->private_impl.width,
                  .max_excl_y = c->private_impl.height,
              })
-           : ((wuffs_base__rect_ie_u32){});
+           : ((wuffs_base__rect_ie_u32){0});
 }
 
 static inline uint32_t  //
@@ -1969,13 +1973,19 @@
     c->private_impl.first_frame_is_opaque = first_frame_is_opaque;
     return;
   }
-  *c = ((wuffs_base__image_config){});
+  *c = ((wuffs_base__image_config){
+      .pixcfg = {.private_impl = {0}},
+      .private_impl = {0},
+  });
 }
 
 static inline void  //
 wuffs_base__image_config__invalidate(wuffs_base__image_config* c) {
   if (c) {
-    *c = ((wuffs_base__image_config){});
+    *c = ((wuffs_base__image_config){
+        .pixcfg = {.private_impl = {0}},
+        .private_impl = {0},
+    });
   }
 }
 
@@ -2122,7 +2132,7 @@
 
 static inline wuffs_base__rect_ie_u32  //
 wuffs_base__frame_config__bounds(wuffs_base__frame_config* c) {
-  return c ? c->private_impl.bounds : ((wuffs_base__rect_ie_u32){});
+  return c ? c->private_impl.bounds : ((wuffs_base__rect_ie_u32){0});
 }
 
 static inline uint32_t  //
@@ -2254,7 +2264,7 @@
   if (!b) {
     return wuffs_base__error__bad_receiver;
   }
-  *b = ((wuffs_base__pixel_buffer){});
+  memset(b, 0, sizeof(*b));
   if (!pixcfg) {
     return wuffs_base__error__bad_argument;
   }
@@ -2326,7 +2336,7 @@
       });
     }
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 static inline wuffs_base__pixel_format  //
@@ -2341,7 +2351,7 @@
 wuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) {
   return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))
              ? b->private_impl.planes[p]
-             : ((wuffs_base__table_u8){});
+             : ((wuffs_base__table_u8){0});
 }
 
 #ifdef __cplusplus
@@ -3895,7 +3905,7 @@
 
 static inline wuffs_base__empty_struct  //
 wuffs_base__return_empty_struct() {
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 // ---------------- Numeric Types
@@ -4232,14 +4242,14 @@
         .len = t.width,
     });
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 // ---------------- Slices and Tables (Utility)
 
 static inline wuffs_base__slice_u8  //
 wuffs_base__utility__null_slice_u8() {
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 // ---------------- Bureaucracy re -Wunused-function
@@ -4614,7 +4624,7 @@
   o->private_impl.limit = data.ptr + data.len;
   *ptr_iop_r = data.ptr;
   *ptr_io1_r = data.ptr + data.len;
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 static inline wuffs_base__empty_struct  //
@@ -4624,13 +4634,13 @@
   if (o && (((size_t)(o->private_impl.limit - iop_r)) > limit)) {
     o->private_impl.limit = iop_r + limit;
   }
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 static inline wuffs_base__empty_struct  //
 wuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) {
   o->private_impl.mark = mark;
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 static inline wuffs_base__slice_u8  //
@@ -4643,7 +4653,7 @@
         .len = n,
     });
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 static inline wuffs_base__empty_struct  //
@@ -4663,25 +4673,25 @@
   o->private_impl.limit = data.ptr + data.len;
   *ptr_iop_w = data.ptr;
   *ptr_io1_w = data.ptr + data.len;
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 static inline wuffs_base__empty_struct  //
 wuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) {
   o->private_impl.mark = mark;
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 // ---------------- I/O (Utility)
 
 static inline wuffs_base__io_reader  //
 wuffs_base__utility__null_io_reader() {
-  return ((wuffs_base__io_reader){});
+  return ((wuffs_base__io_reader){.private_impl = {0}});
 }
 
 static inline wuffs_base__io_writer  //
 wuffs_base__utility__null_io_writer() {
-  return ((wuffs_base__io_writer){});
+  return ((wuffs_base__io_writer){.private_impl = {0}});
 }
 
 // ---------------- Bureaucracy re -Wunused-function
@@ -4989,7 +4999,7 @@
 
 size_t  //
 sizeof__wuffs_adler32__hasher() {
-  return sizeof((wuffs_adler32__hasher){});
+  return sizeof(wuffs_adler32__hasher);
 }
 
 // ---------------- Function Implementations
@@ -5008,8 +5018,8 @@
 
   uint32_t v_s1 = 0;
   uint32_t v_s2 = 0;
-  wuffs_base__slice_u8 v_remaining = {};
-  wuffs_base__slice_u8 v_p = {};
+  wuffs_base__slice_u8 v_remaining = {0};
+  wuffs_base__slice_u8 v_p = {0};
 
   if (!self->private_impl.f_started) {
     self->private_impl.f_started = true;
@@ -5988,7 +5998,7 @@
 
 size_t  //
 sizeof__wuffs_crc32__ieee_hasher() {
-  return sizeof((wuffs_crc32__ieee_hasher){});
+  return sizeof(wuffs_crc32__ieee_hasher);
 }
 
 // ---------------- Function Implementations
@@ -6006,7 +6016,7 @@
   }
 
   uint32_t v_s = 0;
-  wuffs_base__slice_u8 v_p = {};
+  wuffs_base__slice_u8 v_p = {0};
 
   v_s = (4294967295 ^ self->private_impl.f_state);
   {
@@ -6266,7 +6276,7 @@
 
 size_t  //
 sizeof__wuffs_deflate__decoder() {
-  return sizeof((wuffs_deflate__decoder){});
+  return sizeof(wuffs_deflate__decoder);
 }
 
 // ---------------- Function Implementations
@@ -6276,10 +6286,10 @@
 WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64  //
 wuffs_deflate__decoder__workbuf_len(const wuffs_deflate__decoder* self) {
   if (!self) {
-    return ((wuffs_base__range_ii_u64){});
+    return ((wuffs_base__range_ii_u64){0});
   }
   if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
-    return ((wuffs_base__range_ii_u64){});
+    return ((wuffs_base__range_ii_u64){0});
   }
 
   return wuffs_base__utility__make_range_ii_u64(33280, 33280);
@@ -6309,7 +6319,7 @@
   wuffs_base__status status = NULL;
 
   wuffs_base__status v_status = NULL;
-  wuffs_base__slice_u8 v_written = {};
+  wuffs_base__slice_u8 v_written = {0};
   uint64_t v_n_copied = 0;
   uint32_t v_already_full = 0;
 
@@ -7030,13 +7040,13 @@
                                   uint32_t a_n_codes0,
                                   uint32_t a_n_codes1,
                                   uint32_t a_base_symbol) {
-  uint16_t v_counts[16] = {};
+  uint16_t v_counts[16] = {0};
   uint32_t v_i = 0;
   uint32_t v_remaining = 0;
-  uint16_t v_offsets[16] = {};
+  uint16_t v_offsets[16] = {0};
   uint32_t v_n_symbols = 0;
   uint32_t v_count = 0;
-  uint16_t v_symbols[320] = {};
+  uint16_t v_symbols[320] = {0};
   uint32_t v_min_cl = 0;
   uint32_t v_max_cl = 0;
   uint32_t v_initial_high_bits = 0;
@@ -8049,7 +8059,7 @@
 
 size_t  //
 sizeof__wuffs_lzw__decoder() {
-  return sizeof((wuffs_lzw__decoder){});
+  return sizeof(wuffs_lzw__decoder);
 }
 
 // ---------------- Function Implementations
@@ -8059,18 +8069,18 @@
 WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct  //
 wuffs_lzw__decoder__set_literal_width(wuffs_lzw__decoder* self, uint32_t a_lw) {
   if (!self) {
-    return ((wuffs_base__empty_struct){});
+    return ((wuffs_base__empty_struct){0});
   }
   if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
-    return ((wuffs_base__empty_struct){});
+    return ((wuffs_base__empty_struct){0});
   }
   if (a_lw < 2 || a_lw > 8) {
     self->private_impl.magic = WUFFS_BASE__DISABLED;
-    return ((wuffs_base__empty_struct){});
+    return ((wuffs_base__empty_struct){0});
   }
 
   self->private_impl.f_set_literal_width_arg = a_lw;
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 // -------- func lzw.decoder.workbuf_len
@@ -8078,10 +8088,10 @@
 WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64  //
 wuffs_lzw__decoder__workbuf_len(const wuffs_lzw__decoder* self) {
   if (!self) {
-    return ((wuffs_base__range_ii_u64){});
+    return ((wuffs_base__range_ii_u64){0});
   }
   if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
-    return ((wuffs_base__range_ii_u64){});
+    return ((wuffs_base__range_ii_u64){0});
   }
 
   return wuffs_base__utility__make_range_ii_u64(0, 0);
@@ -8379,7 +8389,7 @@
         iop_a_src - a_src.private_impl.buf->data.ptr;
   }
 
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 // -------- func lzw.decoder.write_to
@@ -8389,7 +8399,7 @@
                              wuffs_base__io_writer a_dst) {
   wuffs_base__status status = NULL;
 
-  wuffs_base__slice_u8 v_s = {};
+  wuffs_base__slice_u8 v_s = {0};
   uint64_t v_n = 0;
 
   uint8_t* iop_a_dst = NULL;
@@ -8466,13 +8476,13 @@
 WUFFS_BASE__MAYBE_STATIC wuffs_base__slice_u8  //
 wuffs_lzw__decoder__flush(wuffs_lzw__decoder* self) {
   if (!self) {
-    return ((wuffs_base__slice_u8){});
+    return ((wuffs_base__slice_u8){0});
   }
   if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
-    return ((wuffs_base__slice_u8){});
+    return ((wuffs_base__slice_u8){0});
   }
 
-  wuffs_base__slice_u8 v_s = {};
+  wuffs_base__slice_u8 v_s = {0};
 
   if (self->private_impl.f_output_ri <= self->private_impl.f_output_wi) {
     v_s = wuffs_base__slice_u8__subslice_ij(
@@ -8633,7 +8643,7 @@
 
 size_t  //
 sizeof__wuffs_gif__decoder() {
-  return sizeof((wuffs_gif__decoder){});
+  return sizeof(wuffs_gif__decoder);
 }
 
 // ---------------- Function Implementations
@@ -8770,10 +8780,10 @@
 WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32  //
 wuffs_gif__decoder__frame_dirty_rect(const wuffs_gif__decoder* self) {
   if (!self) {
-    return ((wuffs_base__rect_ie_u32){});
+    return ((wuffs_base__rect_ie_u32){0});
   }
   if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
-    return ((wuffs_base__rect_ie_u32){});
+    return ((wuffs_base__rect_ie_u32){0});
   }
 
   return wuffs_base__utility__make_rect_ie_u32(
@@ -8790,10 +8800,10 @@
 WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64  //
 wuffs_gif__decoder__workbuf_len(const wuffs_gif__decoder* self) {
   if (!self) {
-    return ((wuffs_base__range_ii_u64){});
+    return ((wuffs_base__range_ii_u64){0});
   }
   if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
-    return ((wuffs_base__range_ii_u64){});
+    return ((wuffs_base__range_ii_u64){0});
   }
 
   return wuffs_base__utility__make_range_ii_u64(
@@ -8858,8 +8868,7 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    (memset(&self->private_impl.f_dirty_y, 0,
-            sizeof((wuffs_base__range_ie_u32){})),
+    (memset(&self->private_impl.f_dirty_y, 0, sizeof(wuffs_base__range_ie_u32)),
      wuffs_base__return_empty_struct());
     if (!self->private_impl.f_end_of_data) {
       if (self->private_impl.f_call_sequence == 0) {
@@ -9110,7 +9119,7 @@
   self->private_impl.f_gc_transparent_index = 0;
   self->private_impl.f_gc_disposal = 0;
   self->private_impl.f_gc_duration = 0;
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 // -------- func gif.decoder.decode_up_to_id_part1
@@ -9237,7 +9246,7 @@
                                   wuffs_base__io_reader a_src) {
   wuffs_base__status status = NULL;
 
-  uint8_t v_c[6] = {};
+  uint8_t v_c[6] = {0};
   uint32_t v_i = 0;
 
   uint8_t* iop_a_src = NULL;
@@ -10208,7 +10217,7 @@
   uint32_t v_num_palette_entries = 0;
   uint32_t v_i = 0;
   uint32_t v_argb = 0;
-  wuffs_base__slice_u8 v_dst_palette = {};
+  wuffs_base__slice_u8 v_dst_palette = {0};
   uint8_t v_lw = 0;
 
   uint8_t* iop_a_src = NULL;
@@ -10346,10 +10355,10 @@
             .len = 1024,
         }));
     if (self->private_impl.f_previous_lzw_decode_ended_abruptly) {
-      (memset(&self->private_data.f_lzw, 0, sizeof((wuffs_lzw__decoder){})),
+      (memset(&self->private_data.f_lzw, 0, sizeof(wuffs_lzw__decoder)),
        wuffs_base__ignore_status(wuffs_lzw__decoder__initialize(
-           &self->private_data.f_lzw, sizeof((wuffs_lzw__decoder){}),
-           WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED)),
+           &self->private_data.f_lzw, sizeof(wuffs_lzw__decoder), WUFFS_VERSION,
+           WUFFS_INITIALIZE__ALREADY_ZEROED)),
        wuffs_base__return_empty_struct());
     }
     {
@@ -10404,14 +10413,17 @@
   uint64_t v_block_size = 0;
   bool v_need_block_size = false;
   uint64_t v_n_compressed = 0;
-  wuffs_base__slice_u8 v_compressed = {};
-  wuffs_base__io_reader v_r = {};
-  wuffs_base__io_buffer u_r WUFFS_BASE__POTENTIALLY_UNUSED = {};
+  wuffs_base__slice_u8 v_compressed = {0};
+  wuffs_base__io_reader v_r = {.private_impl = {0}};
+  wuffs_base__io_buffer u_r WUFFS_BASE__POTENTIALLY_UNUSED = {
+      .data = ((wuffs_base__slice_u8){0}),
+      .meta = ((wuffs_base__io_buffer_meta){0}),
+  };
   uint8_t* iop_v_r WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
   uint8_t* io1_v_r WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
   wuffs_base__status v_lzw_status = NULL;
   wuffs_base__status v_copy_status = NULL;
-  wuffs_base__slice_u8 v_uncompressed = {};
+  wuffs_base__slice_u8 v_uncompressed = {0};
 
   uint8_t* iop_a_src = NULL;
   uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
@@ -10628,13 +10640,13 @@
 wuffs_gif__decoder__copy_to_image_buffer(wuffs_gif__decoder* self,
                                          wuffs_base__pixel_buffer* a_pb,
                                          wuffs_base__slice_u8 a_src) {
-  wuffs_base__slice_u8 v_dst = {};
-  wuffs_base__slice_u8 v_src = {};
+  wuffs_base__slice_u8 v_dst = {0};
+  wuffs_base__slice_u8 v_src = {0};
   uint64_t v_n = 0;
   uint64_t v_src_ri = 0;
   uint32_t v_bytes_per_pixel = 0;
   uint32_t v_pixfmt = 0;
-  wuffs_base__table_u8 v_tab = {};
+  wuffs_base__table_u8 v_tab = {0};
   uint64_t v_i = 0;
   uint64_t v_j = 0;
 
@@ -10801,7 +10813,7 @@
 
 size_t  //
 sizeof__wuffs_gzip__decoder() {
-  return sizeof((wuffs_gzip__decoder){});
+  return sizeof(wuffs_gzip__decoder);
 }
 
 // ---------------- Function Implementations
@@ -10811,14 +10823,14 @@
 WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct  //
 wuffs_gzip__decoder__set_ignore_checksum(wuffs_gzip__decoder* self, bool a_ic) {
   if (!self) {
-    return ((wuffs_base__empty_struct){});
+    return ((wuffs_base__empty_struct){0});
   }
   if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
-    return ((wuffs_base__empty_struct){});
+    return ((wuffs_base__empty_struct){0});
   }
 
   self->private_impl.f_ignore_checksum = a_ic;
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 // -------- func gzip.decoder.workbuf_len
@@ -10826,10 +10838,10 @@
 WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64  //
 wuffs_gzip__decoder__workbuf_len(const wuffs_gzip__decoder* self) {
   if (!self) {
-    return ((wuffs_base__range_ii_u64){});
+    return ((wuffs_base__range_ii_u64){0});
   }
   if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
-    return ((wuffs_base__range_ii_u64){});
+    return ((wuffs_base__range_ii_u64){0});
   }
 
   return wuffs_base__utility__make_range_ii_u64(33280, 33280);
@@ -11274,7 +11286,7 @@
 
 size_t  //
 sizeof__wuffs_zlib__decoder() {
-  return sizeof((wuffs_zlib__decoder){});
+  return sizeof(wuffs_zlib__decoder);
 }
 
 // ---------------- Function Implementations
@@ -11284,14 +11296,14 @@
 WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct  //
 wuffs_zlib__decoder__set_ignore_checksum(wuffs_zlib__decoder* self, bool a_ic) {
   if (!self) {
-    return ((wuffs_base__empty_struct){});
+    return ((wuffs_base__empty_struct){0});
   }
   if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
-    return ((wuffs_base__empty_struct){});
+    return ((wuffs_base__empty_struct){0});
   }
 
   self->private_impl.f_ignore_checksum = a_ic;
-  return ((wuffs_base__empty_struct){});
+  return ((wuffs_base__empty_struct){0});
 }
 
 // -------- func zlib.decoder.workbuf_len
@@ -11299,10 +11311,10 @@
 WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64  //
 wuffs_zlib__decoder__workbuf_len(const wuffs_zlib__decoder* self) {
   if (!self) {
-    return ((wuffs_base__range_ii_u64){});
+    return ((wuffs_base__range_ii_u64){0});
   }
   if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
-    return ((wuffs_base__range_ii_u64){});
+    return ((wuffs_base__range_ii_u64){0});
   }
 
   return wuffs_base__utility__make_range_ii_u64(33280, 33280);