LLVMFuzzerTestOneInput:
  118|  3.50k|LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
  119|  3.50k|  llvmFuzzerTestOneInput(data, size);
  120|  3.50k|  return 0;
  121|  3.50k|}
pixel_swizzler_fuzzer.c:llvmFuzzerTestOneInput:
   84|  3.50k|llvmFuzzerTestOneInput(const uint8_t* data, size_t size) {
   85|       |  // Make a 64-bit hash out of two 32-bit hashes, each on half of the data.
   86|  3.50k|  size_t s2 = size / 2;
   87|  3.50k|  uint32_t hash0 = jenkins_hash_u32(data, s2);
   88|  3.50k|  uint32_t hash1 = jenkins_hash_u32(data + s2, size - s2);
   89|  3.50k|  uint64_t hash = (((uint64_t)hash0) << 32) | ((uint64_t)hash1);
   90|       |
   91|       |  // The ! means that closed will be true for (size == 0).
   92|  3.50k|  const bool closed = !(1 & popcount32(hash0));
   93|       |
   94|  3.50k|  wuffs_base__io_buffer src =
   95|  3.50k|      wuffs_base__ptr_u8__reader((uint8_t*)data, size, closed);
   96|       |
   97|  3.50k|  const char* msg = fuzz(&src, hash);
   98|  3.50k|  if (msg) {
  ------------------
  |  Branch (98:7): [True: 2.01k, False: 1.49k]
  ------------------
   99|  2.01k|    if (strnlen(msg, 2047) >= 2047) {
  ------------------
  |  Branch (99:9): [True: 0, False: 2.01k]
  ------------------
  100|      0|      msg = "fuzzlib: internal error: error message is too long";
  101|      0|    }
  102|  2.01k|    if (closed && strstr(msg, "base: short read")) {
  ------------------
  |  Branch (102:9): [True: 1.03k, False: 980]
  |  Branch (102:19): [True: 0, False: 1.03k]
  ------------------
  103|      0|      fprintf(stderr, "short read on a closed io_reader\n");
  104|      0|      intentional_segfault();
  105|  2.01k|    } else if (strstr(msg, "internal error:")) {
  ------------------
  |  Branch (105:16): [True: 0, False: 2.01k]
  ------------------
  106|       |      fprintf(stderr, "internal errors shouldn't occur: \"%s\"\n", msg);
  107|      0|      intentional_segfault();
  108|      0|    }
  109|  2.01k|  }
  110|  3.50k|  return msg;
  111|  3.50k|}
pixel_swizzler_fuzzer.c:jenkins_hash_u32:
   53|  7.01k|jenkins_hash_u32(const uint8_t* data, size_t size) {
   54|  7.01k|  uint32_t hash = 0;
   55|  7.01k|  size_t i = 0;
   56|  25.2M|  while (i != size) {
  ------------------
  |  Branch (56:10): [True: 25.2M, False: 7.01k]
  ------------------
   57|  25.2M|    hash += data[i++];
   58|  25.2M|    hash += hash << 10;
   59|  25.2M|    hash ^= hash >> 6;
   60|  25.2M|  }
   61|  7.01k|  hash += hash << 3;
   62|  7.01k|  hash ^= hash >> 11;
   63|  7.01k|  hash += hash << 15;
   64|  7.01k|  return hash;
   65|  7.01k|}
pixel_swizzler_fuzzer.c:popcount32:
   27|  3.50k|popcount32(uint32_t x) {
   28|  3.50k|  static const uint8_t table[256] = {
   29|  3.50k|      0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,  //
   30|  3.50k|      1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,  //
   31|  3.50k|      1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,  //
   32|  3.50k|      2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,  //
   33|  3.50k|      1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,  //
   34|  3.50k|      2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,  //
   35|  3.50k|      2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,  //
   36|  3.50k|      3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,  //
   37|  3.50k|      1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,  //
   38|  3.50k|      2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,  //
   39|  3.50k|      2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,  //
   40|  3.50k|      3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,  //
   41|  3.50k|      2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,  //
   42|  3.50k|      3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,  //
   43|  3.50k|      3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,  //
   44|  3.50k|      4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,  //
   45|  3.50k|  };
   46|  3.50k|  return table[0xFF & (x >> 0)] + table[0xFF & (x >> 8)] +
   47|  3.50k|         table[0xFF & (x >> 16)] + table[0xFF & (x >> 24)];
   48|  3.50k|}

round_up_to_pagesize:
   97|      3|round_up_to_pagesize(size_t n) {
   98|      3|  size_t ps = getpagesize();
   99|      3|  if (ps <= 0) {
  ------------------
  |  Branch (99:7): [True: 0, False: 3]
  ------------------
  100|      0|    return n;
  101|      0|  }
  102|      3|  return ((n + (ps - 1)) / ps) * ps;
  103|      3|}
allocate_guarded_pages:
  109|      7|allocate_guarded_pages(uint8_t** ptr_out, size_t len) {
  110|      7|  void* ptr =
  111|      7|      mmap(NULL, 2 * len, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
  112|      7|  if (ptr == MAP_FAILED) {
  ------------------
  |  Branch (112:7): [True: 0, False: 7]
  ------------------
  113|      0|    return "fuzz: internal error: mmap failed";
  114|      0|  }
  115|      7|  if (mprotect(ptr, len, PROT_READ | PROT_WRITE)) {
  ------------------
  |  Branch (115:7): [True: 0, False: 7]
  ------------------
  116|      0|    return "fuzz: internal error: mprotect failed";
  117|      0|  }
  118|      7|  *ptr_out = ptr;
  119|       |  return NULL;
  120|      7|}
fuzz_swizzle_interleaved_from_slice:
  126|  3.50k|fuzz_swizzle_interleaved_from_slice(wuffs_base__io_buffer* src, uint64_t hash) {
  127|  3.50k|  uint8_t dst_palette_array[1024];
  128|  3.50k|  uint8_t src_palette_array[1024];
  129|  3.50k|  if ((src->meta.wi - src->meta.ri) >= 2048) {
  ------------------
  |  Branch (129:7): [True: 222, False: 3.28k]
  ------------------
  130|    222|    memcpy(dst_palette_array, src->data.ptr + src->meta.ri, 1024);
  131|    222|    src->meta.ri += 1024;
  132|    222|    memcpy(src_palette_array, src->data.ptr + src->meta.ri, 1024);
  133|    222|    src->meta.ri += 1024;
  134|  3.28k|  } else {
  135|  3.36M|    for (uint32_t i = 0; i < 1024; i++) {
  ------------------
  |  Branch (135:26): [True: 3.36M, False: 3.28k]
  ------------------
  136|  3.36M|      dst_palette_array[i] = (uint8_t)i;
  137|  3.36M|      src_palette_array[i] = (uint8_t)i;
  138|  3.36M|    }
  139|  3.28k|  }
  140|  3.50k|  wuffs_base__slice_u8 dst_palette =
  141|  3.50k|      wuffs_base__make_slice_u8(&dst_palette_array[0], 1024);
  142|  3.50k|  wuffs_base__slice_u8 src_palette =
  143|  3.50k|      wuffs_base__make_slice_u8(&src_palette_array[0], 1024);
  144|       |
  145|  3.50k|  size_t num_pixfmts = sizeof(pixfmts) / sizeof(pixfmts[0]);
  146|  3.50k|  wuffs_base__pixel_format dst_pixfmt = wuffs_base__make_pixel_format(
  147|  3.50k|      pixfmts[(0xFF & (hash >> 0)) % num_pixfmts]);
  148|  3.50k|  wuffs_base__pixel_format src_pixfmt = wuffs_base__make_pixel_format(
  149|  3.50k|      pixfmts[(0xFF & (hash >> 8)) % num_pixfmts]);
  150|       |
  151|  3.50k|  size_t num_blends = sizeof(blends) / sizeof(blends[0]);
  152|  3.50k|  wuffs_base__pixel_blend blend = blends[(0xFF & (hash >> 16)) % num_blends];
  153|       |
  154|  3.50k|  size_t dst_len = 0xFF & (hash >> 24);
  155|  3.50k|  size_t src_len = 0xFF & (hash >> 32);
  156|       |
  157|  3.50k|  wuffs_base__pixel_swizzler swizzler;
  158|  3.50k|  wuffs_base__status status = wuffs_base__pixel_swizzler__prepare(
  159|  3.50k|      &swizzler, dst_pixfmt, dst_palette, src_pixfmt, src_palette, blend);
  160|  3.50k|  if (status.repr) {
  ------------------
  |  Branch (160:7): [True: 298, False: 3.21k]
  ------------------
  161|    298|    return wuffs_base__status__message(&status);
  162|    298|  }
  163|       |
  164|  3.21k|  static size_t alloc_size = 0;
  165|  3.21k|  if (alloc_size == 0) {
  ------------------
  |  Branch (165:7): [True: 1, False: 3.21k]
  ------------------
  166|      1|    alloc_size = round_up_to_pagesize(0x100);
  167|      1|  }
  168|       |
  169|  3.21k|  static uint8_t* dst_alloc = NULL;
  170|  3.21k|  if (!dst_alloc) {
  ------------------
  |  Branch (170:7): [True: 1, False: 3.21k]
  ------------------
  171|      1|    const char* z = allocate_guarded_pages(&dst_alloc, alloc_size);
  172|      1|    if (z != NULL) {
  ------------------
  |  Branch (172:9): [True: 0, False: 1]
  ------------------
  173|      0|      return z;
  174|      0|    }
  175|      1|  }
  176|       |
  177|  3.21k|  static uint8_t* src_alloc = NULL;
  178|  3.21k|  if (!src_alloc) {
  ------------------
  |  Branch (178:7): [True: 1, False: 3.21k]
  ------------------
  179|      1|    const char* z = allocate_guarded_pages(&src_alloc, alloc_size);
  180|      1|    if (z != NULL) {
  ------------------
  |  Branch (180:9): [True: 0, False: 1]
  ------------------
  181|      0|      return z;
  182|      0|    }
  183|      1|  }
  184|       |
  185|       |  // Position dst_slice and src_slice so that reading or writing one byte past
  186|       |  // their end will cause a segmentation fault.
  187|  3.21k|  wuffs_base__slice_u8 dst_slice =
  188|  3.21k|      wuffs_base__make_slice_u8(dst_alloc + alloc_size - dst_len, dst_len);
  189|  3.21k|  wuffs_base__slice_u8 src_slice =
  190|  3.21k|      wuffs_base__make_slice_u8(src_alloc + alloc_size - src_len, src_len);
  191|       |
  192|       |  // Fill in dst_slice and src_slice.
  193|  3.21k|  if ((src->meta.wi - src->meta.ri) >= (dst_len + src_len)) {
  ------------------
  |  Branch (193:7): [True: 584, False: 2.62k]
  ------------------
  194|    584|    memcpy(dst_slice.ptr, src->data.ptr + src->meta.ri, dst_len);
  195|    584|    src->meta.ri += dst_len;
  196|    584|    memcpy(src_slice.ptr, src->data.ptr + src->meta.ri, src_len);
  197|    584|    src->meta.ri += src_len;
  198|  2.62k|  } else {
  199|   330k|    for (size_t i = 0; i < dst_len; i++) {
  ------------------
  |  Branch (199:24): [True: 328k, False: 2.62k]
  ------------------
  200|   328k|      dst_slice.ptr[i] = (uint8_t)i;
  201|   328k|    }
  202|   232k|    for (size_t i = 0; i < src_len; i++) {
  ------------------
  |  Branch (202:24): [True: 229k, False: 2.62k]
  ------------------
  203|   229k|      src_slice.ptr[i] = (uint8_t)i;
  204|   229k|    }
  205|  2.62k|  }
  206|       |
  207|       |  // When manually testing this program, enabling this code should lead to a
  208|       |  // segmentation fault.
  209|       |#if 0
  210|       |  src_slice.ptr[src_slice.len]++;
  211|       |#endif
  212|       |
  213|       |  // Calling etc__swizzle_interleaved_from_slice should not crash, whether for
  214|       |  // reading/writing out of bounds or for other reasons.
  215|  3.21k|  wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(
  216|  3.21k|      &swizzler, dst_slice, dst_palette, src_slice);
  217|       |
  218|       |  return NULL;
  219|  3.21k|}
fuzz_swizzle_ycck:
  222|  3.50k|fuzz_swizzle_ycck(wuffs_base__io_buffer* src, uint64_t hash) {
  223|  3.50k|  uint8_t dst_palette_array[1024] = {0};
  224|  3.50k|  wuffs_base__slice_u8 dst_palette =
  225|  3.50k|      wuffs_base__make_slice_u8(&dst_palette_array[0], 1024);
  226|       |
  227|  3.50k|  size_t num_pixfmts = sizeof(pixfmts) / sizeof(pixfmts[0]);
  228|  3.50k|  wuffs_base__pixel_format dst_pixfmt = wuffs_base__make_pixel_format(
  229|  3.50k|      pixfmts[(0xFF & (hash >> 0)) % num_pixfmts]);
  230|       |
  231|  3.50k|  uint32_t x_min_incl = (63 & (hash >> 8)) + 1;
  232|  3.50k|  uint32_t x_max_excl = (63 & (hash >> 14)) + 1;
  233|  3.50k|  uint32_t y_min_incl = (63 & (hash >> 20)) + 1;
  234|  3.50k|  uint32_t y_max_excl = (63 & (hash >> 26)) + 1;
  235|       |
  236|  3.50k|  uint32_t width_in_mcus = (3 & (hash >> 32)) + 1;
  237|  3.50k|  uint32_t height_in_mcus = (3 & (hash >> 34)) + 1;
  238|       |
  239|  3.50k|  uint32_t allow_hv3 = 1 & (hash >> 36);
  240|  3.50k|  uint8_t ycc_model = (1 & (hash >> 37)) ? 0x80 : 0x00;
  ------------------
  |  Branch (240:23): [True: 1.10k, False: 2.40k]
  ------------------
  241|  3.50k|  uint8_t ycc_upsampling = 1 & (hash >> 38);
  242|  3.50k|  bool use_4th_component = 1 & (hash >> 39);
  243|       |
  244|  3.50k|  if (ycc_upsampling) {
  ------------------
  |  Branch (244:7): [True: 1.35k, False: 2.15k]
  ------------------
  245|  1.35k|    x_min_incl = 0;
  246|  1.35k|    y_min_incl = 0;
  247|  2.15k|  } else {
  248|  2.15k|    if (x_min_incl > x_max_excl) {
  ------------------
  |  Branch (248:9): [True: 1.08k, False: 1.06k]
  ------------------
  249|  1.08k|      uint32_t a = x_min_incl;
  250|  1.08k|      x_min_incl = x_max_excl;
  251|  1.08k|      x_max_excl = a;
  252|  1.08k|    }
  253|  2.15k|    if (y_min_incl > y_max_excl) {
  ------------------
  |  Branch (253:9): [True: 1.25k, False: 898]
  ------------------
  254|  1.25k|      uint32_t a = y_min_incl;
  255|  1.25k|      y_min_incl = y_max_excl;
  256|  1.25k|      y_max_excl = a;
  257|  1.25k|    }
  258|  2.15k|  }
  259|       |
  260|  3.50k|  uint32_t possible_hv_values[2][4] = {
  261|  3.50k|      {1, 1, 2, 4},
  262|  3.50k|      {1, 1, 3, 3},
  263|  3.50k|  };
  264|  3.50k|  uint32_t h0 = possible_hv_values[allow_hv3][3 & (hash >> 28)];
  265|  3.50k|  uint32_t h1 = possible_hv_values[allow_hv3][3 & (hash >> 30)];
  266|  3.50k|  uint32_t h2 = possible_hv_values[allow_hv3][3 & (hash >> 32)];
  267|  3.50k|  uint32_t h3 =
  268|  3.50k|      use_4th_component ? possible_hv_values[allow_hv3][3 & (hash >> 34)] : 0;
  ------------------
  |  Branch (268:7): [True: 804, False: 2.70k]
  ------------------
  269|  3.50k|  uint32_t v0 = possible_hv_values[allow_hv3][3 & (hash >> 36)];
  270|  3.50k|  uint32_t v1 = possible_hv_values[allow_hv3][3 & (hash >> 38)];
  271|  3.50k|  uint32_t v2 = possible_hv_values[allow_hv3][3 & (hash >> 40)];
  272|  3.50k|  uint32_t v3 =
  273|  3.50k|      use_4th_component ? possible_hv_values[allow_hv3][3 & (hash >> 42)] : 0;
  ------------------
  |  Branch (273:7): [True: 804, False: 2.70k]
  ------------------
  274|       |
  275|  3.50k|  uint32_t width0 = 8 * width_in_mcus * h0;
  276|  3.50k|  uint32_t width1 = 8 * width_in_mcus * h1;
  277|  3.50k|  uint32_t width2 = 8 * width_in_mcus * h2;
  278|  3.50k|  uint32_t width3 = 8 * width_in_mcus * h3;
  279|  3.50k|  uint32_t height0 = 8 * height_in_mcus * v0;
  280|  3.50k|  uint32_t height1 = 8 * height_in_mcus * v1;
  281|  3.50k|  uint32_t height2 = 8 * height_in_mcus * v2;
  282|  3.50k|  uint32_t height3 = 8 * height_in_mcus * v3;
  283|       |
  284|  3.50k|  uint32_t hmax = wuffs_base__u32__max(
  285|  3.50k|      h0, wuffs_base__u32__max(h1, wuffs_base__u32__max(h2, h3)));
  286|  3.50k|  uint32_t vmax = wuffs_base__u32__max(
  287|  3.50k|      v0, wuffs_base__u32__max(v1, wuffs_base__u32__max(v2, v3)));
  288|  3.50k|  x_max_excl = x_min_incl + wuffs_base__u32__min(x_max_excl - x_min_incl,
  289|  3.50k|                                                 8 * width_in_mcus * hmax);
  290|  3.50k|  y_max_excl = y_min_incl + wuffs_base__u32__min(y_max_excl - y_min_incl,
  291|  3.50k|                                                 8 * height_in_mcus * vmax);
  292|       |
  293|  3.50k|  static size_t dst_alloc_size = 0;
  294|  3.50k|  if (dst_alloc_size == 0) {
  ------------------
  |  Branch (294:7): [True: 1, False: 3.50k]
  ------------------
  295|      1|    dst_alloc_size = round_up_to_pagesize(8 * 64 * 64);
  296|      1|  }
  297|       |
  298|  3.50k|  static uint8_t* dst_alloc = NULL;
  299|  3.50k|  if (!dst_alloc) {
  ------------------
  |  Branch (299:7): [True: 1, False: 3.50k]
  ------------------
  300|      1|    const char* z = allocate_guarded_pages(&dst_alloc, dst_alloc_size);
  301|      1|    if (z != NULL) {
  ------------------
  |  Branch (301:9): [True: 0, False: 1]
  ------------------
  302|      0|      return z;
  303|      0|    }
  304|      1|  }
  305|       |
  306|  3.50k|  wuffs_base__pixel_buffer dst_pixbuf;
  307|  3.50k|  wuffs_base__pixel_config dst_pixcfg;
  308|  3.50k|  wuffs_base__pixel_config__set(&dst_pixcfg, dst_pixfmt.repr, 0, x_max_excl,
  309|  3.50k|                                y_max_excl);
  310|  3.50k|  uint64_t dst_pixbuf_len = wuffs_base__pixel_config__pixbuf_len(&dst_pixcfg);
  311|  3.50k|  if (dst_pixbuf_len > dst_alloc_size) {
  ------------------
  |  Branch (311:7): [True: 0, False: 3.50k]
  ------------------
  312|      0|    return "fuzz: internal error: dst_alloc_size is too small";
  313|  3.50k|  } else {
  314|  3.50k|    wuffs_base__status status = wuffs_base__pixel_buffer__set_from_slice(
  315|  3.50k|        &dst_pixbuf, &dst_pixcfg,
  316|  3.50k|        wuffs_base__make_slice_u8(dst_alloc + dst_alloc_size - dst_pixbuf_len,
  317|  3.50k|                                  dst_pixbuf_len));
  318|  3.50k|    if (status.repr) {
  ------------------
  |  Branch (318:9): [True: 0, False: 3.50k]
  ------------------
  319|      0|      return "fuzz: internal error: wuffs_base__pixel_buffer__set_from_slice "
  320|      0|             "failed";
  321|      0|    }
  322|  3.50k|  }
  323|       |
  324|  3.50k|  static size_t src_alloc_size = 0;
  325|  3.50k|  if (src_alloc_size == 0) {
  ------------------
  |  Branch (325:7): [True: 1, False: 3.50k]
  ------------------
  326|      1|    src_alloc_size = round_up_to_pagesize(8 * 4 * 4 * 8 * 4 * 4);
  327|      1|  }
  328|       |
  329|  3.50k|  static uint8_t* src_alloc0 = NULL;
  330|  3.50k|  static uint8_t* src_alloc1 = NULL;
  331|  3.50k|  static uint8_t* src_alloc2 = NULL;
  332|  3.50k|  static uint8_t* src_alloc3 = NULL;
  333|  3.50k|  if (!src_alloc0) {
  ------------------
  |  Branch (333:7): [True: 1, False: 3.50k]
  ------------------
  334|      1|    const char* z = allocate_guarded_pages(&src_alloc0, src_alloc_size);
  335|      1|    if (z != NULL) {
  ------------------
  |  Branch (335:9): [True: 0, False: 1]
  ------------------
  336|      0|      return z;
  337|      0|    }
  338|      1|  }
  339|  3.50k|  if (!src_alloc1) {
  ------------------
  |  Branch (339:7): [True: 1, False: 3.50k]
  ------------------
  340|      1|    const char* z = allocate_guarded_pages(&src_alloc1, src_alloc_size);
  341|      1|    if (z != NULL) {
  ------------------
  |  Branch (341:9): [True: 0, False: 1]
  ------------------
  342|      0|      return z;
  343|      0|    }
  344|      1|  }
  345|  3.50k|  if (!src_alloc2) {
  ------------------
  |  Branch (345:7): [True: 1, False: 3.50k]
  ------------------
  346|      1|    const char* z = allocate_guarded_pages(&src_alloc2, src_alloc_size);
  347|      1|    if (z != NULL) {
  ------------------
  |  Branch (347:9): [True: 0, False: 1]
  ------------------
  348|      0|      return z;
  349|      0|    }
  350|      1|  }
  351|  3.50k|  if (!src_alloc3) {
  ------------------
  |  Branch (351:7): [True: 1, False: 3.50k]
  ------------------
  352|      1|    const char* z = allocate_guarded_pages(&src_alloc3, src_alloc_size);
  353|      1|    if (z != NULL) {
  ------------------
  |  Branch (353:9): [True: 0, False: 1]
  ------------------
  354|      0|      return z;
  355|      0|    }
  356|      1|  }
  357|       |
  358|  3.50k|  uint32_t src_len0 = width0 * height0;
  359|  3.50k|  uint32_t src_len1 = width1 * height1;
  360|  3.50k|  uint32_t src_len2 = width2 * height2;
  361|  3.50k|  uint32_t src_len3 = width3 * height3;
  362|  3.50k|  if ((src_len0 > src_alloc_size) ||  //
  ------------------
  |  Branch (362:7): [True: 0, False: 3.50k]
  ------------------
  363|  3.50k|      (src_len1 > src_alloc_size) ||  //
  ------------------
  |  Branch (363:7): [True: 0, False: 3.50k]
  ------------------
  364|  3.50k|      (src_len2 > src_alloc_size) ||  //
  ------------------
  |  Branch (364:7): [True: 0, False: 3.50k]
  ------------------
  365|  3.50k|      (src_len3 > src_alloc_size)) {
  ------------------
  |  Branch (365:7): [True: 0, False: 3.50k]
  ------------------
  366|      0|    return "fuzz: internal error: src_alloc_size is too small";
  367|      0|  }
  368|       |
  369|  3.50k|  uint8_t s0 = 0x90;
  370|  3.50k|  if (src->meta.ri < src->meta.wi) {
  ------------------
  |  Branch (370:7): [True: 3.20k, False: 306]
  ------------------
  371|  3.20k|    s0 = src->data.ptr[src->meta.ri++];
  372|  3.20k|  }
  373|  3.50k|  uint8_t s1 = 0x91;
  374|  3.50k|  if (src->meta.ri < src->meta.wi) {
  ------------------
  |  Branch (374:7): [True: 2.90k, False: 609]
  ------------------
  375|  2.90k|    s1 = src->data.ptr[src->meta.ri++];
  376|  2.90k|  }
  377|  3.50k|  uint8_t s2 = 0x92;
  378|  3.50k|  if (src->meta.ri < src->meta.wi) {
  ------------------
  |  Branch (378:7): [True: 1.76k, False: 1.74k]
  ------------------
  379|  1.76k|    s2 = src->data.ptr[src->meta.ri++];
  380|  1.76k|  }
  381|  3.50k|  uint8_t s3 = 0x93;
  382|  3.50k|  if (src->meta.ri < src->meta.wi) {
  ------------------
  |  Branch (382:7): [True: 375, False: 3.13k]
  ------------------
  383|    375|    s3 = src->data.ptr[src->meta.ri++];
  384|    375|  }
  385|       |
  386|  3.50k|  wuffs_base__slice_u8 src0 = wuffs_base__make_slice_u8(
  387|  3.50k|      src_alloc0 + src_alloc_size - src_len0, src_len0);
  388|  3.50k|  memset(src0.ptr, s0, src0.len);
  389|  3.50k|  wuffs_base__slice_u8 src1 = wuffs_base__make_slice_u8(
  390|  3.50k|      src_alloc1 + src_alloc_size - src_len1, src_len1);
  391|  3.50k|  memset(src1.ptr, s1, src1.len);
  392|  3.50k|  wuffs_base__slice_u8 src2 = wuffs_base__make_slice_u8(
  393|  3.50k|      src_alloc2 + src_alloc_size - src_len2, src_len2);
  394|  3.50k|  memset(src2.ptr, s2, src2.len);
  395|  3.50k|  wuffs_base__slice_u8 src3 = wuffs_base__empty_slice_u8();
  396|  3.50k|  if (use_4th_component) {
  ------------------
  |  Branch (396:7): [True: 804, False: 2.70k]
  ------------------
  397|    804|    wuffs_base__slice_u8 src3 = wuffs_base__make_slice_u8(
  398|    804|        src_alloc3 + src_alloc_size - src_len3, src_len3);
  399|    804|    memset(src3.ptr, s3, src3.len);
  400|    804|  }
  401|       |
  402|  3.50k|  wuffs_base__pixel_swizzler swizzler = {0};
  403|  3.50k|  uint8_t scratch_buffer[2048];
  404|  3.50k|  wuffs_base__status status = wuffs_base__pixel_swizzler__swizzle_ycck(
  405|  3.50k|      &swizzler, &dst_pixbuf, dst_palette,  //
  406|  3.50k|      x_min_incl, x_max_excl,               //
  407|  3.50k|      y_min_incl, y_max_excl,               //
  408|  3.50k|      src0, src1, src2, src3,               //
  409|  3.50k|      width0, width1, width2, width3,       //
  410|  3.50k|      height0, height1, height2, height3,   //
  411|  3.50k|      width0, width1, width2, width3,       //
  412|  3.50k|      h0, h1, h2, h3,                       //
  413|  3.50k|      v0, v1, v2, v3,                       //
  414|  3.50k|      ycc_model,                            //
  415|  3.50k|      ycc_upsampling,                       //
  416|  3.50k|      wuffs_base__make_slice_u8(scratch_buffer, sizeof(scratch_buffer)));
  417|  3.50k|  if (status.repr) {
  ------------------
  |  Branch (417:7): [True: 1.77k, False: 1.73k]
  ------------------
  418|  1.77k|    return wuffs_base__status__message(&status);
  419|  1.77k|  }
  420|  1.73k|  return NULL;
  421|  3.50k|}
fuzz:
  424|  3.50k|fuzz(wuffs_base__io_buffer* src, uint64_t hash) {
  425|  3.50k|  const char* s0 = fuzz_swizzle_interleaved_from_slice(src, hash);
  426|  3.50k|  const char* s1 = fuzz_swizzle_ycck(src, hash);
  427|  3.50k|  if (s0 && strstr(s0, "internal error:")) {
  ------------------
  |  Branch (427:7): [True: 298, False: 3.21k]
  |  Branch (427:13): [True: 0, False: 298]
  ------------------
  428|      0|    return s0;
  429|      0|  }
  430|  3.50k|  if (s1 && strstr(s1, "internal error:")) {
  ------------------
  |  Branch (430:7): [True: 1.77k, False: 1.73k]
  |  Branch (430:13): [True: 0, False: 1.77k]
  ------------------
  431|      0|    return s1;
  432|      0|  }
  433|  3.50k|  return s0 ? s0 : s1;
  ------------------
  |  Branch (433:10): [True: 298, False: 3.21k]
  ------------------
  434|  3.50k|}

wuffs_base__pixel_buffer__set_color_u32_argb_premul_at:
24596|   509k|    wuffs_base__color_u32_argb_premul color) {
24597|   509k|  if (!pb) {
  ------------------
  |  Branch (24597:7): [True: 0, False: 509k]
  ------------------
24598|      0|    return wuffs_base__make_status(wuffs_base__error__bad_receiver);
24599|      0|  }
24600|   509k|  if ((x >= pb->pixcfg.private_impl.width) ||
  ------------------
  |  Branch (24600:7): [True: 0, False: 509k]
  ------------------
24601|   509k|      (y >= pb->pixcfg.private_impl.height)) {
  ------------------
  |  Branch (24601:7): [True: 0, False: 509k]
  ------------------
24602|      0|    return wuffs_base__make_status(wuffs_base__error__bad_argument);
24603|      0|  }
24604|       |
24605|   509k|  if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) {
  ------------------
  |  Branch (24605:7): [True: 0, False: 509k]
  ------------------
24606|       |    // TODO: support planar formats.
24607|      0|    return wuffs_base__make_status(wuffs_base__error__unsupported_option);
24608|      0|  }
24609|       |
24610|   509k|  size_t stride = pb->private_impl.planes[0].stride;
24611|   509k|  uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y));
24612|       |
24613|   509k|  switch (pb->pixcfg.private_impl.pixfmt.repr) {
24614|  10.3k|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|  10.3k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (24614:5): [True: 10.3k, False: 499k]
  ------------------
24615|  22.0k|    case WUFFS_BASE__PIXEL_FORMAT__BGRX:
  ------------------
  |  | 4969|  22.0k|#define WUFFS_BASE__PIXEL_FORMAT__BGRX                      0x90008888
  ------------------
  |  Branch (24615:5): [True: 11.7k, False: 498k]
  ------------------
24616|  22.0k|      wuffs_base__poke_u32le__no_bounds_check(row + (4 * ((size_t)x)), color);
24617|  22.0k|      break;
24618|       |
24619|       |      // Common formats above. Rarer formats below.
24620|       |
24621|  64.7k|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|  64.7k|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (24621:5): [True: 64.7k, False: 445k]
  ------------------
24622|  64.7k|      wuffs_base__poke_u8__no_bounds_check(
24623|  64.7k|          row + ((size_t)x),
24624|  64.7k|          wuffs_base__color_u32_argb_premul__as__color_u8_gray(color));
24625|  64.7k|      break;
24626|  12.0k|    case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:
  ------------------
  |  | 4944|  12.0k|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE                    0x2000000B
  ------------------
  |  Branch (24626:5): [True: 12.0k, False: 497k]
  ------------------
24627|  12.0k|      wuffs_base__poke_u16le__no_bounds_check(
24628|  12.0k|          row + (2 * ((size_t)x)),
24629|  12.0k|          wuffs_base__color_u32_argb_premul__as__color_u16_gray(color));
24630|  12.0k|      break;
24631|  12.0k|    case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:
  ------------------
  |  | 4945|  12.0k|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE                    0x2010000B
  ------------------
  |  Branch (24631:5): [True: 12.0k, False: 497k]
  ------------------
24632|  12.0k|      wuffs_base__poke_u16be__no_bounds_check(
24633|  12.0k|          row + (2 * ((size_t)x)),
24634|  12.0k|          wuffs_base__color_u32_argb_premul__as__color_u16_gray(color));
24635|  12.0k|      break;
24636|  23.6k|    case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL:
  ------------------
  |  | 4946|  23.6k|#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL              0x21000088
  ------------------
  |  Branch (24636:5): [True: 23.6k, False: 486k]
  ------------------
24637|  23.6k|      wuffs_base__poke_u16le__no_bounds_check(
24638|  23.6k|          row + (2 * ((size_t)x)),
24639|  23.6k|          wuffs_base__color_u32_argb_premul__as__color_u16_alpha_gray_nonpremul(
24640|  23.6k|              color));
24641|  23.6k|      break;
24642|       |
24643|  42.6k|    case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:
  ------------------
  |  | 4958|  42.6k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL   0x81040008
  ------------------
  |  Branch (24643:5): [True: 42.6k, False: 467k]
  ------------------
24644|  42.6k|    case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:
  ------------------
  |  | 4959|  42.6k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL      0x82040008
  ------------------
  |  Branch (24644:5): [True: 0, False: 509k]
  ------------------
24645|  72.9k|    case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:
  ------------------
  |  | 4960|  72.9k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY      0x83040008
  ------------------
  |  Branch (24645:5): [True: 30.3k, False: 479k]
  ------------------
24646|  72.9k|      wuffs_base__poke_u8__no_bounds_check(
24647|  72.9k|          row + ((size_t)x), wuffs_base__pixel_palette__closest_element(
24648|  72.9k|                                 wuffs_base__pixel_buffer__palette(pb),
24649|  72.9k|                                 pb->pixcfg.private_impl.pixfmt, color));
24650|  72.9k|      break;
24651|       |
24652|  57.3k|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|  57.3k|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (24652:5): [True: 57.3k, False: 452k]
  ------------------
24653|  57.3k|      wuffs_base__poke_u16le__no_bounds_check(
24654|  57.3k|          row + (2 * ((size_t)x)),
24655|  57.3k|          wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(color));
24656|  57.3k|      break;
24657|  55.5k|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|  55.5k|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (24657:5): [True: 55.5k, False: 454k]
  ------------------
24658|  55.5k|      wuffs_base__poke_u24le__no_bounds_check(row + (3 * ((size_t)x)), color);
24659|  55.5k|      break;
24660|  27.7k|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|  27.7k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (24660:5): [True: 27.7k, False: 482k]
  ------------------
24661|  27.7k|      wuffs_base__poke_u32le__no_bounds_check(
24662|  27.7k|          row + (4 * ((size_t)x)),
24663|  27.7k|          wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(
24664|  27.7k|              color));
24665|  27.7k|      break;
24666|  70.3k|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|  70.3k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (24666:5): [True: 70.3k, False: 439k]
  ------------------
24667|  70.3k|      wuffs_base__poke_u64le__no_bounds_check(
24668|  70.3k|          row + (8 * ((size_t)x)),
24669|  70.3k|          wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul(
24670|  70.3k|              color));
24671|  70.3k|      break;
24672|      0|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:
  ------------------
  |  | 4967|      0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE        0x8200BBBB
  ------------------
  |  Branch (24672:5): [True: 0, False: 509k]
  ------------------
24673|      0|      wuffs_base__poke_u64le__no_bounds_check(
24674|      0|          row + (8 * ((size_t)x)), wuffs_base__color_u32__as__color_u64(color));
24675|      0|      break;
24676|      0|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
  ------------------
  |  | 4968|      0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY               0x83008888
  ------------------
  |  Branch (24676:5): [True: 0, False: 509k]
  ------------------
24677|      0|      wuffs_base__poke_u32le__no_bounds_check(
24678|      0|          row + (4 * ((size_t)x)), (color >> 31) ? (color | 0xFF000000) : 0);
  ------------------
  |  Branch (24678:36): [True: 0, False: 0]
  ------------------
24679|      0|      break;
24680|       |
24681|  56.0k|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|  56.0k|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (24681:5): [True: 56.0k, False: 453k]
  ------------------
24682|  56.0k|      wuffs_base__poke_u24le__no_bounds_check(
24683|  56.0k|          row + (3 * ((size_t)x)), wuffs_base__color_swap_u32_argb_abgr(color));
24684|  56.0k|      break;
24685|  21.2k|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|  21.2k|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (24685:5): [True: 21.2k, False: 488k]
  ------------------
24686|  21.2k|      wuffs_base__poke_u32le__no_bounds_check(
24687|  21.2k|          row + (4 * ((size_t)x)),
24688|  21.2k|          wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(
24689|  21.2k|              wuffs_base__color_swap_u32_argb_abgr(color)));
24690|  21.2k|      break;
24691|  14.1k|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|  14.1k|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (24691:5): [True: 14.1k, False: 495k]
  ------------------
24692|  14.1k|    case WUFFS_BASE__PIXEL_FORMAT__RGBX:
  ------------------
  |  | 4977|  14.1k|#define WUFFS_BASE__PIXEL_FORMAT__RGBX                      0xB0008888
  ------------------
  |  Branch (24692:5): [True: 0, False: 509k]
  ------------------
24693|  14.1k|      wuffs_base__poke_u32le__no_bounds_check(
24694|  14.1k|          row + (4 * ((size_t)x)), wuffs_base__color_swap_u32_argb_abgr(color));
24695|  14.1k|      break;
24696|       |
24697|      0|    default:
  ------------------
  |  Branch (24697:5): [True: 0, False: 509k]
  ------------------
24698|       |      // TODO: support more formats.
24699|      0|      return wuffs_base__make_status(wuffs_base__error__unsupported_option);
24700|   509k|  }
24701|       |
24702|   509k|  return wuffs_base__make_status(NULL);
24703|   509k|}
wuffs_base__pixel_palette__closest_element:
25365|  72.9k|    wuffs_base__color_u32_argb_premul c) {
25366|  72.9k|  size_t n = palette_slice.len / 4;
25367|  72.9k|  if (n > (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
  ------------------
  |  | 4900|  72.9k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
  |  Branch (25367:7): [True: 0, False: 72.9k]
  ------------------
25368|      0|    n = (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4);
  ------------------
  |  | 4900|      0|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
25369|      0|  }
25370|  72.9k|  size_t best_index = 0;
25371|  72.9k|  uint64_t best_score = 0xFFFFFFFFFFFFFFFF;
25372|       |
25373|       |  // Work in 16-bit color.
25374|  72.9k|  uint32_t ca = 0x101 * (0xFF & (c >> 24));
25375|  72.9k|  uint32_t cr = 0x101 * (0xFF & (c >> 16));
25376|  72.9k|  uint32_t cg = 0x101 * (0xFF & (c >> 8));
25377|  72.9k|  uint32_t cb = 0x101 * (0xFF & (c >> 0));
25378|       |
25379|  72.9k|  switch (palette_format.repr) {
  ------------------
  |  Branch (25379:11): [True: 72.9k, False: 0]
  ------------------
25380|  42.6k|    case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:
  ------------------
  |  | 4958|  42.6k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL   0x81040008
  ------------------
  |  Branch (25380:5): [True: 42.6k, False: 30.3k]
  ------------------
25381|  42.6k|    case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:
  ------------------
  |  | 4959|  42.6k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL      0x82040008
  ------------------
  |  Branch (25381:5): [True: 0, False: 72.9k]
  ------------------
25382|  72.9k|    case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: {
  ------------------
  |  | 4960|  72.9k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY      0x83040008
  ------------------
  |  Branch (25382:5): [True: 30.3k, False: 42.6k]
  ------------------
25383|  72.9k|      bool nonpremul = palette_format.repr ==
25384|  72.9k|                       WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL;
  ------------------
  |  | 4958|  72.9k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL   0x81040008
  ------------------
25385|       |
25386|  72.9k|      size_t i;
25387|  18.7M|      for (i = 0; i < n; i++) {
  ------------------
  |  Branch (25387:19): [True: 18.6M, False: 72.9k]
  ------------------
25388|       |        // Work in 16-bit color.
25389|  18.6M|        uint32_t pb = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 0]));
25390|  18.6M|        uint32_t pg = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 1]));
25391|  18.6M|        uint32_t pr = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 2]));
25392|  18.6M|        uint32_t pa = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 3]));
25393|       |
25394|       |        // Convert to premultiplied alpha.
25395|  18.6M|        if (nonpremul && (pa != 0xFFFF)) {
  ------------------
  |  Branch (25395:13): [True: 10.9M, False: 7.76M]
  |  Branch (25395:26): [True: 6.56M, False: 4.34M]
  ------------------
25396|  6.56M|          pb = (pb * pa) / 0xFFFF;
25397|  6.56M|          pg = (pg * pa) / 0xFFFF;
25398|  6.56M|          pr = (pr * pa) / 0xFFFF;
25399|  6.56M|        }
25400|       |
25401|       |        // These deltas are conceptually int32_t (signed) but after squaring,
25402|       |        // it's equivalent to work in uint32_t (unsigned).
25403|  18.6M|        pb -= cb;
25404|  18.6M|        pg -= cg;
25405|  18.6M|        pr -= cr;
25406|  18.6M|        pa -= ca;
25407|  18.6M|        uint64_t score = ((uint64_t)(pb * pb)) + ((uint64_t)(pg * pg)) +
25408|  18.6M|                         ((uint64_t)(pr * pr)) + ((uint64_t)(pa * pa));
25409|  18.6M|        if (best_score > score) {
  ------------------
  |  Branch (25409:13): [True: 123k, False: 18.5M]
  ------------------
25410|   123k|          best_score = score;
25411|   123k|          best_index = i;
25412|   123k|        }
25413|  18.6M|      }
25414|  72.9k|      break;
25415|  42.6k|    }
25416|  72.9k|  }
25417|       |
25418|  72.9k|  return (uint8_t)best_index;
25419|  72.9k|}
wuffs_base__pixel_swizzler__prepare:
32599|  3.50k|                                    wuffs_base__pixel_blend blend) {
32600|  3.50k|  if (!p) {
  ------------------
  |  Branch (32600:7): [True: 0, False: 3.50k]
  ------------------
32601|      0|    return wuffs_base__make_status(wuffs_base__error__bad_receiver);
32602|      0|  }
32603|  3.50k|  p->private_impl.func = NULL;
32604|  3.50k|  p->private_impl.transparent_black_func = NULL;
32605|  3.50k|  p->private_impl.dst_pixfmt_bytes_per_pixel = 0;
32606|  3.50k|  p->private_impl.src_pixfmt_bytes_per_pixel = 0;
32607|       |
32608|       |  // ----
32609|       |
32610|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST)
32611|       |  switch (dst_pixfmt.repr) {
32612|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_Y)
32613|       |    case WUFFS_BASE__PIXEL_FORMAT__Y:
32614|       |      break;
32615|       |#endif
32616|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_YA_NONPREMUL)
32617|       |    case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL:
32618|       |      break;
32619|       |#endif
32620|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGR_565)
32621|       |    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
32622|       |      break;
32623|       |#endif
32624|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGR)
32625|       |    case WUFFS_BASE__PIXEL_FORMAT__BGR:
32626|       |      break;
32627|       |#endif
32628|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_NONPREMUL)
32629|       |    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
32630|       |      break;
32631|       |#endif
32632|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_NONPREMUL_4X16LE)
32633|       |    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
32634|       |      break;
32635|       |#endif
32636|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_PREMUL)
32637|       |    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
32638|       |      break;
32639|       |#endif
32640|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGB)
32641|       |    case WUFFS_BASE__PIXEL_FORMAT__RGB:
32642|       |      break;
32643|       |#endif
32644|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGBA_NONPREMUL)
32645|       |    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
32646|       |      break;
32647|       |#endif
32648|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGBA_PREMUL)
32649|       |    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
32650|       |      break;
32651|       |#endif
32652|       |    default:
32653|       |      return wuffs_base__make_status(
32654|       |          wuffs_base__error__disabled_by_wuffs_config_dst_pixel_format_enable_allowlist);
32655|       |  }
32656|       |#endif  // defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST)
32657|       |
32658|       |  // ----
32659|       |
32660|  3.50k|  wuffs_base__pixel_swizzler__func func = NULL;
32661|  3.50k|  wuffs_base__pixel_swizzler__transparent_black_func transparent_black_func =
32662|  3.50k|      NULL;
32663|       |
32664|  3.50k|  uint32_t dst_pixfmt_bits_per_pixel =
32665|  3.50k|      wuffs_base__pixel_format__bits_per_pixel(&dst_pixfmt);
32666|  3.50k|  if ((dst_pixfmt_bits_per_pixel == 0) ||
  ------------------
  |  Branch (32666:7): [True: 0, False: 3.50k]
  ------------------
32667|  3.50k|      ((dst_pixfmt_bits_per_pixel & 7) != 0)) {
  ------------------
  |  Branch (32667:7): [True: 0, False: 3.50k]
  ------------------
32668|      0|    return wuffs_base__make_status(
32669|      0|        wuffs_base__error__unsupported_pixel_swizzler_option);
32670|      0|  }
32671|       |
32672|  3.50k|  uint32_t src_pixfmt_bits_per_pixel =
32673|  3.50k|      wuffs_base__pixel_format__bits_per_pixel(&src_pixfmt);
32674|  3.50k|  if ((src_pixfmt_bits_per_pixel == 0) ||
  ------------------
  |  Branch (32674:7): [True: 0, False: 3.50k]
  ------------------
32675|  3.50k|      ((src_pixfmt_bits_per_pixel & 7) != 0)) {
  ------------------
  |  Branch (32675:7): [True: 0, False: 3.50k]
  ------------------
32676|      0|    return wuffs_base__make_status(
32677|      0|        wuffs_base__error__unsupported_pixel_swizzler_option);
32678|      0|  }
32679|       |
32680|       |  // TODO: support many more formats.
32681|       |
32682|  3.50k|  switch (blend) {
  ------------------
  |  Branch (32682:11): [True: 3.50k, False: 0]
  ------------------
32683|  1.54k|    case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|  1.54k|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32683:5): [True: 1.54k, False: 1.96k]
  ------------------
32684|  1.54k|      transparent_black_func =
32685|  1.54k|          wuffs_private_impl__swizzle_transparent_black_src;
32686|  1.54k|      break;
32687|       |
32688|  1.96k|    case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|  1.96k|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32688:5): [True: 1.96k, False: 1.54k]
  ------------------
32689|  1.96k|      transparent_black_func =
32690|  1.96k|          wuffs_private_impl__swizzle_transparent_black_src_over;
32691|  1.96k|      break;
32692|  3.50k|  }
32693|       |
32694|  3.50k|  switch (src_pixfmt.repr) {
  ------------------
  |  Branch (32694:11): [True: 3.50k, False: 0]
  ------------------
32695|    133|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|    133|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (32695:5): [True: 133, False: 3.37k]
  ------------------
32696|    133|      func = wuffs_private_impl__pixel_swizzler__prepare__y(
32697|    133|          p, dst_pixfmt, dst_palette, src_palette, blend);
32698|    133|      break;
32699|       |
32700|    130|    case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:
  ------------------
  |  | 4945|    130|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE                    0x2010000B
  ------------------
  |  Branch (32700:5): [True: 130, False: 3.37k]
  ------------------
32701|    130|      func = wuffs_private_impl__pixel_swizzler__prepare__y_16be(
32702|    130|          p, dst_pixfmt, dst_palette, src_palette, blend);
32703|    130|      break;
32704|       |
32705|    136|    case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:
  ------------------
  |  | 4944|    136|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE                    0x2000000B
  ------------------
  |  Branch (32705:5): [True: 136, False: 3.37k]
  ------------------
32706|    136|      func = wuffs_private_impl__pixel_swizzler__prepare__y_16le(
32707|    136|          p, dst_pixfmt, dst_palette, src_palette, blend);
32708|    136|      break;
32709|       |
32710|    306|    case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL:
  ------------------
  |  | 4946|    306|#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL              0x21000088
  ------------------
  |  Branch (32710:5): [True: 306, False: 3.20k]
  ------------------
32711|    306|      func = wuffs_private_impl__pixel_swizzler__prepare__ya_nonpremul(
32712|    306|          p, dst_pixfmt, dst_palette, src_palette, blend);
32713|    306|      break;
32714|       |
32715|    237|    case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:
  ------------------
  |  | 4958|    237|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL   0x81040008
  ------------------
  |  Branch (32715:5): [True: 237, False: 3.27k]
  ------------------
32716|    237|      func =
32717|    237|          wuffs_private_impl__pixel_swizzler__prepare__indexed__bgra_nonpremul(
32718|    237|              p, dst_pixfmt, dst_palette, src_palette, blend);
32719|    237|      break;
32720|       |
32721|    341|    case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:
  ------------------
  |  | 4960|    341|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY      0x83040008
  ------------------
  |  Branch (32721:5): [True: 341, False: 3.16k]
  ------------------
32722|    341|      func = wuffs_private_impl__pixel_swizzler__prepare__indexed__bgra_binary(
32723|    341|          p, dst_pixfmt, dst_palette, src_palette, blend);
32724|    341|      break;
32725|       |
32726|    130|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|    130|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (32726:5): [True: 130, False: 3.37k]
  ------------------
32727|    130|      func = wuffs_private_impl__pixel_swizzler__prepare__bgr_565(
32728|    130|          p, dst_pixfmt, dst_palette, src_palette, blend);
32729|    130|      break;
32730|       |
32731|    133|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|    133|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (32731:5): [True: 133, False: 3.37k]
  ------------------
32732|    133|      func = wuffs_private_impl__pixel_swizzler__prepare__bgr(
32733|    133|          p, dst_pixfmt, dst_palette, src_palette, blend);
32734|    133|      break;
32735|       |
32736|    223|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|    223|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (32736:5): [True: 223, False: 3.28k]
  ------------------
32737|    223|      func = wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul(
32738|    223|          p, dst_pixfmt, dst_palette, src_palette, blend);
32739|    223|      break;
32740|       |
32741|    296|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|    296|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (32741:5): [True: 296, False: 3.21k]
  ------------------
32742|    296|      func = wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul_4x16le(
32743|    296|          p, dst_pixfmt, dst_palette, src_palette, blend);
32744|    296|      break;
32745|       |
32746|    281|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|    281|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (32746:5): [True: 281, False: 3.22k]
  ------------------
32747|    281|      func = wuffs_private_impl__pixel_swizzler__prepare__bgra_premul(
32748|    281|          p, dst_pixfmt, dst_palette, src_palette, blend);
32749|    281|      break;
32750|       |
32751|    441|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:
  ------------------
  |  | 4967|    441|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE        0x8200BBBB
  ------------------
  |  Branch (32751:5): [True: 441, False: 3.06k]
  ------------------
32752|    441|      func = wuffs_private_impl__pixel_swizzler__prepare__bgra_premul_4x16le(
32753|    441|          p, dst_pixfmt, dst_palette, src_palette, blend);
32754|    441|      break;
32755|       |
32756|      0|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
  ------------------
  |  | 4968|      0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY               0x83008888
  ------------------
  |  Branch (32756:5): [True: 0, False: 3.50k]
  ------------------
32757|      0|      func = wuffs_private_impl__pixel_swizzler__prepare__bgra_binary(
32758|      0|          p, dst_pixfmt, dst_palette, src_palette, blend);
32759|      0|      break;
32760|       |
32761|    122|    case WUFFS_BASE__PIXEL_FORMAT__BGRX:
  ------------------
  |  | 4969|    122|#define WUFFS_BASE__PIXEL_FORMAT__BGRX                      0x90008888
  ------------------
  |  Branch (32761:5): [True: 122, False: 3.38k]
  ------------------
32762|    122|      func = wuffs_private_impl__pixel_swizzler__prepare__bgrx(
32763|    122|          p, dst_pixfmt, dst_palette, src_palette, blend);
32764|    122|      break;
32765|       |
32766|    114|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|    114|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (32766:5): [True: 114, False: 3.39k]
  ------------------
32767|    114|      func = wuffs_private_impl__pixel_swizzler__prepare__rgb(
32768|    114|          p, dst_pixfmt, dst_palette, src_palette, blend);
32769|    114|      break;
32770|       |
32771|    226|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|    226|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (32771:5): [True: 226, False: 3.28k]
  ------------------
32772|    226|      func = wuffs_private_impl__pixel_swizzler__prepare__rgba_nonpremul(
32773|    226|          p, dst_pixfmt, dst_palette, src_palette, blend);
32774|    226|      break;
32775|       |
32776|    260|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|    260|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (32776:5): [True: 260, False: 3.24k]
  ------------------
32777|    260|      func = wuffs_private_impl__pixel_swizzler__prepare__rgba_premul(
32778|    260|          p, dst_pixfmt, dst_palette, src_palette, blend);
32779|    260|      break;
32780|  3.50k|  }
32781|       |
32782|  3.50k|  p->private_impl.func = func;
32783|  3.50k|  p->private_impl.transparent_black_func = transparent_black_func;
32784|  3.50k|  p->private_impl.dst_pixfmt_bytes_per_pixel = dst_pixfmt_bits_per_pixel / 8;
32785|  3.50k|  p->private_impl.src_pixfmt_bytes_per_pixel = src_pixfmt_bits_per_pixel / 8;
32786|  3.50k|  return wuffs_base__make_status(
32787|  3.50k|      func ? NULL : wuffs_base__error__unsupported_pixel_swizzler_option);
  ------------------
  |  Branch (32787:7): [True: 3.21k, False: 298]
  ------------------
32788|  3.50k|}
wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice:
32837|  3.21k|    wuffs_base__slice_u8 src) {
32838|  3.21k|  if (p && p->private_impl.func) {
  ------------------
  |  Branch (32838:7): [True: 3.21k, False: 0]
  |  Branch (32838:12): [True: 3.21k, False: 0]
  ------------------
32839|  3.21k|    return (*p->private_impl.func)(dst.ptr, dst.len, dst_palette.ptr,
32840|  3.21k|                                   dst_palette.len, src.ptr, src.len);
32841|  3.21k|  }
32842|      0|  return 0;
32843|  3.21k|}
wuffs_base__pixel_swizzler__swizzle_ycck:
34295|  3.50k|    wuffs_base__slice_u8 scratch_buffer_2k) {
34296|  3.50k|  if (!p) {
  ------------------
  |  Branch (34296:7): [True: 0, False: 3.50k]
  ------------------
34297|      0|    return wuffs_base__make_status(wuffs_base__error__bad_receiver);
34298|  3.50k|  } else if (!dst ||                             //
  ------------------
  |  Branch (34298:14): [True: 0, False: 3.50k]
  ------------------
34299|  3.50k|             (x_min_incl > x_max_excl) ||        //
  ------------------
  |  Branch (34299:14): [True: 0, False: 3.50k]
  ------------------
34300|  3.50k|             (x_max_excl > 0xFFFFu) ||           //
  ------------------
  |  Branch (34300:14): [True: 0, False: 3.50k]
  ------------------
34301|  3.50k|             (y_min_incl > y_max_excl) ||        //
  ------------------
  |  Branch (34301:14): [True: 0, False: 3.50k]
  ------------------
34302|  3.50k|             (y_max_excl > 0xFFFFu) ||           //
  ------------------
  |  Branch (34302:14): [True: 0, False: 3.50k]
  ------------------
34303|  3.50k|             (4u <= ((unsigned int)h0 - 1u)) ||  //
  ------------------
  |  Branch (34303:14): [True: 0, False: 3.50k]
  ------------------
34304|  3.50k|             (4u <= ((unsigned int)h1 - 1u)) ||  //
  ------------------
  |  Branch (34304:14): [True: 0, False: 3.50k]
  ------------------
34305|  3.50k|             (4u <= ((unsigned int)h2 - 1u)) ||  //
  ------------------
  |  Branch (34305:14): [True: 0, False: 3.50k]
  ------------------
34306|  3.50k|             (4u <= ((unsigned int)v0 - 1u)) ||  //
  ------------------
  |  Branch (34306:14): [True: 0, False: 3.50k]
  ------------------
34307|  3.50k|             (4u <= ((unsigned int)v1 - 1u)) ||  //
  ------------------
  |  Branch (34307:14): [True: 0, False: 3.50k]
  ------------------
34308|  3.50k|             (4u <= ((unsigned int)v2 - 1u)) ||  //
  ------------------
  |  Branch (34308:14): [True: 0, False: 3.50k]
  ------------------
34309|  3.50k|             ((ycc_upsampling != 0) && ((x_min_incl | y_min_incl) > 0u)) ||
  ------------------
  |  Branch (34309:15): [True: 1.35k, False: 2.15k]
  |  Branch (34309:40): [True: 0, False: 1.35k]
  ------------------
34310|  3.50k|             (scratch_buffer_2k.len < 2048u)) {
  ------------------
  |  Branch (34310:14): [True: 0, False: 3.50k]
  ------------------
34311|      0|    return wuffs_base__make_status(wuffs_base__error__bad_argument);
34312|      0|  }
34313|  3.50k|  if ((h3 != 0u) || (v3 != 0u)) {
  ------------------
  |  Branch (34313:7): [True: 804, False: 2.70k]
  |  Branch (34313:21): [True: 0, False: 2.70k]
  ------------------
34314|    804|    if ((4u <= ((unsigned int)h3 - 1u)) ||  //
  ------------------
  |  Branch (34314:9): [True: 0, False: 804]
  ------------------
34315|    804|        (4u <= ((unsigned int)v3 - 1u))) {
  ------------------
  |  Branch (34315:9): [True: 0, False: 804]
  ------------------
34316|      0|      return wuffs_base__make_status(wuffs_base__error__bad_argument);
34317|      0|    }
34318|    804|  }
34319|       |
34320|  3.50k|  uint32_t max_incl_h = wuffs_private_impl__u32__max_of_4(h0, h1, h2, h3);
34321|  3.50k|  uint32_t max_incl_v = wuffs_private_impl__u32__max_of_4(v0, v1, v2, v3);
34322|       |
34323|       |  // Calculate the inverse h and v ratios.
34324|       |  //
34325|       |  // It also canonicalizes (h=2 and max_incl_h=4) as equivalent to (h=1 and
34326|       |  // max_incl_h=2). In both cases, the inv_h value is 2.
34327|  3.50k|  uint32_t inv_h0 = max_incl_h / h0;
34328|  3.50k|  uint32_t inv_h1 = max_incl_h / h1;
34329|  3.50k|  uint32_t inv_h2 = max_incl_h / h2;
34330|  3.50k|  uint32_t inv_h3 = h3 ? (max_incl_h / h3) : 0u;
  ------------------
  |  Branch (34330:21): [True: 804, False: 2.70k]
  ------------------
34331|  3.50k|  uint32_t inv_v0 = max_incl_v / v0;
34332|  3.50k|  uint32_t inv_v1 = max_incl_v / v1;
34333|  3.50k|  uint32_t inv_v2 = max_incl_v / v2;
34334|  3.50k|  uint32_t inv_v3 = v3 ? (max_incl_v / v3) : 0u;
  ------------------
  |  Branch (34334:21): [True: 804, False: 2.70k]
  ------------------
34335|       |
34336|  3.50k|  if (x_min_incl != 0) {
  ------------------
  |  Branch (34336:7): [True: 2.15k, False: 1.35k]
  ------------------
34337|  2.15k|    if ((x_min_incl % inv_h0) || (x_min_incl % inv_h1) ||
  ------------------
  |  Branch (34337:9): [True: 438, False: 1.71k]
  |  Branch (34337:34): [True: 226, False: 1.48k]
  ------------------
34338|  1.48k|        (x_min_incl % inv_h2) || (inv_h3 && (x_min_incl % inv_h3))) {
  ------------------
  |  Branch (34338:9): [True: 128, False: 1.36k]
  |  Branch (34338:35): [True: 156, False: 1.20k]
  |  Branch (34338:45): [True: 6, False: 150]
  ------------------
34339|    798|      return wuffs_base__make_status(wuffs_base__error__bad_argument);
34340|    798|    }
34341|  2.15k|  }
34342|  2.71k|  if (y_min_incl != 0) {
  ------------------
  |  Branch (34342:7): [True: 1.35k, False: 1.35k]
  ------------------
34343|  1.35k|    if ((y_min_incl % inv_v0) || (y_min_incl % inv_v1) ||
  ------------------
  |  Branch (34343:9): [True: 281, False: 1.07k]
  |  Branch (34343:34): [True: 90, False: 984]
  ------------------
34344|    984|        (y_min_incl % inv_v2) || (inv_v3 && (y_min_incl % inv_v3))) {
  ------------------
  |  Branch (34344:9): [True: 30, False: 954]
  |  Branch (34344:35): [True: 66, False: 888]
  |  Branch (34344:45): [True: 10, False: 56]
  ------------------
34345|    411|      return wuffs_base__make_status(wuffs_base__error__bad_argument);
34346|    411|    }
34347|  1.35k|  }
34348|       |
34349|  2.30k|  uint32_t half_width_for_2to1 = ((x_max_excl - x_min_incl) + 1u) / 2u;
34350|  2.30k|  if (inv_h0 == 2) {
  ------------------
  |  Branch (34350:7): [True: 320, False: 1.98k]
  ------------------
34351|    320|    half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width0);
34352|    320|  }
34353|  2.30k|  if (inv_h1 == 2) {
  ------------------
  |  Branch (34353:7): [True: 324, False: 1.97k]
  ------------------
34354|    324|    half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width1);
34355|    324|  }
34356|  2.30k|  if (inv_h2 == 2) {
  ------------------
  |  Branch (34356:7): [True: 346, False: 1.95k]
  ------------------
34357|    346|    half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width2);
34358|    346|  }
34359|  2.30k|  if (inv_h3 == 2) {
  ------------------
  |  Branch (34359:7): [True: 75, False: 2.22k]
  ------------------
34360|     75|    half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width3);
34361|     75|  }
34362|       |
34363|  2.30k|  uint32_t half_height_for_2to1 = ((y_max_excl - y_min_incl) + 1u) / 2u;
34364|  2.30k|  if (inv_v0 == 2) {
  ------------------
  |  Branch (34364:7): [True: 352, False: 1.94k]
  ------------------
34365|    352|    half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height0);
34366|    352|  }
34367|  2.30k|  if (inv_v1 == 2) {
  ------------------
  |  Branch (34367:7): [True: 337, False: 1.96k]
  ------------------
34368|    337|    half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height1);
34369|    337|  }
34370|  2.30k|  if (inv_v2 == 2) {
  ------------------
  |  Branch (34370:7): [True: 201, False: 2.09k]
  ------------------
34371|    201|    half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height2);
34372|    201|  }
34373|  2.30k|  if (inv_v3 == 2) {
  ------------------
  |  Branch (34373:7): [True: 62, False: 2.23k]
  ------------------
34374|     62|    half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height3);
34375|     62|  }
34376|       |
34377|  2.30k|  x_max_excl = wuffs_base__u32__min(                   //
34378|  2.30k|      wuffs_base__pixel_config__width(&dst->pixcfg),   //
34379|  2.30k|      x_min_incl + wuffs_private_impl__u32__min_of_5(  //
34380|  2.30k|                       x_max_excl - x_min_incl,        //
34381|  2.30k|                       width0 * inv_h0,                //
34382|  2.30k|                       width1 * inv_h1,                //
34383|  2.30k|                       width2 * inv_h2,                //
34384|  2.30k|                       inv_h3 ? (width3 * inv_h3) : 0xFFFFFFFF));
  ------------------
  |  Branch (34384:24): [True: 538, False: 1.76k]
  ------------------
34385|  2.30k|  y_max_excl = wuffs_base__u32__min(                   //
34386|  2.30k|      wuffs_base__pixel_config__height(&dst->pixcfg),  //
34387|  2.30k|      y_min_incl + wuffs_private_impl__u32__min_of_5(  //
34388|  2.30k|                       y_max_excl - y_min_incl,        //
34389|  2.30k|                       height0 * inv_v0,               //
34390|  2.30k|                       height1 * inv_v1,               //
34391|  2.30k|                       height2 * inv_v2,               //
34392|  2.30k|                       inv_v3 ? (height3 * inv_v3) : 0xFFFFFFFF));
  ------------------
  |  Branch (34392:24): [True: 538, False: 1.76k]
  ------------------
34393|       |
34394|  2.30k|  if ((x_min_incl >= x_max_excl) || (y_min_incl >= y_max_excl)) {
  ------------------
  |  Branch (34394:7): [True: 12, False: 2.28k]
  |  Branch (34394:37): [True: 18, False: 2.27k]
  ------------------
34395|     30|    return wuffs_base__make_status(NULL);
34396|     30|  }
34397|  2.27k|  uint32_t width = x_max_excl - x_min_incl;
34398|  2.27k|  uint32_t height = y_max_excl - y_min_incl;
34399|       |
34400|  2.27k|  if (((h0 * inv_h0) != max_incl_h) ||  //
  ------------------
  |  Branch (34400:7): [True: 0, False: 2.27k]
  ------------------
34401|  2.27k|      ((h1 * inv_h1) != max_incl_h) ||  //
  ------------------
  |  Branch (34401:7): [True: 0, False: 2.27k]
  ------------------
34402|  2.27k|      ((h2 * inv_h2) != max_incl_h) ||  //
  ------------------
  |  Branch (34402:7): [True: 0, False: 2.27k]
  ------------------
34403|  2.27k|      ((v0 * inv_v0) != max_incl_v) ||  //
  ------------------
  |  Branch (34403:7): [True: 0, False: 2.27k]
  ------------------
34404|  2.27k|      ((v1 * inv_v1) != max_incl_v) ||  //
  ------------------
  |  Branch (34404:7): [True: 0, False: 2.27k]
  ------------------
34405|  2.27k|      ((v2 * inv_v2) != max_incl_v) ||  //
  ------------------
  |  Branch (34405:7): [True: 0, False: 2.27k]
  ------------------
34406|  2.27k|      (src0.len < wuffs_private_impl__swizzle_flattened_length(
  ------------------
  |  Branch (34406:7): [True: 0, False: 2.27k]
  ------------------
34407|  2.27k|                      width, height, stride0, inv_h0, inv_v0)) ||
34408|  2.27k|      (src1.len < wuffs_private_impl__swizzle_flattened_length(
  ------------------
  |  Branch (34408:7): [True: 0, False: 2.27k]
  ------------------
34409|  2.27k|                      width, height, stride1, inv_h1, inv_v1)) ||
34410|  2.27k|      (src2.len < wuffs_private_impl__swizzle_flattened_length(
  ------------------
  |  Branch (34410:7): [True: 0, False: 2.27k]
  ------------------
34411|  2.27k|                      width, height, stride2, inv_h2, inv_v2))) {
34412|      0|    return wuffs_base__make_status(wuffs_base__error__bad_argument);
34413|      0|  }
34414|  2.27k|  if ((h3 != 0u) || (v3 != 0u)) {
  ------------------
  |  Branch (34414:7): [True: 537, False: 1.73k]
  |  Branch (34414:21): [True: 0, False: 1.73k]
  ------------------
34415|    537|    if (((h3 * inv_h3) != max_incl_h) ||  //
  ------------------
  |  Branch (34415:9): [True: 0, False: 537]
  ------------------
34416|    537|        ((v3 * inv_v3) != max_incl_v) ||  //
  ------------------
  |  Branch (34416:9): [True: 0, False: 537]
  ------------------
34417|    537|        (src3.len < wuffs_private_impl__swizzle_flattened_length(
  ------------------
  |  Branch (34417:9): [True: 537, False: 0]
  ------------------
34418|    537|                        width, height, stride3, inv_h3, inv_v3))) {
34419|    537|      return wuffs_base__make_status(wuffs_base__error__bad_argument);
34420|    537|    }
34421|    537|  }
34422|       |
34423|  1.73k|  if (wuffs_base__pixel_format__is_planar(&dst->pixcfg.private_impl.pixfmt)) {
  ------------------
  |  Branch (34423:7): [True: 0, False: 1.73k]
  ------------------
34424|       |    // TODO: see wuffs_base__pixel_buffer__set_color_u32_argb_premul_at's TODO.
34425|      0|    return wuffs_base__make_status(
34426|      0|        wuffs_base__error__unsupported_pixel_swizzler_option);
34427|      0|  }
34428|       |
34429|       |  // ----
34430|       |
34431|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST)
34432|       |  switch (dst->pixcfg.private_impl.pixfmt.repr) {
34433|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_Y)
34434|       |    case WUFFS_BASE__PIXEL_FORMAT__Y:
34435|       |      break;
34436|       |#endif
34437|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_YA_NONPREMUL)
34438|       |    case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL:
34439|       |      break;
34440|       |#endif
34441|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGR_565)
34442|       |    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
34443|       |      break;
34444|       |#endif
34445|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGR)
34446|       |    case WUFFS_BASE__PIXEL_FORMAT__BGR:
34447|       |      break;
34448|       |#endif
34449|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_NONPREMUL)
34450|       |    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
34451|       |      break;
34452|       |#endif
34453|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_NONPREMUL_4X16LE)
34454|       |    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
34455|       |      break;
34456|       |#endif
34457|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_PREMUL)
34458|       |    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
34459|       |      break;
34460|       |#endif
34461|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGB)
34462|       |    case WUFFS_BASE__PIXEL_FORMAT__RGB:
34463|       |      break;
34464|       |#endif
34465|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGBA_NONPREMUL)
34466|       |    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
34467|       |      break;
34468|       |#endif
34469|       |#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGBA_PREMUL)
34470|       |    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
34471|       |      break;
34472|       |#endif
34473|       |    default:
34474|       |      return wuffs_base__make_status(
34475|       |          wuffs_base__error__disabled_by_wuffs_config_dst_pixel_format_enable_allowlist);
34476|       |  }
34477|       |#else   // defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST)
34478|  1.73k|  switch (dst->pixcfg.private_impl.pixfmt.repr) {
34479|    173|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|    173|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (34479:5): [True: 173, False: 1.56k]
  ------------------
34480|    203|    case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:
  ------------------
  |  | 4944|    203|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE                    0x2000000B
  ------------------
  |  Branch (34480:5): [True: 30, False: 1.70k]
  ------------------
34481|    230|    case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:
  ------------------
  |  | 4945|    230|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE                    0x2010000B
  ------------------
  |  Branch (34481:5): [True: 27, False: 1.70k]
  ------------------
34482|    295|    case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL:
  ------------------
  |  | 4946|    295|#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL              0x21000088
  ------------------
  |  Branch (34482:5): [True: 65, False: 1.66k]
  ------------------
34483|    371|    case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:
  ------------------
  |  | 4958|    371|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL   0x81040008
  ------------------
  |  Branch (34483:5): [True: 76, False: 1.65k]
  ------------------
34484|    371|    case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:
  ------------------
  |  | 4959|    371|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL      0x82040008
  ------------------
  |  Branch (34484:5): [True: 0, False: 1.73k]
  ------------------
34485|    417|    case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:
  ------------------
  |  | 4960|    417|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY      0x83040008
  ------------------
  |  Branch (34485:5): [True: 46, False: 1.68k]
  ------------------
34486|    555|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|    555|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (34486:5): [True: 138, False: 1.59k]
  ------------------
34487|    662|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|    662|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (34487:5): [True: 107, False: 1.62k]
  ------------------
34488|    834|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|    834|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (34488:5): [True: 172, False: 1.56k]
  ------------------
34489|  1.03k|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|  1.03k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (34489:5): [True: 197, False: 1.53k]
  ------------------
34490|  1.15k|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|  1.15k|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (34490:5): [True: 124, False: 1.60k]
  ------------------
34491|  1.24k|    case WUFFS_BASE__PIXEL_FORMAT__BGRX:
  ------------------
  |  | 4969|  1.24k|#define WUFFS_BASE__PIXEL_FORMAT__BGRX                      0x90008888
  ------------------
  |  Branch (34491:5): [True: 91, False: 1.64k]
  ------------------
34492|  1.35k|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|  1.35k|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (34492:5): [True: 106, False: 1.62k]
  ------------------
34493|  1.55k|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|  1.55k|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (34493:5): [True: 199, False: 1.53k]
  ------------------
34494|  1.70k|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|  1.70k|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (34494:5): [True: 156, False: 1.57k]
  ------------------
34495|  1.70k|    case WUFFS_BASE__PIXEL_FORMAT__RGBX:
  ------------------
  |  | 4977|  1.70k|#define WUFFS_BASE__PIXEL_FORMAT__RGBX                      0xB0008888
  ------------------
  |  Branch (34495:5): [True: 0, False: 1.73k]
  ------------------
34496|  1.70k|      break;
34497|       |
34498|     26|    default:
  ------------------
  |  Branch (34498:5): [True: 26, False: 1.70k]
  ------------------
34499|       |      // TODO: see wuffs_base__pixel_buffer__set_color_u32_argb_premul_at's
34500|       |      // TODO.
34501|     26|      return wuffs_base__make_status(
34502|     26|          wuffs_base__error__unsupported_pixel_swizzler_option);
34503|  1.73k|  }
34504|  1.70k|#endif  // defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST)
34505|       |
34506|       |  // ----
34507|       |
34508|  1.70k|  wuffs_private_impl__swizzle_ycc__convert_3_func conv3func = NULL;
34509|       |
34510|  1.70k|  if (ycc_model >= WUFFS_BASE__YCC_MODEL__RGB) {
  ------------------
  |  | 5257|  1.70k|#define WUFFS_BASE__YCC_MODEL__RGB                                   0x40
  ------------------
  |  Branch (34510:7): [True: 388, False: 1.31k]
  ------------------
34511|    388|    conv3func = &wuffs_private_impl__swizzle_rgb__convert_3_general;
34512|       |
34513|  1.31k|  } else if (ycc_model >= WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE) {
  ------------------
  |  | 5254|  1.31k|#define WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE                   0x04
  ------------------
  |  Branch (34513:14): [True: 0, False: 1.31k]
  ------------------
34514|      0|    switch (dst->pixcfg.private_impl.pixfmt.repr) {
34515|      0|      case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|      0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (34515:7): [True: 0, False: 0]
  ------------------
34516|      0|      case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|      0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (34516:7): [True: 0, False: 0]
  ------------------
34517|      0|      case WUFFS_BASE__PIXEL_FORMAT__BGRX:
  ------------------
  |  | 4969|      0|#define WUFFS_BASE__PIXEL_FORMAT__BGRX                      0x90008888
  ------------------
  |  Branch (34517:7): [True: 0, False: 0]
  ------------------
34518|      0|        conv3func = &wuffs_private_impl__swizzle_ycc_bt601sr__convert_3_bgrx;
34519|      0|        break;
34520|      0|      case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|      0|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (34520:7): [True: 0, False: 0]
  ------------------
34521|      0|      case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|      0|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (34521:7): [True: 0, False: 0]
  ------------------
34522|      0|      case WUFFS_BASE__PIXEL_FORMAT__RGBX:
  ------------------
  |  | 4977|      0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX                      0xB0008888
  ------------------
  |  Branch (34522:7): [True: 0, False: 0]
  ------------------
34523|      0|        conv3func = &wuffs_private_impl__swizzle_ycc_bt601sr__convert_3_rgbx;
34524|      0|        break;
34525|      0|      default:
  ------------------
  |  Branch (34525:7): [True: 0, False: 0]
  ------------------
34526|      0|        conv3func = &wuffs_private_impl__swizzle_ycc_bt601sr__convert_3_general;
34527|      0|        break;
34528|      0|    }
34529|       |
34530|  1.31k|  } else {
34531|  1.31k|    switch (dst->pixcfg.private_impl.pixfmt.repr) {
34532|    136|      case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|    136|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (34532:7): [True: 136, False: 1.18k]
  ------------------
34533|    238|      case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|    238|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (34533:7): [True: 102, False: 1.21k]
  ------------------
34534|    315|      case WUFFS_BASE__PIXEL_FORMAT__BGRX:
  ------------------
  |  | 4969|    315|#define WUFFS_BASE__PIXEL_FORMAT__BGRX                      0x90008888
  ------------------
  |  Branch (34534:7): [True: 77, False: 1.24k]
  ------------------
34535|    315|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
34536|    315|        if (wuffs_base__cpu_arch__have_x86_avx2()) {
  ------------------
  |  Branch (34536:13): [True: 315, False: 0]
  ------------------
34537|    315|          conv3func =
34538|    315|              &wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_bgrx_x86_avx2;
34539|    315|          break;
34540|    315|        }
34541|      0|#endif
34542|      0|        conv3func = &wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_bgrx;
34543|      0|        break;
34544|    173|      case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|    173|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (34544:7): [True: 173, False: 1.14k]
  ------------------
34545|    302|      case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|    302|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (34545:7): [True: 129, False: 1.19k]
  ------------------
34546|    302|      case WUFFS_BASE__PIXEL_FORMAT__RGBX:
  ------------------
  |  | 4977|    302|#define WUFFS_BASE__PIXEL_FORMAT__RGBX                      0xB0008888
  ------------------
  |  Branch (34546:7): [True: 0, False: 1.31k]
  ------------------
34547|    302|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
34548|    302|        if (wuffs_base__cpu_arch__have_x86_avx2()) {
  ------------------
  |  Branch (34548:13): [True: 302, False: 0]
  ------------------
34549|    302|          conv3func =
34550|    302|              &wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_rgbx_x86_avx2;
34551|    302|          break;
34552|    302|        }
34553|      0|#endif
34554|      0|        conv3func = &wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_rgbx;
34555|      0|        break;
34556|    702|      default:
  ------------------
  |  Branch (34556:7): [True: 702, False: 617]
  ------------------
34557|    702|        conv3func = &wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_general;
34558|    702|        break;
34559|  1.31k|    }
34560|  1.31k|  }
34561|       |
34562|  1.70k|  void (*func3)(wuffs_base__pixel_buffer * dst,  //
34563|  1.70k|                uint32_t x_min_incl,             //
34564|  1.70k|                uint32_t x_max_excl,             //
34565|  1.70k|                uint32_t y_min_incl,             //
34566|  1.70k|                uint32_t y_max_excl,             //
34567|  1.70k|                const uint8_t* src_ptr0,         //
34568|  1.70k|                const uint8_t* src_ptr1,         //
34569|  1.70k|                const uint8_t* src_ptr2,         //
34570|  1.70k|                uint32_t stride0,                //
34571|  1.70k|                uint32_t stride1,                //
34572|  1.70k|                uint32_t stride2,                //
34573|  1.70k|                uint32_t inv_h0,                 //
34574|  1.70k|                uint32_t inv_h1,                 //
34575|  1.70k|                uint32_t inv_h2,                 //
34576|  1.70k|                uint32_t inv_v0,                 //
34577|  1.70k|                uint32_t inv_v1,                 //
34578|  1.70k|                uint32_t inv_v2,                 //
34579|  1.70k|                uint32_t half_width_for_2to1,    //
34580|  1.70k|                uint32_t half_height_for_2to1,   //
34581|  1.70k|                uint8_t* scratch_buffer_2k_ptr,  //
34582|  1.70k|                wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4],
34583|  1.70k|                wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) =
34584|  1.70k|      &wuffs_private_impl__swizzle_ycc__general__box_filter;
34585|       |
34586|  1.70k|  void (*func4)(wuffs_base__pixel_buffer * dst,  //
34587|  1.70k|                uint32_t x_min_incl,             //
34588|  1.70k|                uint32_t x_max_excl,             //
34589|  1.70k|                uint32_t y_min_incl,             //
34590|  1.70k|                uint32_t y_max_excl,             //
34591|  1.70k|                const uint8_t* src_ptr0,         //
34592|  1.70k|                const uint8_t* src_ptr1,         //
34593|  1.70k|                const uint8_t* src_ptr2,         //
34594|  1.70k|                const uint8_t* src_ptr3,         //
34595|  1.70k|                uint32_t stride0,                //
34596|  1.70k|                uint32_t stride1,                //
34597|  1.70k|                uint32_t stride2,                //
34598|  1.70k|                uint32_t stride3,                //
34599|  1.70k|                uint32_t inv_h0,                 //
34600|  1.70k|                uint32_t inv_h1,                 //
34601|  1.70k|                uint32_t inv_h2,                 //
34602|  1.70k|                uint32_t inv_h3,                 //
34603|  1.70k|                uint32_t inv_v0,                 //
34604|  1.70k|                uint32_t inv_v1,                 //
34605|  1.70k|                uint32_t inv_v2,                 //
34606|  1.70k|                uint32_t inv_v3,                 //
34607|  1.70k|                uint32_t half_width_for_2to1,    //
34608|  1.70k|                uint32_t half_height_for_2to1,   //
34609|  1.70k|                uint8_t* scratch_buffer_2k_ptr,  //
34610|  1.70k|                wuffs_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4],
34611|  1.70k|                wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) =
34612|  1.70k|      &wuffs_private_impl__swizzle_ycck__general__box_filter;
34613|       |
34614|  1.70k|  wuffs_private_impl__swizzle_ycc__upsample_func upfuncs[4][4];
34615|  1.70k|  memcpy(&upfuncs, &wuffs_private_impl__swizzle_ycc__upsample_funcs,
34616|  1.70k|         sizeof upfuncs);
34617|       |
34618|  1.70k|  if ((ycc_upsampling != 0) &&
  ------------------
  |  Branch (34618:7): [True: 863, False: 844]
  ------------------
34619|    863|      (wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h0, inv_v0) ||
  ------------------
  |  Branch (34619:8): [True: 203, False: 660]
  ------------------
34620|    660|       wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h1, inv_v1) ||
  ------------------
  |  Branch (34620:8): [True: 97, False: 563]
  ------------------
34621|    563|       wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h2, inv_v2) ||
  ------------------
  |  Branch (34621:8): [True: 76, False: 487]
  ------------------
34622|    487|       wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h3, inv_v3))) {
  ------------------
  |  Branch (34622:8): [True: 0, False: 487]
  ------------------
34623|    376|    func3 = &wuffs_private_impl__swizzle_ycc__general__triangle_filter;
34624|    376|    func4 = &wuffs_private_impl__swizzle_ycck__general__triangle_filter;
34625|       |
34626|    376|    upfuncs[0][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle;
34627|    376|    upfuncs[1][0] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle;
34628|    376|    upfuncs[1][1] =
34629|    376|        (ycc_upsampling == 1)
  ------------------
  |  Branch (34629:9): [True: 376, False: 0]
  ------------------
34630|    376|            ? wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg
34631|    376|            : wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libwebp;
34632|       |
34633|    376|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
34634|       |#if defined(__GNUC__) && !defined(__clang__)
34635|       |    // Don't use our AVX2 implementation for GCC (but do use it for clang). For
34636|       |    // some unknown reason, GCC performs noticably better on the non-SIMD
34637|       |    // version. Possibly because GCC's auto-vectorizer is smarter (just with
34638|       |    // SSE2, not AVX2) than our hand-written code, but that's just a guess.
34639|       |    //
34640|       |    // See commits 51bc60ef9298cb2efc1b29a9681191f66d49820d and
34641|       |    // cd769a0cdf1b5affee13f6089b995f3d39569cb4 for benchmark numbers.
34642|       |    //
34643|       |    // See also https://godbolt.org/z/MbhbPGEz4 for Debian Bullseye's clang 11
34644|       |    // versus gcc 10, where only gcc auto-vectorizes, although later clang
34645|       |    // versions will also auto-vectorize.
34646|       |#else
34647|    376|    if (wuffs_base__cpu_arch__have_x86_avx2()) {
  ------------------
  |  Branch (34647:9): [True: 376, False: 0]
  ------------------
34648|    376|      upfuncs[1][1] =
34649|    376|          (ycc_upsampling == 1)
  ------------------
  |  Branch (34649:11): [True: 376, False: 0]
  ------------------
34650|    376|              ? wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg_x86_avx2
34651|    376|              : wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libwebp_x86_avx2;
34652|    376|    }
34653|    376|#endif
34654|    376|#endif
34655|    376|  }
34656|       |
34657|  1.70k|  if ((h3 != 0u) || (v3 != 0u)) {
  ------------------
  |  Branch (34657:7): [True: 0, False: 1.70k]
  |  Branch (34657:21): [True: 0, False: 1.70k]
  ------------------
34658|      0|    wuffs_private_impl__swizzle_ycc__convert_4_func conv4func = NULL;
34659|      0|    switch (ycc_model) {
34660|      0|      case WUFFS_BASE__YCC_MODEL__BT_601_FULL_RANGE:
  ------------------
  |  | 5253|      0|#define WUFFS_BASE__YCC_MODEL__BT_601_FULL_RANGE                     0x00
  ------------------
  |  Branch (34660:7): [True: 0, False: 0]
  ------------------
34661|      0|        conv4func = &wuffs_private_impl__swizzle_ycck__convert_4_general;
34662|      0|        break;
34663|      0|      case WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC:
  ------------------
  |  | 5255|      0|#define WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC       0x06
  ------------------
  |  Branch (34663:7): [True: 0, False: 0]
  ------------------
34664|      0|        if (dst->pixcfg.private_impl.pixfmt.repr ==
  ------------------
  |  Branch (34664:13): [True: 0, False: 0]
  ------------------
34665|      0|            WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL) {
  ------------------
  |  | 4966|      0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
34666|      0|          conv4func =
34667|      0|              &wuffs_private_impl__swizzle_ycca_bt601sr_src__convert_4_bgra_premul;
34668|      0|        } else {
34669|      0|          conv4func =
34670|      0|              &wuffs_private_impl__swizzle_ycca_bt601sr_src__convert_4_general;
34671|      0|        }
34672|      0|        break;
34673|      0|      case WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC_OVER:
  ------------------
  |  | 5256|      0|#define WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC_OVER  0x07
  ------------------
  |  Branch (34673:7): [True: 0, False: 0]
  ------------------
34674|      0|        if (dst->pixcfg.private_impl.pixfmt.repr ==
  ------------------
  |  Branch (34674:13): [True: 0, False: 0]
  ------------------
34675|      0|            WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL) {
  ------------------
  |  | 4966|      0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
34676|      0|          conv4func =
34677|      0|              &wuffs_private_impl__swizzle_ycca_bt601sr_src_over__convert_4_bgra_premul;
34678|      0|        } else {
34679|      0|          conv4func =
34680|      0|              &wuffs_private_impl__swizzle_ycca_bt601sr_src_over__convert_4_general;
34681|      0|        }
34682|      0|        break;
34683|      0|      case WUFFS_BASE__YCC_MODEL__CMY:
  ------------------
  |  | 5258|      0|#define WUFFS_BASE__YCC_MODEL__CMY                                   0x80
  ------------------
  |  Branch (34683:7): [True: 0, False: 0]
  ------------------
34684|      0|        conv4func = &wuffs_private_impl__swizzle_cmyk__convert_4_general;
34685|      0|        break;
34686|      0|      default:
  ------------------
  |  Branch (34686:7): [True: 0, False: 0]
  ------------------
34687|      0|        return wuffs_base__make_status(
34688|      0|            wuffs_base__error__unsupported_pixel_swizzler_option);
34689|      0|    }
34690|       |
34691|      0|    (*func4)(                                                 //
34692|      0|        dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl,  //
34693|      0|        src0.ptr, src1.ptr, src2.ptr, src3.ptr,               //
34694|      0|        stride0, stride1, stride2, stride3,                   //
34695|      0|        inv_h0, inv_h1, inv_h2, inv_h3,                       //
34696|      0|        inv_v0, inv_v1, inv_v2, inv_v3,                       //
34697|      0|        half_width_for_2to1, half_height_for_2to1,            //
34698|      0|        scratch_buffer_2k.ptr, &upfuncs, conv4func);
34699|       |
34700|  1.70k|  } else {
34701|  1.70k|    (*func3)(                                                 //
34702|  1.70k|        dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl,  //
34703|  1.70k|        src0.ptr, src1.ptr, src2.ptr,                         //
34704|  1.70k|        stride0, stride1, stride2,                            //
34705|  1.70k|        inv_h0, inv_h1, inv_h2,                               //
34706|  1.70k|        inv_v0, inv_v1, inv_v2,                               //
34707|  1.70k|        half_width_for_2to1, half_height_for_2to1,            //
34708|  1.70k|        scratch_buffer_2k.ptr, &upfuncs, conv3func);
34709|  1.70k|  }
34710|       |
34711|  1.70k|  return wuffs_base__make_status(NULL);
34712|  1.70k|}
pixel_swizzler_fuzzer.c:wuffs_base__make_status:
  624|   520k|wuffs_base__make_status(const char* repr) {
  625|   520k|  wuffs_base__status z;
  626|   520k|  z.repr = repr;
  627|   520k|  return z;
  628|   520k|}
pixel_swizzler_fuzzer.c:wuffs_base__u32__min:
 1057|  32.0k|wuffs_base__u32__min(uint32_t x, uint32_t y) {
 1058|  32.0k|  return x < y ? x : y;
  ------------------
  |  Branch (1058:10): [True: 17.0k, False: 14.9k]
  ------------------
 1059|  32.0k|}
pixel_swizzler_fuzzer.c:wuffs_base__make_slice_u8:
 1721|   108k|wuffs_base__make_slice_u8(uint8_t* ptr, size_t len) {
 1722|   108k|  wuffs_base__slice_u8 ret;
 1723|   108k|  ret.ptr = ptr;
 1724|   108k|  ret.len = len;
 1725|   108k|  return ret;
 1726|   108k|}
pixel_swizzler_fuzzer.c:wuffs_base__peek_u32le__no_bounds_check:
 1441|  58.0k|wuffs_base__peek_u32le__no_bounds_check(const uint8_t* p) {
 1442|       |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE)
 1443|       |  uint32_t x;
 1444|       |  memcpy(&x, p, 4);
 1445|       |  return x;
 1446|       |#else
 1447|  58.0k|  return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |
 1448|  58.0k|         ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);
 1449|  58.0k|#endif
 1450|  58.0k|}
pixel_swizzler_fuzzer.c:wuffs_base__peek_u24le__no_bounds_check:
 1423|  1.24k|wuffs_base__peek_u24le__no_bounds_check(const uint8_t* p) {
 1424|  1.24k|  return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |
 1425|  1.24k|         ((uint32_t)(p[2]) << 16);
 1426|  1.24k|}
pixel_swizzler_fuzzer.c:wuffs_base__peek_u16le__no_bounds_check:
 1406|  9.69k|wuffs_base__peek_u16le__no_bounds_check(const uint8_t* p) {
 1407|       |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE)
 1408|       |  uint16_t x;
 1409|       |  memcpy(&x, p, 2);
 1410|       |  return x;
 1411|       |#else
 1412|  9.69k|  return (uint16_t)(((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8));
 1413|  9.69k|#endif
 1414|  9.69k|}
pixel_swizzler_fuzzer.c:wuffs_base__peek_u24be__no_bounds_check:
 1417|    647|wuffs_base__peek_u24be__no_bounds_check(const uint8_t* p) {
 1418|    647|  return ((uint32_t)(p[0]) << 16) | ((uint32_t)(p[1]) << 8) |
 1419|    647|         ((uint32_t)(p[2]) << 0);
 1420|    647|}
pixel_swizzler_fuzzer.c:wuffs_base__peek_u16be__no_bounds_check:
 1395|     46|wuffs_base__peek_u16be__no_bounds_check(const uint8_t* p) {
 1396|       |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE)
 1397|       |  uint16_t x;
 1398|       |  memcpy(&x, p, 2);
 1399|       |  return _byteswap_ushort(x);
 1400|       |#else
 1401|     46|  return (uint16_t)(((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0));
 1402|     46|#endif
 1403|     46|}
pixel_swizzler_fuzzer.c:wuffs_base__pixel_format__is_planar:
 5031|   518k|wuffs_base__pixel_format__is_planar(const wuffs_base__pixel_format* f) {
 5032|   518k|  return ((f->repr >> 16) & 0x03) != 0;
 5033|   518k|}
pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul:
 4485|  14.2k|    uint32_t argb_nonpremul) {
 4486|       |  // Multiplying by 0x101 (twice, once for alpha and once for color) converts
 4487|       |  // from 8-bit to 16-bit color. Shifting right by 8 undoes that.
 4488|       |  //
 4489|       |  // Working in the higher bit depth can produce slightly different (and
 4490|       |  // arguably slightly more accurate) results. For example, given 8-bit blue
 4491|       |  // and alpha of 0x80 and 0x81:
 4492|       |  //
 4493|       |  //  - ((0x80   * 0x81  ) / 0xFF  )      = 0x40        = 0x40
 4494|       |  //  - ((0x8080 * 0x8181) / 0xFFFF) >> 8 = 0x4101 >> 8 = 0x41
 4495|  14.2k|  uint32_t a = 0xFF & (argb_nonpremul >> 24);
 4496|  14.2k|  uint32_t a16 = a * (0x101 * 0x101);
 4497|       |
 4498|  14.2k|  uint32_t r = 0xFF & (argb_nonpremul >> 16);
 4499|  14.2k|  r = ((r * a16) / 0xFFFF) >> 8;
 4500|  14.2k|  uint32_t g = 0xFF & (argb_nonpremul >> 8);
 4501|  14.2k|  g = ((g * a16) / 0xFFFF) >> 8;
 4502|  14.2k|  uint32_t b = 0xFF & (argb_nonpremul >> 0);
 4503|  14.2k|  b = ((b * a16) / 0xFFFF) >> 8;
 4504|       |
 4505|  14.2k|  return (a << 24) | (r << 16) | (g << 8) | (b << 0);
 4506|  14.2k|}
pixel_swizzler_fuzzer.c:wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul:
 4417|  2.80k|wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(uint16_t rgb_565) {
 4418|  2.80k|  uint32_t b5 = 0x1F & (rgb_565 >> 0);
 4419|  2.80k|  uint32_t b = (b5 << 3) | (b5 >> 2);
 4420|  2.80k|  uint32_t g6 = 0x3F & (rgb_565 >> 5);
 4421|  2.80k|  uint32_t g = (g6 << 2) | (g6 >> 4);
 4422|  2.80k|  uint32_t r5 = 0x1F & (rgb_565 >> 11);
 4423|  2.80k|  uint32_t r = (r5 << 3) | (r5 >> 2);
 4424|  2.80k|  return 0xFF000000 | (r << 16) | (g << 8) | (b << 0);
 4425|  2.80k|}
pixel_swizzler_fuzzer.c:wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul:
 4535|    672|    uint64_t argb_nonpremul) {
 4536|    672|  uint32_t a16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 48)));
 4537|       |
 4538|    672|  uint32_t r16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 32)));
 4539|    672|  r16 = (r16 * a16) / 0xFFFF;
 4540|    672|  uint32_t g16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 16)));
 4541|    672|  g16 = (g16 * a16) / 0xFFFF;
 4542|    672|  uint32_t b16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 0)));
 4543|    672|  b16 = (b16 * a16) / 0xFFFF;
 4544|       |
 4545|    672|  return ((a16 >> 8) << 24) | ((r16 >> 8) << 16) | ((g16 >> 8) << 8) |
 4546|    672|         ((b16 >> 8) << 0);
 4547|    672|}
pixel_swizzler_fuzzer.c:wuffs_base__peek_u64le__no_bounds_check:
 1511|  6.54k|wuffs_base__peek_u64le__no_bounds_check(const uint8_t* p) {
 1512|       |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE)
 1513|       |  uint64_t x;
 1514|       |  memcpy(&x, p, 8);
 1515|       |  return x;
 1516|       |#else
 1517|  6.54k|  return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |
 1518|  6.54k|         ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |
 1519|  6.54k|         ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) |
 1520|  6.54k|         ((uint64_t)(p[6]) << 48) | ((uint64_t)(p[7]) << 56);
 1521|  6.54k|#endif
 1522|  6.54k|}
pixel_swizzler_fuzzer.c:wuffs_base__color_u64__as__color_u32:
 4660|  2.72k|wuffs_base__color_u64__as__color_u32(uint64_t c) {
 4661|  2.72k|  uint32_t a = ((uint32_t)(0xFF & (c >> 56)));
 4662|  2.72k|  uint32_t r = ((uint32_t)(0xFF & (c >> 40)));
 4663|  2.72k|  uint32_t g = ((uint32_t)(0xFF & (c >> 24)));
 4664|  2.72k|  uint32_t b = ((uint32_t)(0xFF & (c >> 8)));
 4665|  2.72k|  return (a << 24) | (r << 16) | (g << 8) | (b << 0);
 4666|  2.72k|}
pixel_swizzler_fuzzer.c:wuffs_base__color_swap_u32_argb_abgr:
 4829|   100k|wuffs_base__color_swap_u32_argb_abgr(uint32_t u) {
 4830|   100k|  uint32_t o = u & 0xFF00FF00ul;
 4831|   100k|  uint32_t r = u & 0x00FF0000ul;
 4832|   100k|  uint32_t b = u & 0x000000FFul;
 4833|   100k|  return o | (r >> 16) | (b << 16);
 4834|   100k|}
pixel_swizzler_fuzzer.c:wuffs_base__poke_u32le__no_bounds_check:
 1578|   252k|wuffs_base__poke_u32le__no_bounds_check(uint8_t* p, uint32_t x) {
 1579|       |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) || \
 1580|       |    (defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__))
 1581|       |  // This seems to perform better on gcc 10 (but not clang 9). Clang also
 1582|       |  // defines "__GNUC__".
 1583|       |  memcpy(p, &x, 4);
 1584|       |#else
 1585|   252k|  p[0] = (uint8_t)(x >> 0);
 1586|   252k|  p[1] = (uint8_t)(x >> 8);
 1587|   252k|  p[2] = (uint8_t)(x >> 16);
 1588|   252k|  p[3] = (uint8_t)(x >> 24);
 1589|   252k|#endif
 1590|   252k|}
pixel_swizzler_fuzzer.c:wuffs_base__poke_u8__no_bounds_check:
 1532|   137k|wuffs_base__poke_u8__no_bounds_check(uint8_t* p, uint8_t x) {
 1533|   137k|  p[0] = x;
 1534|   137k|}
pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u8_gray:
 4429|  84.9k|    wuffs_base__color_u32_argb_premul c) {
 4430|       |  // Work in 16-bit color.
 4431|  84.9k|  uint32_t cr = 0x101 * (0xFF & (c >> 16));
 4432|  84.9k|  uint32_t cg = 0x101 * (0xFF & (c >> 8));
 4433|  84.9k|  uint32_t cb = 0x101 * (0xFF & (c >> 0));
 4434|       |
 4435|       |  // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same
 4436|       |  // as those given by the JFIF specification.
 4437|       |  //
 4438|       |  // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We
 4439|       |  // shift by 24, not just by 16, because the return value is 8-bit color, not
 4440|       |  // 16-bit color.
 4441|  84.9k|  uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768;
 4442|  84.9k|  return (uint8_t)(weighted_average >> 24);
 4443|  84.9k|}
pixel_swizzler_fuzzer.c:wuffs_base__poke_u16le__no_bounds_check:
 1543|   103k|wuffs_base__poke_u16le__no_bounds_check(uint8_t* p, uint16_t x) {
 1544|       |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) || \
 1545|       |    (defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__))
 1546|       |  // This seems to perform better on gcc 10 (but not clang 9). Clang also
 1547|       |  // defines "__GNUC__".
 1548|       |  memcpy(p, &x, 2);
 1549|       |#else
 1550|   103k|  p[0] = (uint8_t)(x >> 0);
 1551|   103k|  p[1] = (uint8_t)(x >> 8);
 1552|   103k|#endif
 1553|   103k|}
pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u16_gray:
 4467|  24.1k|    wuffs_base__color_u32_argb_premul c) {
 4468|       |  // Work in 16-bit color.
 4469|  24.1k|  uint32_t cr = 0x101 * (0xFF & (c >> 16));
 4470|  24.1k|  uint32_t cg = 0x101 * (0xFF & (c >> 8));
 4471|  24.1k|  uint32_t cb = 0x101 * (0xFF & (c >> 0));
 4472|       |
 4473|       |  // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same
 4474|       |  // as those given by the JFIF specification.
 4475|       |  //
 4476|       |  // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16).
 4477|  24.1k|  uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768;
 4478|  24.1k|  return (uint16_t)(weighted_average >> 16);
 4479|  24.1k|}
pixel_swizzler_fuzzer.c:wuffs_base__poke_u16be__no_bounds_check:
 1537|  12.0k|wuffs_base__poke_u16be__no_bounds_check(uint8_t* p, uint16_t x) {
 1538|  12.0k|  p[0] = (uint8_t)(x >> 8);
 1539|  12.0k|  p[1] = (uint8_t)(x >> 0);
 1540|  12.0k|}
pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u16_alpha_gray_nonpremul:
 4447|  23.6k|    wuffs_base__color_u32_argb_premul c) {
 4448|  23.6k|  uint32_t a = 0xFF & (c >> 24);
 4449|  23.6k|  if (a == 0) {
  ------------------
  |  Branch (4449:7): [True: 0, False: 23.6k]
  ------------------
 4450|      0|    return 0;
 4451|      0|  }
 4452|  23.6k|  uint32_t a16 = a * 0x101;
 4453|       |
 4454|  23.6k|  uint32_t cr = 0xFF & (c >> 16);
 4455|  23.6k|  cr = (cr * (0x101 * 0xFFFF)) / a16;
 4456|  23.6k|  uint32_t cg = 0xFF & (c >> 8);
 4457|  23.6k|  cg = (cg * (0x101 * 0xFFFF)) / a16;
 4458|  23.6k|  uint32_t cb = 0xFF & (c >> 0);
 4459|  23.6k|  cb = (cb * (0x101 * 0xFFFF)) / a16;
 4460|       |
 4461|  23.6k|  uint32_t weighted_average = (19595 * cr) + (38470 * cg) + (7471 * cb) + 32768;
 4462|  23.6k|  return (uint16_t)((a16 & 0xFF00) | (weighted_average >> 24));
 4463|  23.6k|}
pixel_swizzler_fuzzer.c:wuffs_base__pixel_buffer__palette:
 6048|  72.9k|wuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* pb) {
 6049|  72.9k|  if (pb &&
  ------------------
  |  Branch (6049:7): [True: 72.9k, False: 0]
  ------------------
 6050|  72.9k|      wuffs_base__pixel_format__is_indexed(&pb->pixcfg.private_impl.pixfmt)) {
  ------------------
  |  Branch (6050:7): [True: 72.9k, False: 0]
  ------------------
 6051|  72.9k|    wuffs_base__table_u8* tab =
 6052|  72.9k|        &pb->private_impl
 6053|  72.9k|             .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];
  ------------------
  |  | 4897|  72.9k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE 3
  ------------------
 6054|  72.9k|    if ((tab->width ==
  ------------------
  |  Branch (6054:9): [True: 72.9k, False: 0]
  ------------------
 6055|  72.9k|         WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) &&
  ------------------
  |  | 4900|  72.9k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
 6056|  72.9k|        (tab->height == 1)) {
  ------------------
  |  Branch (6056:9): [True: 72.9k, False: 0]
  ------------------
 6057|  72.9k|      return wuffs_base__make_slice_u8(
 6058|  72.9k|          tab->ptr, WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH);
  ------------------
  |  | 4900|  72.9k|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
 6059|  72.9k|    }
 6060|  72.9k|  }
 6061|      0|  return wuffs_base__empty_slice_u8();
 6062|  72.9k|}
pixel_swizzler_fuzzer.c:wuffs_base__pixel_format__is_indexed:
 5021|  79.9k|wuffs_base__pixel_format__is_indexed(const wuffs_base__pixel_format* f) {
 5022|  79.9k|  return ((f->repr >> 18) & 0x01) != 0;
 5023|  79.9k|}
pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565:
 4409|  60.1k|    wuffs_base__color_u32_argb_premul c) {
 4410|  60.1k|  uint32_t r5 = 0xF800 & (c >> 8);
 4411|  60.1k|  uint32_t g6 = 0x07E0 & (c >> 5);
 4412|  60.1k|  uint32_t b5 = 0x001F & (c >> 3);
 4413|  60.1k|  return (uint16_t)(r5 | g6 | b5);
 4414|  60.1k|}
pixel_swizzler_fuzzer.c:wuffs_base__poke_u24le__no_bounds_check:
 1563|   117k|wuffs_base__poke_u24le__no_bounds_check(uint8_t* p, uint32_t x) {
 1564|   117k|  p[0] = (uint8_t)(x >> 0);
 1565|   117k|  p[1] = (uint8_t)(x >> 8);
 1566|   117k|  p[2] = (uint8_t)(x >> 16);
 1567|   117k|}
pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul:
 4512|  50.2k|    wuffs_base__color_u32_argb_premul c) {
 4513|  50.2k|  uint32_t a = 0xFF & (c >> 24);
 4514|  50.2k|  if (a == 0xFF) {
  ------------------
  |  Branch (4514:7): [True: 49.1k, False: 1.03k]
  ------------------
 4515|  49.1k|    return c;
 4516|  49.1k|  } else if (a == 0) {
  ------------------
  |  Branch (4516:14): [True: 289, False: 749]
  ------------------
 4517|    289|    return 0;
 4518|    289|  }
 4519|    749|  uint32_t a16 = a * 0x101;
 4520|       |
 4521|    749|  uint32_t r = 0xFF & (c >> 16);
 4522|    749|  r = ((r * (0x101 * 0xFFFF)) / a16) >> 8;
 4523|    749|  uint32_t g = 0xFF & (c >> 8);
 4524|    749|  g = ((g * (0x101 * 0xFFFF)) / a16) >> 8;
 4525|    749|  uint32_t b = 0xFF & (c >> 0);
 4526|    749|  b = ((b * (0x101 * 0xFFFF)) / a16) >> 8;
 4527|       |
 4528|    749|  return (a << 24) | (r << 16) | (g << 8) | (b << 0);
 4529|  50.2k|}
pixel_swizzler_fuzzer.c:wuffs_base__poke_u64le__no_bounds_check:
 1665|  73.9k|wuffs_base__poke_u64le__no_bounds_check(uint8_t* p, uint64_t x) {
 1666|       |#if defined(WUFFS_BASE__USE_MEMCPY_LE_PEEK_POKE) || \
 1667|       |    (defined(__GNUC__) && !defined(__clang__) && defined(__x86_64__))
 1668|       |  // This seems to perform better on gcc 10 (but not clang 9). Clang also
 1669|       |  // defines "__GNUC__".
 1670|       |  memcpy(p, &x, 8);
 1671|       |#else
 1672|  73.9k|  p[0] = (uint8_t)(x >> 0);
 1673|  73.9k|  p[1] = (uint8_t)(x >> 8);
 1674|  73.9k|  p[2] = (uint8_t)(x >> 16);
 1675|  73.9k|  p[3] = (uint8_t)(x >> 24);
 1676|  73.9k|  p[4] = (uint8_t)(x >> 32);
 1677|  73.9k|  p[5] = (uint8_t)(x >> 40);
 1678|  73.9k|  p[6] = (uint8_t)(x >> 48);
 1679|  73.9k|  p[7] = (uint8_t)(x >> 56);
 1680|  73.9k|#endif
 1681|  73.9k|}
pixel_swizzler_fuzzer.c:wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul:
 4553|  70.3k|    wuffs_base__color_u32_argb_premul c) {
 4554|  70.3k|  uint32_t a = 0xFF & (c >> 24);
 4555|  70.3k|  if (a == 0xFF) {
  ------------------
  |  Branch (4555:7): [True: 70.3k, False: 0]
  ------------------
 4556|  70.3k|    uint64_t r16 = 0x101 * (0xFF & (c >> 16));
 4557|  70.3k|    uint64_t g16 = 0x101 * (0xFF & (c >> 8));
 4558|  70.3k|    uint64_t b16 = 0x101 * (0xFF & (c >> 0));
 4559|  70.3k|    return 0xFFFF000000000000u | (r16 << 32) | (g16 << 16) | (b16 << 0);
 4560|  70.3k|  } else if (a == 0) {
  ------------------
  |  Branch (4560:14): [True: 0, False: 0]
  ------------------
 4561|      0|    return 0;
 4562|      0|  }
 4563|      0|  uint64_t a16 = a * 0x101;
 4564|       |
 4565|      0|  uint64_t r = 0xFF & (c >> 16);
 4566|      0|  uint64_t r16 = (r * (0x101 * 0xFFFF)) / a16;
 4567|      0|  uint64_t g = 0xFF & (c >> 8);
 4568|      0|  uint64_t g16 = (g * (0x101 * 0xFFFF)) / a16;
 4569|      0|  uint64_t b = 0xFF & (c >> 0);
 4570|      0|  uint64_t b16 = (b * (0x101 * 0xFFFF)) / a16;
 4571|       |
 4572|      0|  return (a16 << 48) | (r16 << 32) | (g16 << 16) | (b16 << 0);
 4573|  70.3k|}
pixel_swizzler_fuzzer.c:wuffs_base__color_u32__as__color_u64:
 4651|  3.54k|wuffs_base__color_u32__as__color_u64(uint32_t c) {
 4652|  3.54k|  uint64_t a16 = 0x101 * (0xFF & (c >> 24));
 4653|  3.54k|  uint64_t r16 = 0x101 * (0xFF & (c >> 16));
 4654|  3.54k|  uint64_t g16 = 0x101 * (0xFF & (c >> 8));
 4655|  3.54k|  uint64_t b16 = 0x101 * (0xFF & (c >> 0));
 4656|  3.54k|  return (a16 << 48) | (r16 << 32) | (g16 << 16) | (b16 << 0);
 4657|  3.54k|}
pixel_swizzler_fuzzer.c:wuffs_base__pixel_format__bits_per_pixel:
 4994|  14.0k|wuffs_base__pixel_format__bits_per_pixel(const wuffs_base__pixel_format* f) {
 4995|  14.0k|  if (((f->repr >> 16) & 0x03) != 0) {
  ------------------
  |  Branch (4995:7): [True: 0, False: 14.0k]
  ------------------
 4996|      0|    return 0;
 4997|      0|  }
 4998|  14.0k|  return wuffs_private_impl__pixel_format__bits_per_channel[0x0F &
 4999|  14.0k|                                                            (f->repr >> 0)] +
 5000|  14.0k|         wuffs_private_impl__pixel_format__bits_per_channel[0x0F &
 5001|  14.0k|                                                            (f->repr >> 4)] +
 5002|  14.0k|         wuffs_private_impl__pixel_format__bits_per_channel[0x0F &
 5003|  14.0k|                                                            (f->repr >> 8)] +
 5004|  14.0k|         wuffs_private_impl__pixel_format__bits_per_channel[0x0F &
 5005|  14.0k|                                                            (f->repr >> 12)];
 5006|  14.0k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__y:
31166|    133|    wuffs_base__pixel_blend blend) {
31167|    133|  switch (dst_pixfmt.repr) {
  ------------------
  |  Branch (31167:11): [True: 122, False: 11]
  ------------------
31168|     16|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|     16|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (31168:5): [True: 16, False: 117]
  ------------------
31169|     16|      return wuffs_private_impl__swizzle_copy_1_1;
31170|       |
31171|     15|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|     15|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (31171:5): [True: 15, False: 118]
  ------------------
31172|     15|      return wuffs_private_impl__swizzle_bgr_565__y;
31173|       |
31174|     15|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|     15|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (31174:5): [True: 15, False: 118]
  ------------------
31175|     22|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|     22|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (31175:5): [True: 7, False: 126]
  ------------------
31176|     22|      return wuffs_private_impl__swizzle_xxx__y;
31177|       |
31178|     10|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|     10|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (31178:5): [True: 10, False: 123]
  ------------------
31179|     14|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|     14|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (31179:5): [True: 4, False: 129]
  ------------------
31180|     14|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
  ------------------
  |  | 4968|     14|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY               0x83008888
  ------------------
  |  Branch (31180:5): [True: 0, False: 133]
  ------------------
31181|     24|    case WUFFS_BASE__PIXEL_FORMAT__BGRX:
  ------------------
  |  | 4969|     24|#define WUFFS_BASE__PIXEL_FORMAT__BGRX                      0x90008888
  ------------------
  |  Branch (31181:5): [True: 10, False: 123]
  ------------------
31182|     36|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|     36|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (31182:5): [True: 12, False: 121]
  ------------------
31183|     46|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|     46|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (31183:5): [True: 10, False: 123]
  ------------------
31184|     46|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
  ------------------
  |  | 4976|     46|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY               0xA3008888
  ------------------
  |  Branch (31184:5): [True: 0, False: 133]
  ------------------
31185|     46|    case WUFFS_BASE__PIXEL_FORMAT__RGBX:
  ------------------
  |  | 4977|     46|#define WUFFS_BASE__PIXEL_FORMAT__RGBX                      0xB0008888
  ------------------
  |  Branch (31185:5): [True: 0, False: 133]
  ------------------
31186|     46|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
31187|     46|      if (wuffs_base__cpu_arch__have_x86_sse42()) {
  ------------------
  |  Branch (31187:11): [True: 46, False: 0]
  ------------------
31188|     46|        return wuffs_private_impl__swizzle_xxxx__y__x86_sse42;
31189|     46|      }
31190|      0|#endif
31191|      0|      return wuffs_private_impl__swizzle_xxxx__y;
31192|       |
31193|     19|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|     19|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (31193:5): [True: 19, False: 114]
  ------------------
31194|     23|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:
  ------------------
  |  | 4967|     23|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE        0x8200BBBB
  ------------------
  |  Branch (31194:5): [True: 4, False: 129]
  ------------------
31195|     23|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE:
  ------------------
  |  | 4973|     23|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE     0xA100BBBB
  ------------------
  |  Branch (31195:5): [True: 0, False: 133]
  ------------------
31196|     23|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE:
  ------------------
  |  | 4975|     23|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE        0xA200BBBB
  ------------------
  |  Branch (31196:5): [True: 0, False: 133]
  ------------------
31197|     23|      return wuffs_private_impl__swizzle_xxxxxxxx__y;
31198|    133|  }
31199|     11|  return NULL;
31200|    133|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_1_1:
25929|     37|                                     size_t src_len) {
25930|     37|  size_t len = (dst_len < src_len) ? dst_len : src_len;
  ------------------
  |  Branch (25930:16): [True: 20, False: 17]
  ------------------
25931|     37|  if (len > 0) {
  ------------------
  |  Branch (25931:7): [True: 18, False: 19]
  ------------------
25932|     18|    memmove(dst_ptr, src_ptr, len);
25933|     18|  }
25934|     37|  return len;
25935|     37|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__y:
26627|     15|                                       size_t src_len) {
26628|     15|  size_t dst_len2 = dst_len / 2;
26629|     15|  size_t len = (dst_len2 < src_len) ? dst_len2 : src_len;
  ------------------
  |  Branch (26629:16): [True: 7, False: 8]
  ------------------
26630|     15|  uint8_t* d = dst_ptr;
26631|     15|  const uint8_t* s = src_ptr;
26632|     15|  size_t n = len;
26633|       |
26634|       |  // TODO: unroll.
26635|       |
26636|    566|  while (n >= 1) {
  ------------------
  |  Branch (26636:10): [True: 551, False: 15]
  ------------------
26637|    551|    uint32_t y5 = (uint32_t)(s[0] >> 3);
26638|    551|    uint32_t y6 = (uint32_t)(s[0] >> 2);
26639|    551|    uint32_t rgb_565 = (y5 << 11) | (y6 << 5) | (y5 << 0);
26640|    551|    wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565);
26641|       |
26642|    551|    s += 1 * 1;
26643|    551|    d += 1 * 2;
26644|    551|    n -= 1;
26645|    551|  }
26646|       |
26647|     15|  return len;
26648|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__y:
29807|     22|                                   size_t src_len) {
29808|     22|  size_t dst_len3 = dst_len / 3;
29809|     22|  size_t len = (dst_len3 < src_len) ? dst_len3 : src_len;
  ------------------
  |  Branch (29809:16): [True: 14, False: 8]
  ------------------
29810|     22|  uint8_t* d = dst_ptr;
29811|     22|  const uint8_t* s = src_ptr;
29812|     22|  size_t n = len;
29813|       |
29814|       |  // TODO: unroll.
29815|       |
29816|    350|  while (n >= 1) {
  ------------------
  |  Branch (29816:10): [True: 328, False: 22]
  ------------------
29817|    328|    uint8_t s0 = s[0];
29818|    328|    d[0] = s0;
29819|    328|    d[1] = s0;
29820|    328|    d[2] = s0;
29821|       |
29822|    328|    s += 1 * 1;
29823|    328|    d += 1 * 3;
29824|    328|    n -= 1;
29825|    328|  }
29826|       |
29827|     22|  return len;
29828|     22|}
pixel_swizzler_fuzzer.c:wuffs_base__cpu_arch__have_x86_sse42:
  375|    155|wuffs_base__cpu_arch__have_x86_sse42(void) {
  376|       |#if defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__)
  377|       |  return true;
  378|       |#else
  379|    155|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
  380|       |  // GCC defines these macros but MSVC does not.
  381|       |  //  - bit_PCLMUL = (1 <<  1)
  382|       |  //  - bit_POPCNT = (1 << 23)
  383|       |  //  - bit_SSE4_2 = (1 << 20)
  384|    155|  const unsigned int sse42_ecx1 = 0x00900002;
  385|       |
  386|       |  // clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__).
  387|    155|#if defined(__GNUC__)
  388|    155|  unsigned int eax1 = 0;
  389|    155|  unsigned int ebx1 = 0;
  390|    155|  unsigned int ecx1 = 0;
  391|    155|  unsigned int edx1 = 0;
  392|    155|  if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) &&
  ------------------
  |  Branch (392:7): [True: 155, False: 0]
  ------------------
  393|    155|      ((ecx1 & sse42_ecx1) == sse42_ecx1)) {
  ------------------
  |  Branch (393:7): [True: 155, False: 0]
  ------------------
  394|    155|    return true;
  395|    155|  }
  396|       |#elif defined(_MSC_VER)  // defined(__GNUC__)
  397|       |  int x1[4];
  398|       |  __cpuid(x1, 1);
  399|       |  if ((((unsigned int)(x1[2])) & sse42_ecx1) == sse42_ecx1) {
  400|       |    return true;
  401|       |  }
  402|       |#else
  403|       |#error "WUFFS_PRIVATE_IMPL__CPU_ARCH__ETC combined with an unsupported compiler"
  404|       |#endif  // defined(__GNUC__); defined(_MSC_VER)
  405|      0|#endif  // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
  406|      0|  return false;
  407|    155|#endif  // defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__)
  408|    155|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__y__x86_sse42:
30077|     46|                                               size_t src_len) {
30078|     46|  size_t dst_len4 = dst_len / 4;
30079|     46|  size_t len = (dst_len4 < src_len) ? dst_len4 : src_len;
  ------------------
  |  Branch (30079:16): [True: 30, False: 16]
  ------------------
30080|     46|  uint8_t* d = dst_ptr;
30081|     46|  const uint8_t* s = src_ptr;
30082|     46|  size_t n = len;
30083|       |
30084|     46|  __m128i shuffle = _mm_set_epi8(+0x03, +0x03, +0x03, +0x03,  //
30085|     46|                                 +0x02, +0x02, +0x02, +0x02,  //
30086|     46|                                 +0x01, +0x01, +0x01, +0x01,  //
30087|     46|                                 +0x00, +0x00, +0x00, +0x00);
30088|     46|  __m128i or_ff = _mm_set_epi8(-0x01, +0x00, +0x00, +0x00,  //
30089|     46|                               -0x01, +0x00, +0x00, +0x00,  //
30090|     46|                               -0x01, +0x00, +0x00, +0x00,  //
30091|     46|                               -0x01, +0x00, +0x00, +0x00);
30092|       |
30093|    214|  while (n >= 4) {
  ------------------
  |  Branch (30093:10): [True: 168, False: 46]
  ------------------
30094|    168|    __m128i x;
30095|    168|    x = _mm_cvtsi32_si128((int)(wuffs_base__peek_u32le__no_bounds_check(s)));
30096|    168|    x = _mm_shuffle_epi8(x, shuffle);
30097|    168|    x = _mm_or_si128(x, or_ff);
30098|    168|    _mm_storeu_si128((__m128i*)(void*)d, x);
30099|       |
30100|    168|    s += 4 * 1;
30101|    168|    d += 4 * 4;
30102|    168|    n -= 4;
30103|    168|  }
30104|       |
30105|     91|  while (n >= 1) {
  ------------------
  |  Branch (30105:10): [True: 45, False: 46]
  ------------------
30106|     45|    wuffs_base__poke_u32le__no_bounds_check(
30107|     45|        d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0]));
30108|       |
30109|     45|    s += 1 * 1;
30110|     45|    d += 1 * 4;
30111|     45|    n -= 1;
30112|     45|  }
30113|       |
30114|     46|  return len;
30115|     46|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__y:
30269|     23|                                        size_t src_len) {
30270|     23|  size_t dst_len8 = dst_len / 8;
30271|     23|  size_t len = (dst_len8 < src_len) ? dst_len8 : src_len;
  ------------------
  |  Branch (30271:16): [True: 17, False: 6]
  ------------------
30272|     23|  uint8_t* d = dst_ptr;
30273|     23|  const uint8_t* s = src_ptr;
30274|     23|  size_t n = len;
30275|       |
30276|    306|  while (n >= 1) {
  ------------------
  |  Branch (30276:10): [True: 283, False: 23]
  ------------------
30277|    283|    wuffs_base__poke_u64le__no_bounds_check(
30278|    283|        d + (0 * 8), 0xFFFF000000000000 | (0x010101010101 * (uint64_t)s[0]));
30279|       |
30280|    283|    s += 1 * 1;
30281|    283|    d += 1 * 8;
30282|    283|    n -= 1;
30283|    283|  }
30284|       |
30285|     23|  return len;
30286|     23|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__y_16be:
31208|    130|    wuffs_base__pixel_blend blend) {
31209|    130|  switch (dst_pixfmt.repr) {
  ------------------
  |  Branch (31209:11): [True: 121, False: 9]
  ------------------
31210|     23|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|     23|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (31210:5): [True: 23, False: 107]
  ------------------
31211|     23|      return wuffs_private_impl__swizzle_y__y_16be;
31212|       |
31213|      5|    case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:
  ------------------
  |  | 4944|      5|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE                    0x2000000B
  ------------------
  |  Branch (31213:5): [True: 5, False: 125]
  ------------------
31214|      5|      return wuffs_private_impl__swizzle_y_16le__y_16be;
31215|       |
31216|      2|    case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:
  ------------------
  |  | 4945|      2|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE                    0x2010000B
  ------------------
  |  Branch (31216:5): [True: 2, False: 128]
  ------------------
31217|      2|      return wuffs_private_impl__swizzle_copy_2_2;
31218|       |
31219|     22|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|     22|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (31219:5): [True: 22, False: 108]
  ------------------
31220|     22|      return wuffs_private_impl__swizzle_bgr_565__y_16be;
31221|       |
31222|      3|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|      3|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (31222:5): [True: 3, False: 127]
  ------------------
31223|     12|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|     12|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (31223:5): [True: 9, False: 121]
  ------------------
31224|     12|      return wuffs_private_impl__swizzle_xxx__y_16be;
31225|       |
31226|     10|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|     10|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (31226:5): [True: 10, False: 120]
  ------------------
31227|     20|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|     20|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (31227:5): [True: 10, False: 120]
  ------------------
31228|     20|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
  ------------------
  |  | 4968|     20|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY               0x83008888
  ------------------
  |  Branch (31228:5): [True: 0, False: 130]
  ------------------
31229|     31|    case WUFFS_BASE__PIXEL_FORMAT__BGRX:
  ------------------
  |  | 4969|     31|#define WUFFS_BASE__PIXEL_FORMAT__BGRX                      0x90008888
  ------------------
  |  Branch (31229:5): [True: 11, False: 119]
  ------------------
31230|     43|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|     43|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (31230:5): [True: 12, False: 118]
  ------------------
31231|     48|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|     48|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (31231:5): [True: 5, False: 125]
  ------------------
31232|     48|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
  ------------------
  |  | 4976|     48|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY               0xA3008888
  ------------------
  |  Branch (31232:5): [True: 0, False: 130]
  ------------------
31233|     48|    case WUFFS_BASE__PIXEL_FORMAT__RGBX:
  ------------------
  |  | 4977|     48|#define WUFFS_BASE__PIXEL_FORMAT__RGBX                      0xB0008888
  ------------------
  |  Branch (31233:5): [True: 0, False: 130]
  ------------------
31234|     48|      return wuffs_private_impl__swizzle_xxxx__y_16be;
31235|       |
31236|      3|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|      3|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (31236:5): [True: 3, False: 127]
  ------------------
31237|      9|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:
  ------------------
  |  | 4967|      9|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE        0x8200BBBB
  ------------------
  |  Branch (31237:5): [True: 6, False: 124]
  ------------------
31238|      9|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE:
  ------------------
  |  | 4973|      9|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE     0xA100BBBB
  ------------------
  |  Branch (31238:5): [True: 0, False: 130]
  ------------------
31239|      9|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE:
  ------------------
  |  | 4975|      9|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE        0xA200BBBB
  ------------------
  |  Branch (31239:5): [True: 0, False: 130]
  ------------------
31240|      9|      return wuffs_private_impl__swizzle_xxxxxxxx__y_16be;
31241|    130|  }
31242|      9|  return NULL;
31243|    130|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__y_16be:
30863|     23|                                      size_t src_len) {
30864|     23|  size_t src_len2 = src_len / 2;
30865|     23|  size_t len = (dst_len < src_len2) ? dst_len : src_len2;
  ------------------
  |  Branch (30865:16): [True: 5, False: 18]
  ------------------
30866|     23|  uint8_t* d = dst_ptr;
30867|     23|  const uint8_t* s = src_ptr;
30868|     23|  size_t n = len;
30869|       |
30870|       |  // TODO: unroll.
30871|       |
30872|    958|  while (n >= 1) {
  ------------------
  |  Branch (30872:10): [True: 935, False: 23]
  ------------------
30873|    935|    d[0] = s[0];
30874|       |
30875|    935|    s += 1 * 2;
30876|    935|    d += 1 * 1;
30877|    935|    n -= 1;
30878|    935|  }
30879|       |
30880|     23|  return len;
30881|     23|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y_16le__y_16be:
31071|     24|                                           size_t src_len) {
31072|     24|  size_t dst_len2 = dst_len / 2;
31073|     24|  size_t src_len2 = src_len / 2;
31074|     24|  size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2;
  ------------------
  |  Branch (31074:16): [True: 5, False: 19]
  ------------------
31075|     24|  uint8_t* d = dst_ptr;
31076|     24|  const uint8_t* s = src_ptr;
31077|     24|  size_t n = len;
31078|       |
31079|    859|  while (n >= 1) {
  ------------------
  |  Branch (31079:10): [True: 835, False: 24]
  ------------------
31080|    835|    uint8_t s0 = s[0];
31081|    835|    uint8_t s1 = s[1];
31082|    835|    d[0] = s1;
31083|    835|    d[1] = s0;
31084|       |
31085|    835|    s += 1 * 2;
31086|    835|    d += 1 * 2;
31087|    835|    n -= 1;
31088|    835|  }
31089|       |
31090|     24|  return len;
31091|     24|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_2_2:
25943|     19|                                     size_t src_len) {
25944|     19|  size_t dst_len2 = dst_len / 2;
25945|     19|  size_t src_len2 = src_len / 2;
25946|     19|  size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2;
  ------------------
  |  Branch (25946:16): [True: 2, False: 17]
  ------------------
25947|     19|  if (len > 0) {
  ------------------
  |  Branch (25947:7): [True: 14, False: 5]
  ------------------
25948|     14|    memmove(dst_ptr, src_ptr, len * 2);
25949|     14|  }
25950|     19|  return len;
25951|     19|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__y_16be:
26656|     22|                                            size_t src_len) {
26657|     22|  size_t dst_len2 = dst_len / 2;
26658|     22|  size_t src_len2 = src_len / 2;
26659|     22|  size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2;
  ------------------
  |  Branch (26659:16): [True: 6, False: 16]
  ------------------
26660|     22|  uint8_t* d = dst_ptr;
26661|     22|  const uint8_t* s = src_ptr;
26662|     22|  size_t n = len;
26663|       |
26664|       |  // TODO: unroll.
26665|       |
26666|  1.11k|  while (n >= 1) {
  ------------------
  |  Branch (26666:10): [True: 1.08k, False: 22]
  ------------------
26667|  1.08k|    uint32_t y5 = (uint32_t)(s[0] >> 3);
26668|  1.08k|    uint32_t y6 = (uint32_t)(s[0] >> 2);
26669|  1.08k|    uint32_t rgb_565 = (y5 << 11) | (y6 << 5) | (y5 << 0);
26670|  1.08k|    wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565);
26671|       |
26672|  1.08k|    s += 1 * 2;
26673|  1.08k|    d += 1 * 2;
26674|  1.08k|    n -= 1;
26675|  1.08k|  }
26676|       |
26677|     22|  return len;
26678|     22|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__y_16be:
29836|     12|                                        size_t src_len) {
29837|     12|  size_t dst_len3 = dst_len / 3;
29838|     12|  size_t src_len2 = src_len / 2;
29839|     12|  size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2;
  ------------------
  |  Branch (29839:16): [True: 4, False: 8]
  ------------------
29840|     12|  uint8_t* d = dst_ptr;
29841|     12|  const uint8_t* s = src_ptr;
29842|     12|  size_t n = len;
29843|       |
29844|       |  // TODO: unroll.
29845|       |
29846|    243|  while (n >= 1) {
  ------------------
  |  Branch (29846:10): [True: 231, False: 12]
  ------------------
29847|    231|    uint8_t s0 = s[0];
29848|    231|    d[0] = s0;
29849|    231|    d[1] = s0;
29850|    231|    d[2] = s0;
29851|       |
29852|    231|    s += 1 * 2;
29853|    231|    d += 1 * 3;
29854|    231|    n -= 1;
29855|    231|  }
29856|       |
29857|     12|  return len;
29858|     12|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__y_16be:
30150|     48|                                         size_t src_len) {
30151|     48|  size_t dst_len4 = dst_len / 4;
30152|     48|  size_t src_len2 = src_len / 2;
30153|     48|  size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2;
  ------------------
  |  Branch (30153:16): [True: 21, False: 27]
  ------------------
30154|     48|  uint8_t* d = dst_ptr;
30155|     48|  const uint8_t* s = src_ptr;
30156|     48|  size_t n = len;
30157|       |
30158|  1.04k|  while (n >= 1) {
  ------------------
  |  Branch (30158:10): [True: 992, False: 48]
  ------------------
30159|    992|    wuffs_base__poke_u32le__no_bounds_check(
30160|    992|        d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0]));
30161|       |
30162|    992|    s += 1 * 2;
30163|    992|    d += 1 * 4;
30164|    992|    n -= 1;
30165|    992|  }
30166|       |
30167|     48|  return len;
30168|     48|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__y_16be:
30294|      9|                                             size_t src_len) {
30295|      9|  size_t dst_len8 = dst_len / 8;
30296|      9|  size_t src_len2 = src_len / 2;
30297|      9|  size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2;
  ------------------
  |  Branch (30297:16): [True: 7, False: 2]
  ------------------
30298|      9|  uint8_t* d = dst_ptr;
30299|      9|  const uint8_t* s = src_ptr;
30300|      9|  size_t n = len;
30301|       |
30302|     55|  while (n >= 1) {
  ------------------
  |  Branch (30302:10): [True: 46, False: 9]
  ------------------
30303|     46|    uint64_t s0 =
30304|     46|        ((uint64_t)(wuffs_base__peek_u16be__no_bounds_check(s + (0 * 2))));
30305|     46|    wuffs_base__poke_u64le__no_bounds_check(
30306|     46|        d + (0 * 8), 0xFFFF000000000000 | (0x000100010001 * s0));
30307|       |
30308|     46|    s += 1 * 2;
30309|     46|    d += 1 * 8;
30310|     46|    n -= 1;
30311|     46|  }
30312|       |
30313|      9|  return len;
30314|      9|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__y_16le:
31251|    136|    wuffs_base__pixel_blend blend) {
31252|    136|  switch (dst_pixfmt.repr) {
  ------------------
  |  Branch (31252:11): [True: 124, False: 12]
  ------------------
31253|     18|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|     18|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (31253:5): [True: 18, False: 118]
  ------------------
31254|     18|      return wuffs_private_impl__swizzle_y__y_16le;
31255|       |
31256|      7|    case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:
  ------------------
  |  | 4944|      7|#define WUFFS_BASE__PIXEL_FORMAT__Y_16LE                    0x2000000B
  ------------------
  |  Branch (31256:5): [True: 7, False: 129]
  ------------------
31257|      7|      return wuffs_private_impl__swizzle_copy_2_2;
31258|       |
31259|     19|    case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:
  ------------------
  |  | 4945|     19|#define WUFFS_BASE__PIXEL_FORMAT__Y_16BE                    0x2010000B
  ------------------
  |  Branch (31259:5): [True: 19, False: 117]
  ------------------
31260|     19|      return wuffs_private_impl__swizzle_y_16le__y_16be;
31261|       |
31262|     18|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|     18|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (31262:5): [True: 18, False: 118]
  ------------------
31263|     18|      return wuffs_private_impl__swizzle_bgr_565__y_16le;
31264|       |
31265|      4|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|      4|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (31265:5): [True: 4, False: 132]
  ------------------
31266|     13|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|     13|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (31266:5): [True: 9, False: 127]
  ------------------
31267|     13|      return wuffs_private_impl__swizzle_xxx__y_16le;
31268|       |
31269|      5|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|      5|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (31269:5): [True: 5, False: 131]
  ------------------
31270|      8|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|      8|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (31270:5): [True: 3, False: 133]
  ------------------
31271|      8|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
  ------------------
  |  | 4968|      8|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY               0x83008888
  ------------------
  |  Branch (31271:5): [True: 0, False: 136]
  ------------------
31272|     12|    case WUFFS_BASE__PIXEL_FORMAT__BGRX:
  ------------------
  |  | 4969|     12|#define WUFFS_BASE__PIXEL_FORMAT__BGRX                      0x90008888
  ------------------
  |  Branch (31272:5): [True: 4, False: 132]
  ------------------
31273|     22|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|     22|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (31273:5): [True: 10, False: 126]
  ------------------
31274|     37|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|     37|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (31274:5): [True: 15, False: 121]
  ------------------
31275|     37|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
  ------------------
  |  | 4976|     37|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY               0xA3008888
  ------------------
  |  Branch (31275:5): [True: 0, False: 136]
  ------------------
31276|     37|    case WUFFS_BASE__PIXEL_FORMAT__RGBX:
  ------------------
  |  | 4977|     37|#define WUFFS_BASE__PIXEL_FORMAT__RGBX                      0xB0008888
  ------------------
  |  Branch (31276:5): [True: 0, False: 136]
  ------------------
31277|     37|      return wuffs_private_impl__swizzle_xxxx__y_16le;
31278|       |
31279|     10|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|     10|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (31279:5): [True: 10, False: 126]
  ------------------
31280|     12|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:
  ------------------
  |  | 4967|     12|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE        0x8200BBBB
  ------------------
  |  Branch (31280:5): [True: 2, False: 134]
  ------------------
31281|     12|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE:
  ------------------
  |  | 4973|     12|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE     0xA100BBBB
  ------------------
  |  Branch (31281:5): [True: 0, False: 136]
  ------------------
31282|     12|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE:
  ------------------
  |  | 4975|     12|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE        0xA200BBBB
  ------------------
  |  Branch (31282:5): [True: 0, False: 136]
  ------------------
31283|     12|      return wuffs_private_impl__swizzle_xxxxxxxx__y_16le;
31284|    136|  }
31285|     12|  return NULL;
31286|    136|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__y_16le:
30889|     18|                                      size_t src_len) {
30890|     18|  size_t src_len2 = src_len / 2;
30891|     18|  size_t len = (dst_len < src_len2) ? dst_len : src_len2;
  ------------------
  |  Branch (30891:16): [True: 4, False: 14]
  ------------------
30892|     18|  uint8_t* d = dst_ptr;
30893|     18|  const uint8_t* s = src_ptr;
30894|     18|  size_t n = len;
30895|       |
30896|       |  // TODO: unroll.
30897|       |
30898|    353|  while (n >= 1) {
  ------------------
  |  Branch (30898:10): [True: 335, False: 18]
  ------------------
30899|    335|    d[0] = s[1];
30900|       |
30901|    335|    s += 1 * 2;
30902|    335|    d += 1 * 1;
30903|    335|    n -= 1;
30904|    335|  }
30905|       |
30906|     18|  return len;
30907|     18|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__y_16le:
26686|     18|                                            size_t src_len) {
26687|     18|  size_t dst_len2 = dst_len / 2;
26688|     18|  size_t src_len2 = src_len / 2;
26689|     18|  size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2;
  ------------------
  |  Branch (26689:16): [True: 5, False: 13]
  ------------------
26690|     18|  uint8_t* d = dst_ptr;
26691|     18|  const uint8_t* s = src_ptr;
26692|     18|  size_t n = len;
26693|       |
26694|       |  // TODO: unroll.
26695|       |
26696|    725|  while (n >= 1) {
  ------------------
  |  Branch (26696:10): [True: 707, False: 18]
  ------------------
26697|    707|    uint32_t y5 = (uint32_t)(s[1] >> 3);
26698|    707|    uint32_t y6 = (uint32_t)(s[1] >> 2);
26699|    707|    uint32_t rgb_565 = (y5 << 11) | (y6 << 5) | (y5 << 0);
26700|    707|    wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565);
26701|       |
26702|    707|    s += 1 * 2;
26703|    707|    d += 1 * 2;
26704|    707|    n -= 1;
26705|    707|  }
26706|       |
26707|     18|  return len;
26708|     18|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__y_16le:
29866|     13|                                        size_t src_len) {
29867|     13|  size_t dst_len3 = dst_len / 3;
29868|     13|  size_t src_len2 = src_len / 2;
29869|     13|  size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2;
  ------------------
  |  Branch (29869:16): [True: 5, False: 8]
  ------------------
29870|     13|  uint8_t* d = dst_ptr;
29871|     13|  const uint8_t* s = src_ptr;
29872|     13|  size_t n = len;
29873|       |
29874|       |  // TODO: unroll.
29875|       |
29876|    315|  while (n >= 1) {
  ------------------
  |  Branch (29876:10): [True: 302, False: 13]
  ------------------
29877|    302|    uint8_t s0 = s[1];
29878|    302|    d[0] = s0;
29879|    302|    d[1] = s0;
29880|    302|    d[2] = s0;
29881|       |
29882|    302|    s += 1 * 2;
29883|    302|    d += 1 * 3;
29884|    302|    n -= 1;
29885|    302|  }
29886|       |
29887|     13|  return len;
29888|     13|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__y_16le:
30176|     37|                                         size_t src_len) {
30177|     37|  size_t dst_len4 = dst_len / 4;
30178|     37|  size_t src_len2 = src_len / 2;
30179|     37|  size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2;
  ------------------
  |  Branch (30179:16): [True: 14, False: 23]
  ------------------
30180|     37|  uint8_t* d = dst_ptr;
30181|     37|  const uint8_t* s = src_ptr;
30182|     37|  size_t n = len;
30183|       |
30184|    681|  while (n >= 1) {
  ------------------
  |  Branch (30184:10): [True: 644, False: 37]
  ------------------
30185|    644|    wuffs_base__poke_u32le__no_bounds_check(
30186|    644|        d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[1]));
30187|       |
30188|    644|    s += 1 * 2;
30189|    644|    d += 1 * 4;
30190|    644|    n -= 1;
30191|    644|  }
30192|       |
30193|     37|  return len;
30194|     37|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__y_16le:
30322|     12|                                             size_t src_len) {
30323|     12|  size_t dst_len8 = dst_len / 8;
30324|     12|  size_t src_len2 = src_len / 2;
30325|     12|  size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2;
  ------------------
  |  Branch (30325:16): [True: 5, False: 7]
  ------------------
30326|     12|  uint8_t* d = dst_ptr;
30327|     12|  const uint8_t* s = src_ptr;
30328|     12|  size_t n = len;
30329|       |
30330|     91|  while (n >= 1) {
  ------------------
  |  Branch (30330:10): [True: 79, False: 12]
  ------------------
30331|     79|    uint64_t s0 =
30332|     79|        ((uint64_t)(wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))));
30333|     79|    wuffs_base__poke_u64le__no_bounds_check(
30334|     79|        d + (0 * 8), 0xFFFF000000000000 | (0x000100010001 * s0));
30335|       |
30336|     79|    s += 1 * 2;
30337|     79|    d += 1 * 8;
30338|     79|    n -= 1;
30339|     79|  }
30340|       |
30341|     12|  return len;
30342|     12|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__ya_nonpremul:
31294|    306|    wuffs_base__pixel_blend blend) {
31295|    306|  switch (dst_pixfmt.repr) {
  ------------------
  |  Branch (31295:11): [True: 280, False: 26]
  ------------------
31296|     35|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|     35|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (31296:5): [True: 35, False: 271]
  ------------------
31297|     35|      switch (blend) {
  ------------------
  |  Branch (31297:15): [True: 35, False: 0]
  ------------------
31298|     19|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     19|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31298:9): [True: 19, False: 16]
  ------------------
31299|     19|          return wuffs_private_impl__swizzle_y__ya_nonpremul__src;
31300|     16|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     16|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31300:9): [True: 16, False: 19]
  ------------------
31301|     16|          return wuffs_private_impl__swizzle_y__ya_nonpremul__src_over;
31302|     35|      }
31303|      0|      return NULL;
31304|       |
31305|     40|    case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL:
  ------------------
  |  | 4946|     40|#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL              0x21000088
  ------------------
  |  Branch (31305:5): [True: 40, False: 266]
  ------------------
31306|     40|      switch (blend) {
  ------------------
  |  Branch (31306:15): [True: 40, False: 0]
  ------------------
31307|      5|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      5|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31307:9): [True: 5, False: 35]
  ------------------
31308|      5|          return wuffs_private_impl__swizzle_copy_2_2;
31309|     35|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     35|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31309:9): [True: 35, False: 5]
  ------------------
31310|     35|          return wuffs_private_impl__swizzle_ya_nonpremul__ya_nonpremul__src_over;
31311|     40|      }
31312|      0|      return NULL;
31313|       |
31314|     39|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|     39|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (31314:5): [True: 39, False: 267]
  ------------------
31315|     39|      switch (blend) {
  ------------------
  |  Branch (31315:15): [True: 39, False: 0]
  ------------------
31316|     21|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     21|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31316:9): [True: 21, False: 18]
  ------------------
31317|     21|          return wuffs_private_impl__swizzle_bgr_565__ya_nonpremul__src;
31318|     18|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     18|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31318:9): [True: 18, False: 21]
  ------------------
31319|     18|          return wuffs_private_impl__swizzle_bgr_565__ya_nonpremul__src_over;
31320|     39|      }
31321|      0|      return NULL;
31322|       |
31323|     19|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|     19|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (31323:5): [True: 19, False: 287]
  ------------------
31324|     32|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|     32|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (31324:5): [True: 13, False: 293]
  ------------------
31325|     32|      switch (blend) {
  ------------------
  |  Branch (31325:15): [True: 32, False: 0]
  ------------------
31326|     15|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     15|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31326:9): [True: 15, False: 17]
  ------------------
31327|     15|          return wuffs_private_impl__swizzle_xxx__ya_nonpremul__src;
31328|     17|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     17|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31328:9): [True: 17, False: 15]
  ------------------
31329|     17|          return wuffs_private_impl__swizzle_xxx__ya_nonpremul__src_over;
31330|     32|      }
31331|      0|      return NULL;
31332|       |
31333|     22|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|     22|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (31333:5): [True: 22, False: 284]
  ------------------
31334|     43|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|     43|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (31334:5): [True: 21, False: 285]
  ------------------
31335|     43|      switch (blend) {
  ------------------
  |  Branch (31335:15): [True: 43, False: 0]
  ------------------
31336|     17|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     17|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31336:9): [True: 17, False: 26]
  ------------------
31337|     17|          return wuffs_private_impl__swizzle_bgra_nonpremul__ya_nonpremul__src;
31338|     26|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     26|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31338:9): [True: 26, False: 17]
  ------------------
31339|     26|          return wuffs_private_impl__swizzle_bgra_nonpremul__ya_nonpremul__src_over;
31340|     43|      }
31341|      0|      return NULL;
31342|       |
31343|     19|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|     19|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (31343:5): [True: 19, False: 287]
  ------------------
31344|     42|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|     42|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (31344:5): [True: 23, False: 283]
  ------------------
31345|     42|      switch (blend) {
  ------------------
  |  Branch (31345:15): [True: 42, False: 0]
  ------------------
31346|     18|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     18|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31346:9): [True: 18, False: 24]
  ------------------
31347|     18|          return wuffs_private_impl__swizzle_bgra_premul__ya_nonpremul__src;
31348|     24|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     24|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31348:9): [True: 24, False: 18]
  ------------------
31349|     24|          return wuffs_private_impl__swizzle_bgra_premul__ya_nonpremul__src_over;
31350|     42|      }
31351|      0|      return NULL;
31352|       |
31353|     49|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|     49|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (31353:5): [True: 49, False: 257]
  ------------------
31354|     49|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE:
  ------------------
  |  | 4973|     49|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE     0xA100BBBB
  ------------------
  |  Branch (31354:5): [True: 0, False: 306]
  ------------------
31355|     49|      switch (blend) {
  ------------------
  |  Branch (31355:15): [True: 49, False: 0]
  ------------------
31356|     10|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31356:9): [True: 10, False: 39]
  ------------------
31357|     10|          return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__ya_nonpremul__src;
31358|     39|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     39|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31358:9): [True: 39, False: 10]
  ------------------
31359|     39|          return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__ya_nonpremul__src_over;
31360|     49|      }
31361|      0|      return NULL;
31362|    306|  }
31363|     26|  return NULL;
31364|    306|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__ya_nonpremul__src:
30915|     19|                                                 size_t src_len) {
30916|     19|  size_t src_len2 = src_len / 2;
30917|     19|  size_t len = (dst_len < src_len2) ? dst_len : src_len2;
  ------------------
  |  Branch (30917:16): [True: 4, False: 15]
  ------------------
30918|     19|  uint8_t* d = dst_ptr;
30919|     19|  const uint8_t* s = src_ptr;
30920|     19|  size_t n = len;
30921|       |
30922|       |  // TODO: unroll.
30923|       |
30924|    584|  while (n >= 1) {
  ------------------
  |  Branch (30924:10): [True: 565, False: 19]
  ------------------
30925|    565|    uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101);
30926|    565|    d[0] = (uint8_t)
30927|    565|        wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0);
30928|       |
30929|    565|    s += 1 * 2;
30930|    565|    d += 1 * 1;
30931|    565|    n -= 1;
30932|    565|  }
30933|       |
30934|     19|  return len;
30935|     19|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__ya_nonpremul__src_over:
30943|     16|                                                      size_t src_len) {
30944|     16|  size_t src_len2 = src_len / 2;
30945|     16|  size_t len = (dst_len < src_len2) ? dst_len : src_len2;
  ------------------
  |  Branch (30945:16): [True: 2, False: 14]
  ------------------
30946|     16|  uint8_t* d = dst_ptr;
30947|     16|  const uint8_t* s = src_ptr;
30948|     16|  size_t n = len;
30949|       |
30950|       |  // TODO: unroll.
30951|       |
30952|    667|  while (n >= 1) {
  ------------------
  |  Branch (30952:10): [True: 651, False: 16]
  ------------------
30953|    651|    uint32_t d0 = 0xFF000000 | ((uint32_t)(d[0]) * 0x010101);
30954|    651|    uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101);
30955|    651|    d[0] = (uint8_t)wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0,
30956|    651|                                                                            s0);
30957|       |
30958|    651|    s += 1 * 2;
30959|    651|    d += 1 * 1;
30960|    651|    n -= 1;
30961|    651|  }
30962|       |
30963|     16|  return len;
30964|     16|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_premul_nonpremul_u32_axxx:
25610|  6.00k|    uint32_t src_nonpremul) {
25611|       |  // Extract 16-bit color components.
25612|  6.00k|  uint32_t da = 0x101 * (0xFF & (dst_premul >> 24));
25613|  6.00k|  uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16));
25614|  6.00k|  uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8));
25615|  6.00k|  uint32_t db = 0x101 * (0xFF & (dst_premul >> 0));
25616|  6.00k|  uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24));
25617|  6.00k|  uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16));
25618|  6.00k|  uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8));
25619|  6.00k|  uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0));
25620|       |
25621|       |  // Calculate the inverse of the src-alpha: how much of the dst to keep.
25622|  6.00k|  uint32_t ia = 0xFFFF - sa;
25623|       |
25624|       |  // Composite src (nonpremul) over dst (premul).
25625|  6.00k|  da = sa + ((da * ia) / 0xFFFF);
25626|  6.00k|  dr = ((sr * sa) + (dr * ia)) / 0xFFFF;
25627|  6.00k|  dg = ((sg * sa) + (dg * ia)) / 0xFFFF;
25628|  6.00k|  db = ((sb * sa) + (db * ia)) / 0xFFFF;
25629|       |
25630|       |  // Convert from 16-bit color to 8-bit color.
25631|  6.00k|  da >>= 8;
25632|  6.00k|  dr >>= 8;
25633|  6.00k|  dg >>= 8;
25634|  6.00k|  db >>= 8;
25635|       |
25636|       |  // Combine components.
25637|  6.00k|  return (db << 0) | (dg << 8) | (dr << 16) | (da << 24);
25638|  6.00k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ya_nonpremul__ya_nonpremul__src_over:
31102|     35|    size_t src_len) {
31103|     35|  size_t dst_len2 = dst_len / 2;
31104|     35|  size_t src_len2 = src_len / 2;
31105|     35|  size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2;
  ------------------
  |  Branch (31105:16): [True: 9, False: 26]
  ------------------
31106|     35|  uint8_t* d = dst_ptr;
31107|     35|  const uint8_t* s = src_ptr;
31108|     35|  size_t n = len;
31109|       |
31110|    964|  while (n >= 1) {
  ------------------
  |  Branch (31110:10): [True: 929, False: 35]
  ------------------
31111|    929|    uint32_t d0 = ((uint32_t)(d[1]) << 24) | ((uint32_t)(d[0]) * 0x010101);
31112|    929|    uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101);
31113|    929|    uint32_t c0 =
31114|    929|        wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0);
31115|    929|    wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)(c0 >> 16));
31116|       |
31117|    929|    s += 1 * 2;
31118|    929|    d += 1 * 2;
31119|    929|    n -= 1;
31120|    929|  }
31121|       |
31122|     35|  return len;
31123|     35|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx:
25426|  2.39k|    uint32_t src_nonpremul) {
25427|       |  // Extract 16-bit color components.
25428|       |  //
25429|       |  // If the destination is transparent then SRC_OVER is equivalent to SRC: just
25430|       |  // return src_nonpremul. This isn't just an optimization (skipping the rest
25431|       |  // of the function's computation). It also preserves the nonpremul
25432|       |  // distinction between e.g. transparent red and transparent blue that would
25433|       |  // otherwise be lost by converting from nonpremul to premul and back.
25434|  2.39k|  uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24));
25435|  2.39k|  if (da == 0) {
  ------------------
  |  Branch (25435:7): [True: 495, False: 1.89k]
  ------------------
25436|    495|    return src_nonpremul;
25437|    495|  }
25438|  1.89k|  uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16));
25439|  1.89k|  uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8));
25440|  1.89k|  uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0));
25441|  1.89k|  uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24));
25442|  1.89k|  uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16));
25443|  1.89k|  uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8));
25444|  1.89k|  uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0));
25445|       |
25446|       |  // Convert dst from nonpremul to premul.
25447|  1.89k|  dr = (dr * da) / 0xFFFF;
25448|  1.89k|  dg = (dg * da) / 0xFFFF;
25449|  1.89k|  db = (db * da) / 0xFFFF;
25450|       |
25451|       |  // Calculate the inverse of the src-alpha: how much of the dst to keep.
25452|  1.89k|  uint32_t ia = 0xFFFF - sa;
25453|       |
25454|       |  // Composite src (nonpremul) over dst (premul).
25455|  1.89k|  da = sa + ((da * ia) / 0xFFFF);
25456|  1.89k|  dr = ((sr * sa) + (dr * ia)) / 0xFFFF;
25457|  1.89k|  dg = ((sg * sa) + (dg * ia)) / 0xFFFF;
25458|  1.89k|  db = ((sb * sa) + (db * ia)) / 0xFFFF;
25459|       |
25460|       |  // Convert dst from premul to nonpremul.
25461|  1.89k|  if (da != 0) {
  ------------------
  |  Branch (25461:7): [True: 1.89k, False: 0]
  ------------------
25462|  1.89k|    dr = (dr * 0xFFFF) / da;
25463|  1.89k|    dg = (dg * 0xFFFF) / da;
25464|  1.89k|    db = (db * 0xFFFF) / da;
25465|  1.89k|  }
25466|       |
25467|       |  // Convert from 16-bit color to 8-bit color.
25468|  1.89k|  da >>= 8;
25469|  1.89k|  dr >>= 8;
25470|  1.89k|  dg >>= 8;
25471|  1.89k|  db >>= 8;
25472|       |
25473|       |  // Combine components.
25474|  1.89k|  return (db << 0) | (dg << 8) | (dr << 16) | (da << 24);
25475|  2.39k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__ya_nonpremul__src:
26716|     21|                                                       size_t src_len) {
26717|     21|  size_t dst_len2 = dst_len / 2;
26718|     21|  size_t src_len2 = src_len / 2;
26719|     21|  size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2;
  ------------------
  |  Branch (26719:16): [True: 2, False: 19]
  ------------------
26720|     21|  uint8_t* d = dst_ptr;
26721|     21|  const uint8_t* s = src_ptr;
26722|     21|  size_t n = len;
26723|       |
26724|       |  // TODO: unroll.
26725|       |
26726|    957|  while (n >= 1) {
  ------------------
  |  Branch (26726:10): [True: 936, False: 21]
  ------------------
26727|    936|    uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101);
26728|       |
26729|    936|    wuffs_base__poke_u16le__no_bounds_check(
26730|    936|        d + (0 * 2),
26731|    936|        wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(
26732|    936|            wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
26733|    936|                s0)));
26734|       |
26735|    936|    s += 1 * 2;
26736|    936|    d += 1 * 2;
26737|    936|    n -= 1;
26738|    936|  }
26739|       |
26740|     21|  return len;
26741|     21|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__ya_nonpremul__src_over:
26750|     18|    size_t src_len) {
26751|     18|  size_t dst_len2 = dst_len / 2;
26752|     18|  size_t src_len2 = src_len / 2;
26753|     18|  size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2;
  ------------------
  |  Branch (26753:16): [True: 6, False: 12]
  ------------------
26754|     18|  uint8_t* d = dst_ptr;
26755|     18|  const uint8_t* s = src_ptr;
26756|     18|  size_t n = len;
26757|       |
26758|       |  // TODO: unroll.
26759|       |
26760|    621|  while (n >= 1) {
  ------------------
  |  Branch (26760:10): [True: 603, False: 18]
  ------------------
26761|       |    // Extract 16-bit color components.
26762|    603|    uint32_t sa = 0x101 * ((uint32_t)s[1]);
26763|    603|    uint32_t sy = 0x101 * ((uint32_t)s[0]);
26764|       |
26765|       |    // Convert from 565 color to 16-bit color.
26766|    603|    uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));
26767|    603|    uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);
26768|    603|    uint32_t dr = (0x8421 * old_r5) >> 4;
26769|    603|    uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);
26770|    603|    uint32_t dg = (0x1041 * old_g6) >> 2;
26771|    603|    uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);
26772|    603|    uint32_t db = (0x8421 * old_b5) >> 4;
26773|       |
26774|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
26775|    603|    uint32_t ia = 0xFFFF - sa;
26776|       |
26777|       |    // Composite src (nonpremul) over dst (premul).
26778|    603|    dr = ((sy * sa) + (dr * ia)) / 0xFFFF;
26779|    603|    dg = ((sy * sa) + (dg * ia)) / 0xFFFF;
26780|    603|    db = ((sy * sa) + (db * ia)) / 0xFFFF;
26781|       |
26782|       |    // Convert from 16-bit color to 565 color and combine the components.
26783|    603|    uint32_t new_r5 = 0x1F & (dr >> 11);
26784|    603|    uint32_t new_g6 = 0x3F & (dg >> 10);
26785|    603|    uint32_t new_b5 = 0x1F & (db >> 11);
26786|    603|    uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);
26787|    603|    wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);
26788|       |
26789|    603|    s += 1 * 2;
26790|    603|    d += 1 * 2;
26791|    603|    n -= 1;
26792|    603|  }
26793|       |
26794|     18|  return len;
26795|     18|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__ya_nonpremul__src:
29896|     15|                                                   size_t src_len) {
29897|     15|  size_t dst_len3 = dst_len / 3;
29898|     15|  size_t src_len2 = src_len / 2;
29899|     15|  size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2;
  ------------------
  |  Branch (29899:16): [True: 5, False: 10]
  ------------------
29900|     15|  uint8_t* d = dst_ptr;
29901|     15|  const uint8_t* s = src_ptr;
29902|     15|  size_t n = len;
29903|       |
29904|       |  // TODO: unroll.
29905|       |
29906|    366|  while (n >= 1) {
  ------------------
  |  Branch (29906:10): [True: 351, False: 15]
  ------------------
29907|    351|    uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101);
29908|    351|    wuffs_base__poke_u24le__no_bounds_check(
29909|    351|        d + (0 * 3),
29910|    351|        wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0));
29911|       |
29912|    351|    s += 1 * 2;
29913|    351|    d += 1 * 3;
29914|    351|    n -= 1;
29915|    351|  }
29916|       |
29917|     15|  return len;
29918|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__ya_nonpremul__src_over:
29927|     17|    size_t src_len) {
29928|     17|  size_t dst_len3 = dst_len / 3;
29929|     17|  size_t src_len2 = src_len / 2;
29930|     17|  size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2;
  ------------------
  |  Branch (29930:16): [True: 10, False: 7]
  ------------------
29931|     17|  uint8_t* d = dst_ptr;
29932|     17|  const uint8_t* s = src_ptr;
29933|     17|  size_t n = len;
29934|       |
29935|       |  // TODO: unroll.
29936|       |
29937|    302|  while (n >= 1) {
  ------------------
  |  Branch (29937:10): [True: 285, False: 17]
  ------------------
29938|    285|    uint32_t d0 =
29939|    285|        wuffs_base__peek_u24le__no_bounds_check(d + (0 * 3)) | 0xFF000000;
29940|    285|    uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101);
29941|    285|    wuffs_base__poke_u24le__no_bounds_check(
29942|    285|        d + (0 * 3),
29943|    285|        wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0));
29944|       |
29945|    285|    s += 1 * 2;
29946|    285|    d += 1 * 3;
29947|    285|    n -= 1;
29948|    285|  }
29949|       |
29950|     17|  return len;
29951|     17|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__ya_nonpremul__src:
27952|     17|    size_t src_len) {
27953|     17|  size_t dst_len4 = dst_len / 4;
27954|     17|  size_t src_len2 = src_len / 2;
27955|     17|  size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2;
  ------------------
  |  Branch (27955:16): [True: 5, False: 12]
  ------------------
27956|     17|  uint8_t* d = dst_ptr;
27957|     17|  const uint8_t* s = src_ptr;
27958|     17|  size_t n = len;
27959|       |
27960|       |  // TODO: unroll.
27961|       |
27962|    323|  while (n >= 1) {
  ------------------
  |  Branch (27962:10): [True: 306, False: 17]
  ------------------
27963|    306|    uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101);
27964|    306|    wuffs_base__poke_u32le__no_bounds_check(d + (0 * 4), s0);
27965|       |
27966|    306|    s += 1 * 2;
27967|    306|    d += 1 * 4;
27968|    306|    n -= 1;
27969|    306|  }
27970|       |
27971|     17|  return len;
27972|     17|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__ya_nonpremul__src_over:
27981|     26|    size_t src_len) {
27982|     26|  size_t dst_len4 = dst_len / 4;
27983|     26|  size_t src_len2 = src_len / 2;
27984|     26|  size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2;
  ------------------
  |  Branch (27984:16): [True: 13, False: 13]
  ------------------
27985|     26|  uint8_t* d = dst_ptr;
27986|     26|  const uint8_t* s = src_ptr;
27987|     26|  size_t n = len;
27988|       |
27989|       |  // TODO: unroll.
27990|       |
27991|    396|  while (n >= 1) {
  ------------------
  |  Branch (27991:10): [True: 370, False: 26]
  ------------------
27992|    370|    uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));
27993|    370|    uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101);
27994|    370|    wuffs_base__poke_u32le__no_bounds_check(
27995|    370|        d + (0 * 4),
27996|    370|        wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0));
27997|       |
27998|    370|    s += 1 * 2;
27999|    370|    d += 1 * 4;
28000|    370|    n -= 1;
28001|    370|  }
28002|       |
28003|     26|  return len;
28004|     26|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__ya_nonpremul__src:
28936|     18|    size_t src_len) {
28937|     18|  size_t dst_len4 = dst_len / 4;
28938|     18|  size_t src_len2 = src_len / 2;
28939|     18|  size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2;
  ------------------
  |  Branch (28939:16): [True: 6, False: 12]
  ------------------
28940|     18|  uint8_t* d = dst_ptr;
28941|     18|  const uint8_t* s = src_ptr;
28942|     18|  size_t n = len;
28943|       |
28944|       |  // TODO: unroll.
28945|       |
28946|    414|  while (n >= 1) {
  ------------------
  |  Branch (28946:10): [True: 396, False: 18]
  ------------------
28947|    396|    uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101);
28948|    396|    wuffs_base__poke_u32le__no_bounds_check(
28949|    396|        d + (0 * 4),
28950|    396|        wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0));
28951|       |
28952|    396|    s += 1 * 2;
28953|    396|    d += 1 * 4;
28954|    396|    n -= 1;
28955|    396|  }
28956|       |
28957|     18|  return len;
28958|     18|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__ya_nonpremul__src_over:
28967|     24|    size_t src_len) {
28968|     24|  size_t dst_len4 = dst_len / 4;
28969|     24|  size_t src_len2 = src_len / 2;
28970|     24|  size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2;
  ------------------
  |  Branch (28970:16): [True: 11, False: 13]
  ------------------
28971|     24|  uint8_t* d = dst_ptr;
28972|     24|  const uint8_t* s = src_ptr;
28973|     24|  size_t n = len;
28974|       |
28975|       |  // TODO: unroll.
28976|       |
28977|    440|  while (n >= 1) {
  ------------------
  |  Branch (28977:10): [True: 416, False: 24]
  ------------------
28978|    416|    uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));
28979|    416|    uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101);
28980|    416|    wuffs_base__poke_u32le__no_bounds_check(
28981|    416|        d + (0 * 4),
28982|    416|        wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0));
28983|       |
28984|    416|    s += 1 * 2;
28985|    416|    d += 1 * 4;
28986|    416|    n -= 1;
28987|    416|  }
28988|       |
28989|     24|  return len;
28990|     24|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__ya_nonpremul__src:
28387|     10|    size_t src_len) {
28388|     10|  size_t dst_len8 = dst_len / 8;
28389|     10|  size_t src_len2 = src_len / 2;
28390|     10|  size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2;
  ------------------
  |  Branch (28390:16): [True: 6, False: 4]
  ------------------
28391|     10|  uint8_t* d = dst_ptr;
28392|     10|  const uint8_t* s = src_ptr;
28393|       |
28394|     10|  size_t n = len;
28395|    102|  while (n >= 1) {
  ------------------
  |  Branch (28395:10): [True: 92, False: 10]
  ------------------
28396|     92|    uint64_t s0 = ((uint64_t)(s[1]) * 0x0101000000000000) |
28397|     92|                  ((uint64_t)(s[0]) * 0x0000010101010101);
28398|     92|    wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0);
28399|       |
28400|     92|    s += 1 * 2;
28401|     92|    d += 1 * 8;
28402|     92|    n -= 1;
28403|     92|  }
28404|     10|  return len;
28405|     10|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__ya_nonpremul__src_over:
28414|     39|    size_t src_len) {
28415|     39|  size_t dst_len8 = dst_len / 8;
28416|     39|  size_t src_len2 = src_len / 2;
28417|     39|  size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2;
  ------------------
  |  Branch (28417:16): [True: 16, False: 23]
  ------------------
28418|     39|  uint8_t* d = dst_ptr;
28419|     39|  const uint8_t* s = src_ptr;
28420|       |
28421|     39|  size_t n = len;
28422|    291|  while (n >= 1) {
  ------------------
  |  Branch (28422:10): [True: 252, False: 39]
  ------------------
28423|    252|    uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));
28424|    252|    uint64_t s0 = ((uint64_t)(s[1]) * 0x0101000000000000) |
28425|    252|                  ((uint64_t)(s[0]) * 0x0000010101010101);
28426|    252|    wuffs_base__poke_u64le__no_bounds_check(
28427|    252|        d + (0 * 8),
28428|    252|        wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0));
28429|       |
28430|    252|    s += 1 * 2;
28431|    252|    d += 1 * 8;
28432|    252|    n -= 1;
28433|    252|  }
28434|     39|  return len;
28435|     39|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx:
25480|  1.57k|    uint64_t src_nonpremul) {
25481|       |  // Extract components.
25482|       |  //
25483|       |  // If the destination is transparent then SRC_OVER is equivalent to SRC: just
25484|       |  // return src_nonpremul. This isn't just an optimization (skipping the rest
25485|       |  // of the function's computation). It also preserves the nonpremul
25486|       |  // distinction between e.g. transparent red and transparent blue that would
25487|       |  // otherwise be lost by converting from nonpremul to premul and back.
25488|  1.57k|  uint64_t da = 0xFFFF & (dst_nonpremul >> 48);
25489|  1.57k|  if (da == 0) {
  ------------------
  |  Branch (25489:7): [True: 264, False: 1.31k]
  ------------------
25490|    264|    return src_nonpremul;
25491|    264|  }
25492|  1.31k|  uint64_t dr = 0xFFFF & (dst_nonpremul >> 32);
25493|  1.31k|  uint64_t dg = 0xFFFF & (dst_nonpremul >> 16);
25494|  1.31k|  uint64_t db = 0xFFFF & (dst_nonpremul >> 0);
25495|  1.31k|  uint64_t sa = 0xFFFF & (src_nonpremul >> 48);
25496|  1.31k|  uint64_t sr = 0xFFFF & (src_nonpremul >> 32);
25497|  1.31k|  uint64_t sg = 0xFFFF & (src_nonpremul >> 16);
25498|  1.31k|  uint64_t sb = 0xFFFF & (src_nonpremul >> 0);
25499|       |
25500|       |  // Convert dst from nonpremul to premul.
25501|  1.31k|  dr = (dr * da) / 0xFFFF;
25502|  1.31k|  dg = (dg * da) / 0xFFFF;
25503|  1.31k|  db = (db * da) / 0xFFFF;
25504|       |
25505|       |  // Calculate the inverse of the src-alpha: how much of the dst to keep.
25506|  1.31k|  uint64_t ia = 0xFFFF - sa;
25507|       |
25508|       |  // Composite src (nonpremul) over dst (premul).
25509|  1.31k|  da = sa + ((da * ia) / 0xFFFF);
25510|  1.31k|  dr = ((sr * sa) + (dr * ia)) / 0xFFFF;
25511|  1.31k|  dg = ((sg * sa) + (dg * ia)) / 0xFFFF;
25512|  1.31k|  db = ((sb * sa) + (db * ia)) / 0xFFFF;
25513|       |
25514|       |  // Convert dst from premul to nonpremul.
25515|  1.31k|  if (da != 0) {
  ------------------
  |  Branch (25515:7): [True: 1.31k, False: 0]
  ------------------
25516|  1.31k|    dr = (dr * 0xFFFF) / da;
25517|  1.31k|    dg = (dg * 0xFFFF) / da;
25518|  1.31k|    db = (db * 0xFFFF) / da;
25519|  1.31k|  }
25520|       |
25521|       |  // Combine components.
25522|  1.31k|  return (db << 0) | (dg << 16) | (dr << 32) | (da << 48);
25523|  1.57k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__indexed__bgra_nonpremul:
31372|    237|    wuffs_base__pixel_blend blend) {
31373|    237|  switch (dst_pixfmt.repr) {
  ------------------
  |  Branch (31373:11): [True: 216, False: 21]
  ------------------
31374|     44|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|     44|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (31374:5): [True: 44, False: 193]
  ------------------
31375|     44|      switch (blend) {
  ------------------
  |  Branch (31375:15): [True: 44, False: 0]
  ------------------
31376|     18|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     18|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31376:9): [True: 18, False: 26]
  ------------------
31377|     18|          if (wuffs_private_impl__swizzle_squash_align4_y_8888(
  ------------------
  |  Branch (31377:15): [True: 0, False: 18]
  ------------------
31378|     18|                  dst_palette.ptr, dst_palette.len, src_palette.ptr,
31379|     18|                  src_palette.len, true) !=
31380|     18|              (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
  ------------------
  |  | 4900|     18|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31381|      0|            return NULL;
31382|      0|          }
31383|     18|          return wuffs_private_impl__swizzle_y__index__src;
31384|     26|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     26|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31384:9): [True: 26, False: 18]
  ------------------
31385|     26|          if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette,
  ------------------
  |  Branch (31385:15): [True: 0, False: 26]
  ------------------
31386|     26|                                                            src_palette) !=
31387|     26|              WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     26|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31388|      0|            return NULL;
31389|      0|          }
31390|     26|          return wuffs_private_impl__swizzle_y__index_bgra_nonpremul__src_over;
31391|     44|      }
31392|      0|      return NULL;
31393|       |
31394|     19|    case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:
  ------------------
  |  | 4958|     19|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL   0x81040008
  ------------------
  |  Branch (31394:5): [True: 19, False: 218]
  ------------------
31395|     19|      if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette,
  ------------------
  |  Branch (31395:11): [True: 0, False: 19]
  ------------------
31396|     19|                                                        src_palette) !=
31397|     19|          WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     19|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31398|      0|        return NULL;
31399|      0|      }
31400|     19|      switch (blend) {
  ------------------
  |  Branch (31400:15): [True: 14, False: 5]
  ------------------
31401|     14|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     14|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31401:9): [True: 14, False: 5]
  ------------------
31402|     14|          return wuffs_private_impl__swizzle_copy_1_1;
31403|     19|      }
31404|      5|      return NULL;
31405|       |
31406|     17|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|     17|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (31406:5): [True: 17, False: 220]
  ------------------
31407|     17|      switch (blend) {
  ------------------
  |  Branch (31407:15): [True: 17, False: 0]
  ------------------
31408|      2|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      2|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31408:9): [True: 2, False: 15]
  ------------------
31409|      2|          if (wuffs_private_impl__swizzle_squash_align4_bgr_565_8888(
  ------------------
  |  Branch (31409:15): [True: 0, False: 2]
  ------------------
31410|      2|                  dst_palette.ptr, dst_palette.len, src_palette.ptr,
31411|      2|                  src_palette.len, true) !=
31412|      2|              (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
  ------------------
  |  | 4900|      2|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31413|      0|            return NULL;
31414|      0|          }
31415|      2|          return wuffs_private_impl__swizzle_bgr_565__index__src;
31416|     15|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     15|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31416:9): [True: 15, False: 2]
  ------------------
31417|     15|          if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette,
  ------------------
  |  Branch (31417:15): [True: 0, False: 15]
  ------------------
31418|     15|                                                            src_palette) !=
31419|     15|              WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     15|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31420|      0|            return NULL;
31421|      0|          }
31422|     15|          return wuffs_private_impl__swizzle_bgr_565__index_bgra_nonpremul__src_over;
31423|     17|      }
31424|      0|      return NULL;
31425|       |
31426|     14|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|     14|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (31426:5): [True: 14, False: 223]
  ------------------
31427|     14|      switch (blend) {
  ------------------
  |  Branch (31427:15): [True: 14, False: 0]
  ------------------
31428|      4|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      4|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31428:9): [True: 4, False: 10]
  ------------------
31429|      4|          if (wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src(
  ------------------
  |  Branch (31429:15): [True: 0, False: 4]
  ------------------
31430|      4|                  dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,
31431|      4|                  src_palette.len) !=
31432|      4|              (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
  ------------------
  |  | 4900|      4|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31433|      0|            return NULL;
31434|      0|          }
31435|      4|          return wuffs_private_impl__swizzle_xxx__index__src;
31436|     10|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31436:9): [True: 10, False: 4]
  ------------------
31437|     10|          if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette,
  ------------------
  |  Branch (31437:15): [True: 0, False: 10]
  ------------------
31438|     10|                                                            src_palette) !=
31439|     10|              WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     10|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31440|      0|            return NULL;
31441|      0|          }
31442|     10|          return wuffs_private_impl__swizzle_xxx__index_bgra_nonpremul__src_over;
31443|     14|      }
31444|      0|      return NULL;
31445|       |
31446|     29|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|     29|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (31446:5): [True: 29, False: 208]
  ------------------
31447|     29|      if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette,
  ------------------
  |  Branch (31447:11): [True: 0, False: 29]
  ------------------
31448|     29|                                                        src_palette) !=
31449|     29|          WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     29|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31450|      0|        return NULL;
31451|      0|      }
31452|     29|      switch (blend) {
  ------------------
  |  Branch (31452:15): [True: 29, False: 0]
  ------------------
31453|     11|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     11|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31453:9): [True: 11, False: 18]
  ------------------
31454|     11|          return wuffs_private_impl__swizzle_xxxx__index__src;
31455|     18|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     18|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31455:9): [True: 18, False: 11]
  ------------------
31456|     18|          return wuffs_private_impl__swizzle_bgra_nonpremul__index_bgra_nonpremul__src_over;
31457|     29|      }
31458|      0|      return NULL;
31459|       |
31460|     48|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|     48|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (31460:5): [True: 48, False: 189]
  ------------------
31461|     48|      if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette,
  ------------------
  |  Branch (31461:11): [True: 0, False: 48]
  ------------------
31462|     48|                                                        src_palette) !=
31463|     48|          WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     48|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31464|      0|        return NULL;
31465|      0|      }
31466|     48|      switch (blend) {
  ------------------
  |  Branch (31466:15): [True: 48, False: 0]
  ------------------
31467|      5|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      5|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31467:9): [True: 5, False: 43]
  ------------------
31468|      5|          return wuffs_private_impl__swizzle_xxxxxxxx__index__src;
31469|     43|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     43|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31469:9): [True: 43, False: 5]
  ------------------
31470|     43|          return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__index_bgra_nonpremul__src_over;
31471|     48|      }
31472|      0|      return NULL;
31473|       |
31474|     11|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|     11|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (31474:5): [True: 11, False: 226]
  ------------------
31475|     11|      switch (blend) {
  ------------------
  |  Branch (31475:15): [True: 11, False: 0]
  ------------------
31476|      3|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      3|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31476:9): [True: 3, False: 8]
  ------------------
31477|      3|          if (wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src(
  ------------------
  |  Branch (31477:15): [True: 0, False: 3]
  ------------------
31478|      3|                  dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,
31479|      3|                  src_palette.len) !=
31480|      3|              (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
  ------------------
  |  | 4900|      3|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31481|      0|            return NULL;
31482|      0|          }
31483|      3|          return wuffs_private_impl__swizzle_xxxx__index__src;
31484|      8|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      8|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31484:9): [True: 8, False: 3]
  ------------------
31485|      8|          if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette,
  ------------------
  |  Branch (31485:15): [True: 0, False: 8]
  ------------------
31486|      8|                                                            src_palette) !=
31487|      8|              WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|      8|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31488|      0|            return NULL;
31489|      0|          }
31490|      8|          return wuffs_private_impl__swizzle_bgra_premul__index_bgra_nonpremul__src_over;
31491|     11|      }
31492|      0|      return NULL;
31493|       |
31494|     18|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|     18|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (31494:5): [True: 18, False: 219]
  ------------------
31495|     18|      switch (blend) {
  ------------------
  |  Branch (31495:15): [True: 18, False: 0]
  ------------------
31496|      7|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      7|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31496:9): [True: 7, False: 11]
  ------------------
31497|      7|          if (wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src(
  ------------------
  |  Branch (31497:15): [True: 0, False: 7]
  ------------------
31498|      7|                  dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,
31499|      7|                  src_palette.len) !=
31500|      7|              (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
  ------------------
  |  | 4900|      7|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31501|      0|            return NULL;
31502|      0|          }
31503|      7|          return wuffs_private_impl__swizzle_xxx__index__src;
31504|     11|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31504:9): [True: 11, False: 7]
  ------------------
31505|     11|          if (wuffs_private_impl__swizzle_swap_rgbx_bgrx(
  ------------------
  |  Branch (31505:15): [True: 0, False: 11]
  ------------------
31506|     11|                  dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,
31507|     11|                  src_palette.len) !=
31508|     11|              (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
  ------------------
  |  | 4900|     11|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31509|      0|            return NULL;
31510|      0|          }
31511|     11|          return wuffs_private_impl__swizzle_xxx__index_bgra_nonpremul__src_over;
31512|     18|      }
31513|      0|      return NULL;
31514|       |
31515|      8|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|      8|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (31515:5): [True: 8, False: 229]
  ------------------
31516|      8|      if (wuffs_private_impl__swizzle_swap_rgbx_bgrx(
  ------------------
  |  Branch (31516:11): [True: 0, False: 8]
  ------------------
31517|      8|              dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,
31518|      8|              src_palette.len) !=
31519|      8|          (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
  ------------------
  |  | 4900|      8|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31520|      0|        return NULL;
31521|      0|      }
31522|      8|      switch (blend) {
  ------------------
  |  Branch (31522:15): [True: 8, False: 0]
  ------------------
31523|      0|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      0|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31523:9): [True: 0, False: 8]
  ------------------
31524|      0|          return wuffs_private_impl__swizzle_xxxx__index__src;
31525|      8|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      8|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31525:9): [True: 8, False: 0]
  ------------------
31526|      8|          return wuffs_private_impl__swizzle_bgra_nonpremul__index_bgra_nonpremul__src_over;
31527|      8|      }
31528|      0|      return NULL;
31529|       |
31530|      8|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|      8|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (31530:5): [True: 8, False: 229]
  ------------------
31531|      8|      switch (blend) {
  ------------------
  |  Branch (31531:15): [True: 8, False: 0]
  ------------------
31532|      4|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      4|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31532:9): [True: 4, False: 4]
  ------------------
31533|      4|          if (wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src(
  ------------------
  |  Branch (31533:15): [True: 0, False: 4]
  ------------------
31534|      4|                  dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,
31535|      4|                  src_palette.len) !=
31536|      4|              (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
  ------------------
  |  | 4900|      4|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31537|      0|            return NULL;
31538|      0|          }
31539|      4|          return wuffs_private_impl__swizzle_xxxx__index__src;
31540|      4|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      4|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31540:9): [True: 4, False: 4]
  ------------------
31541|      4|          if (wuffs_private_impl__swizzle_swap_rgbx_bgrx(
  ------------------
  |  Branch (31541:15): [True: 0, False: 4]
  ------------------
31542|      4|                  dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,
31543|      4|                  src_palette.len) !=
31544|      4|              (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
  ------------------
  |  | 4900|      4|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31545|      0|            return NULL;
31546|      0|          }
31547|      4|          return wuffs_private_impl__swizzle_bgra_premul__index_bgra_nonpremul__src_over;
31548|      8|      }
31549|      0|      return NULL;
31550|       |
31551|      0|    case WUFFS_BASE__PIXEL_FORMAT__RGBX:
  ------------------
  |  | 4977|      0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX                      0xB0008888
  ------------------
  |  Branch (31551:5): [True: 0, False: 237]
  ------------------
31552|       |      // TODO.
31553|      0|      break;
31554|    237|  }
31555|     21|  return NULL;
31556|    237|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_squash_align4_y_8888:
25763|     53|                                                 bool nonpremul) {
25764|     53|  size_t len = (dst_len < src_len ? dst_len : src_len) / 4;
  ------------------
  |  Branch (25764:17): [True: 0, False: 53]
  ------------------
25765|     53|  uint8_t* d = dst_ptr;
25766|     53|  const uint8_t* s = src_ptr;
25767|       |
25768|     53|  size_t n = len;
25769|  13.6k|  while (n--) {
  ------------------
  |  Branch (25769:10): [True: 13.5k, False: 53]
  ------------------
25770|  13.5k|    uint32_t argb = wuffs_base__peek_u32le__no_bounds_check(s);
25771|  13.5k|    if (nonpremul) {
  ------------------
  |  Branch (25771:9): [True: 4.60k, False: 8.96k]
  ------------------
25772|  4.60k|      argb =
25773|  4.60k|          wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(argb);
25774|  4.60k|    }
25775|  13.5k|    uint32_t s0 = wuffs_base__color_u32_argb_premul__as__color_u8_gray(argb);
25776|  13.5k|    wuffs_base__poke_u32le__no_bounds_check(
25777|  13.5k|        d, (argb & 0xFF000000) | (s0 * 0x010101));
25778|  13.5k|    s += 4;
25779|  13.5k|    d += 4;
25780|  13.5k|  }
25781|     53|  return len;
25782|     53|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__index__src:
30972|     21|                                          size_t src_len) {
30973|     21|  if (dst_palette_len !=
  ------------------
  |  Branch (30973:7): [True: 0, False: 21]
  ------------------
30974|     21|      WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     21|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
30975|      0|    return 0;
30976|      0|  }
30977|     21|  size_t len = (dst_len < src_len) ? dst_len : src_len;
  ------------------
  |  Branch (30977:16): [True: 5, False: 16]
  ------------------
30978|     21|  uint8_t* d = dst_ptr;
30979|     21|  const uint8_t* s = src_ptr;
30980|     21|  size_t n = len;
30981|       |
30982|       |  // TODO: unroll.
30983|       |
30984|  1.59k|  while (n >= 1) {
  ------------------
  |  Branch (30984:10): [True: 1.57k, False: 21]
  ------------------
30985|  1.57k|    d[0] = dst_palette_ptr[(size_t)s[0] * 4];
30986|       |
30987|  1.57k|    s += 1 * 1;
30988|  1.57k|    d += 1 * 1;
30989|  1.57k|    n -= 1;
30990|  1.57k|  }
30991|       |
30992|     21|  return len;
30993|     21|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__slice_u8__copy_from_slice:
18632|    332|                                              wuffs_base__slice_u8 src) {
18633|    332|  size_t len = dst.len < src.len ? dst.len : src.len;
  ------------------
  |  Branch (18633:16): [True: 0, False: 332]
  ------------------
18634|    332|  if (len > 0) {
  ------------------
  |  Branch (18634:7): [True: 332, False: 0]
  ------------------
18635|    332|    memmove(dst.ptr, src.ptr, len);
18636|    332|  }
18637|    332|  return len;
18638|    332|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__index_bgra_nonpremul__src_over:
31002|     26|    size_t src_len) {
31003|     26|  if (dst_palette_len !=
  ------------------
  |  Branch (31003:7): [True: 0, False: 26]
  ------------------
31004|     26|      WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     26|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31005|      0|    return 0;
31006|      0|  }
31007|     26|  size_t len = (dst_len < src_len) ? dst_len : src_len;
  ------------------
  |  Branch (31007:16): [True: 3, False: 23]
  ------------------
31008|     26|  uint8_t* d = dst_ptr;
31009|     26|  const uint8_t* s = src_ptr;
31010|     26|  size_t n = len;
31011|       |
31012|       |  // TODO: unroll.
31013|       |
31014|  2.66k|  while (n >= 1) {
  ------------------
  |  Branch (31014:10): [True: 2.64k, False: 26]
  ------------------
31015|  2.64k|    uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0])));
31016|  2.64k|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
31017|  2.64k|                                                          ((size_t)s[0] * 4));
31018|  2.64k|    d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(
31019|  2.64k|        wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0));
31020|       |
31021|  2.64k|    s += 1 * 1;
31022|  2.64k|    d += 1 * 1;
31023|  2.64k|    n -= 1;
31024|  2.64k|  }
31025|       |
31026|     26|  return len;
31027|     26|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_squash_align4_bgr_565_8888:
25732|     35|                                                       bool nonpremul) {
25733|     35|  size_t len = (dst_len < src_len ? dst_len : src_len) / 4;
  ------------------
  |  Branch (25733:17): [True: 0, False: 35]
  ------------------
25734|     35|  uint8_t* d = dst_ptr;
25735|     35|  const uint8_t* s = src_ptr;
25736|       |
25737|     35|  size_t n = len;
25738|  8.99k|  while (n--) {
  ------------------
  |  Branch (25738:10): [True: 8.96k, False: 35]
  ------------------
25739|  8.96k|    uint32_t argb = wuffs_base__peek_u32le__no_bounds_check(s);
25740|  8.96k|    if (nonpremul) {
  ------------------
  |  Branch (25740:9): [True: 512, False: 8.44k]
  ------------------
25741|    512|      argb =
25742|    512|          wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(argb);
25743|    512|    }
25744|  8.96k|    uint32_t b5 = 0x1F & (argb >> (8 - 5));
25745|  8.96k|    uint32_t g6 = 0x3F & (argb >> (16 - 6));
25746|  8.96k|    uint32_t r5 = 0x1F & (argb >> (24 - 5));
25747|  8.96k|    uint32_t alpha = argb & 0xFF000000;
25748|  8.96k|    wuffs_base__poke_u32le__no_bounds_check(
25749|  8.96k|        d, alpha | (r5 << 11) | (g6 << 5) | (b5 << 0));
25750|  8.96k|    s += 4;
25751|  8.96k|    d += 4;
25752|  8.96k|  }
25753|     35|  return len;
25754|     35|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__index__src:
26803|     12|                                                size_t src_len) {
26804|     12|  if (dst_palette_len !=
  ------------------
  |  Branch (26804:7): [True: 0, False: 12]
  ------------------
26805|     12|      WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     12|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
26806|      0|    return 0;
26807|      0|  }
26808|     12|  size_t dst_len2 = dst_len / 2;
26809|     12|  size_t len = (dst_len2 < src_len) ? dst_len2 : src_len;
  ------------------
  |  Branch (26809:16): [True: 2, False: 10]
  ------------------
26810|     12|  uint8_t* d = dst_ptr;
26811|     12|  const uint8_t* s = src_ptr;
26812|     12|  size_t n = len;
26813|       |
26814|     12|  const size_t loop_unroll_count = 4;
26815|       |
26816|    145|  while (n >= loop_unroll_count) {
  ------------------
  |  Branch (26816:10): [True: 133, False: 12]
  ------------------
26817|    133|    wuffs_base__poke_u16le__no_bounds_check(
26818|    133|        d + (0 * 2), wuffs_base__peek_u16le__no_bounds_check(
26819|    133|                         dst_palette_ptr + ((size_t)s[0] * 4)));
26820|    133|    wuffs_base__poke_u16le__no_bounds_check(
26821|    133|        d + (1 * 2), wuffs_base__peek_u16le__no_bounds_check(
26822|    133|                         dst_palette_ptr + ((size_t)s[1] * 4)));
26823|    133|    wuffs_base__poke_u16le__no_bounds_check(
26824|    133|        d + (2 * 2), wuffs_base__peek_u16le__no_bounds_check(
26825|    133|                         dst_palette_ptr + ((size_t)s[2] * 4)));
26826|    133|    wuffs_base__poke_u16le__no_bounds_check(
26827|    133|        d + (3 * 2), wuffs_base__peek_u16le__no_bounds_check(
26828|    133|                         dst_palette_ptr + ((size_t)s[3] * 4)));
26829|       |
26830|    133|    s += loop_unroll_count * 1;
26831|    133|    d += loop_unroll_count * 2;
26832|    133|    n -= loop_unroll_count;
26833|    133|  }
26834|       |
26835|     28|  while (n >= 1) {
  ------------------
  |  Branch (26835:10): [True: 16, False: 12]
  ------------------
26836|     16|    wuffs_base__poke_u16le__no_bounds_check(
26837|     16|        d + (0 * 2), wuffs_base__peek_u16le__no_bounds_check(
26838|     16|                         dst_palette_ptr + ((size_t)s[0] * 4)));
26839|       |
26840|     16|    s += 1 * 1;
26841|     16|    d += 1 * 2;
26842|     16|    n -= 1;
26843|     16|  }
26844|       |
26845|     12|  return len;
26846|     12|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__index_bgra_nonpremul__src_over:
26855|     15|    size_t src_len) {
26856|     15|  if (dst_palette_len !=
  ------------------
  |  Branch (26856:7): [True: 0, False: 15]
  ------------------
26857|     15|      WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     15|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
26858|      0|    return 0;
26859|      0|  }
26860|     15|  size_t dst_len2 = dst_len / 2;
26861|     15|  size_t len = (dst_len2 < src_len) ? dst_len2 : src_len;
  ------------------
  |  Branch (26861:16): [True: 6, False: 9]
  ------------------
26862|     15|  uint8_t* d = dst_ptr;
26863|     15|  const uint8_t* s = src_ptr;
26864|     15|  size_t n = len;
26865|       |
26866|       |  // TODO: unroll.
26867|       |
26868|    468|  while (n >= 1) {
  ------------------
  |  Branch (26868:10): [True: 453, False: 15]
  ------------------
26869|    453|    uint32_t d0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(
26870|    453|        wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2)));
26871|    453|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
26872|    453|                                                          ((size_t)s[0] * 4));
26873|    453|    wuffs_base__poke_u16le__no_bounds_check(
26874|    453|        d + (0 * 2),
26875|    453|        wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(
26876|    453|            wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)));
26877|       |
26878|    453|    s += 1 * 1;
26879|    453|    d += 1 * 2;
26880|    453|    n -= 1;
26881|    453|  }
26882|       |
26883|     15|  return len;
26884|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src:
28446|     28|    size_t src_len) {
28447|     28|  size_t dst_len4 = dst_len / 4;
28448|     28|  size_t src_len4 = src_len / 4;
28449|     28|  size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
  ------------------
  |  Branch (28449:16): [True: 7, False: 21]
  ------------------
28450|     28|  uint8_t* d = dst_ptr;
28451|     28|  const uint8_t* s = src_ptr;
28452|     28|  size_t n = len;
28453|       |
28454|       |  // TODO: unroll.
28455|       |
28456|  2.05k|  while (n >= 1) {
  ------------------
  |  Branch (28456:10): [True: 2.02k, False: 28]
  ------------------
28457|  2.02k|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
28458|  2.02k|    wuffs_base__poke_u32le__no_bounds_check(
28459|  2.02k|        d + (0 * 4),
28460|  2.02k|        wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0));
28461|       |
28462|  2.02k|    s += 1 * 4;
28463|  2.02k|    d += 1 * 4;
28464|  2.02k|    n -= 1;
28465|  2.02k|  }
28466|       |
28467|     28|  return len;
28468|     28|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__index__src:
29622|     21|                                            size_t src_len) {
29623|     21|  if (dst_palette_len !=
  ------------------
  |  Branch (29623:7): [True: 0, False: 21]
  ------------------
29624|     21|      WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     21|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
29625|      0|    return 0;
29626|      0|  }
29627|     21|  size_t dst_len3 = dst_len / 3;
29628|     21|  size_t len = (dst_len3 < src_len) ? dst_len3 : src_len;
  ------------------
  |  Branch (29628:16): [True: 8, False: 13]
  ------------------
29629|     21|  uint8_t* d = dst_ptr;
29630|     21|  const uint8_t* s = src_ptr;
29631|     21|  size_t n = len;
29632|       |
29633|     21|  const size_t loop_unroll_count = 4;
29634|       |
29635|       |  // The comparison in the while condition is ">", not ">=", because with
29636|       |  // ">=", the last 4-byte store could write past the end of the dst slice.
29637|       |  //
29638|       |  // Each 4-byte store writes one too many bytes, but a subsequent store
29639|       |  // will overwrite that with the correct byte. There is always another
29640|       |  // store, whether a 4-byte store in this loop or a 1-byte store in the
29641|       |  // next loop.
29642|    171|  while (n > loop_unroll_count) {
  ------------------
  |  Branch (29642:10): [True: 150, False: 21]
  ------------------
29643|    150|    wuffs_base__poke_u32le__no_bounds_check(
29644|    150|        d + (0 * 3), wuffs_base__peek_u32le__no_bounds_check(
29645|    150|                         dst_palette_ptr + ((size_t)s[0] * 4)));
29646|    150|    wuffs_base__poke_u32le__no_bounds_check(
29647|    150|        d + (1 * 3), wuffs_base__peek_u32le__no_bounds_check(
29648|    150|                         dst_palette_ptr + ((size_t)s[1] * 4)));
29649|    150|    wuffs_base__poke_u32le__no_bounds_check(
29650|    150|        d + (2 * 3), wuffs_base__peek_u32le__no_bounds_check(
29651|    150|                         dst_palette_ptr + ((size_t)s[2] * 4)));
29652|    150|    wuffs_base__poke_u32le__no_bounds_check(
29653|    150|        d + (3 * 3), wuffs_base__peek_u32le__no_bounds_check(
29654|    150|                         dst_palette_ptr + ((size_t)s[3] * 4)));
29655|       |
29656|    150|    s += loop_unroll_count * 1;
29657|    150|    d += loop_unroll_count * 3;
29658|    150|    n -= loop_unroll_count;
29659|    150|  }
29660|       |
29661|     67|  while (n >= 1) {
  ------------------
  |  Branch (29661:10): [True: 46, False: 21]
  ------------------
29662|     46|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
29663|     46|                                                          ((size_t)s[0] * 4));
29664|     46|    wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);
29665|       |
29666|     46|    s += 1 * 1;
29667|     46|    d += 1 * 3;
29668|     46|    n -= 1;
29669|     46|  }
29670|       |
29671|     21|  return len;
29672|     21|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__index_bgra_nonpremul__src_over:
29681|     21|    size_t src_len) {
29682|     21|  if (dst_palette_len !=
  ------------------
  |  Branch (29682:7): [True: 0, False: 21]
  ------------------
29683|     21|      WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     21|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
29684|      0|    return 0;
29685|      0|  }
29686|     21|  size_t dst_len3 = dst_len / 3;
29687|     21|  size_t len = (dst_len3 < src_len) ? dst_len3 : src_len;
  ------------------
  |  Branch (29687:16): [True: 11, False: 10]
  ------------------
29688|     21|  uint8_t* d = dst_ptr;
29689|     21|  const uint8_t* s = src_ptr;
29690|     21|  size_t n = len;
29691|       |
29692|       |  // TODO: unroll.
29693|       |
29694|    524|  while (n >= 1) {
  ------------------
  |  Branch (29694:10): [True: 503, False: 21]
  ------------------
29695|    503|    uint32_t d0 =
29696|    503|        wuffs_base__peek_u24le__no_bounds_check(d + (0 * 3)) | 0xFF000000;
29697|    503|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
29698|    503|                                                          ((size_t)s[0] * 4));
29699|    503|    wuffs_base__poke_u24le__no_bounds_check(
29700|    503|        d + (0 * 3),
29701|    503|        wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0));
29702|       |
29703|    503|    s += 1 * 1;
29704|    503|    d += 1 * 3;
29705|    503|    n -= 1;
29706|    503|  }
29707|       |
29708|     21|  return len;
29709|     21|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__index__src:
29961|     26|                                             size_t src_len) {
29962|     26|  if (dst_palette_len !=
  ------------------
  |  Branch (29962:7): [True: 0, False: 26]
  ------------------
29963|     26|      WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     26|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
29964|      0|    return 0;
29965|      0|  }
29966|     26|  size_t dst_len4 = dst_len / 4;
29967|     26|  size_t len = (dst_len4 < src_len) ? dst_len4 : src_len;
  ------------------
  |  Branch (29967:16): [True: 18, False: 8]
  ------------------
29968|     26|  uint8_t* d = dst_ptr;
29969|     26|  const uint8_t* s = src_ptr;
29970|     26|  size_t n = len;
29971|       |
29972|     26|  const size_t loop_unroll_count = 4;
29973|       |
29974|    157|  while (n >= loop_unroll_count) {
  ------------------
  |  Branch (29974:10): [True: 131, False: 26]
  ------------------
29975|    131|    wuffs_base__poke_u32le__no_bounds_check(
29976|    131|        d + (0 * 4), wuffs_base__peek_u32le__no_bounds_check(
29977|    131|                         dst_palette_ptr + ((size_t)s[0] * 4)));
29978|    131|    wuffs_base__poke_u32le__no_bounds_check(
29979|    131|        d + (1 * 4), wuffs_base__peek_u32le__no_bounds_check(
29980|    131|                         dst_palette_ptr + ((size_t)s[1] * 4)));
29981|    131|    wuffs_base__poke_u32le__no_bounds_check(
29982|    131|        d + (2 * 4), wuffs_base__peek_u32le__no_bounds_check(
29983|    131|                         dst_palette_ptr + ((size_t)s[2] * 4)));
29984|    131|    wuffs_base__poke_u32le__no_bounds_check(
29985|    131|        d + (3 * 4), wuffs_base__peek_u32le__no_bounds_check(
29986|    131|                         dst_palette_ptr + ((size_t)s[3] * 4)));
29987|       |
29988|    131|    s += loop_unroll_count * 1;
29989|    131|    d += loop_unroll_count * 4;
29990|    131|    n -= loop_unroll_count;
29991|    131|  }
29992|       |
29993|     56|  while (n >= 1) {
  ------------------
  |  Branch (29993:10): [True: 30, False: 26]
  ------------------
29994|     30|    wuffs_base__poke_u32le__no_bounds_check(
29995|     30|        d + (0 * 4), wuffs_base__peek_u32le__no_bounds_check(
29996|     30|                         dst_palette_ptr + ((size_t)s[0] * 4)));
29997|       |
29998|     30|    s += 1 * 1;
29999|     30|    d += 1 * 4;
30000|     30|    n -= 1;
30001|     30|  }
30002|       |
30003|     26|  return len;
30004|     26|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__index_bgra_nonpremul__src_over:
27824|     26|    size_t src_len) {
27825|     26|  if (dst_palette_len !=
  ------------------
  |  Branch (27825:7): [True: 0, False: 26]
  ------------------
27826|     26|      WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     26|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
27827|      0|    return 0;
27828|      0|  }
27829|     26|  size_t dst_len4 = dst_len / 4;
27830|     26|  size_t len = (dst_len4 < src_len) ? dst_len4 : src_len;
  ------------------
  |  Branch (27830:16): [True: 16, False: 10]
  ------------------
27831|     26|  uint8_t* d = dst_ptr;
27832|     26|  const uint8_t* s = src_ptr;
27833|     26|  size_t n = len;
27834|       |
27835|       |  // TODO: unroll.
27836|       |
27837|    437|  while (n >= 1) {
  ------------------
  |  Branch (27837:10): [True: 411, False: 26]
  ------------------
27838|    411|    uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));
27839|    411|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
27840|    411|                                                          ((size_t)s[0] * 4));
27841|    411|    wuffs_base__poke_u32le__no_bounds_check(
27842|    411|        d + (0 * 4),
27843|    411|        wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0));
27844|       |
27845|    411|    s += 1 * 1;
27846|    411|    d += 1 * 4;
27847|    411|    n -= 1;
27848|    411|  }
27849|       |
27850|     26|  return len;
27851|     26|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__index__src:
30204|     16|                                                 size_t src_len) {
30205|     16|  if (dst_palette_len !=
  ------------------
  |  Branch (30205:7): [True: 0, False: 16]
  ------------------
30206|     16|      WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     16|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
30207|      0|    return 0;
30208|      0|  }
30209|     16|  size_t dst_len8 = dst_len / 8;
30210|     16|  size_t len = (dst_len8 < src_len) ? dst_len8 : src_len;
  ------------------
  |  Branch (30210:16): [True: 7, False: 9]
  ------------------
30211|     16|  uint8_t* d = dst_ptr;
30212|     16|  const uint8_t* s = src_ptr;
30213|     16|  size_t n = len;
30214|       |
30215|    228|  while (n >= 1) {
  ------------------
  |  Branch (30215:10): [True: 212, False: 16]
  ------------------
30216|    212|    wuffs_base__poke_u64le__no_bounds_check(
30217|    212|        d + (0 * 8), wuffs_base__color_u32__as__color_u64(
30218|    212|                         wuffs_base__peek_u32le__no_bounds_check(
30219|    212|                             dst_palette_ptr + ((size_t)s[0] * 4))));
30220|       |
30221|    212|    s += 1 * 1;
30222|    212|    d += 1 * 8;
30223|    212|    n -= 1;
30224|    212|  }
30225|       |
30226|     16|  return len;
30227|     16|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__index_bgra_nonpremul__src_over:
28225|     43|    size_t src_len) {
28226|     43|  if (dst_palette_len !=
  ------------------
  |  Branch (28226:7): [True: 0, False: 43]
  ------------------
28227|     43|      WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     43|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
28228|      0|    return 0;
28229|      0|  }
28230|     43|  size_t dst_len8 = dst_len / 8;
28231|     43|  size_t len = (dst_len8 < src_len) ? dst_len8 : src_len;
  ------------------
  |  Branch (28231:16): [True: 29, False: 14]
  ------------------
28232|     43|  uint8_t* d = dst_ptr;
28233|     43|  const uint8_t* s = src_ptr;
28234|     43|  size_t n = len;
28235|       |
28236|    306|  while (n >= 1) {
  ------------------
  |  Branch (28236:10): [True: 263, False: 43]
  ------------------
28237|    263|    uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));
28238|    263|    uint64_t s0 = wuffs_base__color_u32__as__color_u64(
28239|    263|        wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
28240|    263|                                                ((size_t)s[0] * 4)));
28241|    263|    wuffs_base__poke_u64le__no_bounds_check(
28242|    263|        d + (0 * 8),
28243|    263|        wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0));
28244|       |
28245|    263|    s += 1 * 1;
28246|    263|    d += 1 * 8;
28247|    263|    n -= 1;
28248|    263|  }
28249|       |
28250|     43|  return len;
28251|     43|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__index_bgra_nonpremul__src_over:
28670|     12|    size_t src_len) {
28671|     12|  if (dst_palette_len !=
  ------------------
  |  Branch (28671:7): [True: 0, False: 12]
  ------------------
28672|     12|      WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     12|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
28673|      0|    return 0;
28674|      0|  }
28675|     12|  size_t dst_len4 = dst_len / 4;
28676|     12|  size_t len = (dst_len4 < src_len) ? dst_len4 : src_len;
  ------------------
  |  Branch (28676:16): [True: 9, False: 3]
  ------------------
28677|     12|  uint8_t* d = dst_ptr;
28678|     12|  const uint8_t* s = src_ptr;
28679|     12|  size_t n = len;
28680|       |
28681|       |  // TODO: unroll.
28682|       |
28683|    173|  while (n >= 1) {
  ------------------
  |  Branch (28683:10): [True: 161, False: 12]
  ------------------
28684|    161|    uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));
28685|    161|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
28686|    161|                                                          ((size_t)s[0] * 4));
28687|    161|    wuffs_base__poke_u32le__no_bounds_check(
28688|    161|        d + (0 * 4),
28689|    161|        wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0));
28690|       |
28691|    161|    s += 1 * 1;
28692|    161|    d += 1 * 4;
28693|    161|    n -= 1;
28694|    161|  }
28695|       |
28696|     12|  return len;
28697|     12|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src:
28706|     29|    size_t src_len) {
28707|     29|  size_t dst_len4 = dst_len / 4;
28708|     29|  size_t src_len4 = src_len / 4;
28709|     29|  size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
  ------------------
  |  Branch (28709:16): [True: 6, False: 23]
  ------------------
28710|     29|  uint8_t* d = dst_ptr;
28711|     29|  const uint8_t* s = src_ptr;
28712|     29|  size_t n = len;
28713|       |
28714|       |  // TODO: unroll.
28715|       |
28716|  3.14k|  while (n >= 1) {
  ------------------
  |  Branch (28716:10): [True: 3.11k, False: 29]
  ------------------
28717|  3.11k|    uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr(
28718|  3.11k|        wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
28719|  3.11k|    wuffs_base__poke_u32le__no_bounds_check(
28720|  3.11k|        d + (0 * 4),
28721|  3.11k|        wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0));
28722|       |
28723|  3.11k|    s += 1 * 4;
28724|  3.11k|    d += 1 * 4;
28725|  3.11k|    n -= 1;
28726|  3.11k|  }
28727|       |
28728|     29|  return len;
28729|     29|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_swap_rgbx_bgrx:
25865|    104|                                           size_t src_len) {
25866|    104|  size_t len = (dst_len < src_len ? dst_len : src_len) / 4;
  ------------------
  |  Branch (25866:17): [True: 0, False: 104]
  ------------------
25867|    104|  uint8_t* d = dst_ptr;
25868|    104|  const uint8_t* s = src_ptr;
25869|       |
25870|    104|  size_t n = len;
25871|  26.7k|  while (n--) {
  ------------------
  |  Branch (25871:10): [True: 26.6k, False: 104]
  ------------------
25872|  26.6k|    uint8_t s0 = s[0];
25873|  26.6k|    uint8_t s1 = s[1];
25874|  26.6k|    uint8_t s2 = s[2];
25875|  26.6k|    uint8_t s3 = s[3];
25876|  26.6k|    d[0] = s2;
25877|  26.6k|    d[1] = s1;
25878|  26.6k|    d[2] = s0;
25879|  26.6k|    d[3] = s3;
25880|  26.6k|    s += 4;
25881|  26.6k|    d += 4;
25882|  26.6k|  }
25883|    104|  return len;
25884|    104|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__indexed__bgra_binary:
31564|    341|    wuffs_base__pixel_blend blend) {
31565|    341|  switch (dst_pixfmt.repr) {
  ------------------
  |  Branch (31565:11): [True: 326, False: 15]
  ------------------
31566|     35|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|     35|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (31566:5): [True: 35, False: 306]
  ------------------
31567|     35|      if (wuffs_private_impl__swizzle_squash_align4_y_8888(
  ------------------
  |  Branch (31567:11): [True: 0, False: 35]
  ------------------
31568|     35|              dst_palette.ptr, dst_palette.len, src_palette.ptr,
31569|     35|              src_palette.len, false) !=
31570|     35|          (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
  ------------------
  |  | 4900|     35|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31571|      0|        return NULL;
31572|      0|      }
31573|     35|      switch (blend) {
  ------------------
  |  Branch (31573:15): [True: 35, False: 0]
  ------------------
31574|      3|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      3|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31574:9): [True: 3, False: 32]
  ------------------
31575|      3|          return wuffs_private_impl__swizzle_y__index__src;
31576|     32|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     32|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31576:9): [True: 32, False: 3]
  ------------------
31577|     32|          return wuffs_private_impl__swizzle_y__index_binary_alpha__src_over;
31578|     35|      }
31579|      0|      return NULL;
31580|       |
31581|      3|    case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:
  ------------------
  |  | 4958|      3|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL   0x81040008
  ------------------
  |  Branch (31581:5): [True: 3, False: 338]
  ------------------
31582|      3|    case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:
  ------------------
  |  | 4959|      3|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL      0x82040008
  ------------------
  |  Branch (31582:5): [True: 0, False: 341]
  ------------------
31583|     14|    case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:
  ------------------
  |  | 4960|     14|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY      0x83040008
  ------------------
  |  Branch (31583:5): [True: 11, False: 330]
  ------------------
31584|     14|      if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette,
  ------------------
  |  Branch (31584:11): [True: 0, False: 14]
  ------------------
31585|     14|                                                        src_palette) !=
31586|     14|          WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     14|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31587|      0|        return NULL;
31588|      0|      }
31589|     14|      switch (blend) {
  ------------------
  |  Branch (31589:15): [True: 7, False: 7]
  ------------------
31590|      7|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      7|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31590:9): [True: 7, False: 7]
  ------------------
31591|      7|          return wuffs_private_impl__swizzle_copy_1_1;
31592|     14|      }
31593|      7|      return NULL;
31594|       |
31595|     33|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|     33|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (31595:5): [True: 33, False: 308]
  ------------------
31596|     33|      if (wuffs_private_impl__swizzle_squash_align4_bgr_565_8888(
  ------------------
  |  Branch (31596:11): [True: 0, False: 33]
  ------------------
31597|     33|              dst_palette.ptr, dst_palette.len, src_palette.ptr,
31598|     33|              src_palette.len, false) !=
31599|     33|          (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
  ------------------
  |  | 4900|     33|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31600|      0|        return NULL;
31601|      0|      }
31602|     33|      switch (blend) {
  ------------------
  |  Branch (31602:15): [True: 33, False: 0]
  ------------------
31603|     10|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31603:9): [True: 10, False: 23]
  ------------------
31604|     10|          return wuffs_private_impl__swizzle_bgr_565__index__src;
31605|     23|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     23|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31605:9): [True: 23, False: 10]
  ------------------
31606|     23|          return wuffs_private_impl__swizzle_bgr_565__index_binary_alpha__src_over;
31607|     33|      }
31608|      0|      return NULL;
31609|       |
31610|     67|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|     67|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (31610:5): [True: 67, False: 274]
  ------------------
31611|     67|      if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette,
  ------------------
  |  Branch (31611:11): [True: 0, False: 67]
  ------------------
31612|     67|                                                        src_palette) !=
31613|     67|          WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     67|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31614|      0|        return NULL;
31615|      0|      }
31616|     67|      switch (blend) {
  ------------------
  |  Branch (31616:15): [True: 67, False: 0]
  ------------------
31617|      9|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      9|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31617:9): [True: 9, False: 58]
  ------------------
31618|      9|          return wuffs_private_impl__swizzle_xxx__index__src;
31619|     58|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     58|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31619:9): [True: 58, False: 9]
  ------------------
31620|     58|          return wuffs_private_impl__swizzle_xxx__index_binary_alpha__src_over;
31621|     67|      }
31622|      0|      return NULL;
31623|       |
31624|     24|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|     24|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (31624:5): [True: 24, False: 317]
  ------------------
31625|     52|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|     52|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (31625:5): [True: 28, False: 313]
  ------------------
31626|     52|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
  ------------------
  |  | 4968|     52|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY               0x83008888
  ------------------
  |  Branch (31626:5): [True: 0, False: 341]
  ------------------
31627|     52|      if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette,
  ------------------
  |  Branch (31627:11): [True: 0, False: 52]
  ------------------
31628|     52|                                                        src_palette) !=
31629|     52|          WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     52|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31630|      0|        return NULL;
31631|      0|      }
31632|     52|      switch (blend) {
  ------------------
  |  Branch (31632:15): [True: 52, False: 0]
  ------------------
31633|      3|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      3|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31633:9): [True: 3, False: 49]
  ------------------
31634|      3|          return wuffs_private_impl__swizzle_xxxx__index__src;
31635|     49|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     49|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31635:9): [True: 49, False: 3]
  ------------------
31636|     49|          return wuffs_private_impl__swizzle_xxxx__index_binary_alpha__src_over;
31637|     52|      }
31638|      0|      return NULL;
31639|       |
31640|     19|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|     19|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (31640:5): [True: 19, False: 322]
  ------------------
31641|     44|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:
  ------------------
  |  | 4967|     44|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE        0x8200BBBB
  ------------------
  |  Branch (31641:5): [True: 25, False: 316]
  ------------------
31642|     44|      if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette,
  ------------------
  |  Branch (31642:11): [True: 0, False: 44]
  ------------------
31643|     44|                                                        src_palette) !=
31644|     44|          WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     44|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31645|      0|        return NULL;
31646|      0|      }
31647|     44|      switch (blend) {
  ------------------
  |  Branch (31647:15): [True: 44, False: 0]
  ------------------
31648|     11|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     11|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31648:9): [True: 11, False: 33]
  ------------------
31649|     11|          return wuffs_private_impl__swizzle_xxxxxxxx__index__src;
31650|     33|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     33|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31650:9): [True: 33, False: 11]
  ------------------
31651|     33|          return wuffs_private_impl__swizzle_xxxxxxxx__index_binary_alpha__src_over;
31652|     44|      }
31653|      0|      return NULL;
31654|       |
31655|     35|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|     35|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (31655:5): [True: 35, False: 306]
  ------------------
31656|     35|      if (wuffs_private_impl__swizzle_swap_rgbx_bgrx(
  ------------------
  |  Branch (31656:11): [True: 0, False: 35]
  ------------------
31657|     35|              dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,
31658|     35|              src_palette.len) !=
31659|     35|          (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
  ------------------
  |  | 4900|     35|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31660|      0|        return NULL;
31661|      0|      }
31662|     35|      switch (blend) {
  ------------------
  |  Branch (31662:15): [True: 35, False: 0]
  ------------------
31663|      1|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      1|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31663:9): [True: 1, False: 34]
  ------------------
31664|      1|          return wuffs_private_impl__swizzle_xxx__index__src;
31665|     34|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     34|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31665:9): [True: 34, False: 1]
  ------------------
31666|     34|          return wuffs_private_impl__swizzle_xxx__index_binary_alpha__src_over;
31667|     35|      }
31668|      0|      return NULL;
31669|       |
31670|     21|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|     21|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (31670:5): [True: 21, False: 320]
  ------------------
31671|     46|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|     46|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (31671:5): [True: 25, False: 316]
  ------------------
31672|     46|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
  ------------------
  |  | 4976|     46|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY               0xA3008888
  ------------------
  |  Branch (31672:5): [True: 0, False: 341]
  ------------------
31673|     46|      if (wuffs_private_impl__swizzle_swap_rgbx_bgrx(
  ------------------
  |  Branch (31673:11): [True: 0, False: 46]
  ------------------
31674|     46|              dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,
31675|     46|              src_palette.len) !=
31676|     46|          (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
  ------------------
  |  | 4900|     46|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31677|      0|        return NULL;
31678|      0|      }
31679|     46|      switch (blend) {
  ------------------
  |  Branch (31679:15): [True: 46, False: 0]
  ------------------
31680|      5|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      5|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31680:9): [True: 5, False: 41]
  ------------------
31681|      5|          return wuffs_private_impl__swizzle_xxxx__index__src;
31682|     41|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     41|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31682:9): [True: 41, False: 5]
  ------------------
31683|     41|          return wuffs_private_impl__swizzle_xxxx__index_binary_alpha__src_over;
31684|     46|      }
31685|      0|      return NULL;
31686|    341|  }
31687|     15|  return NULL;
31688|    341|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__index_binary_alpha__src_over:
31036|     32|    size_t src_len) {
31037|     32|  if (dst_palette_len !=
  ------------------
  |  Branch (31037:7): [True: 0, False: 32]
  ------------------
31038|     32|      WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     32|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
31039|      0|    return 0;
31040|      0|  }
31041|     32|  size_t len = (dst_len < src_len) ? dst_len : src_len;
  ------------------
  |  Branch (31041:16): [True: 6, False: 26]
  ------------------
31042|     32|  uint8_t* d = dst_ptr;
31043|     32|  const uint8_t* s = src_ptr;
31044|     32|  size_t n = len;
31045|       |
31046|       |  // TODO: unroll.
31047|       |
31048|  2.24k|  while (n >= 1) {
  ------------------
  |  Branch (31048:10): [True: 2.21k, False: 32]
  ------------------
31049|  2.21k|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
31050|  2.21k|                                                          ((size_t)s[0] * 4));
31051|  2.21k|    if (s0) {
  ------------------
  |  Branch (31051:9): [True: 1.85k, False: 358]
  ------------------
31052|  1.85k|      d[0] = (uint8_t)s0;
31053|  1.85k|    }
31054|       |
31055|  2.21k|    s += 1 * 1;
31056|  2.21k|    d += 1 * 1;
31057|  2.21k|    n -= 1;
31058|  2.21k|  }
31059|       |
31060|     32|  return len;
31061|     32|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__index_binary_alpha__src_over:
26893|     23|    size_t src_len) {
26894|     23|  if (dst_palette_len !=
  ------------------
  |  Branch (26894:7): [True: 0, False: 23]
  ------------------
26895|     23|      WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     23|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
26896|      0|    return 0;
26897|      0|  }
26898|     23|  size_t dst_len2 = dst_len / 2;
26899|     23|  size_t len = (dst_len2 < src_len) ? dst_len2 : src_len;
  ------------------
  |  Branch (26899:16): [True: 8, False: 15]
  ------------------
26900|     23|  uint8_t* d = dst_ptr;
26901|     23|  const uint8_t* s = src_ptr;
26902|     23|  size_t n = len;
26903|       |
26904|       |  // TODO: unroll.
26905|       |
26906|    946|  while (n >= 1) {
  ------------------
  |  Branch (26906:10): [True: 923, False: 23]
  ------------------
26907|    923|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
26908|    923|                                                          ((size_t)s[0] * 4));
26909|    923|    if (s0) {
  ------------------
  |  Branch (26909:9): [True: 831, False: 92]
  ------------------
26910|    831|      wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)s0);
26911|    831|    }
26912|       |
26913|    923|    s += 1 * 1;
26914|    923|    d += 1 * 2;
26915|    923|    n -= 1;
26916|    923|  }
26917|       |
26918|     23|  return len;
26919|     23|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__index_binary_alpha__src_over:
29718|     92|    size_t src_len) {
29719|     92|  if (dst_palette_len !=
  ------------------
  |  Branch (29719:7): [True: 0, False: 92]
  ------------------
29720|     92|      WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     92|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
29721|      0|    return 0;
29722|      0|  }
29723|     92|  size_t dst_len3 = dst_len / 3;
29724|     92|  size_t len = (dst_len3 < src_len) ? dst_len3 : src_len;
  ------------------
  |  Branch (29724:16): [True: 63, False: 29]
  ------------------
29725|     92|  uint8_t* d = dst_ptr;
29726|     92|  const uint8_t* s = src_ptr;
29727|     92|  size_t n = len;
29728|       |
29729|     92|  const size_t loop_unroll_count = 4;
29730|       |
29731|  1.01k|  while (n >= loop_unroll_count) {
  ------------------
  |  Branch (29731:10): [True: 920, False: 92]
  ------------------
29732|    920|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
29733|    920|                                                          ((size_t)s[0] * 4));
29734|    920|    if (s0) {
  ------------------
  |  Branch (29734:9): [True: 754, False: 166]
  ------------------
29735|    754|      wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);
29736|    754|    }
29737|    920|    uint32_t s1 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
29738|    920|                                                          ((size_t)s[1] * 4));
29739|    920|    if (s1) {
  ------------------
  |  Branch (29739:9): [True: 764, False: 156]
  ------------------
29740|    764|      wuffs_base__poke_u24le__no_bounds_check(d + (1 * 3), s1);
29741|    764|    }
29742|    920|    uint32_t s2 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
29743|    920|                                                          ((size_t)s[2] * 4));
29744|    920|    if (s2) {
  ------------------
  |  Branch (29744:9): [True: 763, False: 157]
  ------------------
29745|    763|      wuffs_base__poke_u24le__no_bounds_check(d + (2 * 3), s2);
29746|    763|    }
29747|    920|    uint32_t s3 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
29748|    920|                                                          ((size_t)s[3] * 4));
29749|    920|    if (s3) {
  ------------------
  |  Branch (29749:9): [True: 743, False: 177]
  ------------------
29750|    743|      wuffs_base__poke_u24le__no_bounds_check(d + (3 * 3), s3);
29751|    743|    }
29752|       |
29753|    920|    s += loop_unroll_count * 1;
29754|    920|    d += loop_unroll_count * 3;
29755|    920|    n -= loop_unroll_count;
29756|    920|  }
29757|       |
29758|    246|  while (n >= 1) {
  ------------------
  |  Branch (29758:10): [True: 154, False: 92]
  ------------------
29759|    154|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
29760|    154|                                                          ((size_t)s[0] * 4));
29761|    154|    if (s0) {
  ------------------
  |  Branch (29761:9): [True: 139, False: 15]
  ------------------
29762|    139|      wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);
29763|    139|    }
29764|       |
29765|    154|    s += 1 * 1;
29766|    154|    d += 1 * 3;
29767|    154|    n -= 1;
29768|    154|  }
29769|       |
29770|     92|  return len;
29771|     92|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxx__index_binary_alpha__src_over:
30013|     90|    size_t src_len) {
30014|     90|  if (dst_palette_len !=
  ------------------
  |  Branch (30014:7): [True: 0, False: 90]
  ------------------
30015|     90|      WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     90|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
30016|      0|    return 0;
30017|      0|  }
30018|     90|  size_t dst_len4 = dst_len / 4;
30019|     90|  size_t len = (dst_len4 < src_len) ? dst_len4 : src_len;
  ------------------
  |  Branch (30019:16): [True: 64, False: 26]
  ------------------
30020|     90|  uint8_t* d = dst_ptr;
30021|     90|  const uint8_t* s = src_ptr;
30022|     90|  size_t n = len;
30023|       |
30024|     90|  const size_t loop_unroll_count = 4;
30025|       |
30026|    772|  while (n >= loop_unroll_count) {
  ------------------
  |  Branch (30026:10): [True: 682, False: 90]
  ------------------
30027|    682|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
30028|    682|                                                          ((size_t)s[0] * 4));
30029|    682|    if (s0) {
  ------------------
  |  Branch (30029:9): [True: 558, False: 124]
  ------------------
30030|    558|      wuffs_base__poke_u32le__no_bounds_check(d + (0 * 4), s0);
30031|    558|    }
30032|    682|    uint32_t s1 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
30033|    682|                                                          ((size_t)s[1] * 4));
30034|    682|    if (s1) {
  ------------------
  |  Branch (30034:9): [True: 558, False: 124]
  ------------------
30035|    558|      wuffs_base__poke_u32le__no_bounds_check(d + (1 * 4), s1);
30036|    558|    }
30037|    682|    uint32_t s2 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
30038|    682|                                                          ((size_t)s[2] * 4));
30039|    682|    if (s2) {
  ------------------
  |  Branch (30039:9): [True: 535, False: 147]
  ------------------
30040|    535|      wuffs_base__poke_u32le__no_bounds_check(d + (2 * 4), s2);
30041|    535|    }
30042|    682|    uint32_t s3 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
30043|    682|                                                          ((size_t)s[3] * 4));
30044|    682|    if (s3) {
  ------------------
  |  Branch (30044:9): [True: 525, False: 157]
  ------------------
30045|    525|      wuffs_base__poke_u32le__no_bounds_check(d + (3 * 4), s3);
30046|    525|    }
30047|       |
30048|    682|    s += loop_unroll_count * 1;
30049|    682|    d += loop_unroll_count * 4;
30050|    682|    n -= loop_unroll_count;
30051|    682|  }
30052|       |
30053|    238|  while (n >= 1) {
  ------------------
  |  Branch (30053:10): [True: 148, False: 90]
  ------------------
30054|    148|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
30055|    148|                                                          ((size_t)s[0] * 4));
30056|    148|    if (s0) {
  ------------------
  |  Branch (30056:9): [True: 125, False: 23]
  ------------------
30057|    125|      wuffs_base__poke_u32le__no_bounds_check(d + (0 * 4), s0);
30058|    125|    }
30059|       |
30060|    148|    s += 1 * 1;
30061|    148|    d += 1 * 4;
30062|    148|    n -= 1;
30063|    148|  }
30064|       |
30065|     90|  return len;
30066|     90|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxxxxxxx__index_binary_alpha__src_over:
30236|     33|    size_t src_len) {
30237|     33|  if (dst_palette_len !=
  ------------------
  |  Branch (30237:7): [True: 0, False: 33]
  ------------------
30238|     33|      WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|     33|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
30239|      0|    return 0;
30240|      0|  }
30241|     33|  size_t dst_len8 = dst_len / 8;
30242|     33|  size_t len = (dst_len8 < src_len) ? dst_len8 : src_len;
  ------------------
  |  Branch (30242:16): [True: 25, False: 8]
  ------------------
30243|     33|  uint8_t* d = dst_ptr;
30244|     33|  const uint8_t* s = src_ptr;
30245|     33|  size_t n = len;
30246|       |
30247|    510|  while (n >= 1) {
  ------------------
  |  Branch (30247:10): [True: 477, False: 33]
  ------------------
30248|    477|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
30249|    477|                                                          ((size_t)s[0] * 4));
30250|    477|    if (s0) {
  ------------------
  |  Branch (30250:9): [True: 395, False: 82]
  ------------------
30251|    395|      wuffs_base__poke_u64le__no_bounds_check(
30252|    395|          d + (0 * 8), wuffs_base__color_u32__as__color_u64(s0));
30253|    395|    }
30254|       |
30255|    477|    s += 1 * 1;
30256|    477|    d += 1 * 8;
30257|    477|    n -= 1;
30258|    477|  }
30259|       |
30260|     33|  return len;
30261|     33|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgr_565:
31696|    130|    wuffs_base__pixel_blend blend) {
31697|    130|  switch (dst_pixfmt.repr) {
  ------------------
  |  Branch (31697:11): [True: 112, False: 18]
  ------------------
31698|     19|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|     19|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (31698:5): [True: 19, False: 111]
  ------------------
31699|     19|      return wuffs_private_impl__swizzle_y__bgr_565;
31700|       |
31701|      5|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|      5|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (31701:5): [True: 5, False: 125]
  ------------------
31702|      5|      return wuffs_private_impl__swizzle_copy_2_2;
31703|       |
31704|     15|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|     15|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (31704:5): [True: 15, False: 115]
  ------------------
31705|     15|      return wuffs_private_impl__swizzle_bgr__bgr_565;
31706|       |
31707|      4|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|      4|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (31707:5): [True: 4, False: 126]
  ------------------
31708|     11|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|     11|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (31708:5): [True: 7, False: 123]
  ------------------
31709|     11|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
  ------------------
  |  | 4968|     11|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY               0x83008888
  ------------------
  |  Branch (31709:5): [True: 0, False: 130]
  ------------------
31710|     21|    case WUFFS_BASE__PIXEL_FORMAT__BGRX:
  ------------------
  |  | 4969|     21|#define WUFFS_BASE__PIXEL_FORMAT__BGRX                      0x90008888
  ------------------
  |  Branch (31710:5): [True: 10, False: 120]
  ------------------
31711|     21|      return wuffs_private_impl__swizzle_bgrw__bgr_565;
31712|       |
31713|      2|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|      2|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (31713:5): [True: 2, False: 128]
  ------------------
31714|     15|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:
  ------------------
  |  | 4967|     15|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE        0x8200BBBB
  ------------------
  |  Branch (31714:5): [True: 13, False: 117]
  ------------------
31715|     15|      return wuffs_private_impl__swizzle_bgrw_4x16le__bgr_565;
31716|       |
31717|     13|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|     13|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (31717:5): [True: 13, False: 117]
  ------------------
31718|     13|      return wuffs_private_impl__swizzle_rgb__bgr_565;
31719|       |
31720|      6|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|      6|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (31720:5): [True: 6, False: 124]
  ------------------
31721|     24|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|     24|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (31721:5): [True: 18, False: 112]
  ------------------
31722|     24|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
  ------------------
  |  | 4976|     24|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY               0xA3008888
  ------------------
  |  Branch (31722:5): [True: 0, False: 130]
  ------------------
31723|     24|    case WUFFS_BASE__PIXEL_FORMAT__RGBX:
  ------------------
  |  | 4977|     24|#define WUFFS_BASE__PIXEL_FORMAT__RGBX                      0xB0008888
  ------------------
  |  Branch (31723:5): [True: 0, False: 130]
  ------------------
31724|     24|      return wuffs_private_impl__swizzle_rgbw__bgr_565;
31725|    130|  }
31726|     18|  return NULL;
31727|    130|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgr_565:
30380|     19|                                       size_t src_len) {
30381|     19|  size_t src_len2 = src_len / 2;
30382|     19|  size_t len = (dst_len < src_len2) ? dst_len : src_len2;
  ------------------
  |  Branch (30382:16): [True: 3, False: 16]
  ------------------
30383|     19|  uint8_t* d = dst_ptr;
30384|     19|  const uint8_t* s = src_ptr;
30385|     19|  size_t n = len;
30386|       |
30387|       |  // TODO: unroll.
30388|       |
30389|    726|  while (n >= 1) {
  ------------------
  |  Branch (30389:10): [True: 707, False: 19]
  ------------------
30390|    707|    uint32_t s0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(
30391|    707|        wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)));
30392|    707|    d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0);
30393|       |
30394|    707|    s += 1 * 2;
30395|    707|    d += 1 * 1;
30396|    707|    n -= 1;
30397|    707|  }
30398|       |
30399|     19|  return len;
30400|     19|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgr_565:
26929|     15|                                         size_t src_len) {
26930|     15|  size_t dst_len3 = dst_len / 3;
26931|     15|  size_t src_len2 = src_len / 2;
26932|     15|  size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2;
  ------------------
  |  Branch (26932:16): [True: 5, False: 10]
  ------------------
26933|     15|  uint8_t* d = dst_ptr;
26934|     15|  const uint8_t* s = src_ptr;
26935|     15|  size_t n = len;
26936|       |
26937|       |  // TODO: unroll.
26938|       |
26939|    433|  while (n >= 1) {
  ------------------
  |  Branch (26939:10): [True: 418, False: 15]
  ------------------
26940|    418|    uint32_t s0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(
26941|    418|        wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)));
26942|    418|    wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);
26943|       |
26944|    418|    s += 1 * 2;
26945|    418|    d += 1 * 3;
26946|    418|    n -= 1;
26947|    418|  }
26948|       |
26949|     15|  return len;
26950|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__bgr_565:
29060|     21|                                          size_t src_len) {
29061|     21|  size_t dst_len4 = dst_len / 4;
29062|     21|  size_t src_len2 = src_len / 2;
29063|     21|  size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2;
  ------------------
  |  Branch (29063:16): [True: 12, False: 9]
  ------------------
29064|     21|  uint8_t* d = dst_ptr;
29065|     21|  const uint8_t* s = src_ptr;
29066|     21|  size_t n = len;
29067|       |
29068|       |  // TODO: unroll.
29069|       |
29070|    328|  while (n >= 1) {
  ------------------
  |  Branch (29070:10): [True: 307, False: 21]
  ------------------
29071|    307|    wuffs_base__poke_u32le__no_bounds_check(
29072|    307|        d + (0 * 4), wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(
29073|    307|                         wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))));
29074|       |
29075|    307|    s += 1 * 2;
29076|    307|    d += 1 * 4;
29077|    307|    n -= 1;
29078|    307|  }
29079|       |
29080|     21|  return len;
29081|     21|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw_4x16le__bgr_565:
29329|     15|                                                 size_t src_len) {
29330|     15|  size_t dst_len8 = dst_len / 8;
29331|     15|  size_t src_len2 = src_len / 2;
29332|     15|  size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2;
  ------------------
  |  Branch (29332:16): [True: 10, False: 5]
  ------------------
29333|     15|  uint8_t* d = dst_ptr;
29334|     15|  const uint8_t* s = src_ptr;
29335|     15|  size_t n = len;
29336|       |
29337|    140|  while (n >= 1) {
  ------------------
  |  Branch (29337:10): [True: 125, False: 15]
  ------------------
29338|    125|    wuffs_base__poke_u64le__no_bounds_check(
29339|    125|        d + (0 * 8),
29340|    125|        wuffs_base__color_u32__as__color_u64(
29341|    125|            wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(
29342|    125|                wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)))));
29343|       |
29344|    125|    s += 1 * 2;
29345|    125|    d += 1 * 8;
29346|    125|    n -= 1;
29347|    125|  }
29348|       |
29349|     15|  return len;
29350|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgb__bgr_565:
29430|     13|                                         size_t src_len) {
29431|     13|  size_t dst_len3 = dst_len / 3;
29432|     13|  size_t src_len2 = src_len / 2;
29433|     13|  size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2;
  ------------------
  |  Branch (29433:16): [True: 5, False: 8]
  ------------------
29434|     13|  uint8_t* d = dst_ptr;
29435|     13|  const uint8_t* s = src_ptr;
29436|     13|  size_t n = len;
29437|       |
29438|       |  // TODO: unroll.
29439|       |
29440|    279|  while (n >= 1) {
  ------------------
  |  Branch (29440:10): [True: 266, False: 13]
  ------------------
29441|    266|    wuffs_base__poke_u24le__no_bounds_check(
29442|    266|        d + (0 * 3),
29443|    266|        wuffs_base__color_swap_u32_argb_abgr(
29444|    266|            wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(
29445|    266|                wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)))));
29446|       |
29447|    266|    s += 1 * 2;
29448|    266|    d += 1 * 3;
29449|    266|    n -= 1;
29450|    266|  }
29451|       |
29452|     13|  return len;
29453|     13|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgbw__bgr_565:
29589|     24|                                          size_t src_len) {
29590|     24|  size_t dst_len4 = dst_len / 4;
29591|     24|  size_t src_len2 = src_len / 2;
29592|     24|  size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2;
  ------------------
  |  Branch (29592:16): [True: 8, False: 16]
  ------------------
29593|     24|  uint8_t* d = dst_ptr;
29594|     24|  const uint8_t* s = src_ptr;
29595|     24|  size_t n = len;
29596|       |
29597|       |  // TODO: unroll.
29598|       |
29599|    556|  while (n >= 1) {
  ------------------
  |  Branch (29599:10): [True: 532, False: 24]
  ------------------
29600|    532|    wuffs_base__poke_u32le__no_bounds_check(
29601|    532|        d + (0 * 4),
29602|    532|        wuffs_base__color_swap_u32_argb_abgr(
29603|    532|            wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(
29604|    532|                wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)))));
29605|       |
29606|    532|    s += 1 * 2;
29607|    532|    d += 1 * 4;
29608|    532|    n -= 1;
29609|    532|  }
29610|       |
29611|     24|  return len;
29612|     24|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgr:
31735|    133|    wuffs_base__pixel_blend blend) {
31736|    133|  switch (dst_pixfmt.repr) {
  ------------------
  |  Branch (31736:11): [True: 122, False: 11]
  ------------------
31737|     21|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|     21|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (31737:5): [True: 21, False: 112]
  ------------------
31738|     21|      return wuffs_private_impl__swizzle_y__bgr;
31739|       |
31740|     21|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|     21|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (31740:5): [True: 21, False: 112]
  ------------------
31741|     21|      return wuffs_private_impl__swizzle_bgr_565__bgr;
31742|       |
31743|     12|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|     12|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (31743:5): [True: 12, False: 121]
  ------------------
31744|     12|      return wuffs_private_impl__swizzle_copy_3_3;
31745|       |
31746|      2|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|      2|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (31746:5): [True: 2, False: 131]
  ------------------
31747|      9|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|      9|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (31747:5): [True: 7, False: 126]
  ------------------
31748|      9|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
  ------------------
  |  | 4968|      9|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY               0x83008888
  ------------------
  |  Branch (31748:5): [True: 0, False: 133]
  ------------------
31749|     23|    case WUFFS_BASE__PIXEL_FORMAT__BGRX:
  ------------------
  |  | 4969|     23|#define WUFFS_BASE__PIXEL_FORMAT__BGRX                      0x90008888
  ------------------
  |  Branch (31749:5): [True: 14, False: 119]
  ------------------
31750|     23|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
31751|     23|      if (wuffs_base__cpu_arch__have_x86_sse42()) {
  ------------------
  |  Branch (31751:11): [True: 23, False: 0]
  ------------------
31752|     23|        return wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42;
31753|     23|      }
31754|      0|#endif
31755|      0|      return wuffs_private_impl__swizzle_bgrw__bgr;
31756|       |
31757|      8|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|      8|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (31757:5): [True: 8, False: 125]
  ------------------
31758|      9|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:
  ------------------
  |  | 4967|      9|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE        0x8200BBBB
  ------------------
  |  Branch (31758:5): [True: 1, False: 132]
  ------------------
31759|      9|      return wuffs_private_impl__swizzle_bgrw_4x16le__bgr;
31760|       |
31761|     16|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|     16|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (31761:5): [True: 16, False: 117]
  ------------------
31762|     16|      return wuffs_private_impl__swizzle_swap_rgb_bgr;
31763|       |
31764|     11|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|     11|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (31764:5): [True: 11, False: 122]
  ------------------
31765|     20|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|     20|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (31765:5): [True: 9, False: 124]
  ------------------
31766|     20|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
  ------------------
  |  | 4976|     20|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY               0xA3008888
  ------------------
  |  Branch (31766:5): [True: 0, False: 133]
  ------------------
31767|     20|    case WUFFS_BASE__PIXEL_FORMAT__RGBX:
  ------------------
  |  | 4977|     20|#define WUFFS_BASE__PIXEL_FORMAT__RGBX                      0xB0008888
  ------------------
  |  Branch (31767:5): [True: 0, False: 133]
  ------------------
31768|     20|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
31769|     20|      if (wuffs_base__cpu_arch__have_x86_sse42()) {
  ------------------
  |  Branch (31769:11): [True: 20, False: 0]
  ------------------
31770|     20|        return wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42;
31771|     20|      }
31772|      0|#endif
31773|      0|      return wuffs_private_impl__swizzle_bgrw__rgb;
31774|    133|  }
31775|     11|  return NULL;
31776|    133|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgr:
30352|     21|                                   size_t src_len) {
30353|     21|  size_t src_len3 = src_len / 3;
30354|     21|  size_t len = (dst_len < src_len3) ? dst_len : src_len3;
  ------------------
  |  Branch (30354:16): [True: 5, False: 16]
  ------------------
30355|     21|  uint8_t* d = dst_ptr;
30356|     21|  const uint8_t* s = src_ptr;
30357|     21|  size_t n = len;
30358|       |
30359|       |  // TODO: unroll.
30360|       |
30361|    481|  while (n >= 1) {
  ------------------
  |  Branch (30361:10): [True: 460, False: 21]
  ------------------
30362|    460|    uint32_t s0 =
30363|    460|        0xFF000000 | wuffs_base__peek_u24le__no_bounds_check(s + (0 * 3));
30364|    460|    d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0);
30365|       |
30366|    460|    s += 1 * 3;
30367|    460|    d += 1 * 1;
30368|    460|    n -= 1;
30369|    460|  }
30370|       |
30371|     21|  return len;
30372|     21|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgr:
26009|     21|                                         size_t src_len) {
26010|     21|  size_t dst_len2 = dst_len / 2;
26011|     21|  size_t src_len3 = src_len / 3;
26012|     21|  size_t len = (dst_len2 < src_len3) ? dst_len2 : src_len3;
  ------------------
  |  Branch (26012:16): [True: 7, False: 14]
  ------------------
26013|     21|  uint8_t* d = dst_ptr;
26014|     21|  const uint8_t* s = src_ptr;
26015|     21|  size_t n = len;
26016|       |
26017|       |  // TODO: unroll.
26018|       |
26019|    347|  while (n >= 1) {
  ------------------
  |  Branch (26019:10): [True: 326, False: 21]
  ------------------
26020|    326|    uint32_t b5 = (uint32_t)(s[0] >> 3);
26021|    326|    uint32_t g6 = (uint32_t)(s[1] >> 2);
26022|    326|    uint32_t r5 = (uint32_t)(s[2] >> 3);
26023|    326|    uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0);
26024|    326|    wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565);
26025|       |
26026|    326|    s += 1 * 3;
26027|    326|    d += 1 * 2;
26028|    326|    n -= 1;
26029|    326|  }
26030|       |
26031|     21|  return len;
26032|     21|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_3_3:
25959|     19|                                     size_t src_len) {
25960|     19|  size_t dst_len3 = dst_len / 3;
25961|     19|  size_t src_len3 = src_len / 3;
25962|     19|  size_t len = (dst_len3 < src_len3) ? dst_len3 : src_len3;
  ------------------
  |  Branch (25962:16): [True: 8, False: 11]
  ------------------
25963|     19|  if (len > 0) {
  ------------------
  |  Branch (25963:7): [True: 16, False: 3]
  ------------------
25964|     16|    memmove(dst_ptr, src_ptr, len * 3);
25965|     16|  }
25966|     19|  return len;
25967|     19|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42:
29121|     37|                                                 size_t src_len) {
29122|     37|  size_t dst_len4 = dst_len / 4;
29123|     37|  size_t src_len3 = src_len / 3;
29124|     37|  size_t len = (dst_len4 < src_len3) ? dst_len4 : src_len3;
  ------------------
  |  Branch (29124:16): [True: 10, False: 27]
  ------------------
29125|     37|  uint8_t* d = dst_ptr;
29126|     37|  const uint8_t* s = src_ptr;
29127|     37|  size_t n = len;
29128|       |
29129|     37|  __m128i shuffle = _mm_set_epi8(+0x00, +0x0B, +0x0A, +0x09,  //
29130|     37|                                 +0x00, +0x08, +0x07, +0x06,  //
29131|     37|                                 +0x00, +0x05, +0x04, +0x03,  //
29132|     37|                                 +0x00, +0x02, +0x01, +0x00);
29133|     37|  __m128i or_ff = _mm_set_epi8(-0x01, +0x00, +0x00, +0x00,  //
29134|     37|                               -0x01, +0x00, +0x00, +0x00,  //
29135|     37|                               -0x01, +0x00, +0x00, +0x00,  //
29136|     37|                               -0x01, +0x00, +0x00, +0x00);
29137|       |
29138|    168|  while (n >= 6) {
  ------------------
  |  Branch (29138:10): [True: 131, False: 37]
  ------------------
29139|    131|    __m128i x;
29140|    131|    x = _mm_lddqu_si128((const __m128i*)(const void*)s);
29141|    131|    x = _mm_shuffle_epi8(x, shuffle);
29142|    131|    x = _mm_or_si128(x, or_ff);
29143|    131|    _mm_storeu_si128((__m128i*)(void*)d, x);
29144|       |
29145|    131|    s += 4 * 3;
29146|    131|    d += 4 * 4;
29147|    131|    n -= 4;
29148|    131|  }
29149|       |
29150|    144|  while (n >= 1) {
  ------------------
  |  Branch (29150:10): [True: 107, False: 37]
  ------------------
29151|    107|    uint8_t b0 = s[0];
29152|    107|    uint8_t b1 = s[1];
29153|    107|    uint8_t b2 = s[2];
29154|    107|    d[0] = b0;
29155|    107|    d[1] = b1;
29156|    107|    d[2] = b2;
29157|    107|    d[3] = 0xFF;
29158|       |
29159|    107|    s += 1 * 3;
29160|    107|    d += 1 * 4;
29161|    107|    n -= 1;
29162|    107|  }
29163|       |
29164|     37|  return len;
29165|     37|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw_4x16le__bgr:
29294|      9|                                             size_t src_len) {
29295|      9|  size_t dst_len8 = dst_len / 8;
29296|      9|  size_t src_len3 = src_len / 3;
29297|      9|  size_t len = (dst_len8 < src_len3) ? dst_len8 : src_len3;
  ------------------
  |  Branch (29297:16): [True: 2, False: 7]
  ------------------
29298|      9|  uint8_t* d = dst_ptr;
29299|      9|  const uint8_t* s = src_ptr;
29300|      9|  size_t n = len;
29301|       |
29302|     92|  while (n >= 1) {
  ------------------
  |  Branch (29302:10): [True: 83, False: 9]
  ------------------
29303|     83|    uint8_t s0 = s[0];
29304|     83|    uint8_t s1 = s[1];
29305|     83|    uint8_t s2 = s[2];
29306|     83|    d[0] = s0;
29307|     83|    d[1] = s0;
29308|     83|    d[2] = s1;
29309|     83|    d[3] = s1;
29310|     83|    d[4] = s2;
29311|     83|    d[5] = s2;
29312|     83|    d[6] = 0xFF;
29313|     83|    d[7] = 0xFF;
29314|       |
29315|     83|    s += 1 * 3;
29316|     83|    d += 1 * 8;
29317|     83|    n -= 1;
29318|     83|  }
29319|       |
29320|      9|  return len;
29321|      9|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_swap_rgb_bgr:
25792|     26|                                         size_t src_len) {
25793|     26|  size_t len = (dst_len < src_len ? dst_len : src_len) / 3;
  ------------------
  |  Branch (25793:17): [True: 6, False: 20]
  ------------------
25794|     26|  uint8_t* d = dst_ptr;
25795|     26|  const uint8_t* s = src_ptr;
25796|       |
25797|     26|  size_t n = len;
25798|    733|  while (n--) {
  ------------------
  |  Branch (25798:10): [True: 707, False: 26]
  ------------------
25799|    707|    uint8_t s0 = s[0];
25800|    707|    uint8_t s1 = s[1];
25801|    707|    uint8_t s2 = s[2];
25802|    707|    d[0] = s2;
25803|    707|    d[1] = s1;
25804|    707|    d[2] = s0;
25805|    707|    s += 3;
25806|    707|    d += 3;
25807|    707|  }
25808|     26|  return len;
25809|     26|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42:
29174|     39|                                                 size_t src_len) {
29175|     39|  size_t dst_len4 = dst_len / 4;
29176|     39|  size_t src_len3 = src_len / 3;
29177|     39|  size_t len = (dst_len4 < src_len3) ? dst_len4 : src_len3;
  ------------------
  |  Branch (29177:16): [True: 11, False: 28]
  ------------------
29178|     39|  uint8_t* d = dst_ptr;
29179|     39|  const uint8_t* s = src_ptr;
29180|     39|  size_t n = len;
29181|       |
29182|     39|  __m128i shuffle = _mm_set_epi8(+0x00, +0x09, +0x0A, +0x0B,  //
29183|     39|                                 +0x00, +0x06, +0x07, +0x08,  //
29184|     39|                                 +0x00, +0x03, +0x04, +0x05,  //
29185|     39|                                 +0x00, +0x00, +0x01, +0x02);
29186|     39|  __m128i or_ff = _mm_set_epi8(-0x01, +0x00, +0x00, +0x00,  //
29187|     39|                               -0x01, +0x00, +0x00, +0x00,  //
29188|     39|                               -0x01, +0x00, +0x00, +0x00,  //
29189|     39|                               -0x01, +0x00, +0x00, +0x00);
29190|       |
29191|    217|  while (n >= 6) {
  ------------------
  |  Branch (29191:10): [True: 178, False: 39]
  ------------------
29192|    178|    __m128i x;
29193|    178|    x = _mm_lddqu_si128((const __m128i*)(const void*)s);
29194|    178|    x = _mm_shuffle_epi8(x, shuffle);
29195|    178|    x = _mm_or_si128(x, or_ff);
29196|    178|    _mm_storeu_si128((__m128i*)(void*)d, x);
29197|       |
29198|    178|    s += 4 * 3;
29199|    178|    d += 4 * 4;
29200|    178|    n -= 4;
29201|    178|  }
29202|       |
29203|    142|  while (n >= 1) {
  ------------------
  |  Branch (29203:10): [True: 103, False: 39]
  ------------------
29204|    103|    uint8_t b0 = s[0];
29205|    103|    uint8_t b1 = s[1];
29206|    103|    uint8_t b2 = s[2];
29207|    103|    d[0] = b2;
29208|    103|    d[1] = b1;
29209|    103|    d[2] = b0;
29210|    103|    d[3] = 0xFF;
29211|       |
29212|    103|    s += 1 * 3;
29213|    103|    d += 1 * 4;
29214|    103|    n -= 1;
29215|    103|  }
29216|       |
29217|     39|  return len;
29218|     39|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul:
31784|    223|    wuffs_base__pixel_blend blend) {
31785|    223|  switch (dst_pixfmt.repr) {
  ------------------
  |  Branch (31785:11): [True: 207, False: 16]
  ------------------
31786|     25|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|     25|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (31786:5): [True: 25, False: 198]
  ------------------
31787|     25|      switch (blend) {
  ------------------
  |  Branch (31787:15): [True: 25, False: 0]
  ------------------
31788|     14|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     14|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31788:9): [True: 14, False: 11]
  ------------------
31789|     14|          return wuffs_private_impl__swizzle_y__bgra_nonpremul__src;
31790|     11|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31790:9): [True: 11, False: 14]
  ------------------
31791|     11|          return wuffs_private_impl__swizzle_y__bgra_nonpremul__src_over;
31792|     25|      }
31793|      0|      return NULL;
31794|       |
31795|     30|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|     30|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (31795:5): [True: 30, False: 193]
  ------------------
31796|     30|      switch (blend) {
  ------------------
  |  Branch (31796:15): [True: 30, False: 0]
  ------------------
31797|     15|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     15|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31797:9): [True: 15, False: 15]
  ------------------
31798|     15|          return wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul__src;
31799|     15|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     15|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31799:9): [True: 15, False: 15]
  ------------------
31800|     15|          return wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul__src_over;
31801|     30|      }
31802|      0|      return NULL;
31803|       |
31804|     18|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|     18|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (31804:5): [True: 18, False: 205]
  ------------------
31805|     18|      switch (blend) {
  ------------------
  |  Branch (31805:15): [True: 18, False: 0]
  ------------------
31806|      2|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      2|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31806:9): [True: 2, False: 16]
  ------------------
31807|      2|          return wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src;
31808|     16|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     16|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31808:9): [True: 16, False: 2]
  ------------------
31809|     16|          return wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src_over;
31810|     18|      }
31811|      0|      return NULL;
31812|       |
31813|     12|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|     12|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (31813:5): [True: 12, False: 211]
  ------------------
31814|     12|      switch (blend) {
  ------------------
  |  Branch (31814:15): [True: 12, False: 0]
  ------------------
31815|      0|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      0|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31815:9): [True: 0, False: 12]
  ------------------
31816|      0|          return wuffs_private_impl__swizzle_copy_4_4;
31817|     12|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     12|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31817:9): [True: 12, False: 0]
  ------------------
31818|     12|          return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul__src_over;
31819|     12|      }
31820|      0|      return NULL;
31821|       |
31822|     46|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|     46|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (31822:5): [True: 46, False: 177]
  ------------------
31823|     46|      switch (blend) {
  ------------------
  |  Branch (31823:15): [True: 46, False: 0]
  ------------------
31824|     12|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     12|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31824:9): [True: 12, False: 34]
  ------------------
31825|     12|          return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul__src;
31826|     34|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     34|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31826:9): [True: 34, False: 12]
  ------------------
31827|     34|          return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul__src_over;
31828|     46|      }
31829|      0|      return NULL;
31830|       |
31831|      6|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|      6|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (31831:5): [True: 6, False: 217]
  ------------------
31832|      6|      switch (blend) {
  ------------------
  |  Branch (31832:15): [True: 6, False: 0]
  ------------------
31833|      2|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      2|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31833:9): [True: 2, False: 4]
  ------------------
31834|      2|          return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src;
31835|      4|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      4|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31835:9): [True: 4, False: 2]
  ------------------
31836|      4|          return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src_over;
31837|      6|      }
31838|      0|      return NULL;
31839|       |
31840|      0|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
  ------------------
  |  | 4968|      0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY               0x83008888
  ------------------
  |  Branch (31840:5): [True: 0, False: 223]
  ------------------
31841|      7|    case WUFFS_BASE__PIXEL_FORMAT__BGRX:
  ------------------
  |  | 4969|      7|#define WUFFS_BASE__PIXEL_FORMAT__BGRX                      0x90008888
  ------------------
  |  Branch (31841:5): [True: 7, False: 216]
  ------------------
31842|       |      // TODO.
31843|      7|      break;
31844|       |
31845|     25|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|     25|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (31845:5): [True: 25, False: 198]
  ------------------
31846|     25|      switch (blend) {
  ------------------
  |  Branch (31846:15): [True: 25, False: 0]
  ------------------
31847|     14|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     14|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31847:9): [True: 14, False: 11]
  ------------------
31848|     14|          return wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src;
31849|     11|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31849:9): [True: 11, False: 14]
  ------------------
31850|     11|          return wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src_over;
31851|     25|      }
31852|      0|      return NULL;
31853|       |
31854|     21|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|     21|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (31854:5): [True: 21, False: 202]
  ------------------
31855|     21|      switch (blend) {
  ------------------
  |  Branch (31855:15): [True: 21, False: 0]
  ------------------
31856|     15|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     15|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31856:9): [True: 15, False: 6]
  ------------------
31857|     15|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
31858|     15|          if (wuffs_base__cpu_arch__have_x86_sse42()) {
  ------------------
  |  Branch (31858:15): [True: 15, False: 0]
  ------------------
31859|     15|            return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42;
31860|     15|          }
31861|      0|#endif
31862|      0|          return wuffs_private_impl__swizzle_swap_rgbx_bgrx;
31863|      6|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      6|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31863:9): [True: 6, False: 15]
  ------------------
31864|      6|          return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_nonpremul__src_over;
31865|     21|      }
31866|      0|      return NULL;
31867|       |
31868|     17|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|     17|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (31868:5): [True: 17, False: 206]
  ------------------
31869|     17|      switch (blend) {
  ------------------
  |  Branch (31869:15): [True: 17, False: 0]
  ------------------
31870|      8|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      8|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31870:9): [True: 8, False: 9]
  ------------------
31871|      8|          return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src;
31872|      9|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31872:9): [True: 9, False: 8]
  ------------------
31873|      9|          return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src_over;
31874|     17|      }
31875|      0|      return NULL;
31876|       |
31877|      0|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
  ------------------
  |  | 4976|      0|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY               0xA3008888
  ------------------
  |  Branch (31877:5): [True: 0, False: 223]
  ------------------
31878|      0|    case WUFFS_BASE__PIXEL_FORMAT__RGBX:
  ------------------
  |  | 4977|      0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX                      0xB0008888
  ------------------
  |  Branch (31878:5): [True: 0, False: 223]
  ------------------
31879|       |      // TODO.
31880|      0|      break;
31881|    223|  }
31882|     23|  return NULL;
31883|    223|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_nonpremul__src:
30408|     14|                                                   size_t src_len) {
30409|     14|  size_t src_len4 = src_len / 4;
30410|     14|  size_t len = (dst_len < src_len4) ? dst_len : src_len4;
  ------------------
  |  Branch (30410:16): [True: 1, False: 13]
  ------------------
30411|     14|  uint8_t* d = dst_ptr;
30412|     14|  const uint8_t* s = src_ptr;
30413|     14|  size_t n = len;
30414|       |
30415|       |  // TODO: unroll.
30416|       |
30417|    284|  while (n >= 1) {
  ------------------
  |  Branch (30417:10): [True: 270, False: 14]
  ------------------
30418|    270|    uint32_t s0 =
30419|    270|        wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
30420|    270|            wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
30421|    270|    d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0);
30422|       |
30423|    270|    s += 1 * 4;
30424|    270|    d += 1 * 1;
30425|    270|    n -= 1;
30426|    270|  }
30427|       |
30428|     14|  return len;
30429|     14|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_nonpremul__src_over:
30438|     11|    size_t src_len) {
30439|     11|  size_t src_len4 = src_len / 4;
30440|     11|  size_t len = (dst_len < src_len4) ? dst_len : src_len4;
  ------------------
  |  Branch (30440:16): [True: 1, False: 10]
  ------------------
30441|     11|  uint8_t* d = dst_ptr;
30442|     11|  const uint8_t* s = src_ptr;
30443|     11|  size_t n = len;
30444|       |
30445|       |  // TODO: unroll.
30446|       |
30447|    182|  while (n >= 1) {
  ------------------
  |  Branch (30447:10): [True: 171, False: 11]
  ------------------
30448|    171|    uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0])));
30449|    171|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
30450|    171|    d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(
30451|    171|        wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0));
30452|       |
30453|    171|    s += 1 * 4;
30454|    171|    d += 1 * 1;
30455|    171|    n -= 1;
30456|    171|  }
30457|       |
30458|     11|  return len;
30459|     11|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul__src:
26072|     15|    size_t src_len) {
26073|     15|  size_t dst_len2 = dst_len / 2;
26074|     15|  size_t src_len4 = src_len / 4;
26075|     15|  size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;
  ------------------
  |  Branch (26075:16): [True: 1, False: 14]
  ------------------
26076|     15|  uint8_t* d = dst_ptr;
26077|     15|  const uint8_t* s = src_ptr;
26078|     15|  size_t n = len;
26079|       |
26080|       |  // TODO: unroll.
26081|       |
26082|    387|  while (n >= 1) {
  ------------------
  |  Branch (26082:10): [True: 372, False: 15]
  ------------------
26083|    372|    wuffs_base__poke_u16le__no_bounds_check(
26084|    372|        d + (0 * 2),
26085|    372|        wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(
26086|    372|            wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
26087|    372|                wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))));
26088|       |
26089|    372|    s += 1 * 4;
26090|    372|    d += 1 * 2;
26091|    372|    n -= 1;
26092|    372|  }
26093|       |
26094|     15|  return len;
26095|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul__src_over:
26136|     15|    size_t src_len) {
26137|     15|  size_t dst_len2 = dst_len / 2;
26138|     15|  size_t src_len4 = src_len / 4;
26139|     15|  size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;
  ------------------
  |  Branch (26139:16): [True: 2, False: 13]
  ------------------
26140|     15|  uint8_t* d = dst_ptr;
26141|     15|  const uint8_t* s = src_ptr;
26142|     15|  size_t n = len;
26143|       |
26144|       |  // TODO: unroll.
26145|       |
26146|    379|  while (n >= 1) {
  ------------------
  |  Branch (26146:10): [True: 364, False: 15]
  ------------------
26147|       |    // Extract 16-bit color components.
26148|    364|    uint32_t sa = 0x101 * ((uint32_t)s[3]);
26149|    364|    uint32_t sr = 0x101 * ((uint32_t)s[2]);
26150|    364|    uint32_t sg = 0x101 * ((uint32_t)s[1]);
26151|    364|    uint32_t sb = 0x101 * ((uint32_t)s[0]);
26152|       |
26153|       |    // Convert from 565 color to 16-bit color.
26154|    364|    uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));
26155|    364|    uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);
26156|    364|    uint32_t dr = (0x8421 * old_r5) >> 4;
26157|    364|    uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);
26158|    364|    uint32_t dg = (0x1041 * old_g6) >> 2;
26159|    364|    uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);
26160|    364|    uint32_t db = (0x8421 * old_b5) >> 4;
26161|       |
26162|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
26163|    364|    uint32_t ia = 0xFFFF - sa;
26164|       |
26165|       |    // Composite src (nonpremul) over dst (premul).
26166|    364|    dr = ((sr * sa) + (dr * ia)) / 0xFFFF;
26167|    364|    dg = ((sg * sa) + (dg * ia)) / 0xFFFF;
26168|    364|    db = ((sb * sa) + (db * ia)) / 0xFFFF;
26169|       |
26170|       |    // Convert from 16-bit color to 565 color and combine the components.
26171|    364|    uint32_t new_r5 = 0x1F & (dr >> 11);
26172|    364|    uint32_t new_g6 = 0x3F & (dg >> 10);
26173|    364|    uint32_t new_b5 = 0x1F & (db >> 11);
26174|    364|    uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);
26175|    364|    wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);
26176|       |
26177|    364|    s += 1 * 4;
26178|    364|    d += 1 * 2;
26179|    364|    n -= 1;
26180|    364|  }
26181|       |
26182|     15|  return len;
26183|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src:
26958|     14|                                                     size_t src_len) {
26959|     14|  size_t dst_len3 = dst_len / 3;
26960|     14|  size_t src_len4 = src_len / 4;
26961|     14|  size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;
  ------------------
  |  Branch (26961:16): [True: 2, False: 12]
  ------------------
26962|     14|  uint8_t* d = dst_ptr;
26963|     14|  const uint8_t* s = src_ptr;
26964|     14|  size_t n = len;
26965|       |
26966|       |  // TODO: unroll.
26967|       |
26968|    197|  while (n >= 1) {
  ------------------
  |  Branch (26968:10): [True: 183, False: 14]
  ------------------
26969|    183|    uint32_t s0 =
26970|    183|        wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
26971|    183|            wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
26972|    183|    wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);
26973|       |
26974|    183|    s += 1 * 4;
26975|    183|    d += 1 * 3;
26976|    183|    n -= 1;
26977|    183|  }
26978|       |
26979|     14|  return len;
26980|     14|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src_over:
27020|     17|    size_t src_len) {
27021|     17|  size_t dst_len3 = dst_len / 3;
27022|     17|  size_t src_len4 = src_len / 4;
27023|     17|  size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;
  ------------------
  |  Branch (27023:16): [True: 3, False: 14]
  ------------------
27024|     17|  uint8_t* d = dst_ptr;
27025|     17|  const uint8_t* s = src_ptr;
27026|     17|  size_t n = len;
27027|       |
27028|       |  // TODO: unroll.
27029|       |
27030|    314|  while (n >= 1) {
  ------------------
  |  Branch (27030:10): [True: 297, False: 17]
  ------------------
27031|       |    // Extract 16-bit color components.
27032|    297|    uint32_t dr = 0x101 * ((uint32_t)d[2]);
27033|    297|    uint32_t dg = 0x101 * ((uint32_t)d[1]);
27034|    297|    uint32_t db = 0x101 * ((uint32_t)d[0]);
27035|    297|    uint32_t sa = 0x101 * ((uint32_t)s[3]);
27036|    297|    uint32_t sr = 0x101 * ((uint32_t)s[2]);
27037|    297|    uint32_t sg = 0x101 * ((uint32_t)s[1]);
27038|    297|    uint32_t sb = 0x101 * ((uint32_t)s[0]);
27039|       |
27040|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
27041|    297|    uint32_t ia = 0xFFFF - sa;
27042|       |
27043|       |    // Composite src (nonpremul) over dst (premul).
27044|    297|    dr = ((sr * sa) + (dr * ia)) / 0xFFFF;
27045|    297|    dg = ((sg * sa) + (dg * ia)) / 0xFFFF;
27046|    297|    db = ((sb * sa) + (db * ia)) / 0xFFFF;
27047|       |
27048|       |    // Convert from 16-bit color to 8-bit color.
27049|    297|    d[0] = (uint8_t)(db >> 8);
27050|    297|    d[1] = (uint8_t)(dg >> 8);
27051|    297|    d[2] = (uint8_t)(dr >> 8);
27052|       |
27053|    297|    s += 1 * 4;
27054|    297|    d += 1 * 3;
27055|    297|    n -= 1;
27056|    297|  }
27057|       |
27058|     17|  return len;
27059|     17|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_4_4:
25975|     24|                                     size_t src_len) {
25976|     24|  size_t dst_len4 = dst_len / 4;
25977|     24|  size_t src_len4 = src_len / 4;
25978|     24|  size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
  ------------------
  |  Branch (25978:16): [True: 7, False: 17]
  ------------------
25979|     24|  if (len > 0) {
  ------------------
  |  Branch (25979:7): [True: 19, False: 5]
  ------------------
25980|     19|    memmove(dst_ptr, src_ptr, len * 4);
25981|     19|  }
25982|     24|  return len;
25983|     24|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul__src_over:
27614|     21|    size_t src_len) {
27615|     21|  size_t dst_len4 = dst_len / 4;
27616|     21|  size_t src_len4 = src_len / 4;
27617|     21|  size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
  ------------------
  |  Branch (27617:16): [True: 6, False: 15]
  ------------------
27618|     21|  uint8_t* d = dst_ptr;
27619|     21|  const uint8_t* s = src_ptr;
27620|     21|  size_t n = len;
27621|       |
27622|    220|  while (n >= 1) {
  ------------------
  |  Branch (27622:10): [True: 199, False: 21]
  ------------------
27623|    199|    uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));
27624|    199|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
27625|    199|    wuffs_base__poke_u32le__no_bounds_check(
27626|    199|        d + (0 * 4),
27627|    199|        wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0));
27628|       |
27629|    199|    s += 1 * 4;
27630|    199|    d += 1 * 4;
27631|    199|    n -= 1;
27632|    199|  }
27633|       |
27634|     21|  return len;
27635|     21|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul__src:
28015|     12|    size_t src_len) {
28016|     12|  size_t dst_len8 = dst_len / 8;
28017|     12|  size_t src_len4 = src_len / 4;
28018|     12|  size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
  ------------------
  |  Branch (28018:16): [True: 4, False: 8]
  ------------------
28019|     12|  uint8_t* d = dst_ptr;
28020|     12|  const uint8_t* s = src_ptr;
28021|       |
28022|     12|  size_t n = len;
28023|    130|  while (n >= 1) {
  ------------------
  |  Branch (28023:10): [True: 118, False: 12]
  ------------------
28024|    118|    uint8_t s0 = s[0];
28025|    118|    uint8_t s1 = s[1];
28026|    118|    uint8_t s2 = s[2];
28027|    118|    uint8_t s3 = s[3];
28028|    118|    d[0] = s0;
28029|    118|    d[1] = s0;
28030|    118|    d[2] = s1;
28031|    118|    d[3] = s1;
28032|    118|    d[4] = s2;
28033|    118|    d[5] = s2;
28034|    118|    d[6] = s3;
28035|    118|    d[7] = s3;
28036|       |
28037|    118|    s += 1 * 4;
28038|    118|    d += 1 * 8;
28039|    118|    n -= 1;
28040|    118|  }
28041|     12|  return len;
28042|     12|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul__src_over:
28051|     34|    size_t src_len) {
28052|     34|  size_t dst_len8 = dst_len / 8;
28053|     34|  size_t src_len4 = src_len / 4;
28054|     34|  size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
  ------------------
  |  Branch (28054:16): [True: 10, False: 24]
  ------------------
28055|     34|  uint8_t* d = dst_ptr;
28056|     34|  const uint8_t* s = src_ptr;
28057|       |
28058|     34|  size_t n = len;
28059|    230|  while (n >= 1) {
  ------------------
  |  Branch (28059:10): [True: 196, False: 34]
  ------------------
28060|    196|    uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));
28061|    196|    uint64_t s0 = wuffs_base__color_u32__as__color_u64(
28062|    196|        wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
28063|    196|    wuffs_base__poke_u64le__no_bounds_check(
28064|    196|        d + (0 * 8),
28065|    196|        wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0));
28066|       |
28067|    196|    s += 1 * 4;
28068|    196|    d += 1 * 8;
28069|    196|    n -= 1;
28070|    196|  }
28071|     34|  return len;
28072|     34|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src_over:
28508|     15|    size_t src_len) {
28509|     15|  size_t dst_len4 = dst_len / 4;
28510|     15|  size_t src_len4 = src_len / 4;
28511|     15|  size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
  ------------------
  |  Branch (28511:16): [True: 3, False: 12]
  ------------------
28512|     15|  uint8_t* d = dst_ptr;
28513|     15|  const uint8_t* s = src_ptr;
28514|     15|  size_t n = len;
28515|       |
28516|       |  // TODO: unroll.
28517|       |
28518|    321|  while (n >= 1) {
  ------------------
  |  Branch (28518:10): [True: 306, False: 15]
  ------------------
28519|    306|    uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));
28520|    306|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
28521|    306|    wuffs_base__poke_u32le__no_bounds_check(
28522|    306|        d + (0 * 4),
28523|    306|        wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0));
28524|       |
28525|    306|    s += 1 * 4;
28526|    306|    d += 1 * 4;
28527|    306|    n -= 1;
28528|    306|  }
28529|       |
28530|     15|  return len;
28531|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src:
27268|     15|                                                     size_t src_len) {
27269|     15|  size_t dst_len3 = dst_len / 3;
27270|     15|  size_t src_len4 = src_len / 4;
27271|     15|  size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;
  ------------------
  |  Branch (27271:16): [True: 3, False: 12]
  ------------------
27272|     15|  uint8_t* d = dst_ptr;
27273|     15|  const uint8_t* s = src_ptr;
27274|     15|  size_t n = len;
27275|       |
27276|       |  // TODO: unroll.
27277|       |
27278|    341|  while (n >= 1) {
  ------------------
  |  Branch (27278:10): [True: 326, False: 15]
  ------------------
27279|    326|    uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr(
27280|    326|        wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
27281|    326|            wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))));
27282|    326|    wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);
27283|       |
27284|    326|    s += 1 * 4;
27285|    326|    d += 1 * 3;
27286|    326|    n -= 1;
27287|    326|  }
27288|       |
27289|     15|  return len;
27290|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src_over:
27330|     19|    size_t src_len) {
27331|     19|  size_t dst_len3 = dst_len / 3;
27332|     19|  size_t src_len4 = src_len / 4;
27333|     19|  size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;
  ------------------
  |  Branch (27333:16): [True: 2, False: 17]
  ------------------
27334|     19|  uint8_t* d = dst_ptr;
27335|     19|  const uint8_t* s = src_ptr;
27336|     19|  size_t n = len;
27337|       |
27338|       |  // TODO: unroll.
27339|       |
27340|    390|  while (n >= 1) {
  ------------------
  |  Branch (27340:10): [True: 371, False: 19]
  ------------------
27341|       |    // Extract 16-bit color components.
27342|    371|    uint32_t dr = 0x101 * ((uint32_t)d[2]);
27343|    371|    uint32_t dg = 0x101 * ((uint32_t)d[1]);
27344|    371|    uint32_t db = 0x101 * ((uint32_t)d[0]);
27345|    371|    uint32_t sa = 0x101 * ((uint32_t)s[3]);
27346|    371|    uint32_t sb = 0x101 * ((uint32_t)s[2]);
27347|    371|    uint32_t sg = 0x101 * ((uint32_t)s[1]);
27348|    371|    uint32_t sr = 0x101 * ((uint32_t)s[0]);
27349|       |
27350|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
27351|    371|    uint32_t ia = 0xFFFF - sa;
27352|       |
27353|       |    // Composite src (nonpremul) over dst (premul).
27354|    371|    dr = ((sr * sa) + (dr * ia)) / 0xFFFF;
27355|    371|    dg = ((sg * sa) + (dg * ia)) / 0xFFFF;
27356|    371|    db = ((sb * sa) + (db * ia)) / 0xFFFF;
27357|       |
27358|       |    // Convert from 16-bit color to 8-bit color.
27359|    371|    d[0] = (uint8_t)(db >> 8);
27360|    371|    d[1] = (uint8_t)(dg >> 8);
27361|    371|    d[2] = (uint8_t)(dr >> 8);
27362|       |
27363|    371|    s += 1 * 4;
27364|    371|    d += 1 * 3;
27365|    371|    n -= 1;
27366|    371|  }
27367|       |
27368|     19|  return len;
27369|     19|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42:
25820|     33|                                                      size_t src_len) {
25821|     33|  size_t len = (dst_len < src_len ? dst_len : src_len) / 4;
  ------------------
  |  Branch (25821:17): [True: 9, False: 24]
  ------------------
25822|     33|  uint8_t* d = dst_ptr;
25823|     33|  const uint8_t* s = src_ptr;
25824|     33|  size_t n = len;
25825|       |
25826|     33|  __m128i shuffle = _mm_set_epi8(+0x0F, +0x0C, +0x0D, +0x0E,  //
25827|     33|                                 +0x0B, +0x08, +0x09, +0x0A,  //
25828|     33|                                 +0x07, +0x04, +0x05, +0x06,  //
25829|     33|                                 +0x03, +0x00, +0x01, +0x02);
25830|       |
25831|    165|  while (n >= 4) {
  ------------------
  |  Branch (25831:10): [True: 132, False: 33]
  ------------------
25832|    132|    __m128i x;
25833|    132|    x = _mm_lddqu_si128((const __m128i*)(const void*)s);
25834|    132|    x = _mm_shuffle_epi8(x, shuffle);
25835|    132|    _mm_storeu_si128((__m128i*)(void*)d, x);
25836|       |
25837|    132|    s += 4 * 4;
25838|    132|    d += 4 * 4;
25839|    132|    n -= 4;
25840|    132|  }
25841|       |
25842|     81|  while (n--) {
  ------------------
  |  Branch (25842:10): [True: 48, False: 33]
  ------------------
25843|     48|    uint8_t s0 = s[0];
25844|     48|    uint8_t s1 = s[1];
25845|     48|    uint8_t s2 = s[2];
25846|     48|    uint8_t s3 = s[3];
25847|     48|    d[0] = s2;
25848|     48|    d[1] = s1;
25849|     48|    d[2] = s0;
25850|     48|    d[3] = s3;
25851|     48|    s += 4;
25852|     48|    d += 4;
25853|     48|  }
25854|     33|  return len;
25855|     33|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__rgba_nonpremul__src_over:
27860|     28|    size_t src_len) {
27861|     28|  size_t dst_len4 = dst_len / 4;
27862|     28|  size_t src_len4 = src_len / 4;
27863|     28|  size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
  ------------------
  |  Branch (27863:16): [True: 4, False: 24]
  ------------------
27864|     28|  uint8_t* d = dst_ptr;
27865|     28|  const uint8_t* s = src_ptr;
27866|     28|  size_t n = len;
27867|       |
27868|    509|  while (n >= 1) {
  ------------------
  |  Branch (27868:10): [True: 481, False: 28]
  ------------------
27869|    481|    uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));
27870|    481|    uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr(
27871|    481|        wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
27872|    481|    wuffs_base__poke_u32le__no_bounds_check(
27873|    481|        d + (0 * 4),
27874|    481|        wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(d0, s0));
27875|       |
27876|    481|    s += 1 * 4;
27877|    481|    d += 1 * 4;
27878|    481|    n -= 1;
27879|    481|  }
27880|       |
27881|     28|  return len;
27882|     28|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src_over:
28738|     19|    size_t src_len) {
28739|     19|  size_t dst_len4 = dst_len / 4;
28740|     19|  size_t src_len4 = src_len / 4;
28741|     19|  size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
  ------------------
  |  Branch (28741:16): [True: 3, False: 16]
  ------------------
28742|     19|  uint8_t* d = dst_ptr;
28743|     19|  const uint8_t* s = src_ptr;
28744|     19|  size_t n = len;
28745|       |
28746|       |  // TODO: unroll.
28747|       |
28748|    271|  while (n >= 1) {
  ------------------
  |  Branch (28748:10): [True: 252, False: 19]
  ------------------
28749|    252|    uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));
28750|    252|    uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr(
28751|    252|        wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
28752|    252|    wuffs_base__poke_u32le__no_bounds_check(
28753|    252|        d + (0 * 4),
28754|    252|        wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0));
28755|       |
28756|    252|    s += 1 * 4;
28757|    252|    d += 1 * 4;
28758|    252|    n -= 1;
28759|    252|  }
28760|       |
28761|     19|  return len;
28762|     19|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgra_nonpremul_4x16le:
31891|    296|    wuffs_base__pixel_blend blend) {
31892|    296|  switch (dst_pixfmt.repr) {
  ------------------
  |  Branch (31892:11): [True: 279, False: 17]
  ------------------
31893|     22|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|     22|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (31893:5): [True: 22, False: 274]
  ------------------
31894|     22|      switch (blend) {
  ------------------
  |  Branch (31894:15): [True: 22, False: 0]
  ------------------
31895|      9|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      9|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31895:9): [True: 9, False: 13]
  ------------------
31896|      9|          return wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src;
31897|     13|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     13|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31897:9): [True: 13, False: 9]
  ------------------
31898|     13|          return wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src_over;
31899|     22|      }
31900|      0|      return NULL;
31901|       |
31902|     38|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|     38|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (31902:5): [True: 38, False: 258]
  ------------------
31903|     38|      switch (blend) {
  ------------------
  |  Branch (31903:15): [True: 38, False: 0]
  ------------------
31904|     19|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     19|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31904:9): [True: 19, False: 19]
  ------------------
31905|     19|          return wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul_4x16le__src;
31906|     19|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     19|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31906:9): [True: 19, False: 19]
  ------------------
31907|     19|          return wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul_4x16le__src_over;
31908|     38|      }
31909|      0|      return NULL;
31910|       |
31911|     18|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|     18|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (31911:5): [True: 18, False: 278]
  ------------------
31912|     18|      switch (blend) {
  ------------------
  |  Branch (31912:15): [True: 18, False: 0]
  ------------------
31913|      9|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      9|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31913:9): [True: 9, False: 9]
  ------------------
31914|      9|          return wuffs_private_impl__swizzle_bgr__bgra_nonpremul_4x16le__src;
31915|      9|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31915:9): [True: 9, False: 9]
  ------------------
31916|      9|          return wuffs_private_impl__swizzle_bgr__bgra_nonpremul_4x16le__src_over;
31917|     18|      }
31918|      0|      return NULL;
31919|       |
31920|     46|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|     46|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (31920:5): [True: 46, False: 250]
  ------------------
31921|     46|      switch (blend) {
  ------------------
  |  Branch (31921:15): [True: 46, False: 0]
  ------------------
31922|     14|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     14|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31922:9): [True: 14, False: 32]
  ------------------
31923|     14|          return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul_4x16le__src;
31924|     32|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     32|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31924:9): [True: 32, False: 14]
  ------------------
31925|     32|          return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul_4x16le__src_over;
31926|     46|      }
31927|      0|      return NULL;
31928|       |
31929|     40|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|     40|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (31929:5): [True: 40, False: 256]
  ------------------
31930|     40|      switch (blend) {
  ------------------
  |  Branch (31930:15): [True: 40, False: 0]
  ------------------
31931|      7|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      7|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31931:9): [True: 7, False: 33]
  ------------------
31932|      7|          return wuffs_private_impl__swizzle_copy_8_8;
31933|     33|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     33|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31933:9): [True: 33, False: 7]
  ------------------
31934|     33|          return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul_4x16le__src_over;
31935|     40|      }
31936|      0|      return NULL;
31937|       |
31938|     24|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|     24|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (31938:5): [True: 24, False: 272]
  ------------------
31939|     24|      switch (blend) {
  ------------------
  |  Branch (31939:15): [True: 24, False: 0]
  ------------------
31940|     10|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31940:9): [True: 10, False: 14]
  ------------------
31941|     10|          return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul_4x16le__src;
31942|     14|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     14|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31942:9): [True: 14, False: 10]
  ------------------
31943|     14|          return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul_4x16le__src_over;
31944|     24|      }
31945|      0|      return NULL;
31946|       |
31947|      0|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
  ------------------
  |  | 4968|      0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY               0x83008888
  ------------------
  |  Branch (31947:5): [True: 0, False: 296]
  ------------------
31948|      2|    case WUFFS_BASE__PIXEL_FORMAT__BGRX:
  ------------------
  |  | 4969|      2|#define WUFFS_BASE__PIXEL_FORMAT__BGRX                      0x90008888
  ------------------
  |  Branch (31948:5): [True: 2, False: 294]
  ------------------
31949|       |      // TODO.
31950|      2|      break;
31951|       |
31952|     26|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|     26|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (31952:5): [True: 26, False: 270]
  ------------------
31953|     26|      switch (blend) {
  ------------------
  |  Branch (31953:15): [True: 26, False: 0]
  ------------------
31954|     13|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     13|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31954:9): [True: 13, False: 13]
  ------------------
31955|     13|          return wuffs_private_impl__swizzle_bgr__rgba_nonpremul_4x16le__src;
31956|     13|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     13|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31956:9): [True: 13, False: 13]
  ------------------
31957|     13|          return wuffs_private_impl__swizzle_bgr__rgba_nonpremul_4x16le__src_over;
31958|     26|      }
31959|      0|      return NULL;
31960|       |
31961|     39|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|     39|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (31961:5): [True: 39, False: 257]
  ------------------
31962|     39|      switch (blend) {
  ------------------
  |  Branch (31962:15): [True: 39, False: 0]
  ------------------
31963|     12|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     12|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31963:9): [True: 12, False: 27]
  ------------------
31964|     12|          return wuffs_private_impl__swizzle_rgba_nonpremul__bgra_nonpremul_4x16le__src;
31965|     27|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     27|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31965:9): [True: 27, False: 12]
  ------------------
31966|     27|          return wuffs_private_impl__swizzle_rgba_nonpremul__bgra_nonpremul_4x16le__src_over;
31967|     39|      }
31968|      0|      break;
31969|       |
31970|     24|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|     24|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (31970:5): [True: 24, False: 272]
  ------------------
31971|     24|      switch (blend) {
  ------------------
  |  Branch (31971:15): [True: 24, False: 0]
  ------------------
31972|     10|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31972:9): [True: 10, False: 14]
  ------------------
31973|     10|          return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul_4x16le__src;
31974|     14|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     14|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31974:9): [True: 14, False: 10]
  ------------------
31975|     14|          return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul_4x16le__src_over;
31976|     24|      }
31977|      0|      return NULL;
31978|       |
31979|      0|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
  ------------------
  |  | 4976|      0|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY               0xA3008888
  ------------------
  |  Branch (31979:5): [True: 0, False: 296]
  ------------------
31980|      0|    case WUFFS_BASE__PIXEL_FORMAT__RGBX:
  ------------------
  |  | 4977|      0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX                      0xB0008888
  ------------------
  |  Branch (31980:5): [True: 0, False: 296]
  ------------------
31981|       |      // TODO.
31982|      0|      break;
31983|    296|  }
31984|     19|  return NULL;
31985|    296|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src:
30468|      9|    size_t src_len) {
30469|      9|  size_t src_len8 = src_len / 8;
30470|      9|  size_t len = (dst_len < src_len8) ? dst_len : src_len8;
  ------------------
  |  Branch (30470:16): [True: 1, False: 8]
  ------------------
30471|      9|  uint8_t* d = dst_ptr;
30472|      9|  const uint8_t* s = src_ptr;
30473|      9|  size_t n = len;
30474|       |
30475|       |  // TODO: unroll.
30476|       |
30477|     67|  while (n >= 1) {
  ------------------
  |  Branch (30477:10): [True: 58, False: 9]
  ------------------
30478|     58|    d[0] = wuffs_base__color_u64_argb_nonpremul__as__color_u8_gray(
30479|     58|        wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)));
30480|       |
30481|     58|    s += 1 * 8;
30482|     58|    d += 1 * 1;
30483|     58|    n -= 1;
30484|     58|  }
30485|       |
30486|      9|  return len;
30487|      9|}
pixel_swizzler_fuzzer.c:wuffs_base__color_u64_argb_nonpremul__as__color_u8_gray:
 4629|     58|    uint64_t argb_nonpremul) {
 4630|     58|  uint32_t a16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 48)));
 4631|       |
 4632|     58|  uint32_t r16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 32)));
 4633|     58|  r16 = (r16 * a16) / 0xFFFF;
 4634|     58|  uint32_t g16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 16)));
 4635|     58|  g16 = (g16 * a16) / 0xFFFF;
 4636|     58|  uint32_t b16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 0)));
 4637|     58|  b16 = (b16 * a16) / 0xFFFF;
 4638|       |
 4639|       |  // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same
 4640|       |  // as those given by the JFIF specification.
 4641|       |  //
 4642|       |  // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We
 4643|       |  // shift by 24, not just by 16, because the return value is 8-bit color, not
 4644|       |  // 16-bit color.
 4645|     58|  uint32_t weighted_average =
 4646|     58|      (19595 * r16) + (38470 * g16) + (7471 * b16) + 32768;
 4647|     58|  return (uint8_t)(weighted_average >> 24);
 4648|     58|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src_over:
30496|     13|    size_t src_len) {
30497|     13|  size_t src_len8 = src_len / 8;
30498|     13|  size_t len = (dst_len < src_len8) ? dst_len : src_len8;
  ------------------
  |  Branch (30498:16): [True: 2, False: 11]
  ------------------
30499|     13|  uint8_t* d = dst_ptr;
30500|     13|  const uint8_t* s = src_ptr;
30501|     13|  size_t n = len;
30502|       |
30503|       |  // TODO: unroll.
30504|       |
30505|    127|  while (n >= 1) {
  ------------------
  |  Branch (30505:10): [True: 114, False: 13]
  ------------------
30506|       |    // Extract 16-bit color components.
30507|    114|    uint32_t dr = 0x101 * ((uint32_t)d[0]);
30508|    114|    uint32_t dg = 0x101 * ((uint32_t)d[0]);
30509|    114|    uint32_t db = 0x101 * ((uint32_t)d[0]);
30510|    114|    uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6));
30511|    114|    uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4));
30512|    114|    uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2));
30513|    114|    uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0));
30514|       |
30515|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
30516|    114|    uint32_t ia = 0xFFFF - sa;
30517|       |
30518|       |    // Composite src (nonpremul) over dst (premul).
30519|    114|    dr = ((sr * sa) + (dr * ia)) / 0xFFFF;
30520|    114|    dg = ((sg * sa) + (dg * ia)) / 0xFFFF;
30521|    114|    db = ((sb * sa) + (db * ia)) / 0xFFFF;
30522|       |
30523|       |    // Convert to 16-bit color to 8-bit gray.
30524|    114|    uint32_t weighted_average =
30525|    114|        (19595 * dr) + (38470 * dg) + (7471 * db) + 32768;
30526|    114|    d[0] = (uint8_t)(weighted_average >> 24);
30527|       |
30528|    114|    s += 1 * 8;
30529|    114|    d += 1 * 1;
30530|    114|    n -= 1;
30531|    114|  }
30532|       |
30533|     13|  return len;
30534|     13|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul_4x16le__src:
26104|     19|    size_t src_len) {
26105|     19|  size_t dst_len2 = dst_len / 2;
26106|     19|  size_t src_len8 = src_len / 8;
26107|     19|  size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8;
  ------------------
  |  Branch (26107:16): [True: 1, False: 18]
  ------------------
26108|     19|  uint8_t* d = dst_ptr;
26109|     19|  const uint8_t* s = src_ptr;
26110|     19|  size_t n = len;
26111|       |
26112|       |  // TODO: unroll.
26113|       |
26114|    226|  while (n >= 1) {
  ------------------
  |  Branch (26114:10): [True: 207, False: 19]
  ------------------
26115|    207|    wuffs_base__poke_u16le__no_bounds_check(
26116|    207|        d + (0 * 2),
26117|    207|        wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(
26118|    207|            wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(
26119|    207|                wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))));
26120|       |
26121|    207|    s += 1 * 8;
26122|    207|    d += 1 * 2;
26123|    207|    n -= 1;
26124|    207|  }
26125|       |
26126|     19|  return len;
26127|     19|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_nonpremul_4x16le__src_over:
26192|     19|    size_t src_len) {
26193|     19|  size_t dst_len2 = dst_len / 2;
26194|     19|  size_t src_len8 = src_len / 8;
26195|     19|  size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8;
  ------------------
  |  Branch (26195:16): [True: 1, False: 18]
  ------------------
26196|     19|  uint8_t* d = dst_ptr;
26197|     19|  const uint8_t* s = src_ptr;
26198|     19|  size_t n = len;
26199|       |
26200|       |  // TODO: unroll.
26201|       |
26202|    182|  while (n >= 1) {
  ------------------
  |  Branch (26202:10): [True: 163, False: 19]
  ------------------
26203|       |    // Extract 16-bit color components.
26204|    163|    uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6));
26205|    163|    uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4));
26206|    163|    uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2));
26207|    163|    uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0));
26208|       |
26209|       |    // Convert from 565 color to 16-bit color.
26210|    163|    uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));
26211|    163|    uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);
26212|    163|    uint32_t dr = (0x8421 * old_r5) >> 4;
26213|    163|    uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);
26214|    163|    uint32_t dg = (0x1041 * old_g6) >> 2;
26215|    163|    uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);
26216|    163|    uint32_t db = (0x8421 * old_b5) >> 4;
26217|       |
26218|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
26219|    163|    uint32_t ia = 0xFFFF - sa;
26220|       |
26221|       |    // Composite src (nonpremul) over dst (premul).
26222|    163|    dr = ((sr * sa) + (dr * ia)) / 0xFFFF;
26223|    163|    dg = ((sg * sa) + (dg * ia)) / 0xFFFF;
26224|    163|    db = ((sb * sa) + (db * ia)) / 0xFFFF;
26225|       |
26226|       |    // Convert from 16-bit color to 565 color and combine the components.
26227|    163|    uint32_t new_r5 = 0x1F & (dr >> 11);
26228|    163|    uint32_t new_g6 = 0x3F & (dg >> 10);
26229|    163|    uint32_t new_b5 = 0x1F & (db >> 11);
26230|    163|    uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);
26231|    163|    wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);
26232|       |
26233|    163|    s += 1 * 8;
26234|    163|    d += 1 * 2;
26235|    163|    n -= 1;
26236|    163|  }
26237|       |
26238|     19|  return len;
26239|     19|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_nonpremul_4x16le__src:
26989|      9|    size_t src_len) {
26990|      9|  size_t dst_len3 = dst_len / 3;
26991|      9|  size_t src_len8 = src_len / 8;
26992|      9|  size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8;
  ------------------
  |  Branch (26992:16): [True: 1, False: 8]
  ------------------
26993|      9|  uint8_t* d = dst_ptr;
26994|      9|  const uint8_t* s = src_ptr;
26995|      9|  size_t n = len;
26996|       |
26997|       |  // TODO: unroll.
26998|       |
26999|    123|  while (n >= 1) {
  ------------------
  |  Branch (26999:10): [True: 114, False: 9]
  ------------------
27000|    114|    uint32_t s0 =
27001|    114|        wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(
27002|    114|            wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)));
27003|    114|    wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);
27004|       |
27005|    114|    s += 1 * 8;
27006|    114|    d += 1 * 3;
27007|    114|    n -= 1;
27008|    114|  }
27009|       |
27010|      9|  return len;
27011|      9|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_nonpremul_4x16le__src_over:
27068|      9|    size_t src_len) {
27069|      9|  size_t dst_len3 = dst_len / 3;
27070|      9|  size_t src_len8 = src_len / 8;
27071|      9|  size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8;
  ------------------
  |  Branch (27071:16): [True: 1, False: 8]
  ------------------
27072|      9|  uint8_t* d = dst_ptr;
27073|      9|  const uint8_t* s = src_ptr;
27074|      9|  size_t n = len;
27075|       |
27076|       |  // TODO: unroll.
27077|       |
27078|     81|  while (n >= 1) {
  ------------------
  |  Branch (27078:10): [True: 72, False: 9]
  ------------------
27079|       |    // Extract 16-bit color components.
27080|     72|    uint32_t dr = 0x101 * ((uint32_t)d[2]);
27081|     72|    uint32_t dg = 0x101 * ((uint32_t)d[1]);
27082|     72|    uint32_t db = 0x101 * ((uint32_t)d[0]);
27083|     72|    uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6));
27084|     72|    uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4));
27085|     72|    uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2));
27086|     72|    uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0));
27087|       |
27088|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
27089|     72|    uint32_t ia = 0xFFFF - sa;
27090|       |
27091|       |    // Composite src (nonpremul) over dst (premul).
27092|     72|    dr = ((sr * sa) + (dr * ia)) / 0xFFFF;
27093|     72|    dg = ((sg * sa) + (dg * ia)) / 0xFFFF;
27094|     72|    db = ((sb * sa) + (db * ia)) / 0xFFFF;
27095|       |
27096|       |    // Convert from 16-bit color to 8-bit color.
27097|     72|    d[0] = (uint8_t)(db >> 8);
27098|     72|    d[1] = (uint8_t)(dg >> 8);
27099|     72|    d[2] = (uint8_t)(dr >> 8);
27100|       |
27101|     72|    s += 1 * 8;
27102|     72|    d += 1 * 3;
27103|     72|    n -= 1;
27104|     72|  }
27105|       |
27106|      9|  return len;
27107|      9|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul_4x16le__src:
27644|     14|    size_t src_len) {
27645|     14|  size_t dst_len4 = dst_len / 4;
27646|     14|  size_t src_len8 = src_len / 8;
27647|     14|  size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
  ------------------
  |  Branch (27647:16): [True: 2, False: 12]
  ------------------
27648|     14|  uint8_t* d = dst_ptr;
27649|     14|  const uint8_t* s = src_ptr;
27650|       |
27651|     14|  size_t n = len;
27652|    167|  while (n >= 1) {
  ------------------
  |  Branch (27652:10): [True: 153, False: 14]
  ------------------
27653|    153|    wuffs_base__poke_u32le__no_bounds_check(
27654|    153|        d + (0 * 4), wuffs_base__color_u64__as__color_u32(
27655|    153|                         wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))));
27656|       |
27657|    153|    s += 1 * 8;
27658|    153|    d += 1 * 4;
27659|    153|    n -= 1;
27660|    153|  }
27661|     14|  return len;
27662|     14|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul_4x16le__src_over:
27671|     32|    size_t src_len) {
27672|     32|  size_t dst_len4 = dst_len / 4;
27673|     32|  size_t src_len8 = src_len / 8;
27674|     32|  size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
  ------------------
  |  Branch (27674:16): [True: 2, False: 30]
  ------------------
27675|     32|  uint8_t* d = dst_ptr;
27676|     32|  const uint8_t* s = src_ptr;
27677|     32|  size_t n = len;
27678|       |
27679|    303|  while (n >= 1) {
  ------------------
  |  Branch (27679:10): [True: 271, False: 32]
  ------------------
27680|    271|    uint64_t d0 = wuffs_base__color_u32__as__color_u64(
27681|    271|        wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));
27682|    271|    uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));
27683|    271|    wuffs_base__poke_u32le__no_bounds_check(
27684|    271|        d + (0 * 4),
27685|    271|        wuffs_base__color_u64__as__color_u32(
27686|    271|            wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0,
27687|    271|                                                                       s0)));
27688|       |
27689|    271|    s += 1 * 8;
27690|    271|    d += 1 * 4;
27691|    271|    n -= 1;
27692|    271|  }
27693|       |
27694|     32|  return len;
27695|     32|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_copy_8_8:
25991|      7|                                     size_t src_len) {
25992|      7|  size_t dst_len8 = dst_len / 8;
25993|      7|  size_t src_len8 = src_len / 8;
25994|      7|  size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8;
  ------------------
  |  Branch (25994:16): [True: 4, False: 3]
  ------------------
25995|      7|  if (len > 0) {
  ------------------
  |  Branch (25995:7): [True: 5, False: 2]
  ------------------
25996|      5|    memmove(dst_ptr, src_ptr, len * 8);
25997|      5|  }
25998|      7|  return len;
25999|      7|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_nonpremul_4x16le__src_over:
28081|     33|    size_t src_len) {
28082|     33|  size_t dst_len8 = dst_len / 8;
28083|     33|  size_t src_len8 = src_len / 8;
28084|     33|  size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8;
  ------------------
  |  Branch (28084:16): [True: 3, False: 30]
  ------------------
28085|     33|  uint8_t* d = dst_ptr;
28086|     33|  const uint8_t* s = src_ptr;
28087|       |
28088|     33|  size_t n = len;
28089|    217|  while (n >= 1) {
  ------------------
  |  Branch (28089:10): [True: 184, False: 33]
  ------------------
28090|    184|    uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));
28091|    184|    uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));
28092|    184|    wuffs_base__poke_u64le__no_bounds_check(
28093|    184|        d + (0 * 8),
28094|    184|        wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0));
28095|       |
28096|    184|    s += 1 * 8;
28097|    184|    d += 1 * 8;
28098|    184|    n -= 1;
28099|    184|  }
28100|     33|  return len;
28101|     33|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul_4x16le__src:
28477|     10|    size_t src_len) {
28478|     10|  size_t dst_len4 = dst_len / 4;
28479|     10|  size_t src_len8 = src_len / 8;
28480|     10|  size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
  ------------------
  |  Branch (28480:16): [True: 2, False: 8]
  ------------------
28481|     10|  uint8_t* d = dst_ptr;
28482|     10|  const uint8_t* s = src_ptr;
28483|     10|  size_t n = len;
28484|       |
28485|       |  // TODO: unroll.
28486|       |
28487|    112|  while (n >= 1) {
  ------------------
  |  Branch (28487:10): [True: 102, False: 10]
  ------------------
28488|    102|    uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));
28489|    102|    wuffs_base__poke_u32le__no_bounds_check(
28490|    102|        d + (0 * 4),
28491|    102|        wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(s0));
28492|       |
28493|    102|    s += 1 * 8;
28494|    102|    d += 1 * 4;
28495|    102|    n -= 1;
28496|    102|  }
28497|       |
28498|     10|  return len;
28499|     10|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul_4x16le__src_over:
28540|     14|    size_t src_len) {
28541|     14|  size_t dst_len4 = dst_len / 4;
28542|     14|  size_t src_len8 = src_len / 8;
28543|     14|  size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
  ------------------
  |  Branch (28543:16): [True: 3, False: 11]
  ------------------
28544|     14|  uint8_t* d = dst_ptr;
28545|     14|  const uint8_t* s = src_ptr;
28546|     14|  size_t n = len;
28547|       |
28548|       |  // TODO: unroll.
28549|       |
28550|    169|  while (n >= 1) {
  ------------------
  |  Branch (28550:10): [True: 155, False: 14]
  ------------------
28551|    155|    uint64_t d0 = wuffs_base__color_u32__as__color_u64(
28552|    155|        wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));
28553|    155|    uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));
28554|    155|    wuffs_base__poke_u32le__no_bounds_check(
28555|    155|        d + (0 * 4),
28556|    155|        wuffs_base__color_u64__as__color_u32(
28557|    155|            wuffs_private_impl__composite_premul_nonpremul_u64_axxx(d0, s0)));
28558|       |
28559|    155|    s += 1 * 8;
28560|    155|    d += 1 * 4;
28561|    155|    n -= 1;
28562|    155|  }
28563|       |
28564|     14|  return len;
28565|     14|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_premul_nonpremul_u64_axxx:
25643|    269|    uint64_t src_nonpremul) {
25644|       |  // Extract components.
25645|    269|  uint64_t da = 0xFFFF & (dst_premul >> 48);
25646|    269|  uint64_t dr = 0xFFFF & (dst_premul >> 32);
25647|    269|  uint64_t dg = 0xFFFF & (dst_premul >> 16);
25648|    269|  uint64_t db = 0xFFFF & (dst_premul >> 0);
25649|    269|  uint64_t sa = 0xFFFF & (src_nonpremul >> 48);
25650|    269|  uint64_t sr = 0xFFFF & (src_nonpremul >> 32);
25651|    269|  uint64_t sg = 0xFFFF & (src_nonpremul >> 16);
25652|    269|  uint64_t sb = 0xFFFF & (src_nonpremul >> 0);
25653|       |
25654|       |  // Calculate the inverse of the src-alpha: how much of the dst to keep.
25655|    269|  uint64_t ia = 0xFFFF - sa;
25656|       |
25657|       |  // Composite src (nonpremul) over dst (premul).
25658|    269|  da = sa + ((da * ia) / 0xFFFF);
25659|    269|  dr = ((sr * sa) + (dr * ia)) / 0xFFFF;
25660|    269|  dg = ((sg * sa) + (dg * ia)) / 0xFFFF;
25661|    269|  db = ((sb * sa) + (db * ia)) / 0xFFFF;
25662|       |
25663|       |  // Combine components.
25664|    269|  return (db << 0) | (dg << 16) | (dr << 32) | (da << 48);
25665|    269|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_nonpremul_4x16le__src:
27299|     13|    size_t src_len) {
27300|     13|  size_t dst_len3 = dst_len / 3;
27301|     13|  size_t src_len8 = src_len / 8;
27302|     13|  size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8;
  ------------------
  |  Branch (27302:16): [True: 3, False: 10]
  ------------------
27303|     13|  uint8_t* d = dst_ptr;
27304|     13|  const uint8_t* s = src_ptr;
27305|     13|  size_t n = len;
27306|       |
27307|       |  // TODO: unroll.
27308|       |
27309|    193|  while (n >= 1) {
  ------------------
  |  Branch (27309:10): [True: 180, False: 13]
  ------------------
27310|    180|    uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr(
27311|    180|        wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(
27312|    180|            wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))));
27313|    180|    wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);
27314|       |
27315|    180|    s += 1 * 8;
27316|    180|    d += 1 * 3;
27317|    180|    n -= 1;
27318|    180|  }
27319|       |
27320|     13|  return len;
27321|     13|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_nonpremul_4x16le__src_over:
27378|     13|    size_t src_len) {
27379|     13|  size_t dst_len3 = dst_len / 3;
27380|     13|  size_t src_len8 = src_len / 8;
27381|     13|  size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8;
  ------------------
  |  Branch (27381:16): [True: 1, False: 12]
  ------------------
27382|     13|  uint8_t* d = dst_ptr;
27383|     13|  const uint8_t* s = src_ptr;
27384|     13|  size_t n = len;
27385|       |
27386|       |  // TODO: unroll.
27387|       |
27388|    138|  while (n >= 1) {
  ------------------
  |  Branch (27388:10): [True: 125, False: 13]
  ------------------
27389|       |    // Extract 16-bit color components.
27390|    125|    uint32_t dr = 0x101 * ((uint32_t)d[2]);
27391|    125|    uint32_t dg = 0x101 * ((uint32_t)d[1]);
27392|    125|    uint32_t db = 0x101 * ((uint32_t)d[0]);
27393|    125|    uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6));
27394|    125|    uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4));
27395|    125|    uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2));
27396|    125|    uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0));
27397|       |
27398|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
27399|    125|    uint32_t ia = 0xFFFF - sa;
27400|       |
27401|       |    // Composite src (nonpremul) over dst (premul).
27402|    125|    dr = ((sr * sa) + (dr * ia)) / 0xFFFF;
27403|    125|    dg = ((sg * sa) + (dg * ia)) / 0xFFFF;
27404|    125|    db = ((sb * sa) + (db * ia)) / 0xFFFF;
27405|       |
27406|       |    // Convert from 16-bit color to 8-bit color.
27407|    125|    d[0] = (uint8_t)(db >> 8);
27408|    125|    d[1] = (uint8_t)(dg >> 8);
27409|    125|    d[2] = (uint8_t)(dr >> 8);
27410|       |
27411|    125|    s += 1 * 8;
27412|    125|    d += 1 * 3;
27413|    125|    n -= 1;
27414|    125|  }
27415|       |
27416|     13|  return len;
27417|     13|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgba_nonpremul__bgra_nonpremul_4x16le__src:
29464|     12|    size_t src_len) {
29465|     12|  size_t dst_len4 = dst_len / 4;
29466|     12|  size_t src_len8 = src_len / 8;
29467|     12|  size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
  ------------------
  |  Branch (29467:16): [True: 3, False: 9]
  ------------------
29468|     12|  uint8_t* d = dst_ptr;
29469|     12|  const uint8_t* s = src_ptr;
29470|       |
29471|     12|  size_t n = len;
29472|     97|  while (n >= 1) {
  ------------------
  |  Branch (29472:10): [True: 85, False: 12]
  ------------------
29473|     85|    wuffs_base__poke_u32le__no_bounds_check(
29474|     85|        d + (0 * 4),
29475|     85|        wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr(
29476|     85|            wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))));
29477|       |
29478|     85|    s += 1 * 8;
29479|     85|    d += 1 * 4;
29480|     85|    n -= 1;
29481|     85|  }
29482|     12|  return len;
29483|     12|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr:
24486|    384|wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr(uint64_t c) {
24487|    384|  uint32_t a = ((uint32_t)(0xFF & (c >> 56)));
24488|    384|  uint32_t r = ((uint32_t)(0xFF & (c >> 40)));
24489|    384|  uint32_t g = ((uint32_t)(0xFF & (c >> 24)));
24490|    384|  uint32_t b = ((uint32_t)(0xFF & (c >> 8)));
24491|    384|  return (a << 24) | (b << 16) | (g << 8) | (r << 0);
24492|    384|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgba_nonpremul__bgra_nonpremul_4x16le__src_over:
29492|     27|    size_t src_len) {
29493|     27|  size_t dst_len4 = dst_len / 4;
29494|     27|  size_t src_len8 = src_len / 8;
29495|     27|  size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
  ------------------
  |  Branch (29495:16): [True: 3, False: 24]
  ------------------
29496|     27|  uint8_t* d = dst_ptr;
29497|     27|  const uint8_t* s = src_ptr;
29498|     27|  size_t n = len;
29499|       |
29500|    251|  while (n >= 1) {
  ------------------
  |  Branch (29500:10): [True: 224, False: 27]
  ------------------
29501|    224|    uint64_t d0 = wuffs_base__color_u32__as__color_u64(
29502|    224|        wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));
29503|    224|    uint64_t s0 = wuffs_base__color_swap_u64_argb_abgr(
29504|    224|        wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)));
29505|    224|    wuffs_base__poke_u32le__no_bounds_check(
29506|    224|        d + (0 * 4),
29507|    224|        wuffs_base__color_u64__as__color_u32(
29508|    224|            wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0,
29509|    224|                                                                       s0)));
29510|       |
29511|    224|    s += 1 * 8;
29512|    224|    d += 1 * 4;
29513|    224|    n -= 1;
29514|    224|  }
29515|       |
29516|     27|  return len;
29517|     27|}
pixel_swizzler_fuzzer.c:wuffs_base__color_swap_u64_argb_abgr:
 4839|    702|wuffs_base__color_swap_u64_argb_abgr(uint64_t u) {
 4840|    702|  uint64_t o = u & 0xFFFF0000FFFF0000ull;
 4841|    702|  uint64_t r = u & 0x0000FFFF00000000ull;
 4842|    702|  uint64_t b = u & 0x000000000000FFFFull;
 4843|    702|  return o | (r >> 32) | (b << 32);
 4844|    702|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul_4x16le__src:
28771|     10|    size_t src_len) {
28772|     10|  size_t dst_len4 = dst_len / 4;
28773|     10|  size_t src_len8 = src_len / 8;
28774|     10|  size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
  ------------------
  |  Branch (28774:16): [True: 2, False: 8]
  ------------------
28775|     10|  uint8_t* d = dst_ptr;
28776|     10|  const uint8_t* s = src_ptr;
28777|     10|  size_t n = len;
28778|       |
28779|       |  // TODO: unroll.
28780|       |
28781|     79|  while (n >= 1) {
  ------------------
  |  Branch (28781:10): [True: 69, False: 10]
  ------------------
28782|     69|    uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));
28783|     69|    wuffs_base__poke_u32le__no_bounds_check(
28784|     69|        d + (0 * 4),
28785|     69|        wuffs_base__color_swap_u32_argb_abgr(
28786|     69|            wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(
28787|     69|                s0)));
28788|       |
28789|     69|    s += 1 * 8;
28790|     69|    d += 1 * 4;
28791|     69|    n -= 1;
28792|     69|  }
28793|       |
28794|     10|  return len;
28795|     10|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul_4x16le__src_over:
28804|     14|    size_t src_len) {
28805|     14|  size_t dst_len4 = dst_len / 4;
28806|     14|  size_t src_len8 = src_len / 8;
28807|     14|  size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
  ------------------
  |  Branch (28807:16): [True: 2, False: 12]
  ------------------
28808|     14|  uint8_t* d = dst_ptr;
28809|     14|  const uint8_t* s = src_ptr;
28810|     14|  size_t n = len;
28811|       |
28812|       |  // TODO: unroll.
28813|       |
28814|    128|  while (n >= 1) {
  ------------------
  |  Branch (28814:10): [True: 114, False: 14]
  ------------------
28815|    114|    uint64_t d0 = wuffs_base__color_u32__as__color_u64(
28816|    114|        wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));
28817|    114|    uint64_t s0 = wuffs_base__color_swap_u64_argb_abgr(
28818|    114|        wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)));
28819|    114|    wuffs_base__poke_u32le__no_bounds_check(
28820|    114|        d + (0 * 4),
28821|    114|        wuffs_base__color_u64__as__color_u32(
28822|    114|            wuffs_private_impl__composite_premul_nonpremul_u64_axxx(d0, s0)));
28823|       |
28824|    114|    s += 1 * 8;
28825|    114|    d += 1 * 4;
28826|    114|    n -= 1;
28827|    114|  }
28828|       |
28829|     14|  return len;
28830|     14|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgra_premul:
31993|    281|    wuffs_base__pixel_blend blend) {
31994|    281|  switch (dst_pixfmt.repr) {
  ------------------
  |  Branch (31994:11): [True: 251, False: 30]
  ------------------
31995|     40|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|     40|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (31995:5): [True: 40, False: 241]
  ------------------
31996|     40|      switch (blend) {
  ------------------
  |  Branch (31996:15): [True: 40, False: 0]
  ------------------
31997|     19|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     19|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (31997:9): [True: 19, False: 21]
  ------------------
31998|     19|          return wuffs_private_impl__swizzle_y__bgra_premul__src;
31999|     21|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     21|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (31999:9): [True: 21, False: 19]
  ------------------
32000|     21|          return wuffs_private_impl__swizzle_y__bgra_premul__src_over;
32001|     40|      }
32002|      0|      return NULL;
32003|       |
32004|     21|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|     21|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (32004:5): [True: 21, False: 260]
  ------------------
32005|     21|      switch (blend) {
  ------------------
  |  Branch (32005:15): [True: 21, False: 0]
  ------------------
32006|     12|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     12|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32006:9): [True: 12, False: 9]
  ------------------
32007|     12|          return wuffs_private_impl__swizzle_bgr_565__bgra_premul__src;
32008|      9|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32008:9): [True: 9, False: 12]
  ------------------
32009|      9|          return wuffs_private_impl__swizzle_bgr_565__bgra_premul__src_over;
32010|     21|      }
32011|      0|      return NULL;
32012|       |
32013|     16|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|     16|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (32013:5): [True: 16, False: 265]
  ------------------
32014|     16|      switch (blend) {
  ------------------
  |  Branch (32014:15): [True: 16, False: 0]
  ------------------
32015|      6|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      6|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32015:9): [True: 6, False: 10]
  ------------------
32016|      6|          return wuffs_private_impl__swizzle_bgr__bgra_premul__src;
32017|     10|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32017:9): [True: 10, False: 6]
  ------------------
32018|     10|          return wuffs_private_impl__swizzle_bgr__bgra_premul__src_over;
32019|     16|      }
32020|      0|      return NULL;
32021|       |
32022|     30|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|     30|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (32022:5): [True: 30, False: 251]
  ------------------
32023|     30|      switch (blend) {
  ------------------
  |  Branch (32023:15): [True: 30, False: 0]
  ------------------
32024|     21|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     21|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32024:9): [True: 21, False: 9]
  ------------------
32025|     21|          return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src;
32026|      9|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32026:9): [True: 9, False: 21]
  ------------------
32027|      9|          return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src_over;
32028|     30|      }
32029|      0|      return NULL;
32030|       |
32031|     59|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|     59|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (32031:5): [True: 59, False: 222]
  ------------------
32032|     59|      switch (blend) {
  ------------------
  |  Branch (32032:15): [True: 59, False: 0]
  ------------------
32033|     30|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     30|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32033:9): [True: 30, False: 29]
  ------------------
32034|     30|          return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src;
32035|     29|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     29|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32035:9): [True: 29, False: 30]
  ------------------
32036|     29|          return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src_over;
32037|     59|      }
32038|      0|      return NULL;
32039|       |
32040|     19|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|     19|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (32040:5): [True: 19, False: 262]
  ------------------
32041|     19|      switch (blend) {
  ------------------
  |  Branch (32041:15): [True: 19, False: 0]
  ------------------
32042|     16|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     16|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32042:9): [True: 16, False: 3]
  ------------------
32043|     16|          return wuffs_private_impl__swizzle_copy_4_4;
32044|      3|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      3|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32044:9): [True: 3, False: 16]
  ------------------
32045|      3|          return wuffs_private_impl__swizzle_bgra_premul__bgra_premul__src_over;
32046|     19|      }
32047|      0|      return NULL;
32048|       |
32049|     15|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|     15|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (32049:5): [True: 15, False: 266]
  ------------------
32050|     15|      switch (blend) {
  ------------------
  |  Branch (32050:15): [True: 15, False: 0]
  ------------------
32051|      6|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      6|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32051:9): [True: 6, False: 9]
  ------------------
32052|      6|          return wuffs_private_impl__swizzle_bgr__rgba_premul__src;
32053|      9|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32053:9): [True: 9, False: 6]
  ------------------
32054|      9|          return wuffs_private_impl__swizzle_bgr__rgba_premul__src_over;
32055|     15|      }
32056|      0|      return NULL;
32057|       |
32058|     44|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|     44|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (32058:5): [True: 44, False: 237]
  ------------------
32059|     44|      switch (blend) {
  ------------------
  |  Branch (32059:15): [True: 44, False: 0]
  ------------------
32060|     21|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     21|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32060:9): [True: 21, False: 23]
  ------------------
32061|     21|          return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src;
32062|     23|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     23|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32062:9): [True: 23, False: 21]
  ------------------
32063|     23|          return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src_over;
32064|     44|      }
32065|      0|      return NULL;
32066|       |
32067|      7|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|      7|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (32067:5): [True: 7, False: 274]
  ------------------
32068|      7|      switch (blend) {
  ------------------
  |  Branch (32068:15): [True: 7, False: 0]
  ------------------
32069|      5|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      5|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32069:9): [True: 5, False: 2]
  ------------------
32070|      5|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
32071|      5|          if (wuffs_base__cpu_arch__have_x86_sse42()) {
  ------------------
  |  Branch (32071:15): [True: 5, False: 0]
  ------------------
32072|      5|            return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42;
32073|      5|          }
32074|      0|#endif
32075|      0|          return wuffs_private_impl__swizzle_swap_rgbx_bgrx;
32076|      2|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      2|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32076:9): [True: 2, False: 5]
  ------------------
32077|      2|          return wuffs_private_impl__swizzle_bgra_premul__rgba_premul__src_over;
32078|      7|      }
32079|      0|      return NULL;
32080|    281|  }
32081|     30|  return NULL;
32082|    281|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_premul__src:
30542|     19|                                                size_t src_len) {
30543|     19|  size_t src_len4 = src_len / 4;
30544|     19|  size_t len = (dst_len < src_len4) ? dst_len : src_len4;
  ------------------
  |  Branch (30544:16): [True: 2, False: 17]
  ------------------
30545|     19|  uint8_t* d = dst_ptr;
30546|     19|  const uint8_t* s = src_ptr;
30547|     19|  size_t n = len;
30548|       |
30549|       |  // TODO: unroll.
30550|       |
30551|    339|  while (n >= 1) {
  ------------------
  |  Branch (30551:10): [True: 320, False: 19]
  ------------------
30552|    320|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
30553|    320|    d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0);
30554|       |
30555|    320|    s += 1 * 4;
30556|    320|    d += 1 * 1;
30557|    320|    n -= 1;
30558|    320|  }
30559|       |
30560|     19|  return len;
30561|     19|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_premul__src_over:
30569|     21|                                                     size_t src_len) {
30570|     21|  size_t src_len4 = src_len / 4;
30571|     21|  size_t len = (dst_len < src_len4) ? dst_len : src_len4;
  ------------------
  |  Branch (30571:16): [True: 3, False: 18]
  ------------------
30572|     21|  uint8_t* d = dst_ptr;
30573|     21|  const uint8_t* s = src_ptr;
30574|     21|  size_t n = len;
30575|       |
30576|       |  // TODO: unroll.
30577|       |
30578|    382|  while (n >= 1) {
  ------------------
  |  Branch (30578:10): [True: 361, False: 21]
  ------------------
30579|       |    // Extract 16-bit color components.
30580|    361|    uint32_t dr = 0x101 * ((uint32_t)d[0]);
30581|    361|    uint32_t dg = 0x101 * ((uint32_t)d[0]);
30582|    361|    uint32_t db = 0x101 * ((uint32_t)d[0]);
30583|    361|    uint32_t sa = 0x101 * ((uint32_t)s[3]);
30584|    361|    uint32_t sr = 0x101 * ((uint32_t)s[2]);
30585|    361|    uint32_t sg = 0x101 * ((uint32_t)s[1]);
30586|    361|    uint32_t sb = 0x101 * ((uint32_t)s[0]);
30587|       |
30588|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
30589|    361|    uint32_t ia = 0xFFFF - sa;
30590|       |
30591|       |    // Composite src (premul) over dst (premul).
30592|    361|    dr = sr + ((dr * ia) / 0xFFFF);
30593|    361|    dg = sg + ((dg * ia) / 0xFFFF);
30594|    361|    db = sb + ((db * ia) / 0xFFFF);
30595|       |
30596|       |    // Convert to 16-bit color to 8-bit gray.
30597|    361|    uint32_t weighted_average =
30598|    361|        (19595 * dr) + (38470 * dg) + (7471 * db) + 32768;
30599|    361|    d[0] = (uint8_t)(weighted_average >> 24);
30600|       |
30601|    361|    s += 1 * 4;
30602|    361|    d += 1 * 1;
30603|    361|    n -= 1;
30604|    361|  }
30605|       |
30606|     21|  return len;
30607|     21|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_premul__src:
26247|     12|                                                      size_t src_len) {
26248|     12|  size_t dst_len2 = dst_len / 2;
26249|     12|  size_t src_len4 = src_len / 4;
26250|     12|  size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;
  ------------------
  |  Branch (26250:16): [True: 2, False: 10]
  ------------------
26251|     12|  uint8_t* d = dst_ptr;
26252|     12|  const uint8_t* s = src_ptr;
26253|     12|  size_t n = len;
26254|       |
26255|       |  // TODO: unroll.
26256|       |
26257|    307|  while (n >= 1) {
  ------------------
  |  Branch (26257:10): [True: 295, False: 12]
  ------------------
26258|    295|    wuffs_base__poke_u16le__no_bounds_check(
26259|    295|        d + (0 * 2), wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(
26260|    295|                         wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))));
26261|       |
26262|    295|    s += 1 * 4;
26263|    295|    d += 1 * 2;
26264|    295|    n -= 1;
26265|    295|  }
26266|       |
26267|     12|  return len;
26268|     12|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_premul__src_over:
26309|      9|    size_t src_len) {
26310|      9|  size_t dst_len2 = dst_len / 2;
26311|      9|  size_t src_len4 = src_len / 4;
26312|      9|  size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;
  ------------------
  |  Branch (26312:16): [True: 1, False: 8]
  ------------------
26313|      9|  uint8_t* d = dst_ptr;
26314|      9|  const uint8_t* s = src_ptr;
26315|      9|  size_t n = len;
26316|       |
26317|       |  // TODO: unroll.
26318|       |
26319|    181|  while (n >= 1) {
  ------------------
  |  Branch (26319:10): [True: 172, False: 9]
  ------------------
26320|       |    // Extract 16-bit color components.
26321|    172|    uint32_t sa = 0x101 * ((uint32_t)s[3]);
26322|    172|    uint32_t sr = 0x101 * ((uint32_t)s[2]);
26323|    172|    uint32_t sg = 0x101 * ((uint32_t)s[1]);
26324|    172|    uint32_t sb = 0x101 * ((uint32_t)s[0]);
26325|       |
26326|       |    // Convert from 565 color to 16-bit color.
26327|    172|    uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));
26328|    172|    uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);
26329|    172|    uint32_t dr = (0x8421 * old_r5) >> 4;
26330|    172|    uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);
26331|    172|    uint32_t dg = (0x1041 * old_g6) >> 2;
26332|    172|    uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);
26333|    172|    uint32_t db = (0x8421 * old_b5) >> 4;
26334|       |
26335|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
26336|    172|    uint32_t ia = 0xFFFF - sa;
26337|       |
26338|       |    // Composite src (premul) over dst (premul).
26339|    172|    dr = sr + ((dr * ia) / 0xFFFF);
26340|    172|    dg = sg + ((dg * ia) / 0xFFFF);
26341|    172|    db = sb + ((db * ia) / 0xFFFF);
26342|       |
26343|       |    // Convert from 16-bit color to 565 color and combine the components.
26344|    172|    uint32_t new_r5 = 0x1F & (dr >> 11);
26345|    172|    uint32_t new_g6 = 0x3F & (dg >> 10);
26346|    172|    uint32_t new_b5 = 0x1F & (db >> 11);
26347|    172|    uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);
26348|    172|    wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);
26349|       |
26350|    172|    s += 1 * 4;
26351|    172|    d += 1 * 2;
26352|    172|    n -= 1;
26353|    172|  }
26354|       |
26355|      9|  return len;
26356|      9|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_premul__src:
27115|     18|                                                  size_t src_len) {
27116|     18|  size_t dst_len3 = dst_len / 3;
27117|     18|  size_t src_len4 = src_len / 4;
27118|     18|  size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;
  ------------------
  |  Branch (27118:16): [True: 1, False: 17]
  ------------------
27119|     18|  uint8_t* d = dst_ptr;
27120|     18|  const uint8_t* s = src_ptr;
27121|     18|  size_t n = len;
27122|       |
27123|    417|  while (n >= 1) {
  ------------------
  |  Branch (27123:10): [True: 399, False: 18]
  ------------------
27124|    399|    uint8_t s0 = s[0];
27125|    399|    uint8_t s1 = s[1];
27126|    399|    uint8_t s2 = s[2];
27127|    399|    d[0] = s0;
27128|    399|    d[1] = s1;
27129|    399|    d[2] = s2;
27130|       |
27131|    399|    s += 1 * 4;
27132|    399|    d += 1 * 3;
27133|    399|    n -= 1;
27134|    399|  }
27135|       |
27136|     18|  return len;
27137|     18|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_premul__src_over:
27175|     18|                                                       size_t src_len) {
27176|     18|  size_t dst_len3 = dst_len / 3;
27177|     18|  size_t src_len4 = src_len / 4;
27178|     18|  size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;
  ------------------
  |  Branch (27178:16): [True: 7, False: 11]
  ------------------
27179|     18|  uint8_t* d = dst_ptr;
27180|     18|  const uint8_t* s = src_ptr;
27181|     18|  size_t n = len;
27182|       |
27183|    415|  while (n >= 1) {
  ------------------
  |  Branch (27183:10): [True: 397, False: 18]
  ------------------
27184|       |    // Extract 16-bit color components.
27185|    397|    uint32_t dr = 0x101 * ((uint32_t)d[2]);
27186|    397|    uint32_t dg = 0x101 * ((uint32_t)d[1]);
27187|    397|    uint32_t db = 0x101 * ((uint32_t)d[0]);
27188|    397|    uint32_t sa = 0x101 * ((uint32_t)s[3]);
27189|    397|    uint32_t sr = 0x101 * ((uint32_t)s[2]);
27190|    397|    uint32_t sg = 0x101 * ((uint32_t)s[1]);
27191|    397|    uint32_t sb = 0x101 * ((uint32_t)s[0]);
27192|       |
27193|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
27194|    397|    uint32_t ia = 0xFFFF - sa;
27195|       |
27196|       |    // Composite src (premul) over dst (premul).
27197|    397|    dr = sr + ((dr * ia) / 0xFFFF);
27198|    397|    dg = sg + ((dg * ia) / 0xFFFF);
27199|    397|    db = sb + ((db * ia) / 0xFFFF);
27200|       |
27201|       |    // Convert from 16-bit color to 8-bit color.
27202|    397|    d[0] = (uint8_t)(db >> 8);
27203|    397|    d[1] = (uint8_t)(dg >> 8);
27204|    397|    d[2] = (uint8_t)(dr >> 8);
27205|       |
27206|    397|    s += 1 * 4;
27207|    397|    d += 1 * 3;
27208|    397|    n -= 1;
27209|    397|  }
27210|       |
27211|     18|  return len;
27212|     18|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src:
27704|     39|    size_t src_len) {
27705|     39|  size_t dst_len4 = dst_len / 4;
27706|     39|  size_t src_len4 = src_len / 4;
27707|     39|  size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
  ------------------
  |  Branch (27707:16): [True: 11, False: 28]
  ------------------
27708|     39|  uint8_t* d = dst_ptr;
27709|     39|  const uint8_t* s = src_ptr;
27710|     39|  size_t n = len;
27711|       |
27712|    535|  while (n >= 1) {
  ------------------
  |  Branch (27712:10): [True: 496, False: 39]
  ------------------
27713|    496|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
27714|    496|    wuffs_base__poke_u32le__no_bounds_check(
27715|    496|        d + (0 * 4),
27716|    496|        wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(s0));
27717|       |
27718|    496|    s += 1 * 4;
27719|    496|    d += 1 * 4;
27720|    496|    n -= 1;
27721|    496|  }
27722|       |
27723|     39|  return len;
27724|     39|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src_over:
27733|     33|    size_t src_len) {
27734|     33|  size_t dst_len4 = dst_len / 4;
27735|     33|  size_t src_len4 = src_len / 4;
27736|     33|  size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
  ------------------
  |  Branch (27736:16): [True: 8, False: 25]
  ------------------
27737|     33|  uint8_t* d = dst_ptr;
27738|     33|  const uint8_t* s = src_ptr;
27739|     33|  size_t n = len;
27740|       |
27741|    463|  while (n >= 1) {
  ------------------
  |  Branch (27741:10): [True: 430, False: 33]
  ------------------
27742|    430|    uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));
27743|    430|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
27744|    430|    wuffs_base__poke_u32le__no_bounds_check(
27745|    430|        d + (0 * 4),
27746|    430|        wuffs_private_impl__composite_nonpremul_premul_u32_axxx(d0, s0));
27747|       |
27748|    430|    s += 1 * 4;
27749|    430|    d += 1 * 4;
27750|    430|    n -= 1;
27751|    430|  }
27752|       |
27753|     33|  return len;
27754|     33|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_nonpremul_premul_u32_axxx:
25527|    926|                                                        uint32_t src_premul) {
25528|       |  // Extract 16-bit color components.
25529|    926|  uint32_t da = 0x101 * (0xFF & (dst_nonpremul >> 24));
25530|    926|  uint32_t dr = 0x101 * (0xFF & (dst_nonpremul >> 16));
25531|    926|  uint32_t dg = 0x101 * (0xFF & (dst_nonpremul >> 8));
25532|    926|  uint32_t db = 0x101 * (0xFF & (dst_nonpremul >> 0));
25533|    926|  uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));
25534|    926|  uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));
25535|    926|  uint32_t sg = 0x101 * (0xFF & (src_premul >> 8));
25536|    926|  uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));
25537|       |
25538|       |  // Convert dst from nonpremul to premul.
25539|    926|  dr = (dr * da) / 0xFFFF;
25540|    926|  dg = (dg * da) / 0xFFFF;
25541|    926|  db = (db * da) / 0xFFFF;
25542|       |
25543|       |  // Calculate the inverse of the src-alpha: how much of the dst to keep.
25544|    926|  uint32_t ia = 0xFFFF - sa;
25545|       |
25546|       |  // Composite src (premul) over dst (premul).
25547|    926|  da = sa + ((da * ia) / 0xFFFF);
25548|    926|  dr = sr + ((dr * ia) / 0xFFFF);
25549|    926|  dg = sg + ((dg * ia) / 0xFFFF);
25550|    926|  db = sb + ((db * ia) / 0xFFFF);
25551|       |
25552|       |  // Convert dst from premul to nonpremul.
25553|    926|  if (da != 0) {
  ------------------
  |  Branch (25553:7): [True: 759, False: 167]
  ------------------
25554|    759|    dr = (dr * 0xFFFF) / da;
25555|    759|    dg = (dg * 0xFFFF) / da;
25556|    759|    db = (db * 0xFFFF) / da;
25557|    759|  }
25558|       |
25559|       |  // Convert from 16-bit color to 8-bit color.
25560|    926|  da >>= 8;
25561|    926|  dr >>= 8;
25562|    926|  dg >>= 8;
25563|    926|  db >>= 8;
25564|       |
25565|       |  // Combine components.
25566|    926|  return (db << 0) | (dg << 8) | (dr << 16) | (da << 24);
25567|    926|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src:
28110|     30|    size_t src_len) {
28111|     30|  size_t dst_len8 = dst_len / 8;
28112|     30|  size_t src_len4 = src_len / 4;
28113|     30|  size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
  ------------------
  |  Branch (28113:16): [True: 11, False: 19]
  ------------------
28114|     30|  uint8_t* d = dst_ptr;
28115|     30|  const uint8_t* s = src_ptr;
28116|       |
28117|     30|  size_t n = len;
28118|    179|  while (n >= 1) {
  ------------------
  |  Branch (28118:10): [True: 149, False: 30]
  ------------------
28119|    149|    uint64_t s0 = wuffs_base__color_u32__as__color_u64(
28120|    149|        wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(
28121|    149|            wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))));
28122|    149|    wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0);
28123|       |
28124|    149|    s += 1 * 4;
28125|    149|    d += 1 * 8;
28126|    149|    n -= 1;
28127|    149|  }
28128|     30|  return len;
28129|     30|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src_over:
28138|     29|    size_t src_len) {
28139|     29|  size_t dst_len8 = dst_len / 8;
28140|     29|  size_t src_len4 = src_len / 4;
28141|     29|  size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
  ------------------
  |  Branch (28141:16): [True: 7, False: 22]
  ------------------
28142|     29|  uint8_t* d = dst_ptr;
28143|     29|  const uint8_t* s = src_ptr;
28144|       |
28145|     29|  size_t n = len;
28146|    218|  while (n >= 1) {
  ------------------
  |  Branch (28146:10): [True: 189, False: 29]
  ------------------
28147|    189|    uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));
28148|    189|    uint64_t s0 = wuffs_base__color_u32__as__color_u64(
28149|    189|        wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
28150|    189|    wuffs_base__poke_u64le__no_bounds_check(
28151|    189|        d + (0 * 8),
28152|    189|        wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0));
28153|       |
28154|    189|    s += 1 * 4;
28155|    189|    d += 1 * 8;
28156|    189|    n -= 1;
28157|    189|  }
28158|     29|  return len;
28159|     29|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_nonpremul_premul_u64_axxx:
25571|  1.14k|                                                        uint64_t src_premul) {
25572|       |  // Extract components.
25573|  1.14k|  uint64_t da = 0xFFFF & (dst_nonpremul >> 48);
25574|  1.14k|  uint64_t dr = 0xFFFF & (dst_nonpremul >> 32);
25575|  1.14k|  uint64_t dg = 0xFFFF & (dst_nonpremul >> 16);
25576|  1.14k|  uint64_t db = 0xFFFF & (dst_nonpremul >> 0);
25577|  1.14k|  uint64_t sa = 0xFFFF & (src_premul >> 48);
25578|  1.14k|  uint64_t sr = 0xFFFF & (src_premul >> 32);
25579|  1.14k|  uint64_t sg = 0xFFFF & (src_premul >> 16);
25580|  1.14k|  uint64_t sb = 0xFFFF & (src_premul >> 0);
25581|       |
25582|       |  // Convert dst from nonpremul to premul.
25583|  1.14k|  dr = (dr * da) / 0xFFFF;
25584|  1.14k|  dg = (dg * da) / 0xFFFF;
25585|  1.14k|  db = (db * da) / 0xFFFF;
25586|       |
25587|       |  // Calculate the inverse of the src-alpha: how much of the dst to keep.
25588|  1.14k|  uint64_t ia = 0xFFFF - sa;
25589|       |
25590|       |  // Composite src (premul) over dst (premul).
25591|  1.14k|  da = sa + ((da * ia) / 0xFFFF);
25592|  1.14k|  dr = sr + ((dr * ia) / 0xFFFF);
25593|  1.14k|  dg = sg + ((dg * ia) / 0xFFFF);
25594|  1.14k|  db = sb + ((db * ia) / 0xFFFF);
25595|       |
25596|       |  // Convert dst from premul to nonpremul.
25597|  1.14k|  if (da != 0) {
  ------------------
  |  Branch (25597:7): [True: 958, False: 183]
  ------------------
25598|    958|    dr = (dr * 0xFFFF) / da;
25599|    958|    dg = (dg * 0xFFFF) / da;
25600|    958|    db = (db * 0xFFFF) / da;
25601|    958|  }
25602|       |
25603|       |  // Combine components.
25604|  1.14k|  return (db << 0) | (dg << 16) | (dr << 32) | (da << 48);
25605|  1.14k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_premul__src_over:
28604|     14|    size_t src_len) {
28605|     14|  size_t dst_len4 = dst_len / 4;
28606|     14|  size_t src_len4 = src_len / 4;
28607|     14|  size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
  ------------------
  |  Branch (28607:16): [True: 1, False: 13]
  ------------------
28608|     14|  uint8_t* d = dst_ptr;
28609|     14|  const uint8_t* s = src_ptr;
28610|     14|  size_t n = len;
28611|       |
28612|       |  // TODO: unroll.
28613|       |
28614|    152|  while (n >= 1) {
  ------------------
  |  Branch (28614:10): [True: 138, False: 14]
  ------------------
28615|    138|    uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));
28616|    138|    uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
28617|    138|    wuffs_base__poke_u32le__no_bounds_check(
28618|    138|        d + (0 * 4),
28619|    138|        wuffs_private_impl__composite_premul_premul_u32_axxx(d0, s0));
28620|       |
28621|    138|    s += 1 * 4;
28622|    138|    d += 1 * 4;
28623|    138|    n -= 1;
28624|    138|  }
28625|       |
28626|     14|  return len;
28627|     14|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_premul_premul_u32_axxx:
25669|    525|                                                     uint32_t src_premul) {
25670|       |  // Extract 16-bit color components.
25671|    525|  uint32_t da = 0x101 * (0xFF & (dst_premul >> 24));
25672|    525|  uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16));
25673|    525|  uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8));
25674|    525|  uint32_t db = 0x101 * (0xFF & (dst_premul >> 0));
25675|    525|  uint32_t sa = 0x101 * (0xFF & (src_premul >> 24));
25676|    525|  uint32_t sr = 0x101 * (0xFF & (src_premul >> 16));
25677|    525|  uint32_t sg = 0x101 * (0xFF & (src_premul >> 8));
25678|    525|  uint32_t sb = 0x101 * (0xFF & (src_premul >> 0));
25679|       |
25680|       |  // Calculate the inverse of the src-alpha: how much of the dst to keep.
25681|    525|  uint32_t ia = 0xFFFF - sa;
25682|       |
25683|       |  // Composite src (premul) over dst (premul).
25684|    525|  da = sa + ((da * ia) / 0xFFFF);
25685|    525|  dr = sr + ((dr * ia) / 0xFFFF);
25686|    525|  dg = sg + ((dg * ia) / 0xFFFF);
25687|    525|  db = sb + ((db * ia) / 0xFFFF);
25688|       |
25689|       |  // Convert from 16-bit color to 8-bit color.
25690|    525|  da >>= 8;
25691|    525|  dr >>= 8;
25692|    525|  dg >>= 8;
25693|    525|  db >>= 8;
25694|       |
25695|       |  // Combine components.
25696|    525|  return (db << 0) | (dg << 8) | (dr << 16) | (da << 24);
25697|    525|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_premul__src:
27425|     15|                                                  size_t src_len) {
27426|     15|  size_t dst_len3 = dst_len / 3;
27427|     15|  size_t src_len4 = src_len / 4;
27428|     15|  size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;
  ------------------
  |  Branch (27428:16): [True: 5, False: 10]
  ------------------
27429|     15|  uint8_t* d = dst_ptr;
27430|     15|  const uint8_t* s = src_ptr;
27431|     15|  size_t n = len;
27432|       |
27433|    206|  while (n >= 1) {
  ------------------
  |  Branch (27433:10): [True: 191, False: 15]
  ------------------
27434|    191|    uint8_t s0 = s[0];
27435|    191|    uint8_t s1 = s[1];
27436|    191|    uint8_t s2 = s[2];
27437|    191|    d[0] = s2;
27438|    191|    d[1] = s1;
27439|    191|    d[2] = s0;
27440|       |
27441|    191|    s += 1 * 4;
27442|    191|    d += 1 * 3;
27443|    191|    n -= 1;
27444|    191|  }
27445|       |
27446|     15|  return len;
27447|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_premul__src_over:
27486|     12|                                                       size_t src_len) {
27487|     12|  size_t dst_len3 = dst_len / 3;
27488|     12|  size_t src_len4 = src_len / 4;
27489|     12|  size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;
  ------------------
  |  Branch (27489:16): [True: 4, False: 8]
  ------------------
27490|     12|  uint8_t* d = dst_ptr;
27491|     12|  const uint8_t* s = src_ptr;
27492|     12|  size_t n = len;
27493|       |
27494|    178|  while (n >= 1) {
  ------------------
  |  Branch (27494:10): [True: 166, False: 12]
  ------------------
27495|       |    // Extract 16-bit color components.
27496|    166|    uint32_t dr = 0x101 * ((uint32_t)d[2]);
27497|    166|    uint32_t dg = 0x101 * ((uint32_t)d[1]);
27498|    166|    uint32_t db = 0x101 * ((uint32_t)d[0]);
27499|    166|    uint32_t sa = 0x101 * ((uint32_t)s[3]);
27500|    166|    uint32_t sb = 0x101 * ((uint32_t)s[2]);
27501|    166|    uint32_t sg = 0x101 * ((uint32_t)s[1]);
27502|    166|    uint32_t sr = 0x101 * ((uint32_t)s[0]);
27503|       |
27504|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
27505|    166|    uint32_t ia = 0xFFFF - sa;
27506|       |
27507|       |    // Composite src (premul) over dst (premul).
27508|    166|    dr = sr + ((dr * ia) / 0xFFFF);
27509|    166|    dg = sg + ((dg * ia) / 0xFFFF);
27510|    166|    db = sb + ((db * ia) / 0xFFFF);
27511|       |
27512|       |    // Convert from 16-bit color to 8-bit color.
27513|    166|    d[0] = (uint8_t)(db >> 8);
27514|    166|    d[1] = (uint8_t)(dg >> 8);
27515|    166|    d[2] = (uint8_t)(dr >> 8);
27516|       |
27517|    166|    s += 1 * 4;
27518|    166|    d += 1 * 3;
27519|    166|    n -= 1;
27520|    166|  }
27521|       |
27522|     12|  return len;
27523|     12|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src:
27891|     37|    size_t src_len) {
27892|     37|  size_t dst_len4 = dst_len / 4;
27893|     37|  size_t src_len4 = src_len / 4;
27894|     37|  size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
  ------------------
  |  Branch (27894:16): [True: 6, False: 31]
  ------------------
27895|     37|  uint8_t* d = dst_ptr;
27896|     37|  const uint8_t* s = src_ptr;
27897|     37|  size_t n = len;
27898|       |
27899|    506|  while (n >= 1) {
  ------------------
  |  Branch (27899:10): [True: 469, False: 37]
  ------------------
27900|    469|    uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr(
27901|    469|        wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
27902|    469|    wuffs_base__poke_u32le__no_bounds_check(
27903|    469|        d + (0 * 4),
27904|    469|        wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(s0));
27905|       |
27906|    469|    s += 1 * 4;
27907|    469|    d += 1 * 4;
27908|    469|    n -= 1;
27909|    469|  }
27910|       |
27911|     37|  return len;
27912|     37|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src_over:
27921|     32|    size_t src_len) {
27922|     32|  size_t dst_len4 = dst_len / 4;
27923|     32|  size_t src_len4 = src_len / 4;
27924|     32|  size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
  ------------------
  |  Branch (27924:16): [True: 7, False: 25]
  ------------------
27925|     32|  uint8_t* d = dst_ptr;
27926|     32|  const uint8_t* s = src_ptr;
27927|     32|  size_t n = len;
27928|       |
27929|    528|  while (n >= 1) {
  ------------------
  |  Branch (27929:10): [True: 496, False: 32]
  ------------------
27930|    496|    uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));
27931|    496|    uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr(
27932|    496|        wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
27933|    496|    wuffs_base__poke_u32le__no_bounds_check(
27934|    496|        d + (0 * 4),
27935|    496|        wuffs_private_impl__composite_nonpremul_premul_u32_axxx(d0, s0));
27936|       |
27937|    496|    s += 1 * 4;
27938|    496|    d += 1 * 4;
27939|    496|    n -= 1;
27940|    496|  }
27941|       |
27942|     32|  return len;
27943|     32|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_premul__src_over:
28839|     13|    size_t src_len) {
28840|     13|  size_t dst_len4 = dst_len / 4;
28841|     13|  size_t src_len4 = src_len / 4;
28842|     13|  size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
  ------------------
  |  Branch (28842:16): [True: 2, False: 11]
  ------------------
28843|     13|  uint8_t* d = dst_ptr;
28844|     13|  const uint8_t* s = src_ptr;
28845|     13|  size_t n = len;
28846|       |
28847|    182|  while (n >= 1) {
  ------------------
  |  Branch (28847:10): [True: 169, False: 13]
  ------------------
28848|    169|    uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));
28849|    169|    uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr(
28850|    169|        wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
28851|    169|    wuffs_base__poke_u32le__no_bounds_check(
28852|    169|        d + (0 * 4),
28853|    169|        wuffs_private_impl__composite_premul_premul_u32_axxx(d0, s0));
28854|       |
28855|    169|    s += 1 * 4;
28856|    169|    d += 1 * 4;
28857|    169|    n -= 1;
28858|    169|  }
28859|       |
28860|     13|  return len;
28861|     13|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgra_premul_4x16le:
32090|    441|    wuffs_base__pixel_blend blend) {
32091|    441|  switch (dst_pixfmt.repr) {
  ------------------
  |  Branch (32091:11): [True: 428, False: 13]
  ------------------
32092|     28|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|     28|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (32092:5): [True: 28, False: 413]
  ------------------
32093|     28|      switch (blend) {
  ------------------
  |  Branch (32093:15): [True: 28, False: 0]
  ------------------
32094|     10|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32094:9): [True: 10, False: 18]
  ------------------
32095|     10|          return wuffs_private_impl__swizzle_y__bgra_premul_4x16le__src;
32096|     18|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     18|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32096:9): [True: 18, False: 10]
  ------------------
32097|     18|          return wuffs_private_impl__swizzle_y__bgra_premul_4x16le__src_over;
32098|     28|      }
32099|      0|      return NULL;
32100|       |
32101|     18|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|     18|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (32101:5): [True: 18, False: 423]
  ------------------
32102|     18|      switch (blend) {
  ------------------
  |  Branch (32102:15): [True: 18, False: 0]
  ------------------
32103|      8|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      8|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32103:9): [True: 8, False: 10]
  ------------------
32104|      8|          return wuffs_private_impl__swizzle_bgr_565__bgra_premul_4x16le__src;
32105|     10|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32105:9): [True: 10, False: 8]
  ------------------
32106|     10|          return wuffs_private_impl__swizzle_bgr_565__bgra_premul_4x16le__src_over;
32107|     18|      }
32108|      0|      return NULL;
32109|       |
32110|     21|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|     21|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (32110:5): [True: 21, False: 420]
  ------------------
32111|     21|      switch (blend) {
  ------------------
  |  Branch (32111:15): [True: 21, False: 0]
  ------------------
32112|      7|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      7|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32112:9): [True: 7, False: 14]
  ------------------
32113|      7|          return wuffs_private_impl__swizzle_bgr__bgra_premul_4x16le__src;
32114|     14|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     14|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32114:9): [True: 14, False: 7]
  ------------------
32115|     14|          return wuffs_private_impl__swizzle_bgr__bgra_premul_4x16le__src_over;
32116|     21|      }
32117|      0|      return NULL;
32118|       |
32119|     84|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|     84|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (32119:5): [True: 84, False: 357]
  ------------------
32120|     84|      switch (blend) {
  ------------------
  |  Branch (32120:15): [True: 84, False: 0]
  ------------------
32121|     54|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     54|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32121:9): [True: 54, False: 30]
  ------------------
32122|     54|          return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul_4x16le__src;
32123|     30|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     30|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32123:9): [True: 30, False: 54]
  ------------------
32124|     30|          return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul_4x16le__src_over;
32125|     84|      }
32126|      0|      return NULL;
32127|       |
32128|     69|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|     69|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (32128:5): [True: 69, False: 372]
  ------------------
32129|       |
32130|     69|      switch (blend) {
  ------------------
  |  Branch (32130:15): [True: 69, False: 0]
  ------------------
32131|     43|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     43|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32131:9): [True: 43, False: 26]
  ------------------
32132|     43|          return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul_4x16le__src;
32133|     26|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     26|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32133:9): [True: 26, False: 43]
  ------------------
32134|     26|          return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul_4x16le__src_over;
32135|     69|      }
32136|      0|      return NULL;
32137|       |
32138|     30|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|     30|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (32138:5): [True: 30, False: 411]
  ------------------
32139|     30|      switch (blend) {
  ------------------
  |  Branch (32139:15): [True: 30, False: 0]
  ------------------
32140|     15|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     15|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32140:9): [True: 15, False: 15]
  ------------------
32141|     15|          return wuffs_private_impl__swizzle_bgra_premul__bgra_premul_4x16le__src;
32142|     15|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     15|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32142:9): [True: 15, False: 15]
  ------------------
32143|     15|          return wuffs_private_impl__swizzle_bgra_premul__bgra_premul_4x16le__src_over;
32144|     30|      }
32145|      0|      return NULL;
32146|       |
32147|     15|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:
  ------------------
  |  | 4967|     15|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE        0x8200BBBB
  ------------------
  |  Branch (32147:5): [True: 15, False: 426]
  ------------------
32148|     15|      switch (blend) {
  ------------------
  |  Branch (32148:15): [True: 15, False: 0]
  ------------------
32149|      0|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      0|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32149:9): [True: 0, False: 15]
  ------------------
32150|      0|          return wuffs_private_impl__swizzle_copy_8_8;
32151|     15|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     15|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32151:9): [True: 15, False: 0]
  ------------------
32152|     15|          return wuffs_private_impl__swizzle_bgra_premul_4x16le__bgra_premul_4x16le__src_over;
32153|     15|      }
32154|      0|      return NULL;
32155|       |
32156|      0|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
  ------------------
  |  | 4968|      0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY               0x83008888
  ------------------
  |  Branch (32156:5): [True: 0, False: 441]
  ------------------
32157|      3|    case WUFFS_BASE__PIXEL_FORMAT__BGRX:
  ------------------
  |  | 4969|      3|#define WUFFS_BASE__PIXEL_FORMAT__BGRX                      0x90008888
  ------------------
  |  Branch (32157:5): [True: 3, False: 438]
  ------------------
32158|       |      // TODO.
32159|      3|      break;
32160|       |
32161|     34|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|     34|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (32161:5): [True: 34, False: 407]
  ------------------
32162|     34|      switch (blend) {
  ------------------
  |  Branch (32162:15): [True: 34, False: 0]
  ------------------
32163|     15|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     15|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32163:9): [True: 15, False: 19]
  ------------------
32164|     15|          return wuffs_private_impl__swizzle_bgr__rgba_premul_4x16le__src;
32165|     19|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     19|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32165:9): [True: 19, False: 15]
  ------------------
32166|     19|          return wuffs_private_impl__swizzle_bgr__rgba_premul_4x16le__src_over;
32167|     34|      }
32168|      0|      return NULL;
32169|       |
32170|     93|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|     93|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (32170:5): [True: 93, False: 348]
  ------------------
32171|     93|      switch (blend) {
  ------------------
  |  Branch (32171:15): [True: 93, False: 0]
  ------------------
32172|     54|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     54|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32172:9): [True: 54, False: 39]
  ------------------
32173|     54|          return wuffs_private_impl__swizzle_rgba_nonpremul__bgra_premul_4x16le__src;
32174|     39|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     39|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32174:9): [True: 39, False: 54]
  ------------------
32175|     39|          return wuffs_private_impl__swizzle_rgba_nonpremul__bgra_premul_4x16le__src_over;
32176|     93|      }
32177|      0|      break;
32178|       |
32179|     33|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|     33|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (32179:5): [True: 33, False: 408]
  ------------------
32180|     33|      switch (blend) {
  ------------------
  |  Branch (32180:15): [True: 33, False: 0]
  ------------------
32181|     23|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     23|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32181:9): [True: 23, False: 10]
  ------------------
32182|     23|          return wuffs_private_impl__swizzle_bgra_premul__rgba_premul_4x16le__src;
32183|     10|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32183:9): [True: 10, False: 23]
  ------------------
32184|     10|          return wuffs_private_impl__swizzle_bgra_premul__rgba_premul_4x16le__src_over;
32185|     33|      }
32186|      0|      return NULL;
32187|       |
32188|      0|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
  ------------------
  |  | 4976|      0|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY               0xA3008888
  ------------------
  |  Branch (32188:5): [True: 0, False: 441]
  ------------------
32189|      0|    case WUFFS_BASE__PIXEL_FORMAT__RGBX:
  ------------------
  |  | 4977|      0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX                      0xB0008888
  ------------------
  |  Branch (32189:5): [True: 0, False: 441]
  ------------------
32190|       |      // TODO.
32191|      0|      break;
32192|    441|  }
32193|     16|  return NULL;
32194|    441|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_premul_4x16le__src:
30615|     10|                                                       size_t src_len) {
30616|     10|  size_t src_len8 = src_len / 8;
30617|     10|  size_t len = (dst_len < src_len8) ? dst_len : src_len8;
  ------------------
  |  Branch (30617:16): [True: 1, False: 9]
  ------------------
30618|     10|  uint8_t* d = dst_ptr;
30619|     10|  const uint8_t* s = src_ptr;
30620|     10|  size_t n = len;
30621|       |
30622|       |  // TODO: unroll.
30623|       |
30624|    117|  while (n >= 1) {
  ------------------
  |  Branch (30624:10): [True: 107, False: 10]
  ------------------
30625|    107|    d[0] = wuffs_base__color_u64_argb_premul__as__color_u8_gray(
30626|    107|        wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)));
30627|       |
30628|    107|    s += 1 * 8;
30629|    107|    d += 1 * 1;
30630|    107|    n -= 1;
30631|    107|  }
30632|       |
30633|     10|  return len;
30634|     10|}
pixel_swizzler_fuzzer.c:wuffs_base__color_u64_argb_premul__as__color_u8_gray:
 4576|    107|wuffs_base__color_u64_argb_premul__as__color_u8_gray(uint64_t argb_premul) {
 4577|    107|  uint32_t r16 = ((uint32_t)(0xFFFF & (argb_premul >> 32)));
 4578|    107|  uint32_t g16 = ((uint32_t)(0xFFFF & (argb_premul >> 16)));
 4579|    107|  uint32_t b16 = ((uint32_t)(0xFFFF & (argb_premul >> 0)));
 4580|       |
 4581|       |  // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same
 4582|       |  // as those given by the JFIF specification.
 4583|       |  //
 4584|       |  // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We
 4585|       |  // shift by 24, not just by 16, because the return value is 8-bit color, not
 4586|       |  // 16-bit color.
 4587|    107|  uint32_t weighted_average =
 4588|    107|      (19595 * r16) + (38470 * g16) + (7471 * b16) + 32768;
 4589|    107|  return (uint8_t)(weighted_average >> 24);
 4590|    107|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgra_premul_4x16le__src_over:
30643|     18|    size_t src_len) {
30644|     18|  size_t src_len8 = src_len / 8;
30645|     18|  size_t len = (dst_len < src_len8) ? dst_len : src_len8;
  ------------------
  |  Branch (30645:16): [True: 4, False: 14]
  ------------------
30646|     18|  uint8_t* d = dst_ptr;
30647|     18|  const uint8_t* s = src_ptr;
30648|     18|  size_t n = len;
30649|       |
30650|       |  // TODO: unroll.
30651|       |
30652|    167|  while (n >= 1) {
  ------------------
  |  Branch (30652:10): [True: 149, False: 18]
  ------------------
30653|       |    // Extract 16-bit color components.
30654|    149|    uint32_t dr = 0x101 * ((uint32_t)d[0]);
30655|    149|    uint32_t dg = 0x101 * ((uint32_t)d[0]);
30656|    149|    uint32_t db = 0x101 * ((uint32_t)d[0]);
30657|    149|    uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6));
30658|    149|    uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4));
30659|    149|    uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2));
30660|    149|    uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0));
30661|       |
30662|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
30663|    149|    uint32_t ia = 0xFFFF - sa;
30664|       |
30665|       |    // Composite src (premul) over dst (premul).
30666|    149|    dr = sr + ((dr * ia) / 0xFFFF);
30667|    149|    dg = sg + ((dg * ia) / 0xFFFF);
30668|    149|    db = sb + ((db * ia) / 0xFFFF);
30669|       |
30670|       |    // Convert to 16-bit color to 8-bit gray.
30671|    149|    uint32_t weighted_average =
30672|    149|        (19595 * dr) + (38470 * dg) + (7471 * db) + 32768;
30673|    149|    d[0] = (uint8_t)(weighted_average >> 24);
30674|       |
30675|    149|    s += 1 * 8;
30676|    149|    d += 1 * 1;
30677|    149|    n -= 1;
30678|    149|  }
30679|       |
30680|     18|  return len;
30681|     18|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_premul_4x16le__src:
26277|      8|    size_t src_len) {
26278|      8|  size_t dst_len2 = dst_len / 2;
26279|      8|  size_t src_len8 = src_len / 8;
26280|      8|  size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8;
  ------------------
  |  Branch (26280:16): [True: 4, False: 4]
  ------------------
26281|      8|  uint8_t* d = dst_ptr;
26282|      8|  const uint8_t* s = src_ptr;
26283|      8|  size_t n = len;
26284|       |
26285|       |  // TODO: unroll.
26286|       |
26287|     58|  while (n >= 1) {
  ------------------
  |  Branch (26287:10): [True: 50, False: 8]
  ------------------
26288|     50|    wuffs_base__poke_u16le__no_bounds_check(
26289|     50|        d + (0 * 2),
26290|     50|        wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(
26291|     50|            wuffs_base__color_u64__as__color_u32(
26292|     50|                wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))));
26293|       |
26294|     50|    s += 1 * 8;
26295|     50|    d += 1 * 2;
26296|     50|    n -= 1;
26297|     50|  }
26298|       |
26299|      8|  return len;
26300|      8|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgra_premul_4x16le__src_over:
26365|     10|    size_t src_len) {
26366|     10|  size_t dst_len2 = dst_len / 2;
26367|     10|  size_t src_len8 = src_len / 8;
26368|     10|  size_t len = (dst_len2 < src_len8) ? dst_len2 : src_len8;
  ------------------
  |  Branch (26368:16): [True: 1, False: 9]
  ------------------
26369|     10|  uint8_t* d = dst_ptr;
26370|     10|  const uint8_t* s = src_ptr;
26371|     10|  size_t n = len;
26372|       |
26373|       |  // TODO: unroll.
26374|       |
26375|    135|  while (n >= 1) {
  ------------------
  |  Branch (26375:10): [True: 125, False: 10]
  ------------------
26376|       |    // Extract 16-bit color components.
26377|    125|    uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6));
26378|    125|    uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4));
26379|    125|    uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2));
26380|    125|    uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0));
26381|       |
26382|       |    // Convert from 565 color to 16-bit color.
26383|    125|    uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));
26384|    125|    uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);
26385|    125|    uint32_t dr = (0x8421 * old_r5) >> 4;
26386|    125|    uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);
26387|    125|    uint32_t dg = (0x1041 * old_g6) >> 2;
26388|    125|    uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);
26389|    125|    uint32_t db = (0x8421 * old_b5) >> 4;
26390|       |
26391|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
26392|    125|    uint32_t ia = 0xFFFF - sa;
26393|       |
26394|       |    // Composite src (premul) over dst (premul).
26395|    125|    dr = sr + ((dr * ia) / 0xFFFF);
26396|    125|    dg = sg + ((dg * ia) / 0xFFFF);
26397|    125|    db = sb + ((db * ia) / 0xFFFF);
26398|       |
26399|       |    // Convert from 16-bit color to 565 color and combine the components.
26400|    125|    uint32_t new_r5 = 0x1F & (dr >> 11);
26401|    125|    uint32_t new_g6 = 0x3F & (dg >> 10);
26402|    125|    uint32_t new_b5 = 0x1F & (db >> 11);
26403|    125|    uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);
26404|    125|    wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);
26405|       |
26406|    125|    s += 1 * 8;
26407|    125|    d += 1 * 2;
26408|    125|    n -= 1;
26409|    125|  }
26410|       |
26411|     10|  return len;
26412|     10|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_premul_4x16le__src:
27146|      7|    size_t src_len) {
27147|      7|  size_t dst_len3 = dst_len / 3;
27148|      7|  size_t src_len8 = src_len / 8;
27149|      7|  size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8;
  ------------------
  |  Branch (27149:16): [True: 1, False: 6]
  ------------------
27150|      7|  uint8_t* d = dst_ptr;
27151|      7|  const uint8_t* s = src_ptr;
27152|      7|  size_t n = len;
27153|       |
27154|       |  // TODO: unroll.
27155|       |
27156|     63|  while (n >= 1) {
  ------------------
  |  Branch (27156:10): [True: 56, False: 7]
  ------------------
27157|     56|    uint32_t s0 = wuffs_base__color_u64__as__color_u32(
27158|     56|        wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)));
27159|     56|    wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);
27160|       |
27161|     56|    s += 1 * 8;
27162|     56|    d += 1 * 3;
27163|     56|    n -= 1;
27164|     56|  }
27165|       |
27166|      7|  return len;
27167|      7|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__bgra_premul_4x16le__src_over:
27221|     14|    size_t src_len) {
27222|     14|  size_t dst_len3 = dst_len / 3;
27223|     14|  size_t src_len8 = src_len / 8;
27224|     14|  size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8;
  ------------------
  |  Branch (27224:16): [True: 2, False: 12]
  ------------------
27225|     14|  uint8_t* d = dst_ptr;
27226|     14|  const uint8_t* s = src_ptr;
27227|     14|  size_t n = len;
27228|       |
27229|       |  // TODO: unroll.
27230|       |
27231|    187|  while (n >= 1) {
  ------------------
  |  Branch (27231:10): [True: 173, False: 14]
  ------------------
27232|       |    // Extract 16-bit color components.
27233|    173|    uint32_t dr = 0x101 * ((uint32_t)d[2]);
27234|    173|    uint32_t dg = 0x101 * ((uint32_t)d[1]);
27235|    173|    uint32_t db = 0x101 * ((uint32_t)d[0]);
27236|    173|    uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6));
27237|    173|    uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4));
27238|    173|    uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2));
27239|    173|    uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0));
27240|       |
27241|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
27242|    173|    uint32_t ia = 0xFFFF - sa;
27243|       |
27244|       |    // Composite src (premul) over dst (premul).
27245|    173|    dr = sr + ((dr * ia) / 0xFFFF);
27246|    173|    dg = sg + ((dg * ia) / 0xFFFF);
27247|    173|    db = sb + ((db * ia) / 0xFFFF);
27248|       |
27249|       |    // Convert from 16-bit color to 8-bit color.
27250|    173|    d[0] = (uint8_t)(db >> 8);
27251|    173|    d[1] = (uint8_t)(dg >> 8);
27252|    173|    d[2] = (uint8_t)(dr >> 8);
27253|       |
27254|    173|    s += 1 * 8;
27255|    173|    d += 1 * 3;
27256|    173|    n -= 1;
27257|    173|  }
27258|       |
27259|     14|  return len;
27260|     14|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul_4x16le__src:
27763|     54|    size_t src_len) {
27764|     54|  size_t dst_len4 = dst_len / 4;
27765|     54|  size_t src_len8 = src_len / 8;
27766|     54|  size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
  ------------------
  |  Branch (27766:16): [True: 4, False: 50]
  ------------------
27767|     54|  uint8_t* d = dst_ptr;
27768|     54|  const uint8_t* s = src_ptr;
27769|       |
27770|     54|  size_t n = len;
27771|    524|  while (n >= 1) {
  ------------------
  |  Branch (27771:10): [True: 470, False: 54]
  ------------------
27772|    470|    wuffs_base__poke_u32le__no_bounds_check(
27773|    470|        d + (0 * 4),
27774|    470|        wuffs_base__color_u64__as__color_u32(
27775|    470|            wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul(
27776|    470|                wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))));
27777|       |
27778|    470|    s += 1 * 8;
27779|    470|    d += 1 * 4;
27780|    470|    n -= 1;
27781|    470|  }
27782|     54|  return len;
27783|     54|}
pixel_swizzler_fuzzer.c:wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul:
 4594|    990|    uint64_t argb_premul) {
 4595|    990|  uint64_t a = 0xFFFF & (argb_premul >> 48);
 4596|    990|  if (a == 0xFFFF) {
  ------------------
  |  Branch (4596:7): [True: 132, False: 858]
  ------------------
 4597|    132|    return argb_premul;
 4598|    858|  } else if (a == 0) {
  ------------------
  |  Branch (4598:14): [True: 175, False: 683]
  ------------------
 4599|    175|    return 0;
 4600|    175|  }
 4601|       |
 4602|    683|  uint64_t r = 0xFFFF & (argb_premul >> 32);
 4603|    683|  r = (r * 0xFFFF) / a;
 4604|    683|  uint64_t g = 0xFFFF & (argb_premul >> 16);
 4605|    683|  g = (g * 0xFFFF) / a;
 4606|    683|  uint64_t b = 0xFFFF & (argb_premul >> 0);
 4607|    683|  b = (b * 0xFFFF) / a;
 4608|       |
 4609|    683|  return (a << 48) | (r << 32) | (g << 16) | (b << 0);
 4610|    990|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul_4x16le__src_over:
27792|     30|    size_t src_len) {
27793|     30|  size_t dst_len4 = dst_len / 4;
27794|     30|  size_t src_len8 = src_len / 8;
27795|     30|  size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
  ------------------
  |  Branch (27795:16): [True: 2, False: 28]
  ------------------
27796|     30|  uint8_t* d = dst_ptr;
27797|     30|  const uint8_t* s = src_ptr;
27798|     30|  size_t n = len;
27799|       |
27800|    234|  while (n >= 1) {
  ------------------
  |  Branch (27800:10): [True: 204, False: 30]
  ------------------
27801|    204|    uint64_t d0 = wuffs_base__color_u32__as__color_u64(
27802|    204|        wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));
27803|    204|    uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));
27804|    204|    wuffs_base__poke_u32le__no_bounds_check(
27805|    204|        d + (0 * 4),
27806|    204|        wuffs_base__color_u64__as__color_u32(
27807|    204|            wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0)));
27808|       |
27809|    204|    s += 1 * 8;
27810|    204|    d += 1 * 4;
27811|    204|    n -= 1;
27812|    204|  }
27813|       |
27814|     30|  return len;
27815|     30|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul_4x16le__src:
28168|     43|    size_t src_len) {
28169|     43|  size_t dst_len8 = dst_len / 8;
28170|     43|  size_t src_len8 = src_len / 8;
28171|     43|  size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8;
  ------------------
  |  Branch (28171:16): [True: 6, False: 37]
  ------------------
28172|     43|  uint8_t* d = dst_ptr;
28173|     43|  const uint8_t* s = src_ptr;
28174|       |
28175|     43|  size_t n = len;
28176|    264|  while (n >= 1) {
  ------------------
  |  Branch (28176:10): [True: 221, False: 43]
  ------------------
28177|    221|    uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));
28178|    221|    wuffs_base__poke_u64le__no_bounds_check(
28179|    221|        d + (0 * 8),
28180|    221|        wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul(s0));
28181|       |
28182|    221|    s += 1 * 8;
28183|    221|    d += 1 * 8;
28184|    221|    n -= 1;
28185|    221|  }
28186|     43|  return len;
28187|     43|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul_4x16le__src_over:
28196|     26|    size_t src_len) {
28197|     26|  size_t dst_len8 = dst_len / 8;
28198|     26|  size_t src_len8 = src_len / 8;
28199|     26|  size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8;
  ------------------
  |  Branch (28199:16): [True: 5, False: 21]
  ------------------
28200|     26|  uint8_t* d = dst_ptr;
28201|     26|  const uint8_t* s = src_ptr;
28202|       |
28203|     26|  size_t n = len;
28204|    231|  while (n >= 1) {
  ------------------
  |  Branch (28204:10): [True: 205, False: 26]
  ------------------
28205|    205|    uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));
28206|    205|    uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));
28207|    205|    wuffs_base__poke_u64le__no_bounds_check(
28208|    205|        d + (0 * 8),
28209|    205|        wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0));
28210|       |
28211|    205|    s += 1 * 8;
28212|    205|    d += 1 * 8;
28213|    205|    n -= 1;
28214|    205|  }
28215|     26|  return len;
28216|     26|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_premul_4x16le__src:
28574|     15|    size_t src_len) {
28575|     15|  size_t dst_len4 = dst_len / 4;
28576|     15|  size_t src_len8 = src_len / 8;
28577|     15|  size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
  ------------------
  |  Branch (28577:16): [True: 2, False: 13]
  ------------------
28578|     15|  uint8_t* d = dst_ptr;
28579|     15|  const uint8_t* s = src_ptr;
28580|     15|  size_t n = len;
28581|       |
28582|       |  // TODO: unroll.
28583|       |
28584|    157|  while (n >= 1) {
  ------------------
  |  Branch (28584:10): [True: 142, False: 15]
  ------------------
28585|    142|    uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));
28586|    142|    wuffs_base__poke_u32le__no_bounds_check(
28587|    142|        d + (0 * 4), wuffs_base__color_u64__as__color_u32(s0));
28588|       |
28589|    142|    s += 1 * 8;
28590|    142|    d += 1 * 4;
28591|    142|    n -= 1;
28592|    142|  }
28593|       |
28594|     15|  return len;
28595|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__bgra_premul_4x16le__src_over:
28636|     15|    size_t src_len) {
28637|     15|  size_t dst_len4 = dst_len / 4;
28638|     15|  size_t src_len8 = src_len / 8;
28639|     15|  size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
  ------------------
  |  Branch (28639:16): [True: 1, False: 14]
  ------------------
28640|     15|  uint8_t* d = dst_ptr;
28641|     15|  const uint8_t* s = src_ptr;
28642|     15|  size_t n = len;
28643|       |
28644|       |  // TODO: unroll.
28645|       |
28646|    148|  while (n >= 1) {
  ------------------
  |  Branch (28646:10): [True: 133, False: 15]
  ------------------
28647|    133|    uint64_t d0 = wuffs_base__color_u32__as__color_u64(
28648|    133|        wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));
28649|    133|    uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));
28650|    133|    wuffs_base__poke_u32le__no_bounds_check(
28651|    133|        d + (0 * 4),
28652|    133|        wuffs_base__color_u64__as__color_u32(
28653|    133|            wuffs_private_impl__composite_premul_premul_u64_axxx(d0, s0)));
28654|       |
28655|    133|    s += 1 * 8;
28656|    133|    d += 1 * 4;
28657|    133|    n -= 1;
28658|    133|  }
28659|       |
28660|     15|  return len;
28661|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__composite_premul_premul_u64_axxx:
25701|    325|                                                     uint64_t src_premul) {
25702|       |  // Extract components.
25703|    325|  uint64_t da = 0xFFFF & (dst_premul >> 48);
25704|    325|  uint64_t dr = 0xFFFF & (dst_premul >> 32);
25705|    325|  uint64_t dg = 0xFFFF & (dst_premul >> 16);
25706|    325|  uint64_t db = 0xFFFF & (dst_premul >> 0);
25707|    325|  uint64_t sa = 0xFFFF & (src_premul >> 48);
25708|    325|  uint64_t sr = 0xFFFF & (src_premul >> 32);
25709|    325|  uint64_t sg = 0xFFFF & (src_premul >> 16);
25710|    325|  uint64_t sb = 0xFFFF & (src_premul >> 0);
25711|       |
25712|       |  // Calculate the inverse of the src-alpha: how much of the dst to keep.
25713|    325|  uint64_t ia = 0xFFFF - sa;
25714|       |
25715|       |  // Composite src (premul) over dst (premul).
25716|    325|  da = sa + ((da * ia) / 0xFFFF);
25717|    325|  dr = sr + ((dr * ia) / 0xFFFF);
25718|    325|  dg = sg + ((dg * ia) / 0xFFFF);
25719|    325|  db = sb + ((db * ia) / 0xFFFF);
25720|       |
25721|       |  // Combine components.
25722|    325|  return (db << 0) | (dg << 16) | (dr << 32) | (da << 48);
25723|    325|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul_4x16le__bgra_premul_4x16le__src_over:
29001|     15|    size_t src_len) {
29002|     15|  size_t dst_len8 = dst_len / 8;
29003|     15|  size_t src_len8 = src_len / 8;
29004|     15|  size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8;
  ------------------
  |  Branch (29004:16): [True: 3, False: 12]
  ------------------
29005|     15|  uint8_t* d = dst_ptr;
29006|     15|  const uint8_t* s = src_ptr;
29007|       |
29008|     15|  size_t n = len;
29009|    152|  while (n >= 1) {
  ------------------
  |  Branch (29009:10): [True: 137, False: 15]
  ------------------
29010|    137|    uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));
29011|    137|    uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));
29012|    137|    wuffs_base__poke_u64le__no_bounds_check(
29013|    137|        d + (0 * 8),
29014|    137|        wuffs_private_impl__composite_premul_premul_u64_axxx(d0, s0));
29015|       |
29016|    137|    s += 1 * 8;
29017|    137|    d += 1 * 8;
29018|    137|    n -= 1;
29019|    137|  }
29020|     15|  return len;
29021|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_premul_4x16le__src:
27456|     15|    size_t src_len) {
27457|     15|  size_t dst_len3 = dst_len / 3;
27458|     15|  size_t src_len8 = src_len / 8;
27459|     15|  size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8;
  ------------------
  |  Branch (27459:16): [True: 1, False: 14]
  ------------------
27460|     15|  uint8_t* d = dst_ptr;
27461|     15|  const uint8_t* s = src_ptr;
27462|     15|  size_t n = len;
27463|       |
27464|       |  // TODO: unroll.
27465|       |
27466|    176|  while (n >= 1) {
  ------------------
  |  Branch (27466:10): [True: 161, False: 15]
  ------------------
27467|    161|    uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr(
27468|    161|        wuffs_base__color_u64__as__color_u32(
27469|    161|            wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))));
27470|    161|    wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);
27471|       |
27472|    161|    s += 1 * 8;
27473|    161|    d += 1 * 3;
27474|    161|    n -= 1;
27475|    161|  }
27476|       |
27477|     15|  return len;
27478|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgba_premul_4x16le__src_over:
27532|     19|    size_t src_len) {
27533|     19|  size_t dst_len3 = dst_len / 3;
27534|     19|  size_t src_len8 = src_len / 8;
27535|     19|  size_t len = (dst_len3 < src_len8) ? dst_len3 : src_len8;
  ------------------
  |  Branch (27535:16): [True: 1, False: 18]
  ------------------
27536|     19|  uint8_t* d = dst_ptr;
27537|     19|  const uint8_t* s = src_ptr;
27538|     19|  size_t n = len;
27539|       |
27540|       |  // TODO: unroll.
27541|       |
27542|    201|  while (n >= 1) {
  ------------------
  |  Branch (27542:10): [True: 182, False: 19]
  ------------------
27543|       |    // Extract 16-bit color components.
27544|    182|    uint32_t dr = 0x101 * ((uint32_t)d[2]);
27545|    182|    uint32_t dg = 0x101 * ((uint32_t)d[1]);
27546|    182|    uint32_t db = 0x101 * ((uint32_t)d[0]);
27547|    182|    uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6));
27548|    182|    uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4));
27549|    182|    uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2));
27550|    182|    uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0));
27551|       |
27552|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
27553|    182|    uint32_t ia = 0xFFFF - sa;
27554|       |
27555|       |    // Composite src (premul) over dst (premul).
27556|    182|    dr = sr + ((dr * ia) / 0xFFFF);
27557|    182|    dg = sg + ((dg * ia) / 0xFFFF);
27558|    182|    db = sb + ((db * ia) / 0xFFFF);
27559|       |
27560|       |    // Convert from 16-bit color to 8-bit color.
27561|    182|    d[0] = (uint8_t)(db >> 8);
27562|    182|    d[1] = (uint8_t)(dg >> 8);
27563|    182|    d[2] = (uint8_t)(dr >> 8);
27564|       |
27565|    182|    s += 1 * 8;
27566|    182|    d += 1 * 3;
27567|    182|    n -= 1;
27568|    182|  }
27569|       |
27570|     19|  return len;
27571|     19|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgba_nonpremul__bgra_premul_4x16le__src:
29526|     54|    size_t src_len) {
29527|     54|  size_t dst_len4 = dst_len / 4;
29528|     54|  size_t src_len8 = src_len / 8;
29529|     54|  size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
  ------------------
  |  Branch (29529:16): [True: 2, False: 52]
  ------------------
29530|     54|  uint8_t* d = dst_ptr;
29531|     54|  const uint8_t* s = src_ptr;
29532|       |
29533|     54|  size_t n = len;
29534|    353|  while (n >= 1) {
  ------------------
  |  Branch (29534:10): [True: 299, False: 54]
  ------------------
29535|    299|    wuffs_base__poke_u32le__no_bounds_check(
29536|    299|        d + (0 * 4),
29537|    299|        wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr(
29538|    299|            wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul(
29539|    299|                wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)))));
29540|       |
29541|    299|    s += 1 * 8;
29542|    299|    d += 1 * 4;
29543|    299|    n -= 1;
29544|    299|  }
29545|     54|  return len;
29546|     54|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgba_nonpremul__bgra_premul_4x16le__src_over:
29555|     39|    size_t src_len) {
29556|     39|  size_t dst_len4 = dst_len / 4;
29557|     39|  size_t src_len8 = src_len / 8;
29558|     39|  size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
  ------------------
  |  Branch (29558:16): [True: 1, False: 38]
  ------------------
29559|     39|  uint8_t* d = dst_ptr;
29560|     39|  const uint8_t* s = src_ptr;
29561|     39|  size_t n = len;
29562|       |
29563|    348|  while (n >= 1) {
  ------------------
  |  Branch (29563:10): [True: 309, False: 39]
  ------------------
29564|    309|    uint64_t d0 = wuffs_base__color_u32__as__color_u64(
29565|    309|        wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));
29566|    309|    uint64_t s0 = wuffs_base__color_swap_u64_argb_abgr(
29567|    309|        wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)));
29568|    309|    wuffs_base__poke_u32le__no_bounds_check(
29569|    309|        d + (0 * 4),
29570|    309|        wuffs_base__color_u64__as__color_u32(
29571|    309|            wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0)));
29572|       |
29573|    309|    s += 1 * 8;
29574|    309|    d += 1 * 4;
29575|    309|    n -= 1;
29576|    309|  }
29577|       |
29578|     39|  return len;
29579|     39|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_premul_4x16le__src:
28870|     23|    size_t src_len) {
28871|     23|  size_t dst_len4 = dst_len / 4;
28872|     23|  size_t src_len8 = src_len / 8;
28873|     23|  size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
  ------------------
  |  Branch (28873:16): [True: 1, False: 22]
  ------------------
28874|     23|  uint8_t* d = dst_ptr;
28875|     23|  const uint8_t* s = src_ptr;
28876|     23|  size_t n = len;
28877|       |
28878|       |  // TODO: unroll.
28879|       |
28880|    254|  while (n >= 1) {
  ------------------
  |  Branch (28880:10): [True: 231, False: 23]
  ------------------
28881|    231|    uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));
28882|    231|    wuffs_base__poke_u32le__no_bounds_check(
28883|    231|        d + (0 * 4), wuffs_base__color_swap_u32_argb_abgr(
28884|    231|                         wuffs_base__color_u64__as__color_u32(s0)));
28885|       |
28886|    231|    s += 1 * 8;
28887|    231|    d += 1 * 4;
28888|    231|    n -= 1;
28889|    231|  }
28890|       |
28891|     23|  return len;
28892|     23|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_premul__rgba_premul_4x16le__src_over:
28901|     10|    size_t src_len) {
28902|     10|  size_t dst_len4 = dst_len / 4;
28903|     10|  size_t src_len8 = src_len / 8;
28904|     10|  size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
  ------------------
  |  Branch (28904:16): [True: 1, False: 9]
  ------------------
28905|     10|  uint8_t* d = dst_ptr;
28906|     10|  const uint8_t* s = src_ptr;
28907|     10|  size_t n = len;
28908|       |
28909|       |  // TODO: unroll.
28910|       |
28911|     65|  while (n >= 1) {
  ------------------
  |  Branch (28911:10): [True: 55, False: 10]
  ------------------
28912|     55|    uint64_t d0 = wuffs_base__color_u32__as__color_u64(
28913|     55|        wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));
28914|     55|    uint64_t s0 = wuffs_base__color_swap_u64_argb_abgr(
28915|     55|        wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)));
28916|     55|    wuffs_base__poke_u32le__no_bounds_check(
28917|     55|        d + (0 * 4),
28918|     55|        wuffs_base__color_u64__as__color_u32(
28919|     55|            wuffs_private_impl__composite_premul_premul_u64_axxx(d0, s0)));
28920|       |
28921|     55|    s += 1 * 8;
28922|     55|    d += 1 * 4;
28923|     55|    n -= 1;
28924|     55|  }
28925|       |
28926|     10|  return len;
28927|     10|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__bgrx:
32305|    122|    wuffs_base__pixel_blend blend) {
32306|    122|  switch (dst_pixfmt.repr) {
  ------------------
  |  Branch (32306:11): [True: 111, False: 11]
  ------------------
32307|     21|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|     21|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (32307:5): [True: 21, False: 101]
  ------------------
32308|     21|      return wuffs_private_impl__swizzle_y__bgrx;
32309|       |
32310|     14|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|     14|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (32310:5): [True: 14, False: 108]
  ------------------
32311|     14|      return wuffs_private_impl__swizzle_bgr_565__bgrx;
32312|       |
32313|      9|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|      9|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (32313:5): [True: 9, False: 113]
  ------------------
32314|      9|      return wuffs_private_impl__swizzle_xxx__xxxx;
32315|       |
32316|      4|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|      4|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (32316:5): [True: 4, False: 118]
  ------------------
32317|     19|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|     19|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (32317:5): [True: 15, False: 107]
  ------------------
32318|     19|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
  ------------------
  |  | 4968|     19|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY               0x83008888
  ------------------
  |  Branch (32318:5): [True: 0, False: 122]
  ------------------
32319|     19|      return wuffs_private_impl__swizzle_bgrw__bgrx;
32320|       |
32321|     11|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|     11|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (32321:5): [True: 11, False: 111]
  ------------------
32322|     11|      return wuffs_private_impl__swizzle_bgrw_4x16le__bgrx;
32323|       |
32324|      5|    case WUFFS_BASE__PIXEL_FORMAT__BGRX:
  ------------------
  |  | 4969|      5|#define WUFFS_BASE__PIXEL_FORMAT__BGRX                      0x90008888
  ------------------
  |  Branch (32324:5): [True: 5, False: 117]
  ------------------
32325|      5|      return wuffs_private_impl__swizzle_copy_4_4;
32326|       |
32327|     13|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|     13|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (32327:5): [True: 13, False: 109]
  ------------------
32328|     13|      return wuffs_private_impl__swizzle_bgr__rgbx;
32329|       |
32330|     16|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|     16|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (32330:5): [True: 16, False: 106]
  ------------------
32331|     19|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|     19|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (32331:5): [True: 3, False: 119]
  ------------------
32332|     19|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
  ------------------
  |  | 4976|     19|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY               0xA3008888
  ------------------
  |  Branch (32332:5): [True: 0, False: 122]
  ------------------
32333|     19|    case WUFFS_BASE__PIXEL_FORMAT__RGBX:
  ------------------
  |  | 4977|     19|#define WUFFS_BASE__PIXEL_FORMAT__RGBX                      0xB0008888
  ------------------
  |  Branch (32333:5): [True: 0, False: 122]
  ------------------
32334|     19|      return wuffs_private_impl__swizzle_bgrw__rgbx;
32335|    122|  }
32336|     11|  return NULL;
32337|    122|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__bgrx:
30689|     21|                                    size_t src_len) {
30690|     21|  size_t src_len4 = src_len / 4;
30691|     21|  size_t len = (dst_len < src_len4) ? dst_len : src_len4;
  ------------------
  |  Branch (30691:16): [True: 1, False: 20]
  ------------------
30692|     21|  uint8_t* d = dst_ptr;
30693|     21|  const uint8_t* s = src_ptr;
30694|     21|  size_t n = len;
30695|       |
30696|       |  // TODO: unroll.
30697|       |
30698|    379|  while (n >= 1) {
  ------------------
  |  Branch (30698:10): [True: 358, False: 21]
  ------------------
30699|    358|    uint32_t s0 =
30700|    358|        0xFF000000 | wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
30701|    358|    d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0);
30702|       |
30703|    358|    s += 1 * 4;
30704|    358|    d += 1 * 1;
30705|    358|    n -= 1;
30706|    358|  }
30707|       |
30708|     21|  return len;
30709|     21|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__bgrx:
26040|     14|                                          size_t src_len) {
26041|     14|  size_t dst_len2 = dst_len / 2;
26042|     14|  size_t src_len4 = src_len / 4;
26043|     14|  size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;
  ------------------
  |  Branch (26043:16): [True: 1, False: 13]
  ------------------
26044|     14|  uint8_t* d = dst_ptr;
26045|     14|  const uint8_t* s = src_ptr;
26046|     14|  size_t n = len;
26047|       |
26048|       |  // TODO: unroll.
26049|       |
26050|    334|  while (n >= 1) {
  ------------------
  |  Branch (26050:10): [True: 320, False: 14]
  ------------------
26051|    320|    uint32_t b5 = (uint32_t)(s[0] >> 3);
26052|    320|    uint32_t g6 = (uint32_t)(s[1] >> 2);
26053|    320|    uint32_t r5 = (uint32_t)(s[2] >> 3);
26054|    320|    uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0);
26055|    320|    wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565);
26056|       |
26057|    320|    s += 1 * 4;
26058|    320|    d += 1 * 2;
26059|    320|    n -= 1;
26060|    320|  }
26061|       |
26062|     14|  return len;
26063|     14|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_xxx__xxxx:
29779|      9|                                      size_t src_len) {
29780|      9|  size_t dst_len3 = dst_len / 3;
29781|      9|  size_t src_len4 = src_len / 4;
29782|      9|  size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;
  ------------------
  |  Branch (29782:16): [True: 4, False: 5]
  ------------------
29783|      9|  uint8_t* d = dst_ptr;
29784|      9|  const uint8_t* s = src_ptr;
29785|      9|  size_t n = len;
29786|       |
29787|       |  // TODO: unroll.
29788|       |
29789|    116|  while (n >= 1) {
  ------------------
  |  Branch (29789:10): [True: 107, False: 9]
  ------------------
29790|    107|    wuffs_base__poke_u24le__no_bounds_check(
29791|    107|        d + (0 * 3), wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
29792|       |
29793|    107|    s += 1 * 4;
29794|    107|    d += 1 * 3;
29795|    107|    n -= 1;
29796|    107|  }
29797|       |
29798|      9|  return len;
29799|      9|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__bgrx:
29089|     19|                                       size_t src_len) {
29090|     19|  size_t dst_len4 = dst_len / 4;
29091|     19|  size_t src_len4 = src_len / 4;
29092|     19|  size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
  ------------------
  |  Branch (29092:16): [True: 4, False: 15]
  ------------------
29093|     19|  uint8_t* d = dst_ptr;
29094|     19|  const uint8_t* s = src_ptr;
29095|     19|  size_t n = len;
29096|       |
29097|       |  // TODO: unroll.
29098|       |
29099|    284|  while (n >= 1) {
  ------------------
  |  Branch (29099:10): [True: 265, False: 19]
  ------------------
29100|    265|    wuffs_base__poke_u32le__no_bounds_check(
29101|    265|        d + (0 * 4),
29102|    265|        0xFF000000 | wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
29103|       |
29104|    265|    s += 1 * 4;
29105|    265|    d += 1 * 4;
29106|    265|    n -= 1;
29107|    265|  }
29108|       |
29109|     19|  return len;
29110|     19|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw_4x16le__bgrx:
29358|     11|                                              size_t src_len) {
29359|     11|  size_t dst_len8 = dst_len / 8;
29360|     11|  size_t src_len4 = src_len / 4;
29361|     11|  size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
  ------------------
  |  Branch (29361:16): [True: 4, False: 7]
  ------------------
29362|     11|  uint8_t* d = dst_ptr;
29363|     11|  const uint8_t* s = src_ptr;
29364|     11|  size_t n = len;
29365|       |
29366|    155|  while (n >= 1) {
  ------------------
  |  Branch (29366:10): [True: 144, False: 11]
  ------------------
29367|    144|    uint8_t s0 = s[0];
29368|    144|    uint8_t s1 = s[1];
29369|    144|    uint8_t s2 = s[2];
29370|    144|    d[0] = s0;
29371|    144|    d[1] = s0;
29372|    144|    d[2] = s1;
29373|    144|    d[3] = s1;
29374|    144|    d[4] = s2;
29375|    144|    d[5] = s2;
29376|    144|    d[6] = 0xFF;
29377|    144|    d[7] = 0xFF;
29378|       |
29379|    144|    s += 1 * 4;
29380|    144|    d += 1 * 8;
29381|    144|    n -= 1;
29382|    144|  }
29383|       |
29384|     11|  return len;
29385|     11|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr__rgbx:
27579|     13|                                      size_t src_len) {
27580|     13|  size_t dst_len3 = dst_len / 3;
27581|     13|  size_t src_len4 = src_len / 4;
27582|     13|  size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;
  ------------------
  |  Branch (27582:16): [True: 2, False: 11]
  ------------------
27583|     13|  uint8_t* d = dst_ptr;
27584|     13|  const uint8_t* s = src_ptr;
27585|     13|  size_t n = len;
27586|       |
27587|       |  // TODO: unroll.
27588|       |
27589|    212|  while (n >= 1) {
  ------------------
  |  Branch (27589:10): [True: 199, False: 13]
  ------------------
27590|    199|    uint8_t b0 = s[0];
27591|    199|    uint8_t b1 = s[1];
27592|    199|    uint8_t b2 = s[2];
27593|    199|    d[0] = b2;
27594|    199|    d[1] = b1;
27595|    199|    d[2] = b0;
27596|       |
27597|    199|    s += 1 * 4;
27598|    199|    d += 1 * 3;
27599|    199|    n -= 1;
27600|    199|  }
27601|       |
27602|     13|  return len;
27603|     13|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw__rgbx:
29259|     19|                                       size_t src_len) {
29260|     19|  size_t dst_len4 = dst_len / 4;
29261|     19|  size_t src_len4 = src_len / 4;
29262|     19|  size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
  ------------------
  |  Branch (29262:16): [True: 4, False: 15]
  ------------------
29263|     19|  uint8_t* d = dst_ptr;
29264|     19|  const uint8_t* s = src_ptr;
29265|     19|  size_t n = len;
29266|       |
29267|       |  // TODO: unroll.
29268|       |
29269|    417|  while (n >= 1) {
  ------------------
  |  Branch (29269:10): [True: 398, False: 19]
  ------------------
29270|    398|    uint8_t b0 = s[0];
29271|    398|    uint8_t b1 = s[1];
29272|    398|    uint8_t b2 = s[2];
29273|    398|    d[0] = b2;
29274|    398|    d[1] = b1;
29275|    398|    d[2] = b0;
29276|    398|    d[3] = 0xFF;
29277|       |
29278|    398|    s += 1 * 4;
29279|    398|    d += 1 * 4;
29280|    398|    n -= 1;
29281|    398|  }
29282|       |
29283|     19|  return len;
29284|     19|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__rgb:
32345|    114|    wuffs_base__pixel_blend blend) {
32346|    114|  switch (dst_pixfmt.repr) {
  ------------------
  |  Branch (32346:11): [True: 96, False: 18]
  ------------------
32347|     19|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|     19|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (32347:5): [True: 19, False: 95]
  ------------------
32348|     19|      return wuffs_private_impl__swizzle_y__rgb;
32349|       |
32350|     12|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|     12|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (32350:5): [True: 12, False: 102]
  ------------------
32351|     12|      return wuffs_private_impl__swizzle_bgr_565__rgb;
32352|       |
32353|     10|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|     10|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (32353:5): [True: 10, False: 104]
  ------------------
32354|     10|      return wuffs_private_impl__swizzle_swap_rgb_bgr;
32355|       |
32356|      9|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|      9|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (32356:5): [True: 9, False: 105]
  ------------------
32357|     14|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|     14|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (32357:5): [True: 5, False: 109]
  ------------------
32358|     14|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
  ------------------
  |  | 4968|     14|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY               0x83008888
  ------------------
  |  Branch (32358:5): [True: 0, False: 114]
  ------------------
32359|     19|    case WUFFS_BASE__PIXEL_FORMAT__BGRX:
  ------------------
  |  | 4969|     19|#define WUFFS_BASE__PIXEL_FORMAT__BGRX                      0x90008888
  ------------------
  |  Branch (32359:5): [True: 5, False: 109]
  ------------------
32360|     19|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
32361|     19|      if (wuffs_base__cpu_arch__have_x86_sse42()) {
  ------------------
  |  Branch (32361:11): [True: 19, False: 0]
  ------------------
32362|     19|        return wuffs_private_impl__swizzle_bgrw__rgb__x86_sse42;
32363|     19|      }
32364|      0|#endif
32365|      0|      return wuffs_private_impl__swizzle_bgrw__rgb;
32366|       |
32367|     15|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|     15|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (32367:5): [True: 15, False: 99]
  ------------------
32368|     15|      return wuffs_private_impl__swizzle_bgrw_4x16le__rgb;
32369|       |
32370|      7|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|      7|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (32370:5): [True: 7, False: 107]
  ------------------
32371|      7|      return wuffs_private_impl__swizzle_copy_3_3;
32372|       |
32373|      5|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|      5|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (32373:5): [True: 5, False: 109]
  ------------------
32374|     14|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|     14|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (32374:5): [True: 9, False: 105]
  ------------------
32375|     14|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
  ------------------
  |  | 4976|     14|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY               0xA3008888
  ------------------
  |  Branch (32375:5): [True: 0, False: 114]
  ------------------
32376|     14|    case WUFFS_BASE__PIXEL_FORMAT__RGBX:
  ------------------
  |  | 4977|     14|#define WUFFS_BASE__PIXEL_FORMAT__RGBX                      0xB0008888
  ------------------
  |  Branch (32376:5): [True: 0, False: 114]
  ------------------
32377|     14|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
32378|     14|      if (wuffs_base__cpu_arch__have_x86_sse42()) {
  ------------------
  |  Branch (32378:11): [True: 14, False: 0]
  ------------------
32379|     14|        return wuffs_private_impl__swizzle_bgrw__bgr__x86_sse42;
32380|     14|      }
32381|      0|#endif
32382|      0|      return wuffs_private_impl__swizzle_bgrw__bgr;
32383|    114|  }
32384|     18|  return NULL;
32385|    114|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgb:
30717|     19|                                   size_t src_len) {
30718|     19|  size_t src_len3 = src_len / 3;
30719|     19|  size_t len = (dst_len < src_len3) ? dst_len : src_len3;
  ------------------
  |  Branch (30719:16): [True: 2, False: 17]
  ------------------
30720|     19|  uint8_t* d = dst_ptr;
30721|     19|  const uint8_t* s = src_ptr;
30722|     19|  size_t n = len;
30723|       |
30724|       |  // TODO: unroll.
30725|       |
30726|    666|  while (n >= 1) {
  ------------------
  |  Branch (30726:10): [True: 647, False: 19]
  ------------------
30727|    647|    uint32_t s0 =
30728|    647|        0xFF000000 | wuffs_base__peek_u24be__no_bounds_check(s + (0 * 3));
30729|    647|    d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0);
30730|       |
30731|    647|    s += 1 * 3;
30732|    647|    d += 1 * 1;
30733|    647|    n -= 1;
30734|    647|  }
30735|       |
30736|     19|  return len;
30737|     19|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgb:
26420|     12|                                         size_t src_len) {
26421|     12|  size_t dst_len2 = dst_len / 2;
26422|     12|  size_t src_len3 = src_len / 3;
26423|     12|  size_t len = (dst_len2 < src_len3) ? dst_len2 : src_len3;
  ------------------
  |  Branch (26423:16): [True: 3, False: 9]
  ------------------
26424|     12|  uint8_t* d = dst_ptr;
26425|     12|  const uint8_t* s = src_ptr;
26426|     12|  size_t n = len;
26427|       |
26428|       |  // TODO: unroll.
26429|       |
26430|    219|  while (n >= 1) {
  ------------------
  |  Branch (26430:10): [True: 207, False: 12]
  ------------------
26431|    207|    uint32_t r5 = (uint32_t)(s[0] >> 3);
26432|    207|    uint32_t g6 = (uint32_t)(s[1] >> 2);
26433|    207|    uint32_t b5 = (uint32_t)(s[2] >> 3);
26434|    207|    uint32_t rgb_565 = (r5 << 11) | (g6 << 5) | (b5 << 0);
26435|    207|    wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)rgb_565);
26436|       |
26437|    207|    s += 1 * 3;
26438|    207|    d += 1 * 2;
26439|    207|    n -= 1;
26440|    207|  }
26441|       |
26442|     12|  return len;
26443|     12|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgrw_4x16le__rgb:
29393|     15|                                             size_t src_len) {
29394|     15|  size_t dst_len8 = dst_len / 8;
29395|     15|  size_t src_len3 = src_len / 3;
29396|     15|  size_t len = (dst_len8 < src_len3) ? dst_len8 : src_len3;
  ------------------
  |  Branch (29396:16): [True: 7, False: 8]
  ------------------
29397|     15|  uint8_t* d = dst_ptr;
29398|     15|  const uint8_t* s = src_ptr;
29399|     15|  size_t n = len;
29400|       |
29401|    156|  while (n >= 1) {
  ------------------
  |  Branch (29401:10): [True: 141, False: 15]
  ------------------
29402|    141|    uint8_t s0 = s[0];
29403|    141|    uint8_t s1 = s[1];
29404|    141|    uint8_t s2 = s[2];
29405|    141|    d[0] = s2;
29406|    141|    d[1] = s2;
29407|    141|    d[2] = s1;
29408|    141|    d[3] = s1;
29409|    141|    d[4] = s0;
29410|    141|    d[5] = s0;
29411|    141|    d[6] = 0xFF;
29412|    141|    d[7] = 0xFF;
29413|       |
29414|    141|    s += 1 * 3;
29415|    141|    d += 1 * 8;
29416|    141|    n -= 1;
29417|    141|  }
29418|       |
29419|     15|  return len;
29420|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__rgba_nonpremul:
32393|    226|    wuffs_base__pixel_blend blend) {
32394|    226|  switch (dst_pixfmt.repr) {
  ------------------
  |  Branch (32394:11): [True: 210, False: 16]
  ------------------
32395|     25|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|     25|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (32395:5): [True: 25, False: 201]
  ------------------
32396|     25|      switch (blend) {
  ------------------
  |  Branch (32396:15): [True: 25, False: 0]
  ------------------
32397|     13|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     13|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32397:9): [True: 13, False: 12]
  ------------------
32398|     13|          return wuffs_private_impl__swizzle_y__rgba_nonpremul__src;
32399|     12|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     12|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32399:9): [True: 12, False: 13]
  ------------------
32400|     12|          return wuffs_private_impl__swizzle_y__rgba_nonpremul__src_over;
32401|     25|      }
32402|      0|      return NULL;
32403|       |
32404|     25|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|     25|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (32404:5): [True: 25, False: 201]
  ------------------
32405|     25|      switch (blend) {
  ------------------
  |  Branch (32405:15): [True: 25, False: 0]
  ------------------
32406|     15|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     15|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32406:9): [True: 15, False: 10]
  ------------------
32407|     15|          return wuffs_private_impl__swizzle_bgr_565__rgba_nonpremul__src;
32408|     10|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32408:9): [True: 10, False: 15]
  ------------------
32409|     10|          return wuffs_private_impl__swizzle_bgr_565__rgba_nonpremul__src_over;
32410|     25|      }
32411|      0|      return NULL;
32412|       |
32413|      9|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|      9|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (32413:5): [True: 9, False: 217]
  ------------------
32414|      9|      switch (blend) {
  ------------------
  |  Branch (32414:15): [True: 9, False: 0]
  ------------------
32415|      1|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      1|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32415:9): [True: 1, False: 8]
  ------------------
32416|      1|          return wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src;
32417|      8|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      8|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32417:9): [True: 8, False: 1]
  ------------------
32418|      8|          return wuffs_private_impl__swizzle_bgr__rgba_nonpremul__src_over;
32419|      9|      }
32420|      0|      return NULL;
32421|       |
32422|     32|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|     32|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (32422:5): [True: 32, False: 194]
  ------------------
32423|     32|      switch (blend) {
  ------------------
  |  Branch (32423:15): [True: 32, False: 0]
  ------------------
32424|     10|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32424:9): [True: 10, False: 22]
  ------------------
32425|     10|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
32426|     10|          if (wuffs_base__cpu_arch__have_x86_sse42()) {
  ------------------
  |  Branch (32426:15): [True: 10, False: 0]
  ------------------
32427|     10|            return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42;
32428|     10|          }
32429|      0|#endif
32430|      0|          return wuffs_private_impl__swizzle_swap_rgbx_bgrx;
32431|     22|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     22|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32431:9): [True: 22, False: 10]
  ------------------
32432|     22|          return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_nonpremul__src_over;
32433|     32|      }
32434|      0|      return NULL;
32435|       |
32436|     42|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|     42|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (32436:5): [True: 42, False: 184]
  ------------------
32437|     42|      switch (blend) {
  ------------------
  |  Branch (32437:15): [True: 42, False: 0]
  ------------------
32438|     10|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32438:9): [True: 10, False: 32]
  ------------------
32439|     10|          return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_nonpremul__src;
32440|     32|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     32|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32440:9): [True: 32, False: 10]
  ------------------
32441|     32|          return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_nonpremul__src_over;
32442|     42|      }
32443|      0|      return NULL;
32444|       |
32445|     20|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|     20|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (32445:5): [True: 20, False: 206]
  ------------------
32446|     20|      switch (blend) {
  ------------------
  |  Branch (32446:15): [True: 20, False: 0]
  ------------------
32447|     10|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     10|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32447:9): [True: 10, False: 10]
  ------------------
32448|     10|          return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src;
32449|     10|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     10|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32449:9): [True: 10, False: 10]
  ------------------
32450|     10|          return wuffs_private_impl__swizzle_bgra_premul__rgba_nonpremul__src_over;
32451|     20|      }
32452|      0|      return NULL;
32453|       |
32454|      0|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
  ------------------
  |  | 4968|      0|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY               0x83008888
  ------------------
  |  Branch (32454:5): [True: 0, False: 226]
  ------------------
32455|      4|    case WUFFS_BASE__PIXEL_FORMAT__BGRX:
  ------------------
  |  | 4969|      4|#define WUFFS_BASE__PIXEL_FORMAT__BGRX                      0x90008888
  ------------------
  |  Branch (32455:5): [True: 4, False: 222]
  ------------------
32456|       |      // TODO.
32457|      4|      break;
32458|       |
32459|     13|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|     13|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (32459:5): [True: 13, False: 213]
  ------------------
32460|     13|      switch (blend) {
  ------------------
  |  Branch (32460:15): [True: 13, False: 0]
  ------------------
32461|     12|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     12|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32461:9): [True: 12, False: 1]
  ------------------
32462|     12|          return wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src;
32463|      1|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      1|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32463:9): [True: 1, False: 12]
  ------------------
32464|      1|          return wuffs_private_impl__swizzle_bgr__bgra_nonpremul__src_over;
32465|     13|      }
32466|      0|      return NULL;
32467|       |
32468|     10|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|     10|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (32468:5): [True: 10, False: 216]
  ------------------
32469|     10|      switch (blend) {
  ------------------
  |  Branch (32469:15): [True: 10, False: 0]
  ------------------
32470|      1|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      1|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32470:9): [True: 1, False: 9]
  ------------------
32471|      1|          return wuffs_private_impl__swizzle_copy_4_4;
32472|      9|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32472:9): [True: 9, False: 1]
  ------------------
32473|      9|          return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_nonpremul__src_over;
32474|     10|      }
32475|      0|      return NULL;
32476|       |
32477|     30|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|     30|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (32477:5): [True: 30, False: 196]
  ------------------
32478|     30|      switch (blend) {
  ------------------
  |  Branch (32478:15): [True: 30, False: 0]
  ------------------
32479|     19|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     19|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32479:9): [True: 19, False: 11]
  ------------------
32480|     19|          return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src;
32481|     11|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32481:9): [True: 11, False: 19]
  ------------------
32482|     11|          return wuffs_private_impl__swizzle_bgra_premul__bgra_nonpremul__src_over;
32483|     30|      }
32484|      0|      return NULL;
32485|       |
32486|      0|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
  ------------------
  |  | 4976|      0|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY               0xA3008888
  ------------------
  |  Branch (32486:5): [True: 0, False: 226]
  ------------------
32487|      0|    case WUFFS_BASE__PIXEL_FORMAT__RGBX:
  ------------------
  |  | 4977|      0|#define WUFFS_BASE__PIXEL_FORMAT__RGBX                      0xB0008888
  ------------------
  |  Branch (32487:5): [True: 0, False: 226]
  ------------------
32488|       |      // TODO.
32489|      0|      break;
32490|    226|  }
32491|     20|  return NULL;
32492|    226|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgba_nonpremul__src:
30745|     13|                                                   size_t src_len) {
30746|     13|  size_t src_len4 = src_len / 4;
30747|     13|  size_t len = (dst_len < src_len4) ? dst_len : src_len4;
  ------------------
  |  Branch (30747:16): [True: 1, False: 12]
  ------------------
30748|     13|  uint8_t* d = dst_ptr;
30749|     13|  const uint8_t* s = src_ptr;
30750|     13|  size_t n = len;
30751|       |
30752|       |  // TODO: unroll.
30753|       |
30754|    349|  while (n >= 1) {
  ------------------
  |  Branch (30754:10): [True: 336, False: 13]
  ------------------
30755|    336|    uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr(
30756|    336|        wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
30757|    336|            wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))));
30758|    336|    d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0);
30759|       |
30760|    336|    s += 1 * 4;
30761|    336|    d += 1 * 1;
30762|    336|    n -= 1;
30763|    336|  }
30764|       |
30765|     13|  return len;
30766|     13|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgba_nonpremul__src_over:
30775|     12|    size_t src_len) {
30776|     12|  size_t src_len4 = src_len / 4;
30777|     12|  size_t len = (dst_len < src_len4) ? dst_len : src_len4;
  ------------------
  |  Branch (30777:16): [True: 1, False: 11]
  ------------------
30778|     12|  uint8_t* d = dst_ptr;
30779|     12|  const uint8_t* s = src_ptr;
30780|     12|  size_t n = len;
30781|       |
30782|       |  // TODO: unroll.
30783|       |
30784|    176|  while (n >= 1) {
  ------------------
  |  Branch (30784:10): [True: 164, False: 12]
  ------------------
30785|    164|    uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0])));
30786|    164|    uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr(
30787|    164|        wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
30788|    164|    d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(
30789|    164|        wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0));
30790|       |
30791|    164|    s += 1 * 4;
30792|    164|    d += 1 * 1;
30793|    164|    n -= 1;
30794|    164|  }
30795|       |
30796|     12|  return len;
30797|     12|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgba_nonpremul__src:
26452|     15|    size_t src_len) {
26453|     15|  size_t dst_len2 = dst_len / 2;
26454|     15|  size_t src_len4 = src_len / 4;
26455|     15|  size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;
  ------------------
  |  Branch (26455:16): [True: 3, False: 12]
  ------------------
26456|     15|  uint8_t* d = dst_ptr;
26457|     15|  const uint8_t* s = src_ptr;
26458|     15|  size_t n = len;
26459|       |
26460|       |  // TODO: unroll.
26461|       |
26462|    269|  while (n >= 1) {
  ------------------
  |  Branch (26462:10): [True: 254, False: 15]
  ------------------
26463|    254|    wuffs_base__poke_u16le__no_bounds_check(
26464|    254|        d + (0 * 2),
26465|    254|        wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(
26466|    254|            wuffs_base__color_swap_u32_argb_abgr(
26467|    254|                wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
26468|    254|                    wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))))));
26469|       |
26470|    254|    s += 1 * 4;
26471|    254|    d += 1 * 2;
26472|    254|    n -= 1;
26473|    254|  }
26474|       |
26475|     15|  return len;
26476|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgba_nonpremul__src_over:
26485|     10|    size_t src_len) {
26486|     10|  size_t dst_len2 = dst_len / 2;
26487|     10|  size_t src_len4 = src_len / 4;
26488|     10|  size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;
  ------------------
  |  Branch (26488:16): [True: 1, False: 9]
  ------------------
26489|     10|  uint8_t* d = dst_ptr;
26490|     10|  const uint8_t* s = src_ptr;
26491|     10|  size_t n = len;
26492|       |
26493|       |  // TODO: unroll.
26494|       |
26495|    148|  while (n >= 1) {
  ------------------
  |  Branch (26495:10): [True: 138, False: 10]
  ------------------
26496|       |    // Extract 16-bit color components.
26497|    138|    uint32_t sa = 0x101 * ((uint32_t)s[3]);
26498|    138|    uint32_t sb = 0x101 * ((uint32_t)s[2]);
26499|    138|    uint32_t sg = 0x101 * ((uint32_t)s[1]);
26500|    138|    uint32_t sr = 0x101 * ((uint32_t)s[0]);
26501|       |
26502|       |    // Convert from 565 color to 16-bit color.
26503|    138|    uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));
26504|    138|    uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);
26505|    138|    uint32_t dr = (0x8421 * old_r5) >> 4;
26506|    138|    uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);
26507|    138|    uint32_t dg = (0x1041 * old_g6) >> 2;
26508|    138|    uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);
26509|    138|    uint32_t db = (0x8421 * old_b5) >> 4;
26510|       |
26511|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
26512|    138|    uint32_t ia = 0xFFFF - sa;
26513|       |
26514|       |    // Composite src (nonpremul) over dst (premul).
26515|    138|    dr = ((sr * sa) + (dr * ia)) / 0xFFFF;
26516|    138|    dg = ((sg * sa) + (dg * ia)) / 0xFFFF;
26517|    138|    db = ((sb * sa) + (db * ia)) / 0xFFFF;
26518|       |
26519|       |    // Convert from 16-bit color to 565 color and combine the components.
26520|    138|    uint32_t new_r5 = 0x1F & (dr >> 11);
26521|    138|    uint32_t new_g6 = 0x3F & (dg >> 10);
26522|    138|    uint32_t new_b5 = 0x1F & (db >> 11);
26523|    138|    uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);
26524|    138|    wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);
26525|       |
26526|    138|    s += 1 * 4;
26527|    138|    d += 1 * 2;
26528|    138|    n -= 1;
26529|    138|  }
26530|       |
26531|     10|  return len;
26532|     10|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_nonpremul__src:
28260|     10|    size_t src_len) {
28261|     10|  size_t dst_len8 = dst_len / 8;
28262|     10|  size_t src_len4 = src_len / 4;
28263|     10|  size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
  ------------------
  |  Branch (28263:16): [True: 5, False: 5]
  ------------------
28264|     10|  uint8_t* d = dst_ptr;
28265|     10|  const uint8_t* s = src_ptr;
28266|       |
28267|     10|  size_t n = len;
28268|     63|  while (n >= 1) {
  ------------------
  |  Branch (28268:10): [True: 53, False: 10]
  ------------------
28269|     53|    uint8_t s0 = s[0];
28270|     53|    uint8_t s1 = s[1];
28271|     53|    uint8_t s2 = s[2];
28272|     53|    uint8_t s3 = s[3];
28273|     53|    d[0] = s2;
28274|     53|    d[1] = s2;
28275|     53|    d[2] = s1;
28276|     53|    d[3] = s1;
28277|     53|    d[4] = s0;
28278|     53|    d[5] = s0;
28279|     53|    d[6] = s3;
28280|     53|    d[7] = s3;
28281|       |
28282|     53|    s += 1 * 4;
28283|     53|    d += 1 * 8;
28284|     53|    n -= 1;
28285|     53|  }
28286|     10|  return len;
28287|     10|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_nonpremul__src_over:
28296|     32|    size_t src_len) {
28297|     32|  size_t dst_len8 = dst_len / 8;
28298|     32|  size_t src_len4 = src_len / 4;
28299|     32|  size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
  ------------------
  |  Branch (28299:16): [True: 10, False: 22]
  ------------------
28300|     32|  uint8_t* d = dst_ptr;
28301|     32|  const uint8_t* s = src_ptr;
28302|       |
28303|     32|  size_t n = len;
28304|    218|  while (n >= 1) {
  ------------------
  |  Branch (28304:10): [True: 186, False: 32]
  ------------------
28305|    186|    uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));
28306|    186|    uint64_t s0 = wuffs_base__color_u32__as__color_u64(
28307|    186|        wuffs_base__color_swap_u32_argb_abgr(
28308|    186|            wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))));
28309|    186|    wuffs_base__poke_u64le__no_bounds_check(
28310|    186|        d + (0 * 8),
28311|    186|        wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(d0, s0));
28312|       |
28313|    186|    s += 1 * 4;
28314|    186|    d += 1 * 8;
28315|    186|    n -= 1;
28316|    186|  }
28317|     32|  return len;
28318|     32|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__pixel_swizzler__prepare__rgba_premul:
32500|    260|    wuffs_base__pixel_blend blend) {
32501|    260|  switch (dst_pixfmt.repr) {
  ------------------
  |  Branch (32501:11): [True: 234, False: 26]
  ------------------
32502|     32|    case WUFFS_BASE__PIXEL_FORMAT__Y:
  ------------------
  |  | 4943|     32|#define WUFFS_BASE__PIXEL_FORMAT__Y                         0x20000008
  ------------------
  |  Branch (32502:5): [True: 32, False: 228]
  ------------------
32503|     32|      switch (blend) {
  ------------------
  |  Branch (32503:15): [True: 32, False: 0]
  ------------------
32504|     16|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     16|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32504:9): [True: 16, False: 16]
  ------------------
32505|     16|          return wuffs_private_impl__swizzle_y__rgba_premul__src;
32506|     16|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     16|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32506:9): [True: 16, False: 16]
  ------------------
32507|     16|          return wuffs_private_impl__swizzle_y__rgba_premul__src_over;
32508|     32|      }
32509|      0|      return NULL;
32510|       |
32511|     28|    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
  ------------------
  |  | 4962|     28|#define WUFFS_BASE__PIXEL_FORMAT__BGR_565                   0x80000565
  ------------------
  |  Branch (32511:5): [True: 28, False: 232]
  ------------------
32512|     28|      switch (blend) {
  ------------------
  |  Branch (32512:15): [True: 28, False: 0]
  ------------------
32513|     15|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     15|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32513:9): [True: 15, False: 13]
  ------------------
32514|     15|          return wuffs_private_impl__swizzle_bgr_565__rgba_premul__src;
32515|     13|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     13|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32515:9): [True: 13, False: 15]
  ------------------
32516|     13|          return wuffs_private_impl__swizzle_bgr_565__rgba_premul__src_over;
32517|     28|      }
32518|      0|      return NULL;
32519|       |
32520|     12|    case WUFFS_BASE__PIXEL_FORMAT__BGR:
  ------------------
  |  | 4963|     12|#define WUFFS_BASE__PIXEL_FORMAT__BGR                       0x80000888
  ------------------
  |  Branch (32520:5): [True: 12, False: 248]
  ------------------
32521|     12|      switch (blend) {
  ------------------
  |  Branch (32521:15): [True: 12, False: 0]
  ------------------
32522|      9|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      9|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32522:9): [True: 9, False: 3]
  ------------------
32523|      9|          return wuffs_private_impl__swizzle_bgr__rgba_premul__src;
32524|      3|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      3|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32524:9): [True: 3, False: 9]
  ------------------
32525|      3|          return wuffs_private_impl__swizzle_bgr__rgba_premul__src_over;
32526|     12|      }
32527|      0|      return NULL;
32528|       |
32529|     25|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
  ------------------
  |  | 4964|     25|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL            0x81008888
  ------------------
  |  Branch (32529:5): [True: 25, False: 235]
  ------------------
32530|     25|      switch (blend) {
  ------------------
  |  Branch (32530:15): [True: 25, False: 0]
  ------------------
32531|     16|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     16|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32531:9): [True: 16, False: 9]
  ------------------
32532|     16|          return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src;
32533|      9|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      9|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32533:9): [True: 9, False: 16]
  ------------------
32534|      9|          return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src_over;
32535|     25|      }
32536|      0|      return NULL;
32537|       |
32538|     48|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
  ------------------
  |  | 4965|     48|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE     0x8100BBBB
  ------------------
  |  Branch (32538:5): [True: 48, False: 212]
  ------------------
32539|     48|      switch (blend) {
  ------------------
  |  Branch (32539:15): [True: 48, False: 0]
  ------------------
32540|     22|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     22|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32540:9): [True: 22, False: 26]
  ------------------
32541|     22|          return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_premul__src;
32542|     26|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     26|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32542:9): [True: 26, False: 22]
  ------------------
32543|     26|          return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_premul__src_over;
32544|     48|      }
32545|      0|      return NULL;
32546|       |
32547|     14|    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
  ------------------
  |  | 4966|     14|#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL               0x82008888
  ------------------
  |  Branch (32547:5): [True: 14, False: 246]
  ------------------
32548|     14|      switch (blend) {
  ------------------
  |  Branch (32548:15): [True: 14, False: 0]
  ------------------
32549|      3|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      3|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32549:9): [True: 3, False: 11]
  ------------------
32550|      3|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2)
32551|      3|          if (wuffs_base__cpu_arch__have_x86_sse42()) {
  ------------------
  |  Branch (32551:15): [True: 3, False: 0]
  ------------------
32552|      3|            return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42;
32553|      3|          }
32554|      0|#endif
32555|      0|          return wuffs_private_impl__swizzle_swap_rgbx_bgrx;
32556|     11|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32556:9): [True: 11, False: 3]
  ------------------
32557|     11|          return wuffs_private_impl__swizzle_bgra_premul__rgba_premul__src_over;
32558|     14|      }
32559|      0|      return NULL;
32560|       |
32561|     20|    case WUFFS_BASE__PIXEL_FORMAT__RGB:
  ------------------
  |  | 4971|     20|#define WUFFS_BASE__PIXEL_FORMAT__RGB                       0xA0000888
  ------------------
  |  Branch (32561:5): [True: 20, False: 240]
  ------------------
32562|     20|      switch (blend) {
  ------------------
  |  Branch (32562:15): [True: 20, False: 0]
  ------------------
32563|     12|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     12|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32563:9): [True: 12, False: 8]
  ------------------
32564|     12|          return wuffs_private_impl__swizzle_bgr__bgra_premul__src;
32565|      8|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|      8|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32565:9): [True: 8, False: 12]
  ------------------
32566|      8|          return wuffs_private_impl__swizzle_bgr__bgra_premul__src_over;
32567|     20|      }
32568|      0|      return NULL;
32569|       |
32570|     42|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
  ------------------
  |  | 4972|     42|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL            0xA1008888
  ------------------
  |  Branch (32570:5): [True: 42, False: 218]
  ------------------
32571|     42|      switch (blend) {
  ------------------
  |  Branch (32571:15): [True: 42, False: 0]
  ------------------
32572|     18|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|     18|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32572:9): [True: 18, False: 24]
  ------------------
32573|     18|          return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src;
32574|     24|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     24|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32574:9): [True: 24, False: 18]
  ------------------
32575|     24|          return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src_over;
32576|     42|      }
32577|      0|      return NULL;
32578|       |
32579|     13|    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
  ------------------
  |  | 4974|     13|#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL               0xA2008888
  ------------------
  |  Branch (32579:5): [True: 13, False: 247]
  ------------------
32580|     13|      switch (blend) {
  ------------------
  |  Branch (32580:15): [True: 13, False: 0]
  ------------------
32581|      2|        case WUFFS_BASE__PIXEL_BLEND__SRC:
  ------------------
  |  | 4855|      2|#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
  ------------------
  |  Branch (32581:9): [True: 2, False: 11]
  ------------------
32582|      2|          return wuffs_private_impl__swizzle_copy_4_4;
32583|     11|        case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
  ------------------
  |  | 4856|     11|#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
  ------------------
  |  Branch (32583:9): [True: 11, False: 2]
  ------------------
32584|     11|          return wuffs_private_impl__swizzle_bgra_premul__bgra_premul__src_over;
32585|     13|      }
32586|      0|      return NULL;
32587|    260|  }
32588|     26|  return NULL;
32589|    260|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgba_premul__src:
30805|     16|                                                size_t src_len) {
30806|     16|  size_t src_len4 = src_len / 4;
30807|     16|  size_t len = (dst_len < src_len4) ? dst_len : src_len4;
  ------------------
  |  Branch (30807:16): [True: 1, False: 15]
  ------------------
30808|     16|  uint8_t* d = dst_ptr;
30809|     16|  const uint8_t* s = src_ptr;
30810|     16|  size_t n = len;
30811|       |
30812|       |  // TODO: unroll.
30813|       |
30814|    330|  while (n >= 1) {
  ------------------
  |  Branch (30814:10): [True: 314, False: 16]
  ------------------
30815|    314|    uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr(
30816|    314|        wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
30817|    314|    d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0);
30818|       |
30819|    314|    s += 1 * 4;
30820|    314|    d += 1 * 1;
30821|    314|    n -= 1;
30822|    314|  }
30823|       |
30824|     16|  return len;
30825|     16|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_y__rgba_premul__src_over:
30833|     16|                                                     size_t src_len) {
30834|     16|  size_t src_len4 = src_len / 4;
30835|     16|  size_t len = (dst_len < src_len4) ? dst_len : src_len4;
  ------------------
  |  Branch (30835:16): [True: 2, False: 14]
  ------------------
30836|     16|  uint8_t* d = dst_ptr;
30837|     16|  const uint8_t* s = src_ptr;
30838|     16|  size_t n = len;
30839|       |
30840|       |  // TODO: unroll.
30841|       |
30842|    234|  while (n >= 1) {
  ------------------
  |  Branch (30842:10): [True: 218, False: 16]
  ------------------
30843|    218|    uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0])));
30844|    218|    uint32_t s0 = wuffs_base__color_swap_u32_argb_abgr(
30845|    218|        wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
30846|    218|    d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(
30847|    218|        wuffs_private_impl__composite_premul_premul_u32_axxx(d0, s0));
30848|       |
30849|    218|    s += 1 * 4;
30850|    218|    d += 1 * 1;
30851|    218|    n -= 1;
30852|    218|  }
30853|       |
30854|     16|  return len;
30855|     16|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgba_premul__src:
26540|     15|                                                      size_t src_len) {
26541|     15|  size_t dst_len2 = dst_len / 2;
26542|     15|  size_t src_len4 = src_len / 4;
26543|     15|  size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;
  ------------------
  |  Branch (26543:16): [True: 1, False: 14]
  ------------------
26544|     15|  uint8_t* d = dst_ptr;
26545|     15|  const uint8_t* s = src_ptr;
26546|     15|  size_t n = len;
26547|       |
26548|       |  // TODO: unroll.
26549|       |
26550|    250|  while (n >= 1) {
  ------------------
  |  Branch (26550:10): [True: 235, False: 15]
  ------------------
26551|    235|    wuffs_base__poke_u16le__no_bounds_check(
26552|    235|        d + (0 * 2),
26553|    235|        wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(
26554|    235|            wuffs_base__color_swap_u32_argb_abgr(
26555|    235|                wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))));
26556|       |
26557|    235|    s += 1 * 4;
26558|    235|    d += 1 * 2;
26559|    235|    n -= 1;
26560|    235|  }
26561|       |
26562|     15|  return len;
26563|     15|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgr_565__rgba_premul__src_over:
26572|     13|    size_t src_len) {
26573|     13|  size_t dst_len2 = dst_len / 2;
26574|     13|  size_t src_len4 = src_len / 4;
26575|     13|  size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;
  ------------------
  |  Branch (26575:16): [True: 1, False: 12]
  ------------------
26576|     13|  uint8_t* d = dst_ptr;
26577|     13|  const uint8_t* s = src_ptr;
26578|     13|  size_t n = len;
26579|       |
26580|       |  // TODO: unroll.
26581|       |
26582|    297|  while (n >= 1) {
  ------------------
  |  Branch (26582:10): [True: 284, False: 13]
  ------------------
26583|       |    // Extract 16-bit color components.
26584|    284|    uint32_t sa = 0x101 * ((uint32_t)s[3]);
26585|    284|    uint32_t sb = 0x101 * ((uint32_t)s[2]);
26586|    284|    uint32_t sg = 0x101 * ((uint32_t)s[1]);
26587|    284|    uint32_t sr = 0x101 * ((uint32_t)s[0]);
26588|       |
26589|       |    // Convert from 565 color to 16-bit color.
26590|    284|    uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));
26591|    284|    uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);
26592|    284|    uint32_t dr = (0x8421 * old_r5) >> 4;
26593|    284|    uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);
26594|    284|    uint32_t dg = (0x1041 * old_g6) >> 2;
26595|    284|    uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);
26596|    284|    uint32_t db = (0x8421 * old_b5) >> 4;
26597|       |
26598|       |    // Calculate the inverse of the src-alpha: how much of the dst to keep.
26599|    284|    uint32_t ia = 0xFFFF - sa;
26600|       |
26601|       |    // Composite src (premul) over dst (premul).
26602|    284|    dr = sr + ((dr * ia) / 0xFFFF);
26603|    284|    dg = sg + ((dg * ia) / 0xFFFF);
26604|    284|    db = sb + ((db * ia) / 0xFFFF);
26605|       |
26606|       |    // Convert from 16-bit color to 565 color and combine the components.
26607|    284|    uint32_t new_r5 = 0x1F & (dr >> 11);
26608|    284|    uint32_t new_g6 = 0x3F & (dg >> 10);
26609|    284|    uint32_t new_b5 = 0x1F & (db >> 11);
26610|    284|    uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);
26611|    284|    wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);
26612|       |
26613|    284|    s += 1 * 4;
26614|    284|    d += 1 * 2;
26615|    284|    n -= 1;
26616|    284|  }
26617|       |
26618|     13|  return len;
26619|     13|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_premul__src:
28327|     22|    size_t src_len) {
28328|     22|  size_t dst_len8 = dst_len / 8;
28329|     22|  size_t src_len4 = src_len / 4;
28330|     22|  size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
  ------------------
  |  Branch (28330:16): [True: 6, False: 16]
  ------------------
28331|     22|  uint8_t* d = dst_ptr;
28332|     22|  const uint8_t* s = src_ptr;
28333|       |
28334|     22|  size_t n = len;
28335|    151|  while (n >= 1) {
  ------------------
  |  Branch (28335:10): [True: 129, False: 22]
  ------------------
28336|    129|    uint64_t s0 = wuffs_base__color_u32__as__color_u64(
28337|    129|        wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(
28338|    129|            wuffs_base__color_swap_u32_argb_abgr(
28339|    129|                wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))));
28340|    129|    wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0);
28341|       |
28342|    129|    s += 1 * 4;
28343|    129|    d += 1 * 8;
28344|    129|    n -= 1;
28345|    129|  }
28346|     22|  return len;
28347|     22|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__rgba_premul__src_over:
28356|     26|    size_t src_len) {
28357|     26|  size_t dst_len8 = dst_len / 8;
28358|     26|  size_t src_len4 = src_len / 4;
28359|     26|  size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
  ------------------
  |  Branch (28359:16): [True: 9, False: 17]
  ------------------
28360|     26|  uint8_t* d = dst_ptr;
28361|     26|  const uint8_t* s = src_ptr;
28362|       |
28363|     26|  size_t n = len;
28364|    260|  while (n >= 1) {
  ------------------
  |  Branch (28364:10): [True: 234, False: 26]
  ------------------
28365|    234|    uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));
28366|    234|    uint64_t s0 = wuffs_base__color_u32__as__color_u64(
28367|    234|        wuffs_base__color_swap_u32_argb_abgr(
28368|    234|            wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))));
28369|    234|    wuffs_base__poke_u64le__no_bounds_check(
28370|    234|        d + (0 * 8),
28371|    234|        wuffs_private_impl__composite_nonpremul_premul_u64_axxx(d0, s0));
28372|       |
28373|    234|    s += 1 * 4;
28374|    234|    d += 1 * 8;
28375|    234|    n -= 1;
28376|    234|  }
28377|     26|  return len;
28378|     26|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__u32__max_of_4:
32935|  7.01k|                                  uint32_t d) {
32936|  7.01k|  return wuffs_base__u32__max(     //
32937|  7.01k|      wuffs_base__u32__max(a, b),  //
32938|  7.01k|      wuffs_base__u32__max(c, d));
32939|  7.01k|}
pixel_swizzler_fuzzer.c:wuffs_base__pixel_config__width:
 5379|  2.30k|wuffs_base__pixel_config__width(const wuffs_base__pixel_config* c) {
 5380|  2.30k|  return c ? c->private_impl.width : 0;
  ------------------
  |  Branch (5380:10): [True: 2.30k, False: 0]
  ------------------
 5381|  2.30k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__u32__min_of_5:
32946|  4.60k|                                  uint32_t e) {
32947|  4.60k|  return wuffs_base__u32__min(          //
32948|  4.60k|      wuffs_base__u32__min(             //
32949|  4.60k|          wuffs_base__u32__min(a, b),   //
32950|  4.60k|          wuffs_base__u32__min(c, d)),  //
32951|  4.60k|      e);
32952|  4.60k|}
pixel_swizzler_fuzzer.c:wuffs_base__pixel_config__height:
 5384|  2.30k|wuffs_base__pixel_config__height(const wuffs_base__pixel_config* c) {
 5385|  2.30k|  return c ? c->private_impl.height : 0;
  ------------------
  |  Branch (5385:10): [True: 2.30k, False: 0]
  ------------------
 5386|  2.30k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_flattened_length:
34251|  7.34k|                                             uint32_t inv_v) {
34252|  7.34k|  uint64_t scaled_width = (((uint64_t)width) + (inv_h - 1u)) / inv_h;
34253|  7.34k|  uint64_t scaled_height = (((uint64_t)height) + (inv_v - 1u)) / inv_v;
34254|  7.34k|  if (scaled_height <= 0u) {
  ------------------
  |  Branch (34254:7): [True: 0, False: 7.34k]
  ------------------
34255|      0|    return 0u;
34256|      0|  }
34257|  7.34k|  return ((scaled_height - 1u) * stride) + scaled_width;
34258|  7.34k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_rgb__convert_3_general:
33134|  9.36k|    const uint8_t* up2) {
33135|   288k|  for (; x < x_end; x++) {
  ------------------
  |  Branch (33135:10): [True: 279k, False: 9.36k]
  ------------------
33136|   279k|    uint32_t color = 0xFF000000u |                    //
33137|   279k|                     (((uint32_t)(*up0++)) << 16u) |  //
33138|   279k|                     (((uint32_t)(*up1++)) << 8u) |   //
33139|   279k|                     (((uint32_t)(*up2++)) << 0u);
33140|   279k|    wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(dst, x, y, color);
33141|   279k|  }
33142|  9.36k|}
pixel_swizzler_fuzzer.c:wuffs_base__cpu_arch__have_x86_avx2:
  289|    993|wuffs_base__cpu_arch__have_x86_avx2(void) {
  290|       |#if defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) && \
  291|       |    defined(__AVX2__)
  292|       |  return true;
  293|       |#else
  294|    993|#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
  295|       |  // GCC defines these macros but MSVC does not.
  296|       |  //  - bit_AVX2 = (1 <<  5)
  297|    993|  const unsigned int avx2_ebx7 = 0x00000020;
  298|       |  // GCC defines these macros but MSVC does not.
  299|       |  //  - bit_PCLMUL = (1 <<  1)
  300|       |  //  - bit_POPCNT = (1 << 23)
  301|       |  //  - bit_SSE4_2 = (1 << 20)
  302|    993|  const unsigned int avx2_ecx1 = 0x00900002;
  303|       |
  304|       |  // clang defines __GNUC__ and clang-cl defines _MSC_VER (but not __GNUC__).
  305|    993|#if defined(__GNUC__)
  306|    993|  unsigned int eax7 = 0;
  307|    993|  unsigned int ebx7 = 0;
  308|    993|  unsigned int ecx7 = 0;
  309|    993|  unsigned int edx7 = 0;
  310|    993|  if (__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7) &&
  ------------------
  |  Branch (310:7): [True: 993, False: 0]
  ------------------
  311|    993|      ((ebx7 & avx2_ebx7) == avx2_ebx7)) {
  ------------------
  |  Branch (311:7): [True: 993, False: 0]
  ------------------
  312|    993|    unsigned int eax1 = 0;
  313|    993|    unsigned int ebx1 = 0;
  314|    993|    unsigned int ecx1 = 0;
  315|    993|    unsigned int edx1 = 0;
  316|    993|    if (__get_cpuid(1, &eax1, &ebx1, &ecx1, &edx1) &&
  ------------------
  |  Branch (316:9): [True: 993, False: 0]
  ------------------
  317|    993|        ((ecx1 & avx2_ecx1) == avx2_ecx1)) {
  ------------------
  |  Branch (317:9): [True: 993, False: 0]
  ------------------
  318|    993|      return true;
  319|    993|    }
  320|    993|  }
  321|       |#elif defined(_MSC_VER)  // defined(__GNUC__)
  322|       |  int x7[4];
  323|       |  __cpuidex(x7, 7, 0);
  324|       |  if ((((unsigned int)(x7[1])) & avx2_ebx7) == avx2_ebx7) {
  325|       |    int x1[4];
  326|       |    __cpuid(x1, 1);
  327|       |    if ((((unsigned int)(x1[2])) & avx2_ecx1) == avx2_ecx1) {
  328|       |      return true;
  329|       |    }
  330|       |  }
  331|       |#else
  332|       |#error "WUFFS_PRIVATE_IMPL__CPU_ARCH__ETC combined with an unsupported compiler"
  333|       |#endif  // defined(__GNUC__); defined(_MSC_VER)
  334|      0|#endif  // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64)
  335|      0|  return false;
  336|    993|#endif  // defined(__PCLMUL__) && defined(__POPCNT__) && defined(__SSE4_2__) &&
  337|       |        // defined(__AVX2__)
  338|    993|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_bgrx:
33169|  4.53k|    const uint8_t* up2) {
33170|  4.53k|  size_t dst_stride = dst->private_impl.planes[0].stride;
33171|  4.53k|  uint8_t* dst_iter = dst->private_impl.planes[0].ptr +
33172|  4.53k|                      (dst_stride * ((size_t)y)) + (4u * ((size_t)x));
33173|       |
33174|  64.8k|  for (; x < x_end; x++) {
  ------------------
  |  Branch (33174:10): [True: 60.2k, False: 4.53k]
  ------------------
33175|  60.2k|    uint32_t color =                                   //
33176|  60.2k|        wuffs_base__color_ycc_bt601fr__as__color_u32(  //
33177|  60.2k|            *up0++, *up1++, *up2++);
33178|  60.2k|    wuffs_base__poke_u32le__no_bounds_check(dst_iter, color);
33179|  60.2k|    dst_iter += 4u;
33180|  60.2k|  }
33181|  4.53k|}
pixel_swizzler_fuzzer.c:wuffs_base__color_ycc_bt601fr__as__color_u32:
 4691|   290k|                                             uint8_t cr) {
 4692|       |  // Work in 16.16 fixed point arithmetic (so that 'one half' is (1 << 15)) and
 4693|       |  // bias the chroma values by 0x80.
 4694|   290k|  uint32_t yy32 = (((uint32_t)yy) << 16) | (1 << 15);
 4695|   290k|  uint32_t cb32 = (((uint32_t)cb) - 0x80);
 4696|   290k|  uint32_t cr32 = (((uint32_t)cr) - 0x80);
 4697|       |
 4698|       |  // The formulae:
 4699|       |  //
 4700|       |  //  R = Y                + 1.40200 * Cr
 4701|       |  //  G = Y - 0.34414 * Cb - 0.71414 * Cr
 4702|       |  //  B = Y + 1.77200 * Cb
 4703|       |  //
 4704|       |  // When scaled by 1<<16:
 4705|       |  //
 4706|       |  //  0.34414 becomes 0x0581A =  22554.
 4707|       |  //  0.71414 becomes 0x0B6D2 =  46802.
 4708|       |  //  1.40200 becomes 0x166E9 =  91881.
 4709|       |  //  1.77200 becomes 0x1C5A2 = 116130.
 4710|       |  //
 4711|       |  // Since we're working in 16.16 fixed point arithmetic, masking by 0x00FF0000
 4712|       |  // (possibly followed by a shift) gives the relevant 8 bits per channel.
 4713|       |  //
 4714|       |  // However, we need to saturate for overflow (above 0x00FFFFFF, but not so
 4715|       |  // high that the MSB Most Significant Bit is set) or for underflow (below
 4716|       |  // 0x00000000 as int32_t, which means that the MSB is set as uint32_t). In
 4717|       |  // both cases, some of the high 8 bits (bits 24 ..= 31) will be set.
 4718|       |  //
 4719|       |  // "((uint32_t)(((int32_t)x) >> 31))" just replicates x's MSB across all 32
 4720|       |  // bits. Prepending that with "~" inverts those bits. Thus, "~(etc)" is
 4721|       |  // either 0xFFFFFFFF (for overflow) or 0x00000000 (for underflow).
 4722|   290k|  uint32_t rr32 = yy32 + (0x166E9 * cr32);
 4723|   290k|  uint32_t gg32 = yy32 - (0x0581A * cb32) - (0x0B6D2 * cr32);
 4724|   290k|  uint32_t bb32 = yy32 + (0x1C5A2 * cb32);
 4725|   290k|  if (rr32 >> 24) {
  ------------------
  |  Branch (4725:7): [True: 93.3k, False: 197k]
  ------------------
 4726|  93.3k|    rr32 = ~((uint32_t)(((int32_t)rr32) >> 31));
 4727|  93.3k|  }
 4728|   290k|  if (gg32 >> 24) {
  ------------------
  |  Branch (4728:7): [True: 59.8k, False: 230k]
  ------------------
 4729|  59.8k|    gg32 = ~((uint32_t)(((int32_t)gg32) >> 31));
 4730|  59.8k|  }
 4731|   290k|  if (bb32 >> 24) {
  ------------------
  |  Branch (4731:7): [True: 131k, False: 159k]
  ------------------
 4732|   131k|    bb32 = ~((uint32_t)(((int32_t)bb32) >> 31));
 4733|   131k|  }
 4734|   290k|  return 0xFF000000 |                  //
 4735|   290k|         ((0x00FF0000 & rr32) >> 0) |  //
 4736|   290k|         ((0x00FF0000 & gg32) >> 8) |  //
 4737|   290k|         ((0x00FF0000 & bb32) >> 16);
 4738|   290k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_rgbx:
33191|  4.49k|    const uint8_t* up2) {
33192|  4.49k|  size_t dst_stride = dst->private_impl.planes[0].stride;
33193|  4.49k|  uint8_t* dst_iter = dst->private_impl.planes[0].ptr +
33194|  4.49k|                      (dst_stride * ((size_t)y)) + (4u * ((size_t)x));
33195|       |
33196|  68.6k|  for (; x < x_end; x++) {
  ------------------
  |  Branch (33196:10): [True: 64.1k, False: 4.49k]
  ------------------
33197|  64.1k|    uint32_t color =                                        //
33198|  64.1k|        wuffs_base__color_ycc_bt601fr__as__color_u32_abgr(  //
33199|  64.1k|            *up0++, *up1++, *up2++);
33200|  64.1k|    wuffs_base__poke_u32le__no_bounds_check(dst_iter, color);
33201|  64.1k|    dst_iter += 4u;
33202|  64.1k|  }
33203|  4.49k|}
pixel_swizzler_fuzzer.c:wuffs_base__color_ycc_bt601fr__as__color_u32_abgr:
 4746|  64.1k|                                                  uint8_t cr) {
 4747|  64.1k|  uint32_t yy32 = (((uint32_t)yy) << 16) | (1 << 15);
 4748|  64.1k|  uint32_t cb32 = (((uint32_t)cb) - 0x80);
 4749|  64.1k|  uint32_t cr32 = (((uint32_t)cr) - 0x80);
 4750|  64.1k|  uint32_t rr32 = yy32 + (0x166E9 * cr32);
 4751|  64.1k|  uint32_t gg32 = yy32 - (0x0581A * cb32) - (0x0B6D2 * cr32);
 4752|  64.1k|  uint32_t bb32 = yy32 + (0x1C5A2 * cb32);
 4753|  64.1k|  if (rr32 >> 24) {
  ------------------
  |  Branch (4753:7): [True: 22.5k, False: 41.6k]
  ------------------
 4754|  22.5k|    rr32 = ~((uint32_t)(((int32_t)rr32) >> 31));
 4755|  22.5k|  }
 4756|  64.1k|  if (gg32 >> 24) {
  ------------------
  |  Branch (4756:7): [True: 15.9k, False: 48.2k]
  ------------------
 4757|  15.9k|    gg32 = ~((uint32_t)(((int32_t)gg32) >> 31));
 4758|  15.9k|  }
 4759|  64.1k|  if (bb32 >> 24) {
  ------------------
  |  Branch (4759:7): [True: 31.7k, False: 32.4k]
  ------------------
 4760|  31.7k|    bb32 = ~((uint32_t)(((int32_t)bb32) >> 31));
 4761|  31.7k|  }
 4762|  64.1k|  return 0xFF000000 |                  //
 4763|  64.1k|         ((0x00FF0000 & bb32) >> 0) |  //
 4764|  64.1k|         ((0x00FF0000 & gg32) >> 8) |  //
 4765|  64.1k|         ((0x00FF0000 & rr32) >> 16);
 4766|  64.1k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_general:
33152|  11.2k|    const uint8_t* up2) {
33153|   241k|  for (; x < x_end; x++) {
  ------------------
  |  Branch (33153:10): [True: 230k, False: 11.2k]
  ------------------
33154|   230k|    uint32_t color =                                   //
33155|   230k|        wuffs_base__color_ycc_bt601fr__as__color_u32(  //
33156|   230k|            *up0++, *up1++, *up2++);
33157|   230k|    wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(dst, x, y, color);
33158|   230k|  }
33159|  11.2k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__general__box_filter:
34092|  1.33k|    wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) {
34093|  1.33k|  wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 =
34094|  1.33k|      (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
34095|  1.33k|  wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 =
34096|  1.33k|      (*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u];
34097|  1.33k|  wuffs_private_impl__swizzle_ycc__upsample_func upfunc2 =
34098|  1.33k|      (*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u];
34099|       |
34100|  1.33k|  uint32_t y;
34101|  23.8k|  for (y = y_min_incl; y < y_max_excl; y++) {
  ------------------
  |  Branch (34101:24): [True: 22.5k, False: 1.33k]
  ------------------
34102|  22.5k|    const uint8_t* src0_major =
34103|  22.5k|        src_ptr0 + (((y - y_min_incl) / inv_v0) * (size_t)stride0);
34104|  22.5k|    const uint8_t* src1_major =
34105|  22.5k|        src_ptr1 + (((y - y_min_incl) / inv_v1) * (size_t)stride1);
34106|  22.5k|    const uint8_t* src2_major =
34107|  22.5k|        src_ptr2 + (((y - y_min_incl) / inv_v2) * (size_t)stride2);
34108|       |
34109|  22.5k|    uint32_t x = x_min_incl;
34110|  45.0k|    while (x < x_max_excl) {
  ------------------
  |  Branch (34110:12): [True: 22.5k, False: 22.5k]
  ------------------
34111|  22.5k|      uint32_t end = x + 672u;
34112|  22.5k|      if (end > x_max_excl) {
  ------------------
  |  Branch (34112:11): [True: 22.5k, False: 0]
  ------------------
34113|  22.5k|        end = x_max_excl;
34114|  22.5k|      }
34115|       |
34116|  22.5k|      uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0;
34117|  22.5k|      uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1;
34118|  22.5k|      uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2;
34119|       |
34120|  22.5k|      const uint8_t* up0 = (*upfunc0)(               //
34121|  22.5k|          scratch_buffer_2k_ptr + (0u * 672u),       //
34122|  22.5k|          src0_major + ((x - x_min_incl) / inv_h0),  //
34123|  22.5k|          src0_major + ((x - x_min_incl) / inv_h0),  //
34124|  22.5k|          src_len0,                                  //
34125|  22.5k|          0u, false, false);
34126|       |
34127|  22.5k|      const uint8_t* up1 = (*upfunc1)(               //
34128|  22.5k|          scratch_buffer_2k_ptr + (1u * 672u),       //
34129|  22.5k|          src1_major + ((x - x_min_incl) / inv_h1),  //
34130|  22.5k|          src1_major + ((x - x_min_incl) / inv_h1),  //
34131|  22.5k|          src_len1,                                  //
34132|  22.5k|          0u, false, false);
34133|       |
34134|  22.5k|      const uint8_t* up2 = (*upfunc2)(               //
34135|  22.5k|          scratch_buffer_2k_ptr + (2u * 672u),       //
34136|  22.5k|          src2_major + ((x - x_min_incl) / inv_h2),  //
34137|  22.5k|          src2_major + ((x - x_min_incl) / inv_h2),  //
34138|  22.5k|          src_len2,                                  //
34139|  22.5k|          0u, false, false);
34140|       |
34141|  22.5k|      (*conv3func)(dst, x, end, y, up0, up1, up2);
34142|  22.5k|      x = end;
34143|  22.5k|    }
34144|  22.5k|  }
34145|  1.33k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h1vn_box:
33309|  52.7k|    bool last_column_ignored) {
33310|  52.7k|  return src_ptr_major;
33311|  52.7k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h2vn_box:
33321|  5.07k|    bool last_column_ignored) {
33322|  5.07k|  uint8_t* dp = dst_ptr;
33323|  5.07k|  const uint8_t* sp = src_ptr_major;
33324|  54.6k|  while (src_len--) {
  ------------------
  |  Branch (33324:10): [True: 49.6k, False: 5.07k]
  ------------------
33325|  49.6k|    uint8_t sv = *sp++;
33326|  49.6k|    *dp++ = sv;
33327|  49.6k|    *dp++ = sv;
33328|  49.6k|  }
33329|  5.07k|  return dst_ptr;
33330|  5.07k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h3vn_box:
33340|  11.0k|    bool last_column_ignored) {
33341|  11.0k|  uint8_t* dp = dst_ptr;
33342|  11.0k|  const uint8_t* sp = src_ptr_major;
33343|   101k|  while (src_len--) {
  ------------------
  |  Branch (33343:10): [True: 90.8k, False: 11.0k]
  ------------------
33344|  90.8k|    uint8_t sv = *sp++;
33345|  90.8k|    *dp++ = sv;
33346|  90.8k|    *dp++ = sv;
33347|  90.8k|    *dp++ = sv;
33348|  90.8k|  }
33349|  11.0k|  return dst_ptr;
33350|  11.0k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h4vn_box:
33360|  10.5k|    bool last_column_ignored) {
33361|  10.5k|  uint8_t* dp = dst_ptr;
33362|  10.5k|  const uint8_t* sp = src_ptr_major;
33363|  86.3k|  while (src_len--) {
  ------------------
  |  Branch (33363:10): [True: 75.8k, False: 10.5k]
  ------------------
33364|  75.8k|    uint8_t sv = *sp++;
33365|  75.8k|    *dp++ = sv;
33366|  75.8k|    *dp++ = sv;
33367|  75.8k|    *dp++ = sv;
33368|  75.8k|    *dp++ = sv;
33369|  75.8k|  }
33370|  10.5k|  return dst_ptr;
33371|  10.5k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_has_triangle_upsampler:
33575|  2.57k|                                                   uint32_t inv_v) {
33576|  2.57k|  if (inv_h == 1u) {
  ------------------
  |  Branch (33576:7): [True: 1.21k, False: 1.36k]
  ------------------
33577|  1.21k|    return inv_v == 2u;
33578|  1.36k|  } else if (inv_h == 2u) {
  ------------------
  |  Branch (33578:14): [True: 263, False: 1.10k]
  ------------------
33579|    263|    return (inv_v == 1u) || (inv_v == 2u);
  ------------------
  |  Branch (33579:12): [True: 154, False: 109]
  |  Branch (33579:29): [True: 58, False: 51]
  ------------------
33580|    263|  }
33581|  1.10k|  return false;
33582|  2.57k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__general__triangle_filter:
33955|    376|    wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) {
33956|    376|  if ((x_min_incl != 0) || (y_min_incl != 0)) {
  ------------------
  |  Branch (33956:7): [True: 0, False: 376]
  |  Branch (33956:28): [True: 0, False: 376]
  ------------------
33957|      0|    return;
33958|      0|  }
33959|       |
33960|    376|  wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 =
33961|    376|      (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
33962|    376|  wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 =
33963|    376|      (*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u];
33964|    376|  wuffs_private_impl__swizzle_ycc__upsample_func upfunc2 =
33965|    376|      (*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u];
33966|       |
33967|       |  // First row.
33968|    376|  uint32_t h1v2_bias = 1u;
33969|    376|  wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row(
33970|    376|      dst, x_max_excl, 0u,           //
33971|    376|      src_ptr0, src_ptr1, src_ptr2,  //
33972|    376|      stride0, stride1, stride2,     //
33973|    376|      inv_h0, inv_h1, inv_h2,        //
33974|    376|      inv_v0, inv_v1, inv_v2,        //
33975|    376|      half_width_for_2to1,           //
33976|    376|      h1v2_bias,                     //
33977|    376|      scratch_buffer_2k_ptr,         //
33978|    376|      upfunc0, upfunc1, upfunc2, conv3func);
33979|    376|  h1v2_bias = 2u;
33980|       |
33981|       |  // Middle rows.
33982|    376|  bool last_row = y_max_excl == 2u * half_height_for_2to1;
33983|    376|  uint32_t middle_y_max_excl = last_row ? (y_max_excl - 1u) : y_max_excl;
  ------------------
  |  Branch (33983:32): [True: 241, False: 135]
  ------------------
33984|    376|  uint32_t y;
33985|  7.94k|  for (y = 1u; y < middle_y_max_excl; y++) {
  ------------------
  |  Branch (33985:16): [True: 7.56k, False: 376]
  ------------------
33986|  7.56k|    const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0);
33987|  7.56k|    const uint8_t* src0_minor =
33988|  7.56k|        (inv_v0 != 2u)
  ------------------
  |  Branch (33988:9): [True: 4.84k, False: 2.71k]
  ------------------
33989|  7.56k|            ? src0_major
33990|  7.56k|            : ((y & 1u) ? (src0_major + stride0) : (src0_major - stride0));
  ------------------
  |  Branch (33990:16): [True: 1.35k, False: 1.35k]
  ------------------
33991|  7.56k|    const uint8_t* src1_major = src_ptr1 + ((y / inv_v1) * (size_t)stride1);
33992|  7.56k|    const uint8_t* src1_minor =
33993|  7.56k|        (inv_v1 != 2u)
  ------------------
  |  Branch (33993:9): [True: 3.67k, False: 3.88k]
  ------------------
33994|  7.56k|            ? src1_major
33995|  7.56k|            : ((y & 1u) ? (src1_major + stride1) : (src1_major - stride1));
  ------------------
  |  Branch (33995:16): [True: 1.94k, False: 1.94k]
  ------------------
33996|  7.56k|    const uint8_t* src2_major = src_ptr2 + ((y / inv_v2) * (size_t)stride2);
33997|  7.56k|    const uint8_t* src2_minor =
33998|  7.56k|        (inv_v2 != 2u)
  ------------------
  |  Branch (33998:9): [True: 5.71k, False: 1.84k]
  ------------------
33999|  7.56k|            ? src2_major
34000|  7.56k|            : ((y & 1u) ? (src2_major + stride2) : (src2_major - stride2));
  ------------------
  |  Branch (34000:16): [True: 923, False: 923]
  ------------------
34001|  7.56k|    uint32_t total_src_len0 = 0u;
34002|  7.56k|    uint32_t total_src_len1 = 0u;
34003|  7.56k|    uint32_t total_src_len2 = 0u;
34004|       |
34005|  7.56k|    uint32_t x = 0u;
34006|  15.1k|    while (x < x_max_excl) {
  ------------------
  |  Branch (34006:12): [True: 7.56k, False: 7.56k]
  ------------------
34007|  7.56k|      bool first_column = x == 0u;
34008|  7.56k|      uint32_t end = x + 672u;
34009|  7.56k|      if (end > x_max_excl) {
  ------------------
  |  Branch (34009:11): [True: 7.56k, False: 0]
  ------------------
34010|  7.56k|        end = x_max_excl;
34011|  7.56k|      }
34012|       |
34013|  7.56k|      uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0;
34014|  7.56k|      uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1;
34015|  7.56k|      uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2;
34016|  7.56k|      total_src_len0 += src_len0;
34017|  7.56k|      total_src_len1 += src_len1;
34018|  7.56k|      total_src_len2 += src_len2;
34019|       |
34020|  7.56k|      const uint8_t* up0 = (*upfunc0)(          //
34021|  7.56k|          scratch_buffer_2k_ptr + (0u * 672u),  //
34022|  7.56k|          src0_major + (x / inv_h0),            //
34023|  7.56k|          src0_minor + (x / inv_h0),            //
34024|  7.56k|          src_len0,                             //
34025|  7.56k|          h1v2_bias,                            //
34026|  7.56k|          first_column,                         //
34027|  7.56k|          (total_src_len0 >= half_width_for_2to1));
34028|       |
34029|  7.56k|      const uint8_t* up1 = (*upfunc1)(          //
34030|  7.56k|          scratch_buffer_2k_ptr + (1u * 672u),  //
34031|  7.56k|          src1_major + (x / inv_h1),            //
34032|  7.56k|          src1_minor + (x / inv_h1),            //
34033|  7.56k|          src_len1,                             //
34034|  7.56k|          h1v2_bias,                            //
34035|  7.56k|          first_column,                         //
34036|  7.56k|          (total_src_len1 >= half_width_for_2to1));
34037|       |
34038|  7.56k|      const uint8_t* up2 = (*upfunc2)(          //
34039|  7.56k|          scratch_buffer_2k_ptr + (2u * 672u),  //
34040|  7.56k|          src2_major + (x / inv_h2),            //
34041|  7.56k|          src2_minor + (x / inv_h2),            //
34042|  7.56k|          src_len2,                             //
34043|  7.56k|          h1v2_bias,                            //
34044|  7.56k|          first_column,                         //
34045|  7.56k|          (total_src_len2 >= half_width_for_2to1));
34046|       |
34047|  7.56k|      (*conv3func)(dst, x, end, y, up0, up1, up2);
34048|  7.56k|      x = end;
34049|  7.56k|    }
34050|       |
34051|  7.56k|    h1v2_bias ^= 3u;
34052|  7.56k|  }
34053|       |
34054|       |  // Last row.
34055|    376|  if (middle_y_max_excl != y_max_excl) {
  ------------------
  |  Branch (34055:7): [True: 241, False: 135]
  ------------------
34056|    241|    wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row(
34057|    241|        dst, x_max_excl, middle_y_max_excl,  //
34058|    241|        src_ptr0, src_ptr1, src_ptr2,        //
34059|    241|        stride0, stride1, stride2,           //
34060|    241|        inv_h0, inv_h1, inv_h2,              //
34061|    241|        inv_v0, inv_v1, inv_v2,              //
34062|    241|        half_width_for_2to1,                 //
34063|    241|        h1v2_bias,                           //
34064|    241|        scratch_buffer_2k_ptr,               //
34065|    241|        upfunc0, upfunc1, upfunc2, conv3func);
34066|    241|  }
34067|    376|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row:
33874|    617|    wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) {
33875|    617|  const uint8_t* src0 = src_ptr0 + ((y / inv_v0) * (size_t)stride0);
33876|    617|  const uint8_t* src1 = src_ptr1 + ((y / inv_v1) * (size_t)stride1);
33877|    617|  const uint8_t* src2 = src_ptr2 + ((y / inv_v2) * (size_t)stride2);
33878|    617|  uint32_t total_src_len0 = 0u;
33879|    617|  uint32_t total_src_len1 = 0u;
33880|    617|  uint32_t total_src_len2 = 0u;
33881|       |
33882|    617|  uint32_t x = 0u;
33883|  1.23k|  while (x < width) {
  ------------------
  |  Branch (33883:10): [True: 617, False: 617]
  ------------------
33884|    617|    bool first_column = x == 0u;
33885|    617|    uint32_t end = x + 672u;
33886|    617|    if (end > width) {
  ------------------
  |  Branch (33886:9): [True: 617, False: 0]
  ------------------
33887|    617|      end = width;
33888|    617|    }
33889|       |
33890|    617|    uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0;
33891|    617|    uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1;
33892|    617|    uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2;
33893|    617|    total_src_len0 += src_len0;
33894|    617|    total_src_len1 += src_len1;
33895|    617|    total_src_len2 += src_len2;
33896|       |
33897|    617|    const uint8_t* src_ptr_x0 = src0 + (x / inv_h0);
33898|    617|    const uint8_t* up0 = (*upfunc0)(          //
33899|    617|        scratch_buffer_2k_ptr + (0u * 672u),  //
33900|    617|        src_ptr_x0,                           //
33901|    617|        src_ptr_x0,                           //
33902|    617|        src_len0,                             //
33903|    617|        h1v2_bias,                            //
33904|    617|        first_column,                         //
33905|    617|        (total_src_len0 >= half_width_for_2to1));
33906|       |
33907|    617|    const uint8_t* src_ptr_x1 = src1 + (x / inv_h1);
33908|    617|    const uint8_t* up1 = (*upfunc1)(          //
33909|    617|        scratch_buffer_2k_ptr + (1u * 672u),  //
33910|    617|        src_ptr_x1,                           //
33911|    617|        src_ptr_x1,                           //
33912|    617|        src_len1,                             //
33913|    617|        h1v2_bias,                            //
33914|    617|        first_column,                         //
33915|    617|        (total_src_len1 >= half_width_for_2to1));
33916|       |
33917|    617|    const uint8_t* src_ptr_x2 = src2 + (x / inv_h2);
33918|    617|    const uint8_t* up2 = (*upfunc2)(          //
33919|    617|        scratch_buffer_2k_ptr + (2u * 672u),  //
33920|    617|        src_ptr_x2,                           //
33921|    617|        src_ptr_x2,                           //
33922|    617|        src_len2,                             //
33923|    617|        h1v2_bias,                            //
33924|    617|        first_column,                         //
33925|    617|        (total_src_len2 >= half_width_for_2to1));
33926|       |
33927|    617|    (*conv3func)(dst, x, end, y, up0, up1, up2);
33928|    617|    x = end;
33929|    617|  }
33930|    617|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle:
33381|  5.50k|    bool last_column_ignored) {
33382|  5.50k|  uint8_t* dp = dst_ptr;
33383|  5.50k|  const uint8_t* sp_major = src_ptr_major;
33384|  5.50k|  const uint8_t* sp_minor = src_ptr_minor;
33385|   162k|  while (src_len--) {
  ------------------
  |  Branch (33385:10): [True: 156k, False: 5.50k]
  ------------------
33386|   156k|    *dp++ = (uint8_t)(((3u * ((uint32_t)(*sp_major++))) +  //
33387|   156k|                       (1u * ((uint32_t)(*sp_minor++))) +  //
33388|   156k|                       h1v2_bias) >>
33389|   156k|                      2u);
33390|   156k|  }
33391|  5.50k|  return dst_ptr;
33392|  5.50k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle:
33402|  4.88k|    bool last_column) {
33403|  4.88k|  uint8_t* dp = dst_ptr;
33404|  4.88k|  const uint8_t* sp = src_ptr_major;
33405|       |
33406|  4.88k|  if (first_column) {
  ------------------
  |  Branch (33406:7): [True: 4.88k, False: 0]
  ------------------
33407|  4.88k|    src_len--;
33408|  4.88k|    if ((src_len <= 0u) && last_column) {
  ------------------
  |  Branch (33408:9): [True: 272, False: 4.60k]
  |  Branch (33408:28): [True: 272, False: 0]
  ------------------
33409|    272|      uint8_t sv = *sp++;
33410|    272|      *dp++ = sv;
33411|    272|      *dp++ = sv;
33412|    272|      return dst_ptr;
33413|    272|    }
33414|  4.60k|    uint32_t svp1 = sp[+1];
33415|  4.60k|    uint8_t sv = *sp++;
33416|  4.60k|    *dp++ = sv;
33417|  4.60k|    *dp++ = (uint8_t)(((3u * (uint32_t)sv) + svp1 + 2u) >> 2u);
33418|  4.60k|    if (src_len <= 0u) {
  ------------------
  |  Branch (33418:9): [True: 0, False: 4.60k]
  ------------------
33419|      0|      return dst_ptr;
33420|      0|    }
33421|  4.60k|  }
33422|       |
33423|  4.60k|  if (last_column) {
  ------------------
  |  Branch (33423:7): [True: 4.60k, False: 0]
  ------------------
33424|  4.60k|    src_len--;
33425|  4.60k|  }
33426|       |
33427|  52.1k|  for (; src_len > 0u; src_len--) {
  ------------------
  |  Branch (33427:10): [True: 47.4k, False: 4.60k]
  ------------------
33428|  47.4k|    uint32_t svm1 = sp[-1];
33429|  47.4k|    uint32_t svp1 = sp[+1];
33430|  47.4k|    uint32_t sv3 = 3u * (uint32_t)(*sp++);
33431|  47.4k|    *dp++ = (uint8_t)((sv3 + svm1 + 1u) >> 2u);
33432|  47.4k|    *dp++ = (uint8_t)((sv3 + svp1 + 2u) >> 2u);
33433|  47.4k|  }
33434|       |
33435|  4.60k|  if (last_column) {
  ------------------
  |  Branch (33435:7): [True: 4.60k, False: 0]
  ------------------
33436|  4.60k|    uint32_t svm1 = sp[-1];
33437|  4.60k|    uint8_t sv = *sp++;
33438|  4.60k|    *dp++ = (uint8_t)(((3u * (uint32_t)sv) + svm1 + 1u) >> 2u);
33439|  4.60k|    *dp++ = sv;
33440|  4.60k|  }
33441|       |
33442|  4.60k|  return dst_ptr;
33443|  4.88k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg_x86_avx2:
32907|  2.27k|    bool last_column) {
32908|  2.27k|  return wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
32909|  2.27k|      dst_ptr, src_ptr_major, src_ptr_minor, src_len, h1v2_bias_ignored,
32910|  2.27k|      first_column, last_column, 7);
32911|  2.27k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2:
35152|  2.27k|    uint8_t odd_column_rounding) {
35153|  2.27k|  uint8_t* dp = dst_ptr;
35154|  2.27k|  const uint8_t* sp_major = src_ptr_major;
35155|  2.27k|  const uint8_t* sp_minor = src_ptr_minor;
35156|  2.27k|  const uint8_t oc = odd_column_rounding;
35157|       |
35158|  2.27k|  if (first_column) {
  ------------------
  |  Branch (35158:7): [True: 2.27k, False: 0]
  ------------------
35159|  2.27k|    src_len--;
35160|  2.27k|    if ((src_len <= 0u) && last_column) {
  ------------------
  |  Branch (35160:9): [True: 178, False: 2.10k]
  |  Branch (35160:28): [True: 178, False: 0]
  ------------------
35161|    178|      uint32_t sv = (12u * ((uint32_t)(*sp_major++))) +  //
35162|    178|                    (4u * ((uint32_t)(*sp_minor++)));
35163|    178|      *dp++ = (uint8_t)((sv + 8u) >> 4u);
35164|    178|      *dp++ = (uint8_t)((sv + oc) >> 4u);
35165|    178|      return dst_ptr;
35166|    178|    }
35167|       |
35168|  2.10k|    uint32_t sv_major_m1 = sp_major[-0];  // Clamp offset to zero.
35169|  2.10k|    uint32_t sv_minor_m1 = sp_minor[-0];  // Clamp offset to zero.
35170|  2.10k|    uint32_t sv_major_p1 = sp_major[+1];
35171|  2.10k|    uint32_t sv_minor_p1 = sp_minor[+1];
35172|       |
35173|  2.10k|    uint32_t sv = (9u * ((uint32_t)(*sp_major++))) +  //
35174|  2.10k|                  (3u * ((uint32_t)(*sp_minor++)));
35175|  2.10k|    *dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
35176|  2.10k|    *dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u);
35177|  2.10k|    if (src_len <= 0u) {
  ------------------
  |  Branch (35177:9): [True: 0, False: 2.10k]
  ------------------
35178|      0|      return dst_ptr;
35179|      0|    }
35180|  2.10k|  }
35181|       |
35182|  2.10k|  if (last_column) {
  ------------------
  |  Branch (35182:7): [True: 2.10k, False: 0]
  ------------------
35183|  2.10k|    src_len--;
35184|  2.10k|  }
35185|       |
35186|  2.10k|  if (src_len < 32) {
  ------------------
  |  Branch (35186:7): [True: 2.10k, False: 0]
  ------------------
35187|       |    // This fallback is the same as the non-SIMD-capable code path.
35188|  28.3k|    for (; src_len > 0u; src_len--) {
  ------------------
  |  Branch (35188:12): [True: 26.2k, False: 2.10k]
  ------------------
35189|  26.2k|      uint32_t sv_major_m1 = sp_major[-1];
35190|  26.2k|      uint32_t sv_minor_m1 = sp_minor[-1];
35191|  26.2k|      uint32_t sv_major_p1 = sp_major[+1];
35192|  26.2k|      uint32_t sv_minor_p1 = sp_minor[+1];
35193|       |
35194|  26.2k|      uint32_t sv = (9u * ((uint32_t)(*sp_major++))) +  //
35195|  26.2k|                    (3u * ((uint32_t)(*sp_minor++)));
35196|  26.2k|      *dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
35197|  26.2k|      *dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u);
35198|  26.2k|    }
35199|       |
35200|  2.10k|  } else {
35201|      0|    while (src_len > 0u) {
  ------------------
  |  Branch (35201:12): [True: 0, False: 0]
  ------------------
35202|       |      // Load 1+32+1 samples (six u8x32 vectors) from the major (jxx) and minor
35203|       |      // (nxx) rows.
35204|       |      //
35205|       |      // major_p0 = [j00 j01 j02 j03 .. j28 j29 j30 j31]   // p0 = "plus  0"
35206|       |      // minor_p0 = [n00 n01 n02 n03 .. n28 n29 n30 n31]   // p0 = "plus  0"
35207|       |      // major_m1 = [jm1 j00 j01 j02 .. j27 j28 j29 j30]   // m1 = "minus 1"
35208|       |      // minor_m1 = [nm1 n00 n01 n02 .. n27 n28 n29 n30]   // m1 = "minus 1"
35209|       |      // major_p1 = [j01 j02 j03 j04 .. j29 j30 j31 j32]   // p1 = "plus  1"
35210|       |      // minor_p1 = [n01 n02 n03 n04 .. n29 n30 n31 n32]   // p1 = "plus  1"
35211|      0|      __m256i major_p0 =
35212|      0|          _mm256_lddqu_si256((const __m256i*)(const void*)(sp_major + 0));
35213|      0|      __m256i minor_p0 =
35214|      0|          _mm256_lddqu_si256((const __m256i*)(const void*)(sp_minor + 0));
35215|      0|      __m256i major_m1 =
35216|      0|          _mm256_lddqu_si256((const __m256i*)(const void*)(sp_major - 1));
35217|      0|      __m256i minor_m1 =
35218|      0|          _mm256_lddqu_si256((const __m256i*)(const void*)(sp_minor - 1));
35219|      0|      __m256i major_p1 =
35220|      0|          _mm256_lddqu_si256((const __m256i*)(const void*)(sp_major + 1));
35221|      0|      __m256i minor_p1 =
35222|      0|          _mm256_lddqu_si256((const __m256i*)(const void*)(sp_minor + 1));
35223|       |
35224|       |      // Unpack, staying with u8x32 vectors.
35225|       |      //
35226|       |      // step1_p0_lo = [j00 n00 j01 n01 .. j07 n07  j16 n16 j17 n17 .. j23 n23]
35227|       |      // step1_p0_hi = [j08 n08 j09 n09 .. j15 n15  j24 n24 j25 n25 .. j31 n31]
35228|       |      // step1_m1_lo = [jm1 nm1 j00 n00 .. j06 n06  j15 n15 j16 n16 .. j22 n22]
35229|       |      // step1_m1_hi = [j07 n07 j08 n08 .. j14 n14  j23 n23 j24 n24 .. j30 n30]
35230|       |      // step1_p1_lo = [j01 n01 j02 n02 .. j08 n08  j17 n17 j18 n18 .. j24 n24]
35231|       |      // step1_p1_hi = [j09 n09 j10 n10 .. j16 n16  j25 n25 j26 n26 .. j32 n32]
35232|      0|      __m256i step1_p0_lo = _mm256_unpacklo_epi8(major_p0, minor_p0);
35233|      0|      __m256i step1_p0_hi = _mm256_unpackhi_epi8(major_p0, minor_p0);
35234|      0|      __m256i step1_m1_lo = _mm256_unpacklo_epi8(major_m1, minor_m1);
35235|      0|      __m256i step1_m1_hi = _mm256_unpackhi_epi8(major_m1, minor_m1);
35236|      0|      __m256i step1_p1_lo = _mm256_unpacklo_epi8(major_p1, minor_p1);
35237|      0|      __m256i step1_p1_hi = _mm256_unpackhi_epi8(major_p1, minor_p1);
35238|       |
35239|       |      // Multiply-add to get u16x16 vectors.
35240|       |      //
35241|       |      // step2_p0_lo = [9*j00+3*n00 9*j01+3*n01 .. 9*j23+3*n23]
35242|       |      // step2_p0_hi = [9*j08+3*n08 9*j09+3*n09 .. 9*j31+3*n31]
35243|       |      // step2_m1_lo = [3*jm1+1*nm1 3*j00+1*n00 .. 3*j22+1*n22]
35244|       |      // step2_m1_hi = [3*j07+1*n07 3*j08+1*n08 .. 3*j30+1*n30]
35245|       |      // step2_p1_lo = [3*j01+1*n01 3*j02+1*n02 .. 3*j24+1*n24]
35246|       |      // step2_p1_hi = [3*j09+1*n09 3*j10+1*n10 .. 3*j32+1*n32]
35247|      0|      const __m256i k0309 = _mm256_set1_epi16(0x0309);
35248|      0|      const __m256i k0103 = _mm256_set1_epi16(0x0103);
35249|      0|      __m256i step2_p0_lo = _mm256_maddubs_epi16(step1_p0_lo, k0309);
35250|      0|      __m256i step2_p0_hi = _mm256_maddubs_epi16(step1_p0_hi, k0309);
35251|      0|      __m256i step2_m1_lo = _mm256_maddubs_epi16(step1_m1_lo, k0103);
35252|      0|      __m256i step2_m1_hi = _mm256_maddubs_epi16(step1_m1_hi, k0103);
35253|      0|      __m256i step2_p1_lo = _mm256_maddubs_epi16(step1_p1_lo, k0103);
35254|      0|      __m256i step2_p1_hi = _mm256_maddubs_epi16(step1_p1_hi, k0103);
35255|       |
35256|       |      // Compute the weighted sums of (p0, m1) and (p0, p1). For example:
35257|       |      //
35258|       |      // step3_m1_lo[00] = ((9*j00) + (3*n00) + (3*jm1) + (1*nm1)) as u16
35259|       |      // step3_p1_hi[15] = ((9*j31) + (3*n31) + (3*j32) + (1*n32)) as u16
35260|      0|      __m256i step3_m1_lo = _mm256_add_epi16(step2_p0_lo, step2_m1_lo);
35261|      0|      __m256i step3_m1_hi = _mm256_add_epi16(step2_p0_hi, step2_m1_hi);
35262|      0|      __m256i step3_p1_lo = _mm256_add_epi16(step2_p0_lo, step2_p1_lo);
35263|      0|      __m256i step3_p1_hi = _mm256_add_epi16(step2_p0_hi, step2_p1_hi);
35264|       |
35265|       |      // Bias by 8 (on the left) or 7 (on the right) and then divide by 16
35266|       |      // (which is 9+3+3+1) to get a weighted average. On the left (m1), shift
35267|       |      // the u16 right value by 4. On the right (p1), shift right by 4 and then
35268|       |      // shift left by 8 so that, when still in the u16x16 little-endian
35269|       |      // interpretation, we have:
35270|       |      //  - m1_element =  (etcetera +  8) >> 4
35271|       |      //  - p1_element = ((etcetera + oc) >> 4) << 8
35272|       |      //
35273|       |      // step4_m1_lo = [0x00?? 0x00?? ... 0x00?? 0x00??]
35274|       |      // step4_p1_lo = [0x??00 0x??00 ... 0x??00 0x??00]
35275|       |      // step4_m1_hi = [0x00?? 0x00?? ... 0x00?? 0x00??]
35276|       |      // step4_p1_hi = [0x??00 0x??00 ... 0x??00 0x??00]
35277|      0|      __m256i step4_m1_lo = _mm256_srli_epi16(
35278|      0|          _mm256_add_epi16(step3_m1_lo, _mm256_set1_epi16(8)), 4);
35279|      0|      __m256i step4_p1_lo = _mm256_slli_epi16(
35280|      0|          _mm256_srli_epi16(
35281|      0|              _mm256_add_epi16(step3_p1_lo, _mm256_set1_epi16(oc)), 4),
35282|      0|          8);
35283|      0|      __m256i step4_m1_hi = _mm256_srli_epi16(
35284|      0|          _mm256_add_epi16(step3_m1_hi, _mm256_set1_epi16(8)), 4);
35285|      0|      __m256i step4_p1_hi = _mm256_slli_epi16(
35286|      0|          _mm256_srli_epi16(
35287|      0|              _mm256_add_epi16(step3_p1_hi, _mm256_set1_epi16(oc)), 4),
35288|      0|          8);
35289|       |
35290|       |      // Bitwise-or two "0x00"-rich u16x16 vectors to get a u8x32 vector. Do
35291|       |      // that twice. Once for the low columns and once for the high columns.
35292|       |      //
35293|       |      // In terms of jxx (major row) or nxx (minor row) source samples:
35294|       |      //  - low  columns means ( 0 ..  8; 16 .. 24).
35295|       |      //  - high columns means ( 8 .. 16; 24 .. 32).
35296|       |      //
35297|       |      // In terms of dxx destination samples (there are twice as many):
35298|       |      //  - low  columns means ( 0 .. 16; 32 .. 48).
35299|       |      //  - high columns means (16 .. 32; 48 .. 64).
35300|       |      //
35301|       |      // step5_lo = [d00 d01 .. d14 d15  d32 d33 .. d46 d47]
35302|       |      // step5_hi = [d16 d17 .. d30 d31  d48 d49 .. d62 d63]
35303|       |      //
35304|       |      // The d00, d02 ... d62 even elements come from (p0, m1) weighted sums.
35305|       |      // The d01, d03 ... d63 odd  elements come from (p0, p1) weighted sums.
35306|      0|      __m256i step5_lo = _mm256_or_si256(step4_m1_lo, step4_p1_lo);
35307|      0|      __m256i step5_hi = _mm256_or_si256(step4_m1_hi, step4_p1_hi);
35308|       |
35309|       |      // Permute and store.
35310|       |      //
35311|       |      // step6_00_31 = [d00 d01 .. d14 d15  d16 d17 .. d30 d31]
35312|       |      // step6_32_63 = [d32 d33 .. d46 d47  d48 d49 .. d62 d63]
35313|      0|      __m256i step6_00_31 = _mm256_permute2x128_si256(step5_lo, step5_hi, 0x20);
35314|      0|      __m256i step6_32_63 = _mm256_permute2x128_si256(step5_lo, step5_hi, 0x31);
35315|      0|      _mm256_storeu_si256((__m256i*)(void*)(dp + 0x00), step6_00_31);
35316|      0|      _mm256_storeu_si256((__m256i*)(void*)(dp + 0x20), step6_32_63);
35317|       |
35318|       |      // Advance by up to 32 source samples (64 destination samples). The first
35319|       |      // iteration might be smaller than 32 so that all of the remaining steps
35320|       |      // are exactly 32.
35321|      0|      size_t n = 32u - (31u & (0u - src_len));
35322|      0|      dp += 2u * n;
35323|      0|      sp_major += n;
35324|      0|      sp_minor += n;
35325|      0|      src_len -= n;
35326|      0|    }
35327|      0|  }
35328|       |
35329|  2.10k|  if (last_column) {
  ------------------
  |  Branch (35329:7): [True: 2.10k, False: 0]
  ------------------
35330|  2.10k|    uint32_t sv_major_m1 = sp_major[-1];
35331|  2.10k|    uint32_t sv_minor_m1 = sp_minor[-1];
35332|  2.10k|    uint32_t sv_major_p1 = sp_major[+0];  // Clamp offset to zero.
35333|  2.10k|    uint32_t sv_minor_p1 = sp_minor[+0];  // Clamp offset to zero.
35334|       |
35335|  2.10k|    uint32_t sv = (9u * ((uint32_t)(*sp_major++))) +  //
35336|  2.10k|                  (3u * ((uint32_t)(*sp_minor++)));
35337|  2.10k|    *dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
35338|  2.10k|    *dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u);
35339|  2.10k|  }
35340|       |
35341|  2.10k|  return dst_ptr;
35342|  2.27k|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_bgrx_x86_avx2:
34727|  4.96k|    const uint8_t* up2) {
34728|  4.96k|  if ((x + 32u) > x_end) {
  ------------------
  |  Branch (34728:7): [True: 4.53k, False: 428]
  ------------------
34729|  4.53k|    wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_bgrx(  //
34730|  4.53k|        dst, x, x_end, y, up0, up1, up2);
34731|  4.53k|    return;
34732|  4.53k|  }
34733|       |
34734|    428|  size_t dst_stride = dst->private_impl.planes[0].stride;
34735|    428|  uint8_t* dst_iter = dst->private_impl.planes[0].ptr +
34736|    428|                      (dst_stride * ((size_t)y)) + (4u * ((size_t)x));
34737|       |
34738|       |  // u0001 = u16x16 [0x0001 .. 0x0001]
34739|       |  // u00FF = u16x16 [0x00FF .. 0x00FF]
34740|       |  // uFF80 = u16x16 [0xFF80 .. 0xFF80]
34741|       |  // uFFFF = u16x16 [0xFFFF .. 0xFFFF]
34742|    428|  const __m256i u0001 = _mm256_set1_epi16(+0x0001);
34743|    428|  const __m256i u00FF = _mm256_set1_epi16(+0x00FF);
34744|    428|  const __m256i uFF80 = _mm256_set1_epi16(-0x0080);
34745|    428|  const __m256i uFFFF = _mm256_set1_epi16(-0x0001);
34746|       |
34747|       |  // p8000_p0000 = u16x16 [0x8000 0x0000 .. 0x8000 0x0000]
34748|    428|  const __m256i p8000_p0000 = _mm256_set_epi16(  //
34749|    428|      +0x0000, -0x8000, +0x0000, -0x8000,        //
34750|    428|      +0x0000, -0x8000, +0x0000, -0x8000,        //
34751|    428|      +0x0000, -0x8000, +0x0000, -0x8000,        //
34752|    428|      +0x0000, -0x8000, +0x0000, -0x8000);
34753|       |
34754|       |  // Per wuffs_base__color_ycc_bt601fr__as__color_u32, the formulae:
34755|       |  //
34756|       |  //  R = Y                + 1.40200 * Cr
34757|       |  //  G = Y - 0.34414 * Cb - 0.71414 * Cr
34758|       |  //  B = Y + 1.77200 * Cb
34759|       |  //
34760|       |  // When scaled by 1<<16:
34761|       |  //
34762|       |  //  0.34414 becomes 0x0581A =  22554.
34763|       |  //  0.71414 becomes 0x0B6D2 =  46802.
34764|       |  //  1.40200 becomes 0x166E9 =  91881.
34765|       |  //  1.77200 becomes 0x1C5A2 = 116130.
34766|       |  //
34767|       |  // Separate the integer and fractional parts, since we work with signed
34768|       |  // 16-bit SIMD lanes. The fractional parts range from -0.5 .. +0.5 (as
34769|       |  // floating-point) which is from -0x8000 .. +0x8000 (as fixed-point).
34770|       |  //
34771|       |  //  -0x3A5E = -0x20000 + 0x1C5A2     The B:Cb factor.
34772|       |  //  +0x66E9 = -0x10000 + 0x166E9     The R:Cr factor.
34773|       |  //  -0x581A = +0x00000 - 0x0581A     The G:Cb factor.
34774|       |  //  +0x492E = +0x10000 - 0x0B6D2     The G:Cr factor.
34775|    428|  const __m256i m3A5E = _mm256_set1_epi16(-0x3A5E);
34776|    428|  const __m256i p66E9 = _mm256_set1_epi16(+0x66E9);
34777|    428|  const __m256i m581A_p492E = _mm256_set_epi16(  //
34778|    428|      +0x492E, -0x581A, +0x492E, -0x581A,        //
34779|    428|      +0x492E, -0x581A, +0x492E, -0x581A,        //
34780|    428|      +0x492E, -0x581A, +0x492E, -0x581A,        //
34781|    428|      +0x492E, -0x581A, +0x492E, -0x581A);
34782|       |
34783|  1.19k|  while (x < x_end) {
  ------------------
  |  Branch (34783:10): [True: 762, False: 428]
  ------------------
34784|       |    // Load chroma values in even and odd columns (the high 8 bits of each
34785|       |    // u16x16 element are zero) and then subtract 0x0080.
34786|       |    //
34787|       |    // cb_all = u8x32  [cb.00 cb.01 cb.02 cb.03 .. cb.1C cb.1D cb.1E cb.1F]
34788|       |    // cb_eve = i16x16 [cb.00-0x80  cb.02-0x80  .. cb.1C-0x80  cb.1E-0x80 ]
34789|       |    // cb_odd = i16x16 [cb.01-0x80  cb.03-0x80  .. cb.1D-0x80  cb.1F-0x80 ]
34790|       |    //
34791|       |    // Ditto for the cr_xxx Chroma-Red values.
34792|    762|    __m256i cb_all = _mm256_lddqu_si256((const __m256i*)(const void*)up1);
34793|    762|    __m256i cr_all = _mm256_lddqu_si256((const __m256i*)(const void*)up2);
34794|    762|    __m256i cb_eve = _mm256_add_epi16(uFF80, _mm256_and_si256(cb_all, u00FF));
34795|    762|    __m256i cr_eve = _mm256_add_epi16(uFF80, _mm256_and_si256(cr_all, u00FF));
34796|    762|    __m256i cb_odd = _mm256_add_epi16(uFF80, _mm256_srli_epi16(cb_all, 8));
34797|    762|    __m256i cr_odd = _mm256_add_epi16(uFF80, _mm256_srli_epi16(cr_all, 8));
34798|       |
34799|       |    // ----
34800|       |
34801|       |    // Calculate:
34802|       |    //
34803|       |    //  B-Y = (+1.77200 * Cb)                 as floating-point
34804|       |    //  R-Y = (+1.40200 * Cr)                 as floating-point
34805|       |    //
34806|       |    //  B-Y = ((0x2_0000 - 0x3A5E) * Cb)      as fixed-point
34807|       |    //  R-Y = ((0x1_0000 + 0x66E9) * Cr)      as fixed-point
34808|       |    //
34809|       |    //  B-Y = ((-0x3A5E * Cb) + ("2.0" * Cb))
34810|       |    //  R-Y = ((+0x66E9 * Cr) + ("1.0" * Cr))
34811|       |
34812|       |    // Multiply by m3A5E or p66E9, taking the high 16 bits. There's also a
34813|       |    // doubling (add x to itself), adding-of-1 and halving (shift right by 1).
34814|       |    // That makes multiply-and-take-high round to nearest (instead of down).
34815|    762|    __m256i tmp_by_eve = _mm256_srai_epi16(
34816|    762|        _mm256_add_epi16(
34817|    762|            _mm256_mulhi_epi16(_mm256_add_epi16(cb_eve, cb_eve), m3A5E), u0001),
34818|    762|        1);
34819|    762|    __m256i tmp_by_odd = _mm256_srai_epi16(
34820|    762|        _mm256_add_epi16(
34821|    762|            _mm256_mulhi_epi16(_mm256_add_epi16(cb_odd, cb_odd), m3A5E), u0001),
34822|    762|        1);
34823|    762|    __m256i tmp_ry_eve = _mm256_srai_epi16(
34824|    762|        _mm256_add_epi16(
34825|    762|            _mm256_mulhi_epi16(_mm256_add_epi16(cr_eve, cr_eve), p66E9), u0001),
34826|    762|        1);
34827|    762|    __m256i tmp_ry_odd = _mm256_srai_epi16(
34828|    762|        _mm256_add_epi16(
34829|    762|            _mm256_mulhi_epi16(_mm256_add_epi16(cr_odd, cr_odd), p66E9), u0001),
34830|    762|        1);
34831|       |
34832|       |    // Add (2 * Cb) and (1 * Cr).
34833|    762|    __m256i by_eve =
34834|    762|        _mm256_add_epi16(tmp_by_eve, _mm256_add_epi16(cb_eve, cb_eve));
34835|    762|    __m256i by_odd =
34836|    762|        _mm256_add_epi16(tmp_by_odd, _mm256_add_epi16(cb_odd, cb_odd));
34837|    762|    __m256i ry_eve = _mm256_add_epi16(tmp_ry_eve, cr_eve);
34838|    762|    __m256i ry_odd = _mm256_add_epi16(tmp_ry_odd, cr_odd);
34839|       |
34840|       |    // ----
34841|       |
34842|       |    // Calculate:
34843|       |    //
34844|       |    //  G-Y = (-0.34414 * Cb) +
34845|       |    //        (-0.71414 * Cr)                 as floating-point
34846|       |    //
34847|       |    //  G-Y = ((+0x0_0000 - 0x581A) * Cb) +
34848|       |    //        ((-0x1_0000 + 0x492E) * Cr)     as fixed-point
34849|       |    //
34850|       |    //  G-Y =  (-0x581A * Cb) +
34851|       |    //         (+0x492E * Cr) - ("1.0" * Cr)
34852|       |
34853|       |    // Multiply-add to get ((-0x581A * Cb) + (+0x492E * Cr)).
34854|    762|    __m256i tmp0_gy_eve_lo = _mm256_madd_epi16(  //
34855|    762|        _mm256_unpacklo_epi16(cb_eve, cr_eve), m581A_p492E);
34856|    762|    __m256i tmp0_gy_eve_hi = _mm256_madd_epi16(  //
34857|    762|        _mm256_unpackhi_epi16(cb_eve, cr_eve), m581A_p492E);
34858|    762|    __m256i tmp0_gy_odd_lo = _mm256_madd_epi16(  //
34859|    762|        _mm256_unpacklo_epi16(cb_odd, cr_odd), m581A_p492E);
34860|    762|    __m256i tmp0_gy_odd_hi = _mm256_madd_epi16(  //
34861|    762|        _mm256_unpackhi_epi16(cb_odd, cr_odd), m581A_p492E);
34862|       |
34863|       |    // Divide the i32x8 vectors by (1 << 16), rounding to nearest.
34864|    762|    __m256i tmp1_gy_eve_lo =
34865|    762|        _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_eve_lo, p8000_p0000), 16);
34866|    762|    __m256i tmp1_gy_eve_hi =
34867|    762|        _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_eve_hi, p8000_p0000), 16);
34868|    762|    __m256i tmp1_gy_odd_lo =
34869|    762|        _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_odd_lo, p8000_p0000), 16);
34870|    762|    __m256i tmp1_gy_odd_hi =
34871|    762|        _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_odd_hi, p8000_p0000), 16);
34872|       |
34873|       |    // Pack the ((-0x581A * Cb) + (+0x492E * Cr)) as i16x16 and subtract Cr.
34874|    762|    __m256i gy_eve = _mm256_sub_epi16(
34875|    762|        _mm256_packs_epi32(tmp1_gy_eve_lo, tmp1_gy_eve_hi), cr_eve);
34876|    762|    __m256i gy_odd = _mm256_sub_epi16(
34877|    762|        _mm256_packs_epi32(tmp1_gy_odd_lo, tmp1_gy_odd_hi), cr_odd);
34878|       |
34879|       |    // ----
34880|       |
34881|       |    // Add Y to (B-Y), (G-Y) and (R-Y) to produce B, G and R.
34882|       |    //
34883|       |    // For the resultant packed_x_xxx vectors, only elements 0 ..= 7 and 16 ..=
34884|       |    // 23 of the 32-element vectors matter (since we'll unpacklo but not
34885|       |    // unpackhi them). Let … denote 8 ignored consecutive u8 values and let %
34886|       |    // denote 0xFF. We'll end this section with:
34887|       |    //
34888|       |    // packed_b_eve = u8x32 [b00 b02 .. b0C b0E  …  b10 b12 .. b1C b1E  …]
34889|       |    // packed_b_odd = u8x32 [b01 b03 .. b0D b0F  …  b11 b13 .. b1D b1F  …]
34890|       |    // packed_g_eve = u8x32 [g00 g02 .. g0C g0E  …  g10 g12 .. g1C g1E  …]
34891|       |    // packed_g_odd = u8x32 [g01 g03 .. g0D g0F  …  g11 g13 .. g1D g1F  …]
34892|       |    // packed_r_eve = u8x32 [r00 r02 .. r0C r0E  …  r10 r12 .. r1C r1E  …]
34893|       |    // packed_r_odd = u8x32 [r01 r03 .. r0D r0F  …  r11 r13 .. r1D r1F  …]
34894|       |    // uFFFF        = u8x32 [  %   % ..   %   %  …    %   % ..   %   %  …]
34895|       |
34896|    762|    __m256i yy_all = _mm256_lddqu_si256((const __m256i*)(const void*)up0);
34897|    762|    __m256i yy_eve = _mm256_and_si256(yy_all, u00FF);
34898|    762|    __m256i yy_odd = _mm256_srli_epi16(yy_all, 8);
34899|       |
34900|    762|    __m256i loose_b_eve = _mm256_add_epi16(by_eve, yy_eve);
34901|    762|    __m256i loose_b_odd = _mm256_add_epi16(by_odd, yy_odd);
34902|    762|    __m256i packed_b_eve = _mm256_packus_epi16(loose_b_eve, loose_b_eve);
34903|    762|    __m256i packed_b_odd = _mm256_packus_epi16(loose_b_odd, loose_b_odd);
34904|       |
34905|    762|    __m256i loose_g_eve = _mm256_add_epi16(gy_eve, yy_eve);
34906|    762|    __m256i loose_g_odd = _mm256_add_epi16(gy_odd, yy_odd);
34907|    762|    __m256i packed_g_eve = _mm256_packus_epi16(loose_g_eve, loose_g_eve);
34908|    762|    __m256i packed_g_odd = _mm256_packus_epi16(loose_g_odd, loose_g_odd);
34909|       |
34910|    762|    __m256i loose_r_eve = _mm256_add_epi16(ry_eve, yy_eve);
34911|    762|    __m256i loose_r_odd = _mm256_add_epi16(ry_odd, yy_odd);
34912|    762|    __m256i packed_r_eve = _mm256_packus_epi16(loose_r_eve, loose_r_eve);
34913|    762|    __m256i packed_r_odd = _mm256_packus_epi16(loose_r_odd, loose_r_odd);
34914|       |
34915|       |    // ----
34916|       |
34917|       |    // Mix those values (unpacking in 8, 16 and then 32 bit units) to get the
34918|       |    // desired BGRX/RGBX order.
34919|       |    //
34920|       |    // From here onwards, all of our __m256i registers are u8x32.
34921|       |
34922|       |    // mix00 = [b00 g00 b02 g02 .. b0E g0E b10 g10 .. b1C g1C b1E g1E]
34923|       |    // mix01 = [b01 g01 b03 g03 .. b0F g0F b11 g11 .. b1D g1D b1F g1F]
34924|       |    // mix02 = [r00   % r02   % .. r0E   % r10   % .. r1C   % r1E   %]
34925|       |    // mix03 = [r01   % r03   % .. r0F   % r11   % .. r1D   % r1F   %]
34926|       |    //
34927|       |    // See also § below.
34928|    762|    __m256i mix00 = _mm256_unpacklo_epi8(packed_b_eve, packed_g_eve);
34929|    762|    __m256i mix01 = _mm256_unpacklo_epi8(packed_b_odd, packed_g_odd);
34930|    762|    __m256i mix02 = _mm256_unpacklo_epi8(packed_r_eve, uFFFF);
34931|    762|    __m256i mix03 = _mm256_unpacklo_epi8(packed_r_odd, uFFFF);
34932|       |
34933|       |    // mix10 = [b00 g00 r00 %  b02 g02 r02 %  b04 g04 r04 %  b06 g06 r06 %
34934|       |    //          b10 g10 r10 %  b12 g12 r12 %  b14 g14 r14 %  b16 g16 r16 %]
34935|       |    // mix11 = [b01 g01 r01 %  b03 g03 r03 %  b05 g05 r05 %  b07 g07 r07 %
34936|       |    //          b11 g11 r11 %  b13 g13 r13 %  b15 g15 r15 %  b17 g17 r17 %]
34937|       |    // mix12 = [b08 g08 r08 %  b0A g0A r0A %  b0C g0C r0C %  b0E g0E r0E %
34938|       |    //          b18 g18 r18 %  b1A g1A r1A %  b1C g1C r1C %  b1E g1E r1E %]
34939|       |    // mix13 = [b09 g09 r09 %  b0B g0B r0B %  b0D g0D r0D %  b0F g0F r0F %
34940|       |    //          b19 g19 r19 %  b1B g1B r1B %  b1D g1D r1D %  b1F g1F r1F %]
34941|    762|    __m256i mix10 = _mm256_unpacklo_epi16(mix00, mix02);
34942|    762|    __m256i mix11 = _mm256_unpacklo_epi16(mix01, mix03);
34943|    762|    __m256i mix12 = _mm256_unpackhi_epi16(mix00, mix02);
34944|    762|    __m256i mix13 = _mm256_unpackhi_epi16(mix01, mix03);
34945|       |
34946|       |    // mix20 = [b00 g00 r00 %  b01 g01 r01 %  b02 g02 r02 %  b03 g03 r03 %
34947|       |    //          b10 g10 r10 %  b11 g11 r11 %  b12 g12 r12 %  b13 g13 r13 %]
34948|       |    // mix21 = [b04 g04 r04 %  b05 g05 r05 %  b06 g06 r06 %  b07 g07 r07 %
34949|       |    //          b14 g14 r14 %  b15 g15 r15 %  b16 g16 r16 %  b17 g17 r17 %]
34950|       |    // mix22 = [b08 g08 r08 %  b09 g09 r09 %  b0A g0A r0A %  b0B g0B r0B %
34951|       |    //          b18 g18 r18 %  b19 g19 r19 %  b1A g1A r1A %  b1B g1B r1B %]
34952|       |    // mix23 = [b0C g0C r0C %  b0D g0D r0D %  b0E g0E r0E %  b0F g0F r0F %
34953|       |    //          b1C g1C r1C %  b1D g1D r1D %  b1E g1E r1E %  b1F g1F r1F %]
34954|    762|    __m256i mix20 = _mm256_unpacklo_epi32(mix10, mix11);
34955|    762|    __m256i mix21 = _mm256_unpackhi_epi32(mix10, mix11);
34956|    762|    __m256i mix22 = _mm256_unpacklo_epi32(mix12, mix13);
34957|    762|    __m256i mix23 = _mm256_unpackhi_epi32(mix12, mix13);
34958|       |
34959|       |    // mix30 = [b00 g00 r00 %  b01 g01 r01 %  b02 g02 r02 %  b03 g03 r03 %
34960|       |    //          b04 g04 r04 %  b05 g05 r05 %  b06 g06 r06 %  b07 g07 r07 %]
34961|       |    // mix31 = [b08 g08 r08 %  b09 g09 r09 %  b0A g0A r0A %  b0B g0B r0B %
34962|       |    //          b0C g0C r0C %  b0D g0D r0D %  b0E g0E r0E %  b0F g0F r0F %]
34963|       |    // mix32 = [b10 g10 r10 %  b11 g11 r11 %  b12 g12 r12 %  b13 g13 r13 %
34964|       |    //          b14 g14 r14 %  b15 g15 r15 %  b16 g16 r16 %  b17 g17 r17 %]
34965|       |    // mix33 = [b18 g18 r18 %  b19 g19 r19 %  b1A g1A r1A %  b1B g1B r1B %
34966|       |    //          b1C g1C r1C %  b1D g1D r1D %  b1E g1E r1E %  b1F g1F r1F %]
34967|    762|    __m256i mix30 = _mm256_permute2x128_si256(mix20, mix21, 0x20);
34968|    762|    __m256i mix31 = _mm256_permute2x128_si256(mix22, mix23, 0x20);
34969|    762|    __m256i mix32 = _mm256_permute2x128_si256(mix20, mix21, 0x31);
34970|    762|    __m256i mix33 = _mm256_permute2x128_si256(mix22, mix23, 0x31);
34971|       |
34972|       |    // Write out four u8x32 SIMD registers (128 bytes, 32 BGRX/RGBX pixels).
34973|    762|    _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x00), mix30);
34974|    762|    _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x20), mix31);
34975|    762|    _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x40), mix32);
34976|    762|    _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x60), mix33);
34977|       |
34978|       |    // Advance by up to 32 pixels. The first iteration might be smaller than 32
34979|       |    // so that all of the remaining steps are exactly 32.
34980|    762|    uint32_t n = 32u - (31u & (x - x_end));
34981|    762|    dst_iter += 4u * n;
34982|    762|    up0 += n;
34983|    762|    up1 += n;
34984|    762|    up2 += n;
34985|    762|    x += n;
34986|    762|  }
34987|    428|}
pixel_swizzler_fuzzer.c:wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_rgbx_x86_avx2:
35000|  5.09k|    const uint8_t* up2) {
35001|  5.09k|  if ((x + 32u) > x_end) {
  ------------------
  |  Branch (35001:7): [True: 4.49k, False: 598]
  ------------------
35002|  4.49k|    wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_rgbx(  //
35003|  4.49k|        dst, x, x_end, y, up0, up1, up2);
35004|  4.49k|    return;
35005|  4.49k|  }
35006|       |
35007|    598|  size_t dst_stride = dst->private_impl.planes[0].stride;
35008|    598|  uint8_t* dst_iter = dst->private_impl.planes[0].ptr +
35009|    598|                      (dst_stride * ((size_t)y)) + (4u * ((size_t)x));
35010|       |
35011|    598|  const __m256i u0001 = _mm256_set1_epi16(+0x0001);
35012|    598|  const __m256i u00FF = _mm256_set1_epi16(+0x00FF);
35013|    598|  const __m256i uFF80 = _mm256_set1_epi16(-0x0080);
35014|    598|  const __m256i uFFFF = _mm256_set1_epi16(-0x0001);
35015|       |
35016|    598|  const __m256i p8000_p0000 = _mm256_set_epi16(  //
35017|    598|      +0x0000, -0x8000, +0x0000, -0x8000,        //
35018|    598|      +0x0000, -0x8000, +0x0000, -0x8000,        //
35019|    598|      +0x0000, -0x8000, +0x0000, -0x8000,        //
35020|    598|      +0x0000, -0x8000, +0x0000, -0x8000);
35021|       |
35022|    598|  const __m256i m3A5E = _mm256_set1_epi16(-0x3A5E);
35023|    598|  const __m256i p66E9 = _mm256_set1_epi16(+0x66E9);
35024|    598|  const __m256i m581A_p492E = _mm256_set_epi16(  //
35025|    598|      +0x492E, -0x581A, +0x492E, -0x581A,        //
35026|    598|      +0x492E, -0x581A, +0x492E, -0x581A,        //
35027|    598|      +0x492E, -0x581A, +0x492E, -0x581A,        //
35028|    598|      +0x492E, -0x581A, +0x492E, -0x581A);
35029|       |
35030|  1.73k|  while (x < x_end) {
  ------------------
  |  Branch (35030:10): [True: 1.13k, False: 598]
  ------------------
35031|  1.13k|    __m256i cb_all = _mm256_lddqu_si256((const __m256i*)(const void*)up1);
35032|  1.13k|    __m256i cr_all = _mm256_lddqu_si256((const __m256i*)(const void*)up2);
35033|  1.13k|    __m256i cb_eve = _mm256_add_epi16(uFF80, _mm256_and_si256(cb_all, u00FF));
35034|  1.13k|    __m256i cr_eve = _mm256_add_epi16(uFF80, _mm256_and_si256(cr_all, u00FF));
35035|  1.13k|    __m256i cb_odd = _mm256_add_epi16(uFF80, _mm256_srli_epi16(cb_all, 8));
35036|  1.13k|    __m256i cr_odd = _mm256_add_epi16(uFF80, _mm256_srli_epi16(cr_all, 8));
35037|       |
35038|  1.13k|    __m256i tmp_by_eve = _mm256_srai_epi16(
35039|  1.13k|        _mm256_add_epi16(
35040|  1.13k|            _mm256_mulhi_epi16(_mm256_add_epi16(cb_eve, cb_eve), m3A5E), u0001),
35041|  1.13k|        1);
35042|  1.13k|    __m256i tmp_by_odd = _mm256_srai_epi16(
35043|  1.13k|        _mm256_add_epi16(
35044|  1.13k|            _mm256_mulhi_epi16(_mm256_add_epi16(cb_odd, cb_odd), m3A5E), u0001),
35045|  1.13k|        1);
35046|  1.13k|    __m256i tmp_ry_eve = _mm256_srai_epi16(
35047|  1.13k|        _mm256_add_epi16(
35048|  1.13k|            _mm256_mulhi_epi16(_mm256_add_epi16(cr_eve, cr_eve), p66E9), u0001),
35049|  1.13k|        1);
35050|  1.13k|    __m256i tmp_ry_odd = _mm256_srai_epi16(
35051|  1.13k|        _mm256_add_epi16(
35052|  1.13k|            _mm256_mulhi_epi16(_mm256_add_epi16(cr_odd, cr_odd), p66E9), u0001),
35053|  1.13k|        1);
35054|       |
35055|  1.13k|    __m256i by_eve =
35056|  1.13k|        _mm256_add_epi16(tmp_by_eve, _mm256_add_epi16(cb_eve, cb_eve));
35057|  1.13k|    __m256i by_odd =
35058|  1.13k|        _mm256_add_epi16(tmp_by_odd, _mm256_add_epi16(cb_odd, cb_odd));
35059|  1.13k|    __m256i ry_eve = _mm256_add_epi16(tmp_ry_eve, cr_eve);
35060|  1.13k|    __m256i ry_odd = _mm256_add_epi16(tmp_ry_odd, cr_odd);
35061|       |
35062|  1.13k|    __m256i tmp0_gy_eve_lo = _mm256_madd_epi16(  //
35063|  1.13k|        _mm256_unpacklo_epi16(cb_eve, cr_eve), m581A_p492E);
35064|  1.13k|    __m256i tmp0_gy_eve_hi = _mm256_madd_epi16(  //
35065|  1.13k|        _mm256_unpackhi_epi16(cb_eve, cr_eve), m581A_p492E);
35066|  1.13k|    __m256i tmp0_gy_odd_lo = _mm256_madd_epi16(  //
35067|  1.13k|        _mm256_unpacklo_epi16(cb_odd, cr_odd), m581A_p492E);
35068|  1.13k|    __m256i tmp0_gy_odd_hi = _mm256_madd_epi16(  //
35069|  1.13k|        _mm256_unpackhi_epi16(cb_odd, cr_odd), m581A_p492E);
35070|       |
35071|  1.13k|    __m256i tmp1_gy_eve_lo =
35072|  1.13k|        _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_eve_lo, p8000_p0000), 16);
35073|  1.13k|    __m256i tmp1_gy_eve_hi =
35074|  1.13k|        _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_eve_hi, p8000_p0000), 16);
35075|  1.13k|    __m256i tmp1_gy_odd_lo =
35076|  1.13k|        _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_odd_lo, p8000_p0000), 16);
35077|  1.13k|    __m256i tmp1_gy_odd_hi =
35078|  1.13k|        _mm256_srai_epi32(_mm256_add_epi32(tmp0_gy_odd_hi, p8000_p0000), 16);
35079|       |
35080|  1.13k|    __m256i gy_eve = _mm256_sub_epi16(
35081|  1.13k|        _mm256_packs_epi32(tmp1_gy_eve_lo, tmp1_gy_eve_hi), cr_eve);
35082|  1.13k|    __m256i gy_odd = _mm256_sub_epi16(
35083|  1.13k|        _mm256_packs_epi32(tmp1_gy_odd_lo, tmp1_gy_odd_hi), cr_odd);
35084|       |
35085|  1.13k|    __m256i yy_all = _mm256_lddqu_si256((const __m256i*)(const void*)up0);
35086|  1.13k|    __m256i yy_eve = _mm256_and_si256(yy_all, u00FF);
35087|  1.13k|    __m256i yy_odd = _mm256_srli_epi16(yy_all, 8);
35088|       |
35089|  1.13k|    __m256i loose_b_eve = _mm256_add_epi16(by_eve, yy_eve);
35090|  1.13k|    __m256i loose_b_odd = _mm256_add_epi16(by_odd, yy_odd);
35091|  1.13k|    __m256i packed_b_eve = _mm256_packus_epi16(loose_b_eve, loose_b_eve);
35092|  1.13k|    __m256i packed_b_odd = _mm256_packus_epi16(loose_b_odd, loose_b_odd);
35093|       |
35094|  1.13k|    __m256i loose_g_eve = _mm256_add_epi16(gy_eve, yy_eve);
35095|  1.13k|    __m256i loose_g_odd = _mm256_add_epi16(gy_odd, yy_odd);
35096|  1.13k|    __m256i packed_g_eve = _mm256_packus_epi16(loose_g_eve, loose_g_eve);
35097|  1.13k|    __m256i packed_g_odd = _mm256_packus_epi16(loose_g_odd, loose_g_odd);
35098|       |
35099|  1.13k|    __m256i loose_r_eve = _mm256_add_epi16(ry_eve, yy_eve);
35100|  1.13k|    __m256i loose_r_odd = _mm256_add_epi16(ry_odd, yy_odd);
35101|  1.13k|    __m256i packed_r_eve = _mm256_packus_epi16(loose_r_eve, loose_r_eve);
35102|  1.13k|    __m256i packed_r_odd = _mm256_packus_epi16(loose_r_odd, loose_r_odd);
35103|       |
35104|       |    // § Note the swapped B and R channels.
35105|  1.13k|    __m256i mix00 = _mm256_unpacklo_epi8(packed_r_eve, packed_g_eve);
35106|  1.13k|    __m256i mix01 = _mm256_unpacklo_epi8(packed_r_odd, packed_g_odd);
35107|  1.13k|    __m256i mix02 = _mm256_unpacklo_epi8(packed_b_eve, uFFFF);
35108|  1.13k|    __m256i mix03 = _mm256_unpacklo_epi8(packed_b_odd, uFFFF);
35109|       |
35110|  1.13k|    __m256i mix10 = _mm256_unpacklo_epi16(mix00, mix02);
35111|  1.13k|    __m256i mix11 = _mm256_unpacklo_epi16(mix01, mix03);
35112|  1.13k|    __m256i mix12 = _mm256_unpackhi_epi16(mix00, mix02);
35113|  1.13k|    __m256i mix13 = _mm256_unpackhi_epi16(mix01, mix03);
35114|       |
35115|  1.13k|    __m256i mix20 = _mm256_unpacklo_epi32(mix10, mix11);
35116|  1.13k|    __m256i mix21 = _mm256_unpackhi_epi32(mix10, mix11);
35117|  1.13k|    __m256i mix22 = _mm256_unpacklo_epi32(mix12, mix13);
35118|  1.13k|    __m256i mix23 = _mm256_unpackhi_epi32(mix12, mix13);
35119|       |
35120|  1.13k|    __m256i mix30 = _mm256_permute2x128_si256(mix20, mix21, 0x20);
35121|  1.13k|    __m256i mix31 = _mm256_permute2x128_si256(mix22, mix23, 0x20);
35122|  1.13k|    __m256i mix32 = _mm256_permute2x128_si256(mix20, mix21, 0x31);
35123|  1.13k|    __m256i mix33 = _mm256_permute2x128_si256(mix22, mix23, 0x31);
35124|       |
35125|  1.13k|    _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x00), mix30);
35126|  1.13k|    _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x20), mix31);
35127|  1.13k|    _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x40), mix32);
35128|  1.13k|    _mm256_storeu_si256((__m256i*)(void*)(dst_iter + 0x60), mix33);
35129|       |
35130|  1.13k|    uint32_t n = 32u - (31u & (x - x_end));
35131|  1.13k|    dst_iter += 4u * n;
35132|  1.13k|    up0 += n;
35133|  1.13k|    up1 += n;
35134|  1.13k|    up2 += n;
35135|  1.13k|    x += n;
35136|  1.13k|  }
35137|    598|}
pixel_swizzler_fuzzer.c:wuffs_base__ptr_u8__reader:
 3456|  3.50k|wuffs_base__ptr_u8__reader(uint8_t* ptr, size_t len, bool closed) {
 3457|  3.50k|  wuffs_base__io_buffer ret;
 3458|  3.50k|  ret.data.ptr = ptr;
 3459|  3.50k|  ret.data.len = len;
 3460|  3.50k|  ret.meta.wi = len;
 3461|  3.50k|  ret.meta.ri = 0;
 3462|  3.50k|  ret.meta.pos = 0;
 3463|  3.50k|  ret.meta.closed = closed;
 3464|  3.50k|  return ret;
 3465|  3.50k|}
pixel_swizzler_fuzzer.c:wuffs_base__make_pixel_format:
 4928|  10.5k|wuffs_base__make_pixel_format(uint32_t repr) {
 4929|  10.5k|  wuffs_base__pixel_format f;
 4930|  10.5k|  f.repr = repr;
 4931|  10.5k|  return f;
 4932|  10.5k|}
pixel_swizzler_fuzzer.c:wuffs_base__status__message:
  674|  2.07k|wuffs_base__status__message(const wuffs_base__status* z) {
  675|  2.07k|  if (z->repr) {
  ------------------
  |  Branch (675:7): [True: 2.07k, False: 0]
  ------------------
  676|  2.07k|    if ((*z->repr == '$') || (*z->repr == '#') || (*z->repr == '@')) {
  ------------------
  |  Branch (676:9): [True: 0, False: 2.07k]
  |  Branch (676:30): [True: 2.07k, False: 0]
  |  Branch (676:51): [True: 0, False: 0]
  ------------------
  677|  2.07k|      return z->repr + 1;
  678|  2.07k|    }
  679|  2.07k|  }
  680|      0|  return z->repr;
  681|  2.07k|}
pixel_swizzler_fuzzer.c:wuffs_base__u32__max:
 1062|  42.1k|wuffs_base__u32__max(uint32_t x, uint32_t y) {
 1063|  42.1k|  return x > y ? x : y;
  ------------------
  |  Branch (1063:10): [True: 16.6k, False: 25.4k]
  ------------------
 1064|  42.1k|}
pixel_swizzler_fuzzer.c:wuffs_base__pixel_config__set:
 5307|  3.50k|                              uint32_t height) {
 5308|  3.50k|  if (!c) {
  ------------------
  |  Branch (5308:7): [True: 0, False: 3.50k]
  ------------------
 5309|      0|    return;
 5310|      0|  }
 5311|  3.50k|  if (pixfmt_repr) {
  ------------------
  |  Branch (5311:7): [True: 3.50k, False: 0]
  ------------------
 5312|  3.50k|    do {
 5313|       |#if SIZE_MAX < 0xFFFFFFFFFFFFFFFFull
 5314|       |      uint64_t wh = ((uint64_t)width) * ((uint64_t)height);
 5315|       |      // TODO: handle things other than 1 byte per pixel.
 5316|       |      if (wh > ((uint64_t)SIZE_MAX)) {
 5317|       |        break;
 5318|       |      }
 5319|       |#endif
 5320|  3.50k|      c->private_impl.pixfmt.repr = pixfmt_repr;
 5321|  3.50k|      c->private_impl.pixsub.repr = pixsub_repr;
 5322|  3.50k|      c->private_impl.width = width;
 5323|  3.50k|      c->private_impl.height = height;
 5324|  3.50k|      return;
 5325|  3.50k|    } while (0);
  ------------------
  |  Branch (5325:14): [Folded, False: 0]
  ------------------
 5326|  3.50k|  }
 5327|       |
 5328|      0|  c->private_impl.pixfmt.repr = 0;
 5329|      0|  c->private_impl.pixsub.repr = 0;
 5330|      0|  c->private_impl.width = 0;
 5331|      0|  c->private_impl.height = 0;
 5332|      0|}
pixel_swizzler_fuzzer.c:wuffs_base__pixel_config__pixbuf_len:
 5392|  3.50k|wuffs_base__pixel_config__pixbuf_len(const wuffs_base__pixel_config* c) {
 5393|  3.50k|  if (!c) {
  ------------------
  |  Branch (5393:7): [True: 0, False: 3.50k]
  ------------------
 5394|      0|    return 0;
 5395|      0|  }
 5396|  3.50k|  if (wuffs_base__pixel_format__is_planar(&c->private_impl.pixfmt)) {
  ------------------
  |  Branch (5396:7): [True: 0, False: 3.50k]
  ------------------
 5397|       |    // TODO: support planar pixel formats, concious of pixel subsampling.
 5398|      0|    return 0;
 5399|      0|  }
 5400|  3.50k|  uint32_t bits_per_pixel =
 5401|  3.50k|      wuffs_base__pixel_format__bits_per_pixel(&c->private_impl.pixfmt);
 5402|  3.50k|  if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {
  ------------------
  |  Branch (5402:7): [True: 0, False: 3.50k]
  |  Branch (5402:32): [True: 0, False: 3.50k]
  ------------------
 5403|       |    // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?
 5404|      0|    return 0;
 5405|      0|  }
 5406|  3.50k|  uint64_t bytes_per_pixel = bits_per_pixel / 8;
 5407|       |
 5408|  3.50k|  uint64_t n =
 5409|  3.50k|      ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);
 5410|  3.50k|  if (n > (UINT64_MAX / bytes_per_pixel)) {
  ------------------
  |  Branch (5410:7): [True: 0, False: 3.50k]
  ------------------
 5411|      0|    return 0;
 5412|      0|  }
 5413|  3.50k|  n *= bytes_per_pixel;
 5414|       |
 5415|  3.50k|  if (wuffs_base__pixel_format__is_indexed(&c->private_impl.pixfmt)) {
  ------------------
  |  Branch (5415:7): [True: 143, False: 3.36k]
  ------------------
 5416|    143|    if (n >
  ------------------
  |  Branch (5416:9): [True: 0, False: 143]
  ------------------
 5417|    143|        (UINT64_MAX - WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH)) {
  ------------------
  |  | 4900|    143|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
 5418|      0|      return 0;
 5419|      0|    }
 5420|    143|    n += WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;
  ------------------
  |  | 4900|    143|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
 5421|    143|  }
 5422|       |
 5423|  3.50k|  return n;
 5424|  3.50k|}
pixel_swizzler_fuzzer.c:wuffs_base__pixel_buffer__set_from_slice:
 5978|  3.50k|                                         wuffs_base__slice_u8 pixbuf_memory) {
 5979|  3.50k|  if (!pb) {
  ------------------
  |  Branch (5979:7): [True: 0, False: 3.50k]
  ------------------
 5980|      0|    return wuffs_base__make_status(wuffs_base__error__bad_receiver);
 5981|      0|  }
 5982|  3.50k|  memset(pb, 0, sizeof(*pb));
 5983|  3.50k|  if (!pixcfg) {
  ------------------
  |  Branch (5983:7): [True: 0, False: 3.50k]
  ------------------
 5984|      0|    return wuffs_base__make_status(wuffs_base__error__bad_argument);
 5985|      0|  }
 5986|  3.50k|  if (wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) {
  ------------------
  |  Branch (5986:7): [True: 0, False: 3.50k]
  ------------------
 5987|       |    // TODO: support planar pixel formats, concious of pixel subsampling.
 5988|      0|    return wuffs_base__make_status(wuffs_base__error__unsupported_option);
 5989|      0|  }
 5990|  3.50k|  uint32_t bits_per_pixel =
 5991|  3.50k|      wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt);
 5992|  3.50k|  if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {
  ------------------
  |  Branch (5992:7): [True: 0, False: 3.50k]
  |  Branch (5992:32): [True: 0, False: 3.50k]
  ------------------
 5993|       |    // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?
 5994|      0|    return wuffs_base__make_status(wuffs_base__error__unsupported_option);
 5995|      0|  }
 5996|  3.50k|  uint64_t bytes_per_pixel = bits_per_pixel / 8;
 5997|       |
 5998|  3.50k|  uint8_t* ptr = pixbuf_memory.ptr;
 5999|  3.50k|  uint64_t len = pixbuf_memory.len;
 6000|  3.50k|  if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt)) {
  ------------------
  |  Branch (6000:7): [True: 143, False: 3.36k]
  ------------------
 6001|       |    // Split a WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH byte
 6002|       |    // chunk (1024 bytes = 256 palette entries × 4 bytes per entry) from the
 6003|       |    // start of pixbuf_memory. We split from the start, not the end, so that
 6004|       |    // the both chunks' pointers have the same alignment as the original
 6005|       |    // pointer, up to an alignment of 1024.
 6006|    143|    if (len < WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
  ------------------
  |  | 4900|    143|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
  |  Branch (6006:9): [True: 0, False: 143]
  ------------------
 6007|      0|      return wuffs_base__make_status(
 6008|      0|          wuffs_base__error__bad_argument_length_too_short);
 6009|      0|    }
 6010|    143|    wuffs_base__table_u8* tab =
 6011|    143|        &pb->private_impl
 6012|    143|             .planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];
  ------------------
  |  | 4897|    143|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE 3
  ------------------
 6013|    143|    tab->ptr = ptr;
 6014|    143|    tab->width = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;
  ------------------
  |  | 4900|    143|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
 6015|    143|    tab->height = 1;
 6016|    143|    tab->stride = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;
  ------------------
  |  | 4900|    143|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
 6017|    143|    ptr += WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;
  ------------------
  |  | 4900|    143|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
 6018|    143|    len -= WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;
  ------------------
  |  | 4900|    143|#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
  ------------------
 6019|    143|  }
 6020|       |
 6021|  3.50k|  uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *
 6022|  3.50k|                ((uint64_t)pixcfg->private_impl.height);
 6023|  3.50k|  size_t width = (size_t)(pixcfg->private_impl.width);
 6024|  3.50k|  if ((wh > (UINT64_MAX / bytes_per_pixel)) ||
  ------------------
  |  Branch (6024:7): [True: 0, False: 3.50k]
  ------------------
 6025|  3.50k|      (width > (SIZE_MAX / bytes_per_pixel))) {
  ------------------
  |  Branch (6025:7): [True: 0, False: 3.50k]
  ------------------
 6026|      0|    return wuffs_base__make_status(wuffs_base__error__bad_argument);
 6027|      0|  }
 6028|  3.50k|  wh *= bytes_per_pixel;
 6029|  3.50k|  width = ((size_t)(width * bytes_per_pixel));
 6030|  3.50k|  if (wh > len) {
  ------------------
  |  Branch (6030:7): [True: 0, False: 3.50k]
  ------------------
 6031|      0|    return wuffs_base__make_status(
 6032|      0|        wuffs_base__error__bad_argument_length_too_short);
 6033|      0|  }
 6034|       |
 6035|  3.50k|  pb->pixcfg = *pixcfg;
 6036|  3.50k|  wuffs_base__table_u8* tab = &pb->private_impl.planes[0];
 6037|  3.50k|  tab->ptr = ptr;
 6038|  3.50k|  tab->width = width;
 6039|  3.50k|  tab->height = pixcfg->private_impl.height;
 6040|  3.50k|  tab->stride = width;
 6041|       |  return wuffs_base__make_status(NULL);
 6042|  3.50k|}
pixel_swizzler_fuzzer.c:wuffs_base__empty_slice_u8:
 1785|  3.50k|wuffs_base__empty_slice_u8(void) {
 1786|  3.50k|  wuffs_base__slice_u8 ret;
 1787|       |  ret.ptr = NULL;
 1788|  3.50k|  ret.len = 0;
 1789|  3.50k|  return ret;
 1790|  3.50k|}

