diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c
index dae44d4..d82edab 100644
--- a/release/c/wuffs-unsupported-snapshot.c
+++ b/release/c/wuffs-unsupported-snapshot.c
@@ -6750,8 +6750,6 @@
 
 // ---------------- Struct Declarations
 
-typedef struct wuffs_gif__config_decoder__struct wuffs_gif__config_decoder;
-
 typedef struct wuffs_gif__decoder__struct wuffs_gif__decoder;
 
 // ---------------- Public Initializer Prototypes
@@ -6763,16 +6761,6 @@
 // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
 
 wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
-wuffs_gif__config_decoder__initialize(
-    wuffs_gif__config_decoder* self,
-    size_t sizeof_star_self,
-    uint64_t wuffs_version,
-    uint32_t options);
-
-size_t
-sizeof__wuffs_gif__config_decoder();
-
-wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
 wuffs_gif__decoder__initialize(
     wuffs_gif__decoder* self,
     size_t sizeof_star_self,
@@ -6790,14 +6778,6 @@
 // calling free on the returned pointer. That pointer is effectively a C++
 // std::unique_ptr<T, decltype(&free)>.
 
-wuffs_gif__config_decoder*
-wuffs_gif__config_decoder__alloc();
-
-static inline wuffs_base__image_decoder*
-wuffs_gif__config_decoder__alloc_as__wuffs_base__image_decoder() {
-  return (wuffs_base__image_decoder*)(wuffs_gif__config_decoder__alloc());
-}
-
 wuffs_gif__decoder*
 wuffs_gif__decoder__alloc();
 
@@ -6809,12 +6789,6 @@
 // ---------------- Upcasts
 
 static inline wuffs_base__image_decoder*
-wuffs_gif__config_decoder__upcast_as__wuffs_base__image_decoder(
-    wuffs_gif__config_decoder* p) {
-  return (wuffs_base__image_decoder*)p;
-}
-
-static inline wuffs_base__image_decoder*
 wuffs_gif__decoder__upcast_as__wuffs_base__image_decoder(
     wuffs_gif__decoder* p) {
   return (wuffs_base__image_decoder*)p;
@@ -6823,72 +6797,6 @@
 // ---------------- Public Function Prototypes
 
 WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
-wuffs_gif__config_decoder__set_quirk_enabled(
-    wuffs_gif__config_decoder* self,
-    uint32_t a_quirk,
-    bool a_enabled);
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__status
-wuffs_gif__config_decoder__decode_image_config(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__image_config* a_dst,
-    wuffs_base__io_buffer* a_src);
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
-wuffs_gif__config_decoder__set_report_metadata(
-    wuffs_gif__config_decoder* self,
-    uint32_t a_fourcc,
-    bool a_report);
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__status
-wuffs_gif__config_decoder__tell_me_more(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_dst,
-    wuffs_base__more_information* a_minfo,
-    wuffs_base__io_buffer* a_src);
-
-WUFFS_BASE__MAYBE_STATIC uint32_t
-wuffs_gif__config_decoder__num_animation_loops(
-    const wuffs_gif__config_decoder* self);
-
-WUFFS_BASE__MAYBE_STATIC uint64_t
-wuffs_gif__config_decoder__num_decoded_frame_configs(
-    const wuffs_gif__config_decoder* self);
-
-WUFFS_BASE__MAYBE_STATIC uint64_t
-wuffs_gif__config_decoder__num_decoded_frames(
-    const wuffs_gif__config_decoder* self);
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32
-wuffs_gif__config_decoder__frame_dirty_rect(
-    const wuffs_gif__config_decoder* self);
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64
-wuffs_gif__config_decoder__workbuf_len(
-    const wuffs_gif__config_decoder* self);
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__status
-wuffs_gif__config_decoder__restart_frame(
-    wuffs_gif__config_decoder* self,
-    uint64_t a_index,
-    uint64_t a_io_position);
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__status
-wuffs_gif__config_decoder__decode_frame_config(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__frame_config* a_dst,
-    wuffs_base__io_buffer* a_src);
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__status
-wuffs_gif__config_decoder__decode_frame(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__pixel_buffer* a_dst,
-    wuffs_base__io_buffer* a_src,
-    wuffs_base__pixel_blend a_blend,
-    wuffs_base__slice_u8 a_workbuf,
-    wuffs_base__decode_frame_options* a_opts);
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
 wuffs_gif__decoder__set_quirk_enabled(
     wuffs_gif__decoder* self,
     uint32_t a_quirk,
@@ -6963,245 +6871,6 @@
 
 #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION)
 
-struct wuffs_gif__config_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__image_decoder;
-    wuffs_base__vtable null_vtable;
-
-    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_has_global_palette;
-    uint8_t f_interlace;
-    bool f_seen_num_loops;
-    uint32_t f_num_loops;
-    uint32_t f_background_color_u32_argb_premul;
-    uint32_t f_black_color_u32_argb_premul;
-    bool f_gc_has_transparent_index;
-    uint8_t f_gc_transparent_index;
-    uint8_t f_gc_disposal;
-    uint64_t f_gc_duration;
-    uint64_t f_frame_config_io_position;
-    uint64_t f_num_decoded_frame_configs_value;
-    uint64_t f_num_decoded_frames_value;
-    uint32_t f_frame_rect_x0;
-    uint32_t f_frame_rect_y0;
-    uint32_t f_frame_rect_x1;
-    uint32_t f_frame_rect_y1;
-
-    uint32_t p_decode_image_config[1];
-    uint32_t p_tell_me_more[1];
-    uint32_t p_decode_frame_config[1];
-    uint32_t p_skip_frame[1];
-    uint32_t p_decode_up_to_id_part1[1];
-    uint32_t p_decode_header[1];
-    uint32_t p_decode_lsd[1];
-    uint32_t p_decode_extension[1];
-    uint32_t p_skip_blocks[1];
-    uint32_t p_decode_ae[1];
-    uint32_t p_decode_gc[1];
-    uint32_t p_decode_id_part0[1];
-  } private_impl;
-
-  struct {
-    uint8_t f_palettes[1][1024];
-
-    struct {
-      uint32_t v_background_color;
-    } s_decode_frame_config[1];
-    struct {
-      uint64_t scratch;
-    } s_skip_frame[1];
-    struct {
-      uint8_t v_c[6];
-      uint32_t v_i;
-    } s_decode_header[1];
-    struct {
-      uint8_t v_flags;
-      uint8_t v_background_color_index;
-      uint32_t v_num_palette_entries;
-      uint32_t v_i;
-      uint64_t scratch;
-    } s_decode_lsd[1];
-    struct {
-      uint64_t scratch;
-    } s_skip_blocks[1];
-    struct {
-      uint8_t v_block_size;
-      bool v_is_animexts;
-      bool v_is_netscape;
-      bool v_is_iccp;
-      bool v_is_xmp;
-      uint64_t scratch;
-    } s_decode_ae[1];
-    struct {
-      uint64_t scratch;
-    } s_decode_gc[1];
-    struct {
-      uint64_t scratch;
-    } s_decode_id_part0[1];
-  } private_data;
-
-#ifdef __cplusplus
-#if (__cplusplus >= 201103L)
-  using unique_ptr = std::unique_ptr<wuffs_gif__config_decoder, decltype(&free)>;
-
-  // On failure, the alloc_etc functions return nullptr. They don't throw.
-
-  static inline unique_ptr
-  alloc() {
-    return unique_ptr(wuffs_gif__config_decoder__alloc(), &free);
-  }
-
-  static inline wuffs_base__image_decoder::unique_ptr
-  alloc_as__wuffs_base__image_decoder() {
-    return wuffs_base__image_decoder::unique_ptr(
-        wuffs_gif__config_decoder__alloc_as__wuffs_base__image_decoder(), &free);
-  }
-#endif  // (__cplusplus >= 201103L)
-
-#if (__cplusplus >= 201103L) && !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_gif__config_decoder__struct() = delete;
-  wuffs_gif__config_decoder__struct(const wuffs_gif__config_decoder__struct&) = delete;
-  wuffs_gif__config_decoder__struct& operator=(
-      const wuffs_gif__config_decoder__struct&) = delete;
-
-  // 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  // (__cplusplus >= 201103L) && !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_gif__config_decoder__initialize(
-        this, sizeof_star_self, wuffs_version, options);
-  }
-
-  inline wuffs_base__image_decoder*
-  upcast_as__wuffs_base__image_decoder() {
-    return (wuffs_base__image_decoder*)this;
-  }
-
-  inline wuffs_base__empty_struct
-  set_quirk_enabled(
-      uint32_t a_quirk,
-      bool a_enabled) {
-    return wuffs_gif__config_decoder__set_quirk_enabled(this, a_quirk, a_enabled);
-  }
-
-  inline wuffs_base__status
-  decode_image_config(
-      wuffs_base__image_config* a_dst,
-      wuffs_base__io_buffer* a_src) {
-    return wuffs_gif__config_decoder__decode_image_config(this, a_dst, a_src);
-  }
-
-  inline wuffs_base__empty_struct
-  set_report_metadata(
-      uint32_t a_fourcc,
-      bool a_report) {
-    return wuffs_gif__config_decoder__set_report_metadata(this, a_fourcc, a_report);
-  }
-
-  inline wuffs_base__status
-  tell_me_more(
-      wuffs_base__io_buffer* a_dst,
-      wuffs_base__more_information* a_minfo,
-      wuffs_base__io_buffer* a_src) {
-    return wuffs_gif__config_decoder__tell_me_more(this, a_dst, a_minfo, a_src);
-  }
-
-  inline uint32_t
-  num_animation_loops() const {
-    return wuffs_gif__config_decoder__num_animation_loops(this);
-  }
-
-  inline uint64_t
-  num_decoded_frame_configs() const {
-    return wuffs_gif__config_decoder__num_decoded_frame_configs(this);
-  }
-
-  inline uint64_t
-  num_decoded_frames() const {
-    return wuffs_gif__config_decoder__num_decoded_frames(this);
-  }
-
-  inline wuffs_base__rect_ie_u32
-  frame_dirty_rect() const {
-    return wuffs_gif__config_decoder__frame_dirty_rect(this);
-  }
-
-  inline wuffs_base__range_ii_u64
-  workbuf_len() const {
-    return wuffs_gif__config_decoder__workbuf_len(this);
-  }
-
-  inline wuffs_base__status
-  restart_frame(
-      uint64_t a_index,
-      uint64_t a_io_position) {
-    return wuffs_gif__config_decoder__restart_frame(this, a_index, a_io_position);
-  }
-
-  inline wuffs_base__status
-  decode_frame_config(
-      wuffs_base__frame_config* a_dst,
-      wuffs_base__io_buffer* a_src) {
-    return wuffs_gif__config_decoder__decode_frame_config(this, a_dst, a_src);
-  }
-
-  inline wuffs_base__status
-  decode_frame(
-      wuffs_base__pixel_buffer* a_dst,
-      wuffs_base__io_buffer* a_src,
-      wuffs_base__pixel_blend a_blend,
-      wuffs_base__slice_u8 a_workbuf,
-      wuffs_base__decode_frame_options* a_opts) {
-    return wuffs_gif__config_decoder__decode_frame(this, a_dst, a_src, a_blend, a_workbuf, a_opts);
-  }
-
-#endif  // __cplusplus
-};  // struct wuffs_gif__config_decoder__struct
-
 struct wuffs_gif__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
@@ -22729,55 +22398,6 @@
 // ---------------- Private Function Prototypes
 
 static wuffs_base__status
