LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %ebp, %ebp
xorl %eax, %eax
xorl %ecx, %ecx
cpuid
testl %eax, %eax
jle 0xd745a
movl %ebx, %r8d
movl %ecx, %esi
movl %edx, %r9d
movl %eax, %r14d
xorl %ebp, %ebp
movl $0x1, %eax
xorl %ecx, %ecx
cpuid
cmpl $0x5, %edi
ja 0xd745a
movl %edi, %edi
leaq 0x532e4(%rip), %r10     # 0x12a698
movslq (%r10,%rdi,4), %rdi
addq %r10, %rdi
jmpq *%rdi
shrl $0x1a, %edx
andl $0x1, %edx
movl %edx, %ebp
jmp 0xd745a
notl %ecx
testl $0x18000000, %ecx       # imm = 0x18000000
jne 0xd745a
xorl %ecx, %ecx
xgetbv
notl %eax
xorl %ebp, %ebp
testb $0x6, %al
sete %bpl
jmp 0xd745a
xorl $0x756e6547, %r8d       # imm = 0x756E6547
xorl $0x6c65746e, %esi       # imm = 0x6C65746E
orl %r8d, %esi
xorl $0x49656e69, %r9d       # imm = 0x49656E69
orl %esi, %r9d
setne %dl
btl $0x9, %ecx
setae %cl
orb %dl, %cl
jne 0xd745a
movl %eax, %ecx
andl $0xf00, %ecx            # imm = 0xF00
cmpl $0x600, %ecx            # imm = 0x600
jne 0xd745a
movl %eax, %ecx
shrl $0xc, %ecx
andl $0xf0, %ecx
shrl $0x4, %eax
andl $0xf, %eax
orl %ecx, %eax
xorl %ecx, %ecx
leaq 0x53273(%rip), %rdx     # 0x12a6b0
xorl %ebp, %ebp
movzbl (%rcx,%rdx), %esi
cmpl %esi, %eax
je 0xd7488
incq %rcx
cmpq $0x6, %rcx
jne 0xd743f
jmp 0xd745a
shrl $0x13, %ecx
andl $0x1, %ecx
movl %ecx, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x4, %edi
callq 0xd7378
cmpl $0x7, %r14d
jb 0xd745a
testl %eax, %eax
je 0xd745a
movl $0x7, %eax
xorl %ecx, %ecx
cpuid
movl %ebx, %ebp
shrl $0x5, %ebp
andl $0x1, %ebp
jmp 0xd745a
movl $0x1, %ebp
jmp 0xd745a
nop
// File: /workspace/github_c_makefile_star2_O3/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:
movq (%rdi), %xmm0
punpcklwd %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3]
psrad $0x10, %xmm0
movq 0x18(%rdi), %xmm1
punpcklwd %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3]
psrad $0x10, %xmm1
movdqa %xmm1, %xmm2
paddd %xmm0, %xmm2
movq 0x8(%rdi), %xmm3
punpcklwd %xmm3, %xmm3    # xmm3 = xmm3[0,0,1,1,2,2,3,3]
psrad $0x10, %xmm3
movq 0x10(%rdi), %xmm4
punpcklwd %xmm4, %xmm4    # xmm4 = xmm4[0,0,1,1,2,2,3,3]
psrad $0x10, %xmm4
movdqa %xmm4, %xmm5
paddd %xmm3, %xmm5
psubd %xmm4, %xmm3
psubd %xmm1, %xmm0
movdqa %xmm5, %xmm1
paddd %xmm2, %xmm1
movdqa %xmm1, -0x48(%rsp)
psubd %xmm5, %xmm2
movdqa %xmm2, -0x28(%rsp)
movdqa %xmm3, %xmm1
paddd %xmm0, %xmm1
movdqa %xmm1, -0x38(%rsp)
psubd %xmm3, %xmm0
movdqa %xmm0, -0x18(%rsp)
xorl %eax, %eax
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
cmpq $0x40, %rax
jne 0xd7f38
retq
// File: /workspace/github_c_makefile_star2_O3/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
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
psrad $0x3, %xmm0
xorl %eax, %eax
pxor %xmm1, %xmm1
movd (%rsi,%rax), %xmm2
punpcklbw %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3],xmm2[4],xmm1[4],xmm2[5],xmm1[5],xmm2[6],xmm1[6],xmm2[7],xmm1[7]
punpcklwd %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3]
paddd %xmm0, %xmm2
packssdw %xmm2, %xmm2
packuswb %xmm2, %xmm2
movd %xmm2, (%rsi,%rax)
addq $0x20, %rax
cmpq $0x80, %rax
jne 0xd7fe0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd82a0
movq %r14, %rdi
movq %rbx, %rsi
callq *0xa30b0(%rip)          # 0x17b350
cmpw $0x0, 0x20(%r14)
je 0xd82b6
leaq 0x20(%r14), %rdi
leaq 0x4(%rbx), %rsi
callq *0xa309a(%rip)          # 0x17b350
cmpw $0x0, 0x40(%r14)
je 0xd82cf
leaq 0x40(%r14), %rdi
leaq 0x80(%rbx), %rsi
callq *0xa3081(%rip)          # 0x17b350
cmpw $0x0, 0x60(%r14)
je 0xd82f8
addq $0x60, %r14
movq 0xa306e(%rip), %rax     # 0x17b350
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_O3/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
movl $0x4, %ebx
movl 0x14(%rsp), %eax
movl %eax, (%rsp)
movq %r12, %rdi
movl %r15d, %esi
movl $0x1, %edx
movl $0x10, %ecx
movl %r14d, %r8d
movl %ebp, %r9d
callq 0xd9657
decl %ebx
addq %r13, %r12
cmpl $0x1, %ebx
ja 0xd834f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/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 %r13
pushq %r12
pushq %rbx
leal 0x1(,%rdx,2), %eax
movslq %esi, %rcx
leaq (%rcx,%rcx), %rdx
negq %rdx
movq %rcx, %rsi
negq %rsi
leaq 0x92b42(%rip), %r8      # 0x16afe8
movq (%r8), %r8
leaq 0x92b20(%rip), %r9      # 0x16afd0
movq (%r9), %r9
leaq 0x92b1e(%rip), %r10     # 0x16afd8
movq (%r10), %r10
leaq 0x92b1c(%rip), %r11     # 0x16afe0
movq (%r11), %r11
movl $0x10, %ebx
movzbl (%rdi,%rdx), %r12d
movzbl (%rdi,%rsi), %r15d
movzbl (%rdi), %r14d
movzbl (%rdi,%rcx), %r13d
movq %r15, %rbp
subq %r14, %rbp
movzbl (%r8,%rbp), %ebp
subq %r13, %r12
movzbl (%r8,%r12), %r13d
leal (%r13,%rbp,4), %ebp
cmpl %eax, %ebp
jg 0xd8548
movl %r14d, %r13d
subl %r15d, %r13d
leal (%r13,%r13,2), %r13d
movsbl (%r9,%r12), %r12d
leal (%r12,%r13), %ebp
addl $0x4, %ebp
sarl $0x3, %ebp
movslq %ebp, %rbp
movsbq (%r10,%rbp), %rbp
addl %r13d, %r12d
addl $0x3, %r12d
sarl $0x3, %r12d
movslq %r12d, %r12
movsbq (%r10,%r12), %r12
movl %r15d, %r15d
addq %r12, %r15
movb (%r11,%r15), %r15b
movb %r15b, (%rdi,%rsi)
subq %rbp, %r14
movb (%r11,%r14), %bpl
movb %bpl, (%rdi)
incq %rdi
decq %rbx
jne 0xd84cc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/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
leal 0x1(%rdx,%rdx), %eax
leaq 0x92a76(%rip), %rcx     # 0x16afe8
movq (%rcx), %rcx
leaq 0x92a54(%rip), %rdx     # 0x16afd0
movq (%rdx), %rdx
leaq 0x92a52(%rip), %r8      # 0x16afd8
movq (%r8), %r8
leaq 0x92a50(%rip), %r9      # 0x16afe0
movq (%r9), %r9
movslq %esi, %rsi
movl $0x10, %r10d
movzbl -0x2(%rdi), %r14d
movzbl -0x1(%rdi), %ebx
movzbl (%rdi), %r11d
movzbl 0x1(%rdi), %r15d
movq %rbx, %r12
subq %r11, %r12
movzbl (%rcx,%r12), %r12d
subq %r15, %r14
movzbl (%rcx,%r14), %r15d
leal (%r15,%r12,4), %ebp
cmpl %eax, %ebp
jg 0xd8612
movl %r11d, %r15d
subl %ebx, %r15d
leal (%r15,%r15,2), %r15d
movsbl (%rdx,%r14), %r14d
leal (%r14,%r15), %ebp
addl $0x4, %ebp
sarl $0x3, %ebp
movslq %ebp, %r12
movsbq (%r8,%r12), %r12
leal (%r14,%r15), %ebp
addl $0x3, %ebp
sarl $0x3, %ebp
movslq %ebp, %r14
movsbq (%r8,%r14), %r14
movl %ebx, %ebx
addq %r14, %rbx
movb (%r9,%rbx), %bl
movb %bl, -0x1(%rdi)
subq %r12, %r11
movb (%r9,%r11), %r11b
movb %r11b, (%rdi)
addq %rsi, %rdi
decq %r10
jne 0xd859c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x4, %ebp
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0xd847e
decl %ebp
addq %r12, %r15
cmpl $0x1, %ebp
ja 0xd8646
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
addq $0x4, %r14
movl $0x4, %r15d
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0xd855f
decl %r15d
addq $0x4, %r14
cmpl $0x1, %r15d
ja 0xd867e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
addq $0x4, %r12
movl $0x4, %r13d
movl %ebx, (%rsp)
movq %r12, %rdi
movl $0x1, %esi
movl %r15d, %edx
movl $0x10, %ecx
movl %r14d, %r8d
movl %ebp, %r9d
callq 0xd9657
decl %r13d
addq $0x4, %r12
cmpl $0x1, %r13d
ja 0xd86c5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: TM4_C
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 0x927d4(%rip), %rax     # 0x16afe0
movq (%rax), %rax
movzbl -0x21(%rdi), %ecx
subq %rcx, %rax
xorl %ecx, %ecx
movq %rdi, %rdx
movzbl -0x1(%rdx), %esi
addq %rax, %rsi
xorl %r8d, %r8d
movzbl -0x20(%rdi,%r8), %r9d
movb (%rsi,%r9), %r9b
movb %r9b, (%rdx,%r8)
incq %r8
cmpq $0x4, %r8
jne 0xd8825
addq $0x20, %rdx
incl %ecx
cmpl $0x4, %ecx
jne 0xd881b
retq
// File: /workspace/github_c_makefile_star2_O3/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:
leaq -0x1(%rdi), %rcx
movl $0x10, %eax
movq $-0x10, %rdx
movzbl (%rcx), %esi
addl %eax, %esi
movzbl -0x10(%rdi,%rdx), %eax
addl %esi, %eax
addq $0x20, %rcx
incq %rdx
jne 0xd8da8
shrl $0x5, %eax
xorl %ecx, %ecx
movzbl %al, %eax
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]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqu %xmm0, (%rdi,%rcx)
addq $0x20, %rcx
cmpq $0x200, %rcx            # imm = 0x200
jne 0xd8dd7
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl $0x11, %eax
movzbl -0x1(%rdi), %ecx
movd %ecx, %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, (%rdi)
addq $0x20, %rdi
decl %eax
cmpl $0x1, %eax
ja 0xd8e4d
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movd 0x51849(%rip), %xmm0    # 0x12a710
movq $-0x10, %rax
pxor %xmm1, %xmm1
movd -0x10(%rdi,%rax), %xmm2
punpcklbw %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3],xmm2[4],xmm1[4],xmm2[5],xmm1[5],xmm2[6],xmm1[6],xmm2[7],xmm1[7]
punpcklwd %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3]
paddd %xmm2, %xmm0
addq $0x4, %rax
jne 0xd8ed2
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0     # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, %ecx
shrl $0x4, %ecx
xorl %eax, %eax
movzbl %cl, %ecx
movd %ecx, %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, (%rdi,%rax)
addq $0x20, %rax
cmpq $0x200, %rax            # imm = 0x200
jne 0xd8f1a
retq
// File: /workspace/github_c_makefile_star2_O3/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:
leaq -0x20(%rdi), %rcx
movl $0x8, %eax
movq $-0x1, %rdx
movzbl (%rcx), %esi
addl %eax, %esi
movzbl (%rdi,%rdx), %eax
addl %esi, %eax
incq %rcx
addq $0x20, %rdx
cmpq $0xff, %rdx
jne 0xd8f56
shrl $0x4, %eax
xorl %ecx, %ecx
movzbl %al, %edx
movabsq $0x101010101010101, %rax # imm = 0x101010101010101
imulq %rdx, %rax
movq %rax, (%rdi,%rcx)
addq $0x20, %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0xd8f87
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl $0x4, %eax
movq $-0x1, %rcx
movzbl (%rdi,%rcx), %edx
addl %edx, %eax
addq $0x20, %rcx
cmpq $0xff, %rcx
jne 0xd9025
shrl $0x3, %eax
xorl %ecx, %ecx
movzbl %al, %edx
movabsq $0x101010101010101, %rax # imm = 0x101010101010101
imulq %rdx, %rax
movq %rax, (%rdi,%rcx)
addq $0x20, %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0xd904e
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movd -0x20(%rdi), %xmm0
pxor %xmm1, %xmm1
punpcklbw %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3],xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
punpcklwd %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
movd -0x1c(%rdi), %xmm2
punpcklbw %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3],xmm2[4],xmm1[4],xmm2[5],xmm1[5],xmm2[6],xmm1[6],xmm2[7],xmm1[7]
punpcklwd %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3]
paddd %xmm0, %xmm2
paddd 0x51656(%rip), %xmm2    # 0x12a6e0
pshufd $0xee, %xmm2, %xmm0     # xmm0 = xmm2[2,3,2,3]
paddd %xmm2, %xmm0
pshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
paddd %xmm0, %xmm1
movd %xmm1, %ecx
shrl $0x3, %ecx
xorl %eax, %eax
movzbl %cl, %edx
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
imulq %rdx, %rcx
movq %rcx, (%rdi,%rax)
addq $0x20, %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0xd90b6
retq
// File: /workspace/github_c_makefile_star2_O3/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
xorl %r9d, %r9d
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
cmpq $0x8, %r9
jne 0xd90f4
addq %rax, %rsi
addq $0x8, %rdi
incl %r8d
cmpl $0x8, %r8d
jne 0xd90f1
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xd9ade
movb (%rdi), %al
jmp 0xd9ae0
xorl %eax, %eax
testl %ecx, %ecx
jle 0xd9af6
movl %ecx, %ecx
xorl %edi, %edi
addb (%rsi,%rdi), %al
movb %al, (%rdx,%rdi)
incq %rdi
cmpq %rdi, %rcx
jne 0xd9ae8
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/filters.c
// Function: VerticalUnfilter_C
static void VerticalUnfilter_C(const uint8_t* prev, const uint8_t* in,
                               uint8_t* out, int width) {
  if (prev == NULL) {
    HorizontalUnfilter_C(NULL, in, out, width);
  } else {
    int i;
    for (i = 0; i < width; ++i) out[i] = (uint8_t)(prev[i] + in[i]);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xd9b1a
testl %ecx, %ecx
jle 0xd9b34
movl %ecx, %eax
xorl %ecx, %ecx
movb (%rsi,%rcx), %r8b
addb (%rdi,%rcx), %r8b
movb %r8b, (%rdx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0xd9b04
jmp 0xd9b34
testl %ecx, %ecx
jle 0xd9b34
movl %ecx, %eax
xorl %ecx, %ecx
xorl %edi, %edi
addb (%rsi,%rcx), %dil
movb %dil, (%rdx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0xd9b24
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd9b89
testl %ecx, %ecx
jle 0xd9ba3
movb (%rdi), %r8b
movl %ecx, %eax
xorl %ecx, %ecx
movl %r8d, %r10d
movzbl (%rdi,%rcx), %r9d
movzbl %r8b, %r8d
movzbl %r10b, %r10d
subl %r10d, %r8d
addl %r9d, %r8d
testl %r8d, %r8d
jg 0xd9b63
xorl %r8d, %r8d
movl $0xff, %r10d
cmpl %r10d, %r8d
jl 0xd9b74
movl $0xff, %r8d
addb (%rsi,%rcx), %r8b
movb %r8b, (%rdx,%rcx)
incq %rcx
movl %r9d, %r10d
cmpq %rcx, %rax
jne 0xd9b48
jmp 0xd9ba3
testl %ecx, %ecx
jle 0xd9ba3
movl %ecx, %eax
xorl %ecx, %ecx
xorl %edi, %edi
addb (%rsi,%rcx), %dil
movb %dil, (%rdx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0xd9b93
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
testq %rdi, %rdi
je 0xd9c4f
testq %r8, %r8
je 0xd9c58
testl %esi, %esi
jle 0xd9c61
testl %edx, %edx
jle 0xd9c6a
cmpl %esi, %ecx
jl 0xd9c73
movb (%rdi), %al
movb %al, (%r8)
decl %esi
movl %esi, %eax
je 0xd9bf5
xorl %r9d, %r9d
movb 0x1(%rdi,%r9), %r10b
subb (%rdi,%r9), %r10b
movb %r10b, 0x1(%r8,%r9)
incq %r9
cmpq %r9, %rax
jne 0xd9bdf
cmpl $0x1, %edx
je 0xd9c48
movl %ecx, %ecx
leaq (%r8,%rcx), %r9
incq %r9
leaq (%rdi,%rcx), %r10
incq %r10
movl $0x1, %r11d
movb (%rdi,%rcx), %bl
subb (%rdi), %bl
movb %bl, (%r8,%rcx)
testl %esi, %esi
je 0xd9c34
xorl %ebx, %ebx
movb (%r10,%rbx), %bpl
subb -0x1(%r10,%rbx), %bpl
movb %bpl, (%r9,%rbx)
incq %rbx
cmpq %rbx, %rax
jne 0xd9c1f
addq %rcx, %rdi
addq %rcx, %r8
incl %r11d
addq %rcx, %r9
addq %rcx, %r10
cmpl %edx, %r11d
jne 0xd9c10
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x51e48(%rip), %rdi     # 0x12ba9e
jmp 0xd9c7a
leaq 0x51ea0(%rip), %rdi     # 0x12baff
jmp 0xd9c7a
leaq 0x51ea5(%rip), %rdi     # 0x12bb0d
jmp 0xd9c7a
leaq 0x51ea6(%rip), %rdi     # 0x12bb17
jmp 0xd9c7a
leaq 0x51ea8(%rip), %rdi     # 0x12bb22
leaq 0x51ce6(%rip), %rsi     # 0x12b967
leaq 0x51e23(%rip), %rcx     # 0x12baab
movl $0x36, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0xda28e
movl %esi, %eax
xorl %ecx, %ecx
movl $0xff00ff, %esi         # imm = 0xFF00FF
movl (%rdi,%rcx,4), %r8d
movl %r8d, %r9d
shrl $0x8, %r9d
movzbl %r9b, %r10d
movl %r8d, %r11d
andl %esi, %r11d
addl %r10d, %r11d
shll $0x10, %r9d
addl %r11d, %r9d
andl %esi, %r9d
andl $0xff00ff00, %r8d       # imm = 0xFF00FF00
orl %r9d, %r8d
movl %r8d, (%rdx,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0xda256
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0xda8f0
movslq %esi, %rax
leaq (%rdi,%rax,4), %rax
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
cmpq %rax, %rdi
jb 0xda8d3
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0xda91f
movslq %esi, %rax
leaq (%rdi,%rax,4), %rax
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
cmpq %rax, %rdi
jb 0xda8fc
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0xda96a
movslq %esi, %rax
leaq (%rdi,%rax,4), %rax
movl $0xf0, %ecx
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
cmpq %rax, %rdi
jb 0xda930
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0xda9b7
movslq %esi, %rax
leaq (%rdi,%rax,4), %rax
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
cmpq %rax, %rdi
jb 0xda976
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless.c
// Function: PredictorAdd1_C
static void PredictorAdd1_C(const uint32_t* in, const uint32_t* upper,
                            int num_pixels, uint32_t* out) {
  int i;
  uint32_t left = out[-1];
  (void)upper;
  for (i = 0; i < num_pixels; ++i) {
    out[i] = left = VP8LAddPixels(in[i], left);
  }
}

// Assembly:
testl %edx, %edx
jle 0xdb025
pushq %rbx
movl -0x4(%rcx), %eax
movl %edx, %edx
xorl %esi, %esi
movl $0xff00ff00, %r8d       # imm = 0xFF00FF00
movl $0xff00ff, %r9d         # imm = 0xFF00FF
movl (%rdi,%rsi,4), %r10d
movl %r10d, %r11d
andl %r8d, %r11d
movl %eax, %ebx
andl %r8d, %ebx
addl %r11d, %ebx
andl %r9d, %r10d
andl %r9d, %eax
addl %r10d, %eax
andl %r8d, %ebx
andl %r9d, %eax
orl %ebx, %eax
movl %eax, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0xdaff6
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/rescaler.c
// Function: WebPRescalerImportRowExpand_C
void WebPRescalerImportRowExpand_C(WebPRescaler* const wrk,
                                   const uint8_t* src) {
  const int x_stride = wrk->num_channels;
  const int x_out_max = wrk->dst_width * wrk->num_channels;
  int channel;
  assert(!WebPRescalerInputDone(wrk));
  assert(wrk->x_expand);
  for (channel = 0; channel < x_stride; ++channel) {
    int x_in = channel;
    int x_out = channel;
    // simple bilinear interpolation
    int accum = wrk->x_add;
    rescaler_t left = (rescaler_t)src[x_in];
    rescaler_t right =
        (wrk->src_width > 1) ? (rescaler_t)src[x_in + x_stride] : left;
    x_in += x_stride;
    while (1) {
      wrk->frow[x_out] = right * wrk->x_add + (left - right) * accum;
      x_out += x_stride;
      if (x_out >= x_out_max) break;
      accum -= wrk->x_sub;
      if (accum < 0) {
        left = right;
        x_in += x_stride;
        assert(x_in < wrk->src_width * x_stride);
        right = (rescaler_t)src[x_in];
        accum += wrk->x_add;
      }
    }
    assert(wrk->x_sub == 0 /* <- special case for src_width=1 */ || accum == 0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x3c(%rdi), %eax
cmpl 0x30(%rdi), %eax
jge 0xdb8a9
cmpl $0x0, (%rdi)
je 0xdb8c8
movslq 0x8(%rdi), %rax
testl %eax, %eax
jle 0xdb862
movslq 0x34(%rdi), %rcx
imulq %rax, %rcx
movq 0x60(%rdi), %rdx
xorl %r8d, %r8d
movl %eax, %r9d
movzbl (%rsi,%r8), %ebp
leaq (%r8,%rax), %r10
cmpl $0x2, 0x2c(%rdi)
movl %ebp, %ebx
jl 0xdb7e9
movzbl (%rsi,%r10), %ebx
movl 0x24(%rdi), %r11d
movl %r11d, %r14d
imull %ebp, %r14d
movl %r14d, (%rdx,%r8,4)
cmpq %rcx, %r10
jge 0xdb848
movslq %r9d, %r14
subl 0x28(%rdi), %r11d
js 0xdb80c
movl 0x24(%rdi), %r15d
jmp 0xdb82b
addl %eax, %r10d
movl 0x2c(%rdi), %ebp
imull %eax, %ebp
cmpl %ebp, %r10d
jge 0xdb86b
movslq %r10d, %r15
movl %ebx, %ebp
movzbl (%rsi,%r15), %ebx
movl 0x24(%rdi), %r15d
addl %r15d, %r11d
imull %ebx, %r15d
movl %ebp, %r12d
subl %ebx, %r12d
imull %r11d, %r12d
addl %r15d, %r12d
movl %r12d, (%rdx,%r14,4)
addq %rax, %r14
cmpq %rcx, %r14
jl 0xdb800
cmpl $0x0, 0x28(%rdi)
je 0xdb853
testl %r11d, %r11d
jne 0xdb88a
incq %r8
incl %r9d
cmpq %rax, %r8
jne 0xdb7d3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x509cc(%rip), %rdi     # 0x12c23e
leaq 0x50969(%rip), %rsi     # 0x12c1e2
leaq 0x50975(%rip), %rcx     # 0x12c1f5
movl $0x35, %edx
callq 0x55710
leaq 0x509ce(%rip), %rdi     # 0x12c25f
leaq 0x5094a(%rip), %rsi     # 0x12c1e2
leaq 0x50956(%rip), %rcx     # 0x12c1f5
movl $0x3a, %edx
callq 0x55710
leaq 0x50916(%rip), %rdi     # 0x12c1c6
leaq 0x5092b(%rip), %rsi     # 0x12c1e2
leaq 0x50937(%rip), %rcx     # 0x12c1f5
movl $0x22, %edx
callq 0x55710
leaq 0x509f8(%rip), %rdi     # 0x12c2c7
leaq 0x5090c(%rip), %rsi     # 0x12c1e2
leaq 0x50918(%rip), %rcx     # 0x12c1f5
movl $0x23, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/rescaler.c
// Function: WebPRescalerImportRowShrink_C
void WebPRescalerImportRowShrink_C(WebPRescaler* const wrk,
                                   const uint8_t* src) {
  const int x_stride = wrk->num_channels;
  const int x_out_max = wrk->dst_width * wrk->num_channels;
  int channel;
  assert(!WebPRescalerInputDone(wrk));
  assert(!wrk->x_expand);
  for (channel = 0; channel < x_stride; ++channel) {
    int x_in = channel;
    int x_out = channel;
    uint32_t sum = 0;
    int accum = 0;
    while (x_out < x_out_max) {
      uint32_t base = 0;
      accum += wrk->x_add;
      while (accum > 0) {
        accum -= wrk->x_sub;
        assert(x_in < wrk->src_width * x_stride);
        base = src[x_in];
        sum += base;
        x_in += x_stride;
      }
      {        // Emit next horizontal pixel.
        const rescaler_t frac = base * (-accum);
        wrk->frow[x_out] = sum * wrk->x_sub - frac;
        // fresh fractional start for next pixel
        sum = (int)MULT_FIX(frac, wrk->fx_scale);
      }
      x_out += x_stride;
    }
    assert(accum == 0);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x3c(%rdi), %eax
cmpl 0x30(%rdi), %eax
jge 0xdb9d5
cmpl $0x0, (%rdi)
jne 0xdb9f4
movslq 0x8(%rdi), %rax
testl %eax, %eax
jle 0xdb992
movslq 0x34(%rdi), %rcx
imulq %rax, %rcx
xorl %edx, %edx
cmpl %edx, %ecx
jle 0xdb98a
xorl %r8d, %r8d
movq %rdx, %r9
xorl %r11d, %r11d
movl %edx, %r10d
addl 0x24(%rdi), %r8d
jle 0xdb951
movslq 0x2c(%rdi), %r14
imulq %rax, %r14
movslq %r10d, %r10
cmpq %r14, %r10
jge 0xdb997
movl 0x28(%rdi), %ebp
movzbl (%rsi,%r10), %ebx
addl %ebx, %r11d
addq %rax, %r10
subl %ebp, %r8d
jg 0xdb937
jmp 0xdb956
movl 0x28(%rdi), %ebp
xorl %ebx, %ebx
imull %r11d, %ebp
imull %r8d, %ebx
addl %ebx, %ebp
negl %ebx
movq 0x60(%rdi), %r11
movl %ebp, (%r11,%r9,4)
movl 0xc(%rdi), %r11d
imulq %rbx, %r11
subq $-0x80000000, %r11      # imm = 0x80000000
shrq $0x20, %r11
addq %rax, %r9
cmpq %rcx, %r9
jl 0xdb926
testl %r8d, %r8d
jne 0xdb9b6
incq %rdx
cmpq %rax, %rdx
jne 0xdb916
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x508a0(%rip), %rdi     # 0x12c23e
leaq 0x5083d(%rip), %rsi     # 0x12c1e2
leaq 0x508d1(%rip), %rcx     # 0x12c27d
movl $0x4f, %edx
callq 0x55710
leaq 0x508b5(%rip), %rdi     # 0x12c272
leaq 0x5081e(%rip), %rsi     # 0x12c1e2
leaq 0x508b2(%rip), %rcx     # 0x12c27d
movl $0x5c, %edx
callq 0x55710
leaq 0x507ea(%rip), %rdi     # 0x12c1c6
leaq 0x507ff(%rip), %rsi     # 0x12c1e2
leaq 0x50893(%rip), %rcx     # 0x12c27d
movl $0x43, %edx
callq 0x55710
leaq 0x508cb(%rip), %rdi     # 0x12c2c6
leaq 0x507e0(%rip), %rsi     # 0x12c1e2
leaq 0x50874(%rip), %rcx     # 0x12c27d
movl $0x44, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/rescaler.c
// Function: WebPRescalerExportRowExpand_C
void WebPRescalerExportRowExpand_C(WebPRescaler* const wrk) {
  int x_out;
  uint8_t* const dst = wrk->dst;
  rescaler_t* const irow = wrk->irow;
  const int x_out_max = wrk->dst_width * wrk->num_channels;
  const rescaler_t* const frow = wrk->frow;
  assert(!WebPRescalerOutputDone(wrk));
  assert(wrk->y_accum <= 0);
  assert(wrk->y_expand);
  assert(wrk->y_sub != 0);
  if (wrk->y_accum == 0) {
    for (x_out = 0; x_out < x_out_max; ++x_out) {
      const uint32_t J = frow[x_out];
      const int v = (int)MULT_FIX(J, wrk->fy_scale);
      dst[x_out] = (v > 255) ? 255u : (uint8_t)v;
    }
  } else {
    const uint32_t B = WEBP_RESCALER_FRAC(-wrk->y_accum, wrk->y_sub);
    const uint32_t A = (uint32_t)(WEBP_RESCALER_ONE - B);
    for (x_out = 0; x_out < x_out_max; ++x_out) {
      const uint64_t I = (uint64_t)A * frow[x_out]
                       + (uint64_t)B * irow[x_out];
      const uint32_t J = (uint32_t)((I + ROUNDER) >> WEBP_RESCALER_RFIX);
      const int v = (int)MULT_FIX(J, wrk->fy_scale);
      dst[x_out] = (v > 255) ? 255u : (uint8_t)v;
    }
  }
}

// Assembly:
pushq %rbx
movl 0x40(%rdi), %eax
cmpl 0x38(%rdi), %eax
jge 0xdbb0a
movl 0x18(%rdi), %eax
testl %eax, %eax
jg 0xdbb29
cmpl $0x0, 0x4(%rdi)
je 0xdbb48
movslq 0x20(%rdi), %r8
testq %r8, %r8
je 0xdbb67
movq 0x48(%rdi), %rcx
movl 0x8(%rdi), %r9d
imull 0x34(%rdi), %r9d
movq 0x60(%rdi), %rsi
testl %eax, %eax
je 0xdbaca
negl %eax
shlq $0x20, %rax
xorl %edx, %edx
divq %r8
testl %r9d, %r9d
jle 0xdbb08
movq 0x58(%rdi), %rdx
movl %eax, %r8d
negl %eax
movl %r9d, %r9d
xorl %r10d, %r10d
movl (%rsi,%r10,4), %r11d
imulq %rax, %r11
movl (%rdx,%r10,4), %ebx
imulq %r8, %rbx
addq %r11, %rbx
subq $-0x80000000, %rbx      # imm = 0x80000000
shrq $0x20, %rbx
movl 0x10(%rdi), %r11d
imulq %rbx, %r11
subq $-0x80000000, %r11      # imm = 0x80000000
shrq $0x20, %r11
movl $0xff, %ebx
cmpl $0x100, %r11d           # imm = 0x100
jge 0xdbabc
movl %r11d, %ebx
movb %bl, (%rcx,%r10)
incq %r10
cmpq %r10, %r9
jne 0xdba7a
jmp 0xdbb08
testl %r9d, %r9d
jle 0xdbb08
movl %r9d, %eax
xorl %edx, %edx
movl $0xff, %r8d
movl (%rsi,%rdx,4), %r9d
movl 0x10(%rdi), %r10d
imulq %r9, %r10
subq $-0x80000000, %r10      # imm = 0x80000000
shrq $0x20, %r10
cmpl $0x100, %r10d           # imm = 0x100
cmovgel %r8d, %r10d
movb %r10b, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %rax
jne 0xdbada
popq %rbx
retq
leaq 0x507c4(%rip), %rdi     # 0x12c2d5
leaq 0x506ca(%rip), %rsi     # 0x12c1e2
leaq 0x507d3(%rip), %rcx     # 0x12c2f2
movl $0x69, %edx
callq 0x55710
leaq 0x507fa(%rip), %rdi     # 0x12c32a
leaq 0x506ab(%rip), %rsi     # 0x12c1e2
leaq 0x507b4(%rip), %rcx     # 0x12c2f2
movl $0x6a, %edx
callq 0x55710
leaq 0x50836(%rip), %rdi     # 0x12c385
leaq 0x5068c(%rip), %rsi     # 0x12c1e2
leaq 0x50795(%rip), %rcx     # 0x12c2f2
movl $0x6b, %edx
callq 0x55710
leaq 0x507ce(%rip), %rdi     # 0x12c33c
leaq 0x5066d(%rip), %rsi     # 0x12c1e2
leaq 0x50776(%rip), %rcx     # 0x12c2f2
movl $0x6c, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/rescaler.c
// Function: WebPRescalerExportRowShrink_C
void WebPRescalerExportRowShrink_C(WebPRescaler* const wrk) {
  int x_out;
  uint8_t* const dst = wrk->dst;
  rescaler_t* const irow = wrk->irow;
  const int x_out_max = wrk->dst_width * wrk->num_channels;
  const rescaler_t* const frow = wrk->frow;
  const uint32_t yscale = wrk->fy_scale * (-wrk->y_accum);
  assert(!WebPRescalerOutputDone(wrk));
  assert(wrk->y_accum <= 0);
  assert(!wrk->y_expand);
  if (yscale) {
    for (x_out = 0; x_out < x_out_max; ++x_out) {
      const uint32_t frac = (uint32_t)MULT_FIX_FLOOR(frow[x_out], yscale);
      const int v = (int)MULT_FIX(irow[x_out] - frac, wrk->fxy_scale);
      dst[x_out] = (v > 255) ? 255u : (uint8_t)v;
      irow[x_out] = frac;   // new fractional start
    }
  } else {
    for (x_out = 0; x_out < x_out_max; ++x_out) {
      const int v = (int)MULT_FIX(irow[x_out], wrk->fxy_scale);
      dst[x_out] = (v > 255) ? 255u : (uint8_t)v;
      irow[x_out] = 0;
    }
  }
}

// Assembly:
pushq %rbx
movl 0x40(%rdi), %eax
cmpl 0x38(%rdi), %eax
jge 0xdbc68
movl 0x18(%rdi), %esi
testl %esi, %esi
jg 0xdbc87
cmpl $0x0, 0x4(%rdi)
jne 0xdbca6
movq 0x48(%rdi), %rax
movl 0x8(%rdi), %r8d
imull 0x34(%rdi), %r8d
movq 0x58(%rdi), %rcx
imull 0x10(%rdi), %esi
testl %esi, %esi
je 0xdbc21
testl %r8d, %r8d
jle 0xdbc66
movq 0x60(%rdi), %rdx
negl %esi
movl %esi, %esi
movl %r8d, %r8d
xorl %r9d, %r9d
movl (%rdx,%r9,4), %r10d
imulq %rsi, %r10
shrq $0x20, %r10
movl (%rcx,%r9,4), %ebx
subl %r10d, %ebx
movl 0x14(%rdi), %r11d
imulq %rbx, %r11
subq $-0x80000000, %r11      # imm = 0x80000000
shrq $0x20, %r11
movl $0xff, %ebx
cmpl $0x100, %r11d           # imm = 0x100
jge 0xdbc0f
movl %r11d, %ebx
movb %bl, (%rax,%r9)
movl %r10d, (%rcx,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0xdbbd8
jmp 0xdbc66
testl %r8d, %r8d
jle 0xdbc66
movl %r8d, %edx
xorl %esi, %esi
movl $0xff, %r8d
movl (%rcx,%rsi,4), %r9d
movl 0x14(%rdi), %r10d
imulq %r9, %r10
subq $-0x80000000, %r10      # imm = 0x80000000
shrq $0x20, %r10
cmpl $0x100, %r10d           # imm = 0x100
cmovgel %r8d, %r10d
movb %r10b, (%rax,%rsi)
movl $0x0, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0xdbc31
popq %rbx
retq
leaq 0x50666(%rip), %rdi     # 0x12c2d5
leaq 0x5056c(%rip), %rsi     # 0x12c1e2
leaq 0x506cf(%rip), %rcx     # 0x12c34c
movl $0x87, %edx
callq 0x55710
leaq 0x5069c(%rip), %rdi     # 0x12c32a
leaq 0x5054d(%rip), %rsi     # 0x12c1e2
leaq 0x506b0(%rip), %rcx     # 0x12c34c
movl $0x88, %edx
callq 0x55710
leaq 0x506d7(%rip), %rdi     # 0x12c384
leaq 0x5052e(%rip), %rsi     # 0x12c1e2
leaq 0x50691(%rip), %rcx     # 0x12c34c
movl $0x89, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/rescaler.c
// Function: WebPRescalerImportRow
void WebPRescalerImportRow(WebPRescaler* const wrk, const uint8_t* src) {
  assert(!WebPRescalerInputDone(wrk));
  if (!wrk->x_expand) {
    WebPRescalerImportRowShrink(wrk, src);
  } else {
    WebPRescalerImportRowExpand(wrk, src);
  }
}

// Assembly:
movl 0x3c(%rdi), %eax
cmpl 0x30(%rdi), %eax
jge 0xdbce7
cmpl $0x0, (%rdi)
leaq 0x9f909(%rip), %rax     # 0x17b5e0
leaq 0x9f90a(%rip), %rcx     # 0x17b5e8
cmoveq %rax, %rcx
movq (%rcx), %rax
jmpq *%rax
pushq %rax
leaq 0x504d7(%rip), %rdi     # 0x12c1c6
leaq 0x504ec(%rip), %rsi     # 0x12c1e2
leaq 0x50696(%rip), %rcx     # 0x12c393
movl $0xa2, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/rescaler.c
// Function: WebPRescalerExportRow
void WebPRescalerExportRow(WebPRescaler* const wrk) {
  if (wrk->y_accum <= 0) {
    assert(!WebPRescalerOutputDone(wrk));
    if (wrk->y_expand) {
      WebPRescalerExportRowExpand(wrk);
    } else if (wrk->fxy_scale) {
      WebPRescalerExportRowShrink(wrk);
    } else {  // special case
      int i;
      assert(wrk->src_height == wrk->dst_height && wrk->x_add == 1);
      assert(wrk->src_width == 1 && wrk->dst_width <= 2);
      for (i = 0; i < wrk->num_channels * wrk->dst_width; ++i) {
        wrk->dst[i] = wrk->irow[i];
        wrk->irow[i] = 0;
      }
    }
    wrk->y_accum += wrk->y_add;
    wrk->dst += wrk->dst_stride;
    ++wrk->dst_y;
  }
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x18(%rdi)
jg 0xdbd4f
movq %rdi, %rbx
movl 0x38(%rdi), %eax
cmpl %eax, 0x40(%rdi)
jge 0xdbda3
cmpl $0x0, 0x4(%rbx)
je 0xdbd2c
leaq 0x9f8c6(%rip), %rax     # 0x17b5f0
jmp 0xdbd39
cmpl $0x0, 0x14(%rbx)
je 0xdbd51
leaq 0x9f8bf(%rip), %rax     # 0x17b5f8
movq %rbx, %rdi
callq *(%rax)
movl 0x1c(%rbx), %eax
addl %eax, 0x18(%rbx)
movslq 0x50(%rbx), %rax
addq %rax, 0x48(%rbx)
incl 0x40(%rbx)
popq %rbx
retq
cmpl %eax, 0x30(%rbx)
jne 0xdbdc2
cmpl $0x1, 0x24(%rbx)
jne 0xdbdc2
cmpl $0x1, 0x2c(%rbx)
jne 0xdbde1
movl 0x34(%rbx), %eax
cmpl $0x2, %eax
jg 0xdbde1
imull 0x8(%rbx), %eax
testl %eax, %eax
jle 0xdbd3e
movq 0x58(%rbx), %rcx
xorl %eax, %eax
movb (%rcx,%rax,4), %cl
movq 0x48(%rbx), %rdx
movb %cl, (%rdx,%rax)
movq 0x58(%rbx), %rcx
movl $0x0, (%rcx,%rax,4)
incq %rax
movslq 0x8(%rbx), %rdx
movslq 0x34(%rbx), %rsi
imulq %rdx, %rsi
cmpq %rsi, %rax
jl 0xdbd78
jmp 0xdbd3e
leaq 0x5052b(%rip), %rdi     # 0x12c2d5
leaq 0x50431(%rip), %rsi     # 0x12c1e2
leaq 0x5061c(%rip), %rcx     # 0x12c3d4
movl $0xac, %edx
callq 0x55710
leaq 0x5063b(%rip), %rdi     # 0x12c404
leaq 0x50412(%rip), %rsi     # 0x12c1e2
leaq 0x505fd(%rip), %rcx     # 0x12c3d4
movl $0xb3, %edx
callq 0x55710
leaq 0x50652(%rip), %rdi     # 0x12c43a
leaq 0x503f3(%rip), %rsi     # 0x12c1e2
leaq 0x505de(%rip), %rcx     # 0x12c3d4
movl $0xb4, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/rescaler.c
// Function: WebPRescalerDspInit
WEBP_DSP_INIT_FUNC(WebPRescalerDspInit) {
#if !defined(WEBP_REDUCE_SIZE)
#if !WEBP_NEON_OMIT_C_CODE
  WebPRescalerExportRowExpand = WebPRescalerExportRowExpand_C;
  WebPRescalerExportRowShrink = WebPRescalerExportRowShrink_C;
#endif

  WebPRescalerImportRowExpand = WebPRescalerImportRowExpand_C;
  WebPRescalerImportRowShrink = WebPRescalerImportRowShrink_C;

  if (VP8GetCPUInfo != NULL) {
#if defined(WEBP_HAVE_SSE2)
    if (VP8GetCPUInfo(kSSE2)) {
      WebPRescalerDspInitSSE2();
    }
#endif
#if defined(WEBP_USE_MIPS32)
    if (VP8GetCPUInfo(kMIPS32)) {
      WebPRescalerDspInitMIPS32();
    }
#endif
#if defined(WEBP_USE_MIPS_DSP_R2)
    if (VP8GetCPUInfo(kMIPSdspR2)) {
      WebPRescalerDspInitMIPSdspR2();
    }
#endif
#if defined(WEBP_USE_MSA)
    if (VP8GetCPUInfo(kMSA)) {
      WebPRescalerDspInitMSA();
    }
#endif
  }

#if defined(WEBP_HAVE_NEON)
  if (WEBP_NEON_OMIT_C_CODE ||
      (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {
    WebPRescalerDspInitNEON();
  }
#endif

  assert(WebPRescalerExportRowExpand != NULL);
  assert(WebPRescalerExportRowShrink != NULL);
  assert(WebPRescalerImportRowExpand != NULL);
  assert(WebPRescalerImportRowShrink != NULL);
#endif   // WEBP_REDUCE_SIZE
}

// Assembly:
pushq %rbx
movq 0x92590(%rip), %rcx     # 0x16e398
movq 0x8f949(%rip), %rbx     # 0x16b758
movq (%rbx), %rax
cmpq %rax, %rcx
je 0xdbe9b
leaq -0x40f(%rip), %rcx      # 0xdba13
movq %rcx, 0x9f7c7(%rip)     # 0x17b5f0
leaq -0x2aa(%rip), %rcx      # 0xdbb86
movq %rcx, 0x9f7c1(%rip)     # 0x17b5f8
leaq -0x6a6(%rip), %rcx      # 0xdb798
movq %rcx, 0x9f7a3(%rip)     # 0x17b5e8
leaq -0x565(%rip), %rcx      # 0xdb8e7
movq %rcx, 0x9f78d(%rip)     # 0x17b5e0
testq %rax, %rax
je 0xdbe92
xorl %edi, %edi
callq *%rax
testl %eax, %eax
je 0xdbe65
callq 0xe758c
cmpq $0x0, 0x9f783(%rip)     # 0x17b5f0
je 0xdbe9d
cmpq $0x0, 0x9f781(%rip)     # 0x17b5f8
je 0xdbebc
cmpq $0x0, 0x9f767(%rip)     # 0x17b5e8
je 0xdbedb
cmpq $0x0, 0x9f755(%rip)     # 0x17b5e0
je 0xdbefa
movq (%rbx), %rax
jmp 0xdbe94
xorl %eax, %eax
movq %rax, 0x924fd(%rip)     # 0x16e398
popq %rbx
retq
leaq 0x505c1(%rip), %rdi     # 0x12c465
leaq 0x50337(%rip), %rsi     # 0x12c1e2
leaq 0x505d7(%rip), %rcx     # 0x12c489
movl $0xf7, %edx
callq 0x55710
leaq 0x505ea(%rip), %rdi     # 0x12c4ad
leaq 0x50318(%rip), %rsi     # 0x12c1e2
leaq 0x505b8(%rip), %rcx     # 0x12c489
movl $0xf8, %edx
callq 0x55710
leaq 0x505ef(%rip), %rdi     # 0x12c4d1
leaq 0x502f9(%rip), %rsi     # 0x12c1e2
leaq 0x50599(%rip), %rcx     # 0x12c489
movl $0xf9, %edx
callq 0x55710
leaq 0x505f4(%rip), %rdi     # 0x12c4f5
leaq 0x502da(%rip), %rsi     # 0x12c1e2
leaq 0x5057a(%rip), %rcx     # 0x12c489
movl $0xfa, %edx
callq 0x55710
nopl (%rax)