diff --git a/release/c/wuffs-v0.2.c b/release/c/wuffs-v0.2.c
index c453260..dd7ba15 100644
--- a/release/c/wuffs-v0.2.c
+++ b/release/c/wuffs-v0.2.c
@@ -54,15 +54,15 @@
 // each major.minor branch, the commit count should increase monotonically.
 //
 // WUFFS_VERSION was overridden by "wuffs gen -version" based on revision
-// 4f76d2f893ea86ffc49b756e1f0cc17b810a1ff2 committed on 2019-02-09.
+// c5538078e4aa401af580bd3e5caf6072c56a779c committed on 2019-02-16.
 #define WUFFS_VERSION ((uint64_t)0x0000000000020000)
 #define WUFFS_VERSION_MAJOR ((uint64_t)0x00000000)
 #define WUFFS_VERSION_MINOR ((uint64_t)0x0002)
 #define WUFFS_VERSION_PATCH ((uint64_t)0x0000)
-#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.31"
-#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 1605
-#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20190209
-#define WUFFS_VERSION_STRING "0.2.0-alpha.31+1605.20190209"
+#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.32"
+#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 1625
+#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20190216
+#define WUFFS_VERSION_STRING "0.2.0-alpha.32+1625.20190216"
 
 // Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have
 // static storage. The motivation is discussed in the "ALLOW STATIC
@@ -89,6 +89,32 @@
 // has already been set to all zeroes.
 #define WUFFS_INITIALIZE__ALREADY_ZEROED ((uint32_t)0x00000001)
 
+// WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED means that, absent
+// WUFFS_INITIALIZE__ALREADY_ZEROED, only some of the "self" receiver struct
+// value will be set to all zeroes. Internal buffers, which tend to be a large
+// proportion of the struct's size, will be left uninitialized. Internal means
+// that the buffer is contained by the receiver struct, as opposed to being
+// passed as a separately allocated "work buffer".
+//
+// With or without this bit set, the Wuffs compiler still enforces that no
+// reads or writes will overflow internal buffers' bounds. Even with this bit
+// set, the Wuffs standard library also considers reading from an uninitialized
+// buffer to be a bug, and strives to never do so, but unlike buffer overflows,
+// it is not a bug class that the Wuffs compiler eliminates.
+//
+// For those paranoid about security, leave this bit unset, so that
+// wuffs_foo__bar__initialize will initialize the entire struct value to zeroes
+// (unless WUFFS_INITIALIZE__ALREADY_ZEROED is set).
+//
+// Setting this bit gives a small absolute improvement on micro-benchmarks, but
+// this can be a large relative effect, up to 2x faster, when the actual work
+// to be done is also small, such as decompressing small input. See git commit
+// 438fc105 "Move some struct fields to private_data" for some numbers and a
+// discussion, noting that its commit message was written before this
+// WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED option was defined.
+#define WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED \
+  ((uint32_t)0x00000002)
+
 // --------
 
 // wuffs_base__empty_struct is used when a Wuffs function returns an empty
@@ -349,7 +375,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].
@@ -363,7 +389,7 @@
         .len = j,
     });
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 // wuffs_base__slice_u8__subslice_ij returns s[i:j].
@@ -379,7 +405,7 @@
         .len = j - i,
     });
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 // ---------------- Bureaucracy re -Wunused-function
@@ -1267,14 +1293,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;
 }
@@ -1359,7 +1385,7 @@
       });
     }
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 static inline wuffs_base__slice_u16  //
@@ -1373,7 +1399,7 @@
       });
     }
   }
-  return ((wuffs_base__slice_u16){});
+  return ((wuffs_base__slice_u16){0});
 }
 
 static inline wuffs_base__slice_u32  //
@@ -1387,7 +1413,7 @@
       });
     }
   }
-  return ((wuffs_base__slice_u32){});
+  return ((wuffs_base__slice_u32){0});
 }
 
 static inline wuffs_base__slice_u64  //
@@ -1401,7 +1427,7 @@
       });
     }
   }
-  return ((wuffs_base__slice_u64){});
+  return ((wuffs_base__slice_u64){0});
 }
 
 // ---------------- Bureaucracy re -Wunused-function
@@ -1735,12 +1761,6 @@
   } private_impl;
 
 #ifdef __cplusplus
-  // TODO: deprecated. This is for transitioning pre-v0.2 code.
-  inline void initialize(wuffs_base__pixel_format pixfmt,
-                         wuffs_base__pixel_subsampling pixsub,
-                         uint32_t width,
-                         uint32_t height);
-
   inline void set(wuffs_base__pixel_format pixfmt,
                   wuffs_base__pixel_subsampling pixsub,
                   uint32_t width,
@@ -1778,13 +1798,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},
+    });
   }
 }
 
@@ -1811,7 +1835,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  //
@@ -1863,15 +1887,6 @@
 
 #ifdef __cplusplus
 
-// TODO: deprecated. This is for transitioning pre-v0.2 code.
-inline void  //
-wuffs_base__pixel_config::initialize(wuffs_base__pixel_format pixfmt,
-                                     wuffs_base__pixel_subsampling pixsub,
-                                     uint32_t width,
-                                     uint32_t height) {
-  wuffs_base__pixel_config__set(this, pixfmt, pixsub, width, height);
-}
-
 inline void  //
 wuffs_base__pixel_config::set(wuffs_base__pixel_format pixfmt,
                               wuffs_base__pixel_subsampling pixsub,
@@ -1970,13 +1985,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},
+    });
   }
 }
 
@@ -2123,7 +2144,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  //
@@ -2255,7 +2276,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;
   }
@@ -2327,7 +2348,7 @@
       });
     }
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 static inline wuffs_base__pixel_format  //
@@ -2342,7 +2363,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
@@ -2555,12 +2576,13 @@
 struct wuffs_adler32__hasher__struct {
 #ifdef WUFFS_IMPLEMENTATION
 
-  // Do not access the private_impl's fields directly. There is no API/ABI
-  // compatibility or safety guarantee if you do so. Instead, use the
-  // wuffs_foo__bar__baz functions.
+  // Do not access the private_impl's or private_data's fields directly. There
+  // is no API/ABI compatibility or safety guarantee if you do so. Instead, use
+  // the wuffs_foo__bar__baz functions.
   //
-  // It is a struct, not a struct*, so that the outermost wuffs_foo__bar
-  // struct can be stack allocated when WUFFS_IMPLEMENTATION is defined.
+  // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct
+  // can be stack allocated when WUFFS_IMPLEMENTATION is defined.
+
   struct {
     uint32_t magic;
     uint32_t active_coroutine;
@@ -2685,12 +2707,13 @@
 struct wuffs_crc32__ieee_hasher__struct {
 #ifdef WUFFS_IMPLEMENTATION
 
-  // Do not access the private_impl's fields directly. There is no API/ABI
-  // compatibility or safety guarantee if you do so. Instead, use the
-  // wuffs_foo__bar__baz functions.
+  // Do not access the private_impl's or private_data's fields directly. There
+  // is no API/ABI compatibility or safety guarantee if you do so. Instead, use
+  // the wuffs_foo__bar__baz functions.
   //
-  // It is a struct, not a struct*, so that the outermost wuffs_foo__bar
-  // struct can be stack allocated when WUFFS_IMPLEMENTATION is defined.
+  // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct
+  // can be stack allocated when WUFFS_IMPLEMENTATION is defined.
+
   struct {
     uint32_t magic;
     uint32_t active_coroutine;
@@ -2783,11 +2806,11 @@
 
 // ---------------- Public Consts
 
-#define WUFFS_DEFLATE__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 33280
+#define WUFFS_DEFLATE__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 1
 
 static const uint64_t                                       //
     wuffs_deflate__decoder_workbuf_len_max_incl_worst_case  //
-        WUFFS_BASE__POTENTIALLY_UNUSED = 33280;
+        WUFFS_BASE__POTENTIALLY_UNUSED = 1;
 
 // ---------------- Struct Declarations
 
@@ -2840,12 +2863,13 @@
 struct wuffs_deflate__decoder__struct {
 #ifdef WUFFS_IMPLEMENTATION
 
-  // Do not access the private_impl's fields directly. There is no API/ABI
-  // compatibility or safety guarantee if you do so. Instead, use the
-  // wuffs_foo__bar__baz functions.
+  // Do not access the private_impl's or private_data's fields directly. There
+  // is no API/ABI compatibility or safety guarantee if you do so. Instead, use
+  // the wuffs_foo__bar__baz functions.
   //
-  // It is a struct, not a struct*, so that the outermost wuffs_foo__bar
-  // struct can be stack allocated when WUFFS_IMPLEMENTATION is defined.
+  // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct
+  // can be stack allocated when WUFFS_IMPLEMENTATION is defined.
+
   struct {
     uint32_t magic;
     uint32_t active_coroutine;
@@ -2854,16 +2878,19 @@
     uint32_t f_n_bits;
     uint32_t f_history_index;
     bool f_end_of_block;
-    uint32_t f_huffs[2][1024];
-    uint32_t f_n_huffs_bits[2];
-    uint8_t f_history[32768];
-    uint8_t f_code_lengths[320];
 
     uint32_t p_decode_io_writer[1];
     uint32_t p_decode_blocks[1];
     uint32_t p_decode_uncompressed[1];
     uint32_t p_init_dynamic_huffman[1];
     uint32_t p_decode_huffman_slow[1];
+  } private_impl;
+
+  struct {
+    uint32_t f_huffs[2][1024];
+    uint32_t f_n_huffs_bits[2];
+    uint8_t f_history[32768];
+    uint8_t f_code_lengths[320];
 
     struct {
       uint32_t v_final;
@@ -2899,7 +2926,7 @@
       uint32_t v_hlen;
       uint32_t v_hdist;
     } s_decode_huffman_slow[1];
-  } private_impl;
+  } private_data;
 
 #else  // WUFFS_IMPLEMENTATION
 
@@ -3044,12 +3071,13 @@
 struct wuffs_lzw__decoder__struct {
 #ifdef WUFFS_IMPLEMENTATION
 
-  // Do not access the private_impl's fields directly. There is no API/ABI
-  // compatibility or safety guarantee if you do so. Instead, use the
-  // wuffs_foo__bar__baz functions.
+  // Do not access the private_impl's or private_data's fields directly. There
+  // is no API/ABI compatibility or safety guarantee if you do so. Instead, use
+  // the wuffs_foo__bar__baz functions.
   //
-  // It is a struct, not a struct*, so that the outermost wuffs_foo__bar
-  // struct can be stack allocated when WUFFS_IMPLEMENTATION is defined.
+  // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct
+  // can be stack allocated when WUFFS_IMPLEMENTATION is defined.
+
   struct {
     uint32_t magic;
     uint32_t active_coroutine;
@@ -3066,15 +3094,18 @@
     uint32_t f_output_ri;
     uint32_t f_output_wi;
     uint32_t f_read_from_return_value;
+
+    uint32_t p_decode_io_writer[1];
+    uint32_t p_write_to[1];
+  } private_impl;
+
+  struct {
     uint8_t f_suffixes[4096][8];
     uint16_t f_prefixes[4096];
     uint16_t f_lm1s[4096];
     uint8_t f_output[8199];
 
-    uint32_t p_decode_io_writer[1];
-    uint32_t p_write_to[1];
-
-  } private_impl;
+  } private_data;
 
 #else  // WUFFS_IMPLEMENTATION
 
@@ -3169,11 +3200,11 @@
 
 // ---------------- Public Consts
 
-#define WUFFS_GIF__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 65535
+#define WUFFS_GIF__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 1
 
 static const uint64_t                                   //
     wuffs_gif__decoder_workbuf_len_max_incl_worst_case  //
-        WUFFS_BASE__POTENTIALLY_UNUSED = 65535;
+        WUFFS_BASE__POTENTIALLY_UNUSED = 1;
 
 // ---------------- Struct Declarations
 
@@ -3254,12 +3285,13 @@
 struct wuffs_gif__decoder__struct {
 #ifdef WUFFS_IMPLEMENTATION
 
-  // Do not access the private_impl's fields directly. There is no API/ABI
-  // compatibility or safety guarantee if you do so. Instead, use the
-  // wuffs_foo__bar__baz functions.
+  // Do not access the private_impl's or private_data's fields directly. There
+  // is no API/ABI compatibility or safety guarantee if you do so. Instead, use
+  // the wuffs_foo__bar__baz functions.
   //
-  // It is a struct, not a struct*, so that the outermost wuffs_foo__bar
-  // struct can be stack allocated when WUFFS_IMPLEMENTATION is defined.
+  // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct
+  // can be stack allocated when WUFFS_IMPLEMENTATION is defined.
+
   struct {
     uint32_t magic;
     uint32_t active_coroutine;
@@ -3292,10 +3324,6 @@
     uint64_t f_compressed_ri;
     uint64_t f_compressed_wi;
     wuffs_base__pixel_swizzler f_swizzler;
-    wuffs_lzw__decoder f_lzw;
-    uint8_t f_compressed[4096];
-    uint8_t f_palettes[2][1024];
-    uint8_t f_dst_palette[1024];
 
     uint32_t p_decode_image_config[1];
     uint32_t p_decode_frame_config[1];
@@ -3311,6 +3339,13 @@
     uint32_t p_decode_id_part0[1];
     uint32_t p_decode_id_part1[1];
     uint32_t p_decode_id_part2[1];
+  } private_impl;
+
+  struct {
+    uint8_t f_compressed[4096];
+    uint8_t f_palettes[2][1024];
+    uint8_t f_dst_palette[1024];
+    wuffs_lzw__decoder f_lzw;
 
     struct {
       uint64_t scratch;
@@ -3351,7 +3386,7 @@
       wuffs_base__status v_lzw_status;
       uint64_t scratch;
     } s_decode_id_part2[1];
-  } private_impl;
+  } private_data;
 
 #else  // WUFFS_IMPLEMENTATION
 
@@ -3472,11 +3507,11 @@
 
 // ---------------- Public Consts
 
-#define WUFFS_GZIP__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 33280
+#define WUFFS_GZIP__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 1
 
 static const uint64_t                                    //
     wuffs_gzip__decoder_workbuf_len_max_incl_worst_case  //
-        WUFFS_BASE__POTENTIALLY_UNUSED = 33280;
+        WUFFS_BASE__POTENTIALLY_UNUSED = 1;
 
 // ---------------- Struct Declarations
 
@@ -3532,21 +3567,25 @@
 struct wuffs_gzip__decoder__struct {
 #ifdef WUFFS_IMPLEMENTATION
 
-  // Do not access the private_impl's fields directly. There is no API/ABI
-  // compatibility or safety guarantee if you do so. Instead, use the
-  // wuffs_foo__bar__baz functions.
+  // Do not access the private_impl's or private_data's fields directly. There
+  // is no API/ABI compatibility or safety guarantee if you do so. Instead, use
+  // the wuffs_foo__bar__baz functions.
   //
-  // It is a struct, not a struct*, so that the outermost wuffs_foo__bar
-  // struct can be stack allocated when WUFFS_IMPLEMENTATION is defined.
+  // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct
+  // can be stack allocated when WUFFS_IMPLEMENTATION is defined.
+
   struct {
     uint32_t magic;
     uint32_t active_coroutine;
 
     bool f_ignore_checksum;
-    wuffs_crc32__ieee_hasher f_checksum;
-    wuffs_deflate__decoder f_flate;
 
     uint32_t p_decode_io_writer[1];
+  } private_impl;
+
+  struct {
+    wuffs_crc32__ieee_hasher f_checksum;
+    wuffs_deflate__decoder f_flate;
 
     struct {
       uint8_t v_flags;
@@ -3555,7 +3594,7 @@
       uint32_t v_checksum_want;
       uint64_t scratch;
     } s_decode_io_writer[1];
-  } private_impl;
+  } private_data;
 
 #else  // WUFFS_IMPLEMENTATION
 
@@ -3643,11 +3682,11 @@
 
 // ---------------- Public Consts
 
-#define WUFFS_ZLIB__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 33280
+#define WUFFS_ZLIB__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 1
 
 static const uint64_t                                    //
     wuffs_zlib__decoder_workbuf_len_max_incl_worst_case  //
-        WUFFS_BASE__POTENTIALLY_UNUSED = 33280;
+        WUFFS_BASE__POTENTIALLY_UNUSED = 1;
 
 // ---------------- Struct Declarations
 
@@ -3703,27 +3742,31 @@
 struct wuffs_zlib__decoder__struct {
 #ifdef WUFFS_IMPLEMENTATION
 
-  // Do not access the private_impl's fields directly. There is no API/ABI
-  // compatibility or safety guarantee if you do so. Instead, use the
-  // wuffs_foo__bar__baz functions.
+  // Do not access the private_impl's or private_data's fields directly. There
+  // is no API/ABI compatibility or safety guarantee if you do so. Instead, use
+  // the wuffs_foo__bar__baz functions.
   //
-  // It is a struct, not a struct*, so that the outermost wuffs_foo__bar
-  // struct can be stack allocated when WUFFS_IMPLEMENTATION is defined.
+  // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct
+  // can be stack allocated when WUFFS_IMPLEMENTATION is defined.
+
   struct {
     uint32_t magic;
     uint32_t active_coroutine;
 
     bool f_ignore_checksum;
-    wuffs_adler32__hasher f_checksum;
-    wuffs_deflate__decoder f_flate;
 
     uint32_t p_decode_io_writer[1];
+  } private_impl;
+
+  struct {
+    wuffs_adler32__hasher f_checksum;
+    wuffs_deflate__decoder f_flate;
 
     struct {
       uint32_t v_checksum_got;
       uint64_t scratch;
     } s_decode_io_writer[1];
-  } private_impl;
+  } private_data;
 
 #else  // WUFFS_IMPLEMENTATION
 
@@ -3805,8 +3848,10 @@
 extern "C" {
 #endif
 
-static inline void  //
-wuffs_base__ignore_status(wuffs_base__status z) {}
+static inline wuffs_base__empty_struct  //
+wuffs_base__ignore_status(wuffs_base__status z) {
+  return ((wuffs_base__empty_struct){0});
+}
 
 // WUFFS_BASE__MAGIC is a magic number to check that initializers are called.
 // It's not foolproof, given C doesn't automatically zero memory before use,
@@ -3874,7 +3919,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
@@ -4211,14 +4256,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
@@ -4593,7 +4638,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  //
@@ -4603,13 +4648,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  //
@@ -4622,7 +4667,7 @@
         .len = n,
     });
   }
-  return ((wuffs_base__slice_u8){});
+  return ((wuffs_base__slice_u8){0});
 }
 
 static inline wuffs_base__empty_struct  //
@@ -4642,25 +4687,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
@@ -4949,11 +4994,19 @@
       (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
     return wuffs_base__error__bad_wuffs_version;
   }
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) == 0) {
-    memset(self, 0, sizeof_star_self);
-  } else if (self->private_impl.magic != 0) {
-    return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
+
+  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+    if (self->private_impl.magic != 0) {
+      return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
+    }
+  } else if ((initialize_flags &
+              WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) != 0) {
+    memset(&(self->private_impl), 0, sizeof(self->private_impl));
+  } else {
+    memset(self, 0, sizeof(*self));
+    initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
   }
