LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
xorl %r8d, %r8d
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
cmpq $0x4, %r8
jne 0xd8f97
incq %rdi
addq $0x20, %rsi
cmpq $0x4, %rdi
jne 0xd8f94
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd925d
movq %r14, %rdi
movq %rbx, %rsi
callq *0xa30f3(%rip)          # 0x17c350
cmpw $0x0, 0x20(%r14)
je 0xd9273
leaq 0x20(%r14), %rdi
leaq 0x4(%rbx), %rsi
callq *0xa30dd(%rip)          # 0x17c350
cmpw $0x0, 0x40(%r14)
je 0xd928c
leaq 0x40(%r14), %rdi
leaq 0x80(%rbx), %rsi
callq *0xa30c4(%rip)          # 0x17c350
cmpw $0x0, 0x60(%r14)
je 0xd92b5
addq $0x60, %r14
movq 0xa30b1(%rip), %rax     # 0x17c350
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_O1/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 0xda53a
decl %ebx
addq %r13, %r12
cmpl $0x1, %ebx
ja 0xd930c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x92b85(%rip), %r8      # 0x16bfe8
movq (%r8), %r8
leaq 0x92b63(%rip), %r9      # 0x16bfd0
movq (%r9), %r9
leaq 0x92b61(%rip), %r10     # 0x16bfd8
movq (%r10), %r10
leaq 0x92b5f(%rip), %r11     # 0x16bfe0
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 0xd9505
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 0xd9489
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x92ab9(%rip), %rcx     # 0x16bfe8
movq (%rcx), %rcx
leaq 0x92a97(%rip), %rdx     # 0x16bfd0
movq (%rdx), %rdx
leaq 0x92a95(%rip), %r8      # 0x16bfd8
movq (%r8), %r8
leaq 0x92a93(%rip), %r9      # 0x16bfe0
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 0xd95cf
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 0xd9559
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd943b
decl %ebp
addq %r12, %r15
cmpl $0x1, %ebp
ja 0xd9603
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd951c
decl %r15d
addq $0x4, %r14
cmpl $0x1, %r15d
ja 0xd963b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xda53a
decl %r13d
addq $0x4, %r12
cmpl $0x1, %r13d
ja 0xd9682
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x92810(%rip), %rax     # 0x16bfe0
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 0xd97e9
addq $0x20, %rdx
incl %ecx
cmpl $0x4, %ecx
jne 0xd97df
retq
// File: /workspace/github_c_makefile_star2_O1/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
movb %al, (%rdi,%r8)
movb %cl, 0x1(%rdi,%r8)
movb %dl, 0x2(%rdi,%r8)
movb %sil, 0x3(%rdi,%r8)
addq $0x20, %r8
cmpq $0x80, %r8
jne 0xd9858
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: RD4_C
static void RD4_C(uint8_t* dst) {   // Down-right
  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];
  const int X = dst[-1 - BPS];
  const int A = dst[0 - BPS];
  const int B = dst[1 - BPS];
  const int C = dst[2 - BPS];
  const int D = dst[3 - BPS];
  DST(0, 3)                                     = AVG3(J, K, L);
  DST(1, 3) = DST(0, 2)                         = AVG3(I, J, K);
  DST(2, 3) = DST(1, 2) = DST(0, 1)             = AVG3(X, I, J);
  DST(3, 3) = DST(2, 2) = DST(1, 1) = DST(0, 0) = AVG3(A, X, I);
              DST(3, 2) = DST(2, 1) = DST(1, 0) = AVG3(B, A, X);
                          DST(3, 1) = DST(2, 0) = AVG3(C, B, A);
                                      DST(3, 0) = AVG3(D, C, B);
}