-wuffs_gif__config_decoder__skip_frame(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src);
-
-static wuffs_base__empty_struct
-wuffs_gif__config_decoder__reset_gc(
-    wuffs_gif__config_decoder* self);
-
-static wuffs_base__status
-wuffs_gif__config_decoder__decode_up_to_id_part1(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src);
-
-static wuffs_base__status
-wuffs_gif__config_decoder__decode_header(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src);
-
-static wuffs_base__status
-wuffs_gif__config_decoder__decode_lsd(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src);
-
-static wuffs_base__status
-wuffs_gif__config_decoder__decode_extension(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src);
-
-static wuffs_base__status
-wuffs_gif__config_decoder__skip_blocks(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src);
-
-static wuffs_base__status
-wuffs_gif__config_decoder__decode_ae(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src);
-
-static wuffs_base__status
-wuffs_gif__config_decoder__decode_gc(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src);
-
-static wuffs_base__status
-wuffs_gif__config_decoder__decode_id_part0(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src);
-
-static wuffs_base__status
 wuffs_gif__decoder__skip_frame(
     wuffs_gif__decoder* self,
     wuffs_base__io_buffer* a_src);
@@ -22849,40 +22469,6 @@
 // ---------------- VTables
 
 const wuffs_base__image_decoder__func_ptrs
