diff --git a/release/c/wuffs-v0.3.c b/release/c/wuffs-v0.3.c
index 11db258..7521324 100644
--- a/release/c/wuffs-v0.3.c
+++ b/release/c/wuffs-v0.3.c
@@ -85,15 +85,15 @@
 // each major.minor branch, the commit count should increase monotonically.
 //
 // WUFFS_VERSION was overridden by "wuffs gen -version" based on revision
-// adfd2965cc104f3de6cccaed5095721d042c1251 committed on 2022-01-18.
+// 3ff4bf46746fff230d4704f8c5a35a1665ddbd56 committed on 2022-06-03.
 #define WUFFS_VERSION 0x000030000
 #define WUFFS_VERSION_MAJOR 0
 #define WUFFS_VERSION_MINOR 3
 #define WUFFS_VERSION_PATCH 0
-#define WUFFS_VERSION_PRE_RELEASE_LABEL "beta.14"
-#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3273
-#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20220118
-#define WUFFS_VERSION_STRING "0.3.0-beta.14+3273.20220118"
+#define WUFFS_VERSION_PRE_RELEASE_LABEL "beta.15"
+#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3345
+#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20220603
+#define WUFFS_VERSION_STRING "0.3.0-beta.15+3345.20220603"
 
 // ---------------- Configuration
 
@@ -1461,6 +1461,38 @@
 }
 
 static inline wuffs_base__slice_u8  //
+wuffs_base__make_slice_u8_ij(uint8_t* ptr, size_t i, size_t j) {
+  wuffs_base__slice_u8 ret;
+  ret.ptr = ptr + i;
+  ret.len = (j >= i) ? (j - i) : 0;
+  return ret;
+}
+
+static inline wuffs_base__slice_u16  //
+wuffs_base__make_slice_u16_ij(uint16_t* ptr, size_t i, size_t j) {
+  wuffs_base__slice_u16 ret;
+  ret.ptr = ptr + i;
+  ret.len = (j >= i) ? (j - i) : 0;
+  return ret;
+}
+
+static inline wuffs_base__slice_u32  //
+wuffs_base__make_slice_u32_ij(uint32_t* ptr, size_t i, size_t j) {
+  wuffs_base__slice_u32 ret;
+  ret.ptr = ptr + i;
+  ret.len = (j >= i) ? (j - i) : 0;
+  return ret;
+}
+
+static inline wuffs_base__slice_u64  //
+wuffs_base__make_slice_u64_ij(uint64_t* ptr, size_t i, size_t j) {
+  wuffs_base__slice_u64 ret;
+  ret.ptr = ptr + i;
+  ret.len = (j >= i) ? (j - i) : 0;
+  return ret;
+}
+
+static inline wuffs_base__slice_u8  //
 wuffs_base__empty_slice_u8() {
   wuffs_base__slice_u8 ret;
   ret.ptr = NULL;
@@ -6635,7 +6667,6 @@
       uint64_t scratch;
     } s_decode_image_config[1];
     struct {
-      wuffs_base__status v_status;
       uint64_t scratch;
     } s_decode_frame[1];
     struct {
@@ -6791,6 +6822,272 @@
 
 // ---------------- Status Codes
 
+extern const char wuffs_bzip2__error__bad_huffman_code_over_subscribed[];
+extern const char wuffs_bzip2__error__bad_huffman_code_under_subscribed[];
+extern const char wuffs_bzip2__error__bad_block_header[];
+extern const char wuffs_bzip2__error__bad_block_length[];
+extern const char wuffs_bzip2__error__bad_checksum[];
+extern const char wuffs_bzip2__error__bad_header[];
+extern const char wuffs_bzip2__error__bad_number_of_huffman_codes[];
+extern const char wuffs_bzip2__error__bad_number_of_sections[];
+extern const char wuffs_bzip2__error__unsupported_huffman_code[];
+extern const char wuffs_bzip2__error__unsupported_block_randomization[];
+
+// ---------------- Public Consts
+
+#define WUFFS_BZIP2__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0
+
+// ---------------- Struct Declarations
+
+typedef struct wuffs_bzip2__decoder__struct wuffs_bzip2__decoder;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// ---------------- Public Initializer Prototypes
+
+// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self,
+// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)".
+//
+// Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.
+// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
+
+wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
+wuffs_bzip2__decoder__initialize(
+    wuffs_bzip2__decoder* self,
+    size_t sizeof_star_self,
+    uint64_t wuffs_version,
+    uint32_t options);
+
+size_t
+sizeof__wuffs_bzip2__decoder();
+
+// ---------------- Allocs
+
+// These functions allocate and initialize Wuffs structs. They return NULL if
+// memory allocation fails. If they return non-NULL, there is no need to call
+// wuffs_foo__bar__initialize, but the caller is responsible for eventually
+// calling free on the returned pointer. That pointer is effectively a C++
+// std::unique_ptr<T, decltype(&free)>.
+
+wuffs_bzip2__decoder*
+wuffs_bzip2__decoder__alloc();
+
+static inline wuffs_base__io_transformer*
+wuffs_bzip2__decoder__alloc_as__wuffs_base__io_transformer() {
+  return (wuffs_base__io_transformer*)(wuffs_bzip2__decoder__alloc());
+}
+
+// ---------------- Upcasts
+
+static inline wuffs_base__io_transformer*
+wuffs_bzip2__decoder__upcast_as__wuffs_base__io_transformer(
+    wuffs_bzip2__decoder* p) {
+  return (wuffs_base__io_transformer*)p;
+}
+
+// ---------------- Public Function Prototypes
+
+WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
+wuffs_bzip2__decoder__set_quirk_enabled(
+    wuffs_bzip2__decoder* self,
+    uint32_t a_quirk,
+    bool a_enabled);
+
+WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64
+wuffs_bzip2__decoder__workbuf_len(
+    const wuffs_bzip2__decoder* self);
+
+WUFFS_BASE__MAYBE_STATIC wuffs_base__status
+wuffs_bzip2__decoder__transform_io(
+    wuffs_bzip2__decoder* self,
+    wuffs_base__io_buffer* a_dst,
+    wuffs_base__io_buffer* a_src,
+    wuffs_base__slice_u8 a_workbuf);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+// ---------------- Struct Definitions
+
+// These structs' fields, and the sizeof them, are private implementation
+// details that aren't guaranteed to be stable across Wuffs versions.
+//
+// See https://en.wikipedia.org/wiki/Opaque_pointer#C
+
+#if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION)
+
+struct wuffs_bzip2__decoder__struct {
+  // 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.
+
+  struct {
+    uint32_t magic;
+    uint32_t active_coroutine;
+    wuffs_base__vtable vtable_for__wuffs_base__io_transformer;
+    wuffs_base__vtable null_vtable;
+
+    uint32_t f_bits;
+    uint32_t f_n_bits;
+    uint32_t f_max_incl_block_size;
+    uint32_t f_block_size;
+    bool f_decode_huffman_finished;
+    uint8_t f_decode_huffman_which;
+    uint32_t f_decode_huffman_ticks;
+    uint32_t f_decode_huffman_section;
+    uint32_t f_decode_huffman_run_shift;
+    uint32_t f_flush_pointer;
+    uint32_t f_flush_repeat_count;
+    uint8_t f_flush_prev;
+    bool f_ignore_checksum;
+    uint32_t f_final_checksum_have;
+    uint32_t f_block_checksum_have;
+    uint32_t f_block_checksum_want;
+    uint32_t f_original_pointer;
+    uint32_t f_num_symbols;
+    uint32_t f_num_huffman_codes;
+    uint32_t f_num_sections;
+    uint32_t f_code_lengths_bitmask;
+
+    uint32_t p_transform_io[1];
+    uint32_t p_prepare_block[1];
+    uint32_t p_read_code_lengths[1];
+    uint32_t p_flush_slow[1];
+    uint32_t p_decode_huffman_slow[1];
+  } private_impl;
+
+  struct {
+    uint32_t f_scratch;
+    uint32_t f_letter_counts[256];
+    uint8_t f_presence[256];
+    uint8_t f_mtft[256];
+    uint8_t f_huffman_selectors[32768];
+    uint16_t f_huffman_trees[6][1024][2];
+    uint16_t f_huffman_tables[6][256];
+    uint32_t f_bwt[1048576];
+
+    struct {
+      uint32_t v_i;
+      uint64_t v_tag;
+      uint32_t v_final_checksum_want;
+    } s_transform_io[1];
+    struct {
+      uint32_t v_i;
+      uint32_t v_selector;
+    } s_prepare_block[1];
+    struct {
+      uint32_t v_i;
+      uint32_t v_code_length;
+    } s_read_code_lengths[1];
+    struct {
+      uint32_t v_flush_pointer;
+      uint32_t v_flush_repeat_count;
+      uint8_t v_flush_prev;
+      uint32_t v_block_checksum_have;
+      uint32_t v_block_size;
+      uint8_t v_curr;
+      uint64_t scratch;
+    } s_flush_slow[1];
+    struct {
+      uint32_t v_node_index;
+    } s_decode_huffman_slow[1];
+  } private_data;
+
+#ifdef __cplusplus
+#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
+  using unique_ptr = std::unique_ptr<wuffs_bzip2__decoder, decltype(&free)>;
+
+  // On failure, the alloc_etc functions return nullptr. They don't throw.
+
+  static inline unique_ptr
+  alloc() {
+    return unique_ptr(wuffs_bzip2__decoder__alloc(), &free);
+  }
+
+  static inline wuffs_base__io_transformer::unique_ptr
+  alloc_as__wuffs_base__io_transformer() {
+    return wuffs_base__io_transformer::unique_ptr(
+        wuffs_bzip2__decoder__alloc_as__wuffs_base__io_transformer(), &free);
+  }
+#endif  // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
+
+#if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION)
+  // Disallow constructing or copying an object via standard C++ mechanisms,
+  // e.g. the "new" operator, as this struct is intentionally opaque. Its total
+  // size and field layout is not part of the public, stable, memory-safe API.
+  // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and
+  // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as
+  // their first argument) rather than tweaking bar.private_impl.qux fields.
+  //
+  // In C, we can just leave wuffs_foo__bar as an incomplete type (unless
+  // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in
+  // order to provide convenience methods. These forward on "this", so that you
+  // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)".
+  wuffs_bzip2__decoder__struct() = delete;
+  wuffs_bzip2__decoder__struct(const wuffs_bzip2__decoder__struct&) = delete;
+  wuffs_bzip2__decoder__struct& operator=(
+      const wuffs_bzip2__decoder__struct&) = delete;
+#endif  // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION)
+
+#if !defined(WUFFS_IMPLEMENTATION)
+  // As above, the size of the struct is not part of the public API, and unless
+  // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap
+  // allocated, not stack allocated. Its size is not intended to be known at
+  // compile time, but it is unfortunately divulged as a side effect of
+  // defining C++ convenience methods. Use "sizeof__T()", calling the function,
+  // instead of "sizeof T", invoking the operator. To make the two values
+  // different, so that passing the latter will be rejected by the initialize
+  // function, we add an arbitrary amount of dead weight.
+  uint8_t dead_weight[123000000];  // 123 MB.
+#endif  // !defined(WUFFS_IMPLEMENTATION)
+
+  inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
+  initialize(
+      size_t sizeof_star_self,
+      uint64_t wuffs_version,
+      uint32_t options) {
+    return wuffs_bzip2__decoder__initialize(
+        this, sizeof_star_self, wuffs_version, options);
+  }
+
+  inline wuffs_base__io_transformer*
+  upcast_as__wuffs_base__io_transformer() {
+    return (wuffs_base__io_transformer*)this;
+  }
+
+  inline wuffs_base__empty_struct
+  set_quirk_enabled(
+      uint32_t a_quirk,
+      bool a_enabled) {
+    return wuffs_bzip2__decoder__set_quirk_enabled(this, a_quirk, a_enabled);
+  }
+
+  inline wuffs_base__range_ii_u64
+  workbuf_len() const {
+    return wuffs_bzip2__decoder__workbuf_len(this);
+  }
+
+  inline wuffs_base__status
+  transform_io(
+      wuffs_base__io_buffer* a_dst,
+      wuffs_base__io_buffer* a_src,
+      wuffs_base__slice_u8 a_workbuf) {
+    return wuffs_bzip2__decoder__transform_io(this, a_dst, a_src, a_workbuf);
+  }
+
+#endif  // __cplusplus
+};  // struct wuffs_bzip2__decoder__struct
+
+#endif  // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION)
+
+// ---------------- Status Codes
+
 extern const char wuffs_cbor__error__bad_input[];
 extern const char wuffs_cbor__error__unsupported_recursion_depth[];
 
@@ -6922,7 +7219,6 @@
     struct {
       uint64_t v_string_length;
       uint32_t v_depth;
-      uint32_t v_token_length;
       bool v_tagged;
       uint8_t v_indefinite_string_major_type;
     } s_decode_tokens[1];
@@ -7355,7 +7651,6 @@
       uint32_t v_n_clen;
       uint32_t v_i;
       uint32_t v_mask;
-      uint32_t v_table_entry;
       uint32_t v_n_extra_bits;
       uint8_t v_rep_symbol;
       uint32_t v_rep_count;
@@ -7363,7 +7658,6 @@
     struct {
       uint32_t v_bits;
       uint32_t v_n_bits;
-      uint32_t v_table_entry;
       uint32_t v_table_entry_n_bits;
       uint32_t v_lmask;
       uint32_t v_dmask;
@@ -7371,7 +7665,6 @@
       uint32_t v_redir_mask;
       uint32_t v_length;
       uint32_t v_dist_minus_1;
-      uint32_t v_hlen;
       uint64_t scratch;
     } s_decode_huffman_slow[1];
   } private_data;
@@ -7879,16 +8172,14 @@
     uint32_t f_width;
     uint32_t f_height;
     uint8_t f_call_sequence;
-    bool f_ignore_metadata;
     bool f_report_metadata_iccp;
     bool f_report_metadata_xmp;
     uint32_t f_metadata_fourcc;
     uint64_t f_metadata_io_position;
     bool f_quirks[7];
     bool f_delayed_num_decoded_frames;
-    bool f_end_of_data;
-    bool f_restarted;
     bool f_previous_lzw_decode_ended_abruptly;
+    bool f_seen_header;
     bool f_has_global_palette;
     uint8_t f_interlace;
     bool f_seen_num_animation_loops_value;
@@ -7979,7 +8270,6 @@
     struct {
       uint64_t v_block_size;
       bool v_need_block_size;
-      wuffs_base__status v_lzw_status;
       uint64_t scratch;
     } s_decode_id_part2[1];
   } private_data;
@@ -8520,9 +8810,6 @@
       uint32_t v_expect;
       uint32_t v_expect_after_value;
     } s_decode_tokens[1];
-    struct {
-      uint32_t v_neg;
-    } s_decode_inf_nan[1];
   } private_data;
 
 #ifdef __cplusplus
@@ -9180,12 +9467,13 @@
 extern const char wuffs_png__error__bad_header[];
 extern const char wuffs_png__error__bad_text_chunk_not_latin_1[];
 extern const char wuffs_png__error__missing_palette[];
+extern const char wuffs_png__error__unsupported_cgbi_extension[];
 extern const char wuffs_png__error__unsupported_png_compression_method[];
 extern const char wuffs_png__error__unsupported_png_file[];
 
 // ---------------- Public Consts
 
-#define WUFFS_PNG__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0
+#define WUFFS_PNG__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 2251799562027015
 
 #define WUFFS_PNG__DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL 8
 
@@ -9360,6 +9648,7 @@
     bool f_seen_gama;
     bool f_seen_iccp;
     bool f_seen_idat;
+    bool f_seen_ihdr;
     bool f_seen_plte;
     bool f_seen_srgb;
     bool f_seen_trns;
@@ -16060,8 +16349,9 @@
   // strings). The strings may contain NUL bytes, so the "const char* magic"
   // value starts with the length-minus-1 of the 'magic number'.
   //
-  // Keep it sorted by magic[1], then magic[0] descending and finally by
-  // magic[2:]. When multiple entries match, the longest one wins.
+  // Keep it sorted by magic[1], then magic[0] descending (prioritizing longer
+  // matches) and finally by magic[2:]. When multiple entries match, the
+  // longest one wins.
   //
   // The fourcc field might be negated, in which case there's further
   // specialization (see § below).
@@ -16070,6 +16360,9 @@
     const char* magic;
   } table[] = {
       {-0x30302020, "\x01\x00\x00"},          // '00  'be
+      {+0x475A2020, "\x02\x1F\x8B\x08"},      // GZ
+      {+0x5A535444, "\x03\x28\xB5\x2F\xFD"},  // ZSTD
+      {+0x425A3220, "\x02\x42\x5A\x68"},      // BZ2
       {+0x424D5020, "\x01\x42\x4D"},          // BMP
       {+0x47494620, "\x03\x47\x49\x46\x38"},  // GIF
       {+0x54494646, "\x03\x49\x49\x2A\x00"},  // TIFF (little-endian)
@@ -16077,6 +16370,7 @@
       {-0x52494646, "\x03\x52\x49\x46\x46"},  // RIFF
       {+0x4E494520, "\x02\x6E\xC3\xAF"},      // NIE
       {+0x514F4920, "\x03\x71\x6F\x69\x66"},  // QOI
+      {+0x5A4C4942, "\x01\x78\x9C"},          // ZLIB
       {+0x504E4720, "\x03\x89\x50\x4E\x47"},  // PNG
       {+0x4A504547, "\x01\xFF\xD8"},          // JPEG
   };
@@ -23213,7 +23507,7 @@
           self->private_impl.f_frame_config_io_position,
           (self->private_impl.f_channel_masks[3] == 0));
     }
-    self->private_impl.f_call_sequence = 3;
+    self->private_impl.f_call_sequence = 32;
 
     ok:
     self->private_impl.p_decode_image_config[0] = 0;
@@ -23280,7 +23574,8 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    if (self->private_impl.f_call_sequence < 3) {
+    if (self->private_impl.f_call_sequence == 32) {
+    } else if (self->private_impl.f_call_sequence < 32) {
       if (a_src) {
         a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
       }
@@ -23292,13 +23587,13 @@
       if (status.repr) {
         goto suspend;
       }
-    } else if (self->private_impl.f_call_sequence == 3) {
+    } else if (self->private_impl.f_call_sequence == 40) {
       if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
         status = wuffs_base__make_status(wuffs_base__error__bad_restart);
         goto exit;
       }
-    } else if (self->private_impl.f_call_sequence == 4) {
-      self->private_impl.f_call_sequence = 255;
+    } else if (self->private_impl.f_call_sequence == 64) {
+      self->private_impl.f_call_sequence = 96;
       status = wuffs_base__make_status(wuffs_base__note__end_of_data);
       goto ok;
     } else {
@@ -23321,7 +23616,7 @@
           false,
           4278190080);
     }
-    self->private_impl.f_call_sequence = 4;
+    self->private_impl.f_call_sequence = 64;
 
     ok:
     self->private_impl.p_decode_frame_config[0] = 0;
@@ -23390,13 +23685,11 @@
   }
 
   uint32_t coro_susp_point = self->private_impl.p_decode_frame[0];
-  if (coro_susp_point) {
-    v_status = self->private_data.s_decode_frame[0].v_status;
-  }
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    if (self->private_impl.f_call_sequence < 4) {
+    if (self->private_impl.f_call_sequence == 64) {
+    } else if (self->private_impl.f_call_sequence < 64) {
       if (a_src) {
         a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
       }
@@ -23408,7 +23701,6 @@
       if (status.repr) {
         goto suspend;
       }
-    } else if (self->private_impl.f_call_sequence == 4) {
     } else {
       status = wuffs_base__make_status(wuffs_base__note__end_of_data);
       goto ok;
@@ -23433,7 +23725,7 @@
       }
       v_status = wuffs_base__pixel_swizzler__prepare(&self->private_impl.f_swizzler,
           wuffs_base__pixel_buffer__pixel_format(a_dst),
-          wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8((self->private_data.f_scratch) + 1024, 1024)),
+          wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8_ij(self->private_data.f_scratch, 1024, 2048)),
           wuffs_base__utility__make_pixel_format(self->private_impl.f_src_pixfmt),
           wuffs_base__make_slice_u8(self->private_data.f_src_palette, 1024),
           a_blend);