// Assembly:
pushq %rbp
pushq %rbx
movzbl -0x1(%rdi), %r9d
movzbl 0x1f(%rdi), %r10d
movzbl 0x3f(%rdi), %r11d
movzbl 0x5f(%rdi), %ebx
movzbl -0x21(%rdi), %r8d
movzbl -0x20(%rdi), %esi
movzbl -0x1f(%rdi), %edx
movzbl -0x1e(%rdi), %eax
movzbl -0x1d(%rdi), %ecx
leal (%r10,%r11,2), %ebp
addl $0x2, %ebp
addl %ebx, %ebp
shrl $0x2, %ebp
movb %bpl, 0x60(%rdi)
leal (%r9,%r10,2), %ebx
addl $0x2, %ebx
addl %r11d, %ebx
shrl $0x2, %ebx
movb %bl, 0x40(%rdi)
movb %bl, 0x61(%rdi)
leal (%r10,%r9,2), %r10d
addl $0x2, %r10d
addl %r8d, %r10d
shrl $0x2, %r10d
movb %r10b, 0x20(%rdi)
movb %r10b, 0x41(%rdi)
movb %r10b, 0x62(%rdi)
addl %esi, %r9d
addl $0x2, %r9d
leal (%r9,%r8,2), %r9d
shrl $0x2, %r9d
movb %r9b, (%rdi)
movb %r9b, 0x21(%rdi)
movb %r9b, 0x42(%rdi)
movb %r9b, 0x63(%rdi)
addl %edx, %r8d
leal (%r8,%rsi,2), %r8d
addl $0x2, %r8d
shrl $0x2, %r8d
movb %r8b, 0x1(%rdi)
movb %r8b, 0x22(%rdi)
movb %r8b, 0x43(%rdi)
addl %eax, %esi
leal (%rsi,%rdx,2), %esi
addl $0x2, %esi
shrl $0x2, %esi
movb %sil, 0x2(%rdi)
movb %sil, 0x23(%rdi)
addl %edx, %ecx
leal (%rcx,%rax,2), %eax
addl $0x2, %eax
shrl $0x2, %eax
movb %al, 0x3(%rdi)
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: LD4_C
static void LD4_C(uint8_t* dst) {   // Down-Left
  const int A = dst[0 - BPS];
  const int B = dst[1 - BPS];
  const int C = dst[2 - BPS];
  const int D = dst[3 - BPS];
  const int E = dst[4 - BPS];
  const int F = dst[5 - BPS];
  const int G = dst[6 - BPS];
  const int H = dst[7 - BPS];
  DST(0, 0)                                     = AVG3(A, B, C);
  DST(1, 0) = DST(0, 1)                         = AVG3(B, C, D);
  DST(2, 0) = DST(1, 1) = DST(0, 2)             = AVG3(C, D, E);
  DST(3, 0) = DST(2, 1) = DST(1, 2) = DST(0, 3) = AVG3(D, E, F);
              DST(3, 1) = DST(2, 2) = DST(1, 3) = AVG3(E, F, G);
                          DST(3, 2) = DST(2, 3) = AVG3(F, G, H);
                                      DST(3, 3) = AVG3(G, H, H);
}