-wuffs_gif__config_decoder__func_ptrs_for__wuffs_base__image_decoder = {
-  (wuffs_base__status(*)(void*,
-      wuffs_base__pixel_buffer*,
-      wuffs_base__io_buffer*,
-      wuffs_base__pixel_blend,
-      wuffs_base__slice_u8,
-      wuffs_base__decode_frame_options*))(&wuffs_gif__config_decoder__decode_frame),
-  (wuffs_base__status(*)(void*,
-      wuffs_base__frame_config*,
-      wuffs_base__io_buffer*))(&wuffs_gif__config_decoder__decode_frame_config),
-  (wuffs_base__status(*)(void*,
-      wuffs_base__image_config*,
-      wuffs_base__io_buffer*))(&wuffs_gif__config_decoder__decode_image_config),
-  (wuffs_base__rect_ie_u32(*)(const void*))(&wuffs_gif__config_decoder__frame_dirty_rect),
-  (uint32_t(*)(const void*))(&wuffs_gif__config_decoder__num_animation_loops),
-  (uint64_t(*)(const void*))(&wuffs_gif__config_decoder__num_decoded_frame_configs),
-  (uint64_t(*)(const void*))(&wuffs_gif__config_decoder__num_decoded_frames),
-  (wuffs_base__status(*)(void*,
-      uint64_t,
-      uint64_t))(&wuffs_gif__config_decoder__restart_frame),
-  (wuffs_base__empty_struct(*)(void*,
-      uint32_t,
-      bool))(&wuffs_gif__config_decoder__set_quirk_enabled),
-  (wuffs_base__empty_struct(*)(void*,
-      uint32_t,
-      bool))(&wuffs_gif__config_decoder__set_report_metadata),
-  (wuffs_base__status(*)(void*,
-      wuffs_base__io_buffer*,
-      wuffs_base__more_information*,
-      wuffs_base__io_buffer*))(&wuffs_gif__config_decoder__tell_me_more),
-  (wuffs_base__range_ii_u64(*)(const void*))(&wuffs_gif__config_decoder__workbuf_len),
-};
-
-const wuffs_base__image_decoder__func_ptrs
 wuffs_gif__decoder__func_ptrs_for__wuffs_base__image_decoder = {
   (wuffs_base__status(*)(void*,
       wuffs_base__pixel_buffer*,
@@ -22919,73 +22505,6 @@
 // ---------------- Initializer Implementations
 
 wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
-wuffs_gif__config_decoder__initialize(
-    wuffs_gif__config_decoder* self,
-    size_t sizeof_star_self,
-    uint64_t wuffs_version,
-    uint32_t 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__image_decoder.vtable_name =
-      wuffs_base__image_decoder__vtable_name;
-  self->private_impl.vtable_for__wuffs_base__image_decoder.function_pointers =
-      (const void*)(&wuffs_gif__config_decoder__func_ptrs_for__wuffs_base__image_decoder);
-  return wuffs_base__make_status(NULL);
-}
-
-wuffs_gif__config_decoder*
-wuffs_gif__config_decoder__alloc() {
-  wuffs_gif__config_decoder* x =
-      (wuffs_gif__config_decoder*)(calloc(sizeof(wuffs_gif__config_decoder), 1));
-  if (!x) {
-    return NULL;
-  }
-  if (wuffs_gif__config_decoder__initialize(
-      x, sizeof(wuffs_gif__config_decoder), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED).repr) {
-    free(x);
-    return NULL;
-  }
-  return x;
-}
-
-size_t
-sizeof__wuffs_gif__config_decoder() {
-  return sizeof(wuffs_gif__config_decoder);
-}
-
-wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
 wuffs_gif__decoder__initialize(
     wuffs_gif__decoder* self,
     size_t sizeof_star_self,
@@ -23061,1773 +22580,6 @@
 
 // ---------------- Function Implementations
 
-// -------- func gif.config_decoder.set_quirk_enabled
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
-wuffs_gif__config_decoder__set_quirk_enabled(
-    wuffs_gif__config_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 ((self->private_impl.f_call_sequence == 0) && (a_quirk >= 1041635328)) {
-    a_quirk -= 1041635328;
-    if (a_quirk < 7) {
-      self->private_impl.f_quirks[a_quirk] = a_enabled;
-    }
-  }
-  return wuffs_base__make_empty_struct();
-}
-
-// -------- func gif.config_decoder.decode_image_config
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__status
-wuffs_gif__config_decoder__decode_image_config(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__image_config* a_dst,
-    wuffs_base__io_buffer* a_src) {
-  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_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);
-
-  bool v_ffio = false;
-
-  uint32_t coro_susp_point = self->private_impl.p_decode_image_config[0];
-  switch (coro_susp_point) {
-    WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
-
-    if (self->private_impl.f_call_sequence == 0) {
-      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
-      status = wuffs_gif__config_decoder__decode_header(self, a_src);
-      if (status.repr) {
-        goto suspend;
-      }
-      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
-      status = wuffs_gif__config_decoder__decode_lsd(self, a_src);
-      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;
-    }
-    WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
-    status = wuffs_gif__config_decoder__decode_up_to_id_part1(self, a_src);
-    if (status.repr) {
-      goto suspend;
-    }
-    v_ffio =  ! self->private_impl.f_gc_has_transparent_index;
-    if ( ! self->private_impl.f_quirks[2]) {
-      v_ffio = (v_ffio &&
-          (self->private_impl.f_frame_rect_x0 == 0) &&
-          (self->private_impl.f_frame_rect_y0 == 0) &&
-          (self->private_impl.f_frame_rect_x1 == self->private_impl.f_width) &&
-          (self->private_impl.f_frame_rect_y1 == self->private_impl.f_height));
-    } else if (v_ffio) {
-      self->private_impl.f_black_color_u32_argb_premul = 4278190080;
-    }
-    if (self->private_impl.f_background_color_u32_argb_premul == 77) {
-      self->private_impl.f_background_color_u32_argb_premul = self->private_impl.f_black_color_u32_argb_premul;
-    }
-    if (a_dst != NULL) {
-      wuffs_base__image_config__set(
-          a_dst,
-          2198077448,
-          0,
-          self->private_impl.f_width,
-          self->private_impl.f_height,
-          self->private_impl.f_frame_config_io_position,
-          v_ffio);
-    }
-    self->private_impl.f_call_sequence = 3;
-
-    goto ok;
-    ok:
-    self->private_impl.p_decode_image_config[0] = 0;
-    goto exit;
-  }
-
-  goto suspend;
-  suspend:
-  self->private_impl.p_decode_image_config[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
-  self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 1 : 0;
-
-  goto exit;
-  exit:
-  if (wuffs_base__status__is_error(&status)) {
-    self->private_impl.magic = WUFFS_BASE__DISABLED;
-  }
-  return status;
-}
-
-// -------- func gif.config_decoder.set_report_metadata
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
-wuffs_gif__config_decoder__set_report_metadata(
-    wuffs_gif__config_decoder* self,
-    uint32_t a_fourcc,
-    bool a_report) {
-  if (!self) {
-    return wuffs_base__make_empty_struct();
-  }
-  if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
-    return wuffs_base__make_empty_struct();
-  }
-
-  if (a_fourcc == 1229144912) {
-    self->private_impl.f_report_metadata_iccp = a_report;
-  } else if (a_fourcc == 1481461792) {
-    self->private_impl.f_report_metadata_xmp = a_report;
-  }
-  return wuffs_base__make_empty_struct();
-}
-
-// -------- func gif.config_decoder.tell_me_more
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__status
-wuffs_gif__config_decoder__tell_me_more(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_dst,
-    wuffs_base__more_information* a_minfo,
-    wuffs_base__io_buffer* a_src) {
-  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 != 2)) {
-    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);
-
-  uint64_t v_chunk_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_tell_me_more[0];
-  switch (coro_susp_point) {
-    WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
-
-    if (self->private_impl.f_call_sequence != 1) {
-      status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
-      goto exit;
-    }
-    if (self->private_impl.f_metadata_fourcc == 0) {
-      status = wuffs_base__make_status(wuffs_base__error__no_more_information);
-      goto exit;
-    }
-    while (true) {
-      label__0__continue:;
-      while (true) {
-        if (wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))) != self->private_impl.f_metadata_io_position) {
-          if (a_minfo != NULL) {
-            wuffs_base__more_information__set(a_minfo,
-                2,
-                0,
-                self->private_impl.f_metadata_io_position,
-                0,
-                0);
-          }
-          status = wuffs_base__make_status(wuffs_base__suspension__mispositioned_read);
-          WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
-          goto label__0__continue;
-        }
-        if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
-          if (a_minfo != NULL) {
-            wuffs_base__more_information__set(a_minfo,
-                0,
-                0,
-                0,
-                0,
-                0);
-          }
-          status = wuffs_base__make_status(wuffs_base__suspension__short_read);
-          WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2);
-          goto label__0__continue;
-        }
-        goto label__0__break;
-      }
-      label__0__break:;
-      v_chunk_length = ((uint64_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src)));
-      if (v_chunk_length <= 0) {
-        (iop_a_src += 1, wuffs_base__make_empty_struct());
-        goto label__1__break;
-      }
-      if (self->private_impl.f_metadata_fourcc == 1481461792) {
-        v_chunk_length += 1;
-      } else {
-        (iop_a_src += 1, wuffs_base__make_empty_struct());
-      }
-      self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add(wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))), v_chunk_length);
-      if (a_minfo != NULL) {
-        wuffs_base__more_information__set(a_minfo,
-            3,
-            self->private_impl.f_metadata_fourcc,
-            0,
-            wuffs_base__u64__sat_add(a_src->meta.pos, ((uint64_t)(iop_a_src - io0_a_src))),
-            self->private_impl.f_metadata_io_position);
-      }
-      status = wuffs_base__make_status(wuffs_base__suspension__even_more_information);
-      WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3);
-    }
-    label__1__break:;
-    if (a_minfo != NULL) {
-      wuffs_base__more_information__set(a_minfo,
-          3,
-          self->private_impl.f_metadata_fourcc,
-          0,
-          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_metadata_fourcc = 0;
-    self->private_impl.f_metadata_io_position = 0;
-    status = wuffs_base__make_status(NULL);
-    goto ok;
-
-    goto ok;
-    ok:
-    self->private_impl.p_tell_me_more[0] = 0;
-    goto exit;
-  }
-
-  goto suspend;
-  suspend:
-  self->private_impl.p_tell_me_more[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
-  self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 2 : 0;
-
-  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 gif.config_decoder.num_animation_loops
-
-WUFFS_BASE__MAYBE_STATIC uint32_t
-wuffs_gif__config_decoder__num_animation_loops(
-    const wuffs_gif__config_decoder* self) {
-  if (!self) {
-    return 0;
-  }
-  if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
-      (self->private_impl.magic != WUFFS_BASE__DISABLED)) {
-    return 0;
-  }
-
-  if (self->private_impl.f_seen_num_loops) {
-    return self->private_impl.f_num_loops;
-  }
-  return 1;
-}
-
-// -------- func gif.config_decoder.num_decoded_frame_configs
-
-WUFFS_BASE__MAYBE_STATIC uint64_t
-wuffs_gif__config_decoder__num_decoded_frame_configs(
-    const wuffs_gif__config_decoder* self) {
-  if (!self) {
-    return 0;
-  }
-  if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
-      (self->private_impl.magic != WUFFS_BASE__DISABLED)) {
-    return 0;
-  }
-
-  return self->private_impl.f_num_decoded_frame_configs_value;
-}
-
-// -------- func gif.config_decoder.num_decoded_frames
-
-WUFFS_BASE__MAYBE_STATIC uint64_t
-wuffs_gif__config_decoder__num_decoded_frames(
-    const wuffs_gif__config_decoder* self) {
-  if (!self) {
-    return 0;
-  }
-  if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
-      (self->private_impl.magic != WUFFS_BASE__DISABLED)) {
-    return 0;
-  }
-
-  return self->private_impl.f_num_decoded_frames_value;
-}
-
-// -------- func gif.config_decoder.frame_dirty_rect
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32
-wuffs_gif__config_decoder__frame_dirty_rect(
-    const wuffs_gif__config_decoder* self) {
-  if (!self) {
-    return wuffs_base__utility__empty_rect_ie_u32();
-  }
-  if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
-      (self->private_impl.magic != WUFFS_BASE__DISABLED)) {
-    return wuffs_base__utility__empty_rect_ie_u32();
-  }
-
-  return wuffs_base__utility__empty_rect_ie_u32();
-}
-
-// -------- func gif.config_decoder.workbuf_len
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64
-wuffs_gif__config_decoder__workbuf_len(
-    const wuffs_gif__config_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__empty_range_ii_u64();
-}
-
-// -------- func gif.config_decoder.restart_frame
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__status
-wuffs_gif__config_decoder__restart_frame(
-    wuffs_gif__config_decoder* self,
-    uint64_t a_index,
-    uint64_t a_io_position) {
-  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 (self->private_impl.f_call_sequence == 0) {
-    return wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
-  }
-  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__config_decoder__reset_gc(self);
-  return wuffs_base__make_status(NULL);
-}
-
-// -------- func gif.config_decoder.decode_frame_config
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__status
-wuffs_gif__config_decoder__decode_frame_config(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__frame_config* a_dst,
-    wuffs_base__io_buffer* a_src) {
-  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_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 != 3)) {
-    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);
-
-  uint32_t v_background_color = 0;
-  uint8_t v_flags = 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_frame_config[0];
-  if (coro_susp_point) {
-    v_background_color = self->private_data.s_decode_frame_config[0].v_background_color;
-  }
-  switch (coro_susp_point) {
-    WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
-
-    self->private_impl.f_ignore_metadata = true;
-    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__config_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__config_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__config_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_end_of_data) {
-      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;
-      if (self->private_impl.f_quirks[1] && (self->private_impl.f_num_decoded_frame_configs_value == 0)) {
-        while (((uint64_t)(io2_a_src - iop_a_src)) <= 0) {
-          status = wuffs_base__make_status(wuffs_base__suspension__short_read);
-          WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4);
-        }
-        v_flags = wuffs_base__load_u8be__no_bounds_check(iop_a_src);
-        if ((v_flags & 128) != 0) {
-          v_background_color = self->private_impl.f_black_color_u32_argb_premul;
-        }
-      }
-    }
-    if (a_dst != NULL) {
-      wuffs_base__frame_config__set(
-          a_dst,
-          wuffs_base__utility__make_rect_ie_u32(
-          wuffs_base__u32__min(self->private_impl.f_frame_rect_x0, self->private_impl.f_width),
-          wuffs_base__u32__min(self->private_impl.f_frame_rect_y0, self->private_impl.f_height),
-          wuffs_base__u32__min(self->private_impl.f_frame_rect_x1, self->private_impl.f_width),
-          wuffs_base__u32__min(self->private_impl.f_frame_rect_y1, self->private_impl.f_height)),
-          ((wuffs_base__flicks)(self->private_impl.f_gc_duration)),
-          self->private_impl.f_num_decoded_frame_configs_value,
-          self->private_impl.f_frame_config_io_position,
-          self->private_impl.f_gc_disposal,
-          ! self->private_impl.f_gc_has_transparent_index,
-          false,
-          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;
-
-    goto ok;
-    ok:
-    self->private_impl.p_decode_frame_config[0] = 0;
-    goto exit;
-  }
-
-  goto suspend;
-  suspend:
-  self->private_impl.p_decode_frame_config[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_config[0].v_background_color = v_background_color;
-
-  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 gif.config_decoder.skip_frame
-
-static wuffs_base__status
-wuffs_gif__config_decoder__skip_frame(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src) {
-  wuffs_base__status status = wuffs_base__make_status(NULL);
-
-  uint8_t v_flags = 0;
-  uint8_t v_lw = 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_skip_frame[0];
-  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_flags = t_0;
-    }
-    if ((v_flags & 128) != 0) {
-      self->private_data.s_skip_frame[0].scratch = (((uint32_t)(3)) << (1 + (v_flags & 7)));
-      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
-      if (self->private_data.s_skip_frame[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
-        self->private_data.s_skip_frame[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
-        iop_a_src = io2_a_src;
-        status = wuffs_base__make_status(wuffs_base__suspension__short_read);
-        goto suspend;
-      }
-      iop_a_src += self->private_data.s_skip_frame[0].scratch;
-    }
-    {
-      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_1 = *iop_a_src++;
-      v_lw = t_1;
-    }
-    if (v_lw > 8) {
-      status = wuffs_base__make_status(wuffs_gif__error__bad_literal_width);
-      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_gif__config_decoder__skip_blocks(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_quirks[0]) {
-      self->private_impl.f_delayed_num_decoded_frames = true;
-    } else {
-      wuffs_base__u64__sat_add_indirect(&self->private_impl.f_num_decoded_frames_value, 1);
-    }
-    wuffs_gif__config_decoder__reset_gc(self);
-
-    goto ok;
-    ok:
-    self->private_impl.p_skip_frame[0] = 0;
-    goto exit;
-  }
-
-  goto suspend;
-  suspend:
-  self->private_impl.p_skip_frame[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
-
-  goto exit;
-  exit:
-  if (a_src) {
-    a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-  }
-
-  return status;
-}
-
-// -------- func gif.config_decoder.decode_frame
-
-WUFFS_BASE__MAYBE_STATIC wuffs_base__status
-wuffs_gif__config_decoder__decode_frame(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__pixel_buffer* a_dst,
-    wuffs_base__io_buffer* a_src,
-    wuffs_base__pixel_blend a_blend,
-    wuffs_base__slice_u8 a_workbuf,
-    wuffs_base__decode_frame_options* a_opts) {
-  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 != 4)) {
-    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);
-
-  status = wuffs_base__make_status(wuffs_base__error__unsupported_method);
-  goto exit;
-
-  goto ok;
-  ok:
-  goto exit;
-  exit:
-  if (wuffs_base__status__is_error(&status)) {
-    self->private_impl.magic = WUFFS_BASE__DISABLED;
-  }
-  return status;
-}
-
-// -------- func gif.config_decoder.reset_gc
-
-static wuffs_base__empty_struct
-wuffs_gif__config_decoder__reset_gc(
-    wuffs_gif__config_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;
-  self->private_impl.f_gc_duration = 0;
-  return wuffs_base__make_empty_struct();
-}
-
-// -------- func gif.config_decoder.decode_up_to_id_part1
-
-static wuffs_base__status
-wuffs_gif__config_decoder__decode_up_to_id_part1(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src) {
-  wuffs_base__status status = wuffs_base__make_status(NULL);
-
-  uint8_t v_block_type = 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_up_to_id_part1[0];
-  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->meta.pos, ((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->meta.pos, ((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;
-    }
-    while (true) {
-      {
-        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_block_type = t_0;
-      }
-      if (v_block_type == 33) {
-        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__config_decoder__decode_extension(self, a_src);
-        if (a_src) {
-          iop_a_src = a_src->data.ptr + a_src->meta.ri;
-        }
-        if (status.repr) {
-          goto suspend;
-        }
-      } else if (v_block_type == 44) {
-        if (self->private_impl.f_delayed_num_decoded_frames) {
-          self->private_impl.f_delayed_num_decoded_frames = false;
-          wuffs_base__u64__sat_add_indirect(&self->private_impl.f_num_decoded_frames_value, 1);
-        }
-        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__config_decoder__decode_id_part0(self, a_src);
-        if (a_src) {
-          iop_a_src = a_src->data.ptr + a_src->meta.ri;
-        }
-        if (status.repr) {
-          goto suspend;
-        }
-        goto label__0__break;
-      } else {
-        if (self->private_impl.f_delayed_num_decoded_frames) {
-          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;
-        goto label__0__break;
-      }
-    }
-    label__0__break:;
-
-    goto ok;
-    ok:
-    self->private_impl.p_decode_up_to_id_part1[0] = 0;
-    goto exit;
-  }
-
-  goto suspend;
-  suspend:
-  self->private_impl.p_decode_up_to_id_part1[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
-
-  goto exit;
-  exit:
-  if (a_src) {
-    a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-  }
-
-  return status;
-}
-
-// -------- func gif.config_decoder.decode_header
-
-static wuffs_base__status
-wuffs_gif__config_decoder__decode_header(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src) {
-  wuffs_base__status status = wuffs_base__make_status(NULL);
-
-  uint8_t v_c[6] = {0};
-  uint32_t v_i = 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_header[0];
-  if (coro_susp_point) {
-    memcpy(v_c, self->private_data.s_decode_header[0].v_c, sizeof(v_c));
-    v_i = self->private_data.s_decode_header[0].v_i;
-  }
-  switch (coro_susp_point) {
-    WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
-
-    while (v_i < 6) {
-      {
-        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[v_i] = t_0;
-      }
-      v_i += 1;
-    }
-    if ((v_c[0] != 71) ||
-        (v_c[1] != 73) ||
-        (v_c[2] != 70) ||
-        (v_c[3] != 56) ||
-        ((v_c[4] != 55) && (v_c[4] != 57)) ||
-        (v_c[5] != 97)) {
-      status = wuffs_base__make_status(wuffs_gif__error__bad_header);
-      goto exit;
-    }
-
-    goto ok;
-    ok:
-    self->private_impl.p_decode_header[0] = 0;
-    goto exit;
-  }
-
-  goto suspend;
-  suspend:
-  self->private_impl.p_decode_header[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
-  memcpy(self->private_data.s_decode_header[0].v_c, v_c, sizeof(v_c));
-  self->private_data.s_decode_header[0].v_i = v_i;
-
-  goto exit;
-  exit:
-  if (a_src) {
-    a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-  }
-
-  return status;
-}
-
-// -------- func gif.config_decoder.decode_lsd
-
-static wuffs_base__status
-wuffs_gif__config_decoder__decode_lsd(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src) {
-  wuffs_base__status status = wuffs_base__make_status(NULL);
-
-  uint8_t v_flags = 0;
-  uint8_t v_background_color_index = 0;
-  uint32_t v_num_palette_entries = 0;
-  uint32_t v_i = 0;
-  uint32_t v_j = 0;
-  uint32_t v_argb = 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_lsd[0];
-  if (coro_susp_point) {
-    v_flags = self->private_data.s_decode_lsd[0].v_flags;
-    v_background_color_index = self->private_data.s_decode_lsd[0].v_background_color_index;
-    v_num_palette_entries = self->private_data.s_decode_lsd[0].v_num_palette_entries;
-    v_i = self->private_data.s_decode_lsd[0].v_i;
-  }
-  switch (coro_susp_point) {
-    WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
-
-    {
-      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
-      uint32_t t_0;
-      if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
-        t_0 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src)));
-        iop_a_src += 2;
-      } else {
-        self->private_data.s_decode_lsd[0].scratch = 0;
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
-        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_lsd[0].scratch;
-          uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
-          *scratch <<= 8;
-          *scratch >>= 8;
-          *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
-          if (num_bits_0 == 8) {
-            t_0 = ((uint32_t)(*scratch));
-            break;
-          }
-          num_bits_0 += 8;
-          *scratch |= ((uint64_t)(num_bits_0)) << 56;
-        }
-      }
-      self->private_impl.f_width = t_0;
-    }
-    {
-      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
-      uint32_t t_1;
-      if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
-        t_1 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src)));
-        iop_a_src += 2;
-      } else {
-        self->private_data.s_decode_lsd[0].scratch = 0;
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
-        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_lsd[0].scratch;
-          uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
-          *scratch <<= 8;
-          *scratch >>= 8;
-          *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
-          if (num_bits_1 == 8) {
-            t_1 = ((uint32_t)(*scratch));
-            break;
-          }
-          num_bits_1 += 8;
-          *scratch |= ((uint64_t)(num_bits_1)) << 56;
-        }
-      }
-      self->private_impl.f_height = t_1;
-    }
-    {
-      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_2 = *iop_a_src++;
-      v_flags = t_2;
-    }
-    {
-      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_3 = *iop_a_src++;
-      v_background_color_index = t_3;
-    }
-    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;
-    }
-    iop_a_src++;
-    v_i = 0;
-    self->private_impl.f_has_global_palette = ((v_flags & 128) != 0);
-    if (self->private_impl.f_has_global_palette) {
-      v_num_palette_entries = (((uint32_t)(1)) << (1 + (v_flags & 7)));
-      while (v_i < v_num_palette_entries) {
-        {
-          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
-          uint32_t t_4;
-          if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 3)) {
-            t_4 = ((uint32_t)(wuffs_base__load_u24be__no_bounds_check(iop_a_src)));
-            iop_a_src += 3;
-          } else {
-            self->private_data.s_decode_lsd[0].scratch = 0;
-            WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
-            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_lsd[0].scratch;
-              uint32_t num_bits_4 = ((uint32_t)(*scratch & 0xFF));
-              *scratch >>= 8;
-              *scratch <<= 8;
-              *scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_4);
-              if (num_bits_4 == 16) {
-                t_4 = ((uint32_t)(*scratch >> 40));
-                break;
-              }
-              num_bits_4 += 8;
-              *scratch |= ((uint64_t)(num_bits_4));
-            }
-          }
-          v_argb = t_4;
-        }
-        v_argb |= 4278190080;
-        self->private_data.f_palettes[0][((4 * v_i) + 0)] = ((uint8_t)(((v_argb >> 0) & 255)));
-        self->private_data.f_palettes[0][((4 * v_i) + 1)] = ((uint8_t)(((v_argb >> 8) & 255)));
-        self->private_data.f_palettes[0][((4 * v_i) + 2)] = ((uint8_t)(((v_argb >> 16) & 255)));
-        self->private_data.f_palettes[0][((4 * v_i) + 3)] = ((uint8_t)(((v_argb >> 24) & 255)));
-        v_i += 1;
-      }
-      if (self->private_impl.f_quirks[2]) {
-        if ((v_background_color_index != 0) && (((uint32_t)(v_background_color_index)) < v_num_palette_entries)) {
-          v_j = (4 * ((uint32_t)(v_background_color_index)));
-          self->private_impl.f_background_color_u32_argb_premul = ((((uint32_t)(self->private_data.f_palettes[0][(v_j + 0)])) << 0) |
-              (((uint32_t)(self->private_data.f_palettes[0][(v_j + 1)])) << 8) |
-              (((uint32_t)(self->private_data.f_palettes[0][(v_j + 2)])) << 16) |
-              (((uint32_t)(self->private_data.f_palettes[0][(v_j + 3)])) << 24));
-        } else {
-          self->private_impl.f_background_color_u32_argb_premul = 77;
-        }
-      }
-    }
-    while (v_i < 256) {
-      self->private_data.f_palettes[0][((4 * v_i) + 0)] = 0;
-      self->private_data.f_palettes[0][((4 * v_i) + 1)] = 0;
-      self->private_data.f_palettes[0][((4 * v_i) + 2)] = 0;
-      self->private_data.f_palettes[0][((4 * v_i) + 3)] = 255;
-      v_i += 1;
-    }
-
-    goto ok;
-    ok:
-    self->private_impl.p_decode_lsd[0] = 0;
-    goto exit;
-  }
-
-  goto suspend;
-  suspend:
-  self->private_impl.p_decode_lsd[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
-  self->private_data.s_decode_lsd[0].v_flags = v_flags;
-  self->private_data.s_decode_lsd[0].v_background_color_index = v_background_color_index;
-  self->private_data.s_decode_lsd[0].v_num_palette_entries = v_num_palette_entries;
-  self->private_data.s_decode_lsd[0].v_i = v_i;
-
-  goto exit;
-  exit:
-  if (a_src) {
-    a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-  }
-
-  return status;
-}
-
-// -------- func gif.config_decoder.decode_extension
-
-static wuffs_base__status
-wuffs_gif__config_decoder__decode_extension(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src) {
-  wuffs_base__status status = wuffs_base__make_status(NULL);
-
-  uint8_t v_label = 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_extension[0];
-  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_label = t_0;
-    }
-    if (v_label == 249) {
-      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__config_decoder__decode_gc(self, a_src);
-      if (a_src) {
-        iop_a_src = a_src->data.ptr + a_src->meta.ri;
-      }
-      if (status.repr) {
-        goto suspend;
-      }
-      status = wuffs_base__make_status(NULL);
-      goto ok;
-    } else if (v_label == 255) {
-      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__config_decoder__decode_ae(self, a_src);
-      if (a_src) {
-        iop_a_src = a_src->data.ptr + a_src->meta.ri;
-      }
-      if (status.repr) {
-        goto suspend;
-      }
-      status = wuffs_base__make_status(NULL);
-      goto ok;
-    }
-    if (a_src) {
-      a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-    }
-    WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
-    status = wuffs_gif__config_decoder__skip_blocks(self, a_src);
-    if (a_src) {
-      iop_a_src = a_src->data.ptr + a_src->meta.ri;
-    }
-    if (status.repr) {
-      goto suspend;
-    }
-
-    goto ok;
-    ok:
-    self->private_impl.p_decode_extension[0] = 0;
-    goto exit;
-  }
-
-  goto suspend;
-  suspend:
-  self->private_impl.p_decode_extension[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
-
-  goto exit;
-  exit:
-  if (a_src) {
-    a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-  }
-
-  return status;
-}
-
-// -------- func gif.config_decoder.skip_blocks
-
-static wuffs_base__status
-wuffs_gif__config_decoder__skip_blocks(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src) {
-  wuffs_base__status status = wuffs_base__make_status(NULL);
-
-  uint8_t v_block_size = 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_skip_blocks[0];
-  switch (coro_susp_point) {
-    WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
-
-    while (true) {
-      {
-        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_block_size = t_0;
-      }
-      if (v_block_size == 0) {
-        status = wuffs_base__make_status(NULL);
-        goto ok;
-      }
-      self->private_data.s_skip_blocks[0].scratch = ((uint32_t)(v_block_size));
-      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
-      if (self->private_data.s_skip_blocks[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
-        self->private_data.s_skip_blocks[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
-        iop_a_src = io2_a_src;
-        status = wuffs_base__make_status(wuffs_base__suspension__short_read);
-        goto suspend;
-      }
-      iop_a_src += self->private_data.s_skip_blocks[0].scratch;
-    }
-
-    goto ok;
-    ok:
-    self->private_impl.p_skip_blocks[0] = 0;
-    goto exit;
-  }
-
-  goto suspend;
-  suspend:
-  self->private_impl.p_skip_blocks[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
-
-  goto exit;
-  exit:
-  if (a_src) {
-    a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-  }
-
-  return status;
-}
-
-// -------- func gif.config_decoder.decode_ae
-
-static wuffs_base__status
-wuffs_gif__config_decoder__decode_ae(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src) {
-  wuffs_base__status status = wuffs_base__make_status(NULL);
-
-  uint8_t v_c = 0;
-  uint8_t v_block_size = 0;
-  bool v_is_animexts = false;
-  bool v_is_netscape = false;
-  bool v_is_iccp = false;
-  bool v_is_xmp = false;
-
-  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_ae[0];
-  if (coro_susp_point) {
-    v_block_size = self->private_data.s_decode_ae[0].v_block_size;
-    v_is_animexts = self->private_data.s_decode_ae[0].v_is_animexts;
-    v_is_netscape = self->private_data.s_decode_ae[0].v_is_netscape;
-    v_is_iccp = self->private_data.s_decode_ae[0].v_is_iccp;
-    v_is_xmp = self->private_data.s_decode_ae[0].v_is_xmp;
-  }
-  switch (coro_susp_point) {
-    WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
-
-    while (true) {
-      if (self->private_impl.f_metadata_fourcc != 0) {
-        status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
-        goto ok;
-      }
-      {
-        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_block_size = t_0;
-      }
-      if (v_block_size == 0) {
-        status = wuffs_base__make_status(NULL);
-        goto ok;
-      }
-      if (v_block_size != 11) {
-        self->private_data.s_decode_ae[0].scratch = ((uint32_t)(v_block_size));
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
-        if (self->private_data.s_decode_ae[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
-          self->private_data.s_decode_ae[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
-          iop_a_src = io2_a_src;
-          status = wuffs_base__make_status(wuffs_base__suspension__short_read);
-          goto suspend;
-        }
-        iop_a_src += self->private_data.s_decode_ae[0].scratch;
-        goto label__goto_done__break;
-      }
-      v_is_animexts = true;
-      v_is_netscape = true;
-      v_is_iccp = true;
-      v_is_xmp = true;
-      v_block_size = 0;
-      while (v_block_size < 11) {
-        {
-          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_1 = *iop_a_src++;
-          v_c = t_1;
-        }
-        v_is_animexts = (v_is_animexts && (v_c == WUFFS_GIF__ANIMEXTS1DOT0[v_block_size]));
-        v_is_netscape = (v_is_netscape && (v_c == WUFFS_GIF__NETSCAPE2DOT0[v_block_size]));
-        v_is_iccp = (v_is_iccp && (v_c == WUFFS_GIF__ICCRGBG1012[v_block_size]));
-        v_is_xmp = (v_is_xmp && (v_c == WUFFS_GIF__XMPDATAXMP[v_block_size]));
-#if defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wconversion"
-#endif
-        v_block_size += 1;
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif
-      }
-      if (v_is_animexts || v_is_netscape) {
-        {
-          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_2 = *iop_a_src++;
-          v_block_size = t_2;
-        }
-        if (v_block_size != 3) {
-          self->private_data.s_decode_ae[0].scratch = ((uint32_t)(v_block_size));
-          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
-          if (self->private_data.s_decode_ae[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
-            self->private_data.s_decode_ae[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
-            iop_a_src = io2_a_src;
-            status = wuffs_base__make_status(wuffs_base__suspension__short_read);
-            goto suspend;
-          }
-          iop_a_src += self->private_data.s_decode_ae[0].scratch;
-          goto label__goto_done__break;
-        }
-        {
-          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_3 = *iop_a_src++;
-          v_c = t_3;
-        }
-        if (v_c != 1) {
-          self->private_data.s_decode_ae[0].scratch = 2;
-          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
-          if (self->private_data.s_decode_ae[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
-            self->private_data.s_decode_ae[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src));
-            iop_a_src = io2_a_src;
-            status = wuffs_base__make_status(wuffs_base__suspension__short_read);
-            goto suspend;
-          }
-          iop_a_src += self->private_data.s_decode_ae[0].scratch;
-          goto label__goto_done__break;
-        }
-        {
-          WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
-          uint32_t t_4;
-          if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
-            t_4 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src)));
-            iop_a_src += 2;
-          } else {
-            self->private_data.s_decode_ae[0].scratch = 0;
-            WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
-            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_ae[0].scratch;
-              uint32_t num_bits_4 = ((uint32_t)(*scratch >> 56));
-              *scratch <<= 8;
-              *scratch >>= 8;
-              *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_4;
-              if (num_bits_4 == 8) {
-                t_4 = ((uint32_t)(*scratch));
-                break;
-              }
-              num_bits_4 += 8;
-              *scratch |= ((uint64_t)(num_bits_4)) << 56;
-            }
-          }
-          self->private_impl.f_num_loops = t_4;
-        }
-        self->private_impl.f_seen_num_loops = true;
-        if ((0 < self->private_impl.f_num_loops) && (self->private_impl.f_num_loops <= 65535)) {
-          self->private_impl.f_num_loops += 1;
-        }
-      } else if (self->private_impl.f_ignore_metadata) {
-      } 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->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
-        self->private_impl.f_call_sequence = 1;
-        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->meta.pos, ((uint64_t)(iop_a_src - io0_a_src)));
-        self->private_impl.f_call_sequence = 1;
-        status = wuffs_base__make_status(wuffs_base__note__metadata_reported);
-        goto ok;
-      }
-      goto label__goto_done__break;
-    }
-    label__goto_done__break:;
-    if (a_src) {
-      a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-    }
-    WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
-    status = wuffs_gif__config_decoder__skip_blocks(self, a_src);
-    if (a_src) {
-      iop_a_src = a_src->data.ptr + a_src->meta.ri;
-    }
-    if (status.repr) {
-      goto suspend;
-    }
-
-    goto ok;
-    ok:
-    self->private_impl.p_decode_ae[0] = 0;
-    goto exit;
-  }
-
-  goto suspend;
-  suspend:
-  self->private_impl.p_decode_ae[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
-  self->private_data.s_decode_ae[0].v_block_size = v_block_size;
-  self->private_data.s_decode_ae[0].v_is_animexts = v_is_animexts;
-  self->private_data.s_decode_ae[0].v_is_netscape = v_is_netscape;
-  self->private_data.s_decode_ae[0].v_is_iccp = v_is_iccp;
-  self->private_data.s_decode_ae[0].v_is_xmp = v_is_xmp;
-
-  goto exit;
-  exit:
-  if (a_src) {
-    a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-  }
-
-  return status;
-}
-
-// -------- func gif.config_decoder.decode_gc
-
-static wuffs_base__status
-wuffs_gif__config_decoder__decode_gc(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src) {
-  wuffs_base__status status = wuffs_base__make_status(NULL);
-
-  uint8_t v_c = 0;
-  uint8_t v_flags = 0;
-  uint16_t v_gc_duration_centiseconds = 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_gc[0];
-  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 != 4) {
-      status = wuffs_base__make_status(wuffs_gif__error__bad_graphic_control);
-      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_flags = t_1;
-    }
-    self->private_impl.f_gc_has_transparent_index = ((v_flags & 1) != 0);
-    v_flags = ((v_flags >> 2) & 7);
-    if (v_flags == 2) {
-      self->private_impl.f_gc_disposal = 1;
-    } else if ((v_flags == 3) || (v_flags == 4)) {
-      self->private_impl.f_gc_disposal = 2;
-    } else {
-      self->private_impl.f_gc_disposal = 0;
-    }
-    {
-      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
-      uint16_t t_2;
-      if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
-        t_2 = wuffs_base__load_u16le__no_bounds_check(iop_a_src);
-        iop_a_src += 2;
-      } else {
-        self->private_data.s_decode_gc[0].scratch = 0;
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
-        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_gc[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 == 8) {
-            t_2 = ((uint16_t)(*scratch));
-            break;
-          }
-          num_bits_2 += 8;
-          *scratch |= ((uint64_t)(num_bits_2)) << 56;
-        }
-      }
-      v_gc_duration_centiseconds = t_2;
-    }
-    self->private_impl.f_gc_duration = (((uint64_t)(v_gc_duration_centiseconds)) * 7056000);
-    {
-      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_3 = *iop_a_src++;
-      self->private_impl.f_gc_transparent_index = t_3;
-    }
-    {
-      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_4 = *iop_a_src++;
-      v_c = t_4;
-    }
-    if (v_c != 0) {
-      status = wuffs_base__make_status(wuffs_gif__error__bad_graphic_control);
-      goto exit;
-    }
-
-    goto ok;
-    ok:
-    self->private_impl.p_decode_gc[0] = 0;
-    goto exit;
-  }
-
-  goto suspend;
-  suspend:
-  self->private_impl.p_decode_gc[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
-
-  goto exit;
-  exit:
-  if (a_src) {
-    a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-  }
-
-  return status;
-}
-
-// -------- func gif.config_decoder.decode_id_part0
-
-static wuffs_base__status
-wuffs_gif__config_decoder__decode_id_part0(
-    wuffs_gif__config_decoder* self,
-    wuffs_base__io_buffer* a_src) {
-  wuffs_base__status 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_decode_id_part0[0];
-  switch (coro_susp_point) {
-    WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
-
-    {
-      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
-      uint32_t t_0;
-      if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
-        t_0 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src)));
-        iop_a_src += 2;
-      } else {
-        self->private_data.s_decode_id_part0[0].scratch = 0;
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
-        while (true) {
-          if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
-            status = wuffs_base__make_status(wuffs_base__suspension__short_read);
-            goto suspend;
-          }
-          uint64_t* scratch = &self->private_data.s_decode_id_part0[0].scratch;
-          uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
-          *scratch <<= 8;
-          *scratch >>= 8;
-          *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
-          if (num_bits_0 == 8) {
-            t_0 = ((uint32_t)(*scratch));
-            break;
-          }
-          num_bits_0 += 8;
-          *scratch |= ((uint64_t)(num_bits_0)) << 56;
-        }
-      }
-      self->private_impl.f_frame_rect_x0 = t_0;
-    }
-    {
-      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
-      uint32_t t_1;
-      if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
-        t_1 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src)));
-        iop_a_src += 2;
-      } else {
-        self->private_data.s_decode_id_part0[0].scratch = 0;
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
-        while (true) {
-          if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
-            status = wuffs_base__make_status(wuffs_base__suspension__short_read);
-            goto suspend;
-          }
-          uint64_t* scratch = &self->private_data.s_decode_id_part0[0].scratch;
-          uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
-          *scratch <<= 8;
-          *scratch >>= 8;
-          *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
-          if (num_bits_1 == 8) {
-            t_1 = ((uint32_t)(*scratch));
-            break;
-          }
-          num_bits_1 += 8;
-          *scratch |= ((uint64_t)(num_bits_1)) << 56;
-        }
-      }
-      self->private_impl.f_frame_rect_y0 = t_1;
-    }
-    {
-      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
-      uint32_t t_2;
-      if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
-        t_2 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src)));
-        iop_a_src += 2;
-      } else {
-        self->private_data.s_decode_id_part0[0].scratch = 0;
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
-        while (true) {
-          if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
-            status = wuffs_base__make_status(wuffs_base__suspension__short_read);
-            goto suspend;
-          }
-          uint64_t* scratch = &self->private_data.s_decode_id_part0[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 == 8) {
-            t_2 = ((uint32_t)(*scratch));
-            break;
-          }
-          num_bits_2 += 8;
-          *scratch |= ((uint64_t)(num_bits_2)) << 56;
-        }
-      }
-      self->private_impl.f_frame_rect_x1 = t_2;
-    }
-    self->private_impl.f_frame_rect_x1 += self->private_impl.f_frame_rect_x0;
-    {
-      WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
-      uint32_t t_3;
-      if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) {
-        t_3 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src)));
-        iop_a_src += 2;
-      } else {
-        self->private_data.s_decode_id_part0[0].scratch = 0;
-        WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
-        while (true) {
-          if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
-            status = wuffs_base__make_status(wuffs_base__suspension__short_read);
-            goto suspend;
-          }
-          uint64_t* scratch = &self->private_data.s_decode_id_part0[0].scratch;
-          uint32_t num_bits_3 = ((uint32_t)(*scratch >> 56));
-          *scratch <<= 8;
-          *scratch >>= 8;
-          *scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_3;
-          if (num_bits_3 == 8) {
-            t_3 = ((uint32_t)(*scratch));
-            break;
-          }
-          num_bits_3 += 8;
-          *scratch |= ((uint64_t)(num_bits_3)) << 56;
-        }
-      }
-      self->private_impl.f_frame_rect_y1 = t_3;
-    }
-    self->private_impl.f_frame_rect_y1 += self->private_impl.f_frame_rect_y0;
-    if ((self->private_impl.f_call_sequence == 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);
-    }
-
-    goto ok;
-    ok:
-    self->private_impl.p_decode_id_part0[0] = 0;
-    goto exit;
-  }
-
-  goto suspend;
-  suspend:
-  self->private_impl.p_decode_id_part0[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
-
-  goto exit;
-  exit:
-  if (a_src) {
-    a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
-  }
-
-  return status;
-}
-
 // -------- func gif.decoder.set_quirk_enabled
 
 WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