@@ -23508,7 +23800,7 @@
       iop_a_src += self->private_data.s_decode_frame[0].scratch;
       self->private_impl.f_pending_pad = 0;
     }
-    self->private_impl.f_call_sequence = 255;
+    self->private_impl.f_call_sequence = 96;
 
     ok:
     self->private_impl.p_decode_frame[0] = 0;
@@ -23519,7 +23811,6 @@
   suspend:
   self->private_impl.p_decode_frame[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
   self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 3 : 0;
-  self->private_data.s_decode_frame[0].v_status = v_status;
 
   goto exit;
   exit:
@@ -23571,7 +23862,7 @@
   }
   v_dst_bytes_per_pixel = ((uint64_t)((v_dst_bits_per_pixel / 8)));
   v_dst_bytes_per_row = (((uint64_t)(self->private_impl.f_width)) * v_dst_bytes_per_pixel);
-  v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8((self->private_data.f_scratch) + 1024, 1024));
+  v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8_ij(self->private_data.f_scratch, 1024, 2048));
   v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
   label__outer__continue:;
   while (true) {
@@ -23678,7 +23969,7 @@
   }
   v_dst_bytes_per_pixel = ((uint64_t)((v_dst_bits_per_pixel / 8)));
   v_dst_bytes_per_row = (((uint64_t)(self->private_impl.f_width)) * v_dst_bytes_per_pixel);
-  v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8((self->private_data.f_scratch) + 1024, 1024));
+  v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8_ij(self->private_data.f_scratch, 1024, 2048));
   v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
   v_rle_state = self->private_impl.f_rle_state;
   label__outer__continue:;
@@ -23733,7 +24024,7 @@
                 v_p0 += 2;
               }
             }
-            wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__slice_u8__subslice_j(wuffs_base__make_slice_u8(self->private_data.f_scratch, 2048), self->private_impl.f_rle_length));
+            wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__make_slice_u8(self->private_data.f_scratch, self->private_impl.f_rle_length));
             wuffs_base__u32__sat_add_indirect(&self->private_impl.f_dst_x, self->private_impl.f_rle_length);
             v_rle_state = 0;
             goto label__middle__continue;
@@ -23789,7 +24080,7 @@
                 v_chunk_count -= 1;
               }
               v_p0 = wuffs_base__u32__min(v_p0, self->private_impl.f_rle_length);
-              wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__slice_u8__subslice_j(wuffs_base__make_slice_u8(self->private_data.f_scratch, 2048), v_p0));
+              wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__make_slice_u8(self->private_data.f_scratch, v_p0));
               wuffs_base__u32__sat_add_indirect(&self->private_impl.f_dst_x, v_p0);
               wuffs_base__u32__sat_sub_indirect(&self->private_impl.f_rle_length, v_p0);
             }
@@ -23940,7 +24231,7 @@
   }
   v_dst_bytes_per_pixel = ((uint64_t)((v_dst_bits_per_pixel / 8)));
   v_dst_bytes_per_row = (((uint64_t)(self->private_impl.f_width)) * v_dst_bytes_per_pixel);
-  v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8((self->private_data.f_scratch) + 1024, 1024));
+  v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8_ij(self->private_data.f_scratch, 1024, 2048));
   v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
   label__outer__continue:;
   while (true) {
@@ -24013,7 +24304,7 @@
       if (v_i >= ((uint64_t)(v_dst.len))) {
         goto label__inner__continue;
       }
-      v_n = wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__slice_u8__subslice_j(wuffs_base__make_slice_u8(self->private_data.f_scratch, 2048), (8 * v_p0)));
+      v_n = wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), v_dst_palette, wuffs_base__make_slice_u8(self->private_data.f_scratch, (8 * v_p0)));
       if (v_n == 0) {
         status = wuffs_base__make_status(wuffs_bmp__note__internal_note_short_read);
         goto ok;
@@ -24076,7 +24367,7 @@
   }
   v_dst_bytes_per_pixel = ((uint64_t)((v_dst_bits_per_pixel / 8)));
   v_dst_bytes_per_row = (((uint64_t)(self->private_impl.f_width)) * v_dst_bytes_per_pixel);
-  v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8((self->private_data.f_scratch) + 1024, 1024));
+  v_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8_ij(self->private_data.f_scratch, 1024, 2048));
   v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0);
   label__loop__continue:;
   while (true) {
@@ -24182,7 +24473,7 @@
       }
     }
     v_p0 = wuffs_base__u32__min(v_p0, wuffs_base__u32__sat_sub(self->private_impl.f_width, self->private_impl.f_dst_x));
-    v_n = wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__slice_u8__subslice_j(wuffs_base__make_slice_u8(self->private_data.f_scratch, 2048), v_p0));
+    v_n = wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__make_slice_u8(self->private_data.f_scratch, v_p0));
     if (v_n == 0) {
       status = wuffs_base__make_status(wuffs_bmp__note__internal_note_short_read);
       goto ok;
@@ -24252,7 +24543,7 @@
     return 0;
   }
 
-  if (self->private_impl.f_call_sequence > 3) {
+  if (self->private_impl.f_call_sequence > 32) {
     return 1;
   }
   return 0;
@@ -24271,7 +24562,7 @@
     return 0;
   }
 
-  if (self->private_impl.f_call_sequence > 4) {
+  if (self->private_impl.f_call_sequence > 64) {
     return 1;
   }
   return 0;
@@ -24294,13 +24585,13 @@
         : wuffs_base__error__initialize_not_called);
   }
 
-  if (self->private_impl.f_call_sequence < 3) {
+  if (self->private_impl.f_call_sequence < 32) {
     return wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
   }
   if (a_index != 0) {
     return wuffs_base__make_status(wuffs_base__error__bad_argument);
   }
-  self->private_impl.f_call_sequence = 3;
+  self->private_impl.f_call_sequence = 40;
   self->private_impl.f_frame_config_io_position = a_io_position;
   return wuffs_base__make_status(NULL);
 }
@@ -24566,6 +24857,1550 @@
 
 #endif  // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BMP)
 