+
   self->private_impl.magic = WUFFS_BASE__MAGIC;
   return NULL;
 }
@@ -4968,7 +5021,7 @@
 
 size_t  //
 sizeof__wuffs_adler32__hasher() {
-  return sizeof((wuffs_adler32__hasher){});
+  return sizeof(wuffs_adler32__hasher);
 }
 
 // ---------------- Function Implementations
@@ -4987,8 +5040,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;
@@ -5948,11 +6001,19 @@
       (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
     return wuffs_base__error__bad_wuffs_version;
   }
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) == 0) {
-    memset(self, 0, sizeof_star_self);
-  } else if (self->private_impl.magic != 0) {
-    return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
+
+  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+    if (self->private_impl.magic != 0) {
+      return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
+    }
+  } else if ((initialize_flags &
+              WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) != 0) {
+    memset(&(self->private_impl), 0, sizeof(self->private_impl));
+  } else {
+    memset(self, 0, sizeof(*self));
+    initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
   }
+
   self->private_impl.magic = WUFFS_BASE__MAGIC;
   return NULL;
 }
@@ -5967,7 +6028,7 @@
 
 size_t  //
 sizeof__wuffs_crc32__ieee_hasher() {
-  return sizeof((wuffs_crc32__ieee_hasher){});
+  return sizeof(wuffs_crc32__ieee_hasher);
 }
 
 // ---------------- Function Implementations
@@ -5985,7 +6046,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);
   {
@@ -6226,11 +6287,19 @@
       (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
     return wuffs_base__error__bad_wuffs_version;
   }
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) == 0) {
-    memset(self, 0, sizeof_star_self);
-  } else if (self->private_impl.magic != 0) {
-    return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
+
+  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+    if (self->private_impl.magic != 0) {
+      return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
+    }
+  } else if ((initialize_flags &
+              WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) != 0) {
+    memset(&(self->private_impl), 0, sizeof(self->private_impl));
+  } else {
+    memset(self, 0, sizeof(*self));
+    initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
   }
+
   self->private_impl.magic = WUFFS_BASE__MAGIC;
   return NULL;
 }
@@ -6245,7 +6314,7 @@
 
 size_t  //
 sizeof__wuffs_deflate__decoder() {
-  return sizeof((wuffs_deflate__decoder){});
+  return sizeof(wuffs_deflate__decoder);
 }
 
 // ---------------- Function Implementations
@@ -6255,13 +6324,13 @@
 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);
+  return wuffs_base__utility__make_range_ii_u64(1, 1);
 }
 
 // -------- func deflate.decoder.decode_io_writer
@@ -6288,7 +6357,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;
 
@@ -6349,7 +6418,7 @@
         v_written = wuffs_base__slice_u8__suffix(v_written, 32768);
         wuffs_base__slice_u8__copy_from_slice(
             ((wuffs_base__slice_u8){
-                .ptr = self->private_impl.f_history,
+                .ptr = self->private_data.f_history,
                 .len = 32768,
             }),
             v_written);
@@ -6358,7 +6427,7 @@
         v_n_copied = wuffs_base__slice_u8__copy_from_slice(
             wuffs_base__slice_u8__subslice_i(
                 ((wuffs_base__slice_u8){
-                    .ptr = self->private_impl.f_history,
+                    .ptr = self->private_data.f_history,
                     .len = 32768,
                 }),
                 (self->private_impl.f_history_index & 32767)),
@@ -6367,7 +6436,7 @@
           v_written = wuffs_base__slice_u8__subslice_i(v_written, v_n_copied);
           v_n_copied = wuffs_base__slice_u8__copy_from_slice(
               ((wuffs_base__slice_u8){
-                  .ptr = self->private_impl.f_history,
+                  .ptr = self->private_data.f_history,
                   .len = 32768,
               }),
               v_written);
@@ -6441,7 +6510,7 @@
 
   uint32_t coro_susp_point = self->private_impl.p_decode_blocks[0];
   if (coro_susp_point) {
-    v_final = self->private_impl.s_decode_blocks[0].v_final;
+    v_final = self->private_data.s_decode_blocks[0].v_final;
   }
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
@@ -6559,7 +6628,7 @@
   goto suspend;
 suspend:
   self->private_impl.p_decode_blocks[0] = coro_susp_point;
-  self->private_impl.s_decode_blocks[0].v_final = v_final;
+  self->private_data.s_decode_blocks[0].v_final = v_final;
 
   goto exit;
 exit:
@@ -6616,7 +6685,7 @@
 
   uint32_t coro_susp_point = self->private_impl.p_decode_uncompressed[0];
   if (coro_susp_point) {
-    v_length = self->private_impl.s_decode_uncompressed[0].v_length;
+    v_length = self->private_data.s_decode_uncompressed[0].v_length;
   }
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
@@ -6636,7 +6705,7 @@
         t_0 = wuffs_base__load_u32le(iop_a_src);
         iop_a_src += 4;
       } else {
-        self->private_impl.s_decode_uncompressed[0].scratch = 0;
+        self->private_data.s_decode_uncompressed[0].scratch = 0;
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
         while (true) {
           if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
@@ -6644,7 +6713,7 @@
             goto suspend;
           }
           uint64_t* scratch =
-              &self->private_impl.s_decode_uncompressed[0].scratch;
+              &self->private_data.s_decode_uncompressed[0].scratch;
           uint32_t num_bits_0 = *scratch >> 56;
           *scratch <<= 8;
           *scratch >>= 8;
@@ -6690,7 +6759,7 @@
   goto suspend;
 suspend:
   self->private_impl.p_decode_uncompressed[0] = coro_susp_point;
-  self->private_impl.s_decode_uncompressed[0].v_length = v_length;
+  self->private_data.s_decode_uncompressed[0].v_length = v_length;
 
   goto exit;
 exit:
@@ -6714,23 +6783,23 @@
   wuffs_base__status v_status = NULL;
 
   while (v_i < 144) {
-    self->private_impl.f_code_lengths[v_i] = 8;
+    self->private_data.f_code_lengths[v_i] = 8;
     v_i += 1;
   }
   while (v_i < 256) {
-    self->private_impl.f_code_lengths[v_i] = 9;
+    self->private_data.f_code_lengths[v_i] = 9;
     v_i += 1;
   }
   while (v_i < 280) {
-    self->private_impl.f_code_lengths[v_i] = 7;
+    self->private_data.f_code_lengths[v_i] = 7;
     v_i += 1;
   }
   while (v_i < 288) {
-    self->private_impl.f_code_lengths[v_i] = 8;
+    self->private_data.f_code_lengths[v_i] = 8;
     v_i += 1;
   }
   while (v_i < 320) {
-    self->private_impl.f_code_lengths[v_i] = 5;
+    self->private_data.f_code_lengths[v_i] = 5;
     v_i += 1;
   }
   v_status = wuffs_deflate__decoder__init_huff(self, 0, 0, 288, 257);
@@ -6786,18 +6855,18 @@
 
   uint32_t coro_susp_point = self->private_impl.p_init_dynamic_huffman[0];
   if (coro_susp_point) {
-    v_bits = self->private_impl.s_init_dynamic_huffman[0].v_bits;
-    v_n_bits = self->private_impl.s_init_dynamic_huffman[0].v_n_bits;
-    v_n_lit = self->private_impl.s_init_dynamic_huffman[0].v_n_lit;
-    v_n_dist = self->private_impl.s_init_dynamic_huffman[0].v_n_dist;
-    v_n_clen = self->private_impl.s_init_dynamic_huffman[0].v_n_clen;
-    v_i = self->private_impl.s_init_dynamic_huffman[0].v_i;
-    v_mask = self->private_impl.s_init_dynamic_huffman[0].v_mask;
-    v_table_entry = self->private_impl.s_init_dynamic_huffman[0].v_table_entry;
+    v_bits = self->private_data.s_init_dynamic_huffman[0].v_bits;
+    v_n_bits = self->private_data.s_init_dynamic_huffman[0].v_n_bits;
+    v_n_lit = self->private_data.s_init_dynamic_huffman[0].v_n_lit;
+    v_n_dist = self->private_data.s_init_dynamic_huffman[0].v_n_dist;
+    v_n_clen = self->private_data.s_init_dynamic_huffman[0].v_n_clen;
+    v_i = self->private_data.s_init_dynamic_huffman[0].v_i;
+    v_mask = self->private_data.s_init_dynamic_huffman[0].v_mask;
+    v_table_entry = self->private_data.s_init_dynamic_huffman[0].v_table_entry;
     v_n_extra_bits =
-        self->private_impl.s_init_dynamic_huffman[0].v_n_extra_bits;
-    v_rep_symbol = self->private_impl.s_init_dynamic_huffman[0].v_rep_symbol;
-    v_rep_count = self->private_impl.s_init_dynamic_huffman[0].v_rep_count;
+        self->private_data.s_init_dynamic_huffman[0].v_n_extra_bits;
+    v_rep_symbol = self->private_data.s_init_dynamic_huffman[0].v_rep_symbol;
+    v_rep_count = self->private_data.s_init_dynamic_huffman[0].v_rep_count;
   }
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
@@ -6847,14 +6916,14 @@
         v_bits |= (v_b1 << v_n_bits);
         v_n_bits += 8;
       }