diff --git a/std/gif/decode_config.wuffs b/std/gif/decode_config.wuffs
deleted file mode 100644
index afe61fa..0000000
--- a/std/gif/decode_config.wuffs
+++ /dev/null
@@ -1,733 +0,0 @@
-// This file was automatically generated by "preprocess-wuffs.go".
-
-// --------
-
-// Copyright 2017 The Wuffs Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// --------
-
-// --------
-
-pub struct config_decoder? implements base.image_decoder(
-	width  : base.u32,
-	height : base.u32,
-
-	// Call sequence states:
-	//  - 0: initial state.
-	//  - 1: metadata reported; image config decode is in progress.
-	//  - 2: metadata finished; image config decode is in progress.
-	//  - 3: image config decoded, including the first frame's bounds, but not
-	//       the first frame's pixels.
-	//  - 4: frame config decoded.
-	//  - 5: frame decoded.
-	//
-	// State transitions:
-	//
-	//  - 0 -> 1: via IC (metadata reported)
-	//  - 0 -> 3: via IC (metadata not reported)
-	//  - 0 -> 4: via FC with implicit IC
-	//  - 0 -> 5: via F  with implicit IC and FC
-	//
-	//  - 1 -> 2: via AMC
-	//
-	//  - 2 -> 1: via IC (metadata reported)
-	//  - 2 -> 3: via IC (metadata not reported)
-	//
-	//  - 3 -> 4: via FC
-	//  - 3 -> 5: via F  with implicit FC
-	//
-	//  - 4 -> 4: via FC with implicit F
-	//  - 4 -> 5: via F
-	//
-	//  - 5 -> 4: via FC
-	//  - 5 -> 5: via F  with implicit FC
-	//
-	// Where:
-	//  - AMC is ack_metadata_chunk
-	//  - F   is decode_frame,        implicit means skip_frame
-	//  - FC  is decode_frame_config, implicit means nullptr args.dst
-	//  - IC  is decode_image_config, implicit means nullptr args.dst
-	call_sequence : base.u8,
-
-	ignore_metadata      : base.bool,
-	report_metadata_iccp : base.bool,
-	report_metadata_xmp  : base.bool,
-	metadata_fourcc      : base.u32,
-	metadata_io_position : base.u64,
-
-	quirks : array[QUIRKS_COUNT] base.bool,
-
-	delayed_num_decoded_frames         : base.bool,
-	end_of_data                        : base.bool,
-	restarted                          : base.bool,
-	previous_lzw_decode_ended_abruptly : base.bool,
-
-	has_global_palette : base.bool,
-
-	// interlace indexes the INTERLACE_START and INTERLACE_DELTA arrays.
-	interlace : base.u8[..= 4],
-
-	// Absent an ANIMEXTS1.0 or NETSCAPE2.0 extension, the implicit number of
-	// animation loops is 1.
-	seen_num_loops : base.bool,
-	num_loops      : base.u32,
-
-	background_color_u32_argb_premul : base.u32,
-	black_color_u32_argb_premul      : base.u32,
-
-	gc_has_transparent_index : base.bool,
-	gc_transparent_index     : base.u8,
-	gc_disposal              : base.u8,
-	// There are 7_056000 flicks per centisecond.
-	gc_duration : base.u64[..= 0xFFFF * 7_056000],
-
-	frame_config_io_position        : base.u64,
-	num_decoded_frame_configs_value : base.u64,
-	num_decoded_frames_value        : base.u64,
-
-	frame_rect_x0 : base.u32,
-	frame_rect_y0 : base.u32,
-	frame_rect_x1 : base.u32,
-	frame_rect_y1 : base.u32,
-
-	util : base.utility,
-)(
-	palettes : array[1] array[4 * 256] base.u8,
-)
-
-pub func config_decoder.set_quirk_enabled!(quirk: base.u32, enabled: base.bool) {
-	if (this.call_sequence == 0) and (args.quirk >= QUIRKS_BASE) {
-		args.quirk -= QUIRKS_BASE
-		if args.quirk < QUIRKS_COUNT {
-			this.quirks[args.quirk] = args.enabled
-		}
-	}
-}
-
-pub func config_decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
-	var ffio : base.bool
-
-	if this.call_sequence == 0 {
-		this.decode_header?(src: args.src)
-		this.decode_lsd?(src: args.src)
-	} else if this.call_sequence <> 2 {
-		return base."#bad call sequence"
-	}
-
-	this.decode_up_to_id_part1?(src: args.src)
-
-	// TODO: if this.end_of_data, return an error and/or set dst to zero?
-
-	ffio = not this.gc_has_transparent_index
-	if not this.quirks[QUIRK_HONOR_BACKGROUND_COLOR - QUIRKS_BASE] {
-		ffio = ffio and
-			(this.frame_rect_x0 == 0) and
-			(this.frame_rect_y0 == 0) and
-			(this.frame_rect_x1 == this.width) and
-			(this.frame_rect_y1 == this.height)
-	} else if ffio {
-		// Use opaque black, not transparent black.
-		this.black_color_u32_argb_premul = 0xFF00_0000
-	}
-
-	if this.background_color_u32_argb_premul == 77 {
-		this.background_color_u32_argb_premul = this.black_color_u32_argb_premul
-	}
-
-	if args.dst <> nullptr {
-		args.dst.set!(
-			pixfmt: base.PIXEL_FORMAT__INDEXED__BGRA_BINARY,
-			pixsub: 0,
-			width: this.width,
-			height: this.height,
-			first_frame_io_position: this.frame_config_io_position,
-			first_frame_is_opaque: ffio)
-	}
-
-	this.call_sequence = 3
-}
-
-pub func config_decoder.set_report_metadata!(fourcc: base.u32, report: base.bool) {
-	if args.fourcc == 'ICCP'be {
-		this.report_metadata_iccp = args.report
-	} else if args.fourcc == 'XMP 'be {
-		this.report_metadata_xmp = args.report
-	}
-}
-
-pub func config_decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_information, src: base.io_reader) {
-	var chunk_length : base.u64
-
-	if this.call_sequence <> 1 {
-		return base."#bad call sequence"
-	}
-	if this.metadata_fourcc == 0 {
-		return base."#no more information"
-	}
-
-	while true {
-		while true,
-			post args.src.length() > 0,
-		{
-			if args.src.position() <> this.metadata_io_position {
-				if args.minfo <> nullptr {
-					args.minfo.set!(
-						flavor: 2,  // WUFFS_BASE__MORE_INFORMATION__FLAVOR__IO_SEEK
-						w: 0,
-						x: this.metadata_io_position,
-						y: 0,
-						z: 0)
-				}
-				yield? base."$mispositioned read"
-				continue
-			}
-
-			if args.src.length() <= 0 {
-				if args.minfo <> nullptr {
-					args.minfo.set!(
-						flavor: 0,
-						w: 0,
-						x: 0,
-						y: 0,
-						z: 0)
-				}
-				yield? base."$short read"
-				continue
-			}
-
-			break
-		} endwhile
-
-		chunk_length = args.src.peek_u8_as_u64()
-		if chunk_length <= 0 {
-			// Consume the '\x00' that means a zero-length block.
-			args.src.skip_u32_fast!(actual: 1, worst_case: 1)
-			break
-		}
-
-		if this.metadata_fourcc == 'XMP 'be {
-			// The +1 is because XMP metadata's encoding includes each
-			// block's leading byte (the block size) as part of the
-			// metadata passed to the caller.
-			chunk_length += 1
-		} else {
-			args.src.skip_u32_fast!(actual: 1, worst_case: 1)
-		}
-		this.metadata_io_position = args.src.position() ~sat+ chunk_length
-
-		if args.minfo <> nullptr {
-			args.minfo.set!(
-				flavor: 3,  // WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA
-				w: this.metadata_fourcc,
-				x: 0,
-				y: args.src.position(),
-				z: this.metadata_io_position)
-		}
-
-		yield? base."$even more information"
-	} endwhile
-
-	if args.minfo <> nullptr {
-		args.minfo.set!(
-			flavor: 3,  // WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA
-			w: this.metadata_fourcc,
-			x: 0,
-			y: this.metadata_io_position,
-			z: this.metadata_io_position)
-	}
-	this.call_sequence = 2
-	this.metadata_fourcc = 0
-	this.metadata_io_position = 0
-	return ok
-}
-
-pub func config_decoder.num_animation_loops() base.u32 {
-	if this.seen_num_loops {
-		return this.num_loops
-	}
-	return 1
-}
-
-pub func config_decoder.num_decoded_frame_configs() base.u64 {
-	return this.num_decoded_frame_configs_value
-}
-
-pub func config_decoder.num_decoded_frames() base.u64 {
-	return this.num_decoded_frames_value
-}
-
-pub func config_decoder.frame_dirty_rect() base.rect_ie_u32 {
-	return this.util.empty_rect_ie_u32()
-}
-
-pub func config_decoder.workbuf_len() base.range_ii_u64 {
-	return this.util.empty_range_ii_u64()
-}
-
-pub func config_decoder.restart_frame!(index: base.u64, io_position: base.u64) base.status {
-	if this.call_sequence == 0 {
-		return base."#bad call sequence"
-	}
-	this.delayed_num_decoded_frames = false
-	this.end_of_data = false
-	this.restarted = true
-	this.frame_config_io_position = args.io_position
-	this.num_decoded_frame_configs_value = args.index
-	this.num_decoded_frames_value = args.index
-	this.reset_gc!()
-	return ok
-}
-
-pub func config_decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_reader) {
-	var background_color : base.u32
-	var flags            : base.u8
-
-	this.ignore_metadata = true
-
-	if not this.end_of_data {
-		if this.call_sequence == 0 {
-			this.decode_image_config?(dst: nullptr, src: args.src)
-		} else if this.call_sequence <> 3 {
-			if this.call_sequence == 4 {
-				this.skip_frame?(src: args.src)
-			}
-			this.decode_up_to_id_part1?(src: args.src)
-		}
-	}
-
-	// This is a new "if", not an "else", because the calls above can modify
-	// this.end_of_data.
-	if this.end_of_data {
-		return base."@end of data"
-	}
-
-	background_color = this.black_color_u32_argb_premul
-	if not this.gc_has_transparent_index {
-		background_color = this.background_color_u32_argb_premul
-
-		// If the quirk is enabled and the first frame has a local color
-		// palette, its background color is black.
-		if this.quirks[QUIRK_FIRST_FRAME_LOCAL_PALETTE_MEANS_BLACK_BACKGROUND - QUIRKS_BASE] and
-			(this.num_decoded_frame_configs_value == 0) {
-
-			while args.src.length() <= 0,
-				post args.src.length() > 0,
-			{
-				yield? base."$short read"
-			} endwhile
-			flags = args.src.peek_u8()
-			if (flags & 0x80) <> 0 {
-				background_color = this.black_color_u32_argb_premul
-			}
-		}
-	}
-
-	if args.dst <> nullptr {
-		// The "foo.min(a:this.width_or_height)" calls clip the nominal
-		// frame_rect to the image_rect.
-		args.dst.set!(bounds: this.util.make_rect_ie_u32(
-			min_incl_x: this.frame_rect_x0.min(a: this.width),
-			min_incl_y: this.frame_rect_y0.min(a: this.height),
-			max_excl_x: this.frame_rect_x1.min(a: this.width),
-			max_excl_y: this.frame_rect_y1.min(a: this.height)),
-			duration: this.gc_duration,
-			index: this.num_decoded_frame_configs_value,
-			io_position: this.frame_config_io_position,
-			disposal: this.gc_disposal,
-			opaque_within_bounds: not this.gc_has_transparent_index,
-			overwrite_instead_of_blend: false,
-			background_color: background_color)
-	}
-
-	this.num_decoded_frame_configs_value ~sat+= 1
-	this.call_sequence = 4
-}
-
-pri func config_decoder.skip_frame?(src: base.io_reader) {
-	var flags : base.u8
-	var lw    : base.u8
-
-	// Skip the optional Local Color Table, 3 bytes (RGB) per entry.
-	flags = args.src.read_u8?()
-	if (flags & 0x80) <> 0 {
-		args.src.skip_u32?(n: (3 as base.u32) << (1 + (flags & 0x07)))
-	}
-
-	// Process the LZW literal width.
-	lw = args.src.read_u8?()
-	if lw > 8 {
-		return "#bad literal width"
-	}
-
-	// Skip the blocks of LZW-compressed data.
-	this.skip_blocks?(src: args.src)
-
-	if this.quirks[QUIRK_DELAY_NUM_DECODED_FRAMES - QUIRKS_BASE] {
-		this.delayed_num_decoded_frames = true
-	} else {
-		this.num_decoded_frames_value ~sat+= 1
-	}
-	this.reset_gc!()
-}
-
-// TODO: honor args.opts.
-pub func config_decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
-	return base."#unsupported method"
-}
-
-pri func config_decoder.reset_gc!() {
-	this.call_sequence = 5
-	// The Image Descriptor is mandatory, but the Graphic Control extension is
-	// optional. Reset the GC related fields for the next decode_frame call.
-	this.gc_has_transparent_index = false
-	this.gc_transparent_index = 0
-	this.gc_disposal = 0
-	this.gc_duration = 0
-}
-
-pri func config_decoder.decode_up_to_id_part1?(src: base.io_reader) {
-	var block_type : base.u8
-
-	if not this.restarted {
-		if this.call_sequence <> 2 {
-			this.frame_config_io_position = args.src.position()
-		}
-	} else if this.frame_config_io_position <> args.src.position() {
-		return base."#bad restart"
-	} else {
-		this.restarted = false
-	}
-
-	while true {
-		block_type = args.src.read_u8?()
-		if block_type == 0x21 {  // The spec calls 0x21 the "Extension Introducer".
-			this.decode_extension?(src: args.src)
-		} else if block_type == 0x2C {  // The spec calls 0x2C the "Image Separator".
-			if this.delayed_num_decoded_frames {
-				this.delayed_num_decoded_frames = false
-				this.num_decoded_frames_value ~sat+= 1
-			}
-			this.decode_id_part0?(src: args.src)
-			break
-		} else {
-			// If we don't have 0x21 or 0x2C then, according to the spec, the
-			// only valid byte is 0x3B, called the "Trailer". In practice, some
-			// other popular decoders allow anything (other than 0x21 or 0x2C)
-			// to be equivalent to 0x3B, which ends the animated GIF image, and
-			// we do likewise here. Some real world GIF files that exhibit this
-			// are at https://github.com/golang/go/issues/38853
-			//
-			// Chromium's decoder
-			// https://skia.googlesource.com/libgifcodec/+/c002ec500aba1e1b0189547629787cb02db78193/SkGifImageReader.cpp#563
-			//
-			// Firefox's decoder
-			// https://dxr.mozilla.org/mozilla-central/rev/93a33cb7f2369ac4f1d1f2ac97ec14ba60e1e7d7/image/decoders/nsGIFDecoder2.cpp#569
-			if this.delayed_num_decoded_frames {
-				this.delayed_num_decoded_frames = false
-				this.num_decoded_frames_value ~sat+= 1
-			}
-			this.end_of_data = true
-			break
-		}
-	} endwhile
-}
-
-// decode_header reads either "GIF87a" or "GIF89a".
-//
-// See the spec section 17 "Header" on page 7.
-pri func config_decoder.decode_header?(src: base.io_reader) {
-	var c : array[6] base.u8
-	var i : base.u32
-
-	while i < 6 {
-		c[i] = args.src.read_u8?()
-		i += 1
-	} endwhile
-	if (c[0] <> 'G') or (c[1] <> 'I') or (c[2] <> 'F') or (c[3] <> '8') or
-		((c[4] <> '7') and (c[4] <> '9')) or (c[5] <> 'a') {
-		return "#bad header"
-	}
-}
-
-// decode_lsd reads the Logical Screen Descriptor.
-//
-// See the spec section 18 "Logical Screen Descriptor" on page 8.
-pri func config_decoder.decode_lsd?(src: base.io_reader) {
-	var flags                  : base.u8
-	var background_color_index : base.u8
-	var num_palette_entries    : base.u32[..= 256]
-	var i                      : base.u32
-	var j                      : base.u32[..= 1020]
-	var argb                   : base.u32
-
-	this.width = args.src.read_u16le_as_u32?()
-	this.height = args.src.read_u16le_as_u32?()
-	flags = args.src.read_u8?()
-	background_color_index = args.src.read_u8?()
-	// Ignore the Pixel Aspect Ratio byte.
-	args.src.skip_u32?(n: 1)
-
-	// Read the optional Global Color Table.
-	i = 0
-	this.has_global_palette = (flags & 0x80) <> 0
-	if this.has_global_palette {
-		num_palette_entries = (1 as base.u32) << (1 + (flags & 0x07))
-		while i < num_palette_entries {
-			assert i < 256 via "a < b: a < c; c <= b"(c: num_palette_entries)
-			// Convert from RGB (in memory order) to ARGB (in native u32 order)
-			// to BGRA (in memory order).
-			argb = args.src.read_u24be_as_u32?()
-			argb |= 0xFF00_0000
-			this.palettes[0][(4 * i) + 0] = ((argb >> 0) & 0xFF) as base.u8
-			this.palettes[0][(4 * i) + 1] = ((argb >> 8) & 0xFF) as base.u8
-			this.palettes[0][(4 * i) + 2] = ((argb >> 16) & 0xFF) as base.u8
-			this.palettes[0][(4 * i) + 3] = ((argb >> 24) & 0xFF) as base.u8
-			i += 1
-		} endwhile
-
-		if this.quirks[QUIRK_HONOR_BACKGROUND_COLOR - QUIRKS_BASE] {
-			if (background_color_index <> 0) and
-				((background_color_index as base.u32) < num_palette_entries) {
-
-				j = 4 * (background_color_index as base.u32)
-				this.background_color_u32_argb_premul =
-					((this.palettes[0][j + 0] as base.u32) << 0) |
-					((this.palettes[0][j + 1] as base.u32) << 8) |
-					((this.palettes[0][j + 2] as base.u32) << 16) |
-					((this.palettes[0][j + 3] as base.u32) << 24)
-			} else {
-				// The background color is either opaque black or transparent
-				// black. We set it to an arbitrary nonsense value (77) for
-				// now, and set it to its real value later, once we know
-				// whether the first frame is opaque (the ffio value).
-				this.background_color_u32_argb_premul = 77
-			}
-		}
-	}
-
-	// Set the remaining palette entries to opaque black.
-	while i < 256 {
-		this.palettes[0][(4 * i) + 0] = 0x00
-		this.palettes[0][(4 * i) + 1] = 0x00
-		this.palettes[0][(4 * i) + 2] = 0x00
-		this.palettes[0][(4 * i) + 3] = 0xFF
-		i += 1
-	} endwhile
-}
-
-// decode_extension reads an extension. The Extension Introducer byte has
-// already been read.
-//
-// See the spec:
-//  - section 23 "Graphic Control Extension" on page 15.
-//  - section 24 "Comment Extension" on page 17.
-//  - section 25 "Plain Text Extension" on page 18.
-//  - section 26 "Application Extension" on page 21.
-pri func config_decoder.decode_extension?(src: base.io_reader) {
-	var label : base.u8
-
-	label = args.src.read_u8?()
-	if label == 0xF9 {  // The spec calls 0xF9 the "Graphic Control Label".
-		this.decode_gc?(src: args.src)
-		return ok
-	} else if label == 0xFF {  // The spec calls 0xFF the "Application Extension Label".
-		this.decode_ae?(src: args.src)
-		return ok
-	}
-	// We skip over all other extensions, including 0x01 "Plain Text Label" and
-	// 0xFE "Comment Label".
-	this.skip_blocks?(src: args.src)
-}
-
-pri func config_decoder.skip_blocks?(src: base.io_reader) {
-	var block_size : base.u8
-
-	while true {
-		block_size = args.src.read_u8?()
-		if block_size == 0 {
-			return ok
-		}
-		args.src.skip_u32?(n: block_size as base.u32)
-	} endwhile
-}
-
-// decode_ae reads an Application Extension.
-pri func config_decoder.decode_ae?(src: base.io_reader) {
-	var c           : base.u8
-	var block_size  : base.u8
-	var is_animexts : base.bool
-	var is_netscape : base.bool
-	var is_iccp     : base.bool
-	var is_xmp      : base.bool
-
-	while.goto_done true {{
-	if this.metadata_fourcc <> 0 {
-		return base."@metadata reported"
-	}
-
-	block_size = args.src.read_u8?()
-	if block_size == 0 {
-		return ok
-	}
-
-	// Look only for an 11 byte "ANIMEXTS1.0", "NETSCAPE2.0" or other
-	// extension, as per:
-	//  - http://www.vurdalakov.net/misc/gif/animexts-looping-application-extension
-	//  - http://www.vurdalakov.net/misc/gif/netscape-looping-application-extension
-	//
-	// Other extensions include XMP metadata.
-	if block_size <> 11 {
-		args.src.skip_u32?(n: block_size as base.u32)
-		break.goto_done
-	}
-	is_animexts = true
-	is_netscape = true
-	is_iccp = true
-	is_xmp = true
-	block_size = 0  // Re-purpose the block_size variable as a counter.
-	while block_size < 11 {
-		c = args.src.read_u8?()
-		is_animexts = is_animexts and (c == ANIMEXTS1DOT0[block_size])
-		is_netscape = is_netscape and (c == NETSCAPE2DOT0[block_size])
-		is_iccp = is_iccp and (c == ICCRGBG1012[block_size])
-		is_xmp = is_xmp and (c == XMPDATAXMP[block_size])
-		block_size += 1
-	} endwhile
-
-	if is_animexts or is_netscape {
-		// Those 11 bytes should be followed by 0x03, 0x01 and then the loop
-		// count.
-		block_size = args.src.read_u8?()
-		if block_size <> 3 {
-			args.src.skip_u32?(n: block_size as base.u32)
-			break.goto_done
-		}
-		c = args.src.read_u8?()
-		if c <> 0x01 {
-			args.src.skip_u32?(n: 2)
-			break.goto_done
-		}
-		this.num_loops = args.src.read_u16le_as_u32?()
-		this.seen_num_loops = true
-
-		// A loop count of N, in the wire format, actually means "repeat N
-		// times after the first play", if N is positive. A zero N means to
-		// loop forever. Playing the frames exactly once is denoted by the
-		// *absence* of this NETSCAPE2.0 application extension.
-		//
-		// For example, if there are four frames: A, B, C, D, and N is 2, then
-		// each frame is actually played N+1 or 3 times: ABCDABCDABCD.
-		//
-		// Thus, we increment N if it is positive. The comparison against
-		// 0xFFFF will never fail, but is necessary for the overflow checker.
-		if (0 < this.num_loops) and (this.num_loops <= 0xFFFF) {
-			this.num_loops += 1
-		}
-
-	} else if this.ignore_metadata {
-		// No-op.
-
-	} else if is_iccp and this.report_metadata_iccp {
-		this.metadata_fourcc = 'ICCP'be
-		this.metadata_io_position = args.src.position()
-		this.call_sequence = 1
-		return base."@metadata reported"
-
-	} else if is_xmp and this.report_metadata_xmp {
-		this.metadata_fourcc = 'XMP 'be
-		this.metadata_io_position = args.src.position()
-		this.call_sequence = 1
-		return base."@metadata reported"
-	}
-
-	break.goto_done
-	}} endwhile.goto_done
-
-	this.skip_blocks?(src: args.src)
-}
-
-// decode_gc reads a Graphic Control.
-pri func config_decoder.decode_gc?(src: base.io_reader) {
-	var c                        : base.u8
-	var flags                    : base.u8
-	var gc_duration_centiseconds : base.u16
-
-	c = args.src.read_u8?()
-	if c <> 4 {
-		return "#bad graphic control"
-	}
-
-	flags = args.src.read_u8?()
-	this.gc_has_transparent_index = (flags & 0x01) <> 0
-
-	// Convert the disposal method from GIF's wire format to Wuffs constants.
-	//
-	// The GIF spec discusses the 3-bit flag value being 0, 1, 2 or 3. Values
-	// in the range [4 ..= 7] are "to be defined". In practice, some encoders also
-	// use 4 for "restore previous". See
-	// https://cs.chromium.org/chromium/src/third_party/blink/renderer/platform/image-decoders/gif/gif_image_reader.cc?rcl=5161173c43324da2b13e1aa45bbe69901daa1279&l=625
-	//
-	// TODO: named constants instead of assigning 1 for
-	// WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND, etc.
-	flags = (flags >> 2) & 0x07
-	if flags == 2 {
-		this.gc_disposal = 1  // 1 is WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND
-	} else if (flags == 3) or (flags == 4) {
-		this.gc_disposal = 2  // 2 is WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS
-	} else {
-		this.gc_disposal = 0
-	}
-
-	// There are 7_056000 flicks per centisecond.
-	gc_duration_centiseconds = args.src.read_u16le?()
-	this.gc_duration = (gc_duration_centiseconds as base.u64) * 7_056000
-	this.gc_transparent_index = args.src.read_u8?()
-
-	c = args.src.read_u8?()
-	if c <> 0 {
-		return "#bad graphic control"
-	}
-}
-
-// decode_id_partX reads an Image Descriptor. The Image Separator byte has
-// already been read.
-//
-// See the spec section 20 "Image Descriptor" on page 11.
-//
-// The code is split into three parts (part0, part 1 and part12 because
-// determining the overall image's width and height also requires decoding the
-// first frame's bounds (part0), but doesn't require decoding the first frame's
-// pixels (the other two parts). Decoding the actual pixels is split into two
-// (part1 and part2) not out of necessity, just for the general programming
-// principle that smaller functions are easier to understand.
-
-pri func config_decoder.decode_id_part0?(src: base.io_reader) {
-	this.frame_rect_x0 = args.src.read_u16le_as_u32?()
-	this.frame_rect_y0 = args.src.read_u16le_as_u32?()
-	this.frame_rect_x1 = args.src.read_u16le_as_u32?()
-	this.frame_rect_x1 ~mod+= this.frame_rect_x0
-	this.frame_rect_y1 = args.src.read_u16le_as_u32?()
-	this.frame_rect_y1 ~mod+= this.frame_rect_y0
-
-	// Set the image's overall width and height to be the maximum of the
-	// nominal image width and height (given in the Logical Screen Descriptor)
-	// and the bottom right extent of the first frame. See
-	// test/data/artificial/gif-frame-out-of-bounds.gif.make-artificial.txt for
-	// more discussion.
-	if (this.call_sequence == 0) and (not this.quirks[QUIRK_IMAGE_BOUNDS_ARE_STRICT - QUIRKS_BASE]) {
-		this.width = this.width.max(a: this.frame_rect_x1)
-		this.height = this.height.max(a: this.frame_rect_y1)
-	}
-}
diff --git a/std/gif/decode_gif.wuffs b/std/gif/decode_gif.wuffs
index f0e5c47..17d83c5 100644
--- a/std/gif/decode_gif.wuffs
+++ b/std/gif/decode_gif.wuffs
@@ -14,27 +14,6 @@
 
 // --------
 