+#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BZIP2)
+
+// ---------------- Status Codes Implementations
+
+const char wuffs_bzip2__error__bad_huffman_code_over_subscribed[] = "#bzip2: bad Huffman code (over-subscribed)";
+const char wuffs_bzip2__error__bad_huffman_code_under_subscribed[] = "#bzip2: bad Huffman code (under-subscribed)";
+const char wuffs_bzip2__error__bad_block_header[] = "#bzip2: bad block header";
+const char wuffs_bzip2__error__bad_block_length[] = "#bzip2: bad block length";
+const char wuffs_bzip2__error__bad_checksum[] = "#bzip2: bad checksum";
+const char wuffs_bzip2__error__bad_header[] = "#bzip2: bad header";
+const char wuffs_bzip2__error__bad_number_of_huffman_codes[] = "#bzip2: bad number of Huffman codes";
+const char wuffs_bzip2__error__bad_number_of_sections[] = "#bzip2: bad number of sections";
+const char wuffs_bzip2__error__unsupported_huffman_code[] = "#bzip2: unsupported Huffman code";
+const char wuffs_bzip2__error__unsupported_block_randomization[] = "#bzip2: unsupported block randomization";
+const char wuffs_bzip2__error__internal_error_inconsistent_huffman_decoder_state[] = "#bzip2: internal error: inconsistent Huffman decoder state";
+
+// ---------------- Private Consts
+
+static const uint8_t
+WUFFS_BZIP2__CLAMP_TO_5[8] WUFFS_BASE__POTENTIALLY_UNUSED = {
+  0, 1, 2, 3, 4, 5, 5, 5,
+};
+
+static const uint32_t
+WUFFS_BZIP2__REV_CRC32_TABLE[256] WUFFS_BASE__POTENTIALLY_UNUSED = {
+  0, 79764919, 159529838, 222504665, 319059676, 398814059, 445009330, 507990021,
+  638119352, 583659535, 797628118, 726387553, 890018660, 835552979, 1015980042, 944750013,
+  1276238704, 1221641927, 1167319070, 1095957929, 1595256236, 1540665371, 1452775106, 1381403509,
+  1780037320, 1859660671, 1671105958, 1733955601, 2031960084, 2111593891, 1889500026, 1952343757,
+  2552477408, 2632100695, 2443283854, 2506133561, 2334638140, 2414271883, 2191915858, 2254759653,
+  3190512472, 3135915759, 3081330742, 3009969537, 2905550212, 2850959411, 2762807018, 2691435357,
+  3560074640, 3505614887, 3719321342, 3648080713, 3342211916, 3287746299, 3467911202, 3396681109,
+  4063920168, 4143685023, 4223187782, 4286162673, 3779000052, 3858754371, 3904687514, 3967668269,
+  881225847, 809987520, 1023691545, 969234094, 662832811, 591600412, 771767749, 717299826,
+  311336399, 374308984, 453813921, 533576470, 25881363, 88864420, 134795389, 214552010,
+  2023205639, 2086057648, 1897238633, 1976864222, 1804852699, 1867694188, 1645340341, 1724971778,
+  1587496639, 1516133128, 1461550545, 1406951526, 1302016099, 1230646740, 1142491917, 1087903418,
+  2896545431, 2825181984, 2770861561, 2716262478, 3215044683, 3143675388, 3055782693, 3001194130,
+  2326604591, 2389456536, 2200899649, 2280525302, 2578013683, 2640855108, 2418763421, 2498394922,
+  3769900519, 3832873040, 3912640137, 3992402750, 4088425275, 4151408268, 4197601365, 4277358050,
+  3334271071, 3263032808, 3476998961, 3422541446, 3585640067, 3514407732, 3694837229, 3640369242,
+  1762451694, 1842216281, 1619975040, 1682949687, 2047383090, 2127137669, 1938468188, 2001449195,
+  1325665622, 1271206113, 1183200824, 1111960463, 1543535498, 1489069629, 1434599652, 1363369299,
+  622672798, 568075817, 748617968, 677256519, 907627842, 853037301, 1067152940, 995781531,
+  51762726, 131386257, 177728840, 240578815, 269590778, 349224269, 429104020, 491947555,
+  4046411278, 4126034873, 4172115296, 4234965207, 3794477266, 3874110821, 3953728444, 4016571915,
+  3609705398, 3555108353, 3735388376, 3664026991, 3290680682, 3236090077, 3449943556, 3378572211,
+  3174993278, 3120533705, 3032266256, 2961025959, 2923101090, 2868635157, 2813903052, 2742672763,
+  2604032198, 2683796849, 2461293480, 2524268063, 2284983834, 2364738477, 2175806836, 2238787779,
+  1569362073, 1498123566, 1409854455, 1355396672, 1317987909, 1246755826, 1192025387, 1137557660,
+  2072149281, 2135122070, 1912620623, 1992383480, 1753615357, 1816598090, 1627664531, 1707420964,
+  295390185, 358241886, 404320391, 483945776, 43990325, 106832002, 186451547, 266083308,
+  932423249, 861060070, 1041341759, 986742920, 613929101, 542559546, 756411363, 701822548,
+  3316196985, 3244833742, 3425377559, 3370778784, 3601682597, 3530312978, 3744426955, 3689838204,
+  3819031489, 3881883254, 3928223919, 4007849240, 4037393693, 4100235434, 4180117107, 4259748804,
+  2310601993, 2373574846, 2151335527, 2231098320, 2596047829, 2659030626, 2470359227, 2550115596,
+  2947551409, 2876312838, 2788305887, 2733848168, 3165939309, 3094707162, 3040238851, 2985771188,
+};
+
+// ---------------- Private Initializer Prototypes
+
+// ---------------- Private Function Prototypes
+
+static wuffs_base__status
+wuffs_bzip2__decoder__prepare_block(
+    wuffs_bzip2__decoder* self,
+    wuffs_base__io_buffer* a_src);
+
+static wuffs_base__status
+wuffs_bzip2__decoder__read_code_lengths(
+    wuffs_bzip2__decoder* self,
+    wuffs_base__io_buffer* a_src);
+
+static wuffs_base__status
+wuffs_bzip2__decoder__build_huffman_tree(
+    wuffs_bzip2__decoder* self,
+    uint32_t a_which);
+
+static wuffs_base__empty_struct
+wuffs_bzip2__decoder__build_huffman_table(
+    wuffs_bzip2__decoder* self,
+    uint32_t a_which);
+
+static wuffs_base__empty_struct
+wuffs_bzip2__decoder__invert_bwt(
+    wuffs_bzip2__decoder* self);
+
+static wuffs_base__empty_struct
+wuffs_bzip2__decoder__flush_fast(
+    wuffs_bzip2__decoder* self,
+    wuffs_base__io_buffer* a_dst);
+
+static wuffs_base__status
+wuffs_bzip2__decoder__flush_slow(
+    wuffs_bzip2__decoder* self,
+    wuffs_base__io_buffer* a_dst);
+
+static wuffs_base__status
+wuffs_bzip2__decoder__decode_huffman_fast(
+    wuffs_bzip2__decoder* self,
+    wuffs_base__io_buffer* a_src);
+
+static wuffs_base__status
+wuffs_bzip2__decoder__decode_huffman_slow(
+    wuffs_bzip2__decoder* self,
+    wuffs_base__io_buffer* a_src);
+
+// ---------------- VTables
+
+const wuffs_base__io_transformer__func_ptrs
+wuffs_bzip2__decoder__func_ptrs_for__wuffs_base__io_transformer = {
+  (wuffs_base__empty_struct(*)(void*,
+      uint32_t,
+      bool))(&wuffs_bzip2__decoder__set_quirk_enabled),
+  (wuffs_base__status(*)(void*,
+      wuffs_base__io_buffer*,
+      wuffs_base__io_buffer*,
+      wuffs_base__slice_u8))(&wuffs_bzip2__decoder__transform_io),
+  (wuffs_base__range_ii_u64(*)(const void*))(&wuffs_bzip2__decoder__workbuf_len),
+};
+
+// ---------------- Initializer Implementations
+
+wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
+wuffs_bzip2__decoder__initialize(
+    wuffs_bzip2__decoder* self,
+    size_t sizeof_star_self,
+    uint64_t wuffs_version,
+    uint32_t options){
+  if (!self) {
+    return wuffs_base__make_status(wuffs_base__error__bad_receiver);
+  }
+  if (sizeof(*self) != sizeof_star_self) {
+    return wuffs_base__make_status(wuffs_base__error__bad_sizeof_receiver);
+  }
+  if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) ||
+      (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
+    return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
+  }
+
+  if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
+    // The whole point of this if-check is to detect an uninitialized *self.
+    // We disable the warning on GCC. Clang-5.0 does not have this warning.
+#if !defined(__clang__) && defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+    if (self->private_impl.magic != 0) {
+      return wuffs_base__make_status(wuffs_base__error__initialize_falsely_claimed_already_zeroed);
+    }
+#if !defined(__clang__) && defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+  } else {
+    if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
+      memset(self, 0, sizeof(*self));
+      options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
+    } else {
+      memset(&(self->private_impl), 0, sizeof(self->private_impl));
+    }
+  }
+
+  self->private_impl.magic = WUFFS_BASE__MAGIC;
+  self->private_impl.vtable_for__wuffs_base__io_transformer.vtable_name =
+      wuffs_base__io_transformer__vtable_name;
+  self->private_impl.vtable_for__wuffs_base__io_transformer.function_pointers =
+      (const void*)(&wuffs_bzip2__decoder__func_ptrs_for__wuffs_base__io_transformer);
+  return wuffs_base__make_status(NULL);
+}
+
+wuffs_bzip2__decoder*
+wuffs_bzip2__decoder__alloc() {
+  wuffs_bzip2__decoder* x =
+      (wuffs_bzip2__decoder*)(calloc(sizeof(wuffs_bzip2__decoder), 1));
+  if (!x) {
+    return NULL;
+  }
+  if (wuffs_bzip2__decoder__initialize(
+      x, sizeof(wuffs_bzip2__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED).repr) {
+    free(x);
+    return NULL;
+  }
+  return x;
+}
+
+size_t
+sizeof__wuffs_bzip2__decoder() {
+  return sizeof(wuffs_bzip2__decoder);
+}
+
+// ---------------- Function Implementations
+
+// -------- func bzip2.decoder.set_quirk_enabled
+
+WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
+wuffs_bzip2__decoder__set_quirk_enabled(
+    wuffs_bzip2__decoder* self,
+    uint32_t a_quirk,
+    bool a_enabled) {
+  if (!self) {
+    return wuffs_base__make_empty_struct();
+  }
+  if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
+    return wuffs_base__make_empty_struct();
+  }
+
+  if (a_quirk == 1) {
+    self->private_impl.f_ignore_checksum = a_enabled;
+  }
+  return wuffs_base__make_empty_struct();
+}
+
+// -------- func bzip2.decoder.workbuf_len
+
+WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64
+wuffs_bzip2__decoder__workbuf_len(
+    const wuffs_bzip2__decoder* self) {
+  if (!self) {
+    return wuffs_base__utility__empty_range_ii_u64();
+  }
+  if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
+      (self->private_impl.magic != WUFFS_BASE__DISABLED)) {
+    return wuffs_base__utility__empty_range_ii_u64();
+  }
+
+  return wuffs_base__utility__make_range_ii_u64(0, 0);
+}
+
+// -------- func bzip2.decoder.transform_io
+
+WUFFS_BASE__MAYBE_STATIC wuffs_base__status
+wuffs_bzip2__decoder__transform_io(
+    wuffs_bzip2__decoder* self,
+    wuffs_base__io_buffer* a_dst,
+    wuffs_base__io_buffer* a_src,
+    wuffs_base__slice_u8 a_workbuf) {
+  if (!self) {
+    return wuffs_base__make_status(wuffs_base__error__bad_receiver);
+  }
+  if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
+    return wuffs_base__make_status(
+        (self->private_impl.magic == WUFFS_BASE__DISABLED)
+        ? wuffs_base__error__disabled_by_previous_error
+        : wuffs_base__error__initialize_not_called);
+  }
+  if (!a_dst || !a_src) {
+    self->private_impl.magic = WUFFS_BASE__DISABLED;
+    return wuffs_base__make_status(wuffs_base__error__bad_argument);
+  }
+  if ((self->private_impl.active_coroutine != 0) &&
+      (self->private_impl.active_coroutine != 1)) {
+    self->private_impl.magic = WUFFS_BASE__DISABLED;
+    return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
+  }
+  self->private_impl.active_coroutine = 0;
+  wuffs_base__status status = wuffs_base__make_status(NULL);
+
+  uint8_t v_c = 0;
+  uint32_t v_i = 0;
+  uint64_t v_tag = 0;
+  wuffs_base__status v_status = wuffs_base__make_status(NULL);
+  uint32_t v_final_checksum_want = 0;
+
+  const uint8_t* iop_a_src = NULL;
+  const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  if (a_src) {
+    io0_a_src = a_src->data.ptr;
+    io1_a_src = io0_a_src + a_src->meta.ri;
+    iop_a_src = io1_a_src;
+    io2_a_src = io0_a_src + a_src->meta.wi;
+  }
+
+  uint32_t coro_susp_point = self->private_impl.p_transform_io[0];
+  if (coro_susp_point) {
+    v_i = self->private_data.s_transform_io[0].v_i;
+    v_tag = self->private_data.s_transform_io[0].v_tag;
+    v_final_checksum_want = self->private_data.s_transform_io[0].v_final_checksum_want;
+  }
+  switch (coro_susp_point) {
+    WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
+
+    {
+      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
+      if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+        status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+        goto suspend;
+      }
+      uint8_t t_0 = *iop_a_src++;
+      v_c = t_0;
+    }
+    if (v_c != 66) {
+      status = wuffs_base__make_status(wuffs_bzip2__error__bad_header);
+      goto exit;
+    }
+    {
+      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
+      if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+        status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+        goto suspend;
+      }
+      uint8_t t_1 = *iop_a_src++;
+      v_c = t_1;
+    }
+    if (v_c != 90) {
+      status = wuffs_base__make_status(wuffs_bzip2__error__bad_header);
+      goto exit;
+    }
+    {
+      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
+      if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+        status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+        goto suspend;
+      }
+      uint8_t t_2 = *iop_a_src++;
+      v_c = t_2;
+    }
+    if (v_c != 104) {
+      status = wuffs_base__make_status(wuffs_bzip2__error__bad_header);
+      goto exit;
+    }
+    {
+      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
+      if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+        status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+        goto suspend;
+      }
+      uint8_t t_3 = *iop_a_src++;
+      v_c = t_3;
+    }
+    if ((v_c < 49) || (57 < v_c)) {
+      status = wuffs_base__make_status(wuffs_bzip2__error__bad_header);
+      goto exit;
+    }
+    self->private_impl.f_max_incl_block_size = (((uint32_t)((v_c - 48))) * 100000);
+    while (true) {
+      v_tag = 0;
+      v_i = 0;
+      while (v_i < 48) {
+        if (self->private_impl.f_n_bits <= 0) {
+          {
+            WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
+            if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+              status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+              goto suspend;
+            }
+            uint8_t t_4 = *iop_a_src++;
+            v_c = t_4;
+          }
+          self->private_impl.f_bits = (((uint32_t)(v_c)) << 24);
+          self->private_impl.f_n_bits = 8;
+        }
+        v_tag <<= 1;
+        v_tag |= ((uint64_t)((self->private_impl.f_bits >> 31)));
+        self->private_impl.f_bits <<= 1;
+        self->private_impl.f_n_bits -= 1;
+        v_i += 1;
+      }
+      if (v_tag == 25779555029136) {
+        goto label__0__break;
+      } else if (v_tag != 54156738319193) {
+        status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_header);
+        goto exit;
+      }
+      if (a_src) {
+        a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+      }
+      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
+      status = wuffs_bzip2__decoder__prepare_block(self, a_src);
+      if (a_src) {
+        iop_a_src = a_src->data.ptr + a_src->meta.ri;
+      }
+      if (status.repr) {
+        goto suspend;
+      }
+      self->private_impl.f_block_size = 0;
+      self->private_impl.f_decode_huffman_finished = false;
+      self->private_impl.f_decode_huffman_which = WUFFS_BZIP2__CLAMP_TO_5[(self->private_data.f_huffman_selectors[0] & 7)];
+      self->private_impl.f_decode_huffman_ticks = 50;
+      self->private_impl.f_decode_huffman_section = 0;
+      self->private_impl.f_decode_huffman_run_shift = 0;
+      while ( ! self->private_impl.f_decode_huffman_finished) {
+        if (a_src) {
+          a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+        }
+        v_status = wuffs_bzip2__decoder__decode_huffman_fast(self, a_src);
+        if (a_src) {
+          iop_a_src = a_src->data.ptr + a_src->meta.ri;
+        }
+        if (wuffs_base__status__is_error(&v_status)) {
+          status = v_status;
+          goto exit;
+        } else if (self->private_impl.f_decode_huffman_finished) {
+          goto label__1__break;
+        }
+        if (a_src) {
+          a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+        }
+        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
+        status = wuffs_bzip2__decoder__decode_huffman_slow(self, a_src);
+        if (a_src) {
+          iop_a_src = a_src->data.ptr + a_src->meta.ri;
+        }
+        if (status.repr) {
+          goto suspend;
+        }
+      }
+      label__1__break:;
+      wuffs_bzip2__decoder__invert_bwt(self);
+      self->private_impl.f_block_checksum_have = 4294967295;
+      if (self->private_impl.f_original_pointer >= self->private_impl.f_block_size) {
+        status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_length);
+        goto exit;
+      }
+      self->private_impl.f_flush_pointer = (self->private_data.f_bwt[self->private_impl.f_original_pointer] >> 12);
+      self->private_impl.f_flush_repeat_count = 0;
+      self->private_impl.f_flush_prev = 0;
+      while (self->private_impl.f_block_size > 0) {
+        wuffs_bzip2__decoder__flush_fast(self, a_dst);
+        if (self->private_impl.f_block_size <= 0) {
+          goto label__2__break;
+        }
+        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
+        status = wuffs_bzip2__decoder__flush_slow(self, a_dst);
+        if (status.repr) {
+          goto suspend;
+        }
+      }
+      label__2__break:;
+      self->private_impl.f_block_checksum_have ^= 4294967295;
+      if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_block_checksum_have != self->private_impl.f_block_checksum_want)) {
+        status = wuffs_base__make_status(wuffs_bzip2__error__bad_checksum);
+        goto exit;
+      }
+      self->private_impl.f_final_checksum_have = (self->private_impl.f_block_checksum_have ^ ((self->private_impl.f_final_checksum_have >> 31) | ((uint32_t)(self->private_impl.f_final_checksum_have << 1))));
+    }
+    label__0__break:;
+    v_final_checksum_want = 0;
+    v_i = 0;
+    while (v_i < 32) {
+      if (self->private_impl.f_n_bits <= 0) {
+        {
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
+          if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+            status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+            goto suspend;
+          }
+          uint8_t t_5 = *iop_a_src++;
+          v_c = t_5;
+        }
+        self->private_impl.f_bits = (((uint32_t)(v_c)) << 24);
+        self->private_impl.f_n_bits = 8;
+      }
+      v_final_checksum_want <<= 1;
+      v_final_checksum_want |= (self->private_impl.f_bits >> 31);
+      self->private_impl.f_bits <<= 1;
+      self->private_impl.f_n_bits -= 1;
+      v_i += 1;
+    }
+    if ( ! self->private_impl.f_ignore_checksum && (self->private_impl.f_final_checksum_have != v_final_checksum_want)) {
+      status = wuffs_base__make_status(wuffs_bzip2__error__bad_checksum);
+      goto exit;
+    }
+
+    goto ok;
+    ok:
+    self->private_impl.p_transform_io[0] = 0;
+    goto exit;
+  }
+
+  goto suspend;
+  suspend:
+  self->private_impl.p_transform_io[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
+  self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 1 : 0;
+  self->private_data.s_transform_io[0].v_i = v_i;
+  self->private_data.s_transform_io[0].v_tag = v_tag;
+  self->private_data.s_transform_io[0].v_final_checksum_want = v_final_checksum_want;
+
+  goto exit;
+  exit:
+  if (a_src) {
+    a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+  }
+
+  if (wuffs_base__status__is_error(&status)) {
+    self->private_impl.magic = WUFFS_BASE__DISABLED;
+  }
+  return status;
+}
+
+// -------- func bzip2.decoder.prepare_block
+
+static wuffs_base__status
+wuffs_bzip2__decoder__prepare_block(
+    wuffs_bzip2__decoder* self,
+    wuffs_base__io_buffer* a_src) {
+  wuffs_base__status status = wuffs_base__make_status(NULL);
+
+  uint8_t v_c = 0;
+  uint32_t v_i = 0;
+  uint32_t v_j = 0;
+  uint32_t v_selector = 0;
+  uint32_t v_sel_ff = 0;
+  uint8_t v_movee = 0;
+  wuffs_base__status v_status = wuffs_base__make_status(NULL);
+
+  const uint8_t* iop_a_src = NULL;
+  const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  if (a_src) {
+    io0_a_src = a_src->data.ptr;
+    io1_a_src = io0_a_src + a_src->meta.ri;
+    iop_a_src = io1_a_src;
+    io2_a_src = io0_a_src + a_src->meta.wi;
+  }
+
+  uint32_t coro_susp_point = self->private_impl.p_prepare_block[0];
+  if (coro_susp_point) {
+    v_i = self->private_data.s_prepare_block[0].v_i;
+    v_selector = self->private_data.s_prepare_block[0].v_selector;
+  }
+  switch (coro_susp_point) {
+    WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
+
+    self->private_impl.f_block_checksum_want = 0;
+    v_i = 0;
+    while (v_i < 32) {
+      if (self->private_impl.f_n_bits <= 0) {
+        {
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
+          if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+            status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+            goto suspend;
+          }
+          uint8_t t_0 = *iop_a_src++;
+          v_c = t_0;
+        }
+        self->private_impl.f_bits = (((uint32_t)(v_c)) << 24);
+        self->private_impl.f_n_bits = 8;
+      }
+      self->private_impl.f_block_checksum_want <<= 1;
+      self->private_impl.f_block_checksum_want |= (self->private_impl.f_bits >> 31);
+      self->private_impl.f_bits <<= 1;
+      self->private_impl.f_n_bits -= 1;
+      v_i += 1;
+    }
+    if (self->private_impl.f_n_bits <= 0) {
+      {
+        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
+        if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+          status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+          goto suspend;
+        }
+        uint8_t t_1 = *iop_a_src++;
+        v_c = t_1;
+      }
+      self->private_impl.f_bits = (((uint32_t)(v_c)) << 24);
+      self->private_impl.f_n_bits = 8;
+    }
+    if ((self->private_impl.f_bits >> 31) != 0) {
+      status = wuffs_base__make_status(wuffs_bzip2__error__unsupported_block_randomization);
+      goto exit;
+    }
+    self->private_impl.f_bits <<= 1;
+    self->private_impl.f_n_bits -= 1;
+    self->private_impl.f_original_pointer = 0;
+    v_i = 0;
+    while (v_i < 24) {
+      if (self->private_impl.f_n_bits <= 0) {
+        {
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
+          if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+            status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+            goto suspend;
+          }
+          uint8_t t_2 = *iop_a_src++;
+          v_c = t_2;
+        }
+        self->private_impl.f_bits = (((uint32_t)(v_c)) << 24);
+        self->private_impl.f_n_bits = 8;
+      }
+      self->private_impl.f_original_pointer <<= 1;
+      self->private_impl.f_original_pointer |= (self->private_impl.f_bits >> 31);
+      self->private_impl.f_bits <<= 1;
+      self->private_impl.f_n_bits -= 1;
+      v_i += 1;
+    }
+    v_i = 0;
+    while (v_i < 256) {
+      self->private_data.f_presence[v_i] = 0;
+      v_i += 1;
+    }
+    v_i = 0;
+    while (v_i < 256) {
+      if (self->private_impl.f_n_bits <= 0) {
+        {
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
+          if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+            status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+            goto suspend;
+          }
+          uint8_t t_3 = *iop_a_src++;
+          v_c = t_3;
+        }
+        self->private_impl.f_bits = (((uint32_t)(v_c)) << 24);
+        self->private_impl.f_n_bits = 8;
+      }
+      if ((self->private_impl.f_bits >> 31) != 0) {
+        self->private_data.f_presence[v_i] = 1;
+      }
+      self->private_impl.f_bits <<= 1;
+      self->private_impl.f_n_bits -= 1;
+      v_i += 16;
+    }
+    self->private_data.f_scratch = 0;
+    v_i = 0;
+    label__0__continue:;
+    while (v_i < 256) {
+      if (self->private_data.f_presence[v_i] == 0) {
+        v_i += 16;
+        goto label__0__continue;
+      }
+      while (true) {
+        if (self->private_impl.f_n_bits <= 0) {
+          {
+            WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
+            if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+              status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+              goto suspend;
+            }
+            uint8_t t_4 = *iop_a_src++;
+            v_c = t_4;
+          }
+          self->private_impl.f_bits = (((uint32_t)(v_c)) << 24);
+          self->private_impl.f_n_bits = 8;
+        }
+        self->private_data.f_scratch += (self->private_impl.f_bits >> 31);
+        self->private_data.f_presence[(v_i & 255)] = ((uint8_t)((self->private_impl.f_bits >> 31)));
+        self->private_impl.f_bits <<= 1;
+        self->private_impl.f_n_bits -= 1;
+        v_i += 1;
+        if ((v_i & 15) == 0) {
+          goto label__1__break;
+        }
+      }
+      label__1__break:;
+    }
+    if ((self->private_data.f_scratch < 1) || (256 < self->private_data.f_scratch)) {
+      status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_header);
+      goto exit;
+    }
+    self->private_impl.f_num_symbols = (self->private_data.f_scratch + 2);
+    self->private_data.f_scratch = 0;
+    v_i = 0;
+    while (v_i < 3) {
+      if (self->private_impl.f_n_bits <= 0) {
+        {
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
+          if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+            status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+            goto suspend;
+          }
+          uint8_t t_5 = *iop_a_src++;
+          v_c = t_5;
+        }
+        self->private_impl.f_bits = (((uint32_t)(v_c)) << 24);
+        self->private_impl.f_n_bits = 8;
+      }
+      self->private_data.f_scratch <<= 1;
+      self->private_data.f_scratch |= (self->private_impl.f_bits >> 31);
+      self->private_impl.f_bits <<= 1;
+      self->private_impl.f_n_bits -= 1;
+      v_i += 1;
+    }
+    if ((self->private_data.f_scratch < 2) || (6 < self->private_data.f_scratch)) {
+      status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_header);
+      goto exit;
+    }
+    self->private_impl.f_num_huffman_codes = self->private_data.f_scratch;
+    self->private_data.f_scratch = 0;
+    v_i = 0;
+    while (v_i < 15) {
+      if (self->private_impl.f_n_bits <= 0) {
+        {
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
+          if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+            status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+            goto suspend;
+          }
+          uint8_t t_6 = *iop_a_src++;
+          v_c = t_6;
+        }
+        self->private_impl.f_bits = (((uint32_t)(v_c)) << 24);
+        self->private_impl.f_n_bits = 8;
+      }
+      self->private_data.f_scratch <<= 1;
+      self->private_data.f_scratch |= (self->private_impl.f_bits >> 31);
+      self->private_impl.f_bits <<= 1;
+      self->private_impl.f_n_bits -= 1;
+      v_i += 1;
+    }
+    if ((self->private_data.f_scratch < 1) || (18001 < self->private_data.f_scratch)) {
+      status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_header);
+      goto exit;
+    }
+    self->private_impl.f_num_sections = self->private_data.f_scratch;
+    v_i = 0;
+    while (v_i < self->private_impl.f_num_huffman_codes) {
+      self->private_data.f_mtft[v_i] = ((uint8_t)(v_i));
+      v_i += 1;
+    }
+    v_i = 0;
+    while (v_i < self->private_impl.f_num_sections) {
+      v_selector = 0;
+      while (true) {
+        if (self->private_impl.f_n_bits <= 0) {
+          {
+            WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
+            if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+              status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+              goto suspend;
+            }
+            uint8_t t_7 = *iop_a_src++;
+            v_c = t_7;
+          }
+          self->private_impl.f_bits = (((uint32_t)(v_c)) << 24);
+          self->private_impl.f_n_bits = 8;
+        }
+        if ((self->private_impl.f_bits >> 31) == 0) {
+          self->private_impl.f_bits <<= 1;
+          self->private_impl.f_n_bits -= 1;
+          goto label__2__break;
+        }
+        self->private_impl.f_bits <<= 1;
+        self->private_impl.f_n_bits -= 1;
+        v_selector += 1;
+        if (v_selector >= self->private_impl.f_num_huffman_codes) {
+          status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_header);
+          goto exit;
+        }
+      }
+      label__2__break:;
+      if (v_selector == 0) {
+        self->private_data.f_huffman_selectors[v_i] = self->private_data.f_mtft[0];
+      } else {
+        v_sel_ff = (v_selector & 255);
+        v_movee = self->private_data.f_mtft[v_sel_ff];
+        wuffs_base__slice_u8__copy_from_slice(wuffs_base__make_slice_u8_ij(self->private_data.f_mtft, 1, (1 + v_sel_ff)), wuffs_base__make_slice_u8(self->private_data.f_mtft, v_sel_ff));
+        self->private_data.f_mtft[0] = v_movee;
+        self->private_data.f_huffman_selectors[v_i] = v_movee;
+      }
+      v_i += 1;
+    }
+    v_i = 0;
+    while (v_i < self->private_impl.f_num_huffman_codes) {
+      if (a_src) {
+        a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+      }
+      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
+      status = wuffs_bzip2__decoder__read_code_lengths(self, a_src);
+      if (a_src) {
+        iop_a_src = a_src->data.ptr + a_src->meta.ri;
+      }
+      if (status.repr) {
+        goto suspend;
+      }
+      v_status = wuffs_bzip2__decoder__build_huffman_tree(self, v_i);
+      if (wuffs_base__status__is_error(&v_status)) {
+        status = v_status;
+        goto exit;
+      }
+      wuffs_bzip2__decoder__build_huffman_table(self, v_i);
+      v_i += 1;
+    }
+    v_i = 0;
+    v_j = 0;
+    while (v_i < 256) {
+      if (self->private_data.f_presence[v_i] != 0) {
+        self->private_data.f_mtft[(v_j & 255)] = ((uint8_t)(v_i));
+        v_j += 1;
+      }
+      v_i += 1;
+    }
+    v_i = 0;
+    while (v_i < 256) {
+      self->private_data.f_letter_counts[v_i] = 0;
+      v_i += 1;
+    }
+
+    goto ok;
+    ok:
+    self->private_impl.p_prepare_block[0] = 0;
+    goto exit;
+  }
+
+  goto suspend;
+  suspend:
+  self->private_impl.p_prepare_block[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
+  self->private_data.s_prepare_block[0].v_i = v_i;
+  self->private_data.s_prepare_block[0].v_selector = v_selector;
+
+  goto exit;
+  exit:
+  if (a_src) {
+    a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+  }
+
+  return status;
+}
+
+// -------- func bzip2.decoder.read_code_lengths
+
+static wuffs_base__status
+wuffs_bzip2__decoder__read_code_lengths(
+    wuffs_bzip2__decoder* self,
+    wuffs_base__io_buffer* a_src) {
+  wuffs_base__status status = wuffs_base__make_status(NULL);
+
+  uint8_t v_c = 0;
+  uint32_t v_i = 0;
+  uint32_t v_code_length = 0;
+
+  const uint8_t* iop_a_src = NULL;
+  const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  if (a_src) {
+    io0_a_src = a_src->data.ptr;
+    io1_a_src = io0_a_src + a_src->meta.ri;
+    iop_a_src = io1_a_src;
+    io2_a_src = io0_a_src + a_src->meta.wi;
+  }
+
+  uint32_t coro_susp_point = self->private_impl.p_read_code_lengths[0];
+  if (coro_susp_point) {
+    v_i = self->private_data.s_read_code_lengths[0].v_i;
+    v_code_length = self->private_data.s_read_code_lengths[0].v_code_length;
+  }
+  switch (coro_susp_point) {
+    WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
+
+    self->private_impl.f_code_lengths_bitmask = 0;
+    v_i = 0;
+    while (v_i < 5) {
+      if (self->private_impl.f_n_bits <= 0) {
+        {
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
+          if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+            status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+            goto suspend;
+          }
+          uint8_t t_0 = *iop_a_src++;
+          v_c = t_0;
+        }
+        self->private_impl.f_bits = (((uint32_t)(v_c)) << 24);
+        self->private_impl.f_n_bits = 8;
+      }
+      v_code_length <<= 1;
+      v_code_length |= (self->private_impl.f_bits >> 31);
+      self->private_impl.f_bits <<= 1;
+      self->private_impl.f_n_bits -= 1;
+      v_i += 1;
+    }
+    v_i = 0;
+    while (v_i < self->private_impl.f_num_symbols) {
+      while (true) {
+        if ((v_code_length < 1) || (20 < v_code_length)) {
+          status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_header);
+          goto exit;
+        }
+        if (self->private_impl.f_n_bits <= 0) {
+          {
+            WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
+            if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+              status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+              goto suspend;
+            }
+            uint8_t t_1 = *iop_a_src++;
+            v_c = t_1;
+          }
+          self->private_impl.f_bits = (((uint32_t)(v_c)) << 24);
+          self->private_impl.f_n_bits = 8;
+        }
+        if ((self->private_impl.f_bits >> 31) == 0) {
+          self->private_impl.f_bits <<= 1;
+          self->private_impl.f_n_bits -= 1;
+          goto label__0__break;
+        }
+        self->private_impl.f_bits <<= 1;
+        self->private_impl.f_n_bits -= 1;
+        if (self->private_impl.f_n_bits <= 0) {
+          {
+            WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
+            if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+              status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+              goto suspend;
+            }
+            uint8_t t_2 = *iop_a_src++;
+            v_c = t_2;
+          }
+          self->private_impl.f_bits = (((uint32_t)(v_c)) << 24);
+          self->private_impl.f_n_bits = 8;
+        }
+        if ((self->private_impl.f_bits >> 31) == 0) {
+          v_code_length += 1;
+        } else {
+          v_code_length -= 1;
+        }
+        self->private_impl.f_bits <<= 1;
+        self->private_impl.f_n_bits -= 1;
+      }
+      label__0__break:;
+      self->private_impl.f_code_lengths_bitmask |= (((uint32_t)(1)) << (v_code_length & 31));
+      self->private_data.f_bwt[v_i] = v_code_length;
+      v_i += 1;
+    }
+
+    goto ok;
+    ok:
+    self->private_impl.p_read_code_lengths[0] = 0;
+    goto exit;
+  }
+
+  goto suspend;
+  suspend:
+  self->private_impl.p_read_code_lengths[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
+  self->private_data.s_read_code_lengths[0].v_i = v_i;
+  self->private_data.s_read_code_lengths[0].v_code_length = v_code_length;
+
+  goto exit;
+  exit:
+  if (a_src) {
+    a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+  }
+
+  return status;
+}
+
+// -------- func bzip2.decoder.build_huffman_tree
+
+static wuffs_base__status
+wuffs_bzip2__decoder__build_huffman_tree(
+    wuffs_bzip2__decoder* self,
+    uint32_t a_which) {
+  uint32_t v_code_length = 0;
+  uint32_t v_symbol_index = 0;
+  uint32_t v_num_nodes = 0;
+  uint32_t v_stack_height = 0;
+  uint32_t v_stack_values[21] = {0};
+  uint32_t v_node_index = 0;
+  uint16_t v_leaf_value = 0;
+
+  self->private_data.f_huffman_trees[a_which][0][0] = 0;
+  self->private_data.f_huffman_trees[a_which][0][1] = 0;
+  v_num_nodes = 1;
+  v_stack_height = 1;
+  v_stack_values[0] = 0;
+  v_code_length = 1;
+  label__0__continue:;
+  while (v_code_length <= 20) {
+    if ((self->private_impl.f_code_lengths_bitmask & (((uint32_t)(1)) << v_code_length)) == 0) {
+      v_code_length += 1;
+      goto label__0__continue;
+    }
+    v_symbol_index = 0;
+    label__1__continue:;
+    while (v_symbol_index < self->private_impl.f_num_symbols) {
+      if (self->private_data.f_bwt[v_symbol_index] != v_code_length) {
+        v_symbol_index += 1;
+        goto label__1__continue;
+      }
+      while (true) {
+        if (v_stack_height <= 0) {
+          return wuffs_base__make_status(wuffs_bzip2__error__bad_huffman_code_over_subscribed);
+        } else if (v_stack_height >= v_code_length) {
+          goto label__2__break;
+        }
+        v_node_index = v_stack_values[(v_stack_height - 1)];
+        if (self->private_data.f_huffman_trees[a_which][v_node_index][0] == 0) {
+          self->private_data.f_huffman_trees[a_which][v_node_index][0] = ((uint16_t)(v_num_nodes));
+        } else {
+          self->private_data.f_huffman_trees[a_which][v_node_index][1] = ((uint16_t)(v_num_nodes));
+        }
+        if (v_num_nodes >= 1023) {
+          return wuffs_base__make_status(wuffs_bzip2__error__unsupported_huffman_code);
+        }
+        v_stack_values[v_stack_height] = v_num_nodes;
+        self->private_data.f_huffman_trees[a_which][v_num_nodes][0] = 0;
+        self->private_data.f_huffman_trees[a_which][v_num_nodes][1] = 0;
+        v_num_nodes += 1;
+        v_stack_height += 1;
+      }
+      label__2__break:;
+      v_node_index = v_stack_values[(v_stack_height - 1)];
+      if (v_symbol_index < 2) {
+        v_leaf_value = ((uint16_t)((1280 + v_symbol_index)));
+      } else if ((v_symbol_index + 1) < self->private_impl.f_num_symbols) {
+        v_leaf_value = ((uint16_t)((1023 + v_symbol_index)));
+      } else {
+        v_leaf_value = 2047;
+      }
+      if (self->private_data.f_huffman_trees[a_which][v_node_index][0] == 0) {
+        self->private_data.f_huffman_trees[a_which][v_node_index][0] = v_leaf_value;
+      } else {
+        self->private_data.f_huffman_trees[a_which][v_node_index][1] = v_leaf_value;
+        v_stack_height -= 1;
+        while (v_stack_height > 0) {
+          v_node_index = v_stack_values[(v_stack_height - 1)];
+          if (self->private_data.f_huffman_trees[a_which][v_node_index][1] == 0) {
+            goto label__3__break;
+          }
+          v_stack_height -= 1;
+        }
+        label__3__break:;
+      }
+      v_symbol_index += 1;
+    }
+    v_code_length += 1;
+  }
+  if (v_stack_height != 0) {
+    return wuffs_base__make_status(wuffs_bzip2__error__bad_huffman_code_under_subscribed);
+  }
+  return wuffs_base__make_status(NULL);
+}
+
+// -------- func bzip2.decoder.build_huffman_table
+
+static wuffs_base__empty_struct
+wuffs_bzip2__decoder__build_huffman_table(
+    wuffs_bzip2__decoder* self,
+    uint32_t a_which) {
+  uint32_t v_i = 0;
+  uint32_t v_bits = 0;
+  uint16_t v_n_bits = 0;
+  uint16_t v_child = 0;
+
+  while (v_i < 256) {
+    v_bits = (v_i << 24);
+    v_n_bits = 0;
+    v_child = 0;
+    while ((v_child < 1024) && (v_n_bits < 8)) {
+      v_child = self->private_data.f_huffman_trees[a_which][v_child][(v_bits >> 31)];
+      v_bits <<= 1;
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+      v_n_bits += 1;
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+    }
+    self->private_data.f_huffman_tables[a_which][v_i] = ((uint16_t)((v_child | (v_n_bits << 12))));
+    v_i += 1;
+  }
+  return wuffs_base__make_empty_struct();
+}
+
+// -------- func bzip2.decoder.invert_bwt
+
+static wuffs_base__empty_struct
+wuffs_bzip2__decoder__invert_bwt(
+    wuffs_bzip2__decoder* self) {
+  uint32_t v_i = 0;
+  uint32_t v_letter = 0;
+  uint32_t v_sum = 0;
+  uint32_t v_old_sum = 0;
+
+  v_sum = 0;
+  v_i = 0;
+  while (v_i < 256) {
+    v_old_sum = v_sum;
+    v_sum += self->private_data.f_letter_counts[v_i];
+    self->private_data.f_letter_counts[v_i] = v_old_sum;
+    v_i += 1;
+  }
+  v_i = 0;
+  while (v_i < self->private_impl.f_block_size) {
+    v_letter = (self->private_data.f_bwt[v_i] & 255);
+    self->private_data.f_bwt[(self->private_data.f_letter_counts[v_letter] & 1048575)] |= (v_i << 12);
+    self->private_data.f_letter_counts[v_letter] += 1;
+    v_i += 1;
+  }
+  return wuffs_base__make_empty_struct();
+}
+
+// -------- func bzip2.decoder.flush_fast
+
+static wuffs_base__empty_struct
+wuffs_bzip2__decoder__flush_fast(
+    wuffs_bzip2__decoder* self,
+    wuffs_base__io_buffer* a_dst) {
+  uint32_t v_flush_pointer = 0;
+  uint32_t v_flush_repeat_count = 0;
+  uint8_t v_flush_prev = 0;
+  uint32_t v_block_checksum_have = 0;
+  uint32_t v_block_size = 0;
+  uint32_t v_entry = 0;
+  uint8_t v_curr = 0;
+
+  uint8_t* iop_a_dst = NULL;
+  uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  uint8_t* io1_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  uint8_t* io2_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  if (a_dst) {
+    io0_a_dst = a_dst->data.ptr;
+    io1_a_dst = io0_a_dst + a_dst->meta.wi;
+    iop_a_dst = io1_a_dst;
+    io2_a_dst = io0_a_dst + a_dst->data.len;
+    if (a_dst->meta.closed) {
+      io2_a_dst = iop_a_dst;
+    }
+  }
+
+  v_flush_pointer = self->private_impl.f_flush_pointer;
+  v_flush_repeat_count = self->private_impl.f_flush_repeat_count;
+  v_flush_prev = self->private_impl.f_flush_prev;
+  v_block_checksum_have = self->private_impl.f_block_checksum_have;
+  v_block_size = self->private_impl.f_block_size;
+  while ((v_block_size > 0) && (((uint64_t)(io2_a_dst - iop_a_dst)) >= 255)) {
+    if (v_flush_repeat_count < 4) {
+      v_entry = self->private_data.f_bwt[v_flush_pointer];
+      v_curr = ((uint8_t)((v_entry & 255)));
+      v_flush_pointer = (v_entry >> 12);
+      if (v_curr == v_flush_prev) {
+        v_flush_repeat_count += 1;
+      } else {
+        v_flush_repeat_count = 1;
+      }
+      v_block_checksum_have = (WUFFS_BZIP2__REV_CRC32_TABLE[(((uint8_t)((v_block_checksum_have >> 24))) ^ v_curr)] ^ ((uint32_t)(v_block_checksum_have << 8)));
+      (wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, v_curr), iop_a_dst += 1);
+      v_flush_prev = v_curr;
+      v_block_size -= 1;
+    } else {
+      v_entry = self->private_data.f_bwt[v_flush_pointer];
+      v_curr = ((uint8_t)((v_entry & 255)));
+      v_flush_pointer = (v_entry >> 12);
+      v_flush_repeat_count = ((uint32_t)(v_curr));
+      while (v_flush_repeat_count > 0) {
+        v_block_checksum_have = (WUFFS_BZIP2__REV_CRC32_TABLE[(((uint8_t)((v_block_checksum_have >> 24))) ^ v_flush_prev)] ^ ((uint32_t)(v_block_checksum_have << 8)));
+        if (((uint64_t)(io2_a_dst - iop_a_dst)) > 0) {
+          (wuffs_base__poke_u8be__no_bounds_check(iop_a_dst, v_flush_prev), iop_a_dst += 1);
+        }
+        v_flush_repeat_count -= 1;
+      }
+      v_flush_repeat_count = 0;
+      v_flush_prev = v_curr;
+      v_block_size -= 1;
+    }
+  }
+  self->private_impl.f_flush_pointer = v_flush_pointer;
+  self->private_impl.f_flush_repeat_count = v_flush_repeat_count;
+  self->private_impl.f_flush_prev = v_flush_prev;
+  self->private_impl.f_block_checksum_have = v_block_checksum_have;
+  if (v_block_size <= 900000) {
+    self->private_impl.f_block_size = v_block_size;
+  }
+  if (a_dst) {
+    a_dst->meta.wi = ((size_t)(iop_a_dst - a_dst->data.ptr));
+  }
+
+  return wuffs_base__make_empty_struct();
+}
+
+// -------- func bzip2.decoder.flush_slow
+
+static wuffs_base__status
+wuffs_bzip2__decoder__flush_slow(
+    wuffs_bzip2__decoder* self,
+    wuffs_base__io_buffer* a_dst) {
+  wuffs_base__status status = wuffs_base__make_status(NULL);
+
+  uint32_t v_flush_pointer = 0;
+  uint32_t v_flush_repeat_count = 0;
+  uint8_t v_flush_prev = 0;
+  uint32_t v_block_checksum_have = 0;
+  uint32_t v_block_size = 0;
+  uint32_t v_entry = 0;
+  uint8_t v_curr = 0;
+
+  uint8_t* iop_a_dst = NULL;
+  uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  uint8_t* io1_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  uint8_t* io2_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  if (a_dst) {
+    io0_a_dst = a_dst->data.ptr;
+    io1_a_dst = io0_a_dst + a_dst->meta.wi;
+    iop_a_dst = io1_a_dst;
+    io2_a_dst = io0_a_dst + a_dst->data.len;
+    if (a_dst->meta.closed) {
+      io2_a_dst = iop_a_dst;
+    }
+  }
+
+  uint32_t coro_susp_point = self->private_impl.p_flush_slow[0];
+  if (coro_susp_point) {
+    v_flush_pointer = self->private_data.s_flush_slow[0].v_flush_pointer;
+    v_flush_repeat_count = self->private_data.s_flush_slow[0].v_flush_repeat_count;
+    v_flush_prev = self->private_data.s_flush_slow[0].v_flush_prev;
+    v_block_checksum_have = self->private_data.s_flush_slow[0].v_block_checksum_have;
+    v_block_size = self->private_data.s_flush_slow[0].v_block_size;
+    v_curr = self->private_data.s_flush_slow[0].v_curr;
+  }
+  switch (coro_susp_point) {
+    WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
+
+    v_flush_pointer = self->private_impl.f_flush_pointer;
+    v_flush_repeat_count = self->private_impl.f_flush_repeat_count;
+    v_flush_prev = self->private_impl.f_flush_prev;
+    v_block_checksum_have = self->private_impl.f_block_checksum_have;
+    v_block_size = self->private_impl.f_block_size;
+    while ((v_block_size > 0) &&  ! (self->private_impl.p_flush_slow[0] != 0)) {
+      if (v_flush_repeat_count < 4) {
+        v_entry = self->private_data.f_bwt[v_flush_pointer];
+        v_curr = ((uint8_t)((v_entry & 255)));
+        v_flush_pointer = (v_entry >> 12);
+        if (v_curr == v_flush_prev) {
+          v_flush_repeat_count += 1;
+        } else {
+          v_flush_repeat_count = 1;
+        }
+        v_block_checksum_have = (WUFFS_BZIP2__REV_CRC32_TABLE[(((uint8_t)((v_block_checksum_have >> 24))) ^ v_curr)] ^ ((uint32_t)(v_block_checksum_have << 8)));
+        self->private_data.s_flush_slow[0].scratch = v_curr;
+        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
+        if (iop_a_dst == io2_a_dst) {
+          status = wuffs_base__make_status(wuffs_base__suspension__short_write);
+          goto suspend;
+        }
+        *iop_a_dst++ = ((uint8_t)(self->private_data.s_flush_slow[0].scratch));
+        v_flush_prev = v_curr;
+        v_block_size -= 1;
+      } else {
+        v_entry = self->private_data.f_bwt[v_flush_pointer];
+        v_curr = ((uint8_t)((v_entry & 255)));
+        v_flush_pointer = (v_entry >> 12);
+        v_flush_repeat_count = ((uint32_t)(v_curr));
+        while (v_flush_repeat_count > 0) {
+          v_block_checksum_have = (WUFFS_BZIP2__REV_CRC32_TABLE[(((uint8_t)((v_block_checksum_have >> 24))) ^ v_flush_prev)] ^ ((uint32_t)(v_block_checksum_have << 8)));
+          self->private_data.s_flush_slow[0].scratch = v_flush_prev;
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
+          if (iop_a_dst == io2_a_dst) {
+            status = wuffs_base__make_status(wuffs_base__suspension__short_write);
+            goto suspend;
+          }
+          *iop_a_dst++ = ((uint8_t)(self->private_data.s_flush_slow[0].scratch));
+          v_flush_repeat_count -= 1;
+        }
+        v_flush_repeat_count = 0;
+        v_flush_prev = v_curr;
+        v_block_size -= 1;
+      }
+    }
+    self->private_impl.f_flush_pointer = v_flush_pointer;
+    self->private_impl.f_flush_repeat_count = v_flush_repeat_count;
+    self->private_impl.f_flush_prev = v_flush_prev;
+    self->private_impl.f_block_checksum_have = v_block_checksum_have;
+    if (v_block_size <= 900000) {
+      self->private_impl.f_block_size = v_block_size;
+    }
+
+    goto ok;
+    ok:
+    self->private_impl.p_flush_slow[0] = 0;
+    goto exit;
+  }
+
+  goto suspend;
+  suspend:
+  self->private_impl.p_flush_slow[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
+  self->private_data.s_flush_slow[0].v_flush_pointer = v_flush_pointer;
+  self->private_data.s_flush_slow[0].v_flush_repeat_count = v_flush_repeat_count;
+  self->private_data.s_flush_slow[0].v_flush_prev = v_flush_prev;
+  self->private_data.s_flush_slow[0].v_block_checksum_have = v_block_checksum_have;
+  self->private_data.s_flush_slow[0].v_block_size = v_block_size;
+  self->private_data.s_flush_slow[0].v_curr = v_curr;
+
+  goto exit;
+  exit:
+  if (a_dst) {
+    a_dst->meta.wi = ((size_t)(iop_a_dst - a_dst->data.ptr));
+  }
+
+  return status;
+}
+
+// -------- func bzip2.decoder.decode_huffman_fast
+
+static wuffs_base__status
+wuffs_bzip2__decoder__decode_huffman_fast(
+    wuffs_bzip2__decoder* self,
+    wuffs_base__io_buffer* a_src) {
+  wuffs_base__status status = wuffs_base__make_status(NULL);
+
+  uint32_t v_bits = 0;
+  uint32_t v_n_bits = 0;
+  uint32_t v_block_size = 0;
+  uint8_t v_which = 0;
+  uint32_t v_ticks = 0;
+  uint32_t v_section = 0;
+  uint32_t v_run_shift = 0;
+  uint16_t v_table_entry = 0;
+  uint16_t v_child = 0;
+  uint32_t v_child_ff = 0;
+  uint32_t v_i = 0;
+  uint32_t v_j = 0;
+  uint32_t v_output = 0;
+  uint32_t v_run = 0;
+  uint32_t v_mtft0 = 0;
+
+  const uint8_t* iop_a_src = NULL;
+  const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  if (a_src) {
+    io0_a_src = a_src->data.ptr;
+    io1_a_src = io0_a_src + a_src->meta.ri;
+    iop_a_src = io1_a_src;
+    io2_a_src = io0_a_src + a_src->meta.wi;
+  }
+
+  v_bits = self->private_impl.f_bits;
+  v_n_bits = self->private_impl.f_n_bits;
+  v_block_size = self->private_impl.f_block_size;
+  v_which = self->private_impl.f_decode_huffman_which;
+  v_ticks = self->private_impl.f_decode_huffman_ticks;
+  v_section = self->private_impl.f_decode_huffman_section;
+  v_run_shift = self->private_impl.f_decode_huffman_run_shift;
+  label__outer__continue:;
+  while (((uint64_t)(io2_a_src - iop_a_src)) >= 4) {
+    if (v_ticks > 0) {
+      v_ticks -= 1;
+    } else {
+      v_ticks = 49;
+      v_section += 1;
+      v_which = WUFFS_BZIP2__CLAMP_TO_5[(self->private_data.f_huffman_selectors[(v_section & 32767)] & 7)];
+    }
+    v_bits |= (wuffs_base__peek_u32be__no_bounds_check(iop_a_src) >> v_n_bits);
+    iop_a_src += ((31 - v_n_bits) >> 3);
+    v_n_bits |= 24;
+    v_table_entry = self->private_data.f_huffman_tables[v_which][(v_bits >> 24)];
+    v_bits <<= (v_table_entry >> 12);
+    v_n_bits -= ((uint32_t)((v_table_entry >> 12)));
+    v_child = (v_table_entry & 2047);
+    while (v_child < 1024) {
+      v_child = self->private_data.f_huffman_trees[v_which][v_child][(v_bits >> 31)];
+      v_bits <<= 1;
+      if (v_n_bits <= 0) {
+        status = wuffs_base__make_status(wuffs_bzip2__error__internal_error_inconsistent_huffman_decoder_state);
+        goto exit;
+      }
+      v_n_bits -= 1;
+    }
+    if (v_child < 1280) {
+      v_child_ff = ((uint32_t)((v_child & 255)));
+      v_output = ((uint32_t)(self->private_data.f_mtft[v_child_ff]));
+      wuffs_base__slice_u8__copy_from_slice(wuffs_base__make_slice_u8_ij(self->private_data.f_mtft, 1, (1 + v_child_ff)), wuffs_base__make_slice_u8(self->private_data.f_mtft, v_child_ff));
+      self->private_data.f_mtft[0] = ((uint8_t)(v_output));
+      self->private_data.f_letter_counts[v_output] += 1;
+      self->private_data.f_bwt[v_block_size] = v_output;
+      if (v_block_size >= self->private_impl.f_max_incl_block_size) {
+        status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_length);
+        goto exit;
+      }
+      v_block_size += 1;
+      v_run_shift = 0;
+      goto label__outer__continue;
+    } else if (v_child > 1281) {
+      self->private_impl.f_decode_huffman_finished = true;
+      goto label__outer__break;
+    }
+    if (v_run_shift >= 23) {
+      status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_length);
+      goto exit;
+    }
+    v_run = (((uint32_t)((v_child - 1279))) << v_run_shift);
+    v_run_shift += 1;
+    v_i = v_block_size;
+    v_j = (v_run + v_block_size);
+    if (v_j > self->private_impl.f_max_incl_block_size) {
+      status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_length);
+      goto exit;
+    }
+    v_block_size = v_j;
+    v_mtft0 = ((uint32_t)(self->private_data.f_mtft[0]));
+    self->private_data.f_letter_counts[v_mtft0] += v_run;
+    while (v_i < v_j) {
+      self->private_data.f_bwt[v_i] = v_mtft0;
+      v_i += 1;
+    }
+  }
+  label__outer__break:;
+  self->private_impl.f_bits = v_bits;
+  self->private_impl.f_n_bits = v_n_bits;
+  self->private_impl.f_block_size = v_block_size;
+  self->private_impl.f_decode_huffman_which = v_which;
+  self->private_impl.f_decode_huffman_ticks = v_ticks;
+  self->private_impl.f_decode_huffman_section = v_section;
+  self->private_impl.f_decode_huffman_run_shift = v_run_shift;
+  status = wuffs_base__make_status(NULL);
+  goto ok;
+
+  ok:
+  goto exit;
+  exit:
+  if (a_src) {
+    a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+  }
+
+  return status;
+}
+
+// -------- func bzip2.decoder.decode_huffman_slow
+
+static wuffs_base__status
+wuffs_bzip2__decoder__decode_huffman_slow(
+    wuffs_bzip2__decoder* self,
+    wuffs_base__io_buffer* a_src) {
+  wuffs_base__status status = wuffs_base__make_status(NULL);
+
+  uint8_t v_c = 0;
+  uint32_t v_node_index = 0;
+  uint16_t v_child = 0;
+  uint32_t v_child_ff = 0;
+  uint32_t v_i = 0;
+  uint32_t v_j = 0;
+  uint32_t v_output = 0;
+  uint32_t v_run = 0;
+  uint32_t v_mtft0 = 0;
+
+  const uint8_t* iop_a_src = NULL;
+  const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
+  if (a_src) {
+    io0_a_src = a_src->data.ptr;
+    io1_a_src = io0_a_src + a_src->meta.ri;
+    iop_a_src = io1_a_src;
+    io2_a_src = io0_a_src + a_src->meta.wi;
+  }
+
+  uint32_t coro_susp_point = self->private_impl.p_decode_huffman_slow[0];
+  if (coro_susp_point) {
+    v_node_index = self->private_data.s_decode_huffman_slow[0].v_node_index;
+  }
+  switch (coro_susp_point) {
+    WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
+
+    while ( ! (self->private_impl.p_decode_huffman_slow[0] != 0)) {
+      if (self->private_impl.f_decode_huffman_ticks > 0) {
+        self->private_impl.f_decode_huffman_ticks -= 1;
+      } else {
+        self->private_impl.f_decode_huffman_ticks = 49;
+        self->private_impl.f_decode_huffman_section += 1;
+        self->private_impl.f_decode_huffman_which = WUFFS_BZIP2__CLAMP_TO_5[(self->private_data.f_huffman_selectors[(self->private_impl.f_decode_huffman_section & 32767)] & 7)];
+      }
+      v_node_index = 0;
+      label__0__continue:;
+      while (true) {
+        if (self->private_impl.f_n_bits <= 0) {
+          {
+            WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
+            if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+              status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+              goto suspend;
+            }
+            uint8_t t_0 = *iop_a_src++;
+            v_c = t_0;
+          }
+          self->private_impl.f_bits = (((uint32_t)(v_c)) << 24);
+          self->private_impl.f_n_bits = 8;
+        }
+        v_child = self->private_data.f_huffman_trees[self->private_impl.f_decode_huffman_which][v_node_index][(self->private_impl.f_bits >> 31)];
+        self->private_impl.f_bits <<= 1;
+        self->private_impl.f_n_bits -= 1;
+        if (v_child < 1024) {
+          v_node_index = ((uint32_t)(v_child));
+          goto label__0__continue;
+        } else if (v_child < 1280) {
+          v_child_ff = ((uint32_t)((v_child & 255)));
+          v_output = ((uint32_t)(self->private_data.f_mtft[v_child_ff]));
+          wuffs_base__slice_u8__copy_from_slice(wuffs_base__make_slice_u8_ij(self->private_data.f_mtft, 1, (1 + v_child_ff)), wuffs_base__make_slice_u8(self->private_data.f_mtft, v_child_ff));
+          self->private_data.f_mtft[0] = ((uint8_t)(v_output));
+          self->private_data.f_letter_counts[v_output] += 1;
+          self->private_data.f_bwt[self->private_impl.f_block_size] = v_output;
+          if (self->private_impl.f_block_size >= self->private_impl.f_max_incl_block_size) {
+            status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_length);
+            goto exit;
+          }
+          self->private_impl.f_block_size += 1;
+          self->private_impl.f_decode_huffman_run_shift = 0;
+          goto label__0__break;
+        } else if (v_child > 1281) {
+          self->private_impl.f_decode_huffman_finished = true;
+          goto label__outer__break;
+        }
+        if (self->private_impl.f_decode_huffman_run_shift >= 23) {
+          status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_length);
+          goto exit;
+        }
+        v_run = (((uint32_t)((v_child - 1279))) << self->private_impl.f_decode_huffman_run_shift);
+        self->private_impl.f_decode_huffman_run_shift += 1;
+        v_i = self->private_impl.f_block_size;
+        v_j = (v_run + self->private_impl.f_block_size);
+        if (v_j > self->private_impl.f_max_incl_block_size) {
+          status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_length);
+          goto exit;
+        }
+        self->private_impl.f_block_size = v_j;
+        v_mtft0 = ((uint32_t)(self->private_data.f_mtft[0]));
+        self->private_data.f_letter_counts[v_mtft0] += v_run;
+        while (v_i < v_j) {
+          self->private_data.f_bwt[v_i] = v_mtft0;
+          v_i += 1;
+        }
+        goto label__0__break;
+      }
+      label__0__break:;
+    }
+    label__outer__break:;
+
+    goto ok;
+    ok:
+    self->private_impl.p_decode_huffman_slow[0] = 0;
+    goto exit;
+  }
+
+  goto suspend;
+  suspend:
+  self->private_impl.p_decode_huffman_slow[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
+  self->private_data.s_decode_huffman_slow[0].v_node_index = v_node_index;
+
+  goto exit;
+  exit:
+  if (a_src) {
+    a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+  }
+
+  return status;
+}
+
+#endif  // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BZIP2)
+
 #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__CBOR)
 
 // ---------------- Status Codes Implementations
