LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/webp_dec.c
// Function: GetFeatures
static VP8StatusCode GetFeatures(const uint8_t* const data, size_t data_size,
                                 WebPBitstreamFeatures* const features) {
  if (features == NULL || data == NULL) {
    return VP8_STATUS_INVALID_PARAM;
  }
  DefaultFeatures(features);

  // Only parse enough of the data to retrieve the features.
  return ParseHeadersInternal(data, data_size,
                              &features->width, &features->height,
                              &features->has_alpha, &features->has_animation,
                              &features->format, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x13c4f2
cmpq $0x0, -0x10(%rbp)
jne 0x13c4fb
movl $0x2, -0x4(%rbp)
jmp 0x13c548
movq -0x20(%rbp), %rdi
callq 0x13c5e0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x4, %rcx
movq -0x20(%rbp), %r8
addq $0x8, %r8
movq -0x20(%rbp), %r9
addq $0xc, %r9
movq -0x20(%rbp), %rax
addq $0x10, %rax
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x13b580
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/webp_dec.c
// Function: WebPInitDecoderConfigInternal
int WebPInitDecoderConfigInternal(WebPDecoderConfig* config,
                                  int version) {
  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) {
    return 0;   // version mismatch
  }
  if (config == NULL) {
    return 0;
  }
  memset(config, 0, sizeof(*config));
  DefaultFeatures(&config->input);
  if (!WebPInitDecBuffer(&config->output)) {
    return 0;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
sarl $0x8, %eax
cmpl $0x2, %eax
je 0x13c583
movl $0x0, -0x4(%rbp)
jmp 0x13c5ce
cmpq $0x0, -0x10(%rbp)
jne 0x13c593
movl $0x0, -0x4(%rbp)
jmp 0x13c5ce
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0xf0, %edx
callq 0x5a200
movq -0x10(%rbp), %rdi
callq 0x13c5e0
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x13bd90
cmpl $0x0, %eax
jne 0x13c5c7
movl $0x0, -0x4(%rbp)
jmp 0x13c5ce
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x24(%rbp), %eax
sarl $0x8, %eax
cmpl $0x2, %eax
je 0x13c65b
movl $0x2, -0x4(%rbp)
jmp 0x13c67f
cmpq $0x0, -0x20(%rbp)
jne 0x13c66b
movl $0x2, -0x4(%rbp)
jmp 0x13c67f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13c4d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x13c6ba
movl $0x2, -0x4(%rbp)
jmp 0x13c7fe
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13c4d0
movl %eax, -0x94(%rbp)
cmpl $0x0, -0x94(%rbp)
je 0x13c6fd
cmpl $0x7, -0x94(%rbp)
jne 0x13c6ef
movl $0x3, -0x4(%rbp)
jmp 0x13c7fe
movl -0x94(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x13c7fe
leaq -0x90(%rbp), %rdi
callq 0x13ba30
movq -0x20(%rbp), %rax
addq $0xa0, %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13b3e0
cmpl $0x0, %eax
je 0x13c7db
leaq -0x110(%rbp), %rdi
callq 0x13bd90
cmpl $0x0, %eax
jne 0x13c75c
movl $0x2, -0x4(%rbp)
jmp 0x13c7fe
movq -0x20(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x110(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10c(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x108(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x13bdb0
movl %eax, -0x94(%rbp)
cmpl $0x0, -0x94(%rbp)
jne 0x13c7cd
movq -0x20(%rbp), %rsi
addq $0x28, %rsi
leaq -0x110(%rbp), %rdi
callq 0x13ade0
movl %eax, -0x94(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x5c520
jmp 0x13c7f5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x13bdb0
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x13d6cf
jmp 0x13d6ee
leaq 0x7f037(%rip), %rdi     # 0x1bc70d
leaq 0x7f045(%rip), %rsi     # 0x1bc722
movl $0x58, %edx
leaq 0x7f054(%rip), %rcx     # 0x1bc73d
callq 0x598a0
cmpq $0x0, -0x20(%rbp)
je 0x13d6f7
jmp 0x13d716
leaq 0x7f085(%rip), %rdi     # 0x1bc783
leaq 0x7f01d(%rip), %rsi     # 0x1bc722
movl $0x59, %edx
leaq 0x7f02c(%rip), %rcx     # 0x1bc73d
callq 0x598a0
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x3fffffff, -0x2c(%rbp) # imm = 0x3FFFFFFF
cmpl $0x0, -0x24(%rbp)
jne 0x13d75e
cmpl $0x0, -0xc(%rbp)
jle 0x13d75e
movslq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
imulq %rcx, %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
subq $0x1, %rax
movslq -0xc(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x13d78d
cmpl $0x0, -0x8(%rbp)
jle 0x13d78d
movslq -0xc(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq %rcx, %rax
movslq -0x8(%rbp), %rcx
addq %rcx, %rax
subq $0x1, %rax
movslq -0x8(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x13d7ab
cmpl $0x0, -0x28(%rbp)
jle 0x13d7ab
cmpl $0x3fffffff, -0x24(%rbp) # imm = 0x3FFFFFFF
jg 0x13d7ab
cmpl $0x3fffffff, -0x28(%rbp) # imm = 0x3FFFFFFF
jle 0x13d7b4
movl $0x0, -0x4(%rbp)
jmp 0x13d7cd
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x2d(%rbp)
jge 0x13d86e
movq -0x8(%rbp), %rdi
callq 0x13d960
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x13d87a
jmp 0x13d94d
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x13d8ac
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x151130
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x13d90e
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
movq -0x8(%rbp), %rdx
imull 0x34(%rdx), %ecx
cmpl %ecx, %eax
jge 0x13d90c
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x2c(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x13d8ca
jmp 0x13d90e
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x18(%rax)
jmp 0x13d84d
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13d960
cmpl $0x0, %eax
je 0x13d9d5
movq -0x8(%rbp), %rdi
callq 0x1511b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13d9b3
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x13da12
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13da90
cmpl $0x0, %eax
jne 0x13da2e
movq $0x0, -0x8(%rbp)
jmp 0x13da7a
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
cmpq $0x0, %rax
jbe 0x13da3f
jmp 0x13da5e
leaq 0x7ed53(%rip), %rdi     # 0x1bc799
leaq 0x7ed5d(%rip), %rsi     # 0x1bc7aa
movl $0xc6, %edx
leaq 0x7ed63(%rip), %rcx     # 0x1bc7bc
callq 0x598a0
movq -0x10(%rbp), %rdi
imulq -0x18(%rbp), %rdi
callq 0x5c920
movq %rax, -0x20(%rbp)
jmp 0x13da72
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/utils.c
// Function: CheckSizeArgumentsOverflow
static int CheckSizeArgumentsOverflow(uint64_t nmemb, size_t size) {
  const uint64_t total_size = nmemb * size;
  if (nmemb == 0) return 1;
  if ((uint64_t)size > WEBP_MAX_ALLOCABLE_MEMORY / nmemb) return 0;
  if (!CheckSizeOverflow(total_size)) return 0;
#if defined(PRINT_MEM_INFO) && defined(MALLOC_FAIL_AT)
  if (countdown_to_fail > 0 && --countdown_to_fail == 0) {
    return 0;    // fake fail!
  }
#endif
#if defined(PRINT_MEM_INFO) && defined(MALLOC_LIMIT)
  if (mem_limit > 0) {
    const uint64_t new_total_mem = (uint64_t)total_mem + total_size;
    if (!CheckSizeOverflow(new_total_mem) ||
        new_total_mem > mem_limit) {
      return 0;   // fake fail!
    }
  }
#endif

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x13dabd
movl $0x1, -0x4(%rbp)
jmp 0x13db0a
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movabsq $0x400000000, %rax      # imm = 0x400000000
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jbe 0x13daec
movl $0x0, -0x4(%rbp)
jmp 0x13db0a
movq -0x20(%rbp), %rdi
callq 0x13de30
cmpl $0x0, %eax
jne 0x13db03
movl $0x0, -0x4(%rbp)
jmp 0x13db0a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x13db32
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13da90
cmpl $0x0, %eax
jne 0x13db4e
movq $0x0, -0x8(%rbp)
jmp 0x13db99
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
cmpq $0x0, %rax
jbe 0x13db5f
jmp 0x13db7e
leaq 0x7ec33(%rip), %rdi     # 0x1bc799
leaq 0x7ec3d(%rip), %rsi     # 0x1bc7aa
movl $0xd0, %edx
leaq 0x7ec6a(%rip), %rcx     # 0x1bc7e3
callq 0x598a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5c590
movq %rax, -0x20(%rbp)
jmp 0x13db91
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/utils.c
// Function: WebPSafeFree
void WebPSafeFree(void* const ptr) {
  if (ptr != NULL) {
    Increment(&num_free_calls);
    SubMem(ptr);
  }
  free(ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x13dbcd
jmp 0x13dbc5
jmp 0x13dbc7
jmp 0x13dbc9
jmp 0x13dbcb
jmp 0x13dbcd
movq -0x8(%rbp), %rdi
callq 0x59930
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x13dc4e
cmpq $0x0, -0x18(%rbp)
je 0x13dc4e
jmp 0x13dc6d
leaq 0x7ebb5(%rip), %rdi     # 0x1bc80a
leaq 0x7eb4e(%rip), %rsi     # 0x1bc7aa
movl $0xec, %edx
leaq 0x7ebbd(%rip), %rcx     # 0x1bc825
callq 0x598a0
movl -0xc(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl -0x20(%rbp), %eax
jl 0x13dc8d
movl -0x1c(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl -0x20(%rbp), %eax
jl 0x13dc8d
jmp 0x13dcac
leaq 0x7ebd4(%rip), %rdi     # 0x1bc868
leaq 0x7eb0f(%rip), %rsi     # 0x1bc7aa
movl $0xed, %edx
leaq 0x7eb7e(%rip), %rcx     # 0x1bc825
callq 0x598a0
jmp 0x13dcae
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x0, %eax
jle 0x13dcf3
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x593a0
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x13dcae
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x13dd20
cmpq $0x0, -0x10(%rbp)
je 0x13dd20
jmp 0x13dd3f
leaq 0x7eae3(%rip), %rdi     # 0x1bc80a
leaq 0x7ea7c(%rip), %rsi     # 0x1bc7aa
movl $0xf6, %edx
leaq 0x7eb63(%rip), %rcx     # 0x1bc89d
callq 0x598a0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x13dd61
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x13dd61
jmp 0x13dd80
leaq 0x7eb77(%rip), %rdi     # 0x1bc8df
leaq 0x7ea3b(%rip), %rsi     # 0x1bc7aa
movl $0xf7, %edx
leaq 0x7eb22(%rip), %rcx     # 0x1bc89d
callq 0x598a0
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x13dd94
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x13dd94
jmp 0x13ddb3
leaq 0x7eb7b(%rip), %rdi     # 0x1bc916
leaq 0x7ea08(%rip), %rsi     # 0x1bc7aa
movl $0xf8, %edx
leaq 0x7eaef(%rip), %rcx     # 0x1bc89d
callq 0x598a0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x50(%rax), %esi
shll $0x2, %esi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
shll $0x2, %ecx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %r8d
shll $0x2, %r8d
movq -0x8(%rbp), %rax
movl 0xc(%rax), %r9d
callq 0x5ccc0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc8(%rax)
jle 0x13f22d
callq 0x5ab60
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x98, %rdi
callq *%rax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x13f246
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13f277
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x13f280
movl $0x0, -0x4(%rbp)
jmp 0x13f2b9
cmpq $0x0, -0x18(%rbp)
je 0x13f291
movq -0x18(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x13f293
jmp 0x13f2b2
leaq 0x7d75c(%rip), %rdi     # 0x1bc9f6
leaq 0x7d69b(%rip), %rsi     # 0x1bc93c
movl $0x29d, %edx            # imm = 0x29D
leaq 0x7d772(%rip), %rcx     # 0x1bca1f
callq 0x598a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/frame_dec.c
// Function: VP8InitFrame
int VP8InitFrame(VP8Decoder* const dec, VP8Io* const io) {
  if (!InitThreadContext(dec)) return 0;  // call first. Sets dec->num_caches_.
  if (!AllocateMemory(dec)) return 0;
  InitIo(dec, io);
  VP8DspInit();  // Init critical function pointers and look-up tables.
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13f330
cmpl $0x0, %eax
jne 0x13f2f7
movl $0x0, -0x4(%rbp)
jmp 0x13f327
movq -0x10(%rbp), %rdi
callq 0x13f410
cmpl $0x0, %eax
jne 0x13f30e
movl $0x0, -0x4(%rbp)
jmp 0x13f327
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13f980
callq 0x14a0f0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/frame_dec.c
// Function: InitThreadContext
static int InitThreadContext(VP8Decoder* const dec) {
  dec->cache_id_ = 0;
  if (dec->mt_method_ > 0) {
    WebPWorker* const worker = &dec->worker_;
    if (!WebPGetWorkerInterface()->Reset(worker)) {
      return VP8SetError(dec, VP8_STATUS_OUT_OF_MEMORY,
                         "thread initialization failed.");
    }
    worker->data1 = dec;
    worker->data2 = (void*)&dec->thread_ctx_.io_;
    worker->hook = FinishRow;
    dec->num_caches_ =
      (dec->filter_type_ > 0) ? MT_CACHE_LINES : MT_CACHE_LINES - 1;
  } else {
    dec->num_caches_ = ST_CACHE_LINES;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0xcc(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc8(%rax)
jle 0x13f3ef
movq -0x10(%rbp), %rax
addq $0x98, %rax
movq %rax, -0x18(%rbp)
callq 0x5ab60
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
jne 0x13f397
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x7d8a9(%rip), %rdx     # 0x1bcc36
callq 0x142580
movl %eax, -0x4(%rbp)
jmp 0x13f404
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
addq $0xd8, %rcx
addq $0x20, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
leaq -0xb15(%rip), %rcx      # 0x13e8b0
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0xb68(%rax), %edx
movl $0x2, %ecx
movl $0x3, %eax
cmpl $0x0, %edx
cmovgl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xd0(%rax)
jmp 0x13f3fd
movq -0x10(%rbp), %rax
movl $0x1, 0xd0(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/frame_dec.c
// Function: InitIo
static void InitIo(VP8Decoder* const dec, VP8Io* io) {
  // prepare 'io'
  io->mb_y = 0;
  io->y = dec->cache_y_;
  io->u = dec->cache_u_;
  io->v = dec->cache_v_;
  io->y_stride = dec->cache_y_stride_;
  io->uv_stride = dec->cache_uv_stride_;
  io->a = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0xb28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0xb30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0xb38(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl 0xb40(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0xb44(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x98(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/frame_dec.c
// Function: DoTransform
static WEBP_INLINE void DoTransform(uint32_t bits, const int16_t* const src,
                                    uint8_t* const dst) {
  switch (bits >> 30) {
    case 3:
      VP8Transform(src, dst, 0);
      break;
    case 2:
      VP8TransformAC3(src, dst);
      break;
    case 1:
      VP8TransformDC(src, dst);
      break;
    default:
      break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %eax
shrl $0x1e, %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x13fa95
jmp 0x13fa53
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x13fa7f
jmp 0x13fa5d
movl -0x1c(%rbp), %eax
subl $0x3, %eax
jne 0x13faab
jmp 0x13fa67
leaq 0xd951a(%rip), %rax     # 0x218f88
movq (%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq *%rax
jmp 0x13faad
leaq 0xd950a(%rip), %rax     # 0x218f90
movq (%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
jmp 0x13faad
leaq 0xd9504(%rip), %rax     # 0x218fa0
movq (%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
jmp 0x13faad
jmp 0x13faad
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/frame_dec.c
// Function: CheckMode
static int CheckMode(int mb_x, int mb_y, int mode) {
  if (mode == B_DC_PRED) {
    if (mb_x == 0) {
      return (mb_y == 0) ? B_DC_PRED_NOTOPLEFT : B_DC_PRED_NOLEFT;
    } else {
      return (mb_y == 0) ? B_DC_PRED_NOTOP : B_DC_PRED;
    }
  }
  return mode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x13fb06
cmpl $0x0, -0x8(%rbp)
jne 0x13faf1
movl -0xc(%rbp), %edx
movl $0x5, %eax
movl $0x6, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x13fb0c
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x13fb0c
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/frame_dec.c
// Function: DoUVTransform
static void DoUVTransform(uint32_t bits, const int16_t* const src,
                          uint8_t* const dst) {
  if (bits & 0xff) {    // any non-zero coeff at all?
    if (bits & 0xaa) {  // any non-zero AC coefficient?
      VP8TransformUV(src, dst);   // note we don't use the AC3 variant for U/V
    } else {
      VP8TransformDCUV(src, dst);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
cmpl $0x0, %eax
je 0x13fb79
movl -0x4(%rbp), %eax
andl $0xaa, %eax
cmpl $0x0, %eax
je 0x13fb63
leaq 0xd9444(%rip), %rax     # 0x218f98
movq (%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
jmp 0x13fb77
leaq 0xd943e(%rip), %rax     # 0x218fa8
movq (%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
jmp 0x13fb79
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/frame_dec.c
// Function: FilterRow
static void FilterRow(const VP8Decoder* const dec) {
  int mb_x;
  const int mb_y = dec->thread_ctx_.mb_y_;
  assert(dec->thread_ctx_.filter_row_);
  for (mb_x = dec->tl_mb_x_; mb_x < dec->br_mb_x_; ++mb_x) {
    DoFilter(dec, mb_x, mb_y);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xdc(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xe0(%rax)
je 0x13fba8
jmp 0x13fbc7
leaq 0x7cf1e(%rip), %rdi     # 0x1bcacd
leaq 0x7cd86(%rip), %rsi     # 0x1bc93c
movl $0x100, %edx            # imm = 0x100
leaq 0x7cf28(%rip), %rcx     # 0x1bcaea
callq 0x598a0
movq -0x8(%rbp), %rax
movl 0x1a0(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1a8(%rcx), %eax
jge 0x13fbfd
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x13fd70
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13fbd4
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/frame_dec.c
// Function: DitherRow
static void DitherRow(VP8Decoder* const dec) {
  int mb_x;
  assert(dec->dither_);
  for (mb_x = dec->tl_mb_x_; mb_x < dec->br_mb_x_; ++mb_x) {
    const VP8ThreadContext* const ctx = &dec->thread_ctx_;
    const VP8MBData* const data = ctx->mb_data_ + mb_x;
    const int cache_id = ctx->id_;
    const int uv_bps = dec->cache_uv_stride_;
    if (data->dither_ >= MIN_DITHER_AMP) {
      uint8_t* const u_dst = dec->cache_u_ + cache_id * 8 * uv_bps + mb_x * 8;
      uint8_t* const v_dst = dec->cache_v_ + cache_id * 8 * uv_bps + mb_x * 8;
      Dither8x8(&dec->dithering_rg_, u_dst, uv_bps, data->dither_);
      Dither8x8(&dec->dithering_rg_, v_dst, uv_bps, data->dither_);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x338(%rax)
je 0x13fc2b
jmp 0x13fc4a
leaq 0x7cf1c(%rip), %rdi     # 0x1bcb4e
leaq 0x7cd03(%rip), %rsi     # 0x1bc93c
movl $0x175, %edx            # imm = 0x175
leaq 0x7cf16(%rip), %rcx     # 0x1bcb5b
callq 0x598a0
movq -0x8(%rbp), %rax
movl 0x1a0(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1a8(%rcx), %eax
jge 0x13fd66
movq -0x8(%rbp), %rax
addq $0xd8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0xb44(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x31c(%rax), %eax
cmpl $0x4, %eax
jl 0x13fd56
movq -0x8(%rbp), %rax
movq 0xb30(%rax), %rax
movl -0x24(%rbp), %ecx
shll $0x3, %ecx
imull -0x28(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movl -0xc(%rbp), %ecx
shll $0x3, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0xb38(%rax), %rax
movl -0x24(%rbp), %ecx
shll $0x3, %ecx
imull -0x28(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movl -0xc(%rbp), %ecx
shll $0x3, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
addq $0x33c, %rdi            # imm = 0x33C
movq -0x30(%rbp), %rsi
movl -0x28(%rbp), %edx
movq -0x20(%rbp), %rax
movzbl 0x31c(%rax), %ecx
callq 0x140070
movq -0x8(%rbp), %rdi
addq $0x33c, %rdi            # imm = 0x33C
movq -0x38(%rbp), %rsi
movl -0x28(%rbp), %edx
movq -0x20(%rbp), %rax
movzbl 0x31c(%rax), %ecx
callq 0x140070
jmp 0x13fd58
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13fc57
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x64(%rbp)
cmpl $0x40, -0x64(%rbp)
jge 0x1400b9
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
movl $0x8, %esi
callq 0x1400e0
movb %al, %cl
movslq -0x64(%rbp), %rax
movb %cl, -0x60(%rbp,%rax)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x14008d
leaq 0xd8f50(%rip), %rax     # 0x219010
movq (%rax), %rax
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/utils/random_utils.h
// Function: VP8RandomBits2
static WEBP_INLINE int VP8RandomBits2(VP8Random* const rg, int num_bits,
                                      int amp) {
  int diff;
  assert(num_bits + VP8_RANDOM_DITHER_FIX <= 31);
  diff = rg->tab_[rg->index1_] - rg->tab_[rg->index2_];
  if (diff < 0) diff += (1u << 31);
  rg->tab_[rg->index1_] = diff;
  if (++rg->index1_ == VP8_RANDOM_TABLE_SIZE) rg->index1_ = 0;
  if (++rg->index2_ == VP8_RANDOM_TABLE_SIZE) rg->index2_ = 0;
  // sign-extend, 0-center
  diff = (int)((uint32_t)diff << 1) >> (32 - num_bits);
  diff = (diff * amp) >> VP8_RANDOM_DITHER_FIX;  // restrict range
  diff += 1 << (num_bits - 1);                   // shift back to 0.5-center
  return diff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x8, %eax
cmpl $0x1f, %eax
jg 0x1400ff
jmp 0x14011e
leaq 0x7ca77(%rip), %rdi     # 0x1bcb7d
leaq 0x7ca97(%rip), %rsi     # 0x1bcba4
movl $0x2a, %edx
leaq 0x7caee(%rip), %rcx     # 0x1bcc07
callq 0x598a0
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movl 0x8(%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rdx
movslq 0x4(%rdx), %rdx
subl 0x8(%rcx,%rdx,4), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x140151
movl -0x14(%rbp), %eax
addl $0x80000000, %eax       # imm = 0x80000000
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movl %edx, 0x8(%rax,%rcx,4)
movq -0x8(%rbp), %rcx
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
cmpl $0x37, %eax
jne 0x14017d
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x4(%rcx)
cmpl $0x37, %eax
jne 0x14019a
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movl -0x14(%rbp), %eax
shll %eax
movl $0x20, %ecx
subl -0xc(%rbp), %ecx
sarl %cl, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
imull -0x10(%rbp), %eax
sarl $0x8, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x39(%rip), %rcx        # 0x140250
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
leaq 0xfa(%rip), %rcx        # 0x140320
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
leaq 0x33b(%rip), %rcx       # 0x140570
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x14028d
jmp 0x1402ac
leaq 0x7ca6c(%rip), %rdi     # 0x1bcd00
leaq 0x7ca75(%rip), %rsi     # 0x1bcd10
movl $0x277, %edx            # imm = 0x277
leaq 0x7ca7a(%rip), %rcx     # 0x1bcd21
callq 0x598a0
cmpl $0x0, -0x1c(%rbp)
jle 0x1402b8
cmpl $0x0, -0x20(%rbp)
jg 0x1402c1
movl $0x0, -0x4(%rbp)
jmp 0x14030a
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x1402f6
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
callq *%rax
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq -0x30(%rbp), %rdx
movslq 0x8(%rdx), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x30(%rax), %esi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movl 0x34(%rax), %r8d
movq -0x38(%rbp), %r9
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ebx
movq -0x18(%rbp), %rax
movl 0xc(%rax), %r11d
movq -0x18(%rbp), %rax
movl 0x10(%rax), %r10d
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, %r14d
leaq 0xd84e2(%rip), %rax     # 0x219330
movq (%rax,%r14,8), %rax
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x1539e0
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: EmitYUV
static int EmitYUV(const VP8Io* const io, WebPDecParams* const p) {
  WebPDecBuffer* output = p->output;
  const WebPYUVABuffer* const buf = &output->u.YUVA;
  uint8_t* const y_dst = buf->y + (size_t)io->mb_y * buf->y_stride;
  uint8_t* const u_dst = buf->u + (size_t)(io->mb_y >> 1) * buf->u_stride;
  uint8_t* const v_dst = buf->v + (size_t)(io->mb_y >> 1) * buf->v_stride;
  const int mb_w = io->mb_w;
  const int mb_h = io->mb_h;
  const int uv_w = (mb_w + 1) / 2;
  const int uv_h = (mb_h + 1) / 2;
  WebPCopyPlane(io->y, io->y_stride, y_dst, buf->y_stride, mb_w, mb_h);
  WebPCopyPlane(io->u, io->uv_stride, u_dst, buf->u_stride, uv_w, uv_h);
  WebPCopyPlane(io->v, io->uv_stride, v_dst, buf->v_stride, uv_w, uv_h);
  return io->mb_h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq -0x20(%rbp), %rdx
movslq 0x20(%rdx), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
sarl %ecx
movslq %ecx, %rcx
movq -0x20(%rbp), %rdx
movslq 0x24(%rdx), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
sarl %ecx
movslq %ecx, %rcx
movq -0x20(%rbp), %rdx
movslq 0x28(%rdx), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x44(%rbp)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x30(%rax), %esi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
movl 0x20(%rax), %ecx
movl -0x3c(%rbp), %r8d
movl -0x40(%rbp), %r9d
callq 0x5ccc0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x34(%rax), %esi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rax
movl 0x24(%rax), %ecx
movl -0x44(%rbp), %r8d
movl -0x48(%rbp), %r9d
callq 0x5ccc0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x34(%rax), %esi
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rax
movl 0x28(%rax), %ecx
movl -0x44(%rbp), %r8d
movl -0x48(%rbp), %r9d
callq 0x5ccc0
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq -0x28(%rbp), %rdx
movslq 0x2c(%rdx), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x30(%rbp), %eax
jne 0x141682
jmp 0x1416a1
leaq 0x7b944(%rip), %rdi     # 0x1bcfcd
leaq 0x7b680(%rip), %rsi     # 0x1bcd10
movl $0x86, %edx
leaq 0x7b950(%rip), %rcx     # 0x1bcfec
callq 0x598a0
cmpq $0x0, -0x20(%rbp)
je 0x141702
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x141700
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
shlq $0x0, %rdx
callq 0x593a0
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1416af
jmp 0x141725
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x141723
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
movq -0x28(%rbp), %rax
movl 0x2c(%rax), %ecx
callq 0x1421f0
jmp 0x141725
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)