-      self->private_impl.f_code_lengths[wuffs_deflate__code_order[v_i]] =
+      self->private_data.f_code_lengths[wuffs_deflate__code_order[v_i]] =
           ((uint8_t)((v_bits & 7)));
       v_bits >>= 3;
       v_n_bits -= 3;
       v_i += 1;
     }
     while (v_i < 19) {
-      self->private_impl.f_code_lengths[wuffs_deflate__code_order[v_i]] = 0;
+      self->private_data.f_code_lengths[wuffs_deflate__code_order[v_i]] = 0;
       v_i += 1;
     }
     v_status = wuffs_deflate__decoder__init_huff(self, 0, 0, 19, 4095);
@@ -6862,12 +6931,12 @@
       status = v_status;
       goto exit;
     }
-    v_mask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
+    v_mask = ((((uint32_t)(1)) << self->private_data.f_n_huffs_bits[0]) - 1);
     v_i = 0;
   label_0_continue:;
     while (v_i < (v_n_lit + v_n_dist)) {
       while (true) {
-        v_table_entry = self->private_impl.f_huffs[0][(v_bits & v_mask)];
+        v_table_entry = self->private_data.f_huffs[0][(v_bits & v_mask)];
         v_table_entry_n_bits = (v_table_entry & 15);
         if (v_n_bits >= v_table_entry_n_bits) {
           v_bits >>= v_table_entry_n_bits;
@@ -6894,7 +6963,7 @@
       }
       v_table_entry = ((v_table_entry >> 8) & 255);
       if (v_table_entry < 16) {
-        self->private_impl.f_code_lengths[v_i] = ((uint8_t)(v_table_entry));
+        self->private_data.f_code_lengths[v_i] = ((uint8_t)(v_table_entry));
         v_i += 1;
         goto label_0_continue;
       }
@@ -6907,7 +6976,7 @@
           status = wuffs_deflate__error__bad_huffman_code_length_repetition;
           goto exit;
         }
-        v_rep_symbol = self->private_impl.f_code_lengths[(v_i - 1)];
+        v_rep_symbol = self->private_data.f_code_lengths[(v_i - 1)];
         v_rep_count = 3;
       } else if (v_table_entry == 17) {
         v_n_extra_bits = 3;
@@ -6943,7 +7012,7 @@
           status = wuffs_deflate__error__bad_huffman_code_length_count;
           goto exit;
         }
-        self->private_impl.f_code_lengths[v_i] = v_rep_symbol;
+        self->private_data.f_code_lengths[v_i] = v_rep_symbol;
         v_i += 1;
         v_rep_count -= 1;
       }
@@ -6952,7 +7021,7 @@
       status = wuffs_deflate__error__bad_huffman_code_length_count;
       goto exit;
     }