@@ -24778,7 +26613,6 @@
   if (coro_susp_point) {
     v_string_length = self->private_data.s_decode_tokens[0].v_string_length;
     v_depth = self->private_data.s_decode_tokens[0].v_depth;
-    v_token_length = self->private_data.s_decode_tokens[0].v_token_length;
     v_tagged = self->private_data.s_decode_tokens[0].v_tagged;
     v_indefinite_string_major_type = self->private_data.s_decode_tokens[0].v_indefinite_string_major_type;
   }
@@ -24867,8 +26701,6 @@
                 }
                 status = wuffs_base__make_status(wuffs_base__suspension__short_read);
                 WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3);
-                v_c_major = 0;
-                v_c_minor = 0;
                 goto label__outer__continue;
               }
               status = wuffs_base__make_status(wuffs_cbor__error__internal_error_inconsistent_i_o);
@@ -25289,7 +27121,6 @@
   self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 1 : 0;
   self->private_data.s_decode_tokens[0].v_string_length = v_string_length;
   self->private_data.s_decode_tokens[0].v_depth = v_depth;
-  self->private_data.s_decode_tokens[0].v_token_length = v_token_length;
   self->private_data.s_decode_tokens[0].v_tagged = v_tagged;
   self->private_data.s_decode_tokens[0].v_indefinite_string_major_type = v_indefinite_string_major_type;
 
