LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8l_dec.c
// Function: EmitRowsYUVA
static int EmitRowsYUVA(const VP8LDecoder* const dec,
                        const uint8_t* in, int in_stride,
                        int mb_w, int num_rows) {
  int y_pos = dec->last_out_row_;
  while (num_rows-- > 0) {
    ConvertToYUVA((const uint32_t*)in, mb_w, y_pos, dec->output_);
    in += in_stride;
    ++y_pos;
  }
  return y_pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x94(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
jle 0x148dba
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x20(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
callq 0x148f80
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x148d77
movl -0x20(%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/vp8l_dec.c
// Function: Export
static int Export(WebPRescaler* const rescaler, WEBP_CSP_MODE colorspace,
                  int rgba_stride, uint8_t* const rgba) {
  uint32_t* const src = (uint32_t*)rescaler->dst;
  uint8_t* dst = rgba;
  const int dst_width = rescaler->dst_width;
  int num_lines_out = 0;
  while (WebPRescalerHasPendingOutput(rescaler)) {
    WebPRescalerExportRow(rescaler);
    WebPMultARGBRow(src, dst_width, 1);
    VP8LConvertFromBGRA(src, dst_width, colorspace, dst);
    dst += rgba_stride;
    ++num_lines_out;
  }
  return num_lines_out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x148e80
cmpl $0x0, %eax
je 0x148e69
movq -0x8(%rbp), %rdi
callq 0x1511b0
leaq 0xd001f(%rip), %rax     # 0x218e48
movq (%rax), %rax
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl $0x1, %edx
callq *%rax
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0xc(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x14f4b0
movl -0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x148e0b
movl -0x30(%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/vp8l_dec.c
// Function: ExportYUVA
static int ExportYUVA(const VP8LDecoder* const dec, int y_pos) {
  WebPRescaler* const rescaler = dec->rescaler;
  uint32_t* const src = (uint32_t*)rescaler->dst;
  const int dst_width = rescaler->dst_width;
  int num_lines_out = 0;
  while (WebPRescalerHasPendingOutput(rescaler)) {
    WebPRescalerExportRow(rescaler);
    WebPMultARGBRow(src, dst_width, 1);
    ConvertToYUVA(src, dst_width, y_pos, dec->output_);
    ++y_pos;
    ++num_lines_out;
  }
  return num_lines_out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x188(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x148e80
cmpl $0x0, %eax
je 0x148f75
movq -0x18(%rbp), %rdi
callq 0x1511b0
leaq 0xcff0f(%rip), %rax     # 0x218e48
movq (%rax), %rax
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movl $0x1, %edx
callq *%rax
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
callq 0x148f80
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x148f1b
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8l_dec.c
// Function: ConvertToYUVA
static void ConvertToYUVA(const uint32_t* const src, int width, int y_pos,
                          const WebPDecBuffer* const output) {
  const WebPYUVABuffer* const buf = &output->u.YUVA;

  // first, the luma plane
  WebPConvertARGBToY(src, buf->y + y_pos * buf->y_stride, width);

  // then U/V planes
  {
    uint8_t* const u = buf->u + (y_pos >> 1) * buf->u_stride;
    uint8_t* const v = buf->v + (y_pos >> 1) * buf->v_stride;
    // even lines: store values
    // odd lines: average with previous values
    WebPConvertARGBToUV(src, u, v, width, !(y_pos & 1));
  }
  // Lastly, store alpha if needed.
  if (buf->a != NULL) {
    uint8_t* const a = buf->a + y_pos * buf->a_stride;
#if defined(WORDS_BIGENDIAN)
    WebPExtractAlpha((uint8_t*)src + 0, 0, width, 1, a, 0);
#else
    WebPExtractAlpha((uint8_t*)src + 3, 0, width, 1, a, 0);
#endif
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
leaq 0xd0407(%rip), %rax     # 0x2193b0
movq (%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq (%rcx), %rsi
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rdx
imull 0x20(%rdx), %ecx
movslq %ecx, %rcx
addq %rcx, %rsi
movl -0xc(%rbp), %edx
callq *%rax
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
sarl %ecx
movq -0x20(%rbp), %rdx
imull 0x24(%rdx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x10(%rbp), %ecx
sarl %ecx
movq -0x20(%rbp), %rdx
imull 0x28(%rdx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
leaq 0xd03a6(%rip), %rax     # 0x2193b8
movq (%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
andl $0x1, %r8d
cmpl $0x0, %r8d
setne %r8b
xorb $-0x1, %r8b
andb $0x1, %r8b
movzbl %r8b, %r8d
callq *%rax
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x149090
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rdx
imull 0x2c(%rdx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
leaq 0xcfe07(%rip), %rax     # 0x218e78
movq (%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x3, %rdi
movl -0xc(%rbp), %edx
movq -0x38(%rbp), %r8
xorl %r9d, %r9d
movl $0x1, %ecx
movl %r9d, %esi
callq *%rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing.c
// Function: WebPMultARGBRow_C
void WebPMultARGBRow_C(uint32_t* const ptr, int width, int inverse) {
  int x;
  for (x = 0; x < width; ++x) {
    const uint32_t argb = ptr[x];
    if (argb < 0xff000000u) {      // alpha < 255
      if (argb <= 0x00ffffffu) {   // alpha == 0
        ptr[x] = 0;
      } else {
        const uint32_t alpha = (argb >> 24) & 0xff;
        const uint32_t scale = GetScale(alpha, inverse);
        uint32_t out = argb & 0xff000000u;
        out |= Mult(argb >>  0, scale) <<  0;
        out |= Mult(argb >>  8, scale) <<  8;
        out |= Mult(argb >> 16, scale) << 16;
        ptr[x] = out;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x149192
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
cmpl $0xff000000, -0x18(%rbp) # imm = 0xFF000000
jae 0x149182
cmpl $0xffffff, -0x18(%rbp)  # imm = 0xFFFFFF
ja 0x1490fd
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x149180
movl -0x18(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x1491a0
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
andl $0xff000000, %eax       # imm = 0xFF000000
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
shrl $0x0, %eax
movl -0x20(%rbp), %esi
movzbl %al, %edi
callq 0x1491d0
shll $0x0, %eax
orl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
shrl $0x8, %eax
movl -0x20(%rbp), %esi
movzbl %al, %edi
callq 0x1491d0
shll $0x8, %eax
orl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
shrl $0x10, %eax
movl -0x20(%rbp), %esi
movzbl %al, %edi
callq 0x1491d0
shll $0x10, %eax
orl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x149182
jmp 0x149184
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1490b9
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing.c
// Function: WebPMultRow_C
void WebPMultRow_C(uint8_t* WEBP_RESTRICT const ptr,
                   const uint8_t* WEBP_RESTRICT const alpha,
                   int width, int inverse) {
  int x;
  for (x = 0; x < width; ++x) {
    const uint32_t a = alpha[x];
    if (a != 255) {
      if (a == 0) {
        ptr[x] = 0;
      } else {
        const uint32_t scale = GetScale(a, inverse);
        ptr[x] = Mult(ptr[x], scale);
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1492c1
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x20(%rbp)
cmpl $0xff, -0x20(%rbp)
je 0x1492b4
cmpl $0x0, -0x20(%rbp)
jne 0x149281
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x1492b2
movl -0x20(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x1491a0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movl -0x24(%rbp), %esi
movzbl %al, %edi
callq 0x1491d0
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x1492b4
jmp 0x1492b6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x14924d
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing.c
// Function: WebPMultARGBRows
void WebPMultARGBRows(uint8_t* ptr, int stride, int width, int num_rows,
                      int inverse) {
  int n;
  for (n = 0; n < num_rows; ++n) {
    WebPMultARGBRow((uint32_t*)ptr, width, inverse);
    ptr += stride;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x149327
movq 0xcfb49(%rip), %rax     # 0x218e48
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x18(%rbp), %edx
callq *%rax
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1492f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing.c
// Function: WebPMultRows
void WebPMultRows(uint8_t* WEBP_RESTRICT ptr, int stride,
                  const uint8_t* WEBP_RESTRICT alpha, int alpha_stride,
                  int width, int num_rows, int inverse) {
  int n;
  for (n = 0; n < num_rows; ++n) {
    WebPMultRow(ptr, alpha, width, inverse);
    ptr += stride;
    alpha += alpha_stride;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1493a4
movq 0xcfae9(%rip), %rax     # 0x218e50
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
movl 0x10(%rbp), %ecx
callq *%rax
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)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x149358
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing.c
// Function: PackRGB_C
static void PackRGB_C(const uint8_t* WEBP_RESTRICT r,
                      const uint8_t* WEBP_RESTRICT g,
                      const uint8_t* WEBP_RESTRICT b,
                      int len, int step, uint32_t* WEBP_RESTRICT out) {
  int i, offset = 0;
  for (i = 0; i < len; ++i) {
    out[i] = MakeARGB32(0xff, r[offset], g[offset], b[offset]);
    offset += step;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x149784
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %esi
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %edx
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movl $0xff, %edi
callq 0x149e00
movl %eax, %edx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x14972d
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing.c
// Function: ApplyAlphaMultiply_C
static void ApplyAlphaMultiply_C(uint8_t* rgba, int alpha_first,
                                 int w, int h, int stride) {
  while (h-- > 0) {
    uint8_t* const rgb = rgba + (alpha_first ? 1 : 0);
    const uint8_t* const alpha = rgba + (alpha_first ? 0 : 3);
    int i;
    for (i = 0; i < w; ++i) {
      const uint32_t a = alpha[4 * i];
      if (a != 0xff) {
        const uint32_t mult = MULTIPLIER(a);
        rgb[4 * i + 0] = PREMULTIPLY(rgb[4 * i + 0], mult);
        rgb[4 * i + 1] = PREMULTIPLY(rgb[4 * i + 1], mult);
        rgb[4 * i + 2] = PREMULTIPLY(rgb[4 * i + 2], mult);
      }
    }
    rgba += stride;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
jle 0x1498e9
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %esi
xorl %ecx, %ecx
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %esi
movl $0x3, %ecx
xorl %edx, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1498d3
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x30(%rbp)
cmpl $0xff, -0x30(%rbp)
je 0x1498c3
imull $0x8081, -0x30(%rbp), %eax # imm = 0x8081
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
shll $0x2, %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
imull -0x34(%rbp), %eax
shrl $0x17, %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
shll $0x2, %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
shll $0x2, %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
imull -0x34(%rbp), %eax
shrl $0x17, %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
shll $0x2, %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
shll $0x2, %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
imull -0x34(%rbp), %eax
shrl $0x17, %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
shll $0x2, %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x1498c5
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1497fc
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x1497a5
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing.c
// Function: DispatchAlpha_C
static int DispatchAlpha_C(const uint8_t* WEBP_RESTRICT alpha, int alpha_stride,
                           int width, int height,
                           uint8_t* WEBP_RESTRICT dst, int dst_stride) {
  uint32_t alpha_mask = 0xff;
  int i, j;

  for (j = 0; j < height; ++j) {
    for (i = 0; i < width; ++i) {
      const uint32_t alpha_value = alpha[i];
      dst[4 * i] = alpha_value;
      alpha_mask &= alpha_value;
    }
    alpha += alpha_stride;
    dst += dst_stride;
  }

  return (alpha_mask != 0xff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0xff, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x149993
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x149966
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x34(%rbp), %eax
andl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x149926
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x149917
cmpl $0xff, -0x28(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing.c
// Function: DispatchAlphaToGreen_C
static void DispatchAlphaToGreen_C(const uint8_t* WEBP_RESTRICT alpha,
                                   int alpha_stride, int width, int height,
                                   uint32_t* WEBP_RESTRICT dst,
                                   int dst_stride) {
  int i, j;
  for (j = 0; j < height; ++j) {
    for (i = 0; i < width; ++i) {
      dst[i] = alpha[i] << 8;  // leave A/R/B channels zero'd.
    }
    alpha += alpha_stride;
    dst += dst_stride;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x149a3d
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x149a0c
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %edx
shll $0x8, %edx
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1499df
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1499d0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing.c
// Function: ExtractAlpha_C
static int ExtractAlpha_C(const uint8_t* WEBP_RESTRICT argb, int argb_stride,
                          int width, int height,
                          uint8_t* WEBP_RESTRICT alpha, int alpha_stride) {
  uint8_t alpha_mask = 0xff;
  int i, j;

  for (j = 0; j < height; ++j) {
    for (i = 0; i < width; ++i) {
      const uint8_t alpha_value = argb[4 * i];
      alpha[i] = alpha_value;
      alpha_mask &= alpha_value;
    }
    argb += argb_stride;
    alpha += alpha_stride;
  }
  return (alpha_mask == 0xff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movb $-0x1, -0x25(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x149ae1
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x149ab4
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %dl
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movzbl -0x31(%rbp), %ecx
movzbl -0x25(%rbp), %eax
andl %ecx, %eax
movb %al, -0x25(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x149a73
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x149a64
movzbl -0x25(%rbp), %eax
cmpl $0xff, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing.c
// Function: ApplyAlphaMultiply4444_C
static WEBP_INLINE void ApplyAlphaMultiply4444_C(uint8_t* rgba4444,
                                                 int w, int h, int stride,
                                                 int rg_byte_pos /* 0 or 1 */) {
  while (h-- > 0) {
    int i;
    for (i = 0; i < w; ++i) {
      const uint32_t rg = rgba4444[2 * i + rg_byte_pos];
      const uint32_t ba = rgba4444[2 * i + (rg_byte_pos ^ 1)];
      const uint8_t a = ba & 0x0f;
      const uint32_t mult = MULTIPLIER(a);
      const uint8_t r = multiply(dither_hi(rg), mult);
      const uint8_t g = multiply(dither_lo(rg), mult);
      const uint8_t b = multiply(dither_hi(ba), mult);
      rgba4444[2 * i + rg_byte_pos] = (r & 0xf0) | ((g >> 4) & 0x0f);
      rgba4444[2 * i + (rg_byte_pos ^ 1)] = (b & 0xf0) | a;
    }
    rgba4444 += stride;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rbp)
cmpl $0x0, %eax
jle 0x149d97
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x149d81
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
movl -0x18(%rbp), %edx
xorl $0x1, %edx
addl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
andl $0xf, %eax
movb %al, -0x25(%rbp)
movzbl -0x25(%rbp), %eax
imull $0x1111, %eax, %eax     # imm = 0x1111
movl %eax, -0x2c(%rbp)
movl -0x20(%rbp), %eax
movzbl %al, %edi
callq 0x149dc0
movl -0x2c(%rbp), %esi
movzbl %al, %edi
callq 0x149da0
movb %al, -0x2d(%rbp)
movl -0x20(%rbp), %eax
movzbl %al, %edi
callq 0x149de0
movl -0x2c(%rbp), %esi
movzbl %al, %edi
callq 0x149da0
movb %al, -0x2e(%rbp)
movl -0x24(%rbp), %eax
movzbl %al, %edi
callq 0x149dc0
movl -0x2c(%rbp), %esi
movzbl %al, %edi
callq 0x149da0
movb %al, -0x2f(%rbp)
movzbl -0x2d(%rbp), %eax
andl $0xf0, %eax
movzbl -0x2e(%rbp), %ecx
sarl $0x4, %ecx
andl $0xf, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movzbl -0x2f(%rbp), %eax
andl $0xf0, %eax
movzbl -0x25(%rbp), %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
movl -0x18(%rbp), %esi
xorl $0x1, %esi
addl %esi, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x149c84
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x149c69
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/cpu.c
// Function: GetCPUInfo
static WEBP_INLINE void GetCPUInfo(int cpu_info[4], int info_type) {
  __asm__ volatile (
    "cpuid\n"
    : "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]), "=d"(cpu_info[3])
    : "a"(info_type), "c"(0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %r8
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
xorl %ecx, %ecx
cpuid
movl %eax, %r9d
movq -0x28(%rbp), %rax
movl %ecx, %esi
movq -0x20(%rbp), %rcx
movl %r9d, (%r8)
movl %ebx, 0x4(%rdi)
movl %esi, 0x8(%rcx)
movl %edx, 0xc(%rax)
popq %rbx
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/cpu.c
// Function: CheckSlowModel
static int CheckSlowModel(int info) {
  // Table listing display models with longer latencies for the bsr instruction
  // (ie 2 cycles vs 10/16 cycles) and some SSSE3 instructions like pshufb.
  // Refer to Intel 64 and IA-32 Architectures Optimization Reference Manual.
  static const uint8_t kSlowModels[] = {
    0x37, 0x4a, 0x4d,  // Silvermont Microarchitecture
    0x1c, 0x26, 0x27   // Atom Microarchitecture
  };
  const uint32_t model = ((info & 0xf0000) >> 12) | ((info >> 4) & 0xf);
  const uint32_t family = (info >> 8) & 0xf;
  if (family == 0x06) {
    size_t i;
    for (i = 0; i < sizeof(kSlowModels) / sizeof(kSlowModels[0]); ++i) {
      if (model == kSlowModels[i]) return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xf0000, %eax          # imm = 0xF0000
sarl $0xc, %eax
movl -0x8(%rbp), %ecx
sarl $0x4, %ecx
andl $0xf, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
sarl $0x8, %eax
andl $0xf, %eax
movl %eax, -0x10(%rbp)
cmpl $0x6, -0x10(%rbp)
jne 0x14a0b2
movq $0x0, -0x18(%rbp)
cmpq $0x6, -0x18(%rbp)
jae 0x14a0b0
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rdx
leaq 0x742b7(%rip), %rcx     # 0x1be346
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x14a0a0
movl $0x1, -0x4(%rbp)
jmp 0x14a0b9
jmp 0x14a0a2
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x14a07a
jmp 0x14a0b2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/cpu.c
// Function: xgetbv
static WEBP_INLINE uint64_t xgetbv(void) {
  const uint32_t ecx = 0;
  uint32_t eax, edx;
  // Use the raw opcode for xgetbv for compatibility with older toolchains.
  __asm__ volatile (
    ".byte 0x0f, 0x01, 0xd0\n"
    : "=a"(eax), "=d"(edx) : "c" (ecx));
  return ((uint64_t)edx << 32) | eax;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
xorl %ecx, %ecx
xgetbv
movl %eax, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %eax
shlq $0x20, %rax
movl -0x8(%rbp), %ecx
orq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: TransformDC_C
static void TransformDC_C(const int16_t* in, uint8_t* dst) {
  const int DC = in[0] + 4;
  int i, j;
  for (j = 0; j < 4; ++j) {
    for (i = 0; i < 4; ++i) {
      STORE(i, j, DC);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movswl (%rax), %eax
addl $0x4, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x14adf9
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x14adec
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %edx
shll $0x5, %edx
addl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edi
movl -0x14(%rbp), %eax
sarl $0x3, %eax
addl %eax, %edi
callq 0x14c930
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %esi
shll $0x5, %esi
addl %esi, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x14ada1
jmp 0x14adee
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x14ad94
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: TransformDCUV_C
static void TransformDCUV_C(const int16_t* in, uint8_t* dst) {
  if (in[0 * 16]) VP8TransformDC(in + 0 * 16, dst);
  if (in[1 * 16]) VP8TransformDC(in + 1 * 16, dst + 4);
  if (in[2 * 16]) VP8TransformDC(in + 2 * 16, dst + 4 * BPS);
  if (in[3 * 16]) VP8TransformDC(in + 3 * 16, dst + 4 * BPS + 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpw $0x0, (%rax)
je 0x14b13b
movq 0xcde6f(%rip), %rax     # 0x218fa0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq -0x8(%rbp), %rax
cmpw $0x0, 0x20(%rax)
je 0x14b15f
movq 0xcde53(%rip), %rax     # 0x218fa0
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq *%rax
movq -0x8(%rbp), %rax
cmpw $0x0, 0x40(%rax)
je 0x14b186
movq 0xcde2f(%rip), %rax     # 0x218fa0
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
callq *%rax
movq -0x8(%rbp), %rax
cmpw $0x0, 0x60(%rax)
je 0x14b1b1
movq 0xcde08(%rip), %rax     # 0x218fa0
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
addq $0x4, %rsi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: VFilter16i_C
static void VFilter16i_C(uint8_t* p, int stride,
                         int thresh, int ithresh, int hev_thresh) {
  int k;
  for (k = 3; k > 0; --k) {
    p += 4 * stride;
    FilterLoop24_C(p, stride, 1, 16, thresh, ithresh, hev_thresh);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl $0x3, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x14b279
movl -0xc(%rbp), %ecx
shll $0x2, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %r8d
movl -0x14(%rbp), %r9d
movl -0x18(%rbp), %eax
movl $0x1, %edx
movl $0x10, %ecx
movl %eax, (%rsp)
callq 0x14cf20
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x14b230
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: SimpleVFilter16_C
static void SimpleVFilter16_C(uint8_t* p, int stride, int thresh) {
  int i;
  const int thresh2 = 2 * thresh + 1;
  for (i = 0; i < 16; ++i) {
    if (NeedsFilter_C(p + i, stride, thresh2)) {
      DoFilter2_C(p + i, stride);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x14b435
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x14d0f0
cmpl $0x0, %eax
je 0x14b428
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x14cc80
jmp 0x14b42a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14b3f4
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: SimpleHFilter16_C
static void SimpleHFilter16_C(uint8_t* p, int stride, int thresh) {
  int i;
  const int thresh2 = 2 * thresh + 1;
  for (i = 0; i < 16; ++i) {
    if (NeedsFilter_C(p + i * stride, 1, thresh2)) {
      DoFilter2_C(p + i * stride, 1);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x14b4b3
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
imull -0xc(%rbp), %eax
cltq
addq %rax, %rdi
movl -0x18(%rbp), %edx
movl $0x1, %esi
callq 0x14d0f0
cmpl $0x0, %eax
je 0x14b4a6
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
imull -0xc(%rbp), %eax
cltq
addq %rax, %rdi
movl $0x1, %esi
callq 0x14cc80
jmp 0x14b4a8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14b464
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: SimpleVFilter16i_C
static void SimpleVFilter16i_C(uint8_t* p, int stride, int thresh) {
  int k;
  for (k = 3; k > 0; --k) {
    p += 4 * stride;
    SimpleVFilter16_C(p, stride, thresh);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x3, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x14b50d
movl -0xc(%rbp), %ecx
shll $0x2, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x14b3d0
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14b4d9
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: SimpleHFilter16i_C
static void SimpleHFilter16i_C(uint8_t* p, int stride, int thresh) {
  int k;
  for (k = 3; k > 0; --k) {
    p += 4;
    SimpleHFilter16_C(p, stride, thresh);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x3, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x14b565
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x14b440
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x14b539
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: HFilter16i_C
static void HFilter16i_C(uint8_t* p, int stride,
                         int thresh, int ithresh, int hev_thresh) {
  int k;
  for (k = 3; k > 0; --k) {
    p += 4;
    FilterLoop24_C(p, 1, stride, 16, thresh, ithresh, hev_thresh);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl $0x3, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x14b5d1
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %r8d
movl -0x14(%rbp), %r9d
movl -0x18(%rbp), %eax
movl $0x1, %esi
movl $0x10, %ecx
movl %eax, (%rsp)
callq 0x14cf20
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x14b590
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: DC4_C
static void DC4_C(uint8_t* dst) {   // DC
  uint32_t dc = 4;
  int i;
  for (i = 0; i < 4; ++i) dc += dst[i - BPS] + dst[-1 + i * BPS];
  dc >>= 3;
  for (i = 0; i < 4; ++i) memset(dst + i * BPS, dc, 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x4, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0x14b72b
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x20, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movl -0x10(%rbp), %edx
shll $0x5, %edx
addl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x14b6ea
movl -0xc(%rbp), %eax
shrl $0x3, %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0x14b76b
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
shll $0x5, %eax
cltq
addq %rax, %rdi
movl -0xc(%rbp), %eax
movl $0x4, %edx
movzbl %al, %esi
callq 0x5a200
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x14b73b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: VE4_C
static void VE4_C(uint8_t* dst) {    // vertical
  const uint8_t* top = dst - BPS;
  const uint8_t vals[4] = {
    AVG3(top[-1], top[0], top[1]),
    AVG3(top[ 0], top[1], top[2]),
    AVG3(top[ 1], top[2], top[3]),
    AVG3(top[ 2], top[3], top[4])
  };
  int i;
  for (i = 0; i < 4; ++i) {
    memcpy(dst + i * BPS, vals, sizeof(vals));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x20, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl -0x1(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
shll %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
addl %ecx, %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, -0x13(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
addl %ecx, %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shll %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
addl %ecx, %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x14b879
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
shll $0x5, %ecx
movslq %ecx, %rcx
movl -0x14(%rbp), %edx
movl %edx, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x14b855
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: LD4_C
static void LD4_C(uint8_t* dst) {   // Down-Left
  const int A = dst[0 - BPS];
  const int B = dst[1 - BPS];
  const int C = dst[2 - BPS];
  const int D = dst[3 - BPS];
  const int E = dst[4 - BPS];
  const int F = dst[5 - BPS];
  const int G = dst[6 - BPS];
  const int H = dst[7 - BPS];
  DST(0, 0)                                     = AVG3(A, B, C);
  DST(1, 0) = DST(0, 1)                         = AVG3(B, C, D);
  DST(2, 0) = DST(1, 1) = DST(0, 2)             = AVG3(C, D, E);
  DST(3, 0) = DST(2, 1) = DST(1, 2) = DST(0, 3) = AVG3(D, E, F);
              DST(3, 1) = DST(2, 2) = DST(1, 3) = AVG3(E, F, G);
                          DST(3, 2) = DST(2, 3) = AVG3(F, G, H);
                                      DST(3, 3) = AVG3(G, H, H);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl -0x20(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl -0x1f(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl -0x1e(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzbl -0x1d(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzbl -0x1c(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movzbl -0x1b(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzbl -0x1a(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movzbl -0x19(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
shll %ecx
addl %ecx, %eax
addl -0x14(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movl -0x10(%rbp), %eax
movl -0x14(%rbp), %ecx
shll %ecx
addl %ecx, %eax
addl -0x18(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x20(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
shll %ecx
addl %ecx, %eax
addl -0x1c(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x40(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x21(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x18(%rbp), %eax
movl -0x1c(%rbp), %ecx
shll %ecx
addl %ecx, %eax
addl -0x20(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x60(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x41(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x22(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
shll %ecx
addl %ecx, %eax
addl -0x24(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x61(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x42(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x23(%rax)
movl -0x20(%rbp), %eax
movl -0x24(%rbp), %ecx
shll %ecx
addl %ecx, %eax
addl -0x28(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x62(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x43(%rax)
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %ecx
shll %ecx
addl %ecx, %eax
addl -0x28(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x63(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: HE4_C
static void HE4_C(uint8_t* dst) {    // horizontal
  const int A = dst[-1 - BPS];
  const int B = dst[-1];
  const int C = dst[-1 + BPS];
  const int D = dst[-1 + 2 * BPS];
  const int E = dst[-1 + 3 * BPS];
  WebPUint32ToMem(dst + 0 * BPS, 0x01010101U * AVG3(A, B, C));
  WebPUint32ToMem(dst + 1 * BPS, 0x01010101U * AVG3(B, C, D));
  WebPUint32ToMem(dst + 2 * BPS, 0x01010101U * AVG3(C, D, E));
  WebPUint32ToMem(dst + 3 * BPS, 0x01010101U * AVG3(D, E, E));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl -0x21(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl -0x1(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1f(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x3f(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x5f(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
shll %ecx
addl %ecx, %eax
addl -0x14(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movzbl %al, %eax
imull $0x1010101, %eax, %esi  # imm = 0x1010101
callq 0x14d230
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movl -0x10(%rbp), %eax
movl -0x14(%rbp), %ecx
shll %ecx
addl %ecx, %eax
addl -0x18(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movzbl %al, %eax
imull $0x1010101, %eax, %esi  # imm = 0x1010101
callq 0x14d230
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
shll %ecx
addl %ecx, %eax
addl -0x1c(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movzbl %al, %eax
imull $0x1010101, %eax, %esi  # imm = 0x1010101
callq 0x14d230
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
movl -0x18(%rbp), %eax
movl -0x1c(%rbp), %ecx
shll %ecx
addl %ecx, %eax
addl -0x1c(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movzbl %al, %eax
imull $0x1010101, %eax, %esi  # imm = 0x1010101
callq 0x14d230
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: HU4_C
static void HU4_C(uint8_t* dst) {   // Horizontal-Up
  const int I = dst[-1 + 0 * BPS];
  const int J = dst[-1 + 1 * BPS];
  const int K = dst[-1 + 2 * BPS];
  const int L = dst[-1 + 3 * BPS];
  DST(0, 0) =             AVG2(I, J);
  DST(2, 0) = DST(0, 1) = AVG2(J, K);
  DST(2, 1) = DST(0, 2) = AVG2(K, L);
  DST(1, 0) =             AVG3(I, J, K);
  DST(3, 0) = DST(1, 1) = AVG3(J, K, L);
  DST(3, 1) = DST(1, 2) = AVG3(K, L, L);
  DST(3, 2) = DST(2, 2) =
    DST(0, 3) = DST(1, 3) = DST(2, 3) = DST(3, 3) = L;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl -0x1(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1f(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x3f(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x5f(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
addl $0x1, %eax
sarl %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
addl $0x1, %eax
sarl %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x20(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
addl $0x1, %eax
sarl %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x40(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x22(%rax)
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
shll %ecx
addl %ecx, %eax
addl -0x14(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x10(%rbp), %eax
movl -0x14(%rbp), %ecx
shll %ecx
addl %ecx, %eax
addl -0x18(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x21(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
shll %ecx
addl %ecx, %eax
addl -0x18(%rbp), %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x41(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x23(%rax)
movl -0x18(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x63(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x62(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x61(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x60(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x42(%rax)
movq -0x8(%rbp), %rax
movb %cl, 0x43(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: DC16_C
static void DC16_C(uint8_t* dst) {    // DC
  int DC = 16;
  int j;
  for (j = 0; j < 16; ++j) {
    DC += dst[-1 + j * BPS] + dst[j - BPS];
  }
  Put16(DC >> 5, dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x10, -0x10(%rbp)
jge 0x14c26b
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
shll $0x5, %ecx
addl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movl -0x10(%rbp), %edx
subl $0x20, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x14c22a
movl -0xc(%rbp), %edi
sarl $0x5, %edi
movq -0x8(%rbp), %rsi
callq 0x14d250
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: VE16_C
static void VE16_C(uint8_t* dst) {     // vertical
  int j;
  for (j = 0; j < 16; ++j) {
    memcpy(dst + j * BPS, dst - BPS, 16);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x14c2e2
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
shll $0x5, %ecx
movslq %ecx, %rcx
movq -0x8(%rbp), %rdx
movq -0x20(%rdx), %rsi
movq %rsi, (%rax,%rcx)
movq -0x18(%rdx), %rdx
movq %rdx, 0x8(%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x14c2af
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: HE16_C
static void HE16_C(uint8_t* dst) {     // horizontal
  int j;
  for (j = 16; j > 0; --j) {
    memset(dst, dst[-1], 16);
    dst += BPS;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x14c339
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl -0x1(%rax), %eax
movl $0x10, %edx
movzbl %al, %esi
callq 0x5a200
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x14c303
addq $0x10, %rsp
popq %rbp
retq
nop