-    if (self->private_impl.f_code_lengths[256] == 0) {
+    if (self->private_data.f_code_lengths[256] == 0) {
       status = wuffs_deflate__error__missing_end_of_block_code;
       goto exit;
     }
@@ -6979,17 +7048,17 @@
   goto suspend;
 suspend:
   self->private_impl.p_init_dynamic_huffman[0] = coro_susp_point;
-  self->private_impl.s_init_dynamic_huffman[0].v_bits = v_bits;
-  self->private_impl.s_init_dynamic_huffman[0].v_n_bits = v_n_bits;
-  self->private_impl.s_init_dynamic_huffman[0].v_n_lit = v_n_lit;
-  self->private_impl.s_init_dynamic_huffman[0].v_n_dist = v_n_dist;
-  self->private_impl.s_init_dynamic_huffman[0].v_n_clen = v_n_clen;
-  self->private_impl.s_init_dynamic_huffman[0].v_i = v_i;
-  self->private_impl.s_init_dynamic_huffman[0].v_mask = v_mask;
-  self->private_impl.s_init_dynamic_huffman[0].v_table_entry = v_table_entry;
-  self->private_impl.s_init_dynamic_huffman[0].v_n_extra_bits = v_n_extra_bits;
-  self->private_impl.s_init_dynamic_huffman[0].v_rep_symbol = v_rep_symbol;
-  self->private_impl.s_init_dynamic_huffman[0].v_rep_count = v_rep_count;
+  self->private_data.s_init_dynamic_huffman[0].v_bits = v_bits;
+  self->private_data.s_init_dynamic_huffman[0].v_n_bits = v_n_bits;
+  self->private_data.s_init_dynamic_huffman[0].v_n_lit = v_n_lit;
+  self->private_data.s_init_dynamic_huffman[0].v_n_dist = v_n_dist;
+  self->private_data.s_init_dynamic_huffman[0].v_n_clen = v_n_clen;
+  self->private_data.s_init_dynamic_huffman[0].v_i = v_i;
+  self->private_data.s_init_dynamic_huffman[0].v_mask = v_mask;
+  self->private_data.s_init_dynamic_huffman[0].v_table_entry = v_table_entry;
+  self->private_data.s_init_dynamic_huffman[0].v_n_extra_bits = v_n_extra_bits;
+  self->private_data.s_init_dynamic_huffman[0].v_rep_symbol = v_rep_symbol;
+  self->private_data.s_init_dynamic_huffman[0].v_rep_count = v_rep_count;
 
   goto exit;
 exit:
@@ -7009,13 +7078,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;
@@ -7036,10 +7105,10 @@
 
   v_i = a_n_codes0;
   while (v_i < a_n_codes1) {
-    if (v_counts[self->private_impl.f_code_lengths[v_i]] >= 320) {
+    if (v_counts[self->private_data.f_code_lengths[v_i]] >= 320) {
       return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
     }
-    v_counts[self->private_impl.f_code_lengths[v_i]] += 1;
+    v_counts[self->private_data.f_code_lengths[v_i]] += 1;
     v_i += 1;
   }
   if ((((uint32_t)(v_counts[0])) + a_n_codes0) == a_n_codes1) {
@@ -7079,13 +7148,13 @@
     if (v_i < a_n_codes0) {
       return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
     }
-    if (self->private_impl.f_code_lengths[v_i] != 0) {
-      if (v_offsets[self->private_impl.f_code_lengths[v_i]] >= 320) {
+    if (self->private_data.f_code_lengths[v_i] != 0) {
+      if (v_offsets[self->private_data.f_code_lengths[v_i]] >= 320) {
         return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
       }
-      v_symbols[v_offsets[self->private_impl.f_code_lengths[v_i]]] =
+      v_symbols[v_offsets[self->private_data.f_code_lengths[v_i]]] =
           ((uint16_t)((v_i - a_n_codes0)));
-      v_offsets[self->private_impl.f_code_lengths[v_i]] += 1;
+      v_offsets[self->private_data.f_code_lengths[v_i]] += 1;
     }
     v_i += 1;
   }
@@ -7112,9 +7181,9 @@
   }
 label_1_break:;
   if (v_max_cl <= 9) {
-    self->private_impl.f_n_huffs_bits[a_which] = v_max_cl;
+    self->private_data.f_n_huffs_bits[a_which] = v_max_cl;
   } else {
-    self->private_impl.f_n_huffs_bits[a_which] = 9;
+    self->private_data.f_n_huffs_bits[a_which] = 9;
   }
   v_i = 0;
   if ((v_n_symbols != ((uint32_t)(v_offsets[v_max_cl]))) ||
@@ -7128,7 +7197,7 @@
   if (v_max_cl < 9) {
     v_initial_high_bits = (((uint32_t)(1)) << v_max_cl);
   }
-  v_prev_cl = ((uint32_t)(self->private_impl.f_code_lengths[(
+  v_prev_cl = ((uint32_t)(self->private_data.f_code_lengths[(
       a_n_codes0 + ((uint32_t)(v_symbols[0])))]));
   v_prev_redirect_key = 4294967295;
   v_top = 0;
@@ -7140,7 +7209,7 @@
     if ((a_n_codes0 + ((uint32_t)(v_symbols[v_i]))) >= 320) {
       return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
     }
-    v_cl = ((uint32_t)(self->private_impl.f_code_lengths[(
+    v_cl = ((uint32_t)(self->private_data.f_code_lengths[(
         a_n_codes0 + ((uint32_t)(v_symbols[v_i])))]));
     if (v_cl > v_prev_cl) {
       v_code <<= (v_cl - v_prev_cl);
@@ -7183,7 +7252,7 @@
         v_redirect_key =
             (((uint32_t)(wuffs_deflate__reverse8[(v_redirect_key >> 1)])) |
              ((v_redirect_key & 1) << 8));
-        self->private_impl.f_huffs[a_which][v_redirect_key] =
+        self->private_data.f_huffs[a_which][v_redirect_key] =
             (268435465 | (v_top << 8) | (v_j << 4));
       }
     }
@@ -7216,7 +7285,7 @@
       if ((v_top + ((v_high_bits | v_reversed_key) & 511)) >= 1024) {
         return wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
       }
-      self->private_impl
+      self->private_data
           .f_huffs[a_which][(v_top + ((v_high_bits | v_reversed_key) & 511))] =
           v_value;
     }
@@ -7294,8 +7363,8 @@
   }
   v_bits = self->private_impl.f_bits;
   v_n_bits = self->private_impl.f_n_bits;
-  v_lmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
-  v_dmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
+  v_lmask = ((((uint32_t)(1)) << self->private_data.f_n_huffs_bits[0]) - 1);
+  v_dmask = ((((uint32_t)(1)) << self->private_data.f_n_huffs_bits[1]) - 1);
 label_0_continue:;
   while ((((uint64_t)(io1_a_dst - iop_a_dst)) >= 258) &&
          (((uint64_t)(io1_a_src - iop_a_src)) >= 12)) {
@@ -7308,7 +7377,7 @@
       v_n_bits += 8;
     } else {
     }
-    v_table_entry = self->private_impl.f_huffs[0][(v_bits & v_lmask)];
+    v_table_entry = self->private_data.f_huffs[0][(v_bits & v_lmask)];
     v_table_entry_n_bits = (v_table_entry & 15);
     v_bits >>= v_table_entry_n_bits;
     v_n_bits -= v_table_entry_n_bits;
@@ -7338,7 +7407,7 @@
             wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
         goto exit;
       }
-      v_table_entry = self->private_impl
+      v_table_entry = self->private_data
                           .f_huffs[0][(v_redir_top + (v_bits & v_redir_mask))];
       v_table_entry_n_bits = (v_table_entry & 15);
       v_bits >>= v_table_entry_n_bits;
@@ -7402,7 +7471,7 @@
       v_n_bits += 8;
     } else {
     }
-    v_table_entry = self->private_impl.f_huffs[1][(v_bits & v_dmask)];
+    v_table_entry = self->private_data.f_huffs[1][(v_bits & v_dmask)];
     v_table_entry_n_bits = (v_table_entry & 15);
     v_bits >>= v_table_entry_n_bits;
     v_n_bits -= v_table_entry_n_bits;
@@ -7423,7 +7492,7 @@
             wuffs_deflate__error__internal_error_inconsistent_huffman_decoder_state;
         goto exit;
       }
-      v_table_entry = self->private_impl
+      v_table_entry = self->private_data
                           .f_huffs[1][(v_redir_top + (v_bits & v_redir_mask))];
       v_table_entry_n_bits = (v_table_entry & 15);
       v_bits >>= v_table_entry_n_bits;
@@ -7480,7 +7549,7 @@
               &iop_a_dst, io1_a_dst, v_hlen,
               wuffs_base__slice_u8__subslice_i(
                   ((wuffs_base__slice_u8){
-                      .ptr = self->private_impl.f_history,
+                      .ptr = self->private_data.f_history,
                       .len = 32768,
                   }),
                   (v_hdist & 32767)));
@@ -7491,7 +7560,7 @@
           wuffs_base__io_writer__copy_n_from_slice(
               &iop_a_dst, io1_a_dst, v_hlen,
               ((wuffs_base__slice_u8){
-                  .ptr = self->private_impl.f_history,
+                  .ptr = self->private_data.f_history,
                   .len = 32768,
               }));
           goto label_1_break;
@@ -7606,19 +7675,19 @@
 
   uint32_t coro_susp_point = self->private_impl.p_decode_huffman_slow[0];
   if (coro_susp_point) {
-    v_bits = self->private_impl.s_decode_huffman_slow[0].v_bits;
-    v_n_bits = self->private_impl.s_decode_huffman_slow[0].v_n_bits;
-    v_table_entry = self->private_impl.s_decode_huffman_slow[0].v_table_entry;
+    v_bits = self->private_data.s_decode_huffman_slow[0].v_bits;
+    v_n_bits = self->private_data.s_decode_huffman_slow[0].v_n_bits;
+    v_table_entry = self->private_data.s_decode_huffman_slow[0].v_table_entry;
     v_table_entry_n_bits =
-        self->private_impl.s_decode_huffman_slow[0].v_table_entry_n_bits;
-    v_lmask = self->private_impl.s_decode_huffman_slow[0].v_lmask;
-    v_dmask = self->private_impl.s_decode_huffman_slow[0].v_dmask;
-    v_redir_top = self->private_impl.s_decode_huffman_slow[0].v_redir_top;
-    v_redir_mask = self->private_impl.s_decode_huffman_slow[0].v_redir_mask;
-    v_length = self->private_impl.s_decode_huffman_slow[0].v_length;
-    v_dist_minus_1 = self->private_impl.s_decode_huffman_slow[0].v_dist_minus_1;
-    v_hlen = self->private_impl.s_decode_huffman_slow[0].v_hlen;
-    v_hdist = self->private_impl.s_decode_huffman_slow[0].v_hdist;
+        self->private_data.s_decode_huffman_slow[0].v_table_entry_n_bits;
+    v_lmask = self->private_data.s_decode_huffman_slow[0].v_lmask;
+    v_dmask = self->private_data.s_decode_huffman_slow[0].v_dmask;
+    v_redir_top = self->private_data.s_decode_huffman_slow[0].v_redir_top;
+    v_redir_mask = self->private_data.s_decode_huffman_slow[0].v_redir_mask;
+    v_length = self->private_data.s_decode_huffman_slow[0].v_length;
+    v_dist_minus_1 = self->private_data.s_decode_huffman_slow[0].v_dist_minus_1;
+    v_hlen = self->private_data.s_decode_huffman_slow[0].v_hlen;
+    v_hdist = self->private_data.s_decode_huffman_slow[0].v_hdist;
   }
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
@@ -7631,12 +7700,12 @@
     }
     v_bits = self->private_impl.f_bits;
     v_n_bits = self->private_impl.f_n_bits;
-    v_lmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[0]) - 1);
-    v_dmask = ((((uint32_t)(1)) << self->private_impl.f_n_huffs_bits[1]) - 1);
+    v_lmask = ((((uint32_t)(1)) << self->private_data.f_n_huffs_bits[0]) - 1);
+    v_dmask = ((((uint32_t)(1)) << self->private_data.f_n_huffs_bits[1]) - 1);
   label_0_continue:;
     while (!(self->private_impl.p_decode_huffman_slow[0] != 0)) {
       while (true) {
-        v_table_entry = self->private_impl.f_huffs[0][(v_bits & v_lmask)];
+        v_table_entry = self->private_data.f_huffs[0][(v_bits & v_lmask)];
         v_table_entry_n_bits = (v_table_entry & 15);
         if (v_n_bits >= v_table_entry_n_bits) {
           v_bits >>= v_table_entry_n_bits;
@@ -7678,7 +7747,7 @@
             goto exit;
           }
           v_table_entry =
-              self->private_impl
+              self->private_data
                   .f_huffs[0][(v_redir_top + (v_bits & v_redir_mask))];
           v_table_entry_n_bits = (v_table_entry & 15);
           if (v_n_bits >= v_table_entry_n_bits) {
@@ -7756,7 +7825,7 @@
         v_n_bits -= v_table_entry_n_bits;
       }
       while (true) {
-        v_table_entry = self->private_impl.f_huffs[1][(v_bits & v_dmask)];
+        v_table_entry = self->private_data.f_huffs[1][(v_bits & v_dmask)];
         v_table_entry_n_bits = (v_table_entry & 15);
         if (v_n_bits >= v_table_entry_n_bits) {
           v_bits >>= v_table_entry_n_bits;
@@ -7786,7 +7855,7 @@
             goto exit;
           }
           v_table_entry =
-              self->private_impl
+              self->private_data
                   .f_huffs[1][(v_redir_top + (v_bits & v_redir_mask))];
           v_table_entry_n_bits = (v_table_entry & 15);
           if (v_n_bits >= v_table_entry_n_bits) {
@@ -7863,7 +7932,7 @@
                 &iop_a_dst, io1_a_dst, v_hlen,
                 wuffs_base__slice_u8__subslice_i(
                     ((wuffs_base__slice_u8){
-                        .ptr = self->private_impl.f_history,
+                        .ptr = self->private_data.f_history,
                         .len = 32768,
                     }),
                     (v_hdist & 32767)));
@@ -7888,7 +7957,7 @@
                   &iop_a_dst, io1_a_dst, v_hlen,
                   wuffs_base__slice_u8__subslice_i(
                       ((wuffs_base__slice_u8){
-                          .ptr = self->private_impl.f_history,
+                          .ptr = self->private_data.f_history,
                           .len = 32768,
                       }),
                       (v_hdist & 32767)));
@@ -7939,19 +8008,19 @@
   goto suspend;
 suspend:
   self->private_impl.p_decode_huffman_slow[0] = coro_susp_point;
-  self->private_impl.s_decode_huffman_slow[0].v_bits = v_bits;
-  self->private_impl.s_decode_huffman_slow[0].v_n_bits = v_n_bits;
-  self->private_impl.s_decode_huffman_slow[0].v_table_entry = v_table_entry;
-  self->private_impl.s_decode_huffman_slow[0].v_table_entry_n_bits =
+  self->private_data.s_decode_huffman_slow[0].v_bits = v_bits;
+  self->private_data.s_decode_huffman_slow[0].v_n_bits = v_n_bits;
+  self->private_data.s_decode_huffman_slow[0].v_table_entry = v_table_entry;
+  self->private_data.s_decode_huffman_slow[0].v_table_entry_n_bits =
       v_table_entry_n_bits;
-  self->private_impl.s_decode_huffman_slow[0].v_lmask = v_lmask;
-  self->private_impl.s_decode_huffman_slow[0].v_dmask = v_dmask;
-  self->private_impl.s_decode_huffman_slow[0].v_redir_top = v_redir_top;
-  self->private_impl.s_decode_huffman_slow[0].v_redir_mask = v_redir_mask;
-  self->private_impl.s_decode_huffman_slow[0].v_length = v_length;
-  self->private_impl.s_decode_huffman_slow[0].v_dist_minus_1 = v_dist_minus_1;
-  self->private_impl.s_decode_huffman_slow[0].v_hlen = v_hlen;
-  self->private_impl.s_decode_huffman_slow[0].v_hdist = v_hdist;
+  self->private_data.s_decode_huffman_slow[0].v_lmask = v_lmask;
+  self->private_data.s_decode_huffman_slow[0].v_dmask = v_dmask;
+  self->private_data.s_decode_huffman_slow[0].v_redir_top = v_redir_top;
+  self->private_data.s_decode_huffman_slow[0].v_redir_mask = v_redir_mask;
+  self->private_data.s_decode_huffman_slow[0].v_length = v_length;
+  self->private_data.s_decode_huffman_slow[0].v_dist_minus_1 = v_dist_minus_1;
+  self->private_data.s_decode_huffman_slow[0].v_hlen = v_hlen;
+  self->private_data.s_decode_huffman_slow[0].v_hdist = v_hdist;
 
   goto exit;
 exit:
@@ -8009,11 +8078,19 @@
       (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
     return wuffs_base__error__bad_wuffs_version;
   }
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) == 0) {
-    memset(self, 0, sizeof_star_self);
-  } else if (self->private_impl.magic != 0) {
-    return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
+
+  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+    if (self->private_impl.magic != 0) {
+      return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
+    }
+  } else if ((initialize_flags &
+              WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) != 0) {
+    memset(&(self->private_impl), 0, sizeof(self->private_impl));
+  } else {
+    memset(self, 0, sizeof(*self));
+    initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
   }
+
   self->private_impl.magic = WUFFS_BASE__MAGIC;
   return NULL;
 }
@@ -8028,7 +8105,7 @@
 
 size_t  //
 sizeof__wuffs_lzw__decoder() {
-  return sizeof((wuffs_lzw__decoder){});
+  return sizeof(wuffs_lzw__decoder);
 }
 
 // ---------------- Function Implementations
@@ -8038,18 +8115,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
@@ -8057,10 +8134,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);
@@ -8114,8 +8191,8 @@
     self->private_impl.f_output_wi = 0;
     v_i = 0;
     while (v_i < self->private_impl.f_clear_code) {
-      self->private_impl.f_lm1s[v_i] = 0;
-      self->private_impl.f_suffixes[v_i][0] = ((uint8_t)(v_i));
+      self->private_data.f_lm1s[v_i] = 0;
+      self->private_data.f_suffixes[v_i][0] = ((uint8_t)(v_i));
       v_i += 1;
     }
   label_0_continue:;