@@ -26713,7 +28544,7 @@
     wuffs_base__slice_u8__copy_from_slice(wuffs_base__make_slice_u8(self->private_data.f_history, 32768), v_s);
     self->private_impl.f_history_index = 32768;
   } else {
-    v_n_copied = wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 32768), (self->private_impl.f_history_index & 32767)), v_s);
+    v_n_copied = wuffs_base__slice_u8__copy_from_slice(wuffs_base__make_slice_u8_ij(self->private_data.f_history, (self->private_impl.f_history_index & 32767), 32768), v_s);
     if (v_n_copied < ((uint64_t)(v_s.len))) {
       v_s = wuffs_base__slice_u8__subslice_i(v_s, v_n_copied);
       v_n_copied = wuffs_base__slice_u8__copy_from_slice(wuffs_base__make_slice_u8(self->private_data.f_history, 32768), v_s);
@@ -26726,7 +28557,7 @@
       self->private_impl.f_history_index = ((self->private_impl.f_history_index & 32767) + ((uint32_t)((v_n_copied & 32767))) + v_already_full);
     }
   }
-  wuffs_base__slice_u8__copy_from_slice(wuffs_base__make_slice_u8((self->private_data.f_history) + 32768, 257), wuffs_base__make_slice_u8(self->private_data.f_history, 33025));
+  wuffs_base__slice_u8__copy_from_slice(wuffs_base__make_slice_u8_ij(self->private_data.f_history, 32768, 33025), wuffs_base__make_slice_u8(self->private_data.f_history, 33025));
   return wuffs_base__make_empty_struct();
 }
 
@@ -27230,7 +29061,6 @@
     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_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;
@@ -27430,7 +29260,6 @@
   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;
@@ -27859,7 +29688,7 @@
           goto exit;
         }
         wuffs_base__io_writer__limited_copy_u32_from_slice(
-            &iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), ((self->private_impl.f_history_index - v_hdist) & 32767)));
+            &iop_a_dst, io2_a_dst,v_hlen, wuffs_base__make_slice_u8_ij(self->private_data.f_history, ((self->private_impl.f_history_index - v_hdist) & 32767), 33025));
         if (v_length == 0) {
           goto label__loop__continue;
         }
@@ -28124,7 +29953,7 @@
           goto exit;
         }
         wuffs_base__io_writer__limited_copy_u32_from_slice(
-            &iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), ((self->private_impl.f_history_index - v_hdist) & 32767)));
+            &iop_a_dst, io2_a_dst,v_hlen, wuffs_base__make_slice_u8_ij(self->private_data.f_history, ((self->private_impl.f_history_index - v_hdist) & 32767), 33025));
         if (v_length == 0) {
           goto label__loop__continue;
         }
@@ -28336,7 +30165,7 @@
           goto exit;
         }
         wuffs_base__io_writer__limited_copy_u32_from_slice(
-            &iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), ((self->private_impl.f_history_index - v_hdist) & 32767)));
+            &iop_a_dst, io2_a_dst,v_hlen, wuffs_base__make_slice_u8_ij(self->private_data.f_history, ((self->private_impl.f_history_index - v_hdist) & 32767), 33025));
         if (v_length == 0) {
           goto label__loop__continue;
         }
@@ -28448,7 +30277,6 @@
   if (coro_susp_point) {
     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_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;
@@ -28456,7 +30284,6 @@
     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;
   }
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
@@ -28668,7 +30495,7 @@
             goto exit;
           }
           v_n_copied = wuffs_base__io_writer__limited_copy_u32_from_slice(
-              &iop_a_dst, io2_a_dst,v_hlen, wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_history, 33025), ((self->private_impl.f_history_index - v_hdist) & 32767)));
+              &iop_a_dst, io2_a_dst,v_hlen, wuffs_base__make_slice_u8_ij(self->private_data.f_history, ((self->private_impl.f_history_index - v_hdist) & 32767), 33025));
           if (v_n_copied < v_hlen) {
             v_length -= v_n_copied;
             status = wuffs_base__make_status(wuffs_base__suspension__short_write);
@@ -28708,7 +30535,6 @@
   self->private_impl.p_decode_huffman_slow[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
   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_data.s_decode_huffman_slow[0].v_lmask = v_lmask;
   self->private_data.s_decode_huffman_slow[0].v_dmask = v_dmask;
@@ -28716,7 +30542,6 @@
   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;
 
   goto exit;
   exit:
@@ -29195,8 +31020,7 @@
         status = wuffs_base__make_status(wuffs_lzw__error__internal_error_inconsistent_i_o);
         goto exit;
       }
-      v_s = wuffs_base__slice_u8__subslice_ij(wuffs_base__make_slice_u8(self->private_data.f_output,
-          8199),
+      v_s = wuffs_base__make_slice_u8_ij(self->private_data.f_output,
           self->private_impl.f_output_ri,
           self->private_impl.f_output_wi);
       v_n = wuffs_base__io_writer__copy_from_slice(&iop_a_dst, io2_a_dst,v_s);
@@ -29244,8 +31068,7 @@
   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__make_slice_u8(self->private_data.f_output,
-        8199),
+    v_s = wuffs_base__make_slice_u8_ij(self->private_data.f_output,
         self->private_impl.f_output_ri,
         self->private_impl.f_output_wi);
   }
@@ -29557,7 +31380,10 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    if (self->private_impl.f_call_sequence == 0) {
+    if (self->private_impl.f_call_sequence != 0) {
+      status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
+      goto exit;
+    } else if ( ! self->private_impl.f_seen_header) {
       WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
       status = wuffs_gif__decoder__decode_header(self, a_src);
       if (status.repr) {
@@ -29568,9 +31394,7 @@
       if (status.repr) {
         goto suspend;
       }
-    } else if (self->private_impl.f_call_sequence != 2) {
-      status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
-      goto exit;
+      self->private_impl.f_seen_header = true;
     }
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
     status = wuffs_gif__decoder__decode_up_to_id_part1(self, a_src);
@@ -29600,7 +31424,9 @@
           self->private_impl.f_frame_config_io_position,
           v_ffio);
     }
-    self->private_impl.f_call_sequence = 3;
+    if (self->private_impl.f_call_sequence == 0) {
+      self->private_impl.f_call_sequence = 32;
+    }
 
     goto ok;
     ok:
@@ -29689,7 +31515,7 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    if (self->private_impl.f_call_sequence != 1) {
+    if ((self->private_impl.f_call_sequence & 16) == 0) {
       status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
       goto exit;
     }
@@ -29760,7 +31586,7 @@
           self->private_impl.f_metadata_io_position,
           self->private_impl.f_metadata_io_position);
     }
-    self->private_impl.f_call_sequence = 2;
+    self->private_impl.f_call_sequence &= 239;
     self->private_impl.f_metadata_fourcc = 0;
     self->private_impl.f_metadata_io_position = 0;
     status = wuffs_base__make_status(NULL);
@@ -29895,16 +31721,17 @@
         : wuffs_base__error__initialize_not_called);
   }
 
-  if (self->private_impl.f_call_sequence < 3) {
+  if (self->private_impl.f_call_sequence < 32) {
     return wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
+  } else if (a_io_position == 0) {
+    return wuffs_base__make_status(wuffs_base__error__bad_argument);
   }
   self->private_impl.f_delayed_num_decoded_frames = false;
-  self->private_impl.f_end_of_data = false;
-  self->private_impl.f_restarted = true;
   self->private_impl.f_frame_config_io_position = a_io_position;
   self->private_impl.f_num_decoded_frame_configs_value = a_index;
   self->private_impl.f_num_decoded_frames_value = a_index;
   wuffs_gif__decoder__reset_gc(self);
+  self->private_impl.f_call_sequence = 40;
   return wuffs_base__make_status(NULL);
 }
 
@@ -29957,52 +31784,65 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    self->private_impl.f_ignore_metadata = true;
     self->private_impl.f_dirty_max_excl_y = 0;
-    if ( ! self->private_impl.f_end_of_data) {
-      if (self->private_impl.f_call_sequence == 0) {
-        if (a_src) {
-          a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-        }
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
-        status = wuffs_gif__decoder__decode_image_config(self, NULL, a_src);
-        if (a_src) {
-          iop_a_src = a_src->data.ptr + a_src->meta.ri;
-        }
-        if (status.repr) {
-          goto suspend;
-        }
-      } else if (self->private_impl.f_call_sequence != 3) {
-        if (self->private_impl.f_call_sequence == 4) {
-          if (a_src) {
-            a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-          }
-          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
-          status = wuffs_gif__decoder__skip_frame(self, a_src);
-          if (a_src) {
-            iop_a_src = a_src->data.ptr + a_src->meta.ri;
-          }
-          if (status.repr) {
-            goto suspend;
-          }
-        }
-        if (a_src) {
-          a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-        }
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
-        status = wuffs_gif__decoder__decode_up_to_id_part1(self, a_src);
-        if (a_src) {
-          iop_a_src = a_src->data.ptr + a_src->meta.ri;
-        }
-        if (status.repr) {
-          goto suspend;
-        }
+    if ((self->private_impl.f_call_sequence & 16) != 0) {
+      status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
+      goto exit;
+    } else if (self->private_impl.f_call_sequence == 32) {
+    } else if (self->private_impl.f_call_sequence < 32) {
+      if (a_src) {
+        a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
       }
-    }
-    if (self->private_impl.f_end_of_data) {
+      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
+      status = wuffs_gif__decoder__decode_image_config(self, NULL, a_src);
+      if (a_src) {
+        iop_a_src = a_src->data.ptr + a_src->meta.ri;
+      }
+      if (status.repr) {
+        goto suspend;
+      }
+    } else if (self->private_impl.f_call_sequence == 40) {
+      if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
+        status = wuffs_base__make_status(wuffs_base__error__bad_restart);
+        goto exit;
+      }
+    } else if (self->private_impl.f_call_sequence == 64) {
+      if (a_src) {
+        a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+      }
+      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
+      status = wuffs_gif__decoder__skip_frame(self, a_src);
+      if (a_src) {
+        iop_a_src = a_src->data.ptr + a_src->meta.ri;
+      }
+      if (status.repr) {
+        goto suspend;
+      }
+      if (self->private_impl.f_call_sequence >= 96) {
+        status = wuffs_base__make_status(wuffs_base__note__end_of_data);
+        goto ok;
+      }
+    } else {
       status = wuffs_base__make_status(wuffs_base__note__end_of_data);
       goto ok;
     }
+    if ((self->private_impl.f_num_decoded_frame_configs_value > 0) || (self->private_impl.f_call_sequence == 40)) {
+      if (a_src) {
+        a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+      }
+      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
+      status = wuffs_gif__decoder__decode_up_to_id_part1(self, a_src);
+      if (a_src) {
+        iop_a_src = a_src->data.ptr + a_src->meta.ri;
+      }
+      if (status.repr) {
+        goto suspend;
+      }
+      if (self->private_impl.f_call_sequence >= 96) {
+        status = wuffs_base__make_status(wuffs_base__note__end_of_data);
+        goto ok;
+      }
+    }
     v_background_color = self->private_impl.f_black_color_u32_argb_premul;
     if ( ! self->private_impl.f_gc_has_transparent_index) {
       v_background_color = self->private_impl.f_background_color_u32_argb_premul;
@@ -30034,7 +31874,7 @@
           v_background_color);
     }
     wuffs_base__u64__sat_add_indirect(&self->private_impl.f_num_decoded_frame_configs_value, 1);