-//#USE "go run preprocess-wuffs.go" TO MAKE decode_config.wuffs
-//#WHEN PREPROC000
-//
-// This file defines "struct decoder". It is also preprocessed (copied with
-// automatic edits) to generate the decode_config.wuffs file that defines
-// "struct config_decoder". See preprocess-wuffs.go for more detail about the
-// preprocessor language (the //#FOOBAR comments).
-//
-// config_decoder does not implement decode_frame, only decode_frame_config and
-// decode_image_config (and other miscellaneous methods). The sizeof the
-// config_decoder can be substantially smaller than the sizeof the full
-// decoder, as it does not need any internal buffers for understanding the
-// underlying compression format.
-//
-//#WHEN PREPROC000 decode_config.wuffs
-//#REPLACE   "func decoder" WITH   "func config_decoder"
-//#REPLACE "struct decoder" WITH "struct config_decoder"
-//#DONE PREPROC000
-
-// --------
-
 pub struct decoder? implements base.image_decoder(
 	width  : base.u32,
 	height : base.u32,
@@ -117,7 +96,6 @@
 	frame_rect_x1 : base.u32,
 	frame_rect_y1 : base.u32,
 
-	//#WHEN PREPROC100
 	// The dst_etc fields are the output cursor during copy_to_image_buffer.
 	dst_x            : base.u32,
 	dst_y            : base.u32,
@@ -128,11 +106,9 @@
 	compressed_wi : base.u64,
 
 	swizzler : base.pixel_swizzler,
-	//#DONE PREPROC100
 
 	util : base.utility,
 )(
-	//#WHEN PREPROC101
 	compressed : array[4096] base.u8,
 
 	// palettes[0] and palettes[1] are the Global and Local Color Table.
@@ -141,9 +117,6 @@
 	dst_palette : array[4 * 256] base.u8,
 
 	lzw : lzw.decoder,
-	//#WHEN PREPROC101 decode_config.wuffs
-	//## palettes : array[1] array[4 * 256] base.u8,
-	//#DONE PREPROC101
 )
 
 pub func decoder.set_quirk_enabled!(quirk: base.u32, enabled: base.bool) {
@@ -308,7 +281,6 @@
 }
 
 pub func decoder.frame_dirty_rect() base.rect_ie_u32 {
-	//#WHEN PREPROC200
 	// The "foo.min(a:this.width_or_height)" calls clip the nominal frame_rect
 	// to the image_rect.
 	return this.util.make_rect_ie_u32(
@@ -316,19 +288,12 @@
 		min_incl_y: this.frame_rect_y0.min(a: this.height),
 		max_excl_x: this.frame_rect_x1.min(a: this.width),
 		max_excl_y: this.dirty_max_excl_y.min(a: this.height))
-	//#WHEN PREPROC200 decode_config.wuffs
-	//## return this.util.empty_rect_ie_u32()
-	//#DONE PREPROC200
 }
 
 pub func decoder.workbuf_len() base.range_ii_u64 {
-	//#WHEN PREPROC201
 	return this.util.make_range_ii_u64(
 		min_incl: DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE,
 		max_incl: DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE)
-	//#WHEN PREPROC201 decode_config.wuffs
-	//## return this.util.empty_range_ii_u64()
-	//#DONE PREPROC201
 }
 
 pub func decoder.restart_frame!(index: base.u64, io_position: base.u64) base.status {
@@ -351,9 +316,7 @@
 
 	this.ignore_metadata = true
 
-	//#WHEN PREPROC202
 	this.dirty_max_excl_y = 0
-	//#DONE PREPROC202
 
 	if not this.end_of_data {
 		if this.call_sequence == 0 {
@@ -443,7 +406,6 @@
 
 // TODO: honor args.opts.
 pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
-	//#WHEN PREPROC300
 	this.ignore_metadata = true
 	if this.call_sequence <> 4 {
 		this.decode_frame_config?(dst: nullptr, src: args.src)
@@ -457,9 +419,6 @@
 
 	this.num_decoded_frames_value ~sat+= 1
 	this.reset_gc!()
-	//#WHEN PREPROC300 decode_config.wuffs
-	//## return base."#unsupported method"
-	//#DONE PREPROC300
 }
 
 pri func decoder.reset_gc!() {
@@ -796,10 +755,8 @@
 	this.frame_rect_y1 = args.src.read_u16le_as_u32?()
 	this.frame_rect_y1 ~mod+= this.frame_rect_y0
 
-	//#WHEN PREPROC400
 	this.dst_x = this.frame_rect_x0
 	this.dst_y = this.frame_rect_y0
-	//#DONE PREPROC400
 
 	// Set the image's overall width and height to be the maximum of the
 	// nominal image width and height (given in the Logical Screen Descriptor)
@@ -812,7 +769,6 @@
 	}
 }
 
-//#WHEN PREPROC900
 pri func decoder.decode_id_part1?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend) {
 	var flags               : base.u8
 	var which_palette       : base.u8[..= 1]
@@ -1146,4 +1102,3 @@
 	} endwhile
 	return ok
 }