// Assembly:
movzbl -0x20(%rdi), %r9d
movzbl -0x1f(%rdi), %r10d
movzbl -0x1e(%rdi), %r11d
movzbl -0x1d(%rdi), %r8d
movzbl -0x1c(%rdi), %esi
movzbl -0x1b(%rdi), %edx
movzbl -0x1a(%rdi), %eax
movzbl -0x19(%rdi), %ecx
addl %r11d, %r9d
addl $0x2, %r9d
leal (%r9,%r10,2), %r9d
shrl $0x2, %r9d
movb %r9b, (%rdi)
leal (%r8,%r10), %r9d
addl $0x2, %r9d
leal (%r9,%r11,2), %r9d
shrl $0x2, %r9d
movb %r9b, 0x20(%rdi)
movb %r9b, 0x1(%rdi)
leal (%r11,%r8,2), %r9d
addl $0x2, %r9d
addl %esi, %r9d
shrl $0x2, %r9d
movb %r9b, 0x40(%rdi)
movb %r9b, 0x21(%rdi)
movb %r9b, 0x2(%rdi)
leal (%r8,%rsi,2), %r8d
addl $0x2, %r8d
addl %edx, %r8d
shrl $0x2, %r8d
movb %r8b, 0x60(%rdi)
movb %r8b, 0x41(%rdi)
movb %r8b, 0x22(%rdi)
movb %r8b, 0x3(%rdi)
leal (%rsi,%rdx,2), %esi
addl %eax, %esi
addl $0x2, %esi
shrl $0x2, %esi
movb %sil, 0x61(%rdi)
movb %sil, 0x42(%rdi)
movb %sil, 0x23(%rdi)
leal (%rdx,%rax,2), %edx
addl %ecx, %edx
addl $0x2, %edx
shrl $0x2, %edx
movb %dl, 0x62(%rdi)
movb %dl, 0x43(%rdi)
addl %ecx, %eax
leal (%rax,%rcx,2), %eax
addl $0x2, %eax
shrl $0x2, %eax
movb %al, 0x63(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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), %edx
movzbl -0x1(%rdi), %esi
movzbl 0x1f(%rdi), %r8d
movzbl 0x3f(%rdi), %ecx
movzbl 0x5f(%rdi), %eax
addl %r8d, %edx
addl $0x2, %edx
leal (%rdx,%rsi,2), %r9d
shrl $0x2, %r9d
movl $0xff, %edx
andl %edx, %r9d
imull $0x1010101, %r9d, %r9d  # imm = 0x1010101
movl %r9d, (%rdi)
addl %ecx, %esi
addl $0x2, %esi
leal (%rsi,%r8,2), %esi
shrl $0x2, %esi
andl %edx, %esi
imull $0x1010101, %esi, %esi  # imm = 0x1010101
movl %esi, 0x20(%rdi)
leal (%r8,%rcx,2), %esi
addl $0x2, %esi
addl %eax, %esi
shrl $0x2, %esi
andl %edx, %esi
imull $0x1010101, %esi, %esi  # imm = 0x1010101
movl %esi, 0x40(%rdi)
addl %eax, %ecx
addl $0x2, %ecx
leal (%rcx,%rax,2), %eax
shrl $0x2, %eax
andl %edx, %eax
imull $0x1010101, %eax, %eax  # imm = 0x1010101
movl %eax, 0x60(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: VR4_C
static void VR4_C(uint8_t* dst) {   // Vertical-Right
  const int I = dst[-1 + 0 * BPS];
  const int J = dst[-1 + 1 * BPS];
  const int K = dst[-1 + 2 * BPS];
  const int X = dst[-1 - BPS];
  const int A = dst[0 - BPS];
  const int B = dst[1 - BPS];
  const int C = dst[2 - BPS];
  const int D = dst[3 - BPS];
  DST(0, 0) = DST(1, 2) = AVG2(X, A);
  DST(1, 0) = DST(2, 2) = AVG2(A, B);
  DST(2, 0) = DST(3, 2) = AVG2(B, C);
  DST(3, 0)             = AVG2(C, D);

  DST(0, 3) =             AVG3(K, J, I);
  DST(0, 2) =             AVG3(J, I, X);
  DST(0, 1) = DST(1, 3) = AVG3(I, X, A);
  DST(1, 1) = DST(2, 3) = AVG3(X, A, B);
  DST(2, 1) = DST(3, 3) = AVG3(A, B, C);
  DST(3, 1) =             AVG3(B, C, D);
}

// Assembly:
pushq %rbx
movzbl -0x1(%rdi), %r9d
movzbl 0x1f(%rdi), %r10d
movzbl 0x3f(%rdi), %r11d
movzbl -0x21(%rdi), %r8d
movzbl -0x20(%rdi), %esi
movzbl -0x1f(%rdi), %eax
movzbl -0x1e(%rdi), %edx
movzbl -0x1d(%rdi), %ecx
leal (%rsi,%r8), %ebx
incl %ebx
shrl %ebx
movb %bl, 0x41(%rdi)
movb %bl, (%rdi)
leal (%rsi,%rax), %ebx
incl %ebx
shrl %ebx
movb %bl, 0x42(%rdi)
movb %bl, 0x1(%rdi)
leal (%rax,%rdx), %ebx
incl %ebx
shrl %ebx
movb %bl, 0x43(%rdi)
movb %bl, 0x2(%rdi)
leal (%rdx,%rcx), %ebx
incl %ebx
shrl %ebx
movb %bl, 0x3(%rdi)
addl %r9d, %r11d
addl $0x2, %r11d
leal (%r11,%r10,2), %r11d
shrl $0x2, %r11d
movb %r11b, 0x60(%rdi)
addl %r8d, %r10d
addl $0x2, %r10d
leal (%r10,%r9,2), %r10d
shrl $0x2, %r10d
movb %r10b, 0x40(%rdi)
leal (%r9,%r8,2), %r9d
addl $0x2, %r9d
addl %esi, %r9d
shrl $0x2, %r9d
movb %r9b, 0x61(%rdi)
movb %r9b, 0x20(%rdi)
leal (%r8,%rsi,2), %r8d
addl $0x2, %r8d
addl %eax, %r8d
shrl $0x2, %r8d
movb %r8b, 0x62(%rdi)
movb %r8b, 0x21(%rdi)
leal (%rsi,%rax,2), %esi
addl %edx, %esi
addl $0x2, %esi
shrl $0x2, %esi
movb %sil, 0x63(%rdi)
movb %sil, 0x22(%rdi)
leal (%rax,%rdx,2), %eax
addl %ecx, %eax
addl $0x2, %eax
shrl $0x2, %eax
movb %al, 0x23(%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: VL4_C
static void VL4_C(uint8_t* dst) {   // Vertical-Left
  const int A = dst[0 - BPS];
  const int B = dst[1 - BPS];
  const int C = dst[2 - BPS];
  const int D = dst[3 - BPS];
  const int E = dst[4 - BPS];
  const int F = dst[5 - BPS];
  const int G = dst[6 - BPS];
  const int H = dst[7 - BPS];
  DST(0, 0) =             AVG2(A, B);
  DST(1, 0) = DST(0, 2) = AVG2(B, C);
  DST(2, 0) = DST(1, 2) = AVG2(C, D);
  DST(3, 0) = DST(2, 2) = AVG2(D, E);

  DST(0, 1) =             AVG3(A, B, C);
  DST(1, 1) = DST(0, 3) = AVG3(B, C, D);
  DST(2, 1) = DST(1, 3) = AVG3(C, D, E);
  DST(3, 1) = DST(2, 3) = AVG3(D, E, F);
              DST(3, 2) = AVG3(E, F, G);
              DST(3, 3) = AVG3(F, G, H);
}

// Assembly:
pushq %rbx
movzbl -0x20(%rdi), %r11d
movzbl -0x1f(%rdi), %r10d
movzbl -0x1e(%rdi), %r9d
movzbl -0x1d(%rdi), %r8d
movzbl -0x1c(%rdi), %esi
movzbl -0x1b(%rdi), %ecx
movzbl -0x1a(%rdi), %edx
movzbl -0x19(%rdi), %eax
leal (%r10,%r11), %ebx
incl %ebx
shrl %ebx
movb %bl, (%rdi)
leal (%r10,%r9), %ebx
incl %ebx
shrl %ebx
movb %bl, 0x40(%rdi)
movb %bl, 0x1(%rdi)
leal (%r9,%r8), %ebx
incl %ebx
shrl %ebx
movb %bl, 0x41(%rdi)
movb %bl, 0x2(%rdi)
leal (%r8,%rsi), %ebx
incl %ebx
shrl %ebx
movb %bl, 0x42(%rdi)
movb %bl, 0x3(%rdi)
addl %r9d, %r11d
addl $0x2, %r11d
leal (%r11,%r10,2), %r11d
shrl $0x2, %r11d
movb %r11b, 0x20(%rdi)
addl %r8d, %r10d
addl $0x2, %r10d
leal (%r10,%r9,2), %r10d
shrl $0x2, %r10d
movb %r10b, 0x60(%rdi)
movb %r10b, 0x21(%rdi)
leal (%r9,%r8,2), %r9d
addl $0x2, %r9d
addl %esi, %r9d
shrl $0x2, %r9d
movb %r9b, 0x61(%rdi)
movb %r9b, 0x22(%rdi)
leal (%r8,%rsi,2), %r8d
addl $0x2, %r8d
addl %ecx, %r8d
shrl $0x2, %r8d
movb %r8b, 0x62(%rdi)
movb %r8b, 0x23(%rdi)
leal (%rsi,%rcx,2), %esi
addl %edx, %esi
addl $0x2, %esi
shrl $0x2, %esi
movb %sil, 0x43(%rdi)
leal (%rcx,%rdx,2), %ecx
addl %ecx, %eax
addl $0x2, %eax
shrl $0x2, %eax
movb %al, 0x63(%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: HD4_C
static void HD4_C(uint8_t* dst) {  // Horizontal-Down
  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];
  const int X = dst[-1 - BPS];
  const int A = dst[0 - BPS];
  const int B = dst[1 - BPS];
  const int C = dst[2 - BPS];

  DST(0, 0) = DST(2, 1) = AVG2(I, X);
  DST(0, 1) = DST(2, 2) = AVG2(J, I);
  DST(0, 2) = DST(2, 3) = AVG2(K, J);
  DST(0, 3)             = AVG2(L, K);

  DST(3, 0)             = AVG3(A, B, C);
  DST(2, 0)             = AVG3(X, A, B);
  DST(1, 0) = DST(3, 1) = AVG3(I, X, A);
  DST(1, 1) = DST(3, 2) = AVG3(J, I, X);
  DST(1, 2) = DST(3, 3) = AVG3(K, J, I);
  DST(1, 3)             = AVG3(L, K, J);
}

// Assembly:
pushq %rbx
movzbl -0x1(%rdi), %esi
movzbl 0x1f(%rdi), %ecx
movzbl 0x3f(%rdi), %eax
movzbl 0x5f(%rdi), %edx
movzbl -0x21(%rdi), %r8d
movzbl -0x20(%rdi), %r9d
movzbl -0x1f(%rdi), %r10d
movzbl -0x1e(%rdi), %r11d
leal (%rsi,%r8), %ebx
incl %ebx
shrl %ebx
movb %bl, 0x22(%rdi)
movb %bl, (%rdi)
leal (%rsi,%rcx), %ebx
incl %ebx
shrl %ebx
movb %bl, 0x42(%rdi)
movb %bl, 0x20(%rdi)
leal (%rcx,%rax), %ebx
incl %ebx
shrl %ebx
movb %bl, 0x62(%rdi)
movb %bl, 0x40(%rdi)
leal (%rax,%rdx), %ebx
incl %ebx
shrl %ebx
movb %bl, 0x60(%rdi)
leal (%r9,%r10,2), %ebx
addl %ebx, %r11d
addl $0x2, %r11d
shrl $0x2, %r11d
movb %r11b, 0x3(%rdi)
leal (%r8,%r9,2), %r11d
addl %r11d, %r10d
addl $0x2, %r10d
shrl $0x2, %r10d
movb %r10b, 0x2(%rdi)
leal (%rsi,%r8,2), %r10d
addl $0x2, %r10d
addl %r9d, %r10d
shrl $0x2, %r10d
movb %r10b, 0x23(%rdi)
movb %r10b, 0x1(%rdi)
leal (%rcx,%rsi,2), %r9d
addl $0x2, %r9d
addl %r8d, %r9d
shrl $0x2, %r9d
movb %r9b, 0x43(%rdi)
movb %r9b, 0x21(%rdi)
addl %eax, %esi
addl $0x2, %esi
leal (%rsi,%rcx,2), %esi
shrl $0x2, %esi
movb %sil, 0x63(%rdi)
movb %sil, 0x41(%rdi)
addl %edx, %ecx
addl $0x2, %ecx
leal (%rcx,%rax,2), %eax
shrl $0x2, %eax
movb %al, 0x61(%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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)
movl %eax, %esi
addl %edx, %esi
leal (%rsi,%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)
movb %al, 0x63(%rdi)
movb %al, 0x62(%rdi)
movb %al, 0x61(%rdi)
movb %al, 0x60(%rdi)
movb %al, 0x42(%rdi)
movb %al, 0x43(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd9d78
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 0xd9da7
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd9e1d
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x8, %eax
movq $-0x1, %rcx
movzbl (%rdi,%rcx), %edx
addl %edx, %eax
addq $0x20, %rcx
cmpq $0x1ff, %rcx            # imm = 0x1FF
jne 0xd9e4f
shrl $0x4, %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 0xd9e7c
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x8, %eax
movq $-0x10, %rcx
movzbl -0x10(%rdi,%rcx), %edx
addl %edx, %eax
incq %rcx
jne 0xd9e9b
shrl $0x4, %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 0xd9ec1
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd9efe
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 0xd9f2f
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd9fcd
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 0xd9ff6
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x4, %eax
xorl %ecx, %ecx
movzbl -0x20(%rdi,%rcx), %edx
addl %edx, %eax
incq %rcx
cmpq $0x8, %rcx
jne 0xda00f
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 0xda035
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xda074
addq %rax, %rsi
addq $0x8, %rdi
incl %r8d
cmpl $0x8, %r8d
jne 0xda071
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xda9b6
movb (%rdi), %al
jmp 0xda9b8
xorl %eax, %eax
testl %ecx, %ecx
jle 0xda9ce
movl %ecx, %ecx
xorl %edi, %edi
addb (%rsi,%rdi), %al
movb %al, (%rdx,%rdi)
incq %rdi
cmpq %rdi, %rcx
jne 0xda9c0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xda9f2
testl %ecx, %ecx
jle 0xdaa0c
movl %ecx, %eax
xorl %ecx, %ecx
movb (%rsi,%rcx), %r8b
addb (%rdi,%rcx), %r8b
movb %r8b, (%rdx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0xda9dc
jmp 0xdaa0c
testl %ecx, %ecx
jle 0xdaa0c
movl %ecx, %eax
xorl %ecx, %ecx
xorl %edi, %edi
addb (%rsi,%rcx), %dil
movb %dil, (%rdx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0xda9fc
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdaa61
testl %ecx, %ecx
jle 0xdaa7b
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 0xdaa3b
xorl %r8d, %r8d
movl $0xff, %r10d
cmpl %r10d, %r8d
jl 0xdaa4c
movl $0xff, %r8d
addb (%rsi,%rcx), %r8b
movb %r8b, (%rdx,%rcx)
incq %rcx
movl %r9d, %r10d
cmpq %rcx, %rax
jne 0xdaa20
jmp 0xdaa7b
testl %ecx, %ecx
jle 0xdaa7b
movl %ecx, %eax
xorl %ecx, %ecx
xorl %edi, %edi
addb (%rsi,%rcx), %dil
movb %dil, (%rdx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0xdaa6b
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdb132
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 0xdb0fa
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %edx, %edx
jle 0xdb1a8
pushq %rbp
pushq %rbx
movsbl (%rdi), %eax
movsbl 0x1(%rdi), %r8d
movsbl 0x2(%rdi), %edi
movl %edx, %edx
xorl %r9d, %r9d
movl (%rsi,%r9,4), %r10d
movl %r10d, %r11d
shrl $0x10, %r11d
movl %r10d, %ebx
shrl $0x8, %ebx
movsbl %bl, %ebx
movl %ebx, %ebp
imull %eax, %ebp
sarl $0x5, %ebp
addl %r11d, %ebp
imull %r8d, %ebx
shrl $0x5, %ebx
addl %r10d, %ebx
movsbl %bpl, %r11d
movzbl %r11b, %ebp
imull %edi, %r11d
shrl $0x5, %r11d
addl %ebx, %r11d
movzbl %r11b, %r11d
andl $0xff00ff00, %r10d      # imm = 0xFF00FF00
shll $0x10, %ebp
orl %r10d, %ebp
orl %r11d, %ebp
movl %ebp, (%rcx,%r9,4)
incq %r9
cmpq %r9, %rdx
jne 0xdb14a
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdb794
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 0xdb777
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdb7c3
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 0xdb7a0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdb80e
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 0xdb7d4
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdb85b
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 0xdb81a
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdbec9
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 0xdbe9a
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x3c(%rdi), %eax
cmpl 0x30(%rdi), %eax
jge 0xdc771
cmpl $0x0, (%rdi)
je 0xdc790
movslq 0x8(%rdi), %rax
testl %eax, %eax
jle 0xdc724
movslq 0x34(%rdi), %rcx
imulq %rax, %rcx
movq 0x60(%rdi), %rdx
movslq %ecx, %r8
leaq (%rsi,%rax), %r9
movq %r9, (%rsp)
subq %rax, %r8
xorl %r10d, %r10d
movl %eax, %r11d
movzbl (%rsi,%r10), %r9d
cmpl $0x2, 0x2c(%rdi)
movl %r9d, %ebp
jl 0xdc69f
movq (%rsp), %rbx
movzbl (%rbx,%r10), %ebp
movl 0x24(%rdi), %ebx
movl 0x24(%rdi), %r15d
imull %ebp, %r15d
movl %r9d, %r12d
subl %ebp, %r12d
imull %ebx, %r12d
addl %r15d, %r12d
movl %r12d, (%rdx,%r10,4)
cmpq %r8, %r10
jge 0xdc70b
movslq %r11d, %r15
leal (%rax,%r10), %r12d
subl 0x28(%rdi), %ebx
jns 0xdc6ea
addl %eax, %r12d
movl 0x2c(%rdi), %r14d
imull %eax, %r14d
cmpl %r14d, %r12d
jge 0xdc733
movslq %r12d, %r13
movl %ebp, %r9d
movzbl (%rsi,%r13), %ebp
addl 0x24(%rdi), %ebx
movl 0x24(%rdi), %r13d
imull %ebp, %r13d
movl %r9d, %r14d
subl %ebp, %r14d
imull %ebx, %r14d
addl %r13d, %r14d
movl %r14d, (%rdx,%r15,4)
addq %rax, %r15
cmpq %rcx, %r15
jl 0xdc6c7
cmpl $0x0, 0x28(%rdi)
je 0xdc715
testl %ebx, %ebx
jne 0xdc752
incq %r10
incl %r11d
cmpq %rax, %r10
jne 0xdc688
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x508b4(%rip), %rdi     # 0x12cfee
leaq 0x50851(%rip), %rsi     # 0x12cf92
leaq 0x5085d(%rip), %rcx     # 0x12cfa5
movl $0x35, %edx
callq 0x55710
leaq 0x508b6(%rip), %rdi     # 0x12d00f
leaq 0x50832(%rip), %rsi     # 0x12cf92
leaq 0x5083e(%rip), %rcx     # 0x12cfa5
movl $0x3a, %edx
callq 0x55710
leaq 0x507fe(%rip), %rdi     # 0x12cf76
leaq 0x50813(%rip), %rsi     # 0x12cf92
leaq 0x5081f(%rip), %rcx     # 0x12cfa5
movl $0x22, %edx
callq 0x55710
leaq 0x508e0(%rip), %rdi     # 0x12d077
leaq 0x507f4(%rip), %rsi     # 0x12cf92
leaq 0x50800(%rip), %rcx     # 0x12cfa5
movl $0x23, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl 0x3c(%rdi), %eax
cmpl 0x30(%rdi), %eax
jge 0xdc89d
cmpl $0x0, (%rdi)
jne 0xdc8bc
movslq 0x8(%rdi), %rax
testl %eax, %eax
jle 0xdc857
movslq 0x34(%rdi), %rcx
imulq %rax, %rcx
xorl %edx, %edx
cmpl %edx, %ecx
jle 0xdc84f
xorl %r8d, %r8d
movq %rdx, %r9
xorl %r11d, %r11d
movl %edx, %r10d
addl 0x24(%rdi), %r8d
jle 0xdc817
movslq 0x2c(%rdi), %r14
imulq %rax, %r14
movslq %r10d, %r10
cmpq %r14, %r10
jge 0xdc85f
movzbl (%rsi,%r10), %ebx
addl %ebx, %r11d
addq %rax, %r10
subl 0x28(%rdi), %r8d
jg 0xdc7ff
jmp 0xdc819
xorl %ebx, %ebx
imull %r8d, %ebx
imull 0x28(%rdi), %r11d
addl %ebx, %r11d
negl %ebx
movq 0x60(%rdi), %r14
movl %r11d, (%r14,%r9,4)
movl 0xc(%rdi), %r11d
imulq %rbx, %r11
subq $-0x80000000, %r11      # imm = 0x80000000
shrq $0x20, %r11
addq %rax, %r9
cmpq %rcx, %r9
jl 0xdc7ee
testl %r8d, %r8d
jne 0xdc87e
incq %rdx
cmpq %rax, %rdx
jne 0xdc7de
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x50788(%rip), %rdi     # 0x12cfee
leaq 0x50725(%rip), %rsi     # 0x12cf92
leaq 0x507b9(%rip), %rcx     # 0x12d02d
movl $0x4f, %edx
callq 0x55710
leaq 0x5079d(%rip), %rdi     # 0x12d022
leaq 0x50706(%rip), %rsi     # 0x12cf92
leaq 0x5079a(%rip), %rcx     # 0x12d02d
movl $0x5c, %edx
callq 0x55710
leaq 0x506d2(%rip), %rdi     # 0x12cf76
leaq 0x506e7(%rip), %rsi     # 0x12cf92
leaq 0x5077b(%rip), %rcx     # 0x12d02d
movl $0x43, %edx
callq 0x55710
leaq 0x507b3(%rip), %rdi     # 0x12d076
leaq 0x506c8(%rip), %rsi     # 0x12cf92
leaq 0x5075c(%rip), %rcx     # 0x12d02d
movl $0x44, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O1/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 0xdc9d2
movl 0x18(%rdi), %eax
testl %eax, %eax
jg 0xdc9f1
cmpl $0x0, 0x4(%rdi)
je 0xdca10
movslq 0x20(%rdi), %r8
testq %r8, %r8
je 0xdca2f
movq 0x48(%rdi), %rcx
movl 0x8(%rdi), %r9d
imull 0x34(%rdi), %r9d
movq 0x60(%rdi), %rsi
testl %eax, %eax
je 0xdc992
negl %eax
shlq $0x20, %rax
xorl %edx, %edx
divq %r8
testl %r9d, %r9d
jle 0xdc9d0
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 0xdc984
movl %r11d, %ebx
movb %bl, (%rcx,%r10)
incq %r10
cmpq %r10, %r9
jne 0xdc942
jmp 0xdc9d0
testl %r9d, %r9d
jle 0xdc9d0
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 0xdc9a2
popq %rbx
retq
leaq 0x506ac(%rip), %rdi     # 0x12d085
leaq 0x505b2(%rip), %rsi     # 0x12cf92
leaq 0x506bb(%rip), %rcx     # 0x12d0a2
movl $0x69, %edx
callq 0x55710
leaq 0x506e2(%rip), %rdi     # 0x12d0da
leaq 0x50593(%rip), %rsi     # 0x12cf92
leaq 0x5069c(%rip), %rcx     # 0x12d0a2
movl $0x6a, %edx
callq 0x55710
leaq 0x5071e(%rip), %rdi     # 0x12d135
leaq 0x50574(%rip), %rsi     # 0x12cf92
leaq 0x5067d(%rip), %rcx     # 0x12d0a2
movl $0x6b, %edx
callq 0x55710
leaq 0x506b6(%rip), %rdi     # 0x12d0ec
leaq 0x50555(%rip), %rsi     # 0x12cf92
leaq 0x5065e(%rip), %rcx     # 0x12d0a2
movl $0x6c, %edx
callq 0x55710