-    self->private_impl.f_call_sequence = 4;
+    self->private_impl.f_call_sequence = 64;
 
     ok:
     self->private_impl.p_decode_frame_config[0] = 0;
@@ -30135,6 +31975,7 @@
       wuffs_base__u64__sat_add_indirect(&self->private_impl.f_num_decoded_frames_value, 1);
     }
     wuffs_gif__decoder__reset_gc(self);
+    self->private_impl.f_call_sequence = 32;
 
     goto ok;
     ok:
@@ -30190,13 +32031,16 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    self->private_impl.f_ignore_metadata = true;
-    if (self->private_impl.f_call_sequence != 4) {
+    if (self->private_impl.f_call_sequence == 64) {
+    } else if (self->private_impl.f_call_sequence < 64) {
       WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
       status = wuffs_gif__decoder__decode_frame_config(self, NULL, a_src);
       if (status.repr) {
         goto suspend;
       }
+    } else {
+      status = wuffs_base__make_status(wuffs_base__note__end_of_data);
+      goto ok;
     }
     if (self->private_impl.f_quirks[5] && ((self->private_impl.f_frame_rect_x0 == self->private_impl.f_frame_rect_x1) || (self->private_impl.f_frame_rect_y0 == self->private_impl.f_frame_rect_y1))) {
       status = wuffs_base__make_status(wuffs_gif__error__bad_frame_size);
@@ -30214,8 +32058,8 @@
     }
     wuffs_base__u64__sat_add_indirect(&self->private_impl.f_num_decoded_frames_value, 1);
     wuffs_gif__decoder__reset_gc(self);
+    self->private_impl.f_call_sequence = 32;
 
-    goto ok;
     ok:
     self->private_impl.p_decode_frame[0] = 0;
     goto exit;
@@ -30239,7 +32083,6 @@
 static wuffs_base__empty_struct
 wuffs_gif__decoder__reset_gc(
     wuffs_gif__decoder* self) {
-  self->private_impl.f_call_sequence = 5;
   self->private_impl.f_gc_has_transparent_index = false;
   self->private_impl.f_gc_transparent_index = 0;
   self->private_impl.f_gc_disposal = 0;
@@ -30272,15 +32115,8 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    if ( ! self->private_impl.f_restarted) {
-      if (self->private_impl.f_call_sequence != 2) {
-        self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
-      }
-    } else if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
-      status = wuffs_base__make_status(wuffs_base__error__bad_restart);
-      goto exit;
-    } else {
-      self->private_impl.f_restarted = false;
+    if ((self->private_impl.f_frame_config_io_position == 0) || (self->private_impl.f_num_decoded_frame_configs_value > 0)) {
+      self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
     }
     while (true) {
       {
@@ -30326,7 +32162,7 @@
           self->private_impl.f_delayed_num_decoded_frames = false;
           wuffs_base__u64__sat_add_indirect(&self->private_impl.f_num_decoded_frames_value, 1);
         }
-        self->private_impl.f_end_of_data = true;
+        self->private_impl.f_call_sequence = 96;
         goto label__0__break;
       }
     }
@@ -30958,17 +32794,17 @@
         if ((0 < self->private_impl.f_num_animation_loops_value) && (self->private_impl.f_num_animation_loops_value <= 65535)) {
           self->private_impl.f_num_animation_loops_value += 1;
         }
-      } else if (self->private_impl.f_ignore_metadata) {
+      } else if (self->private_impl.f_call_sequence >= 32) {
       } else if (v_is_iccp && self->private_impl.f_report_metadata_iccp) {
         self->private_impl.f_metadata_fourcc = 1229144912;
         self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
-        self->private_impl.f_call_sequence = 1;
+        self->private_impl.f_call_sequence = 16;
         status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
         goto ok;
       } else if (v_is_xmp && self->private_impl.f_report_metadata_xmp) {
         self->private_impl.f_metadata_fourcc = 1481461792;
         self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
-        self->private_impl.f_call_sequence = 1;
+        self->private_impl.f_call_sequence = 16;
         status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
         goto ok;
       }
@@ -31283,7 +33119,7 @@
     self->private_impl.f_frame_rect_y1 += self->private_impl.f_frame_rect_y0;
     self->private_impl.f_dst_x = self->private_impl.f_frame_rect_x0;
     self->private_impl.f_dst_y = self->private_impl.f_frame_rect_y0;
-    if ((self->private_impl.f_call_sequence == 0) &&  ! self->private_impl.f_quirks[4]) {
+    if ((self->private_impl.f_num_decoded_frame_configs_value == 0) &&  ! self->private_impl.f_quirks[4]) {
       self->private_impl.f_width = wuffs_base__u32__max(self->private_impl.f_width, self->private_impl.f_frame_rect_x1);
       self->private_impl.f_height = wuffs_base__u32__max(self->private_impl.f_height, self->private_impl.f_frame_rect_y1);
     }
@@ -31520,7 +33356,6 @@
   if (coro_susp_point) {
     v_block_size = self->private_data.s_decode_id_part2[0].v_block_size;
     v_need_block_size = 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;
@@ -31557,7 +33392,7 @@
           goto label__0__break;
         }
         v_n_copied = wuffs_base__io_reader__limited_copy_u32_to_slice(
-            &iop_a_src, io2_a_src,((uint32_t)((v_n_compressed & 4294967295))), wuffs_base__slice_u8__subslice_i(wuffs_base__make_slice_u8(self->private_data.f_compressed, 4096), self->private_impl.f_compressed_wi));
+            &iop_a_src, io2_a_src,((uint32_t)((v_n_compressed & 4294967295))), wuffs_base__make_slice_u8_ij(self->private_data.f_compressed, self->private_impl.f_compressed_wi, 4096));
         wuffs_base__u64__sat_add_indirect(&self->private_impl.f_compressed_wi, ((uint64_t)(v_n_copied)));
         wuffs_base__u64__sat_sub_indirect(&v_block_size, ((uint64_t)(v_n_copied)));
         if (v_block_size > 0) {
@@ -31589,8 +33424,7 @@
               &io0_v_r,
               &io1_v_r,
               &io2_v_r,
-              wuffs_base__slice_u8__subslice_ij(wuffs_base__make_slice_u8(self->private_data.f_compressed,
-              4096),
+              wuffs_base__make_slice_u8_ij(self->private_data.f_compressed,
               self->private_impl.f_compressed_ri,
               self->private_impl.f_compressed_wi),
               0);
@@ -31698,7 +33532,6 @@
   self->private_impl.p_decode_id_part2[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
   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:
@@ -32890,7 +34723,6 @@
             }
             status = wuffs_base__make_status(wuffs_base__suspension__short_read);
             WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3);
-            v_whitespace_length = 0;
             goto label__outer__continue;
           }
           v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
@@ -32952,7 +34784,6 @@
                 }
                 status = wuffs_base__make_status(wuffs_base__suspension__short_read);
                 WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
-                v_string_length = 0;
                 goto label__string_loop_outer__continue;
               }
               while (((uint64_t)(io2_a_src - iop_a_src)) > 4) {
@@ -33016,8 +34847,6 @@
                   }
                   status = wuffs_base__make_status(wuffs_base__suspension__short_read);
                   WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6);
-                  v_string_length = 0;
-                  v_char = 0;
                   goto label__string_loop_outer__continue;
                 }
                 v_c = ((uint8_t)((wuffs_base__peek_u16le__no_bounds_check(iop_a_src) >> 8)));
@@ -33046,8 +34875,6 @@
                     }
                     status = wuffs_base__make_status(wuffs_base__suspension__short_read);
                     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
-                    v_string_length = 0;
-                    v_char = 0;
                     goto label__string_loop_outer__continue;
                   }
                   v_uni4_string = (((uint64_t)(wuffs_base__peek_u48le__no_bounds_check(iop_a_src))) >> 16);
@@ -33090,9 +34917,6 @@
                       }
                       status = wuffs_base__make_status(wuffs_base__suspension__short_read);
                       WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(8);
-                      v_string_length = 0;
-                      v_uni4_value = 0;
-                      v_char = 0;
                       goto label__string_loop_outer__continue;
                     }
                     v_uni4_string = (wuffs_base__peek_u64le__no_bounds_check(iop_a_src + 4) >> 16);
@@ -33148,8 +34972,6 @@
                     }
                     status = wuffs_base__make_status(wuffs_base__suspension__short_read);
                     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
-                    v_string_length = 0;
-                    v_char = 0;
                     goto label__string_loop_outer__continue;
                   }
                   v_uni8_string = wuffs_base__peek_u64le__no_bounds_check(iop_a_src + 2);
@@ -33203,8 +35025,6 @@
                     }
                     status = wuffs_base__make_status(wuffs_base__suspension__short_read);
                     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10);
-                    v_string_length = 0;
-                    v_char = 0;
                     goto label__string_loop_outer__continue;
                   }
                   v_backslash_x_string = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
@@ -33254,8 +35074,6 @@
                   }
                   status = wuffs_base__make_status(wuffs_base__suspension__short_read);
                   WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11);
-                  v_string_length = 0;
-                  v_char = 0;
                   goto label__string_loop_outer__continue;
                 }
                 v_multi_byte_utf8 = ((uint32_t)(wuffs_base__peek_u16le__no_bounds_check(iop_a_src)));
@@ -33299,8 +35117,6 @@
                   }
                   status = wuffs_base__make_status(wuffs_base__suspension__short_read);
                   WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(12);
-                  v_string_length = 0;
-                  v_char = 0;
                   goto label__string_loop_outer__continue;
                 }
                 v_multi_byte_utf8 = ((uint32_t)(wuffs_base__peek_u24le__no_bounds_check(iop_a_src)));
@@ -33346,8 +35162,6 @@
                   }
                   status = wuffs_base__make_status(wuffs_base__suspension__short_read);
                   WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(13);
-                  v_string_length = 0;
-                  v_char = 0;
                   goto label__string_loop_outer__continue;
                 }
                 v_multi_byte_utf8 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