@@ -8242,23 +8319,23 @@
     v_bits >>= v_width;
     v_n_bits -= v_width;
     if (v_code < v_clear_code) {
-      self->private_impl.f_output[v_output_wi] = ((uint8_t)(v_code));
+      self->private_data.f_output[v_output_wi] = ((uint8_t)(v_code));
       v_output_wi = ((v_output_wi + 1) & 8191);
       if (v_save_code <= 4095) {
-        v_lm1_a = ((self->private_impl.f_lm1s[v_prev_code] + 1) & 4095);
-        self->private_impl.f_lm1s[v_save_code] = v_lm1_a;
+        v_lm1_a = ((self->private_data.f_lm1s[v_prev_code] + 1) & 4095);
+        self->private_data.f_lm1s[v_save_code] = v_lm1_a;
         if ((v_lm1_a % 8) != 0) {
-          self->private_impl.f_prefixes[v_save_code] =
-              self->private_impl.f_prefixes[v_prev_code];
-          memcpy(self->private_impl.f_suffixes[v_save_code],
-                 self->private_impl.f_suffixes[v_prev_code],
-                 sizeof(self->private_impl.f_suffixes[v_save_code]));
-          self->private_impl.f_suffixes[v_save_code][(v_lm1_a % 8)] =
+          self->private_data.f_prefixes[v_save_code] =
+              self->private_data.f_prefixes[v_prev_code];
+          memcpy(self->private_data.f_suffixes[v_save_code],
+                 self->private_data.f_suffixes[v_prev_code],
+                 sizeof(self->private_data.f_suffixes[v_save_code]));
+          self->private_data.f_suffixes[v_save_code][(v_lm1_a % 8)] =
               ((uint8_t)(v_code));
         } else {
-          self->private_impl.f_prefixes[v_save_code] =
+          self->private_data.f_prefixes[v_save_code] =
               ((uint16_t)(v_prev_code));
-          self->private_impl.f_suffixes[v_save_code][0] = ((uint8_t)(v_code));
+          self->private_data.f_suffixes[v_save_code][0] = ((uint8_t)(v_code));
         }
         v_save_code += 1;
         if (v_width < 12) {
@@ -8280,43 +8357,43 @@
         v_c = v_prev_code;
       }
       v_o = ((v_output_wi +
-              (((uint32_t)(self->private_impl.f_lm1s[v_c])) & 4294967288)) &
+              (((uint32_t)(self->private_data.f_lm1s[v_c])) & 4294967288)) &
              8191);
       v_output_wi =
-          ((v_output_wi + 1 + ((uint32_t)(self->private_impl.f_lm1s[v_c]))) &
+          ((v_output_wi + 1 + ((uint32_t)(self->private_data.f_lm1s[v_c]))) &
            8191);
-      v_steps = (((uint32_t)(self->private_impl.f_lm1s[v_c])) >> 3);
+      v_steps = (((uint32_t)(self->private_data.f_lm1s[v_c])) >> 3);
       while (true) {
-        memcpy((self->private_impl.f_output) + (v_o),
-               (self->private_impl.f_suffixes[v_c]), 8);
+        memcpy((self->private_data.f_output) + (v_o),
+               (self->private_data.f_suffixes[v_c]), 8);
         if (v_steps <= 0) {
           goto label_1_break;
         }
         v_steps -= 1;
         v_o = ((v_o - 8) & 8191);
-        v_c = ((uint32_t)(self->private_impl.f_prefixes[v_c]));
+        v_c = ((uint32_t)(self->private_data.f_prefixes[v_c]));
       }
     label_1_break:;
-      v_first_byte = self->private_impl.f_suffixes[v_c][0];
+      v_first_byte = self->private_data.f_suffixes[v_c][0];
       if (v_code == v_save_code) {
-        self->private_impl.f_output[v_output_wi] = v_first_byte;
+        self->private_data.f_output[v_output_wi] = v_first_byte;
         v_output_wi = ((v_output_wi + 1) & 8191);
       }
       if (v_save_code <= 4095) {
-        v_lm1_b = ((self->private_impl.f_lm1s[v_prev_code] + 1) & 4095);
-        self->private_impl.f_lm1s[v_save_code] = v_lm1_b;
+        v_lm1_b = ((self->private_data.f_lm1s[v_prev_code] + 1) & 4095);
+        self->private_data.f_lm1s[v_save_code] = v_lm1_b;
         if ((v_lm1_b % 8) != 0) {
-          self->private_impl.f_prefixes[v_save_code] =
-              self->private_impl.f_prefixes[v_prev_code];
-          memcpy(self->private_impl.f_suffixes[v_save_code],
-                 self->private_impl.f_suffixes[v_prev_code],
-                 sizeof(self->private_impl.f_suffixes[v_save_code]));
-          self->private_impl.f_suffixes[v_save_code][(v_lm1_b % 8)] =
+          self->private_data.f_prefixes[v_save_code] =
+              self->private_data.f_prefixes[v_prev_code];
+          memcpy(self->private_data.f_suffixes[v_save_code],
+                 self->private_data.f_suffixes[v_prev_code],
+                 sizeof(self->private_data.f_suffixes[v_save_code]));
+          self->private_data.f_suffixes[v_save_code][(v_lm1_b % 8)] =
               v_first_byte;
         } else {
-          self->private_impl.f_prefixes[v_save_code] =
+          self->private_data.f_prefixes[v_save_code] =
               ((uint16_t)(v_prev_code));
-          self->private_impl.f_suffixes[v_save_code][0] =
+          self->private_data.f_suffixes[v_save_code][0] =
               ((uint8_t)(v_first_byte));
         }
         v_save_code += 1;
@@ -8358,7 +8435,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
@@ -8368,7 +8445,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;
@@ -8402,7 +8479,7 @@
       }
       v_s = wuffs_base__slice_u8__subslice_ij(
           ((wuffs_base__slice_u8){
-              .ptr = self->private_impl.f_output,
+              .ptr = self->private_data.f_output,
               .len = 8199,
           }),
           self->private_impl.f_output_ri, self->private_impl.f_output_wi);
@@ -8445,18 +8522,18 @@
 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(
         ((wuffs_base__slice_u8){
-            .ptr = self->private_impl.f_output,
+            .ptr = self->private_data.f_output,
             .len = 8199,
         }),
         self->private_impl.f_output_ri, self->private_impl.f_output_wi);
@@ -8585,14 +8662,22 @@
       (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
     return wuffs_base__error__bad_wuffs_version;
   }
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) == 0) {
-    memset(self, 0, sizeof_star_self);
-  } else if (self->private_impl.magic != 0) {
-    return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
+
+  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+    if (self->private_impl.magic != 0) {
+      return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
+    }
+  } else if ((initialize_flags &
+              WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) != 0) {
+    memset(&(self->private_impl), 0, sizeof(self->private_impl));
+  } else {
+    memset(self, 0, sizeof(*self));
+    initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
   }
+
   {
     wuffs_base__status z = wuffs_lzw__decoder__initialize(
-        &self->private_impl.f_lzw, sizeof(self->private_impl.f_lzw),
+        &self->private_data.f_lzw, sizeof(self->private_data.f_lzw),
         WUFFS_VERSION, initialize_flags);
     if (z) {
       return z;
@@ -8612,7 +8697,7 @@
 
 size_t  //
 sizeof__wuffs_gif__decoder() {
-  return sizeof((wuffs_gif__decoder){});
+  return sizeof(wuffs_gif__decoder);
 }
 
 // ---------------- Function Implementations
@@ -8749,10 +8834,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(
@@ -8769,15 +8854,13 @@
 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(
-      ((uint64_t)(self->private_impl.f_width)),
-      ((uint64_t)(self->private_impl.f_width)));
+  return wuffs_base__utility__make_range_ii_u64(1, 1);
 }
 
 // -------- func gif.decoder.restart_frame
@@ -8837,8 +8920,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) {
@@ -8950,17 +9032,17 @@
       v_flags = t_0;
     }
     if ((v_flags & 128) != 0) {
-      self->private_impl.s_skip_frame[0].scratch =
+      self->private_data.s_skip_frame[0].scratch =
           (((uint32_t)(3)) << (1 + (v_flags & 7)));
       WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
-      if (self->private_impl.s_skip_frame[0].scratch >
+      if (self->private_data.s_skip_frame[0].scratch >
           ((uint64_t)(io1_a_src - iop_a_src))) {
-        self->private_impl.s_skip_frame[0].scratch -= io1_a_src - iop_a_src;
+        self->private_data.s_skip_frame[0].scratch -= io1_a_src - iop_a_src;
         iop_a_src = io1_a_src;
         status = wuffs_base__suspension__short_read;
         goto suspend;
       }
-      iop_a_src += self->private_impl.s_skip_frame[0].scratch;
+      iop_a_src += self->private_data.s_skip_frame[0].scratch;
     }
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
     if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
@@ -9089,7 +9171,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
@@ -9216,7 +9298,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;
@@ -9236,8 +9318,8 @@
 
   uint32_t coro_susp_point = self->private_impl.p_decode_header[0];
   if (coro_susp_point) {
-    memcpy(v_c, self->private_impl.s_decode_header[0].v_c, sizeof(v_c));
-    v_i = self->private_impl.s_decode_header[0].v_i;
+    memcpy(v_c, self->private_data.s_decode_header[0].v_c, sizeof(v_c));
+    v_i = self->private_data.s_decode_header[0].v_i;
   }
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
@@ -9269,8 +9351,8 @@
   goto suspend;
 suspend:
   self->private_impl.p_decode_header[0] = coro_susp_point;
-  memcpy(self->private_impl.s_decode_header[0].v_c, v_c, sizeof(v_c));
-  self->private_impl.s_decode_header[0].v_i = v_i;
+  memcpy(self->private_data.s_decode_header[0].v_c, v_c, sizeof(v_c));
+  self->private_data.s_decode_header[0].v_i = v_i;
 
   goto exit;
 exit:
@@ -9311,10 +9393,10 @@
 
   uint32_t coro_susp_point = self->private_impl.p_decode_lsd[0];
   if (coro_susp_point) {
-    v_flags = self->private_impl.s_decode_lsd[0].v_flags;
+    v_flags = self->private_data.s_decode_lsd[0].v_flags;
     v_num_palette_entries =
-        self->private_impl.s_decode_lsd[0].v_num_palette_entries;
-    v_i = self->private_impl.s_decode_lsd[0].v_i;
+        self->private_data.s_decode_lsd[0].v_num_palette_entries;
+    v_i = self->private_data.s_decode_lsd[0].v_i;
   }
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
@@ -9326,14 +9408,14 @@
         t_0 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src)));
         iop_a_src += 2;
       } else {
-        self->private_impl.s_decode_lsd[0].scratch = 0;
+        self->private_data.s_decode_lsd[0].scratch = 0;
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
         while (true) {
           if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
             status = wuffs_base__suspension__short_read;
             goto suspend;
           }
-          uint64_t* scratch = &self->private_impl.s_decode_lsd[0].scratch;
+          uint64_t* scratch = &self->private_data.s_decode_lsd[0].scratch;
           uint32_t num_bits_0 = *scratch >> 56;
           *scratch <<= 8;
           *scratch >>= 8;
@@ -9355,14 +9437,14 @@
         t_1 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src)));
         iop_a_src += 2;
       } else {
-        self->private_impl.s_decode_lsd[0].scratch = 0;
+        self->private_data.s_decode_lsd[0].scratch = 0;
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
         while (true) {
           if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
             status = wuffs_base__suspension__short_read;
             goto suspend;
           }
-          uint64_t* scratch = &self->private_impl.s_decode_lsd[0].scratch;
+          uint64_t* scratch = &self->private_data.s_decode_lsd[0].scratch;
           uint32_t num_bits_1 = *scratch >> 56;
           *scratch <<= 8;
           *scratch >>= 8;
@@ -9386,16 +9468,16 @@
       uint8_t t_2 = *iop_a_src++;
       v_flags = t_2;
     }
-    self->private_impl.s_decode_lsd[0].scratch = 2;
+    self->private_data.s_decode_lsd[0].scratch = 2;
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
-    if (self->private_impl.s_decode_lsd[0].scratch >
+    if (self->private_data.s_decode_lsd[0].scratch >
         ((uint64_t)(io1_a_src - iop_a_src))) {
-      self->private_impl.s_decode_lsd[0].scratch -= io1_a_src - iop_a_src;
+      self->private_data.s_decode_lsd[0].scratch -= io1_a_src - iop_a_src;
       iop_a_src = io1_a_src;
       status = wuffs_base__suspension__short_read;
       goto suspend;
     }
-    iop_a_src += self->private_impl.s_decode_lsd[0].scratch;
+    iop_a_src += self->private_data.s_decode_lsd[0].scratch;
     if ((v_flags & 128) != 0) {
       v_num_palette_entries = (((uint32_t)(1)) << (1 + (v_flags & 7)));
       v_i = 0;
@@ -9407,14 +9489,14 @@
             t_3 = ((uint32_t)(wuffs_base__load_u24be(iop_a_src)));
             iop_a_src += 3;
           } else {
-            self->private_impl.s_decode_lsd[0].scratch = 0;
+            self->private_data.s_decode_lsd[0].scratch = 0;
             WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
             while (true) {
               if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
                 status = wuffs_base__suspension__short_read;
                 goto suspend;
               }
-              uint64_t* scratch = &self->private_impl.s_decode_lsd[0].scratch;
+              uint64_t* scratch = &self->private_data.s_decode_lsd[0].scratch;
               uint32_t num_bits_3 = *scratch & 0xFF;
               *scratch >>= 8;
               *scratch <<= 8;
@@ -9430,21 +9512,21 @@
           v_argb = t_3;
         }
         v_argb |= 4278190080;
-        self->private_impl.f_palettes[0][((4 * v_i) + 0)] =
+        self->private_data.f_palettes[0][((4 * v_i) + 0)] =
             ((uint8_t)(((v_argb >> 0) & 255)));
-        self->private_impl.f_palettes[0][((4 * v_i) + 1)] =
+        self->private_data.f_palettes[0][((4 * v_i) + 1)] =
             ((uint8_t)(((v_argb >> 8) & 255)));
-        self->private_impl.f_palettes[0][((4 * v_i) + 2)] =
+        self->private_data.f_palettes[0][((4 * v_i) + 2)] =
             ((uint8_t)(((v_argb >> 16) & 255)));
-        self->private_impl.f_palettes[0][((4 * v_i) + 3)] =
+        self->private_data.f_palettes[0][((4 * v_i) + 3)] =
             ((uint8_t)(((v_argb >> 24) & 255)));
         v_i += 1;
       }
       while (v_i < 256) {
-        self->private_impl.f_palettes[0][((4 * v_i) + 0)] = 0;
-        self->private_impl.f_palettes[0][((4 * v_i) + 1)] = 0;
-        self->private_impl.f_palettes[0][((4 * v_i) + 2)] = 0;
-        self->private_impl.f_palettes[0][((4 * v_i) + 3)] = 255;
+        self->private_data.f_palettes[0][((4 * v_i) + 0)] = 0;
+        self->private_data.f_palettes[0][((4 * v_i) + 1)] = 0;
+        self->private_data.f_palettes[0][((4 * v_i) + 2)] = 0;
+        self->private_data.f_palettes[0][((4 * v_i) + 3)] = 255;
         v_i += 1;
       }
     }
