LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/webp_dec.c
// Function: WebPGetInfo
int WebPGetInfo(const uint8_t* data, size_t data_size,
                int* width, int* height) {
  WebPBitstreamFeatures features;

  if (GetFeatures(data, data_size, &features) != VP8_STATUS_OK) {
    return 0;
  }

  if (width != NULL) {
    *width  = features.width;
  }
  if (height != NULL) {
    *height = features.height;
  }

  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
testq %rdi, %rdi
je 0xce0c8
movq %rcx, %rbx
movq %rdx, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, -0x10(%rax)
xorl %r15d, %r15d
movq %r15, 0x10(%rax)
leaq 0x4(%rsp), %rcx
leaq 0x8(%rsp), %r8
leaq 0xc(%rsp), %r9
movq %rsp, %rdx
pushq %r15
pushq %rax
callq 0xcd5db
addq $0x10, %rsp
testl %eax, %eax
jne 0xce0cb
testq %r14, %r14
je 0xce0b5
movl (%rsp), %eax
movl %eax, (%r14)
movl $0x1, %r15d
testq %rbx, %rbx
je 0xce0cb
movl 0x4(%rsp), %eax
movl %eax, (%rbx)
jmp 0xce0cb
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/webp_dec.c
// Function: WebPGetFeaturesInternal
VP8StatusCode WebPGetFeaturesInternal(const uint8_t* data, size_t data_size,
                                      WebPBitstreamFeatures* features,
                                      int version) {
  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) {
    return VP8_STATUS_INVALID_PARAM;   // version mismatch
  }
  if (features == NULL) {
    return VP8_STATUS_INVALID_PARAM;
  }
  return GetFeatures(data, data_size, features);
}

// Assembly:
testq %rdi, %rdi
je 0xce163
testq %rdx, %rdx
je 0xce163
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
cmpl $0x200, %ecx            # imm = 0x200
jne 0xce163
pushq %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdx)
movups %xmm0, (%rdx)
xorl %eax, %eax
movq %rax, 0x20(%rdx)
leaq 0x10(%rdx), %r10
leaq 0x4(%rdx), %rcx
leaq 0x8(%rdx), %r8
leaq 0xc(%rdx), %r9
pushq %rax
pushq %r10
callq 0xcd5db
addq $0x10, %rsp
popq %rcx
retq
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/webp_dec.c
// Function: WebPDecode
VP8StatusCode WebPDecode(const uint8_t* data, size_t data_size,
                         WebPDecoderConfig* config) {
  WebPDecParams params;
  VP8StatusCode status;

  if (config == NULL) {
    return VP8_STATUS_INVALID_PARAM;
  }

  status = GetFeatures(data, data_size, &config->input);
  if (status != VP8_STATUS_OK) {
    if (status == VP8_STATUS_NOT_ENOUGH_DATA) {
      return VP8_STATUS_BITSTREAM_ERROR;  // Not-enough-data treated as error.
    }
    return status;
  }

  WebPResetDecParams(&params);
  params.options = &config->options;
  params.output = &config->output;
  if (WebPAvoidSlowMemory(params.output, &config->input)) {
    // decoding to slow memory: use a temporary in-mem buffer to decode into.
    WebPDecBuffer in_mem_buffer;
    if (!WebPInitDecBuffer(&in_mem_buffer)) {
      return VP8_STATUS_INVALID_PARAM;
    }
    in_mem_buffer.colorspace = config->output.colorspace;
    in_mem_buffer.width = config->input.width;
    in_mem_buffer.height = config->input.height;
    params.output = &in_mem_buffer;
    status = DecodeInto(data, data_size, &params);
    if (status == VP8_STATUS_OK) {  // do the slow-copy
      status = WebPCopyDecBufferPixels(&in_mem_buffer, &config->output);
    }
    WebPFreeDecBuffer(&in_mem_buffer);
  } else {
    status = DecodeInto(data, data_size, &params);
  }

  return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
testq %rdx, %rdx
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
movl $0x2, %ebp
jne 0xce294
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdx)
movups %xmm0, (%rdx)
xorl %eax, %eax
movq %rax, 0x20(%rdx)
leaq 0x10(%rdx), %r10
leaq 0x4(%rdx), %rcx
leaq 0x8(%rdx), %r8
leaq 0xc(%rdx), %r9
pushq %rax
pushq %r10
callq 0xcd5db
addq $0x10, %rsp
testl %eax, %eax
je 0xce1df
movl $0x3, %ebp
cmpl $0x7, %eax
je 0xce294
jmp 0xce292
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsp)
movups %xmm0, 0x58(%rsp)
movups %xmm0, 0x48(%rsp)
movups %xmm0, 0x38(%rsp)
movups %xmm0, 0x18(%rsp)
movups %xmm0, 0x8(%rsp)
movq $0x0, 0x68(%rsp)
leaq 0xa0(%r15), %rax
movq %rax, 0x28(%rsp)
leaq 0x28(%r15), %r12
movq %r12, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0xcd521
testl %eax, %eax
je 0xce284
leaq 0x70(%rsp), %r13
movq %r13, %rdi
movl $0x209, %esi            # imm = 0x209
callq 0x56a10
testl %eax, %eax
je 0xce2a8
movl 0x28(%r15), %eax
movl %eax, 0x70(%rsp)
movq (%r15), %rax
movq %rax, 0x74(%rsp)
movq %rsp, %rdx
movq %r13, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcdc3f
movl %eax, %ebp
testl %eax, %eax
jne 0xce278
leaq 0x70(%rsp), %rdi
movq %r12, %rsi
callq 0xcd200
movl %eax, %ebp
leaq 0x70(%rsp), %rdi
callq 0x57c60
jmp 0xce294
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xcdc3f
movl %eax, %ebp
movl %ebp, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x2, %ebp
jmp 0xce294
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/utils/rescaler_utils.c
// Function: WebPRescalerGetScaledDimensions
int WebPRescalerGetScaledDimensions(int src_width, int src_height,
                                    int* const scaled_width,
                                    int* const scaled_height) {
  assert(scaled_width != NULL);
  assert(scaled_height != NULL);
  {
    int width = *scaled_width;
    int height = *scaled_height;
    const int max_size = INT_MAX / 2;

    // if width is unspecified, scale original proportionally to height ratio.
    if (width == 0 && src_height > 0) {
      width =
          (int)(((uint64_t)src_width * height + src_height - 1) / src_height);
    }
    // if height is unspecified, scale original proportionally to width ratio.
    if (height == 0 && src_width > 0) {
      height =
          (int)(((uint64_t)src_height * width + src_width - 1) / src_width);
    }
    // Check if the overall dimensions still make sense.
    if (width <= 0 || height <= 0 || width > max_size || height > max_size) {
      return 0;
    }

    *scaled_width = width;
    *scaled_height = height;
    return 1;
  }
}