@@ -34137,102 +35951,102 @@
       v_length = 2;
       label__comment_block__continue:;
       while (true) {
-        if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
-          status = wuffs_base__make_status(wuffs_base__suspension__short_write);
-          WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3);
-          v_length = 0;
-          goto label__comment_block__continue;
-        }
-        while (true) {
-          if (((uint64_t)(io2_a_src - iop_a_src)) <= 1) {
-            if (v_length > 0) {
-              *iop_a_dst++ = wuffs_base__make_token(
-                  (((uint64_t)(2)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
-                  (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) |
-                  (((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
-            }
-            if (a_src && a_src->meta.closed) {
-              status = wuffs_base__make_status(wuffs_json__error__bad_input);
-              goto exit;
-            }
-            status = wuffs_base__make_status(wuffs_base__suspension__short_read);
-            WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4);
-            v_length = 0;
-            goto label__comment_block__continue;
-          }
-          v_c2 = wuffs_base__peek_u16le__no_bounds_check(iop_a_src);
-          if (v_c2 == 12074) {
-            iop_a_src += 2;
-            *iop_a_dst++ = wuffs_base__make_token(
-                (((uint64_t)(2)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
-                (((uint64_t)((v_length + 2))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
-            self->private_impl.f_comment_type = 1;
-            status = wuffs_base__make_status(NULL);
-            goto ok;
-          }
-          iop_a_src += 1;
-          if (v_length >= 65533) {
+        if (((uint64_t)(io2_a_src - iop_a_src)) <= 1) {
+          if (v_length > 0) {
             *iop_a_dst++ = wuffs_base__make_token(
                 (((uint64_t)(2)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
                 (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) |
-                (((uint64_t)((v_length + 1))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
-            v_length = 0;
-            goto label__comment_block__continue;
+                (((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
           }
-          v_length += 1;
+          if (a_src && a_src->meta.closed) {
+            status = wuffs_base__make_status(wuffs_json__error__bad_input);
+            goto exit;
+          }
+          status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3);
+          while (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
+            status = wuffs_base__make_status(wuffs_base__suspension__short_write);
+            WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4);
+          }
+          v_length = 0;
+          goto label__comment_block__continue;
         }
+        v_c2 = wuffs_base__peek_u16le__no_bounds_check(iop_a_src);
+        if (v_c2 == 12074) {
+          iop_a_src += 2;
+          *iop_a_dst++ = wuffs_base__make_token(
+              (((uint64_t)(2)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
+              (((uint64_t)((v_length + 2))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
+          self->private_impl.f_comment_type = 1;
+          status = wuffs_base__make_status(NULL);
+          goto ok;
+        }
+        iop_a_src += 1;
+        if (v_length >= 65533) {
+          *iop_a_dst++ = wuffs_base__make_token(
+              (((uint64_t)(2)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
+              (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) |
+              (((uint64_t)((v_length + 1))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
+          while (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
+            status = wuffs_base__make_status(wuffs_base__suspension__short_write);
+            WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
+          }
+          v_length = 0;
+          goto label__comment_block__continue;
+        }
+        v_length += 1;
       }
     } else if ((v_c2 == 12079) && self->private_impl.f_quirks[12]) {
       iop_a_src += 2;
       v_length = 2;
       label__comment_line__continue:;
       while (true) {
-        if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
-          status = wuffs_base__make_status(wuffs_base__suspension__short_write);
-          WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
-          v_length = 0;
-          goto label__comment_line__continue;
-        }
-        while (true) {
-          if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
-            if (a_src && a_src->meta.closed) {
-              *iop_a_dst++ = wuffs_base__make_token(
-                  (((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
-                  (((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
-              self->private_impl.f_comment_type = 2;
-              status = wuffs_base__make_status(NULL);
-              goto ok;
-            } else if (v_length > 0) {
-              *iop_a_dst++ = wuffs_base__make_token(
-                  (((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
-                  (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) |
-                  (((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
-            }
-            status = wuffs_base__make_status(wuffs_base__suspension__short_read);
-            WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6);
-            v_length = 0;
-            goto label__comment_line__continue;
-          }
-          v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
-          if (v_c == 10) {
+        if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
+          if (a_src && a_src->meta.closed) {
             *iop_a_dst++ = wuffs_base__make_token(
                 (((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
                 (((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
             self->private_impl.f_comment_type = 2;
             status = wuffs_base__make_status(NULL);
             goto ok;
-          }
-          iop_a_src += 1;
-          if (v_length >= 65533) {
+          } else if (v_length > 0) {
             *iop_a_dst++ = wuffs_base__make_token(
                 (((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
                 (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) |
-                (((uint64_t)((v_length + 1))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
-            v_length = 0;
-            goto label__comment_line__continue;
+                (((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
           }
-          v_length += 1;
+          status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6);
+          while (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
+            status = wuffs_base__make_status(wuffs_base__suspension__short_write);
+            WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
+          }
+          v_length = 0;
+          goto label__comment_line__continue;
         }
+        v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
+        if (v_c == 10) {
+          *iop_a_dst++ = wuffs_base__make_token(
+              (((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
+              (((uint64_t)(v_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
+          self->private_impl.f_comment_type = 2;
+          status = wuffs_base__make_status(NULL);
+          goto ok;
+        }
+        iop_a_src += 1;
+        if (v_length >= 65533) {
+          *iop_a_dst++ = wuffs_base__make_token(
+              (((uint64_t)(4)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
+              (((uint64_t)(1)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) |
+              (((uint64_t)((v_length + 1))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
+          while (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
+            status = wuffs_base__make_status(wuffs_base__suspension__short_write);
+            WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(8);
+          }
+          v_length = 0;
+          goto label__comment_line__continue;
+        }
+        v_length += 1;
       }
     }
 
@@ -34294,9 +36108,6 @@
   }
 
   uint32_t coro_susp_point = self->private_impl.p_decode_inf_nan[0];
-  if (coro_susp_point) {
-    v_neg = self->private_data.s_decode_inf_nan[0].v_neg;
-  }
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
@@ -34404,7 +36215,6 @@
   goto suspend;
   suspend:
   self->private_impl.p_decode_inf_nan[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
-  self->private_data.s_decode_inf_nan[0].v_neg = v_neg;
 
   goto exit;
   exit:
@@ -34468,23 +36278,21 @@
       if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
         status = wuffs_base__make_status(wuffs_base__suspension__short_write);
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
-        v_whitespace_length = 0;
         goto label__outer__continue;
       }
+      v_whitespace_length = 0;
       while (true) {
         if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
           if (v_whitespace_length > 0) {
             *iop_a_dst++ = wuffs_base__make_token(
                 (((uint64_t)(0)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
                 (((uint64_t)(v_whitespace_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
-            v_whitespace_length = 0;
           }
           if (a_src && a_src->meta.closed) {
             goto label__outer__break;
           }
           status = wuffs_base__make_status(wuffs_base__suspension__short_read);
           WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2);
-          v_whitespace_length = 0;
           goto label__outer__continue;
         }
         v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src);
@@ -34493,7 +36301,6 @@
             *iop_a_dst++ = wuffs_base__make_token(
                 (((uint64_t)(0)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
                 (((uint64_t)(v_whitespace_length)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
-            v_whitespace_length = 0;
           }
           if (self->private_impl.f_trailer_stop > 0) {
             status = wuffs_base__make_status(wuffs_json__error__bad_input);
@@ -34516,8 +36323,6 @@
           if (status.repr) {
             goto suspend;
           }
-          v_c = 0;
-          v_whitespace_length = 0;
           if (self->private_impl.f_comment_type > 0) {
             goto label__outer__continue;
           }
@@ -34529,7 +36334,6 @@
           *iop_a_dst++ = wuffs_base__make_token(
               (((uint64_t)(0)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) |
               (((uint64_t)((v_whitespace_length + 1))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT));
-          v_whitespace_length = 0;
           if (v_c == self->private_impl.f_trailer_stop) {
             status = wuffs_base__make_status(NULL);
             goto ok;
@@ -34904,7 +36708,7 @@
           16,
           false);
     }
-    self->private_impl.f_call_sequence = 3;
+    self->private_impl.f_call_sequence = 32;
 
     goto ok;
     ok:
@@ -34972,7 +36776,8 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    if (self->private_impl.f_call_sequence < 3) {
+    if (self->private_impl.f_call_sequence == 32) {
+    } else if (self->private_impl.f_call_sequence < 32) {
       if (a_src) {
         a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
       }
@@ -34984,13 +36789,13 @@
       if (status.repr) {
         goto suspend;
       }
-    } else if (self->private_impl.f_call_sequence == 3) {
+    } else if (self->private_impl.f_call_sequence == 40) {
       if (16 != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
         status = wuffs_base__make_status(wuffs_base__error__bad_restart);
         goto exit;
       }
-    } else if (self->private_impl.f_call_sequence == 4) {
-      self->private_impl.f_call_sequence = 255;
+    } else if (self->private_impl.f_call_sequence == 64) {
+      self->private_impl.f_call_sequence = 96;
       status = wuffs_base__make_status(wuffs_base__note__end_of_data);
       goto ok;
     } else {
@@ -35013,7 +36818,7 @@
           false,
           0);
     }
-    self->private_impl.f_call_sequence = 4;
+    self->private_impl.f_call_sequence = 64;
 
     ok:
     self->private_impl.p_decode_frame_config[0] = 0;
@@ -35074,13 +36879,13 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    if (self->private_impl.f_call_sequence < 4) {
+    if (self->private_impl.f_call_sequence == 64) {
+    } else if (self->private_impl.f_call_sequence < 64) {
       WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
       status = wuffs_nie__decoder__decode_frame_config(self, NULL, a_src);
       if (status.repr) {
         goto suspend;
       }
-    } else if (self->private_impl.f_call_sequence == 4) {
     } else {
       status = wuffs_base__make_status(wuffs_base__note__end_of_data);
       goto ok;
@@ -35121,7 +36926,7 @@
       WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2);
     }
     label__0__break:;
-    self->private_impl.f_call_sequence = 255;
+    self->private_impl.f_call_sequence = 96;
 
     ok:
     self->private_impl.p_decode_frame[0] = 0;
@@ -35271,7 +37076,7 @@
     return 0;
   }
 
-  if (self->private_impl.f_call_sequence > 3) {
+  if (self->private_impl.f_call_sequence > 32) {
     return 1;
   }
   return 0;
@@ -35290,7 +37095,7 @@
     return 0;
   }
 
-  if (self->private_impl.f_call_sequence > 4) {
+  if (self->private_impl.f_call_sequence > 64) {
     return 1;
   }
   return 0;
@@ -35313,13 +37118,13 @@
         : wuffs_base__error__initialize_not_called);
   }
 
-  if (self->private_impl.f_call_sequence < 3) {
+  if (self->private_impl.f_call_sequence < 32) {
     return wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
   }
   if ((a_index != 0) || (a_io_position != 16)) {
     return wuffs_base__make_status(wuffs_base__error__bad_argument);
   }
-  self->private_impl.f_call_sequence = 3;
+  self->private_impl.f_call_sequence = 40;
   return wuffs_base__make_status(NULL);
 }
 
@@ -35864,6 +37669,7 @@
 const char wuffs_png__error__bad_header[] = "#png: bad header";
 const char wuffs_png__error__bad_text_chunk_not_latin_1[] = "#png: bad text chunk (not Latin-1)";
 const char wuffs_png__error__missing_palette[] = "#png: missing palette";
+const char wuffs_png__error__unsupported_cgbi_extension[] = "#png: unsupported CgBI extension";
 const char wuffs_png__error__unsupported_png_compression_method[] = "#png: unsupported PNG compression method";
 const char wuffs_png__error__unsupported_png_file[] = "#png: unsupported PNG file";
 const char wuffs_png__error__internal_error_inconsistent_i_o[] = "#png: internal error: inconsistent I/O";
@@ -36109,7 +37915,8 @@
 static wuffs_base__status
 wuffs_png__decoder__decode_other_chunk(
     wuffs_png__decoder* self,
-    wuffs_base__io_buffer* a_src);
+    wuffs_base__io_buffer* a_src,
+    bool a_framy);
 
 static wuffs_base__status
 wuffs_png__decoder__decode_actl(
@@ -37785,16 +39592,10 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    if (self->private_impl.f_call_sequence == 2) {
-      if (self->private_impl.f_metadata_fourcc != 0) {
-        self->private_impl.f_call_sequence = 1;
-        status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
-        goto ok;
-      }
-    } else if (self->private_impl.f_call_sequence != 0) {
+    if (self->private_impl.f_call_sequence != 0) {
       status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
       goto exit;
-    } else {
+    } else if ( ! self->private_impl.f_seen_ihdr) {
       {
         WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
         uint64_t t_0;
@@ -37858,6 +39659,10 @@
         v_magic = t_1;
       }
       if (v_magic != 5927942488114331648) {
+        if (v_magic == 5278895250759221248) {
+          status = wuffs_base__make_status(wuffs_png__error__unsupported_cgbi_extension);
+          goto exit;
+        }
         status = wuffs_base__make_status(wuffs_png__error__bad_header);
         goto exit;
       }
@@ -37923,6 +39728,11 @@
         status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
         goto exit;
       }
+      self->private_impl.f_seen_ihdr = true;
+    } else if (self->private_impl.f_metadata_fourcc != 0) {
+      self->private_impl.f_call_sequence = 16;
+      status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
+      goto ok;
     }
     while (true) {
       while (((uint64_t)(io2_a_src - iop_a_src)) < 8) {
@@ -37963,7 +39773,7 @@
           if (a_src) {
             a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
           }
-          wuffs_base__status t_4 = wuffs_png__decoder__decode_other_chunk(self, a_src);
+          wuffs_base__status t_4 = wuffs_png__decoder__decode_other_chunk(self, a_src, false);
           v_status = t_4;
           if (a_src) {
             iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -37980,7 +39790,7 @@
       }
       label__2__break:;
       if (self->private_impl.f_metadata_fourcc != 0) {
-        self->private_impl.f_call_sequence = 1;
+        self->private_impl.f_call_sequence = 16;
         status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
         goto ok;
       }
@@ -38045,7 +39855,7 @@
       self->private_impl.f_first_disposal = 0;
       self->private_impl.f_first_overwrite_instead_of_blend = false;
     }
-    self->private_impl.f_call_sequence = 3;
+    self->private_impl.f_call_sequence = 32;
 
     ok:
     self->private_impl.p_decode_image_config[0] = 0;
@@ -38425,7 +40235,8 @@
 static wuffs_base__status
 wuffs_png__decoder__decode_other_chunk(
     wuffs_png__decoder* self,
-    wuffs_base__io_buffer* a_src) {
+    wuffs_base__io_buffer* a_src,
+    bool a_framy) {
   wuffs_base__status status = wuffs_base__make_status(NULL);
 
   const uint8_t* iop_a_src = NULL;
@@ -38443,7 +40254,7 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    if (self->private_impl.f_chunk_type == 1163152464) {
+    if ((self->private_impl.f_chunk_type == 1163152464) &&  ! a_framy) {
       if (self->private_impl.f_seen_plte) {
         status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
         goto exit;
@@ -38470,43 +40281,8 @@
         status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
         goto exit;
       }
-    } else if (self->private_impl.f_chunk_type == 1280598881) {
-      if (self->private_impl.f_seen_actl) {
-        status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
-        goto exit;
-      }
-      if (a_src) {
-        a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-      }
-      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
-      status = wuffs_png__decoder__decode_actl(self, a_src);
-      if (a_src) {
-        iop_a_src = a_src->data.ptr + a_src->meta.ri;
-      }
-      if (status.repr) {
-        goto suspend;
-      }
-      self->private_impl.f_seen_actl = true;
-    } else if (self->private_impl.f_chunk_type == 1297238115) {
-      if (self->private_impl.f_report_metadata_chrm) {
-        if (self->private_impl.f_seen_chrm) {
-          status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
-          goto exit;
-        }
-        if (a_src) {
-          a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-        }
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
-        status = wuffs_png__decoder__decode_chrm(self, a_src);
-        if (a_src) {
-          iop_a_src = a_src->data.ptr + a_src->meta.ri;
-        }
-        if (status.repr) {
-          goto suspend;
-        }
-        self->private_impl.f_seen_chrm = true;
-      }
-    } else if (self->private_impl.f_chunk_type == 1716082789) {
+    }
+    if (self->private_impl.f_chunk_type == 1716082789) {
       if (self->private_impl.f_report_metadata_exif) {
         if (self->private_impl.f_seen_exif) {
           status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
@@ -38515,7 +40291,7 @@
         if (a_src) {
           a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
         }
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
+        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
         status = wuffs_png__decoder__decode_exif(self, a_src);
         if (a_src) {
           iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -38525,97 +40301,6 @@
         }
         self->private_impl.f_seen_exif = true;
       }
-    } else if (self->private_impl.f_chunk_type == 1280598886) {
-      if (self->private_impl.f_seen_fctl) {
-        status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
-        goto exit;
-      }
-      if (a_src) {
-        a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-      }
-      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
-      status = wuffs_png__decoder__decode_fctl(self, a_src);
-      if (a_src) {
-        iop_a_src = a_src->data.ptr + a_src->meta.ri;
-      }
-      if (status.repr) {
-        goto suspend;
-      }
-      self->private_impl.f_seen_fctl = true;
-    } else if (self->private_impl.f_chunk_type == 1095582055) {
-      if (self->private_impl.f_report_metadata_gama) {
-        if (self->private_impl.f_seen_gama) {
-          status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
-          goto exit;
-        }
-        if (a_src) {
-          a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-        }
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
-        status = wuffs_png__decoder__decode_gama(self, a_src);
-        if (a_src) {
-          iop_a_src = a_src->data.ptr + a_src->meta.ri;
-        }
-        if (status.repr) {
-          goto suspend;
-        }
-        self->private_impl.f_seen_gama = true;
-      }
-    } else if (self->private_impl.f_chunk_type == 1346585449) {
-      if (self->private_impl.f_report_metadata_iccp) {
-        if (self->private_impl.f_seen_iccp) {
-          status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
-          goto exit;
-        }
-        if (a_src) {
-          a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-        }
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
-        status = wuffs_png__decoder__decode_iccp(self, a_src);
-        if (a_src) {
-          iop_a_src = a_src->data.ptr + a_src->meta.ri;
-        }
-        if (status.repr) {
-          goto suspend;
-        }
-        self->private_impl.f_seen_iccp = true;
-      }
-    } else if (self->private_impl.f_chunk_type == 1111970419) {
-      if (self->private_impl.f_report_metadata_srgb) {
-        if (self->private_impl.f_seen_srgb) {
-          status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
-          goto exit;
-        }
-        if (a_src) {
-          a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-        }
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
-        status = wuffs_png__decoder__decode_srgb(self, a_src);
-        if (a_src) {
-          iop_a_src = a_src->data.ptr + a_src->meta.ri;
-        }
-        if (status.repr) {
-          goto suspend;
-        }
-        self->private_impl.f_seen_srgb = true;
-      }
-    } else if (self->private_impl.f_chunk_type == 1397641844) {
-      if (self->private_impl.f_seen_trns || (self->private_impl.f_color_type > 3) || ((self->private_impl.f_color_type == 3) &&  ! self->private_impl.f_seen_plte)) {
-        status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
-        goto exit;
-      }
-      if (a_src) {
-        a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-      }
-      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
-      status = wuffs_png__decoder__decode_trns(self, a_src);
-      if (a_src) {
-        iop_a_src = a_src->data.ptr + a_src->meta.ri;
-      }
-      if (status.repr) {
-        goto suspend;
-      }
-      self->private_impl.f_seen_trns = true;
     } else if ((self->private_impl.f_chunk_type == 1951945833) || (self->private_impl.f_chunk_type == 1951942004) || (self->private_impl.f_chunk_type == 1951945850)) {
       if (self->private_impl.f_report_metadata_kvp) {
         self->private_impl.f_metadata_flavor = 4;
@@ -38624,6 +40309,135 @@
         self->private_impl.f_metadata_y = 0;
         self->private_impl.f_metadata_z = 0;
       }
+    } else if ( ! a_framy) {
+      if (self->private_impl.f_chunk_type == 1280598881) {
+        if (self->private_impl.f_seen_actl) {
+          status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
+          goto exit;
+        }
+        if (a_src) {
+          a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+        }
+        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
+        status = wuffs_png__decoder__decode_actl(self, a_src);
+        if (a_src) {
+          iop_a_src = a_src->data.ptr + a_src->meta.ri;
+        }
+        if (status.repr) {
+          goto suspend;
+        }
+        self->private_impl.f_seen_actl = true;
+      } else if (self->private_impl.f_chunk_type == 1297238115) {
+        if (self->private_impl.f_report_metadata_chrm) {
+          if (self->private_impl.f_seen_chrm) {
+            status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
+            goto exit;
+          }
+          if (a_src) {
+            a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+          }
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
+          status = wuffs_png__decoder__decode_chrm(self, a_src);
+          if (a_src) {
+            iop_a_src = a_src->data.ptr + a_src->meta.ri;
+          }
+          if (status.repr) {
+            goto suspend;
+          }
+          self->private_impl.f_seen_chrm = true;
+        }
+      } else if (self->private_impl.f_chunk_type == 1280598886) {
+        if (self->private_impl.f_seen_fctl) {
+          status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
+          goto exit;
+        }
+        if (a_src) {
+          a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+        }
+        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
+        status = wuffs_png__decoder__decode_fctl(self, a_src);
+        if (a_src) {
+          iop_a_src = a_src->data.ptr + a_src->meta.ri;
+        }
+        if (status.repr) {
+          goto suspend;
+        }
+        self->private_impl.f_seen_fctl = true;
+      } else if (self->private_impl.f_chunk_type == 1095582055) {
+        if (self->private_impl.f_report_metadata_gama) {
+          if (self->private_impl.f_seen_gama) {
+            status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
+            goto exit;
+          }
+          if (a_src) {
+            a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+          }
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
+          status = wuffs_png__decoder__decode_gama(self, a_src);
+          if (a_src) {
+            iop_a_src = a_src->data.ptr + a_src->meta.ri;
+          }
+          if (status.repr) {
+            goto suspend;
+          }
+          self->private_impl.f_seen_gama = true;
+        }
+      } else if (self->private_impl.f_chunk_type == 1346585449) {
+        if (self->private_impl.f_report_metadata_iccp) {
+          if (self->private_impl.f_seen_iccp) {
+            status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
+            goto exit;
+          }
+          if (a_src) {
+            a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+          }
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
+          status = wuffs_png__decoder__decode_iccp(self, a_src);
+          if (a_src) {
+            iop_a_src = a_src->data.ptr + a_src->meta.ri;
+          }
+          if (status.repr) {
+            goto suspend;
+          }
+          self->private_impl.f_seen_iccp = true;
+        }
+      } else if (self->private_impl.f_chunk_type == 1111970419) {
+        if (self->private_impl.f_report_metadata_srgb) {
+          if (self->private_impl.f_seen_srgb) {
+            status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
+            goto exit;
+          }
+          if (a_src) {
+            a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+          }
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
+          status = wuffs_png__decoder__decode_srgb(self, a_src);
+          if (a_src) {
+            iop_a_src = a_src->data.ptr + a_src->meta.ri;
+          }
+          if (status.repr) {
+            goto suspend;
+          }
+          self->private_impl.f_seen_srgb = true;
+        }
+      } else if (self->private_impl.f_chunk_type == 1397641844) {
+        if (self->private_impl.f_seen_trns || (self->private_impl.f_color_type > 3) || ((self->private_impl.f_color_type == 3) &&  ! self->private_impl.f_seen_plte)) {
+          status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
+          goto exit;
+        }
+        if (a_src) {
+          a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+        }
+        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
+        status = wuffs_png__decoder__decode_trns(self, a_src);
+        if (a_src) {
+          iop_a_src = a_src->data.ptr + a_src->meta.ri;
+        }
+        if (status.repr) {
+          goto suspend;
+        }
+        self->private_impl.f_seen_trns = true;
+      }
     }
     if (self->private_impl.f_metadata_fourcc == 0) {
       self->private_data.s_decode_other_chunk[0].scratch = self->private_impl.f_chunk_length;
@@ -39991,6 +41805,8 @@
   self->private_impl.active_coroutine = 0;
   wuffs_base__status status = wuffs_base__make_status(NULL);
 
+  uint32_t v_checksum_have = 0;
+
   const uint8_t* iop_a_src = NULL;
   const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
   const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
@@ -40006,10 +41822,11 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    if (self->private_impl.f_call_sequence == 255) {
-      status = wuffs_base__make_status(wuffs_base__note__end_of_data);
-      goto ok;
-    } else if (self->private_impl.f_call_sequence < 3) {
+    if ((self->private_impl.f_call_sequence & 16) != 0) {
+      status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
+      goto exit;
+    } else if (self->private_impl.f_call_sequence == 32) {
+    } else if (self->private_impl.f_call_sequence < 32) {
       if (a_src) {
         a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
       }
@@ -40021,12 +41838,12 @@
       if (status.repr) {
         goto suspend;
       }
-    } else if (self->private_impl.f_call_sequence == 3) {
+    } else if (self->private_impl.f_call_sequence == 40) {
       if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
         status = wuffs_base__make_status(wuffs_base__error__bad_restart);
         goto exit;
       }
-    } else if (self->private_impl.f_call_sequence == 4) {
+    } else if (self->private_impl.f_call_sequence == 64) {
       if (a_src) {
         a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
       }
@@ -40038,10 +41855,14 @@
       if (status.repr) {
         goto suspend;
       }
-      if (self->private_impl.f_call_sequence == 255) {
-        status = wuffs_base__make_status(wuffs_base__note__end_of_data);
-        goto ok;
-      }
+    } else {
+      status = wuffs_base__make_status(wuffs_base__note__end_of_data);
+      goto ok;
+    }
+    if (self->private_impl.f_metadata_fourcc != 0) {
+      self->private_impl.f_call_sequence = 48;
+      status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
+      goto ok;
     }
     if (self->private_impl.f_num_decoded_frame_configs_value == 0) {
       self->private_impl.f_frame_rect_x0 = self->private_impl.f_first_rect_x0;
@@ -40112,7 +41933,48 @@
           }
           self->private_impl.f_chunk_type = t_1;
         }
-        if (self->private_impl.f_chunk_type == 1413571686) {
+        if (self->private_impl.f_chunk_type == 1145980233) {
+          if (self->private_impl.f_chunk_length != 0) {
+            status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
+            goto exit;
+          }
+          {
+            WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
+            uint32_t t_2;
+            if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
+              t_2 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
+              iop_a_src += 4;
+            } else {
+              self->private_data.s_decode_frame_config[0].scratch = 0;
+              WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
+              while (true) {
+                if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
+                  status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+                  goto suspend;
+                }
+                uint64_t* scratch = &self->private_data.s_decode_frame_config[0].scratch;
+                uint32_t num_bits_2 = ((uint32_t)(*scratch >> 56));
+                *scratch <<= 8;
+                *scratch >>= 8;
+                *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_2;
+                if (num_bits_2 == 24) {
+                  t_2 = ((uint32_t)(*scratch));
+                  break;
+                }
+                num_bits_2 += 8;
+                *scratch |= ((uint64_t)(num_bits_2)) << 56;
+              }
+            }
+            v_checksum_have = t_2;
+          }
+          if ( ! self->private_impl.f_ignore_checksum && (v_checksum_have != 2187346606)) {
+            status = wuffs_base__make_status(wuffs_png__error__bad_checksum);
+            goto exit;
+          }
+          self->private_impl.f_call_sequence = 96;
+          status = wuffs_base__make_status(wuffs_base__note__end_of_data);
+          goto ok;
+        } else if (self->private_impl.f_chunk_type == 1413571686) {
           status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
           goto exit;
         } else if (self->private_impl.f_chunk_type == 1280598886) {
@@ -40120,7 +41982,7 @@
           if (a_src) {
             a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
           }
-          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
           status = wuffs_png__decoder__decode_fctl(self, a_src);
           if (a_src) {
             iop_a_src = a_src->data.ptr + a_src->meta.ri;
@@ -40129,7 +41991,7 @@
             goto suspend;
           }
           self->private_data.s_decode_frame_config[0].scratch = 4;
-          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
           if (self->private_data.s_decode_frame_config[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
             self->private_data.s_decode_frame_config[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
             iop_a_src = io2_a_src;
@@ -40139,8 +42001,24 @@
           iop_a_src += self->private_data.s_decode_frame_config[0].scratch;
           goto label__0__break;
         }
-        self->private_data.s_decode_frame_config[0].scratch = (((uint64_t)(self->private_impl.f_chunk_length)) + 4);
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
+        if (a_src) {
+          a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+        }
+        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
+        status = wuffs_png__decoder__decode_other_chunk(self, a_src, true);
+        if (a_src) {
+          iop_a_src = a_src->data.ptr + a_src->meta.ri;
+        }
+        if (status.repr) {
+          goto suspend;
+        }
+        if (self->private_impl.f_metadata_fourcc != 0) {
+          self->private_impl.f_call_sequence = 48;
+          status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
+          goto ok;
+        }
+        self->private_data.s_decode_frame_config[0].scratch = 4;
+        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12);
         if (self->private_data.s_decode_frame_config[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
           self->private_data.s_decode_frame_config[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
           iop_a_src = io2_a_src;
@@ -40169,7 +42047,7 @@
           0);
     }
     wuffs_base__u32__sat_add_indirect(&self->private_impl.f_num_decoded_frame_configs_value, 1);
-    self->private_impl.f_call_sequence = 4;
+    self->private_impl.f_call_sequence = 64;
 
     ok:
     self->private_impl.p_decode_frame_config[0] = 0;
@@ -40325,11 +42203,7 @@
     }
     label__0__break:;
     wuffs_base__u32__sat_add_indirect(&self->private_impl.f_num_decoded_frames_value, 1);
-    if (self->private_impl.f_num_decoded_frames_value < self->private_impl.f_num_animation_frames_value) {
-      self->private_impl.f_call_sequence = 5;
-    } else {
-      self->private_impl.f_call_sequence = 255;
-    }
+    self->private_impl.f_call_sequence = 32;
 
     ok:
     self->private_impl.p_skip_frame[0] = 0;
@@ -40400,10 +42274,13 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    if (self->private_impl.f_call_sequence == 255) {
+    if ((self->private_impl.f_call_sequence & 16) != 0) {
+      status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
+      goto exit;
+    } else if (self->private_impl.f_call_sequence >= 96) {
       status = wuffs_base__make_status(wuffs_base__note__end_of_data);
       goto ok;
-    } else if (self->private_impl.f_call_sequence != 4) {
+    } else if (self->private_impl.f_call_sequence != 64) {
       if (a_src) {
         a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
       }
@@ -40540,17 +42417,34 @@
       if ((v_pass_width > 0) && (v_pass_height > 0)) {
         self->private_impl.f_pass_bytes_per_row = wuffs_png__decoder__calculate_bytes_per_row(self, v_pass_width);
         self->private_impl.f_pass_workbuf_length = (((uint64_t)(v_pass_height)) * (1 + self->private_impl.f_pass_bytes_per_row));
-        if (a_src) {
-          a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+        while (true) {
+          {
+            if (a_src) {
+              a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
+            }
+            wuffs_base__status t_1 = wuffs_png__decoder__decode_pass(self, a_src, a_workbuf);
+            v_status = t_1;
+            if (a_src) {
+              iop_a_src = a_src->data.ptr + a_src->meta.ri;
+            }
+          }
+          if (wuffs_base__status__is_ok(&v_status)) {
+            goto label__1__break;
+          } else if (wuffs_base__status__is_error(&v_status) || ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed))) {
+            if (self->private_impl.f_workbuf_wi <= ((uint64_t)(a_workbuf.len))) {
+              wuffs_png__decoder__filter_and_swizzle(self, a_dst, wuffs_base__slice_u8__subslice_j(a_workbuf, self->private_impl.f_workbuf_wi));
+            }
+            if (v_status.repr == wuffs_base__suspension__short_read) {
+              while (true) {
+                status = wuffs_base__make_status(wuffs_base__suspension__short_read);
+                WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6);
+              }
+            }
+          }
+          status = v_status;
+          WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
         }
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
-        status = wuffs_png__decoder__decode_pass(self, a_src, a_workbuf);
-        if (a_src) {
-          iop_a_src = a_src->data.ptr + a_src->meta.ri;
-        }
-        if (status.repr) {
-          goto suspend;
-        }
+        label__1__break:;
         v_status = wuffs_png__decoder__filter_and_swizzle(self, a_dst, a_workbuf);
         if ( ! wuffs_base__status__is_ok(&v_status)) {
           status = v_status;
@@ -40565,7 +42459,7 @@
         self->private_impl.f_workbuf_hist_pos_base += self->private_impl.f_pass_workbuf_length;
       }
       if ((self->private_impl.f_interlace_pass == 0) || (self->private_impl.f_interlace_pass >= 7)) {
-        goto label__1__break;
+        goto label__2__break;
       }
 #if defined(__GNUC__)
 #pragma GCC diagnostic push
@@ -40576,13 +42470,9 @@
 #pragma GCC diagnostic pop
 #endif
     }
-    label__1__break:;
+    label__2__break:;
     wuffs_base__u32__sat_add_indirect(&self->private_impl.f_num_decoded_frames_value, 1);
-    if (self->private_impl.f_num_decoded_frames_value < self->private_impl.f_num_animation_frames_value) {
-      self->private_impl.f_call_sequence = 5;
-    } else {
-      self->private_impl.f_call_sequence = 255;
-    }
+    self->private_impl.f_call_sequence = 32;
 
     ok:
     self->private_impl.p_decode_frame[0] = 0;
@@ -41030,12 +42920,12 @@
         : wuffs_base__error__initialize_not_called);
   }
 
-  if (self->private_impl.f_call_sequence < 3) {
+  if (self->private_impl.f_call_sequence < 32) {
     return wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
   } else if ((a_index >= ((uint64_t)(self->private_impl.f_num_animation_frames_value))) || ((a_index == 0) && (a_io_position != self->private_impl.f_first_config_io_position))) {
     return wuffs_base__make_status(wuffs_base__error__bad_argument);
   }
-  self->private_impl.f_call_sequence = 3;
+  self->private_impl.f_call_sequence = 40;
   if (self->private_impl.f_interlace_pass >= 1) {
     self->private_impl.f_interlace_pass = 1;
   }
@@ -41148,7 +43038,7 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    if (self->private_impl.f_call_sequence != 1) {
+    if ((self->private_impl.f_call_sequence & 16) == 0) {
       status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
       goto exit;
     }
@@ -41362,7 +43252,6 @@
                 if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
                   status = wuffs_base__make_status(wuffs_base__suspension__short_write);
                   WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4);
-                  v_c2 = 0;
                   goto label__loop__continue;
                 }
                 self->private_impl.f_ztxt_ri += 1;
@@ -41371,7 +43260,6 @@
                 if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 1) {
                   status = wuffs_base__make_status(wuffs_base__suspension__short_write);
                   WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
-                  v_c2 = 0;
                   goto label__loop__continue;
                 }
                 self->private_impl.f_ztxt_ri += 1;
@@ -41443,7 +43331,6 @@
               if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) {
                 status = wuffs_base__make_status(wuffs_base__suspension__short_write);
                 WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10);
-                v_c2 = 0;
                 goto label__loop__continue;
               }
               self->private_impl.f_chunk_length -= 1;
@@ -41453,7 +43340,6 @@
               if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 1) {
                 status = wuffs_base__make_status(wuffs_base__suspension__short_write);
                 WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11);
-                v_c2 = 0;
                 goto label__loop__continue;
               }
               self->private_impl.f_chunk_length -= 1;
@@ -41547,7 +43433,7 @@
           }
           self->private_impl.f_metadata_is_zlib_compressed = true;
         }
-        self->private_impl.f_call_sequence = 2;
+        self->private_impl.f_call_sequence &= 239;
         status = wuffs_base__make_status(NULL);
         goto ok;
       }
@@ -41572,7 +43458,7 @@
     self->private_impl.f_metadata_x = 0;
     self->private_impl.f_metadata_y = 0;
     self->private_impl.f_metadata_z = 0;
-    self->private_impl.f_call_sequence = 2;
+    self->private_impl.f_call_sequence &= 239;
     status = wuffs_base__make_status(NULL);
     goto ok;
 
@@ -42563,7 +44449,7 @@
           self->private_impl.f_frame_config_io_position,
           self->private_impl.f_opaque);
     }
-    self->private_impl.f_call_sequence = 3;
+    self->private_impl.f_call_sequence = 32;
 
     goto ok;
     ok:
@@ -42632,7 +44518,8 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    if (self->private_impl.f_call_sequence < 3) {
+    if (self->private_impl.f_call_sequence == 32) {
+    } else if (self->private_impl.f_call_sequence < 32) {
       if (a_src) {
         a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
       }
@@ -42644,13 +44531,13 @@
       if (status.repr) {
         goto suspend;
       }
-    } else if (self->private_impl.f_call_sequence == 3) {
+    } else if (self->private_impl.f_call_sequence == 40) {
       if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
         status = wuffs_base__make_status(wuffs_base__error__bad_restart);
         goto exit;
       }
-    } else if (self->private_impl.f_call_sequence == 4) {
-      self->private_impl.f_call_sequence = 255;
+    } else if (self->private_impl.f_call_sequence == 64) {
+      self->private_impl.f_call_sequence = 96;
       status = wuffs_base__make_status(wuffs_base__note__end_of_data);
       goto ok;
     } else {
@@ -42673,7 +44560,7 @@
           false,
           4278190080);
     }
-    self->private_impl.f_call_sequence = 4;
+    self->private_impl.f_call_sequence = 64;
 
     ok:
     self->private_impl.p_decode_frame_config[0] = 0;
@@ -42774,7 +44661,8 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    if (self->private_impl.f_call_sequence < 4) {
+    if (self->private_impl.f_call_sequence == 64) {
+    } else if (self->private_impl.f_call_sequence < 64) {
       if (a_src) {
         a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
       }
@@ -42786,7 +44674,6 @@
       if (status.repr) {
         goto suspend;
       }
-    } else if (self->private_impl.f_call_sequence == 4) {
     } else {
       status = wuffs_base__make_status(wuffs_base__note__end_of_data);
       goto ok;
@@ -42867,7 +44754,7 @@
               }
             } else if (v_run_length > 0) {
               v_run_length -= 1;
-              wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__slice_u8__subslice_j(wuffs_base__make_slice_u8(self->private_data.f_scratch, 4), self->private_impl.f_scratch_bytes_per_pixel));
+              wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__make_slice_u8(self->private_data.f_scratch, self->private_impl.f_scratch_bytes_per_pixel));
               if (v_dst_bytes_per_pixel <= ((uint64_t)(v_dst.len))) {
                 v_dst = wuffs_base__slice_u8__subslice_i(v_dst, v_dst_bytes_per_pixel);
               }
@@ -42957,7 +44844,7 @@
               v_lit_length -= 1;
             } else if (v_run_length > 0) {
               v_run_length -= 1;
-              wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__slice_u8__subslice_j(wuffs_base__make_slice_u8(self->private_data.f_scratch, 4), self->private_impl.f_scratch_bytes_per_pixel));
+              wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, v_dst_palette, wuffs_base__make_slice_u8(self->private_data.f_scratch, self->private_impl.f_scratch_bytes_per_pixel));
               if (v_dst_bytes_per_pixel <= ((uint64_t)(v_dst.len))) {
                 v_dst = wuffs_base__slice_u8__subslice_i(v_dst, v_dst_bytes_per_pixel);
               }
@@ -43013,7 +44900,7 @@
       goto label__resume__break;
     }
     label__resume__break:;
-    self->private_impl.f_call_sequence = 255;
+    self->private_impl.f_call_sequence = 96;
 
     ok:
     self->private_impl.p_decode_frame[0] = 0;
@@ -43094,7 +44981,7 @@
     return 0;
   }
 
-  if (self->private_impl.f_call_sequence > 3) {
+  if (self->private_impl.f_call_sequence > 32) {
     return 1;
   }
   return 0;
@@ -43113,7 +45000,7 @@
     return 0;
   }
 
-  if (self->private_impl.f_call_sequence > 4) {
+  if (self->private_impl.f_call_sequence > 64) {
     return 1;
   }
   return 0;
@@ -43136,13 +45023,13 @@
         : wuffs_base__error__initialize_not_called);
   }
 
-  if (self->private_impl.f_call_sequence < 3) {
+  if (self->private_impl.f_call_sequence < 32) {
     return wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
   }
   if (a_index != 0) {
     return wuffs_base__make_status(wuffs_base__error__bad_argument);
   }
-  self->private_impl.f_call_sequence = 3;
+  self->private_impl.f_call_sequence = 40;
   self->private_impl.f_frame_config_io_position = a_io_position;
   return wuffs_base__make_status(NULL);
 }
@@ -43462,7 +45349,7 @@
           self->private_impl.f_frame_config_io_position,
           true);
     }
-    self->private_impl.f_call_sequence = 3;
+    self->private_impl.f_call_sequence = 32;
 
     goto ok;
     ok:
@@ -43532,7 +45419,8 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    if (self->private_impl.f_call_sequence < 3) {
+    if (self->private_impl.f_call_sequence == 32) {
+    } else if (self->private_impl.f_call_sequence < 32) {
       if (a_src) {
         a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
       }
@@ -43544,13 +45432,13 @@
       if (status.repr) {
         goto suspend;
       }
-    } else if (self->private_impl.f_call_sequence == 3) {
+    } else if (self->private_impl.f_call_sequence == 40) {
       if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
         status = wuffs_base__make_status(wuffs_base__error__bad_restart);
         goto exit;
       }
-    } else if (self->private_impl.f_call_sequence == 4) {
-      self->private_impl.f_call_sequence = 255;
+    } else if (self->private_impl.f_call_sequence == 64) {
+      self->private_impl.f_call_sequence = 96;
       status = wuffs_base__make_status(wuffs_base__note__end_of_data);
       goto ok;
     } else {
@@ -43573,7 +45461,7 @@
           false,
           4278190080);
     }
-    self->private_impl.f_call_sequence = 4;
+    self->private_impl.f_call_sequence = 64;
 
     ok:
     self->private_impl.p_decode_frame_config[0] = 0;
@@ -43662,7 +45550,8 @@
   switch (coro_susp_point) {
     WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
 
-    if (self->private_impl.f_call_sequence < 4) {
+    if (self->private_impl.f_call_sequence == 64) {
+    } else if (self->private_impl.f_call_sequence < 64) {
       if (a_src) {
         a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
       }
@@ -43674,7 +45563,6 @@
       if (status.repr) {
         goto suspend;
       }
-    } else if (self->private_impl.f_call_sequence == 4) {
     } else {
       status = wuffs_base__make_status(wuffs_base__note__end_of_data);
       goto ok;
@@ -43737,7 +45625,7 @@
         v_dst_y += 1;
       }
     }
-    self->private_impl.f_call_sequence = 255;
+    self->private_impl.f_call_sequence = 96;
 
     ok:
     self->private_impl.p_decode_frame[0] = 0;
@@ -43815,7 +45703,7 @@
     return 0;
   }
 
-  if (self->private_impl.f_call_sequence > 3) {
+  if (self->private_impl.f_call_sequence > 32) {
     return 1;
   }
   return 0;
@@ -43834,7 +45722,7 @@
     return 0;
   }
 
-  if (self->private_impl.f_call_sequence > 4) {
+  if (self->private_impl.f_call_sequence > 64) {
     return 1;
   }
   return 0;
@@ -43857,13 +45745,13 @@
         : wuffs_base__error__initialize_not_called);
   }
 
-  if (self->private_impl.f_call_sequence < 3) {
+  if (self->private_impl.f_call_sequence < 32) {
     return wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
   }
   if (a_index != 0) {
     return wuffs_base__make_status(wuffs_base__error__bad_argument);
   }
-  self->private_impl.f_call_sequence = 3;
+  self->private_impl.f_call_sequence = 40;
   self->private_impl.f_frame_config_io_position = a_io_position;
   return wuffs_base__make_status(NULL);
 }
@@ -44915,6 +46803,7 @@
   wuffs_base__image_config image_config = wuffs_base__null_image_config();
   sync_io::DynIOBuffer raw_metadata_buf(max_incl_metadata_length);
   uint64_t start_pos = io_buf.reader_position();
+  bool interested_in_metadata_after_the_frame = false;
   bool redirected = false;
   int32_t fourcc = 0;
 redirect:
@@ -44989,6 +46878,7 @@
         image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__CHRM, true);
       }
       if (flags & DecodeImageArgFlags::REPORT_METADATA_EXIF) {
+        interested_in_metadata_after_the_frame = true;
         image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__EXIF, true);
       }
       if (flags & DecodeImageArgFlags::REPORT_METADATA_GAMA) {
@@ -44998,12 +46888,14 @@
         image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__ICCP, true);
       }
       if (flags & DecodeImageArgFlags::REPORT_METADATA_KVP) {
+        interested_in_metadata_after_the_frame = true;
         image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__KVP, true);
       }
       if (flags & DecodeImageArgFlags::REPORT_METADATA_SRGB) {
         image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__SRGB, true);
       }
       if (flags & DecodeImageArgFlags::REPORT_METADATA_XMP) {
+        interested_in_metadata_after_the_frame = true;
         image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__XMP, true);
       }
     }
@@ -45038,7 +46930,9 @@
       }
     }
   } while (false);
-  raw_metadata_buf.drop();
+  if (!interested_in_metadata_after_the_frame) {
+    raw_metadata_buf.drop();
+  }
 
   // Select the pixel format.
   uint32_t w = image_config.pixcfg.width();
@@ -45099,6 +46993,12 @@
         image_decoder->decode_frame_config(&frame_config, &io_buf);
     if (id_dfc_status.repr == nullptr) {
       break;
+    } else if (id_dfc_status.repr == wuffs_base__note__metadata_reported) {
+      std::string error_message = DecodeImageHandleMetadata(
+          image_decoder, callbacks, input, io_buf, raw_metadata_buf);
+      if (!error_message.empty()) {
+        return DecodeImageResult(std::move(error_message));
+      }
     } else if (id_dfc_status.repr != wuffs_base__suspension__short_read) {
       return DecodeImageResult(id_dfc_status.message());
     } else if (io_buf.meta.closed) {
@@ -45140,6 +47040,35 @@
       }
     }
   }
+
+  // Decode any metadata after the frame.
+  if (interested_in_metadata_after_the_frame) {
+    while (true) {
+      wuffs_base__status id_dfc_status =
+          image_decoder->decode_frame_config(NULL, &io_buf);
+      if (id_dfc_status.repr == wuffs_base__note__end_of_data) {
+        break;
+      } else if (id_dfc_status.repr == nullptr) {
+        continue;
+      } else if (id_dfc_status.repr == wuffs_base__note__metadata_reported) {
+        std::string error_message = DecodeImageHandleMetadata(
+            image_decoder, callbacks, input, io_buf, raw_metadata_buf);
+        if (!error_message.empty()) {
+          return DecodeImageResult(std::move(error_message));
+        }
+      } else if (id_dfc_status.repr != wuffs_base__suspension__short_read) {
+        return DecodeImageResult(id_dfc_status.message());
+      } else if (io_buf.meta.closed) {
+        return DecodeImageResult(DecodeImage_UnexpectedEndOfFile);
+      } else {
+        std::string error_message = input.CopyIn(&io_buf);
+        if (!error_message.empty()) {
+          return DecodeImageResult(std::move(error_message));
+        }
+      }
+    }
+  }
+
   return DecodeImageResult(std::move(alloc_pixbuf_result.mem_owner),
                            pixel_buffer, std::move(message));
 }