LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
xorl %r9d, %r9d
testl %esi, %esi
sete %al
setne %r9b
leaq (%rax,%rax,2), %rax
movslq %r8d, %rsi
xorl %r8d, %r8d
testl %edx, %edx
cmovlel %r8d, %edx
leaq (%r9,%rdi), %r8
addq $0x2, %r8
addq %rdi, %rax
testl %ecx, %ecx
jle 0xcef51
decl %ecx
xorl %edi, %edi
cmpq %rdi, %rdx
je 0xcef49
movzbl (%rax,%rdi,4), %r9d
cmpl $0xff, %r9d
je 0xcef44
imull $0x8081, %r9d, %r9d     # imm = 0x8081
movzbl -0x2(%r8,%rdi,4), %r10d
imull %r9d, %r10d
shrl $0x17, %r10d
movb %r10b, -0x2(%r8,%rdi,4)
movzbl -0x1(%r8,%rdi,4), %r10d
imull %r9d, %r10d
shrl $0x17, %r10d
movb %r10b, -0x1(%r8,%rdi,4)
movzbl (%r8,%rdi,4), %r10d
imull %r9d, %r10d
shrl $0x17, %r10d
movb %r10b, (%r8,%rdi,4)
incq %rdi
jmp 0xceef3
addq %rsi, %r8
addq %rsi, %rax
jmp 0xceeeb
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movslq %esi, %rax
movslq %r9d, %rsi
xorl %r9d, %r9d
testl %edx, %edx
cmovlel %r9d, %edx
testl %ecx, %ecx
cmovlel %r9d, %ecx
movl $0xff, %r10d
cmpl %ecx, %r9d
je 0xcef97
xorl %r11d, %r11d
cmpq %r11, %rdx
je 0xcef8c
movzbl (%rdi,%r11), %ebx
movb %bl, (%r8,%r11,4)
andl %ebx, %r10d
incq %r11
jmp 0xcef76
addq %rax, %rdi
addq %rsi, %r8
incl %r9d
jmp 0xcef6e
xorl %eax, %eax
cmpl $0xff, %r10d
setne %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movslq %esi, %rax
movslq %r9d, %rsi
xorl %r9d, %r9d
testl %edx, %edx
cmovlel %r9d, %edx
testl %ecx, %ecx
cmovlel %r9d, %ecx
shlq $0x2, %rsi
cmpl %ecx, %r9d
je 0xcefe8
xorl %r10d, %r10d
cmpq %r10, %rdx
je 0xcefdd
movzbl (%rdi,%r10), %r11d
shll $0x8, %r11d
movl %r11d, (%r8,%r10,4)
incq %r10
jmp 0xcefc6
addq %rax, %rdi
incl %r9d
addq %rsi, %r8
jmp 0xcefbe
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movslq %esi, %rax
movslq %r9d, %rsi
xorl %r9d, %r9d
testl %edx, %edx
cmovlel %r9d, %edx
testl %ecx, %ecx
cmovlel %r9d, %ecx
movb $-0x1, %r10b
cmpl %ecx, %r9d
je 0xcf02a
xorl %r11d, %r11d
cmpq %r11, %rdx
je 0xcf01f
movb (%rdi,%r11,4), %bl
movb %bl, (%r8,%r11)
andb %bl, %r10b
incq %r11
jmp 0xcf00a
addq %rax, %rdi
addq %rsi, %r8
incl %r9d
jmp 0xcf002
xorl %eax, %eax
cmpb $-0x1, %r10b
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/cpu.c
// Function: x86CPUInfo
static int x86CPUInfo(CPUFeature feature) {
  int max_cpuid_value;
  int cpu_info[4];
  int is_intel = 0;

  // get the highest feature value cpuid supports
  GetCPUInfo(cpu_info, 0);
  max_cpuid_value = cpu_info[0];
  if (max_cpuid_value < 1) {
    return 0;
  } else {
    const int VENDOR_ID_INTEL_EBX = 0x756e6547;  // uneG
    const int VENDOR_ID_INTEL_EDX = 0x49656e69;  // Ieni
    const int VENDOR_ID_INTEL_ECX = 0x6c65746e;  // letn
    is_intel = (cpu_info[1] == VENDOR_ID_INTEL_EBX &&
                cpu_info[2] == VENDOR_ID_INTEL_ECX &&
                cpu_info[3] == VENDOR_ID_INTEL_EDX);    // genuine Intel?
  }

  GetCPUInfo(cpu_info, 1);
  if (feature == kSSE2) {
    return !!(cpu_info[3] & (1 << 26));
  }
  if (feature == kSSE3) {
    return !!(cpu_info[2] & (1 << 0));
  }
  if (feature == kSlowSSSE3) {
    if (is_intel && (cpu_info[2] & (1 << 9))) {   // SSSE3?
      return CheckSlowModel(cpu_info[0]);
    }
    return 0;
  }

  if (feature == kSSE4_1) {
    return !!(cpu_info[2] & (1 << 19));
  }
  if (feature == kAVX) {
    // bits 27 (OSXSAVE) & 28 (256-bit AVX)
    if ((cpu_info[2] & 0x18000000) == 0x18000000) {
      // XMM state and YMM state enabled by the OS.
      return (xgetbv() & 0x6) == 0x6;
    }
  }
  if (feature == kAVX2) {
    if (x86CPUInfo(kAVX) && max_cpuid_value >= 7) {
      GetCPUInfo(cpu_info, 7);
      return !!(cpu_info[1] & (1 << 5));
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorl %r14d, %r14d
xorl %eax, %eax
xorl %ecx, %ecx
cpuid
testl %eax, %eax
jle 0xcf184
movl %ebx, %r9d
movl %ecx, %r10d
movl %edx, %r8d
movl %eax, %ebp
pushq $0x1
popq %rsi
xorl %r14d, %r14d
movl %esi, %eax
xorl %ecx, %ecx
cpuid
cmpl $0x5, %edi
ja 0xcf184
movl %edi, %edi
leaq 0x4b2f2(%rip), %r11     # 0x11a3c8
movslq (%r11,%rdi,4), %rdi
addq %r11, %rdi
jmpq *%rdi
shrl $0x1a, %edx
andl $0x1, %edx
movl %edx, %r14d
jmp 0xcf184
notl %ecx
testl $0x18000000, %ecx       # imm = 0x18000000
jne 0xcf184
xorl %ecx, %ecx
xgetbv
notl %eax
xorl %r14d, %r14d
testb $0x6, %al
sete %r14b
jmp 0xcf184
xorl $0x756e6547, %r9d       # imm = 0x756E6547
xorl $0x6c65746e, %r10d      # imm = 0x6C65746E
orl %r9d, %r10d
xorl $0x49656e69, %r8d       # imm = 0x49656E69
orl %r10d, %r8d
setne %dl
btl $0x9, %ecx
setae %cl
orb %dl, %cl
jne 0xcf184
movl %eax, %ecx
andl $0xf00, %ecx            # imm = 0xF00
cmpl $0x600, %ecx            # imm = 0x600
jne 0xcf184
movl %eax, %ecx
shrl $0xc, %ecx
andl $0xf0, %ecx
shrl $0x4, %eax
andl $0xf, %eax
orl %ecx, %eax
xorl %r14d, %r14d
leaq 0x4b27d(%rip), %rcx     # 0x11a3e0
xorl %edx, %edx
cmpq $0x6, %rdx
je 0xcf184
movzbl (%rdx,%rcx), %edi
incq %rdx
cmpl %edi, %eax
jne 0xcf165
movl %esi, %r14d
jmp 0xcf184
shrl $0x13, %ecx
andl $0x1, %ecx
movl %ecx, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x4
popq %rdi
callq 0xcf098
cmpl $0x7, %ebp
jb 0xcf184
testl %eax, %eax
je 0xcf184
pushq $0x7
popq %rax
xorl %ecx, %ecx
cpuid
movl %ebx, %r14d
shrl $0x5, %r14d
andl $0x1, %r14d
jmp 0xcf184
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: TransformWHT_C
static void TransformWHT_C(const int16_t* in, int16_t* out) {
  int tmp[16];
  int i;
  for (i = 0; i < 4; ++i) {
    const int a0 = in[0 + i] + in[12 + i];
    const int a1 = in[4 + i] + in[ 8 + i];
    const int a2 = in[4 + i] - in[ 8 + i];
    const int a3 = in[0 + i] - in[12 + i];
    tmp[0  + i] = a0 + a1;
    tmp[8  + i] = a0 - a1;
    tmp[4  + i] = a3 + a2;
    tmp[12 + i] = a3 - a2;
  }
  for (i = 0; i < 4; ++i) {
    const int dc = tmp[0 + i * 4] + 3;    // w/ rounder
    const int a0 = dc             + tmp[3 + i * 4];
    const int a1 = tmp[1 + i * 4] + tmp[2 + i * 4];
    const int a2 = tmp[1 + i * 4] - tmp[2 + i * 4];
    const int a3 = dc             - tmp[3 + i * 4];
    out[ 0] = (a0 + a1) >> 3;
    out[16] = (a3 + a2) >> 3;
    out[32] = (a0 - a1) >> 3;
    out[48] = (a3 - a2) >> 3;
    out += 64;
  }
}

// Assembly:
movabsq $0xc, %rax
cmpq $0x10, %rax
je 0xcfc31
movswl -0x18(%rdi,%rax,2), %ecx
movswl (%rdi,%rax,2), %edx
leal (%rdx,%rcx), %r8d
movswl -0x10(%rdi,%rax,2), %r9d
movswl -0x8(%rdi,%rax,2), %r10d
leal (%r10,%r9), %r11d
subl %r10d, %r9d
subl %edx, %ecx
leal (%r11,%r8), %edx
movl %edx, -0x78(%rsp,%rax,4)
subl %r11d, %r8d
movl %r8d, -0x58(%rsp,%rax,4)
leal (%r9,%rcx), %edx
movl %edx, -0x68(%rsp,%rax,4)
subl %r9d, %ecx
movl %ecx, -0x48(%rsp,%rax,4)
incq %rax
jmp 0xcfbe5
xorl %eax, %eax
cmpq $0x40, %rax
je 0xcfc91
movl -0x48(%rsp,%rax), %edx
movl -0x44(%rsp,%rax), %ecx
movl -0x3c(%rsp,%rax), %edi
leal (%rdx,%rdi), %r8d
addl $0x3, %r8d
addl $0x3, %edx
movl -0x40(%rsp,%rax), %r9d
leal (%r9,%rcx), %r10d
subl %r9d, %ecx
subl %edi, %edx
leal (%r10,%r8), %edi
shrl $0x3, %edi
movw %di, (%rsi,%rax,8)
leal (%rcx,%rdx), %edi
shrl $0x3, %edi
movw %di, 0x20(%rsi,%rax,8)
subl %r10d, %r8d
shrl $0x3, %r8d
movw %r8w, 0x40(%rsi,%rax,8)
subl %ecx, %edx
shrl $0x3, %edx
movw %dx, 0x60(%rsi,%rax,8)
addq $0x10, %rax
jmp 0xcfc33
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movswl (%rdi), %eax
addl $0x4, %eax
sarl $0x3, %eax
xorl %ecx, %ecx
movl $0xff, %edx
xorl %edi, %edi
cmpq $0x4, %rdi
je 0xcfd0c
xorl %r8d, %r8d
cmpq $0x4, %r8
je 0xcfd03
movzbl (%rsi,%r8), %r9d
addl %eax, %r9d
testl %r9d, %r9d
cmovlel %ecx, %r9d
cmpl %edx, %r9d
cmovgel %edx, %r9d
movb %r9b, (%rsi,%r8)
incq %r8
jmp 0xcfcde
incq %rdi
addq $0x20, %rsi
jmp 0xcfcd5
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpw $0x0, (%rdi)
je 0xcff9c
movq %r14, %rdi
movq %rbx, %rsi
callq *0xa1574(%rip)          # 0x171510
cmpw $0x0, 0x20(%r14)
je 0xcffb2
leaq 0x20(%r14), %rdi
leaq 0x4(%rbx), %rsi
callq *0xa155e(%rip)          # 0x171510
cmpw $0x0, 0x40(%r14)
je 0xcffcb
leaq 0x40(%r14), %rdi
leaq 0x80(%rbx), %rsi
callq *0xa1545(%rip)          # 0x171510
cmpw $0x0, 0x60(%r14)
je 0xcfff4
addq $0x60, %r14
movq 0xa1532(%rip), %rax     # 0x171510
addq $0x84, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0x14(%rsp)
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
leal (,%r15,4), %eax
movslq %eax, %r13
addq %r13, %r12
pushq $-0x3
popq %rbx
testl %ebx, %ebx
je 0xd006e
movl 0x14(%rsp), %eax
movl %eax, (%rsp)
movq %r12, %rdi
movl %r15d, %esi
pushq $0x1
popq %rdx
pushq $0x10
popq %rcx
movl %r14d, %r8d
movl %ebp, %r9d
callq 0xd0ffa
addq %r13, %r12
incl %ebx
jmp 0xd0045
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leal 0x1(,%rdx,2), %ebp
xorl %r12d, %r12d
cmpq $0x10, %r12
je 0xd01a3
leaq (%r14,%r12), %r15
movq %r15, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0xd1144
testl %eax, %eax
je 0xd019e
movq %r15, %rdi
movl %ebx, %esi
callq 0xd0f73
incq %r12
jmp 0xd017a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leal 0x1(%rdx,%rdx), %ebp
movslq %esi, %r15
pushq $0x10
popq %r12
pushq $0x1
popq %r14
subq $0x1, %r12
jb 0xd01ed
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0xd1144
testl %eax, %eax
je 0xd01e8
movq %rbx, %rdi
movl %r14d, %esi
callq 0xd0f73
addq %r15, %rbx
jmp 0xd01c6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leal (,%r14,4), %eax
movslq %eax, %r12
addq %r12, %r15
pushq $-0x3
popq %rbp
testl %ebp, %ebp
je 0xd022f
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0xd0163
addq %r12, %r15
incl %ebp
jmp 0xd0217
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x4
popq %r15
cmpl $0x10, %r15d
je 0xd0263
leaq (%r14,%r15), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0xd01ac
addq $0x4, %r15
jmp 0xd024a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
pushq $0x4
popq %r13
cmpl $0x10, %r13d
je 0xd02b2
leaq (%r12,%r13), %rdi
movl %ebx, (%rsp)
pushq $0x1
popq %rsi
movl %r15d, %edx
pushq $0x10
popq %rcx
movl %r14d, %r8d
movl %ebp, %r9d
callq 0xd0ffa
addq $0x4, %r13
jmp 0xd028b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movzbl -0x21(%rdi), %eax
movzbl -0x20(%rdi), %ecx
movzbl -0x1f(%rdi), %edx
addl %edx, %eax
addl $0x2, %eax
leal (%rax,%rcx,2), %eax
shrl $0x2, %eax
movzbl -0x1e(%rdi), %esi
addl %esi, %ecx
addl $0x2, %ecx
leal (%rcx,%rdx,2), %ecx
shrl $0x2, %ecx
movzbl -0x1d(%rdi), %r8d
leal (%rdx,%rsi,2), %edx
addl $0x2, %edx
addl %r8d, %edx
shrl $0x2, %edx
movzbl -0x1c(%rdi), %r9d
leal (%rsi,%r8,2), %esi
addl $0x2, %esi
addl %r9d, %esi
shrl $0x2, %esi
xorl %r8d, %r8d
cmpq $0x80, %r8
je 0xd043e
movb %al, (%rdi,%r8)
movb %cl, 0x1(%rdi,%r8)
movb %dl, 0x2(%rdi,%r8)
movb %sil, 0x3(%rdi,%r8)
addq $0x20, %r8
jmp 0xd041c
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movzbl -0x21(%rdi), %eax
movzbl -0x1(%rdi), %ecx
movzbl 0x1f(%rdi), %edx
movzbl 0x3f(%rdi), %esi
movzbl 0x5f(%rdi), %r8d
addl %edx, %eax
addl $0x2, %eax
leal (%rax,%rcx,2), %eax
shrl $0x2, %eax
imull $0x1010101, %eax, %eax  # imm = 0x1010101
movl %eax, (%rdi)
leal (%rsi,%rcx), %eax
addl $0x2, %eax
leal (%rax,%rdx,2), %eax
shrl $0x2, %eax
imull $0x1010101, %eax, %eax  # imm = 0x1010101
movl %eax, 0x20(%rdi)
leal (%rdx,%rsi,2), %eax
addl $0x2, %eax
addl %r8d, %eax
shrl $0x2, %eax
imull $0x1010101, %eax, %eax  # imm = 0x1010101
movl %eax, 0x40(%rdi)
leal (%rsi,%r8), %eax
addl $0x2, %eax
leal (%rax,%r8,2), %eax
shrl $0x2, %eax
imull $0x1010101, %eax, %eax  # imm = 0x1010101
movl %eax, 0x60(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movzbl -0x1(%rdi), %esi
movzbl 0x1f(%rdi), %edx
movzbl 0x3f(%rdi), %ecx
movzbl 0x5f(%rdi), %eax
leal (%rdx,%rsi), %r8d
incl %r8d
shrl %r8d
movb %r8b, (%rdi)
leal (%rdx,%rcx), %r8d
incl %r8d
shrl %r8d
movb %r8b, 0x20(%rdi)
movb %r8b, 0x2(%rdi)
leal (%rcx,%rax), %r8d
incl %r8d
shrl %r8d
movb %r8b, 0x40(%rdi)
movb %r8b, 0x22(%rdi)
addl %ecx, %esi
addl $0x2, %esi
leal (%rsi,%rdx,2), %esi
shrl $0x2, %esi
movb %sil, 0x1(%rdi)
addl %eax, %edx
leal (%rdx,%rcx,2), %edx
addl $0x2, %edx
shrl $0x2, %edx
movb %dl, 0x21(%rdi)
movb %dl, 0x3(%rdi)
addl %eax, %ecx
addl $0x2, %ecx
leal (%rcx,%rax,2), %ecx
shrl $0x2, %ecx
movb %cl, 0x41(%rdi)
movb %cl, 0x23(%rdi)
movd %eax, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
movd %xmm0, 0x60(%rdi)
movb %al, 0x42(%rdi)
movb %al, 0x43(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rsi
leaq -0x20(%rdi), %rax
pushq $0x10
popq %rdi
pushq $-0x1
popq %rcx
cmpq $0x1ff, %rcx            # imm = 0x1FF
je 0xd094e
movzbl (%rsi,%rcx), %edx
movzbl (%rax), %r8d
addl %edx, %edi
addl %r8d, %edi
addq $0x20, %rcx
incq %rax
jmp 0xd092f
shrl $0x5, %edi
jmp 0xd11d5
// File: /workspace/github_c_makefile_star2_O2/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:
leaq -0x20(%rdi), %rax
xorl %ecx, %ecx
cmpq $0x200, %rcx            # imm = 0x200
je 0xd097a
movups (%rax), %xmm0
movups %xmm0, (%rdi,%rcx)
addq $0x20, %rcx
jmp 0xd0964
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
cmpl $0x200, %eax            # imm = 0x200
je 0xd09a9
leaq (%rdi,%rax), %rcx
movzbl -0x1(%rdi,%rax), %edx
movd %edx, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqu %xmm0, (%rcx)
addq $0x20, %rax
jmp 0xd097d
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: DC16NoTop_C
static void DC16NoTop_C(uint8_t* dst) {   // DC with top samples not available
  int DC = 8;
  int j;
  for (j = 0; j < 16; ++j) {
    DC += dst[-1 + j * BPS];
  }
  Put16(DC >> 4, dst);
}

// Assembly:
movq %rdi, %rsi
pushq $0x8
popq %rdi
pushq $-0x1
popq %rax
cmpq $0x1ff, %rax            # imm = 0x1FF
je 0xd09c7
movzbl (%rsi,%rax), %ecx
addl %ecx, %edi
addq $0x20, %rax
jmp 0xd09b3
shrl $0x4, %edi
jmp 0xd11d5
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: DC16NoLeft_C
static void DC16NoLeft_C(uint8_t* dst) {  // DC with left samples not available
  int DC = 8;
  int i;
  for (i = 0; i < 16; ++i) {
    DC += dst[i - BPS];
  }
  Put16(DC >> 4, dst);
}

// Assembly:
movq %rdi, %rsi
pushq $0x8
popq %rdi
pushq $-0x10
popq %rax
testq %rax, %rax
je 0xd09e9
movzbl -0x10(%rsi,%rax), %ecx
addl %ecx, %edi
incq %rax
jmp 0xd09d8
shrl $0x4, %edi
jmp 0xd11d5
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: DC8uv_C
static void DC8uv_C(uint8_t* dst) {     // DC
  int dc0 = 8;
  int i;
  for (i = 0; i < 8; ++i) {
    dc0 += dst[i - BPS] + dst[-1 + i * BPS];
  }
  Put8x8uv(dc0 >> 4, dst);
}

// Assembly:
movq %rdi, %rsi
leaq -0x1(%rdi), %rcx
pushq $0x8
popq %rax
pushq $-0x20
popq %rdx
cmpq $-0x18, %rdx
je 0xd0a27
movzbl (%rsi,%rdx), %edi
movzbl (%rcx), %r8d
addl %edi, %eax
addl %r8d, %eax
incq %rdx
addq $0x20, %rcx
jmp 0xd0a0b
shrl $0x4, %eax
movzbl %al, %edi
jmp 0xd1201
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: VE8uv_C
static void VE8uv_C(uint8_t* dst) {    // vertical
  int j;
  for (j = 0; j < 8; ++j) {
    memcpy(dst + j * BPS, dst - BPS, 8);
  }
}

// Assembly:
movq -0x20(%rdi), %rax
xorl %ecx, %ecx
cmpq $0x100, %rcx            # imm = 0x100
je 0xd0a53
movq %rax, (%rdi,%rcx)
addq $0x20, %rcx
jmp 0xd0a40
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: HE8uv_C
static void HE8uv_C(uint8_t* dst) {    // horizontal
  int j;
  for (j = 0; j < 8; ++j) {
    memset(dst, dst[-1], 8);
    dst += BPS;
  }
}

// Assembly:
xorl %eax, %eax
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
cmpl $0x100, %eax            # imm = 0x100
je 0xd0a7d
leaq (%rdi,%rax), %rdx
movzbl -0x1(%rdi,%rax), %esi
imulq %rcx, %rsi
movq %rsi, (%rdx)
addq $0x20, %rax
jmp 0xd0a60
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: DC8uvNoTop_C
static void DC8uvNoTop_C(uint8_t* dst) {  // DC with no top samples
  int dc0 = 4;
  int i;
  for (i = 0; i < 8; ++i) {
    dc0 += dst[-1 + i * BPS];
  }
  Put8x8uv(dc0 >> 3, dst);
}

// Assembly:
movq %rdi, %rsi
pushq $0x4
popq %rax
pushq $-0x1
popq %rcx
cmpq $0xff, %rcx
je 0xd0a9c
movzbl (%rsi,%rcx), %edx
addl %edx, %eax
addq $0x20, %rcx
jmp 0xd0a87
shrl $0x3, %eax
movzbl %al, %edi
jmp 0xd1201
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: DC8uvNoLeft_C
static void DC8uvNoLeft_C(uint8_t* dst) {   // DC with no left samples
  int dc0 = 4;
  int i;
  for (i = 0; i < 8; ++i) {
    dc0 += dst[i - BPS];
  }
  Put8x8uv(dc0 >> 3, dst);
}

// Assembly:
movq %rdi, %rsi
pushq $0x4
popq %rax
pushq $-0x20
popq %rcx
cmpq $-0x18, %rcx
je 0xd0ac1
movzbl (%rsi,%rcx), %edx
addl %edx, %eax
incq %rcx
jmp 0xd0ab0
shrl $0x3, %eax
movzbl %al, %edi
jmp 0xd1201
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: DitherCombine8x8_C
static void DitherCombine8x8_C(const uint8_t* dither, uint8_t* dst,
                               int dst_stride) {
  int i, j;
  for (j = 0; j < 8; ++j) {
    for (i = 0; i < 8; ++i) {
      const int delta0 = dither[i] - VP8_DITHER_AMP_CENTER;
      const int delta1 =
          (delta0 + VP8_DITHER_DESCALE_ROUNDER) >> VP8_DITHER_DESCALE;
      dst[i] = clip_8b((int)dst[i] + delta1);
    }
    dst += dst_stride;
    dither += 8;
  }
}

// Assembly:
movslq %edx, %rax
xorl %ecx, %ecx
movl $0xff, %edx
xorl %r8d, %r8d
cmpl $0x8, %r8d
je 0xd0b2d
xorl %r9d, %r9d
cmpq $0x8, %r9
je 0xd0b21
movzbl (%rdi,%r9), %r10d
addl $-0x78, %r10d
sarl $0x4, %r10d
movzbl (%rsi,%r9), %r11d
addl %r10d, %r11d
testl %r11d, %r11d
cmovlel %ecx, %r11d
cmpl %edx, %r11d
cmovgel %edx, %r11d
movb %r11b, (%rsi,%r9)
incq %r9
jmp 0xd0aef
addq %rax, %rsi
addq $0x8, %rdi
incl %r8d
jmp 0xd0ae6
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: FilterLoop26_C
static WEBP_INLINE void FilterLoop26_C(uint8_t* p,
                                       int hstride, int vstride, int size,
                                       int thresh, int ithresh,
                                       int hev_thresh) {
  const int thresh2 = 2 * thresh + 1;
  while (size-- > 0) {
    if (NeedsFilter2_C(p, hstride, thresh2, ithresh)) {
      if (Hev(p, hstride, hev_thresh)) {
        DoFilter2_C(p, hstride);
      } else {
        DoFilter6_C(p, hstride);
      }
    }
    p += vstride;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, 0xc(%rsp)
movl %ecx, %ebp
movl %esi, %r14d
movq %rdi, %r15
leal 0x1(,%r8,2), %r13d
imull $-0x3, %esi, %eax
cltq
movq %rax, 0x40(%rsp)
leal (%r14,%r14), %eax
movslq %eax, %rcx
movq %rcx, 0x38(%rsp)
negl %eax
cltq
movq %rax, 0x30(%rsp)
movl %esi, %eax
negl %eax
cltq
movq %rax, 0x28(%rsp)
movslq %esi, %rax
movq %rax, 0x10(%rsp)
leaq 0x902c3(%rip), %rax     # 0x160fd0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
leaq 0x902c4(%rip), %rax     # 0x160fe0
movq (%rax), %r12
movslq %edx, %rbx
movl %r13d, 0x8(%rsp)
movq %rbx, 0x18(%rsp)
testl %ebp, %ebp
jle 0xd0e53
movq %r15, %rdi
movl %r14d, %esi
movl %r13d, %edx
movl 0xc(%rsp), %ecx
callq 0xd0e62
testl %eax, %eax
je 0xd0e49
movq %r15, %rdi
movl %r14d, %esi
movl 0x80(%rsp), %edx
callq 0xd0f2c
testl %eax, %eax
je 0xd0d74
movq %r15, %rdi
movl %r14d, %esi
callq 0xd0f73
jmp 0xd0e49
movq 0x40(%rsp), %r10
movzbl (%r15,%r10), %eax
movq 0x30(%rsp), %r13
movzbl (%r15,%r13), %ecx
movq 0x28(%rsp), %rbx
movzbl (%r15,%rbx), %edx
movzbl (%r15), %esi
movq 0x10(%rsp), %rdi
movzbl (%r15,%rdi), %edi
movq %rsi, %r8
subq %rdx, %r8
leaq (%r8,%r8,2), %r8
movq %rcx, %r9
subq %rdi, %r9
movq 0x20(%rsp), %r11
movsbq (%r11,%r9), %r9
addq %r8, %r9
movsbl (%r11,%r9), %r8d
imull $0x1b, %r8d, %r9d
addl $0x3f, %r9d
sarl $0x7, %r9d
movslq %r9d, %r9
addq %r9, %rdx
subq %r9, %rsi
imull $0x12, %r8d, %r9d
addl $0x3f, %r9d
sarl $0x7, %r9d
movslq %r9d, %r9
addq %r9, %rcx
subq %r9, %rdi
movq 0x38(%rsp), %r11
movzbl (%r15,%r11), %r9d
leal (%r8,%r8,8), %r8d
addl $0x3f, %r8d
sarl $0x7, %r8d
movslq %r8d, %r8
addq %r8, %rax
subq %r8, %r9
movb (%r12,%rax), %al
movb %al, (%r15,%r10)
movb (%r12,%rcx), %al
movb %al, (%r15,%r13)
movl 0x8(%rsp), %r13d
movb (%r12,%rdx), %al
movb %al, (%r15,%rbx)
movq 0x18(%rsp), %rbx
movb (%r12,%rsi), %al
movb %al, (%r15)
movb (%r12,%rdi), %al
movq 0x10(%rsp), %rcx
movb %al, (%r15,%rcx)
movb (%r12,%r9), %al
movb %al, (%r15,%r11)
addq %rbx, %r15
decl %ebp
jmp 0xd0d2c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: NeedsFilter2_C
static WEBP_INLINE int NeedsFilter2_C(const uint8_t* p,
                                      int step, int t, int it) {
  const int p3 = p[-4 * step], p2 = p[-3 * step], p1 = p[-2 * step];
  const int p0 = p[-step], q0 = p[0];
  const int q1 = p[step], q2 = p[2 * step], q3 = p[3 * step];
  if ((4 * VP8kabs0[p0 - q0] + VP8kabs0[p1 - q1]) > t) return 0;
  return VP8kabs0[p3 - p2] <= it && VP8kabs0[p2 - p1] <= it &&
         VP8kabs0[p1 - p0] <= it && VP8kabs0[q3 - q2] <= it &&
         VP8kabs0[q2 - q1] <= it && VP8kabs0[q1 - q0] <= it;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movslq %esi, %r10
leaq (%r10,%r10), %rax
negq %rax
movzbl (%rdi,%rax), %r11d
movq %rdi, %rax
subq %r10, %rax
movzbl (%rax), %ebx
movzbl (%rdi), %esi
movzbl (%rdi,%r10), %r8d
leaq 0x90159(%rip), %rax     # 0x160fe8
movq (%rax), %r9
movq %rbx, %rax
subq %rsi, %rax
movzbl (%r9,%rax), %eax
movq %r11, %r14
subq %r8, %r14
movzbl (%r9,%r14), %r14d
leal (%r14,%rax,4), %ebp
xorl %eax, %eax
cmpl %edx, %ebp
jg 0xd0f25
imulq $-0x3, %r10, %rdx
movzbl (%rdi,%rdx), %edx
leaq (,%r10,4), %r14
movq %rdi, %r15
subq %r14, %r15
movzbl (%r15), %r14d
subq %rdx, %r14
movzbl (%r9,%r14), %ebp
cmpl %ecx, %ebp
jg 0xd0f25
subq %r11, %rdx
movzbl (%r9,%rdx), %edx
cmpl %ecx, %edx
ja 0xd0f25
subq %rbx, %r11
movzbl (%r9,%r11), %edx
cmpl %ecx, %edx
ja 0xd0f25
movzbl (%rdi,%r10,2), %edx
leaq (%r10,%r10,2), %r10
movzbl (%rdi,%r10), %edi
subq %rdx, %rdi
movzbl (%r9,%rdi), %edi
cmpl %ecx, %edi
ja 0xd0f25
subq %r8, %rdx
movzbl (%r9,%rdx), %edx
cmpl %ecx, %edx
ja 0xd0f25
subq %rsi, %r8
movzbl (%r9,%r8), %edx
xorl %eax, %eax
cmpl %ecx, %edx
setbe %al
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: DoFilter2_C
static WEBP_INLINE void DoFilter2_C(uint8_t* p, int step) {
  const int p1 = p[-2*step], p0 = p[-step], q0 = p[0], q1 = p[step];
  const int a = 3 * (q0 - p0) + VP8ksclip1[p1 - q1];  // in [-893,892]
  const int a1 = VP8ksclip2[(a + 4) >> 3];            // in [-16,15]
  const int a2 = VP8ksclip2[(a + 3) >> 3];
  p[-step] = VP8kclip1[p0 + a2];
  p[    0] = VP8kclip1[q0 - a1];
}

// Assembly:
movslq %esi, %rsi
leaq (%rsi,%rsi), %rax
negq %rax
movzbl (%rdi,%rax), %r8d
movq %rdi, %rax
subq %rsi, %rax
movzbl (%rax), %edx
movzbl (%rdi), %ecx
movzbl (%rdi,%rsi), %esi
movl %ecx, %r9d
subl %edx, %r9d
leal (%r9,%r9,2), %r9d
leaq 0x9002d(%rip), %r10     # 0x160fd0
movq (%r10), %r10
subq %rsi, %r8
movsbl (%r10,%r8), %esi
leaq 0x90023(%rip), %r8      # 0x160fd8
movq (%r8), %r8
leal (%rsi,%r9), %r10d
addl $0x4, %r10d
sarl $0x3, %r10d
movslq %r10d, %r10
movsbq (%r8,%r10), %r10
addl %r9d, %esi
addl $0x3, %esi
sarl $0x3, %esi
movslq %esi, %rsi
movsbq (%r8,%rsi), %rsi
leaq 0x8fffc(%rip), %r8      # 0x160fe0
movq (%r8), %r8
addq %rdx, %rsi
movb (%r8,%rsi), %dl
movb %dl, (%rax)
subq %r10, %rcx
movb (%r8,%rcx), %al
movb %al, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: FilterLoop24_C
static WEBP_INLINE void FilterLoop24_C(uint8_t* p,
                                       int hstride, int vstride, int size,
                                       int thresh, int ithresh,
                                       int hev_thresh) {
  const int thresh2 = 2 * thresh + 1;
  while (size-- > 0) {
    if (NeedsFilter2_C(p, hstride, thresh2, ithresh)) {
      if (Hev(p, hstride, hev_thresh)) {
        DoFilter2_C(p, hstride);
      } else {
        DoFilter4_C(p, hstride);
      }
    }
    p += vstride;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0x4(%rsp)
movl %ecx, %ebp
movl %esi, %r14d
movq %rdi, %r15
leal 0x1(,%r8,2), %r13d
leal (%r14,%r14), %eax
negl %eax
cltq
movq %rax, 0x20(%rsp)
movl %esi, %eax
negl %eax
cltq
movq %rax, 0x18(%rsp)
movslq %esi, %rax
movq %rax, 0x10(%rsp)
leaq 0x8ff94(%rip), %rax     # 0x160fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x8ff8d(%rip), %rax     # 0x160fe0
movq (%rax), %r12
movslq %edx, %rbx
movl %r13d, (%rsp)
testl %ebp, %ebp
jle 0xd1135
movq %r15, %rdi
movl %r14d, %esi
movl %r13d, %edx
movl 0x4(%rsp), %ecx
callq 0xd0e62
testl %eax, %eax
je 0xd112b
movq %r15, %rdi
movl %r14d, %esi
movl 0x60(%rsp), %edx
callq 0xd0f2c
testl %eax, %eax
je 0xd10a2
movq %r15, %rdi
movl %r14d, %esi
callq 0xd0f73
jmp 0xd112b
movq 0x20(%rsp), %r10
movzbl (%r15,%r10), %esi
movq 0x18(%rsp), %r11
movzbl (%r15,%r11), %edx
movzbl (%r15), %ecx
movq 0x10(%rsp), %r13
movzbl (%r15,%r13), %eax
movl %ecx, %edi
subl %edx, %edi
leal (%rdi,%rdi,2), %r8d
addl $0x4, %r8d
sarl $0x3, %r8d
movslq %r8d, %r8
movq 0x8(%rsp), %r9
movsbq (%r9,%r8), %r8
leal (%rdi,%rdi,2), %edi
addl $0x3, %edi
sarl $0x3, %edi
movslq %edi, %rdi
movsbq (%r9,%rdi), %rdi
leal 0x1(%r8), %r9d
sarl %r9d
movslq %r9d, %r9
addq %r9, %rsi
movb (%r12,%rsi), %sil
movb %sil, (%r15,%r10)
addq %rdx, %rdi
movb (%r12,%rdi), %dl
movb %dl, (%r15,%r11)
subq %r8, %rcx
movb (%r12,%rcx), %cl
movb %cl, (%r15)
subq %r9, %rax
movb (%r12,%rax), %al
movb %al, (%r15,%r13)
movl (%rsp), %r13d
addq %rbx, %r15
decl %ebp
jmp 0xd105d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: TrueMotion
static WEBP_INLINE void TrueMotion(uint8_t* dst, int size) {
  const uint8_t* top = dst - BPS;
  const uint8_t* const clip0 = VP8kclip1 - top[-1];
  int y;
  for (y = 0; y < size; ++y) {
    const uint8_t* const clip = clip0 + dst[-1];
    int x;
    for (x = 0; x < size; ++x) {
      dst[x] = clip[top[x]];
    }
    dst += BPS;
  }
}

// Assembly:
leaq 0x8fe56(%rip), %rax     # 0x160fe0
movq (%rax), %rax
movzbl -0x21(%rdi), %ecx
subq %rcx, %rax
xorl %ecx, %ecx
testl %esi, %esi
movl $0x0, %edx
cmovgl %esi, %edx
movl %esi, %esi
movq %rdi, %r8
cmpl %edx, %ecx
je 0xd11d4
movzbl -0x1(%r8), %r9d
addq %rax, %r9
xorl %r10d, %r10d
cmpq %r10, %rsi
je 0xd11cc
movzbl -0x20(%rdi,%r10), %r11d
movb (%r9,%r11), %r11b
movb %r11b, (%r8,%r10)
incq %r10
jmp 0xd11b4
addq $0x20, %r8
incl %ecx
jmp 0xd11a5
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/filters.c
// Function: HorizontalUnfilter_C
static void HorizontalUnfilter_C(const uint8_t* prev, const uint8_t* in,
                                 uint8_t* out, int width) {
  uint8_t pred = (prev == NULL) ? 0 : prev[0];
  int i;
  for (i = 0; i < width; ++i) {
    out[i] = (uint8_t)(pred + in[i]);
    pred = out[i];
  }
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0xd1422
movb (%rdi), %dil
jmp 0xd1424
xorl %edi, %edi
testl %ecx, %ecx
cmovlel %eax, %ecx
cmpq %rax, %rcx
je 0xd143b
addb (%rsi,%rax), %dil
movb %dil, (%rdx,%rax)
incq %rax
jmp 0xd1429
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/filters.c
// Function: GradientUnfilter_C
static void GradientUnfilter_C(const uint8_t* prev, const uint8_t* in,
                               uint8_t* out, int width) {
  if (prev == NULL) {
    HorizontalUnfilter_C(NULL, in, out, width);
  } else {
    uint8_t top = prev[0], top_left = top, left = top;
    int i;
    for (i = 0; i < width; ++i) {
      top = prev[i];  // need to read this first, in case prev==out
      left = (uint8_t)(in[i] + GradientPredictor_C(left, top, top_left));
      top_left = top;
      out[i] = left;
    }
  }
}

// Assembly:
testq %rdi, %rdi
je 0xd14b7
movb (%rdi), %r10b
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
movl %r10d, %r8d
cmpq %rax, %rcx
je 0xd14b6
movzbl (%rdi,%rax), %r9d
movzbl %r8b, %r8d
movzbl %r10b, %r10d
subl %r10d, %r8d
addl %r9d, %r8d
testl %r8d, %r8d
jg 0xd1495
xorl %r8d, %r8d
movl $0xff, %r10d
cmpl %r10d, %r8d
jl 0xd14a6
movl $0xff, %r8d
addb (%rsi,%rax), %r8b
movb %r8b, (%rdx,%rax)
incq %rax
movl %r9d, %r10d
jmp 0xd1475
retq
xorl %edi, %edi
jmp 0xd1416
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/filters.c
// Function: HorizontalFilter_C
static WEBP_INLINE void DoHorizontalFilter_C(const uint8_t* in,
                                             int width, int height, int stride,
                                             int row, int num_rows,
                                             int inverse, uint8_t* out) {
  const uint8_t* preds;
  const size_t start_offset = row * stride;
  const int last_row = row + num_rows;
  DCHECK(in, out);
  in += start_offset;
  out += start_offset;
  preds = inverse ? out : in;

  if (row == 0) {
    // Leftmost pixel is the same as input for topmost scanline.
    out[0] = in[0];
    PredictLine_C(in + 1, preds, out + 1, width - 1, inverse);
    row = 1;
    preds += stride;
    in += stride;
    out += stride;
  }

  // Filter line-by-line.
  while (row < last_row) {
    // Leftmost pixel is predicted from above.
    PredictLine_C(in, preds - stride, out, 1, inverse);
    PredictLine_C(in + 1, preds, out + 1, width - 1, inverse);
    ++row;
    preds += stride;
    in += stride;
    out += stride;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd156a
movq %r8, %rbx
testq %r8, %r8
je 0xd1573
movl %esi, %r14d
testl %esi, %esi
jle 0xd157c
movl %edx, %ebp
testl %edx, %edx
jle 0xd1585
movl %ecx, %r12d
cmpl %r14d, %ecx
jl 0xd158e
movq %rdi, %r15
movb (%rdi), %al
movb %al, (%rbx)
incq %rdi
leaq 0x1(%rbx), %rdx
decl %r14d
movq %r15, %rsi
movl %r14d, %ecx
callq 0xd17d0
movl %r12d, %r12d
addq %r12, %rbx
decl %ebp
subl $0x1, %ebp
jb 0xd155b
leaq (%r15,%r12), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
pushq $0x1
popq %rcx
callq 0xd17d0
leaq (%r15,%r12), %rdi
incq %rdi
leaq 0x1(%rbx), %rdx
movq %r13, %rsi
movl %r14d, %ecx
callq 0xd17d0
addq %r12, %rbx
movq %r13, %r15
jmp 0xd1523
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4a20d(%rip), %rdi     # 0x11b77e
jmp 0xd1595
leaq 0x4a265(%rip), %rdi     # 0x11b7df
jmp 0xd1595
leaq 0x4a26a(%rip), %rdi     # 0x11b7ed
jmp 0xd1595
leaq 0x4a26b(%rip), %rdi     # 0x11b7f7
jmp 0xd1595
leaq 0x4a26d(%rip), %rdi     # 0x11b802
leaq 0x4a0ab(%rip), %rsi     # 0x11b647
leaq 0x4a1e8(%rip), %rcx     # 0x11b78b
pushq $0x36
popq %rdx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/filters.c
// Function: VerticalFilter_C
static WEBP_INLINE void DoVerticalFilter_C(const uint8_t* in,
                                           int width, int height, int stride,
                                           int row, int num_rows,
                                           int inverse, uint8_t* out) {
  const uint8_t* preds;
  const size_t start_offset = row * stride;
  const int last_row = row + num_rows;
  DCHECK(in, out);
  in += start_offset;
  out += start_offset;
  preds = inverse ? out : in;

  if (row == 0) {
    // Very first top-left pixel is copied.
    out[0] = in[0];
    // Rest of top scan-line is left-predicted.
    PredictLine_C(in + 1, preds, out + 1, width - 1, inverse);
    row = 1;
    in += stride;
    out += stride;
  } else {
    // We are starting from in-between. Make sure 'preds' points to prev row.
    preds -= stride;
  }

  // Filter line-by-line.
  while (row < last_row) {
    PredictLine_C(in, preds, out, width, inverse);
    ++row;
    preds += stride;
    in += stride;
    out += stride;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd162b
movq %r8, %rbx
testq %r8, %r8
je 0xd1634
movl %esi, %r14d
testl %esi, %esi
jle 0xd163d
movl %edx, %ebp
testl %edx, %edx
jle 0xd1646
movl %ecx, %r12d
cmpl %r14d, %ecx
jl 0xd164f
movq %rdi, %r15
movb (%rdi), %al
movb %al, (%rbx)
incq %rdi
leaq 0x1(%rbx), %rdx
leal -0x1(%r14), %ecx
movq %r15, %rsi
callq 0xd17d0
movl %r12d, %r13d
addq %r13, %rbx
decl %ebp
subl $0x1, %ebp
jb 0xd161c
leaq (%r15,%r13), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl %r14d, %ecx
callq 0xd17d0
addq %r13, %rbx
movq %r12, %r15
jmp 0xd15fa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4a14c(%rip), %rdi     # 0x11b77e
jmp 0xd1656
leaq 0x4a1a4(%rip), %rdi     # 0x11b7df
jmp 0xd1656
leaq 0x4a1a9(%rip), %rdi     # 0x11b7ed
jmp 0xd1656
leaq 0x4a1aa(%rip), %rdi     # 0x11b7f7
jmp 0xd1656
leaq 0x4a1ac(%rip), %rdi     # 0x11b802
leaq 0x49fea(%rip), %rsi     # 0x11b647
leaq 0x4a1ae(%rip), %rcx     # 0x11b812
pushq $0x5b
popq %rdx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless.c
// Function: VP8LAddGreenToBlueAndRed_C
void VP8LAddGreenToBlueAndRed_C(const uint32_t* src, int num_pixels,
                                uint32_t* dst) {
  int i;
  for (i = 0; i < num_pixels; ++i) {
    const uint32_t argb = src[i];
    const uint32_t green = ((argb >> 8) & 0xff);
    uint32_t red_blue = (argb & 0x00ff00ffu);
    red_blue += (green << 16) | green;
    red_blue &= 0x00ff00ffu;
    dst[i] = (argb & 0xff00ff00u) | red_blue;
  }
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
movl $0xff00ff, %ecx         # imm = 0xFF00FF
cmpq %rax, %rsi
je 0xd1b82
movl (%rdi,%rax,4), %r8d
movl %r8d, %r9d
shrl $0x8, %r9d
movzbl %r9b, %r10d
movl %r8d, %r11d
andl %ecx, %r11d
addl %r10d, %r11d
shll $0x10, %r9d
addl %r11d, %r9d
andl %ecx, %r9d
andl $0xff00ff00, %r8d       # imm = 0xFF00FF00
orl %r9d, %r8d
movl %r8d, (%rdx,%rax,4)
incq %rax
jmp 0xd1b48
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless.c
// Function: VP8LTransformColorInverse_C
void VP8LTransformColorInverse_C(const VP8LMultipliers* const m,
                                 const uint32_t* src, int num_pixels,
                                 uint32_t* dst) {
  int i;
  for (i = 0; i < num_pixels; ++i) {
    const uint32_t argb = src[i];
    const int8_t green = (int8_t)(argb >> 8);
    const uint32_t red = argb >> 16;
    int new_red = red & 0xff;
    int new_blue = argb & 0xff;
    new_red += ColorTransformDelta((int8_t)m->green_to_red_, green);
    new_red &= 0xff;
    new_blue += ColorTransformDelta((int8_t)m->green_to_blue_, green);
    new_blue += ColorTransformDelta((int8_t)m->red_to_blue_, (int8_t)new_red);
    new_blue &= 0xff;
    dst[i] = (argb & 0xff00ff00u) | (new_red << 16) | (new_blue);
  }
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
cmpq %rax, %rdx
je 0xd1bfa
movl (%rsi,%rax,4), %r8d
movl %r8d, %r9d
shrl $0x10, %r9d
movsbl (%rdi), %r10d
movl %r8d, %r11d
shrl $0x8, %r11d
movsbl %r11b, %r11d
imull %r11d, %r10d
sarl $0x5, %r10d
addl %r9d, %r10d
movsbl 0x1(%rdi), %r9d
imull %r11d, %r9d
shrl $0x5, %r9d
addl %r8d, %r9d
movsbl 0x2(%rdi), %r11d
movsbl %r10b, %r10d
imull %r10d, %r11d
shrl $0x5, %r11d
addl %r9d, %r11d
movzbl %r11b, %r9d
andl $0xff00ff00, %r8d       # imm = 0xFF00FF00
movzbl %r10b, %r10d
shll $0x10, %r10d
orl %r8d, %r10d
orl %r9d, %r10d
movl %r10d, (%rcx,%rax,4)
incq %rax
jmp 0xd1b8a
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless.c
// Function: VP8LConvertBGRAToRGB_C
void VP8LConvertBGRAToRGB_C(const uint32_t* src,
                            int num_pixels, uint8_t* dst) {
  const uint32_t* const src_end = src + num_pixels;
  while (src < src_end) {
    const uint32_t argb = *src++;
    *dst++ = (argb >> 16) & 0xff;
    *dst++ = (argb >>  8) & 0xff;
    *dst++ = (argb >>  0) & 0xff;
  }
}

// Assembly:
movslq %esi, %rax
leaq (%rdi,%rax,4), %rax
cmpq %rax, %rdi
jae 0xd21ba
movl (%rdi), %ecx
addq $0x4, %rdi
movl %ecx, %esi
shrl $0x10, %esi
movb %sil, (%rdx)
movb %ch, 0x1(%rdx)
movb %cl, 0x2(%rdx)
addq $0x3, %rdx
jmp 0xd219b
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless.c
// Function: VP8LConvertBGRAToRGBA_C
void VP8LConvertBGRAToRGBA_C(const uint32_t* src,
                             int num_pixels, uint8_t* dst) {
  const uint32_t* const src_end = src + num_pixels;
  while (src < src_end) {
    const uint32_t argb = *src++;
    *dst++ = (argb >> 16) & 0xff;
    *dst++ = (argb >>  8) & 0xff;
    *dst++ = (argb >>  0) & 0xff;
    *dst++ = (argb >> 24) & 0xff;
  }
}

// Assembly:
movslq %esi, %rax
leaq (%rdi,%rax,4), %rax
cmpq %rax, %rdi
jae 0xd21e7
movl (%rdi), %ecx
addq $0x4, %rdi
movl %ecx, %esi
shrl $0x10, %esi
movb %sil, (%rdx)
movb %ch, 0x1(%rdx)
movb %cl, 0x2(%rdx)
shrl $0x18, %ecx
movb %cl, 0x3(%rdx)
addq $0x4, %rdx
jmp 0xd21c2
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless.c
// Function: VP8LConvertBGRAToRGBA4444_C
void VP8LConvertBGRAToRGBA4444_C(const uint32_t* src,
                                 int num_pixels, uint8_t* dst) {
  const uint32_t* const src_end = src + num_pixels;
  while (src < src_end) {
    const uint32_t argb = *src++;
    const uint8_t rg = ((argb >> 16) & 0xf0) | ((argb >> 12) & 0xf);
    const uint8_t ba = ((argb >>  0) & 0xf0) | ((argb >> 28) & 0xf);
#if (WEBP_SWAP_16BIT_CSP == 1)
    *dst++ = ba;
    *dst++ = rg;
#else
    *dst++ = rg;
    *dst++ = ba;
#endif
  }
}

// Assembly:
movslq %esi, %rax
leaq (%rdi,%rax,4), %rax
movl $0xf0, %ecx
cmpq %rax, %rdi
jae 0xd2230
movl (%rdi), %esi
addq $0x4, %rdi
movl %esi, %r8d
shrl $0x10, %r8d
andl %ecx, %r8d
movl %esi, %r9d
shrl $0xc, %r9d
andl $0xf, %r9d
orl %r8d, %r9d
movl %esi, %r8d
andl %ecx, %r8d
shrl $0x1c, %esi
orl %r8d, %esi
movb %r9b, (%rdx)
movb %sil, 0x1(%rdx)
addq $0x2, %rdx
jmp 0xd21f4
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless.c
// Function: VP8LConvertBGRAToRGB565_C
void VP8LConvertBGRAToRGB565_C(const uint32_t* src,
                               int num_pixels, uint8_t* dst) {
  const uint32_t* const src_end = src + num_pixels;
  while (src < src_end) {
    const uint32_t argb = *src++;
    const uint8_t rg = ((argb >> 16) & 0xf8) | ((argb >> 13) & 0x7);
    const uint8_t gb = ((argb >>  5) & 0xe0) | ((argb >>  3) & 0x1f);
#if (WEBP_SWAP_16BIT_CSP == 1)
    *dst++ = gb;
    *dst++ = rg;
#else
    *dst++ = rg;
    *dst++ = gb;
#endif
  }
}

// Assembly:
movslq %esi, %rax
leaq (%rdi,%rax,4), %rax
cmpq %rax, %rdi
jae 0xd227b
movl (%rdi), %ecx
addq $0x4, %rdi
movl %ecx, %esi
shrl $0x10, %esi
andl $0xf8, %esi
movl %ecx, %r8d
shrl $0xd, %r8d
andl $0x7, %r8d
orl %esi, %r8d
movl %ecx, %esi
shrl $0x5, %esi
andl $0xe0, %esi
shrl $0x3, %ecx
andl $0x1f, %ecx
orl %esi, %ecx
movb %r8b, (%rdx)
movb %cl, 0x1(%rdx)
addq $0x2, %rdx
jmp 0xd2238
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless.c
// Function: CopyOrSwap
static void CopyOrSwap(const uint32_t* src, int num_pixels, uint8_t* dst,
                       int swap_on_big_endian) {
  if (is_big_endian() == swap_on_big_endian) {
    const uint32_t* const src_end = src + num_pixels;
    while (src < src_end) {
      const uint32_t argb = *src++;
      WebPUint32ToMem(dst, BSwap32(argb));
      dst += sizeof(argb);
    }
  } else {
    memcpy(dst, src, num_pixels * sizeof(*src));
  }
}

// Assembly:
movq %rdi, %r8
movslq %esi, %rax
testl %ecx, %ecx
je 0xd23f7
shlq $0x2, %rax
movq %rdx, %rdi
movq %r8, %rsi
movq %rax, %rdx
jmp 0x562f0
leaq (%r8,%rax,4), %rax
cmpq %rax, %r8
jae 0xd2411
movl (%r8), %ecx
addq $0x4, %r8
bswapl %ecx
movl %ecx, (%rdx)
addq $0x4, %rdx
jmp 0xd23fb
retq