@@ -9458,10 +9540,10 @@
   goto suspend;
 suspend:
   self->private_impl.p_decode_lsd[0] = coro_susp_point;
-  self->private_impl.s_decode_lsd[0].v_flags = v_flags;
-  self->private_impl.s_decode_lsd[0].v_num_palette_entries =
+  self->private_data.s_decode_lsd[0].v_flags = v_flags;
+  self->private_data.s_decode_lsd[0].v_num_palette_entries =
       v_num_palette_entries;
-  self->private_impl.s_decode_lsd[0].v_i = v_i;
+  self->private_data.s_decode_lsd[0].v_i = v_i;
 
   goto exit;
 exit:
@@ -9623,16 +9705,16 @@
         status = NULL;
         goto ok;
       }
-      self->private_impl.s_skip_blocks[0].scratch = ((uint32_t)(v_block_size));
+      self->private_data.s_skip_blocks[0].scratch = ((uint32_t)(v_block_size));
       WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
-      if (self->private_impl.s_skip_blocks[0].scratch >
+      if (self->private_data.s_skip_blocks[0].scratch >
           ((uint64_t)(io1_a_src - iop_a_src))) {
-        self->private_impl.s_skip_blocks[0].scratch -= io1_a_src - iop_a_src;
+        self->private_data.s_skip_blocks[0].scratch -= io1_a_src - iop_a_src;
         iop_a_src = io1_a_src;
         status = wuffs_base__suspension__short_read;
         goto suspend;
       }
-      iop_a_src += self->private_impl.s_skip_blocks[0].scratch;
+      iop_a_src += self->private_data.s_skip_blocks[0].scratch;
     }
 
     goto ok;
@@ -9684,9 +9766,9 @@
 
   uint32_t coro_susp_point = self->private_impl.p_decode_ae[0];
   if (coro_susp_point) {
-    v_block_size = self->private_impl.s_decode_ae[0].v_block_size;
-    v_not_animexts = self->private_impl.s_decode_ae[0].v_not_animexts;
-    v_not_netscape = self->private_impl.s_decode_ae[0].v_not_netscape;
+    v_block_size = self->private_data.s_decode_ae[0].v_block_size;
+    v_not_animexts = self->private_data.s_decode_ae[0].v_not_animexts;
+    v_not_netscape = self->private_data.s_decode_ae[0].v_not_netscape;
   }
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
@@ -9706,16 +9788,16 @@
         goto ok;
       }
       if (v_block_size != 11) {
-        self->private_impl.s_decode_ae[0].scratch = ((uint32_t)(v_block_size));
+        self->private_data.s_decode_ae[0].scratch = ((uint32_t)(v_block_size));
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
-        if (self->private_impl.s_decode_ae[0].scratch >
+        if (self->private_data.s_decode_ae[0].scratch >
             ((uint64_t)(io1_a_src - iop_a_src))) {
-          self->private_impl.s_decode_ae[0].scratch -= io1_a_src - iop_a_src;
+          self->private_data.s_decode_ae[0].scratch -= io1_a_src - iop_a_src;
           iop_a_src = io1_a_src;
           status = wuffs_base__suspension__short_read;
           goto suspend;
         }
-        iop_a_src += self->private_impl.s_decode_ae[0].scratch;
+        iop_a_src += self->private_data.s_decode_ae[0].scratch;
         goto label_0_break;
       }
       v_not_animexts = false;
@@ -9750,16 +9832,16 @@
         v_block_size = t_2;
       }
       if (v_block_size != 3) {
-        self->private_impl.s_decode_ae[0].scratch = ((uint32_t)(v_block_size));
+        self->private_data.s_decode_ae[0].scratch = ((uint32_t)(v_block_size));
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
-        if (self->private_impl.s_decode_ae[0].scratch >
+        if (self->private_data.s_decode_ae[0].scratch >
             ((uint64_t)(io1_a_src - iop_a_src))) {
-          self->private_impl.s_decode_ae[0].scratch -= io1_a_src - iop_a_src;
+          self->private_data.s_decode_ae[0].scratch -= io1_a_src - iop_a_src;
           iop_a_src = io1_a_src;
           status = wuffs_base__suspension__short_read;
           goto suspend;
         }
-        iop_a_src += self->private_impl.s_decode_ae[0].scratch;
+        iop_a_src += self->private_data.s_decode_ae[0].scratch;
         goto label_0_break;
       }
       {
@@ -9772,16 +9854,16 @@
         v_c = t_3;
       }
       if (v_c != 1) {
-        self->private_impl.s_decode_ae[0].scratch = 2;
+        self->private_data.s_decode_ae[0].scratch = 2;
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
-        if (self->private_impl.s_decode_ae[0].scratch >
+        if (self->private_data.s_decode_ae[0].scratch >
             ((uint64_t)(io1_a_src - iop_a_src))) {
-          self->private_impl.s_decode_ae[0].scratch -= io1_a_src - iop_a_src;
+          self->private_data.s_decode_ae[0].scratch -= io1_a_src - iop_a_src;
           iop_a_src = io1_a_src;
           status = wuffs_base__suspension__short_read;
           goto suspend;
         }
-        iop_a_src += self->private_impl.s_decode_ae[0].scratch;
+        iop_a_src += self->private_data.s_decode_ae[0].scratch;
         goto label_0_break;
       }
       {
@@ -9791,14 +9873,14 @@
           t_4 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src)));
           iop_a_src += 2;
         } else {
-          self->private_impl.s_decode_ae[0].scratch = 0;
+          self->private_data.s_decode_ae[0].scratch = 0;
           WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
           while (true) {
             if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
               status = wuffs_base__suspension__short_read;
               goto suspend;
             }
-            uint64_t* scratch = &self->private_impl.s_decode_ae[0].scratch;
+            uint64_t* scratch = &self->private_data.s_decode_ae[0].scratch;
             uint32_t num_bits_4 = *scratch >> 56;
             *scratch <<= 8;
             *scratch >>= 8;
@@ -9844,9 +9926,9 @@
   goto suspend;
 suspend:
   self->private_impl.p_decode_ae[0] = coro_susp_point;
-  self->private_impl.s_decode_ae[0].v_block_size = v_block_size;
-  self->private_impl.s_decode_ae[0].v_not_animexts = v_not_animexts;
-  self->private_impl.s_decode_ae[0].v_not_netscape = v_not_netscape;
+  self->private_data.s_decode_ae[0].v_block_size = v_block_size;
+  self->private_data.s_decode_ae[0].v_not_animexts = v_not_animexts;
+  self->private_data.s_decode_ae[0].v_not_netscape = v_not_netscape;
 
   goto exit;
 exit:
@@ -9932,14 +10014,14 @@
         t_2 = wuffs_base__load_u16le(iop_a_src);
         iop_a_src += 2;
       } else {
-        self->private_impl.s_decode_gc[0].scratch = 0;
+        self->private_data.s_decode_gc[0].scratch = 0;
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
         while (true) {
           if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
             status = wuffs_base__suspension__short_read;
             goto suspend;
           }
-          uint64_t* scratch = &self->private_impl.s_decode_gc[0].scratch;
+          uint64_t* scratch = &self->private_data.s_decode_gc[0].scratch;
           uint32_t num_bits_2 = *scratch >> 56;
           *scratch <<= 8;
           *scratch >>= 8;
@@ -10035,14 +10117,14 @@
         t_0 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src)));
         iop_a_src += 2;
       } else {
-        self->private_impl.s_decode_id_part0[0].scratch = 0;
+        self->private_data.s_decode_id_part0[0].scratch = 0;
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
         while (true) {
           if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
             status = wuffs_base__suspension__short_read;
             goto suspend;
           }
-          uint64_t* scratch = &self->private_impl.s_decode_id_part0[0].scratch;
+          uint64_t* scratch = &self->private_data.s_decode_id_part0[0].scratch;
           uint32_t num_bits_0 = *scratch >> 56;
           *scratch <<= 8;
           *scratch >>= 8;
@@ -10064,14 +10146,14 @@
         t_1 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src)));
         iop_a_src += 2;
       } else {
-        self->private_impl.s_decode_id_part0[0].scratch = 0;
+        self->private_data.s_decode_id_part0[0].scratch = 0;
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
         while (true) {
           if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
             status = wuffs_base__suspension__short_read;
             goto suspend;
           }
-          uint64_t* scratch = &self->private_impl.s_decode_id_part0[0].scratch;
+          uint64_t* scratch = &self->private_data.s_decode_id_part0[0].scratch;
           uint32_t num_bits_1 = *scratch >> 56;
           *scratch <<= 8;
           *scratch >>= 8;
@@ -10093,14 +10175,14 @@
         t_2 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src)));
         iop_a_src += 2;
       } else {
-        self->private_impl.s_decode_id_part0[0].scratch = 0;
+        self->private_data.s_decode_id_part0[0].scratch = 0;
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
         while (true) {
           if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
             status = wuffs_base__suspension__short_read;
             goto suspend;
           }
-          uint64_t* scratch = &self->private_impl.s_decode_id_part0[0].scratch;
+          uint64_t* scratch = &self->private_data.s_decode_id_part0[0].scratch;
           uint32_t num_bits_2 = *scratch >> 56;
           *scratch <<= 8;
           *scratch >>= 8;
@@ -10123,14 +10205,14 @@
         t_3 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src)));
         iop_a_src += 2;
       } else {
-        self->private_impl.s_decode_id_part0[0].scratch = 0;
+        self->private_data.s_decode_id_part0[0].scratch = 0;
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
         while (true) {
           if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
             status = wuffs_base__suspension__short_read;
             goto suspend;
           }
-          uint64_t* scratch = &self->private_impl.s_decode_id_part0[0].scratch;
+          uint64_t* scratch = &self->private_data.s_decode_id_part0[0].scratch;
           uint32_t num_bits_3 = *scratch >> 56;
           *scratch <<= 8;
           *scratch >>= 8;
@@ -10187,7 +10269,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;
@@ -10208,8 +10290,8 @@
   uint32_t coro_susp_point = self->private_impl.p_decode_id_part1[0];
   if (coro_susp_point) {
     v_num_palette_entries =
-        self->private_impl.s_decode_id_part1[0].v_num_palette_entries;
-    v_i = self->private_impl.s_decode_id_part1[0].v_i;
+        self->private_data.s_decode_id_part1[0].v_num_palette_entries;
+    v_i = self->private_data.s_decode_id_part1[0].v_i;
   }
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
@@ -10240,7 +10322,7 @@
             t_1 = ((uint32_t)(wuffs_base__load_u24be(iop_a_src)));
             iop_a_src += 3;
           } else {
-            self->private_impl.s_decode_id_part1[0].scratch = 0;
+            self->private_data.s_decode_id_part1[0].scratch = 0;
             WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
             while (true) {
               if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
@@ -10248,7 +10330,7 @@
                 goto suspend;
               }
               uint64_t* scratch =
-                  &self->private_impl.s_decode_id_part1[0].scratch;
+                  &self->private_data.s_decode_id_part1[0].scratch;
               uint32_t num_bits_1 = *scratch & 0xFF;
               *scratch >>= 8;
               *scratch <<= 8;
@@ -10264,54 +10346,54 @@
           v_argb = t_1;
         }
         v_argb |= 4278190080;
-        self->private_impl.f_palettes[1][((4 * v_i) + 0)] =
+        self->private_data.f_palettes[1][((4 * v_i) + 0)] =
             ((uint8_t)(((v_argb >> 0) & 255)));