// Assembly:
pushq %rax
testq %rdx, %rdx
je 0xce91e
testq %rcx, %rcx
je 0xce93d
movq %rdx, %r8
movl (%rdx), %r9d
movl (%rcx), %r10d
testl %r9d, %r9d
setne %al
testl %esi, %esi
setle %dl
orb %al, %dl
jne 0xce8c9
movslq %r10d, %rax
movslq %edi, %rdx
imulq %rax, %rdx
movl %esi, %r9d
leaq (%r9,%rdx), %rax
decq %rax
xorl %edx, %edx
divq %r9
movq %rax, %r9
testl %r10d, %r10d
setne %al
testl %edi, %edi
setle %dl
orb %al, %dl
jne 0xce8f3
movslq %esi, %rax
movslq %r9d, %rdx
imulq %rax, %rdx
movl %edi, %esi
leaq (%rsi,%rdx), %rax
decq %rax
xorl %edx, %edx
divq %rsi
movq %rax, %r10
movl $0xc0000000, %edx       # imm = 0xC0000000
leal (%r9,%rdx), %esi
xorl %eax, %eax
cmpl $0xc0000001, %esi       # imm = 0xC0000001
jb 0xce91c
addl %r10d, %edx
cmpl $0xc0000001, %edx       # imm = 0xC0000001
jb 0xce91c
movl %r9d, (%r8)
movl %r10d, (%rcx)
movl $0x1, %eax
popq %rcx
retq
leaq 0x5a341(%rip), %rdi     # 0x128c66
leaq 0x5a34f(%rip), %rsi     # 0x128c7b
leaq 0x5a363(%rip), %rcx     # 0x128c96
movl $0x58, %edx
callq 0x55710
leaq 0x5a398(%rip), %rdi     # 0x128cdc
leaq 0x5a330(%rip), %rsi     # 0x128c7b
leaq 0x5a344(%rip), %rcx     # 0x128c96
movl $0x59, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/utils/rescaler_utils.c
// Function: WebPRescalerImport
int WebPRescalerImport(WebPRescaler* const rescaler, int num_lines,
                       const uint8_t* src, int src_stride) {
  int total_imported = 0;
  while (total_imported < num_lines &&
         !WebPRescalerHasPendingOutput(rescaler)) {
    if (rescaler->y_expand) {
      rescaler_t* const tmp = rescaler->irow;
      rescaler->irow = rescaler->frow;
      rescaler->frow = tmp;
    }
    WebPRescalerImportRow(rescaler, src);
    if (!rescaler->y_expand) {    // Accumulate the contribution of the new row.
      int x;
      for (x = 0; x < rescaler->num_channels * rescaler->dst_width; ++x) {
        rescaler->irow[x] += rescaler->frow[x];
      }
    }
    ++rescaler->src_y;
    src += src_stride;
    ++total_imported;
    rescaler->y_accum -= rescaler->y_sub;
  }
  return total_imported;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %esi, %esi
jle 0xcea15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movslq %ecx, %r12
xorl %ebx, %ebx
movl 0x40(%r15), %eax
cmpl 0x38(%r15), %eax
jge 0xce99d
cmpl $0x0, 0x18(%r15)
jle 0xcea17
cmpl $0x0, 0x4(%r15)
je 0xce9b5
movdqu 0x58(%r15), %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x58(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0xdbcc5
cmpl $0x0, 0x4(%r15)
jne 0xce9f8
movl 0x34(%r15), %eax
imull 0x8(%r15), %eax
testl %eax, %eax
jle 0xce9f8
movq 0x58(%r15), %rax
movq 0x60(%r15), %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %esi
addl %esi, (%rax,%rdx,4)
incq %rdx
movslq 0x8(%r15), %rsi
movslq 0x34(%r15), %rdi
imulq %rsi, %rdi
cmpq %rdi, %rdx
jl 0xce9de
incl 0x3c(%r15)
addq %r12, %r14
incl %ebx
movl 0x20(%r15), %eax
subl %eax, 0x18(%r15)
cmpl %ebp, %ebx
jne 0xce98c
movl %ebp, %ebx
jmp 0xcea17
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/utils/rescaler_utils.c
// Function: WebPRescalerExport
int WebPRescalerExport(WebPRescaler* const rescaler) {
  int total_exported = 0;
  while (WebPRescalerHasPendingOutput(rescaler)) {
    WebPRescalerExportRow(rescaler);
    ++total_exported;
  }
  return total_exported;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x40(%rdi), %eax
xorl %ebx, %ebx
cmpl 0x38(%rdi), %eax
jge 0xcea50
movq %rdi, %r14
xorl %ebx, %ebx
cmpl $0x0, 0x18(%r14)
jg 0xcea50
movq %r14, %rdi
callq 0xdbd07
incl %ebx
movl 0x40(%r14), %eax
cmpl 0x38(%r14), %eax
jl 0xcea35
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/utils/utils.c
// Function: WebPSafeMalloc
void* WebPSafeMalloc(uint64_t nmemb, size_t size) {
  void* ptr;
  Increment(&num_malloc_calls);
  if (!CheckSizeArgumentsOverflow(nmemb, size)) return NULL;
  assert(nmemb * size > 0);
  ptr = malloc((size_t)(nmemb * size));
  AddMem(ptr, (size_t)(nmemb * size));
  return ptr;
}

// Assembly:
testq %rdi, %rdi
je 0xcea78
movabsq $0x400000000, %rax      # imm = 0x400000000
xorl %edx, %edx
divq %rdi
cmpq %rsi, %rax
jae 0xcea78
xorl %eax, %eax
retq
imulq %rdi, %rsi
testq %rsi, %rsi
je 0xcea89
movq %rsi, %rdi
jmp 0x57ff0
pushq %rax
leaq 0x5a261(%rip), %rdi     # 0x128cf2
leaq 0x5a26b(%rip), %rsi     # 0x128d03
leaq 0x5a276(%rip), %rcx     # 0x128d15
movl $0xc6, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/utils/utils.c
// Function: WebPSafeCalloc
void* WebPSafeCalloc(uint64_t nmemb, size_t size) {
  void* ptr;
  Increment(&num_calloc_calls);
  if (!CheckSizeArgumentsOverflow(nmemb, size)) return NULL;
  assert(nmemb * size > 0);
  ptr = calloc((size_t)nmemb, size);
  AddMem(ptr, (size_t)(nmemb * size));
  return ptr;
}

// Assembly:
testq %rdi, %rdi
je 0xceac5
movabsq $0x400000000, %rax      # imm = 0x400000000
xorl %edx, %edx
divq %rdi
cmpq %rsi, %rax
jae 0xceac5
xorl %eax, %eax
retq
movq %rsi, %rax
imulq %rdi, %rax
testq %rax, %rax
je 0xcead6
jmp 0x57cd0
pushq %rax
leaq 0x5a214(%rip), %rdi     # 0x128cf2
leaq 0x5a21e(%rip), %rsi     # 0x128d03
leaq 0x5a250(%rip), %rcx     # 0x128d3c
movl $0xd0, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/utils/utils.c
// Function: WebPCopyPlane
void WebPCopyPlane(const uint8_t* src, int src_stride,
                   uint8_t* dst, int dst_stride, int width, int height) {
  assert(src != NULL && dst != NULL);
  assert(abs(src_stride) >= width && abs(dst_stride) >= width);
  while (height-- > 0) {
    memcpy(dst, src, width);
    src += src_stride;
    dst += dst_stride;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xceb7d
movq %rdx, %r14
testq %rdx, %rdx
je 0xceb7d
movl %esi, %edx
negl %edx
cmovsl %esi, %edx
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
cmpl %r8d, %edx
jl 0xceb9c
cmpl %r8d, %eax
jl 0xceb9c
movl %r9d, %ebx
testl %r9d, %r9d
jle 0xceb6e
movq %rdi, %r15
movslq %r8d, %r12
movslq %esi, %r13
movslq %ecx, %rbp
incl %ebx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x552d0
addq %r13, %r15
addq %rbp, %r14
decl %ebx
cmpl $0x1, %ebx
ja 0xceb53
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5a1df(%rip), %rdi     # 0x128d63
leaq 0x5a178(%rip), %rsi     # 0x128d03
leaq 0x5a1ec(%rip), %rcx     # 0x128d7e
movl $0xec, %edx
callq 0x55710
leaq 0x5a21e(%rip), %rdi     # 0x128dc1
leaq 0x5a159(%rip), %rsi     # 0x128d03
leaq 0x5a1cd(%rip), %rcx     # 0x128d7e
movl $0xed, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/utils/utils.c
// Function: WebPCopyPixels
void WebPCopyPixels(const WebPPicture* const src, WebPPicture* const dst) {
  assert(src != NULL && dst != NULL);
  assert(src->width == dst->width && src->height == dst->height);
  assert(src->use_argb && dst->use_argb);
  WebPCopyPlane((uint8_t*)src->argb, 4 * src->argb_stride, (uint8_t*)dst->argb,
                4 * dst->argb_stride, 4 * src->width, src->height);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xcec50
testq %rsi, %rsi
je 0xcec50
movl 0x8(%rdi), %r8d
cmpl 0x8(%rsi), %r8d
jne 0xcec12
movl 0xc(%rdi), %r9d
cmpl 0xc(%rsi), %r9d
jne 0xcec12
cmpl $0x0, (%rdi)
je 0xcec31
cmpl $0x0, (%rsi)
je 0xcec31
movq 0x48(%rdi), %rax
movl 0x50(%rdi), %r10d
shll $0x2, %r10d
movq 0x48(%rsi), %rdx
movl 0x50(%rsi), %ecx
shll $0x2, %ecx
shll $0x2, %r8d
movq %rax, %rdi
movl %r10d, %esi
popq %rax
jmp 0x582e0
leaq 0x5a21f(%rip), %rdi     # 0x128e38
leaq 0x5a0e3(%rip), %rsi     # 0x128d03
leaq 0x5a1cf(%rip), %rcx     # 0x128df6
movl $0xf7, %edx
callq 0x55710
leaq 0x5a237(%rip), %rdi     # 0x128e6f
leaq 0x5a0c4(%rip), %rsi     # 0x128d03
leaq 0x5a1b0(%rip), %rcx     # 0x128df6
movl $0xf8, %edx
callq 0x55710
leaq 0x5a10c(%rip), %rdi     # 0x128d63
leaq 0x5a0a5(%rip), %rsi     # 0x128d03
leaq 0x5a191(%rip), %rcx     # 0x128df6
movl $0xf6, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/frame_dec.c
// Function: VP8InitDithering
void VP8InitDithering(const WebPDecoderOptions* const options,
                      VP8Decoder* const dec) {
  assert(dec != NULL);
  if (options != NULL) {
    const int d = options->dithering_strength;
    const int max_amp = (1 << VP8_RANDOM_DITHER_FIX) - 1;
    const int f = (d < 0) ? 0 : (d > 100) ? max_amp : (d * max_amp / 100);
    if (f > 0) {
      int s;
      int all_amp = 0;
      for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
        VP8QuantMatrix* const dqm = &dec->dqm_[s];
        if (dqm->uv_quant_ < DITHER_AMP_TAB_SIZE) {
          const int idx = (dqm->uv_quant_ < 0) ? 0 : dqm->uv_quant_;
          dqm->dither_ = (f * kQuantToDitherAmp[idx]) >> 3;
        }
        all_amp |= dqm->dither_;
      }
      if (all_amp != 0) {
        VP8InitRandom(&dec->dithering_rg_, 1.0f);
        dec->dither_ = 1;
      }
    }
    // potentially allow alpha dithering
    dec->alpha_dithering_ = options->alpha_dithering_strength;
    if (dec->alpha_dithering_ > 100) {
      dec->alpha_dithering_ = 100;
    } else if (dec->alpha_dithering_ < 0) {
      dec->alpha_dithering_ = 0;
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xced5f
movq %rdi, %r14
testq %rdi, %rdi
je 0xced57
movq %rsi, %rbx
movl 0x2c(%r14), %ecx
testl %ecx, %ecx
js 0xced37
movl $0xff, %eax
cmpl $0x64, %ecx
ja 0xcecc4
testl %ecx, %ecx
je 0xced37
movl %ecx, %eax
shll $0x8, %eax
subl %ecx, %eax
movzwl %ax, %eax
shrl $0x2, %eax
imull $0x147b, %eax, %eax     # imm = 0x147B
shrl $0x11, %eax
xorl %ecx, %ecx
leaq 0x5a213(%rip), %rdx     # 0x128ee0
xorl %edi, %edi
xorl %esi, %esi
movl 0x43c(%rbx,%rdi), %r8d
cmpl $0xc, %r8d
jge 0xcecfd
testl %r8d, %r8d
cmovlel %ecx, %r8d
movzbl (%r8,%rdx), %r8d
imull %eax, %r8d
shrl $0x3, %r8d
movl %r8d, 0x440(%rbx,%rdi)
jmp 0xced05
movl 0x440(%rbx,%rdi), %r8d
orl %r8d, %esi
addq $0x20, %rdi
cmpq $0x80, %rdi
jne 0xcecd1
testl %esi, %esi
je 0xced37
leaq 0x33c(%rbx), %rdi
movss 0x5a168(%rip), %xmm0    # 0x128e90
callq 0xf12b0
movl $0x1, 0x338(%rbx)
movl 0x34(%r14), %ecx
movl %ecx, 0xbc8(%rbx)
movl $0x64, %eax
cmpl $0x64, %ecx
jg 0xced51
testl %ecx, %ecx
jns 0xced57
xorl %eax, %eax
movl %eax, 0xbc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5ab77(%rip), %rdi     # 0x1298dd
leaq 0x5a182(%rip), %rsi     # 0x128eef
leaq 0x5a18f(%rip), %rcx     # 0x128f03
movl $0x14a, %edx            # imm = 0x14A
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/frame_dec.c
// Function: VP8ExitCritical
int VP8ExitCritical(VP8Decoder* const dec, VP8Io* const io) {
  int ok = 1;
  if (dec->mt_method_ > 0) {
    ok = WebPGetWorkerInterface()->Sync(&dec->worker_);
  }

  if (io->teardown != NULL) {
    io->teardown(io);
  }
  return ok;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x0, 0xc8(%rdi)
jle 0xcfe12
movq %rdi, %r14
callq 0x56690
addq $0x98, %r14
movq %r14, %rdi
callq *0x10(%rax)
movl %eax, %ebp
jmp 0xcfe17
movl $0x1, %ebp
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0xcfe25
movq %rbx, %rdi
callq *%rax
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/frame_dec.c
// Function: VP8GetThreadMethod
int VP8GetThreadMethod(const WebPDecoderOptions* const options,
                       const WebPHeaderStructure* const headers,
                       int width, int height) {
  if (options == NULL || options->use_threads == 0) {
    return 0;
  }
  (void)headers;
  (void)width;
  (void)height;
  assert(headers == NULL || !headers->is_lossless);
#if defined(WEBP_USE_THREAD)
  if (width >= MIN_WIDTH_FOR_THREADS) return 2;
#endif
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xcfe42
testq %rsi, %rsi
je 0xcfe42
cmpl $0x0, 0x28(%rdi)
je 0xcfe42
cmpl $0x0, 0x40(%rsi)
jne 0xcfe45
xorl %eax, %eax
retq
pushq %rax
leaq 0x5915c(%rip), %rdi     # 0x128fa9
leaq 0x5909b(%rip), %rsi     # 0x128eef
leaq 0x59177(%rip), %rcx     # 0x128fd2
movl $0x29d, %edx            # imm = 0x29D
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/frame_dec.c
// Function: Dither8x8
static void Dither8x8(VP8Random* const rg, uint8_t* dst, int bps, int amp) {
  uint8_t dither[64];
  int i;
  for (i = 0; i < 8 * 8; ++i) {
    dither[i] = VP8RandomBits2(rg, VP8_DITHER_AMP_BITS + 1, amp);
  }
  VP8DitherCombine8x8(dither, dst, bps);
}

// Assembly:
subq $0x48, %rsp
movq (%rdi), %xmm2
xorl %eax, %eax
pcmpeqd %xmm0, %xmm0
movdqa 0x58c0c(%rip), %xmm1    # 0x128eb0
movd %xmm2, %r8d
movslq %r8d, %r8
movl 0x8(%rdi,%r8,4), %r9d
pshufd $0x55, %xmm2, %xmm2     # xmm2 = xmm2[1,1,1,1]
movd %xmm2, %r10d
movslq %r10d, %r10
subl 0x8(%rdi,%r10,4), %r9d
movl %r9d, %r10d
andl $0x7fffffff, %r10d      # imm = 0x7FFFFFFF
movl %r10d, 0x8(%rdi,%r8,4)
movq (%rdi), %xmm3
psubd %xmm0, %xmm3
movdqa %xmm3, %xmm2
pcmpeqd %xmm1, %xmm2
pandn %xmm3, %xmm2
movq %xmm2, (%rdi)
shrl $0x17, %r9d
movsbl %r9b, %r8d
imull %ecx, %r8d
shrl $0x8, %r8d
addb $-0x80, %r8b
movb %r8b, (%rsp,%rax)
incq %rax
cmpq $0x40, %rax
jne 0xd02a4
leaq 0xab0ae(%rip), %rax     # 0x17b3c0
movq %rsp, %rdi
callq *(%rax)
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: WebPInitCustomIo
void WebPInitCustomIo(WebPDecParams* const params, VP8Io* const io) {
  io->put      = CustomPut;
  io->setup    = CustomSetup;
  io->teardown = CustomTeardown;
  io->opaque   = params;
}

// Assembly:
leaq 0x1f(%rip), %rax        # 0xd0342
movq %rax, 0x40(%rsi)
leaq 0x7f(%rip), %rax        # 0xd03ad
movq %rax, 0x48(%rsi)
leaq 0x69e(%rip), %rax       # 0xd09d7
movq %rax, 0x50(%rsi)
movq %rdi, 0x38(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: CustomPut
static int CustomPut(const VP8Io* io) {
  WebPDecParams* const p = (WebPDecParams*)io->opaque;
  const int mb_w = io->mb_w;
  const int mb_h = io->mb_h;
  int num_lines_out;
  assert(!(io->mb_y & 1));

  if (mb_w <= 0 || mb_h <= 0) {
    return 0;
  }
  num_lines_out = p->emit(io, p);
  if (p->emit_alpha != NULL) {
    p->emit_alpha(io, p, num_lines_out);
  }
  p->last_y += num_lines_out;
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testb $0x1, 0x8(%rdi)
jne 0xd038e
movq %rdi, %rbx
xorl %eax, %eax
cmpl $0x0, 0xc(%rdi)
jle 0xd0389
cmpl $0x0, 0x10(%rbx)
jle 0xd0389
movq 0x38(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq *0x58(%r14)
movl %eax, %ebp
movq 0x60(%r14), %rax
testq %rax, %rax
je 0xd0380
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq *%rax
addl %ebp, 0x20(%r14)
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x58deb(%rip), %rdi     # 0x129180
leaq 0x58df4(%rip), %rsi     # 0x129190
leaq 0x58dfe(%rip), %rcx     # 0x1291a1
movl $0x277, %edx            # imm = 0x277
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: EmitSampledRGB
static int EmitSampledRGB(const VP8Io* const io, WebPDecParams* const p) {
  WebPDecBuffer* const output = p->output;
  WebPRGBABuffer* const buf = &output->u.RGBA;
  uint8_t* const dst = buf->rgba + (size_t)io->mb_y * buf->stride;
  WebPSamplerProcessPlane(io->y, io->y_stride,
                          io->u, io->v, io->uv_stride,
                          dst, buf->stride, io->mb_w, io->mb_h,
                          WebPSamplers[output->colorspace]);
  return io->mb_h;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %r10
movslq 0x8(%rdi), %r9
movslq 0x18(%r10), %rax
imulq %rax, %r9
addq 0x10(%r10), %r9
movq 0x18(%rdi), %rdi
movl 0x30(%rbx), %esi
movq 0x20(%rbx), %rdx
movq 0x28(%rbx), %rcx
movl 0x34(%rbx), %r8d
movl 0xc(%rbx), %r11d
movl 0x10(%rbx), %r14d
movl (%r10), %r10d
leaq 0xaacb1(%rip), %r15     # 0x17b6e0
pushq (%r15,%r10,8)
pushq %r14
pushq %r11
pushq %rax
callq 0xe058c
addq $0x20, %rsp
movl 0x10(%rbx), %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: EmitAlphaRGBA4444
static int EmitAlphaRGBA4444(const VP8Io* const io, WebPDecParams* const p,
                             int expected_num_lines_out) {
  const uint8_t* alpha = io->a;
  if (alpha != NULL) {
    const int mb_w = io->mb_w;
    const WEBP_CSP_MODE colorspace = p->output->colorspace;
    const WebPRGBABuffer* const buf = &p->output->u.RGBA;
    int num_rows;
    const size_t start_y = GetAlphaSourceRow(io, &alpha, &num_rows);
    uint8_t* const base_rgba = buf->rgba + start_y * buf->stride;
#if (WEBP_SWAP_16BIT_CSP == 1)
    uint8_t* alpha_dst = base_rgba;
#else
    uint8_t* alpha_dst = base_rgba + 1;
#endif
    uint32_t alpha_mask = 0x0f;
    int i, j;
    for (j = 0; j < num_rows; ++j) {
      for (i = 0; i < mb_w; ++i) {
        // Fill in the alpha value (converted to 4 bits).
        const uint32_t alpha_value = alpha[i] >> 4;
        alpha_dst[2 * i] = (alpha_dst[2 * i] & 0xf0) | alpha_value;
        alpha_mask &= alpha_value;
      }
      alpha += io->width;
      alpha_dst += buf->stride;
    }
    (void)expected_num_lines_out;
    assert(expected_num_lines_out == num_rows);
    if (alpha_mask != 0x0f && WebPIsPremultipliedMode(colorspace)) {
      WebPApplyAlphaMultiply4444(base_rgba, mb_w, num_rows, buf->stride);
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x98(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xd0ddc
movl %edx, %ebx
movq %rdi, %r15
movl 0xc(%rdi), %r14d
movq (%rsi), %r13
movl (%r13), %ebp
leaq 0x8(%rsp), %rsi
leaq 0x14(%rsp), %r12
movq %r12, %rdx
callq 0xd173a
movslq %eax, %rdi
movslq 0x18(%r13), %rcx
imulq %rcx, %rdi
addq 0x10(%r13), %rdi
movl (%r12), %eax
testl %eax, %eax
jle 0xd0dbb
movq 0x8(%rsp), %rdx
leaq 0x1(%rdi), %r8
movl $0xf, %esi
xorl %r9d, %r9d
testl %r14d, %r14d
jle 0xd0d9f
xorl %ecx, %ecx
movzbl (%rdx,%rcx), %r10d
shrl $0x4, %r10d
movb (%r8,%rcx,2), %r11b
andb $-0x10, %r11b
orb %r10b, %r11b
movb %r11b, (%r8,%rcx,2)
andl %r10d, %esi
incq %rcx
cmpq %rcx, %r14
jne 0xd0d78
movl 0x18(%r13), %ecx
movslq (%r15), %r10
addq %r10, %rdx
movslq %ecx, %r10
addq %r10, %r8
incl %r9d
cmpl %eax, %r9d
jne 0xd0d71
cmpl $0xf, %esi
sete %dl
jmp 0xd0dbd
movb $0x1, %dl
cmpl %ebx, %eax
jne 0xd0ded
addl $-0xb, %ebp
cmpl $-0x4, %ebp
setb %al
orb %al, %dl
jne 0xd0ddc
leaq 0xaa43b(%rip), %rax     # 0x17b210
movl %r14d, %esi
movl %ebx, %edx
callq *(%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x585b1(%rip), %rdi     # 0x1293a5
leaq 0x58395(%rip), %rsi     # 0x129190
leaq 0x585c6(%rip), %rcx     # 0x1293c8
movl $0xe4, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: EmitAlphaRGB
static int EmitAlphaRGB(const VP8Io* const io, WebPDecParams* const p,
                        int expected_num_lines_out) {
  const uint8_t* alpha = io->a;
  if (alpha != NULL) {
    const int mb_w = io->mb_w;
    const WEBP_CSP_MODE colorspace = p->output->colorspace;
    const int alpha_first =
        (colorspace == MODE_ARGB || colorspace == MODE_Argb);
    const WebPRGBABuffer* const buf = &p->output->u.RGBA;
    int num_rows;
    const size_t start_y = GetAlphaSourceRow(io, &alpha, &num_rows);
    uint8_t* const base_rgba = buf->rgba + start_y * buf->stride;
    uint8_t* const dst = base_rgba + (alpha_first ? 0 : 3);
    const int has_alpha = WebPDispatchAlpha(alpha, io->width, mb_w,
                                            num_rows, dst, buf->stride);
    (void)expected_num_lines_out;
    assert(expected_num_lines_out == num_rows);
    // has_alpha is true if there's non-trivial alpha to premultiply with.
    if (has_alpha && WebPIsPremultipliedMode(colorspace)) {
      WebPApplyAlphaMultiply(base_rgba, alpha_first,
                             mb_w, num_rows, buf->stride);
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x98(%rdi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xd0ed3
movl %edx, %ecx
movq %rdi, %r15
movl 0xc(%rdi), %r12d
movq (%rsi), %rbp
movl (%rbp), %ebx
cmpl $0x4, %ebx
sete %al
cmpl $0x9, %ebx
sete %r13b
orb %al, %r13b
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movl %ecx, 0x8(%rsp)
callq 0xd173a
movslq %eax, %r14
movslq 0x18(%rbp), %r9
imulq %r9, %r14
addq 0x10(%rbp), %r14
movl %r13d, %eax
xorb $0x1, %al
movzbl %al, %eax
leaq (%rax,%rax,2), %r8
addq %r14, %r8
leaq 0xaa392(%rip), %rax     # 0x17b218
leaq 0x10(%rsp), %rcx
movq (%rcx), %rdi
movl (%r15), %esi
leaq 0xc(%rsp), %rcx
movl (%rcx), %r15d
movl %r12d, 0x4(%rsp)
movl %r12d, %edx
movl %r15d, %ecx
callq *(%rax)
movl 0x8(%rsp), %ecx
cmpl %ecx, %r15d
jne 0xd0ee4
addl $-0xb, %ebx
cmpl $-0x4, %ebx
jb 0xd0ed3
testl %eax, %eax
je 0xd0ed3
movzbl %r13b, %esi
leaq 0xaa342(%rip), %rax     # 0x17b208
movl 0x18(%rbp), %r8d
movq %r14, %rdi
movl 0x4(%rsp), %edx
callq *(%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x584ba(%rip), %rdi     # 0x1293a5
leaq 0x5829e(%rip), %rsi     # 0x129190
leaq 0x58514(%rip), %rcx     # 0x12940d
movl $0xbe, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: EmitAlphaYUV
static int EmitAlphaYUV(const VP8Io* const io, WebPDecParams* const p,
                        int expected_num_lines_out) {
  const uint8_t* alpha = io->a;
  const WebPYUVABuffer* const buf = &p->output->u.YUVA;
  const int mb_w = io->mb_w;
  const int mb_h = io->mb_h;
  uint8_t* dst = buf->a + (size_t)io->mb_y * buf->a_stride;
  int j;
  (void)expected_num_lines_out;
  assert(expected_num_lines_out == mb_h);
  if (alpha != NULL) {
    for (j = 0; j < mb_h; ++j) {
      memcpy(dst, alpha, mb_w * sizeof(*dst));
      alpha += io->width;
      dst += buf->a_stride;
    }
  } else if (buf->a != NULL) {
    // the user requested alpha, but there is none, set it to opaque.
    FillAlphaPlane(dst, mb_w, mb_h, buf->a_stride);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl %edx, 0x10(%rdi)
jne 0xd0fa2
movl %edx, %ebx
movq %rdi, %r12
movq (%rsi), %rbp
movslq 0xc(%rdi), %r14
movq 0x28(%rbp), %rax
movslq 0x8(%rdi), %r15
movslq 0x3c(%rbp), %rdx
imulq %rdx, %r15
addq %rax, %r15
movq 0x98(%rdi), %r13
testq %r13, %r13
je 0xd0f68
testl %ebx, %ebx
jle 0xd0f91
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x552d0
movslq (%r12), %rax
addq %rax, %r13
movslq 0x3c(%rbp), %rax
addq %rax, %r15
decl %ebx
jne 0xd0f46
jmp 0xd0f91
testq %rax, %rax
sete %al
testl %ebx, %ebx
setle %cl
orb %al, %cl
jne 0xd0f91
movq %rdx, %r12
movq %r15, %rdi
movl $0xff, %esi
movq %r14, %rdx
callq 0x55f20
addq %r12, %r15
decl %ebx
jne 0xd0f7a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x584a4(%rip), %rdi     # 0x12944d
leaq 0x581e0(%rip), %rsi     # 0x129190
leaq 0x584b5(%rip), %rcx     # 0x12946c
movl $0x86, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: EmitRescaledAlphaRGB
static int EmitRescaledAlphaRGB(const VP8Io* const io, WebPDecParams* const p,
                                int expected_num_out_lines) {
  if (io->a != NULL) {
    WebPRescaler* const scaler = p->scaler_a;
    int lines_left = expected_num_out_lines;
    const int y_end = p->last_y + lines_left;
    while (lines_left > 0) {
      const int64_t row_offset = (int64_t)scaler->src_y - io->mb_y;
      WebPRescalerImport(scaler, io->mb_h + io->mb_y - scaler->src_y,
                         io->a + row_offset * io->width, io->width);
      lines_left -= p->emit_alpha_row(p, y_end - lines_left, lines_left);
    }
  }
  return 0;
}

// Assembly:
cmpq $0x0, 0x98(%rdi)
je 0xd1264
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
testl %edx, %edx
jle 0xd125c
movq %rsi, %r14
movq %rdi, %r15
movq 0x48(%rsi), %r12
movl 0x20(%rsi), %ebp
addl %ebx, %ebp
movslq 0x3c(%r12), %rax
movslq 0x8(%r15), %rsi
movq %rax, %rdx
subq %rsi, %rdx
subl %eax, %esi
addl 0x10(%r15), %esi
movslq (%r15), %rcx
imulq %rcx, %rdx
addq 0x98(%r15), %rdx
movq %r12, %rdi
callq 0xce96f
movl %ebp, %esi
subl %ebx, %esi
movq %r14, %rdi
movl %ebx, %edx
callq *0x68(%r14)
subl %eax, %ebx
jg 0xd1220
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: ExportAlphaRGBA4444
static int ExportAlphaRGBA4444(WebPDecParams* const p, int y_pos,
                               int max_lines_out) {
  const WebPRGBABuffer* const buf = &p->output->u.RGBA;
  uint8_t* const base_rgba = buf->rgba + (size_t)y_pos * buf->stride;
#if (WEBP_SWAP_16BIT_CSP == 1)
  uint8_t* alpha_dst = base_rgba;
#else
  uint8_t* alpha_dst = base_rgba + 1;
#endif
  int num_lines_out = 0;
  const WEBP_CSP_MODE colorspace = p->output->colorspace;
  const int width = p->scaler_a->dst_width;
  const int is_premult_alpha = WebPIsPremultipliedMode(colorspace);
  uint32_t alpha_mask = 0x0f;

  while (WebPRescalerHasPendingOutput(p->scaler_a) &&
         num_lines_out < max_lines_out) {
    int i;
    assert(y_pos + num_lines_out < p->output->height);
    WebPRescalerExportRow(p->scaler_a);
    for (i = 0; i < width; ++i) {
      // Fill in the alpha value (converted to 4 bits).
      const uint32_t alpha_value = p->scaler_a->dst[i] >> 4;
      alpha_dst[2 * i] = (alpha_dst[2 * i] & 0xf0) | alpha_value;
      alpha_mask &= alpha_value;
    }
    alpha_dst += buf->stride;
    ++num_lines_out;
  }
  if (is_premult_alpha && alpha_mask != 0x0f) {
    WebPApplyAlphaMultiply4444(base_rgba, width, num_lines_out, buf->stride);
  }
  return num_lines_out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r13
movq 0x48(%rdi), %rdi
movl 0x40(%rdi), %eax
xorl %r14d, %r14d
cmpl 0x38(%rdi), %eax
jge 0xd1385
movl %esi, %r10d
movq (%r13), %rax
movslq %esi, %rsi
movslq 0x18(%rax), %rcx
imulq %rcx, %rsi
movl (%rax), %r8d
movl 0x34(%rdi), %r15d
movq %rax, 0x10(%rsp)
addq 0x10(%rax), %rsi
cmpl $0x0, 0x18(%rdi)
setg %al
testl %edx, %edx
setle %r9b
orb %al, %r9b
jne 0xd1360
movl %edx, 0x4(%rsp)
movl %r8d, (%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x1(%rsi), %r12
movl $0xf, %ebp
xorl %r14d, %r14d
leal (%r14,%r10), %eax
movq (%r13), %rcx
cmpl 0x8(%rcx), %eax
jge 0xd1397
movq %r10, %rbx
callq 0xdbd07
testl %r15d, %r15d
jle 0xd1322
xorl %eax, %eax
movq 0x48(%r13), %rcx
movq 0x48(%rcx), %rcx
movzbl (%rcx,%rax), %ecx
shrl $0x4, %ecx
movb (%r12,%rax,2), %dl
andb $-0x10, %dl
orb %cl, %dl
movb %dl, (%r12,%rax,2)
andl %ecx, %ebp
incq %rax
cmpq %rax, %r15
jne 0xd12fc
movq 0x10(%rsp), %rax
movl 0x18(%rax), %ecx
incl %r14d
movq 0x48(%r13), %rdi
movl 0x40(%rdi), %eax
cmpl 0x38(%rdi), %eax
jge 0xd134f
movq %rbx, %r10
cmpl $0x0, 0x18(%rdi)
jg 0xd134f
movslq %ecx, %rax
addq %rax, %r12
cmpl 0x4(%rsp), %r14d
jl 0xd12dc
cmpl $0xf, %ebp
setne %al
movq 0x8(%rsp), %rsi
movl (%rsp), %r8d
jmp 0xd1365
xorl %r14d, %r14d
xorl %eax, %eax
addl $-0x7, %r8d
cmpl $0x3, %r8d
ja 0xd1385
testb %al, %al
je 0xd1385
leaq 0xa9e96(%rip), %rax     # 0x17b210
movq %rsi, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq *(%rax)
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x57e77(%rip), %rdi     # 0x129215
leaq 0x57deb(%rip), %rsi     # 0x129190
leaq 0x57ee9(%rip), %rcx     # 0x129295
movl $0x1c7, %edx            # imm = 0x1C7
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: ExportAlpha
static int ExportAlpha(WebPDecParams* const p, int y_pos, int max_lines_out) {
  const WebPRGBABuffer* const buf = &p->output->u.RGBA;
  uint8_t* const base_rgba = buf->rgba + (size_t)y_pos * buf->stride;
  const WEBP_CSP_MODE colorspace = p->output->colorspace;
  const int alpha_first =
      (colorspace == MODE_ARGB || colorspace == MODE_Argb);
  uint8_t* dst = base_rgba + (alpha_first ? 0 : 3);
  int num_lines_out = 0;
  const int is_premult_alpha = WebPIsPremultipliedMode(colorspace);
  uint32_t non_opaque = 0;
  const int width = p->scaler_a->dst_width;

  while (WebPRescalerHasPendingOutput(p->scaler_a) &&
         num_lines_out < max_lines_out) {
    assert(y_pos + num_lines_out < p->output->height);
    WebPRescalerExportRow(p->scaler_a);
    non_opaque |= WebPDispatchAlpha(p->scaler_a->dst, 0, width, 1, dst, 0);
    dst += buf->stride;
    ++num_lines_out;
  }
  if (is_premult_alpha && non_opaque) {
    WebPApplyAlphaMultiply(base_rgba, alpha_first,
                           width, num_lines_out, buf->stride);
  }
  return num_lines_out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %r12
movq (%rdi), %rbp
movq 0x48(%rdi), %rdi
movl (%rbp), %esi
cmpl $0x4, %esi
sete %r10b
cmpl $0x9, %esi
sete %al
movl 0x40(%rdi), %ecx
xorl %r13d, %r13d
cmpl 0x38(%rdi), %ecx
jge 0xd14eb
movslq %r15d, %r9
movslq 0x18(%rbp), %r8
imulq %r8, %r9
orb %al, %r10b
movl 0x34(%rdi), %eax
movl %eax, 0x4(%rsp)
addq 0x10(%rbp), %r9
cmpl $0x0, 0x18(%rdi)
setg %al
testl %edx, %edx
setle %cl
orb %al, %cl
jne 0xd14c3
movl %edx, 0xc(%rsp)
movl %esi, 0x8(%rsp)
movb %r10b, 0x3(%rsp)
movl %r10d, %eax
xorb $0x1, %al
movzbl %al, %eax
leaq (%rax,%rax,2), %rbx
movq %r9, 0x10(%rsp)
addq %r9, %rbx
xorl %r14d, %r14d
movl $0x1, %eax
movl %eax, %r13d
movq (%r12), %rax
cmpl 0x8(%rax), %r15d
jge 0xd14fd
callq 0xdbd07
movq 0x48(%r12), %rax
movq 0x48(%rax), %rdi
xorl %esi, %esi
movl 0x4(%rsp), %edx
movl $0x1, %ecx
movq %rbx, %r8
xorl %r9d, %r9d
leaq 0xa9d9b(%rip), %rax     # 0x17b218
callq *(%rax)
orl %eax, %r14d
movl 0x18(%rbp), %r8d
movq 0x48(%r12), %rdi
movl 0x40(%rdi), %eax
cmpl 0x38(%rdi), %eax
jge 0xd14ad
cmpl $0x0, 0x18(%rdi)
jg 0xd14ad
movslq %r8d, %rax
addq %rax, %rbx
incl %r15d
leal 0x1(%r13), %eax
cmpl 0xc(%rsp), %r13d
jl 0xd1446
testl %r14d, %r14d
setne %al
movb 0x3(%rsp), %r10b
movl 0x8(%rsp), %esi
movq 0x10(%rsp), %r9
jmp 0xd14c8
xorl %r13d, %r13d
xorl %eax, %eax
addl $-0x7, %esi
cmpl $0x3, %esi
ja 0xd14eb
testb %al, %al
je 0xd14eb
movzbl %r10b, %esi
leaq 0xa9d29(%rip), %rax     # 0x17b208
movq %r9, %rdi
movl 0x4(%rsp), %edx
movl %r13d, %ecx
callq *(%rax)
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x57d11(%rip), %rdi     # 0x129215
leaq 0x57c85(%rip), %rsi     # 0x129190
leaq 0x57dbb(%rip), %rcx     # 0x1292cd
movl $0x1a8, %edx            # imm = 0x1A8
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: EmitRescaledYUV
static int EmitRescaledYUV(const VP8Io* const io, WebPDecParams* const p) {
  const int mb_h = io->mb_h;
  const int uv_mb_h = (mb_h + 1) >> 1;
  WebPRescaler* const scaler = p->scaler_y;
  int num_lines_out = 0;
  if (WebPIsAlphaMode(p->output->colorspace) && io->a != NULL) {
    // Before rescaling, we premultiply the luma directly into the io->y
    // internal buffer. This is OK since these samples are not used for
    // intra-prediction (the top samples are saved in cache_y_/u_/v_).
    // But we need to cast the const away, though.
    WebPMultRows((uint8_t*)io->y, io->y_stride,
                 io->a, io->width, io->mb_w, mb_h, 0);
  }
  num_lines_out = Rescale(io->y, io->y_stride, mb_h, scaler);
  Rescale(io->u, io->uv_stride, uv_mb_h, p->scaler_u);
  Rescale(io->v, io->uv_stride, uv_mb_h, p->scaler_v);
  return num_lines_out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x10(%rdi), %r15d
movq (%rsi), %rax
movq 0x30(%rsi), %r12
movl (%rax), %eax
cmpl $0xc, %eax
ja 0xd15ca
movl $0x103a, %ecx           # imm = 0x103A
btl %eax, %ecx
jae 0xd15ca
movq 0x98(%r14), %rdx
testq %rdx, %rdx
je 0xd1578
movq 0x18(%r14), %rdi
movl 0x30(%r14), %esi
movl (%r14), %ecx
movl 0xc(%r14), %r8d
movl $0x0, (%rsp)
movl %r15d, %r9d
callq 0xd6d55
leal 0x1(%r15), %ebp
sarl %ebp
movq 0x18(%r14), %rdi
movl 0x30(%r14), %esi
movl %r15d, %edx
movq %r12, %rcx
callq 0xd16da
movl %eax, %r15d
movq 0x20(%r14), %rdi
movl 0x34(%r14), %esi
movq 0x38(%rbx), %rcx
movl %ebp, %edx
callq 0xd16da
movq 0x28(%r14), %rdi
movl 0x34(%r14), %esi
movq 0x40(%rbx), %rcx
movl %ebp, %edx
callq 0xd16da
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addl $-0xb, %eax
cmpl $-0x4, %eax
jae 0xd154e
jmp 0xd1578
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: EmitRescaledAlphaYUV
static int EmitRescaledAlphaYUV(const VP8Io* const io, WebPDecParams* const p,
                                int expected_num_lines_out) {
  const WebPYUVABuffer* const buf = &p->output->u.YUVA;
  uint8_t* const dst_a = buf->a + (size_t)p->last_y * buf->a_stride;
  if (io->a != NULL) {
    uint8_t* const dst_y = buf->y + (size_t)p->last_y * buf->y_stride;
    const int num_lines_out = Rescale(io->a, io->width, io->mb_h, p->scaler_a);
    assert(expected_num_lines_out == num_lines_out);
    if (num_lines_out > 0) {   // unmultiply the Y
      WebPMultRows(dst_y, buf->y_stride, dst_a, buf->a_stride,
                   p->scaler_a->dst_width, num_lines_out, 1);
    }
  } else if (buf->a != NULL) {
    // the user requested alpha, but there is none, set it to opaque.
    assert(p->last_y + expected_num_lines_out <= io->scaled_height);
    FillAlphaPlane(dst_a, io->scaled_width, expected_num_lines_out,
                   buf->a_stride);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq (%rsi), %r13
movq 0x28(%r13), %rdx
movslq 0x20(%rsi), %rcx
movslq 0x3c(%r13), %r12
movq %r12, %r14
imulq %rcx, %r14
addq %rdx, %r14
movq 0x98(%rdi), %rax
testq %rax, %rax
je 0xd165b
movq %rsi, %r15
movslq 0x30(%r13), %r12
imulq %rcx, %r12
addq 0x10(%r13), %r12
movl (%rdi), %esi
movl 0x10(%rdi), %edx
movq 0x48(%r15), %rcx
movq %rax, %rdi
callq 0xd16da
cmpl %ebx, %eax
jne 0xd169c
testl %ebx, %ebx
jle 0xd168c
movl 0x30(%r13), %esi
movl 0x3c(%r13), %ecx
movq 0x48(%r15), %rax
movl 0x34(%rax), %r8d
movl $0x1, (%rsp)
movq %r12, %rdi
movq %r14, %rdx
movl %ebx, %r9d
callq 0xd6d55
jmp 0xd168c
testq %rdx, %rdx
je 0xd168c
addl %ebx, %ecx
cmpl 0x90(%rdi), %ecx
jg 0xd16bb
testl %ebx, %ebx
jle 0xd168c
movslq 0x8c(%rdi), %r15
movq %r14, %rdi
movl $0xff, %esi
movq %r15, %rdx
callq 0x55f20
addq %r12, %r14
decl %ebx
jne 0xd1675
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x57c5a(%rip), %rdi     # 0x1292fd
leaq 0x57ae6(%rip), %rsi     # 0x129190
leaq 0x57c74(%rip), %rcx     # 0x129325
movl $0x116, %edx            # imm = 0x116
callq 0x55710
leaq 0x57cab(%rip), %rdi     # 0x12936d
leaq 0x57ac7(%rip), %rsi     # 0x129190
leaq 0x57c55(%rip), %rcx     # 0x129325
movl $0x11d, %edx            # imm = 0x11D
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: Rescale
static int Rescale(const uint8_t* src, int src_stride,
                   int new_lines, WebPRescaler* const wrk) {
  int num_lines_out = 0;
  while (new_lines > 0) {    // import new contributions of source rows.
    const int lines_in = WebPRescalerImport(wrk, new_lines, src, src_stride);
    src += lines_in * src_stride;
    new_lines -= lines_in;
    num_lines_out += WebPRescalerExport(wrk);    // emit output row(s)
  }
  return num_lines_out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0xd1725
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r12
xorl %r15d, %r15d
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
movl %r14d, %ecx
callq 0xce96f
movl %eax, %r13d
imull %r14d, %eax
cltq
addq %rax, %r12
movq %rbx, %rdi
callq 0xcea22
addl %eax, %r15d
subl %r13d, %ebp
jg 0xd16f7
jmp 0xd1728
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: GetAlphaSourceRow
static int GetAlphaSourceRow(const VP8Io* const io,
                             const uint8_t** alpha, int* const num_rows) {
  int start_y = io->mb_y;
  *num_rows = io->mb_h;

  // Compensate for the 1-line delay of the fancy upscaler.
  // This is similar to EmitFancyRGB().
  if (io->fancy_upsampling) {
    if (start_y == 0) {
      // We don't process the last row yet. It'll be done during the next call.
      --*num_rows;
    } else {
      --start_y;
      // Fortunately, *alpha data is persistent, so we can go back
      // one row and finish alpha blending, now that the fancy upscaler
      // completed the YUV->RGB interpolation.
      *alpha -= io->width;
    }
    if (io->crop_top + io->mb_y + io->mb_h == io->crop_bottom) {
      // If it's the very last call, we process all the remaining rows!
      *num_rows = io->crop_bottom - io->crop_top - start_y;
    }
  }
  return start_y;
}

// Assembly:
movl 0x8(%rdi), %eax
movl 0x10(%rdi), %ecx
movl %ecx, (%rdx)
cmpl $0x0, 0x58(%rdi)
je 0xd177e
testl %eax, %eax
je 0xd1756
decl %eax
movslq (%rdi), %r8
subq %r8, (%rsi)
jmp 0xd175f
decl %ecx
movl %ecx, (%rdx)
movl 0x10(%rdi), %ecx
xorl %eax, %eax
movl 0x80(%rdi), %r8d
movl 0x8(%rdi), %esi
addl %r8d, %esi
addl %ecx, %esi
cmpl 0x84(%rdi), %esi
jne 0xd177e
addl %eax, %r8d
subl %r8d, %esi
movl %esi, (%rdx)
retq
nop
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: VP8InitIoInternal
int VP8InitIoInternal(VP8Io* const io, int version) {
  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) {
    return 0;  // mismatch error
  }
  if (io != NULL) {
    memset(io, 0, sizeof(*io));
  }
  return 1;
}

// Assembly:
pushq %rbx
andl $0xffffff00, %esi       # imm = 0xFFFFFF00
xorl %ebx, %ebx
cmpl $0x200, %esi            # imm = 0x200
jne 0xd17ad
movl $0x1, %ebx
testq %rdi, %rdi
je 0xd17ad
movl $0xa0, %edx
xorl %esi, %esi
callq 0x55f20
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: VP8New
VP8Decoder* VP8New(void) {
  VP8Decoder* const dec = (VP8Decoder*)WebPSafeCalloc(1ULL, sizeof(*dec));
  if (dec != NULL) {
    SetOk(dec);
    WebPGetWorkerInterface()->Init(&dec->worker_);
    dec->ready_ = 0;
    dec->num_parts_minus_one_ = 0;
    InitGetCoeffs();
  }
  return dec;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl $0x1, %edi
movl $0xbd0, %esi            # imm = 0xBD0
callq 0x56580
movq %rax, %rbx
testq %rax, %rax
je 0xd183c
xorl %ebp, %ebp
movl %ebp, (%rbx)
leaq 0x5c971(%rip), %rax     # 0x12e148
movq %rax, 0x8(%rbx)
callq 0x56690
movq %rbx, %rdi
addq $0x98, %rdi
callq *(%rax)
movl %ebp, 0x4(%rbx)
movl %ebp, 0x1b0(%rbx)
movq 0x9cb6c(%rip), %rcx     # 0x16e368
movq 0x99f55(%rip), %r14     # 0x16b758
movq (%r14), %rax
cmpq %rax, %rcx
je 0xd183c
testq %rax, %rax
je 0xd1824
movl $0x2, %edi
callq *%rax
testl %eax, %eax
je 0xd1824
leaq 0xe85(%rip), %rax       # 0xd26a7
jmp 0xd182b
leaq 0x129f(%rip), %rax      # 0xd2aca
movq %rax, 0xa99be(%rip)     # 0x17b1f0
movq (%r14), %rax
movq %rax, 0x9cb2c(%rip)     # 0x16e368
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: VP8Clear
void VP8Clear(VP8Decoder* const dec) {
  if (dec == NULL) {
    return;
  }
  WebPGetWorkerInterface()->End(&dec->worker_);
  WebPDeallocateAlphaMemory(dec);
  WebPSafeFree(dec->mem_);
  dec->mem_ = NULL;
  dec->mem_size_ = 0;
  memset(&dec->br_, 0, sizeof(dec->br_));
  dec->ready_ = 0;
}

// Assembly:
testq %rdi, %rdi
je 0xd18d4
pushq %rbx
movq %rdi, %rbx
callq 0x56690
leaq 0x98(%rbx), %rdi
callq *0x28(%rax)
movq %rbx, %rdi
callq 0xf1474
movq 0xb48(%rbx), %rdi
callq 0x57290
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movl $0x0, 0x4(%rbx)
movups %xmm0, 0xb48(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: VP8SetError
int VP8SetError(VP8Decoder* const dec,
                VP8StatusCode error, const char* const msg) {
  // VP8_STATUS_SUSPENDED is only meaningful in incremental decoding.
  assert(dec->incremental_ || error != VP8_STATUS_SUSPENDED);
  // The oldest error reported takes precedence over the new one.
  if (dec->status_ == VP8_STATUS_OK) {
    dec->status_ = error;
    dec->error_msg_ = msg;
    dec->ready_ = 0;
  }
  return 0;
}

// Assembly:
cmpl $0x5, %esi
jne 0xd18e0
cmpl $0x0, 0x40(%rdi)
je 0xd18f5
cmpl $0x0, (%rdi)
jne 0xd18f2
movl %esi, (%rdi)
movq %rdx, 0x8(%rdi)
movl $0x0, 0x4(%rdi)
xorl %eax, %eax
retq
pushq %rax
leaq 0x57bcd(%rip), %rdi     # 0x1294ca
leaq 0x57bf9(%rip), %rsi     # 0x1294fd
leaq 0x57c04(%rip), %rcx     # 0x12950f
movl $0x5a, %edx
callq 0x55710