-//#DONE PREPROC900
diff --git a/test/c/std/gif.c b/test/c/std/gif.c
index ca3e510..319d298 100644
--- a/test/c/std/gif.c
+++ b/test/c/std/gif.c
@@ -170,19 +170,6 @@
 // ---------------- GIF Tests
 
 const char*  //
-test_wuffs_gif_decode_interface_image_config_decoder() {
-  CHECK_FOCUS(__func__);
-  wuffs_gif__config_decoder dec;
-  CHECK_STATUS("initialize",
-               wuffs_gif__config_decoder__initialize(
-                   &dec, sizeof dec, WUFFS_VERSION,
-                   WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
-  return do_test__wuffs_base__image_config_decoder(
-      wuffs_gif__config_decoder__upcast_as__wuffs_base__image_decoder(&dec),
-      "test/data/animated-red-blue.gif", 0, SIZE_MAX, 4);
-}
-
-const char*  //
 test_wuffs_gif_decode_interface_image_decoder() {
   CHECK_FOCUS(__func__);
   wuffs_gif__decoder dec;
@@ -1998,21 +1985,6 @@
   return NULL;
 }
 
-const char*  //
-test_wuffs_gif_sizeof() {
-  CHECK_FOCUS(__func__);
-  size_t n0 = sizeof(wuffs_gif__config_decoder);
-  size_t n1 = sizeof(wuffs_gif__decoder);
-  // As of 2020-02-05, the two sizeof's differ by over 60KiB. The exact
-  // difference doesn't really matter, just that it's non-trivial.
-  if ((n1 < n0) || ((n1 - n0) < 8192)) {
-    RETURN_FAIL(
-        "config_decoder (%zu) not substantially smaller than decoder (%zu)", n0,
-        n1);
-  }
-  return NULL;
-}
-
 // ---------------- Mimic Tests
 
 #ifdef WUFFS_MIMIC
@@ -2358,7 +2330,6 @@
     test_wuffs_gif_decode_input_is_a_gif_many_medium_reads,
     test_wuffs_gif_decode_input_is_a_gif_many_small_reads,
     test_wuffs_gif_decode_input_is_a_png,
-    test_wuffs_gif_decode_interface_image_config_decoder,
     test_wuffs_gif_decode_interface_image_decoder,
     test_wuffs_gif_decode_interlaced_truncated,
     test_wuffs_gif_decode_metadata_empty,
@@ -2383,7 +2354,6 @@
     test_wuffs_gif_io_position_one_chunk,
     test_wuffs_gif_io_position_two_chunks,
     test_wuffs_gif_small_frame_interlaced,
-    test_wuffs_gif_sizeof,
 
 #ifdef WUFFS_MIMIC
 
diff --git a/test/c/testlib/testlib.c b/test/c/testlib/testlib.c
index d7cd760..5dc741f 100644
--- a/test/c/testlib/testlib.c
+++ b/test/c/testlib/testlib.c
@@ -1059,35 +1059,6 @@
 }
 
 const char*  //
-do_test__wuffs_base__image_config_decoder(wuffs_base__image_decoder* b,
-                                          const char* src_filename,
-                                          size_t src_ri,
-                                          size_t src_wi,
-                                          uint64_t want_num_frames) {
-  wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
-      .data = g_src_slice_u8,
-  });
-  CHECK_STRING(read_file_fragment(&src, src_filename, src_ri, src_wi));
-
-  uint64_t have_num_frames;
-  for (have_num_frames = 0;; have_num_frames++) {
-    wuffs_base__status status =
-        wuffs_base__image_decoder__decode_frame_config(b, NULL, &src);
-    if (status.repr == wuffs_base__note__end_of_data) {
-      break;
-    } else if (!wuffs_base__status__is_ok(&status)) {
-      RETURN_FAIL("decode_frame_config: \"%s\"", status.repr);
-    }
-  }
-
-  if (have_num_frames != want_num_frames) {
-    RETURN_FAIL("num_frames: have %" PRIu64 ", want %" PRIu64, have_num_frames,
-                want_num_frames);
-  }
-  return NULL;
-}
-
-const char*  //
 do_test__wuffs_base__image_decoder(
     wuffs_base__image_decoder* b,
     const char* src_filename,