-        self->private_impl.f_palettes[1][((4 * v_i) + 1)] =
+        self->private_data.f_palettes[1][((4 * v_i) + 1)] =
             ((uint8_t)(((v_argb >> 8) & 255)));
-        self->private_impl.f_palettes[1][((4 * v_i) + 2)] =
+        self->private_data.f_palettes[1][((4 * v_i) + 2)] =
             ((uint8_t)(((v_argb >> 16) & 255)));
-        self->private_impl.f_palettes[1][((4 * v_i) + 3)] =
+        self->private_data.f_palettes[1][((4 * v_i) + 3)] =
             ((uint8_t)(((v_argb >> 24) & 255)));
         v_i += 1;
       }
       while (v_i < 256) {
-        self->private_impl.f_palettes[1][((4 * v_i) + 0)] = 0;
-        self->private_impl.f_palettes[1][((4 * v_i) + 1)] = 0;
-        self->private_impl.f_palettes[1][((4 * v_i) + 2)] = 0;
-        self->private_impl.f_palettes[1][((4 * v_i) + 3)] = 255;
+        self->private_data.f_palettes[1][((4 * v_i) + 0)] = 0;
+        self->private_data.f_palettes[1][((4 * v_i) + 1)] = 0;
+        self->private_data.f_palettes[1][((4 * v_i) + 2)] = 0;
+        self->private_data.f_palettes[1][((4 * v_i) + 3)] = 255;
         v_i += 1;
       }
     } else if (self->private_impl.f_gc_has_transparent_index) {
       wuffs_base__slice_u8__copy_from_slice(
           ((wuffs_base__slice_u8){
-              .ptr = self->private_impl.f_palettes[1],
+              .ptr = self->private_data.f_palettes[1],
               .len = 1024,
           }),
           ((wuffs_base__slice_u8){
-              .ptr = self->private_impl.f_palettes[0],
+              .ptr = self->private_data.f_palettes[0],
               .len = 1024,
           }));
     } else {
       self->private_impl.f_which_palette = 0;
     }
     if (self->private_impl.f_gc_has_transparent_index) {
-      self->private_impl.f_palettes[1][(
+      self->private_data.f_palettes[1][(
           (4 * ((uint32_t)(self->private_impl.f_gc_transparent_index))) + 0)] =
           0;
-      self->private_impl.f_palettes[1][(
+      self->private_data.f_palettes[1][(
           (4 * ((uint32_t)(self->private_impl.f_gc_transparent_index))) + 1)] =
           0;
-      self->private_impl.f_palettes[1][(
+      self->private_data.f_palettes[1][(
           (4 * ((uint32_t)(self->private_impl.f_gc_transparent_index))) + 2)] =
           0;
-      self->private_impl.f_palettes[1][(
+      self->private_data.f_palettes[1][(
           (4 * ((uint32_t)(self->private_impl.f_gc_transparent_index))) + 3)] =
           0;
     }
     v_dst_palette = wuffs_base__pixel_buffer__palette(a_dst);
     if (((uint64_t)(v_dst_palette.len)) == 0) {
       v_dst_palette = ((wuffs_base__slice_u8){
-          .ptr = self->private_impl.f_dst_palette,
+          .ptr = self->private_data.f_dst_palette,
           .len = 1024,
       });
     }
@@ -10320,16 +10402,14 @@
         wuffs_base__pixel_buffer__pixel_format(a_dst), v_dst_palette,
         1191444488,
         ((wuffs_base__slice_u8){
-            .ptr = self->private_impl
+            .ptr = self->private_data
                        .f_palettes[self->private_impl.f_which_palette],
             .len = 1024,
         }));
     if (self->private_impl.f_previous_lzw_decode_ended_abruptly) {
-      (memset(&self->private_impl.f_lzw, 0, sizeof((wuffs_lzw__decoder){})),
-       wuffs_base__ignore_status(wuffs_lzw__decoder__initialize(
-           &self->private_impl.f_lzw, sizeof((wuffs_lzw__decoder){}),
-           WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED)),
-       wuffs_base__return_empty_struct());
+      wuffs_base__ignore_status(wuffs_lzw__decoder__initialize(
+          &self->private_data.f_lzw, sizeof(wuffs_lzw__decoder), WUFFS_VERSION,
+          0));
     }
     {
       WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
@@ -10344,7 +10424,7 @@
       status = wuffs_gif__error__bad_literal_width;
       goto exit;
     }
-    wuffs_lzw__decoder__set_literal_width(&self->private_impl.f_lzw,
+    wuffs_lzw__decoder__set_literal_width(&self->private_data.f_lzw,
                                           ((uint32_t)(v_lw)));
     self->private_impl.f_previous_lzw_decode_ended_abruptly = true;
 
@@ -10357,9 +10437,9 @@
   goto suspend;
 suspend:
   self->private_impl.p_decode_id_part1[0] = coro_susp_point;
-  self->private_impl.s_decode_id_part1[0].v_num_palette_entries =
+  self->private_data.s_decode_id_part1[0].v_num_palette_entries =
       v_num_palette_entries;
-  self->private_impl.s_decode_id_part1[0].v_i = v_i;
+  self->private_data.s_decode_id_part1[0].v_i = v_i;
 
   goto exit;
 exit:
@@ -10383,14 +10463,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;
@@ -10409,10 +10492,10 @@
 
   uint32_t coro_susp_point = self->private_impl.p_decode_id_part2[0];
   if (coro_susp_point) {
-    v_block_size = self->private_impl.s_decode_id_part2[0].v_block_size;
+    v_block_size = self->private_data.s_decode_id_part2[0].v_block_size;
     v_need_block_size =
-        self->private_impl.s_decode_id_part2[0].v_need_block_size;
-    v_lzw_status = self->private_impl.s_decode_id_part2[0].v_lzw_status;
+        self->private_data.s_decode_id_part2[0].v_need_block_size;
+    v_lzw_status = self->private_data.s_decode_id_part2[0].v_lzw_status;
   }
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
@@ -10455,7 +10538,7 @@
         wuffs_base__slice_u8__copy_from_slice(
             wuffs_base__slice_u8__subslice_i(
                 ((wuffs_base__slice_u8){
-                    .ptr = self->private_impl.f_compressed,
+                    .ptr = self->private_data.f_compressed,
                     .len = 4096,
                 }),
                 self->private_impl.f_compressed_wi),
@@ -10474,12 +10557,7 @@
         (iop_a_src += 1, wuffs_base__return_empty_struct());
       }
     label_1_break:;
-      if (((uint64_t)(self->private_impl.f_width)) <
-          ((uint64_t)(a_workbuf.len))) {
-        a_workbuf = wuffs_base__slice_u8__subslice_j(
-            a_workbuf, ((uint64_t)(self->private_impl.f_width)));
-      } else if (((uint64_t)(self->private_impl.f_width)) >
-                 ((uint64_t)(a_workbuf.len))) {
+      if (1 > ((uint64_t)(a_workbuf.len))) {
         status = wuffs_base__error__bad_workbuf_length;
         goto exit;
       }
@@ -10499,7 +10577,7 @@
               &v_r, &u_r, &iop_v_r, &io1_v_r,
               wuffs_base__slice_u8__subslice_ij(
                   ((wuffs_base__slice_u8){
-                      .ptr = self->private_impl.f_compressed,
+                      .ptr = self->private_data.f_compressed,
                       .len = 4096,
                   }),
                   self->private_impl.f_compressed_ri,
@@ -10507,7 +10585,7 @@
           {
             u_r.meta.ri = iop_v_r - u_r.data.ptr;
             wuffs_base__status t_1 = wuffs_lzw__decoder__decode_io_writer(
-                &self->private_impl.f_lzw,
+                &self->private_data.f_lzw,
                 wuffs_base__utility__null_io_writer(), v_r,
                 wuffs_base__utility__null_slice_u8());
             iop_v_r = u_r.data.ptr + u_r.meta.ri;
@@ -10520,7 +10598,7 @@
           iop_v_r = o_0_iop_v_r;
           io1_v_r = o_0_io1_v_r;
         }
-        v_uncompressed = wuffs_lzw__decoder__flush(&self->private_impl.f_lzw);
+        v_uncompressed = wuffs_lzw__decoder__flush(&self->private_data.f_lzw);
         if (((uint64_t)(v_uncompressed.len)) > 0) {
           v_copy_status = wuffs_gif__decoder__copy_to_image_buffer(
               self, a_dst, v_uncompressed);
@@ -10532,18 +10610,18 @@
         if (wuffs_base__status__is_ok(v_lzw_status)) {
           self->private_impl.f_previous_lzw_decode_ended_abruptly = false;
           if (v_need_block_size || (v_block_size > 0)) {
-            self->private_impl.s_decode_id_part2[0].scratch =
+            self->private_data.s_decode_id_part2[0].scratch =
                 ((uint32_t)(v_block_size));
             WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
-            if (self->private_impl.s_decode_id_part2[0].scratch >
+            if (self->private_data.s_decode_id_part2[0].scratch >
                 ((uint64_t)(io1_a_src - iop_a_src))) {
-              self->private_impl.s_decode_id_part2[0].scratch -=
+              self->private_data.s_decode_id_part2[0].scratch -=
                   io1_a_src - iop_a_src;
               iop_a_src = io1_a_src;
               status = wuffs_base__suspension__short_read;
               goto suspend;
             }
-            iop_a_src += self->private_impl.s_decode_id_part2[0].scratch;
+            iop_a_src += self->private_data.s_decode_id_part2[0].scratch;
             if (a_src.private_impl.buf) {
               a_src.private_impl.buf->meta.ri =
                   iop_a_src - a_src.private_impl.buf->data.ptr;
@@ -10587,9 +10665,9 @@
   goto suspend;
 suspend:
   self->private_impl.p_decode_id_part2[0] = coro_susp_point;
-  self->private_impl.s_decode_id_part2[0].v_block_size = v_block_size;
-  self->private_impl.s_decode_id_part2[0].v_need_block_size = v_need_block_size;
-  self->private_impl.s_decode_id_part2[0].v_lzw_status = v_lzw_status;
+  self->private_data.s_decode_id_part2[0].v_block_size = v_block_size;
+  self->private_data.s_decode_id_part2[0].v_need_block_size = v_need_block_size;
+  self->private_data.s_decode_id_part2[0].v_lzw_status = v_lzw_status;
 
   goto exit;
 exit:
@@ -10607,13 +10685,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;
 
@@ -10645,7 +10723,7 @@
       v_n = wuffs_base__pixel_swizzler__swizzle_packed(
           &self->private_impl.f_swizzler, v_dst,
           ((wuffs_base__slice_u8){
-              .ptr = self->private_impl.f_dst_palette,
+              .ptr = self->private_data.f_dst_palette,
               .len = 1024,
           }),
           v_src);
@@ -10745,14 +10823,22 @@
       (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
     return wuffs_base__error__bad_wuffs_version;
   }
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) == 0) {
-    memset(self, 0, sizeof_star_self);
-  } else if (self->private_impl.magic != 0) {
-    return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
+
+  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+    if (self->private_impl.magic != 0) {
+      return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
+    }
+  } else if ((initialize_flags &
+              WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) != 0) {
+    memset(&(self->private_impl), 0, sizeof(self->private_impl));
+  } else {
+    memset(self, 0, sizeof(*self));
+    initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
   }
+
   {
     wuffs_base__status z = wuffs_crc32__ieee_hasher__initialize(
-        &self->private_impl.f_checksum, sizeof(self->private_impl.f_checksum),
+        &self->private_data.f_checksum, sizeof(self->private_data.f_checksum),
         WUFFS_VERSION, initialize_flags);
     if (z) {
       return z;
@@ -10760,7 +10846,7 @@
   }
   {
     wuffs_base__status z = wuffs_deflate__decoder__initialize(
-        &self->private_impl.f_flate, sizeof(self->private_impl.f_flate),
+        &self->private_data.f_flate, sizeof(self->private_data.f_flate),
         WUFFS_VERSION, initialize_flags);
     if (z) {
       return z;
@@ -10780,7 +10866,7 @@
 
 size_t  //
 sizeof__wuffs_gzip__decoder() {
-  return sizeof((wuffs_gzip__decoder){});
+  return sizeof(wuffs_gzip__decoder);
 }
 
 // ---------------- Function Implementations
@@ -10790,14 +10876,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
@@ -10805,13 +10891,13 @@
 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);
+  return wuffs_base__utility__make_range_ii_u64(1, 1);
 }
 
 // -------- func gzip.decoder.decode_io_writer
@@ -10880,11 +10966,11 @@
 
   uint32_t coro_susp_point = self->private_impl.p_decode_io_writer[0];
   if (coro_susp_point) {
-    v_flags = self->private_impl.s_decode_io_writer[0].v_flags;
-    v_checksum_got = self->private_impl.s_decode_io_writer[0].v_checksum_got;
+    v_flags = self->private_data.s_decode_io_writer[0].v_flags;
+    v_checksum_got = self->private_data.s_decode_io_writer[0].v_checksum_got;
     v_decoded_length_got =
-        self->private_impl.s_decode_io_writer[0].v_decoded_length_got;
-    v_checksum_want = self->private_impl.s_decode_io_writer[0].v_checksum_want;
+        self->private_data.s_decode_io_writer[0].v_decoded_length_got;
+    v_checksum_want = self->private_data.s_decode_io_writer[0].v_checksum_want;
   }
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
@@ -10937,16 +11023,16 @@
       uint8_t t_3 = *iop_a_src++;
       v_flags = t_3;
     }
-    self->private_impl.s_decode_io_writer[0].scratch = 6;
+    self->private_data.s_decode_io_writer[0].scratch = 6;
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
-    if (self->private_impl.s_decode_io_writer[0].scratch >
+    if (self->private_data.s_decode_io_writer[0].scratch >
         ((uint64_t)(io1_a_src - iop_a_src))) {
-      self->private_impl.s_decode_io_writer[0].scratch -= io1_a_src - iop_a_src;
+      self->private_data.s_decode_io_writer[0].scratch -= io1_a_src - iop_a_src;
       iop_a_src = io1_a_src;
       status = wuffs_base__suspension__short_read;
       goto suspend;
     }
-    iop_a_src += self->private_impl.s_decode_io_writer[0].scratch;
+    iop_a_src += self->private_data.s_decode_io_writer[0].scratch;
     if ((v_flags & 4) != 0) {
       {
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
@@ -10955,7 +11041,7 @@
           t_4 = wuffs_base__load_u16le(iop_a_src);
           iop_a_src += 2;
         } else {
-          self->private_impl.s_decode_io_writer[0].scratch = 0;
+          self->private_data.s_decode_io_writer[0].scratch = 0;
           WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
           while (true) {
             if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
@@ -10963,7 +11049,7 @@
               goto suspend;
             }
             uint64_t* scratch =
-                &self->private_impl.s_decode_io_writer[0].scratch;
+                &self->private_data.s_decode_io_writer[0].scratch;
             uint32_t num_bits_4 = *scratch >> 56;
             *scratch <<= 8;
             *scratch >>= 8;
@@ -10978,17 +11064,17 @@
         }
         v_xlen = t_4;
       }
-      self->private_impl.s_decode_io_writer[0].scratch = ((uint32_t)(v_xlen));
+      self->private_data.s_decode_io_writer[0].scratch = ((uint32_t)(v_xlen));
       WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
-      if (self->private_impl.s_decode_io_writer[0].scratch >
+      if (self->private_data.s_decode_io_writer[0].scratch >
           ((uint64_t)(io1_a_src - iop_a_src))) {
-        self->private_impl.s_decode_io_writer[0].scratch -=
+        self->private_data.s_decode_io_writer[0].scratch -=
             io1_a_src - iop_a_src;
         iop_a_src = io1_a_src;
         status = wuffs_base__suspension__short_read;
         goto suspend;
       }
-      iop_a_src += self->private_impl.s_decode_io_writer[0].scratch;
+      iop_a_src += self->private_data.s_decode_io_writer[0].scratch;
     }
     if ((v_flags & 8) != 0) {
       while (true) {
@@ -11025,17 +11111,17 @@
     label_1_break:;
     }
     if ((v_flags & 2) != 0) {
-      self->private_impl.s_decode_io_writer[0].scratch = 2;
+      self->private_data.s_decode_io_writer[0].scratch = 2;
       WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
-      if (self->private_impl.s_decode_io_writer[0].scratch >
+      if (self->private_data.s_decode_io_writer[0].scratch >
           ((uint64_t)(io1_a_src - iop_a_src))) {
-        self->private_impl.s_decode_io_writer[0].scratch -=
+        self->private_data.s_decode_io_writer[0].scratch -=
             io1_a_src - iop_a_src;
         iop_a_src = io1_a_src;
         status = wuffs_base__suspension__short_read;
         goto suspend;
       }
-      iop_a_src += self->private_impl.s_decode_io_writer[0].scratch;
+      iop_a_src += self->private_data.s_decode_io_writer[0].scratch;
     }
     if ((v_flags & 224) != 0) {
       status = wuffs_gzip__error__bad_encoding_flags;
@@ -11053,7 +11139,7 @@
               iop_a_src - a_src.private_impl.buf->data.ptr;
         }
         wuffs_base__status t_7 = wuffs_deflate__decoder__decode_io_writer(
-            &self->private_impl.f_flate, a_dst, a_src, a_workbuf);
+            &self->private_data.f_flate, a_dst, a_src, a_workbuf);
         if (a_dst.private_impl.buf) {
           iop_a_dst = a_dst.private_impl.buf->data.ptr +
                       a_dst.private_impl.buf->meta.wi;
@@ -11066,7 +11152,7 @@
       }
       if (!self->private_impl.f_ignore_checksum) {
         v_checksum_got = wuffs_crc32__ieee_hasher__update(
-            &self->private_impl.f_checksum,
+            &self->private_data.f_checksum,
             ((wuffs_base__slice_u8){
                 .ptr = a_dst.private_impl.mark,
                 .len = (size_t)(iop_a_dst - a_dst.private_impl.mark),
@@ -11088,14 +11174,14 @@
         t_8 = wuffs_base__load_u32le(iop_a_src);
         iop_a_src += 4;
       } else {
-        self->private_impl.s_decode_io_writer[0].scratch = 0;
+        self->private_data.s_decode_io_writer[0].scratch = 0;
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14);
         while (true) {
           if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
             status = wuffs_base__suspension__short_read;
             goto suspend;
           }
-          uint64_t* scratch = &self->private_impl.s_decode_io_writer[0].scratch;
+          uint64_t* scratch = &self->private_data.s_decode_io_writer[0].scratch;
           uint32_t num_bits_8 = *scratch >> 56;
           *scratch <<= 8;
           *scratch >>= 8;
@@ -11117,14 +11203,14 @@
         t_9 = wuffs_base__load_u32le(iop_a_src);
         iop_a_src += 4;
       } else {
-        self->private_impl.s_decode_io_writer[0].scratch = 0;
+        self->private_data.s_decode_io_writer[0].scratch = 0;
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16);
         while (true) {
           if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
             status = wuffs_base__suspension__short_read;
             goto suspend;
           }
-          uint64_t* scratch = &self->private_impl.s_decode_io_writer[0].scratch;
+          uint64_t* scratch = &self->private_data.s_decode_io_writer[0].scratch;
           uint32_t num_bits_9 = *scratch >> 56;
           *scratch <<= 8;
           *scratch >>= 8;
@@ -11156,11 +11242,11 @@
 suspend:
   self->private_impl.p_decode_io_writer[0] = coro_susp_point;
   self->private_impl.active_coroutine = 1;
-  self->private_impl.s_decode_io_writer[0].v_flags = v_flags;
-  self->private_impl.s_decode_io_writer[0].v_checksum_got = v_checksum_got;
-  self->private_impl.s_decode_io_writer[0].v_decoded_length_got =
+  self->private_data.s_decode_io_writer[0].v_flags = v_flags;
+  self->private_data.s_decode_io_writer[0].v_checksum_got = v_checksum_got;
+  self->private_data.s_decode_io_writer[0].v_decoded_length_got =
       v_decoded_length_got;
-  self->private_impl.s_decode_io_writer[0].v_checksum_want = v_checksum_want;
+  self->private_data.s_decode_io_writer[0].v_checksum_want = v_checksum_want;
 
   goto exit;
 exit:
@@ -11218,14 +11304,22 @@
       (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
     return wuffs_base__error__bad_wuffs_version;
   }
-  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) == 0) {
-    memset(self, 0, sizeof_star_self);
-  } else if (self->private_impl.magic != 0) {
-    return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
+
+  if ((initialize_flags & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+    if (self->private_impl.magic != 0) {
+      return wuffs_base__error__initialize_falsely_claimed_already_zeroed;
+    }
+  } else if ((initialize_flags &
+              WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) != 0) {
+    memset(&(self->private_impl), 0, sizeof(self->private_impl));
+  } else {
+    memset(self, 0, sizeof(*self));
+    initialize_flags |= WUFFS_INITIALIZE__ALREADY_ZEROED;
   }
+
   {
     wuffs_base__status z = wuffs_adler32__hasher__initialize(
-        &self->private_impl.f_checksum, sizeof(self->private_impl.f_checksum),
+        &self->private_data.f_checksum, sizeof(self->private_data.f_checksum),
         WUFFS_VERSION, initialize_flags);
     if (z) {
       return z;
@@ -11233,7 +11327,7 @@
   }
   {
     wuffs_base__status z = wuffs_deflate__decoder__initialize(
-        &self->private_impl.f_flate, sizeof(self->private_impl.f_flate),
+        &self->private_data.f_flate, sizeof(self->private_data.f_flate),
         WUFFS_VERSION, initialize_flags);
     if (z) {
       return z;
@@ -11253,7 +11347,7 @@
 
 size_t  //
 sizeof__wuffs_zlib__decoder() {
-  return sizeof((wuffs_zlib__decoder){});
+  return sizeof(wuffs_zlib__decoder);
 }
 
 // ---------------- Function Implementations
@@ -11263,14 +11357,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
@@ -11278,13 +11372,13 @@
 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);
+  return wuffs_base__utility__make_range_ii_u64(1, 1);
 }
 
 // -------- func zlib.decoder.decode_io_writer
@@ -11349,7 +11443,7 @@
 
   uint32_t coro_susp_point = self->private_impl.p_decode_io_writer[0];
   if (coro_susp_point) {
-    v_checksum_got = self->private_impl.s_decode_io_writer[0].v_checksum_got;
+    v_checksum_got = self->private_data.s_decode_io_writer[0].v_checksum_got;
   }
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
@@ -11361,14 +11455,14 @@
         t_0 = wuffs_base__load_u16be(iop_a_src);
         iop_a_src += 2;
       } else {
-        self->private_impl.s_decode_io_writer[0].scratch = 0;
+        self->private_data.s_decode_io_writer[0].scratch = 0;
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
         while (true) {
           if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
             status = wuffs_base__suspension__short_read;
             goto suspend;
           }
-          uint64_t* scratch = &self->private_impl.s_decode_io_writer[0].scratch;
+          uint64_t* scratch = &self->private_data.s_decode_io_writer[0].scratch;
           uint32_t num_bits_0 = *scratch & 0xFF;
           *scratch >>= 8;
           *scratch <<= 8;
@@ -11411,7 +11505,7 @@
               iop_a_src - a_src.private_impl.buf->data.ptr;
         }
         wuffs_base__status t_1 = wuffs_deflate__decoder__decode_io_writer(
-            &self->private_impl.f_flate, a_dst, a_src, a_workbuf);
+            &self->private_data.f_flate, a_dst, a_src, a_workbuf);
         if (a_dst.private_impl.buf) {
           iop_a_dst = a_dst.private_impl.buf->data.ptr +
                       a_dst.private_impl.buf->meta.wi;
@@ -11424,7 +11518,7 @@
       }
       if (!self->private_impl.f_ignore_checksum) {
         v_checksum_got = wuffs_adler32__hasher__update(
-            &self->private_impl.f_checksum,
+            &self->private_data.f_checksum,
             ((wuffs_base__slice_u8){
                 .ptr = a_dst.private_impl.mark,
                 .len = (size_t)(iop_a_dst - a_dst.private_impl.mark),
@@ -11444,14 +11538,14 @@
         t_2 = wuffs_base__load_u32be(iop_a_src);
         iop_a_src += 4;
       } else {
-        self->private_impl.s_decode_io_writer[0].scratch = 0;
+        self->private_data.s_decode_io_writer[0].scratch = 0;
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
         while (true) {
           if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) {
             status = wuffs_base__suspension__short_read;
             goto suspend;
           }
-          uint64_t* scratch = &self->private_impl.s_decode_io_writer[0].scratch;
+          uint64_t* scratch = &self->private_data.s_decode_io_writer[0].scratch;
           uint32_t num_bits_2 = *scratch & 0xFF;
           *scratch >>= 8;
           *scratch <<= 8;
@@ -11482,7 +11576,7 @@
 suspend:
   self->private_impl.p_decode_io_writer[0] = coro_susp_point;
   self->private_impl.active_coroutine = 1;
-  self->private_impl.s_decode_io_writer[0].v_checksum_got = v_checksum_got;
+  self->private_data.s_decode_io_writer[0].v_checksum_got = v_checksum_got;
 
   goto exit;
 exit: