LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x8, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x10, -0x10(%rbp)
jge 0x14c388
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
shll $0x5, %ecx
addl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x14c35a
movl -0xc(%rbp), %edi
sarl $0x4, %edi
movq -0x8(%rbp), %rsi
callq 0x14d250
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x8, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x10, -0x10(%rbp)
jge 0x14c3e2
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x20, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x14c3ba
movl -0xc(%rbp), %edi
sarl $0x4, %edi
movq -0x8(%rbp), %rsi
callq 0x14d250
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x8, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0x14c47b
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x20, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movl -0x10(%rbp), %edx
shll $0x5, %edx
addl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x14c43a
movl -0xc(%rbp), %eax
sarl $0x4, %eax
movq -0x8(%rbp), %rsi
movzbl %al, %edi
callq 0x14d2a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: VE8uv_C
static void VE8uv_C(uint8_t* dst) {    // vertical
  int j;
  for (j = 0; j < 8; ++j) {
    memcpy(dst + j * BPS, dst - BPS, 8);
  }
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x14c549
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl -0x1(%rax), %eax
movl $0x8, %edx
movzbl %al, %esi
callq 0x5a200
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x14c513
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x4, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0x14c598
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
shll $0x5, %ecx
addl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x14c56a
movl -0xc(%rbp), %eax
sarl $0x3, %eax
movq -0x8(%rbp), %rsi
movzbl %al, %edi
callq 0x14d2a0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x4, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0x14c5f2
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x20, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x14c5ca
movl -0xc(%rbp), %eax
sarl $0x3, %eax
movq -0x8(%rbp), %rsi
movzbl %al, %edi
callq 0x14d2a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x14c6d8
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0x14c6ad
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
subl $0x80, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl $0x8, %eax
sarl $0x4, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edi
addl -0x24(%rbp), %edi
callq 0x14c930
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x14c65b
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x14c64a
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: FilterLoop26_C
static WEBP_INLINE void FilterLoop26_C(uint8_t* p,
                                       int hstride, int vstride, int size,
                                       int thresh, int ithresh,
                                       int hev_thresh) {
  const int thresh2 = 2 * thresh + 1;
  while (size-- > 0) {
    if (NeedsFilter2_C(p, hstride, thresh2, ithresh)) {
      if (Hev(p, hstride, hev_thresh)) {
        DoFilter2_C(p, hstride);
      } else {
        DoFilter6_C(p, hstride);
      }
    }
    p += vstride;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl -0x18(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
jle 0x14ca05
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x14ca10
cmpl $0x0, %eax
je 0x14c9f2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl 0x10(%rbp), %edx
callq 0x14cbe0
cmpl $0x0, %eax
je 0x14c9e4
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x14cc80
jmp 0x14c9f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x14cd70
jmp 0x14c9f2
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x14c99b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: DoFilter2_C
static WEBP_INLINE void DoFilter2_C(uint8_t* p, int step) {
  const int p1 = p[-2*step], p0 = p[-step], q0 = p[0], q1 = p[step];
  const int a = 3 * (q0 - p0) + VP8ksclip1[p1 - q1];  // in [-893,892]
  const int a1 = VP8ksclip2[(a + 4) >> 3];            // in [-16,15]
  const int a2 = VP8ksclip2[(a + 3) >> 3];
  p[-step] = VP8kclip1[p0 + a2];
  p[    0] = VP8kclip1[q0 - a1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
imull $0xfffffffe, -0xc(%rbp), %ecx # imm = 0xFFFFFFFE
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
imull $0x3, %eax, %eax
leaq 0xbb2c4(%rip), %rcx     # 0x207fa0
movq (%rcx), %rcx
movl -0x10(%rbp), %edx
subl -0x1c(%rbp), %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x20(%rbp)
leaq 0xbb2b0(%rip), %rax     # 0x207fa8
movq (%rax), %rax
movl -0x20(%rbp), %ecx
addl $0x4, %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
leaq 0xbb293(%rip), %rax     # 0x207fa8
movq (%rax), %rax
movl -0x20(%rbp), %ecx
addl $0x3, %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
leaq 0xbb27e(%rip), %rax     # 0x207fb0
movq (%rax), %rax
movl -0x14(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
leaq 0xbb259(%rip), %rax     # 0x207fb0
movq (%rax), %rax
movl -0x18(%rbp), %ecx
subl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: FilterLoop24_C
static WEBP_INLINE void FilterLoop24_C(uint8_t* p,
                                       int hstride, int vstride, int size,
                                       int thresh, int ithresh,
                                       int hev_thresh) {
  const int thresh2 = 2 * thresh + 1;
  while (size-- > 0) {
    if (NeedsFilter2_C(p, hstride, thresh2, ithresh)) {
      if (Hev(p, hstride, hev_thresh)) {
        DoFilter2_C(p, hstride);
      } else {
        DoFilter4_C(p, hstride);
      }
    }
    p += vstride;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl -0x18(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
jle 0x14cfb5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x14ca10
cmpl $0x0, %eax
je 0x14cfa2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl 0x10(%rbp), %edx
callq 0x14cbe0
cmpl $0x0, %eax
je 0x14cf94
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x14cc80
jmp 0x14cfa0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x14cfc0
jmp 0x14cfa2
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x14cf4b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: DoFilter4_C
static WEBP_INLINE void DoFilter4_C(uint8_t* p, int step) {
  const int p1 = p[-2*step], p0 = p[-step], q0 = p[0], q1 = p[step];
  const int a = 3 * (q0 - p0);
  const int a1 = VP8ksclip2[(a + 4) >> 3];
  const int a2 = VP8ksclip2[(a + 3) >> 3];
  const int a3 = (a1 + 1) >> 1;
  p[-2*step] = VP8kclip1[p1 + a3];
  p[-  step] = VP8kclip1[p0 + a2];
  p[      0] = VP8kclip1[q0 - a1];
  p[   step] = VP8kclip1[q1 - a3];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
imull $0xfffffffe, -0xc(%rbp), %ecx # imm = 0xFFFFFFFE
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
imull $0x3, %eax, %eax
movl %eax, -0x20(%rbp)
leaq 0xbaf89(%rip), %rax     # 0x207fa8
movq (%rax), %rax
movl -0x20(%rbp), %ecx
addl $0x4, %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
leaq 0xbaf6c(%rip), %rax     # 0x207fa8
movq (%rax), %rax
movl -0x20(%rbp), %ecx
addl $0x3, %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
sarl %eax
movl %eax, -0x2c(%rbp)
leaq 0xbaf4c(%rip), %rax     # 0x207fb0
movq (%rax), %rax
movl -0x10(%rbp), %ecx
addl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
imull $0xfffffffe, -0xc(%rbp), %ecx # imm = 0xFFFFFFFE
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
leaq 0xbaf25(%rip), %rax     # 0x207fb0
movq (%rax), %rax
movl -0x14(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
leaq 0xbaf00(%rip), %rax     # 0x207fb0
movq (%rax), %rax
movl -0x18(%rbp), %ecx
subl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
leaq 0xbaee4(%rip), %rax     # 0x207fb0
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
subl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec.c
// Function: TrueMotion
static WEBP_INLINE void TrueMotion(uint8_t* dst, int size) {
  const uint8_t* top = dst - BPS;
  const uint8_t* const clip0 = VP8kclip1 - top[-1];
  int y;
  for (y = 0; y < size; ++y) {
    const uint8_t* const clip = clip0 + dst[-1];
    int x;
    for (x = 0; x < size; ++x) {
      dst[x] = clip[top[x]];
    }
    dst += BPS;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $-0x20, %rax
movq %rax, -0x18(%rbp)
leaq 0xbae12(%rip), %rax     # 0x207fb0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movzbl -0x1(%rcx), %ecx
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x14d22c
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movzbl -0x1(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x14d215
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x34(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x14d1e4
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x8(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x14d1bf
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x14d571
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0x14d57b
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movb %al, -0x1d(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x14d5c8
movzbl -0x1d(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x14d588
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x14d604
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edi
callq 0x14d550
jmp 0x14d647
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x14d645
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x14d60b
jmp 0x14d647
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x14d687
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edi
callq 0x14d550
jmp 0x14d708
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
movb %al, -0x1e(%rbp)
movb -0x1d(%rbp), %al
movb %al, -0x1f(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x14d706
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
movb -0x1f(%rbp), %cl
movb -0x1d(%rbp), %al
movzbl %cl, %edi
movzbl %al, %esi
movzbl -0x1e(%rbp), %edx
callq 0x14d800
movl %eax, %ecx
movl -0x28(%rbp), %eax
addl %ecx, %eax
movb %al, -0x1f(%rbp)
movb -0x1d(%rbp), %al
movb %al, -0x1e(%rbp)
movb -0x1f(%rbp), %dl
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x14d6a3
jmp 0x14d708
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless.c
// Function: Select
static WEBP_INLINE uint32_t Select(uint32_t a, uint32_t b, uint32_t c) {
  const int pa_minus_pb =
      Sub3((a >> 24)       , (b >> 24)       , (c >> 24)       ) +
      Sub3((a >> 16) & 0xff, (b >> 16) & 0xff, (c >> 16) & 0xff) +
      Sub3((a >>  8) & 0xff, (b >>  8) & 0xff, (c >>  8) & 0xff) +
      Sub3((a      ) & 0xff, (b      ) & 0xff, (c      ) & 0xff);
  return (pa_minus_pb <= 0) ? a : b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %edi
shrl $0x18, %edi
movl -0x8(%rbp), %esi
shrl $0x18, %esi
movl -0xc(%rbp), %edx
shrl $0x18, %edx
callq 0x14fc50
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %edi
shrl $0x10, %edi
andl $0xff, %edi
movl -0x8(%rbp), %esi
shrl $0x10, %esi
andl $0xff, %esi
movl -0xc(%rbp), %edx
shrl $0x10, %edx
andl $0xff, %edx
callq 0x14fc50
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x4(%rbp), %edi
shrl $0x8, %edi
andl $0xff, %edi
movl -0x8(%rbp), %esi
shrl $0x8, %esi
andl $0xff, %esi
movl -0xc(%rbp), %edx
shrl $0x8, %edx
andl $0xff, %edx
callq 0x14fc50
movl %eax, %ecx
movl -0x18(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %edi
andl $0xff, %edi
movl -0x8(%rbp), %esi
andl $0xff, %esi
movl -0xc(%rbp), %edx
andl $0xff, %edx
callq 0x14fc50
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jg 0x14e469
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x14e46f
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless.c
// Function: ClampedAddSubtractFull
static WEBP_INLINE uint32_t ClampedAddSubtractFull(uint32_t c0, uint32_t c1,
                                                   uint32_t c2) {
  const int a = AddSubtractComponentFull(c0 >> 24, c1 >> 24, c2 >> 24);
  const int r = AddSubtractComponentFull((c0 >> 16) & 0xff,
                                         (c1 >> 16) & 0xff,
                                         (c2 >> 16) & 0xff);
  const int g = AddSubtractComponentFull((c0 >> 8) & 0xff,
                                         (c1 >> 8) & 0xff,
                                         (c2 >> 8) & 0xff);
  const int b = AddSubtractComponentFull(c0 & 0xff, c1 & 0xff, c2 & 0xff);
  return ((uint32_t)a << 24) | (r << 16) | (g << 8) | b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %edi
shrl $0x18, %edi
movl -0x8(%rbp), %esi
shrl $0x18, %esi
movl -0xc(%rbp), %edx
shrl $0x18, %edx
callq 0x14fc90
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %edi
shrl $0x10, %edi
andl $0xff, %edi
movl -0x8(%rbp), %esi
shrl $0x10, %esi
andl $0xff, %esi
movl -0xc(%rbp), %edx
shrl $0x10, %edx
andl $0xff, %edx
callq 0x14fc90
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %edi
shrl $0x8, %edi
andl $0xff, %edi
movl -0x8(%rbp), %esi
shrl $0x8, %esi
andl $0xff, %esi
movl -0xc(%rbp), %edx
shrl $0x8, %edx
andl $0xff, %edx
callq 0x14fc90
movl %eax, -0x18(%rbp)
movl -0x4(%rbp), %edi
andl $0xff, %edi
movl -0x8(%rbp), %esi
andl $0xff, %esi
movl -0xc(%rbp), %edx
andl $0xff, %edx
callq 0x14fc90
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
shll $0x18, %eax
movl -0x14(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl -0x18(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
orl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless.c
// Function: ClampedAddSubtractHalf
static WEBP_INLINE uint32_t ClampedAddSubtractHalf(uint32_t c0, uint32_t c1,
                                                   uint32_t c2) {
  const uint32_t ave = Average2(c0, c1);
  const int a = AddSubtractComponentHalf(ave >> 24, c2 >> 24);
  const int r = AddSubtractComponentHalf((ave >> 16) & 0xff, (c2 >> 16) & 0xff);
  const int g = AddSubtractComponentHalf((ave >> 8) & 0xff, (c2 >> 8) & 0xff);
  const int b = AddSubtractComponentHalf((ave >> 0) & 0xff, (c2 >> 0) & 0xff);
  return ((uint32_t)a << 24) | (r << 16) | (g << 8) | b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x14e220
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
shrl $0x18, %edi
movl -0xc(%rbp), %esi
shrl $0x18, %esi
callq 0x14fcf0
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %edi
shrl $0x10, %edi
andl $0xff, %edi
movl -0xc(%rbp), %esi
shrl $0x10, %esi
andl $0xff, %esi
callq 0x14fcf0
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %edi
shrl $0x8, %edi
andl $0xff, %edi
movl -0xc(%rbp), %esi
shrl $0x8, %esi
andl $0xff, %esi
callq 0x14fcf0
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %edi
shrl $0x0, %edi
andl $0xff, %edi
movl -0xc(%rbp), %esi
shrl $0x0, %esi
andl $0xff, %esi
callq 0x14fcf0
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
shll $0x18, %eax
movl -0x18(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl -0x1c(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
orl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x14e711
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
andl $0xff00ff, %eax         # imm = 0xFF00FF
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
shll $0x10, %eax
orl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
andl $0xff00ff, %eax         # imm = 0xFF00FF
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %edx
andl $0xff00ff00, %edx       # imm = 0xFF00FF00
orl -0x28(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x14e6a6
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x14e80f
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
shrl $0x8, %eax
movb %al, -0x29(%rbp)
movl -0x28(%rbp), %eax
shrl $0x10, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x34(%rbp)
movl -0x28(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %al
movsbl %al, %edi
movsbl -0x29(%rbp), %esi
callq 0x14e820
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movb 0x1(%rax), %al
movsbl %al, %edi
movsbl -0x29(%rbp), %esi
callq 0x14e820
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movb 0x2(%rax), %cl
movl -0x34(%rbp), %eax
movsbl %cl, %edi
movsbl %al, %esi
callq 0x14e820
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x38(%rbp)
movl -0x28(%rbp), %edx
andl $0xff00ff00, %edx       # imm = 0xFF00FF00
movl -0x34(%rbp), %eax
shll $0x10, %eax
orl %eax, %edx
orl -0x38(%rbp), %edx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x14e73e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x14f1fc
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x8(%rbp)
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x24(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x24(%rbp), %eax
shrl $0x0, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x14f182
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x14f2c1
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x8(%rbp)
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x24(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x24(%rbp), %eax
shrl $0x0, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x24(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x14f222
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x14f36c
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x8(%rbp)
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shrl $0x10, %eax
andl $0xf0, %eax
movl -0x24(%rbp), %ecx
shrl $0xc, %ecx
andl $0xf, %ecx
orl %ecx, %eax
movb %al, -0x25(%rbp)
movl -0x24(%rbp), %eax
shrl $0x0, %eax
andl $0xf0, %eax
movl -0x24(%rbp), %ecx
shrl $0x1c, %ecx
andl $0xf, %ecx
orl %ecx, %eax
movb %al, -0x26(%rbp)
movb -0x25(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movb -0x26(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x14f2f2
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x14f40c
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x8(%rbp)
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shrl $0x10, %eax
andl $0xf8, %eax
movl -0x24(%rbp), %ecx
shrl $0xd, %ecx
andl $0x7, %ecx
orl %ecx, %eax
movb %al, -0x25(%rbp)
movl -0x24(%rbp), %eax
shrl $0x5, %eax
andl $0xe0, %eax
movl -0x24(%rbp), %ecx
shrl $0x3, %ecx
andl $0x1f, %ecx
orl %ecx, %eax
movb %al, -0x26(%rbp)
movb -0x25(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movb -0x26(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x14f392
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless.c
// Function: CopyOrSwap
static void CopyOrSwap(const uint32_t* src, int num_pixels, uint8_t* dst,
                       int swap_on_big_endian) {
  if (is_big_endian() == swap_on_big_endian) {
    const uint32_t* const src_end = src + num_pixels;
    while (src < src_end) {
      const uint32_t argb = *src++;
      WebPUint32ToMem(dst, BSwap32(argb));
      dst += sizeof(argb);
    }
  } else {
    memcpy(dst, src, num_pixels * sizeof(*src));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
callq 0x14ff70
cmpl -0x1c(%rbp), %eax
jne 0x14f70c
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x14f70a
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x8(%rbp)
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %edi
callq 0x14ffb0
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x14ff90
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x14f6c3
jmp 0x14f721
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
shlq $0x2, %rdx
callq 0x593a0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless.c
// Function: Clip255
static WEBP_INLINE uint32_t Clip255(uint32_t a) {
  if (a < 256) {
    return a;
  }
  // return 0, when a is a negative integer.
  // return 255, when a is positive.
  return ~a >> 24;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x100, -0x8(%rbp)      # imm = 0x100
jae 0x14fcd8
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x14fce4
movl -0x8(%rbp), %eax
xorl $-0x1, %eax
shrl $0x18, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl -0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x14fdde
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl -0x28(%rbp), %esi
callq 0x14fea0
movl %eax, %edx
movl %edx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x14fda8
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x150a80
cmpl $0x0, %eax
jne 0x151150
jmp 0x15116f
leaq 0x6ece5(%rip), %rdi     # 0x1bfe3c
leaq 0x6ecfa(%rip), %rsi     # 0x1bfe58
movl $0xa2, %edx
leaq 0x6ee9f(%rip), %rcx     # 0x1c0009
callq 0x598a0
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x15118b
movq 0xc80b1(%rip), %rax     # 0x219230
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
jmp 0x15119c
movq 0xc80a6(%rip), %rax     # 0x219238
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jg 0x151337
movq -0x8(%rbp), %rdi
callq 0x150ef0
cmpl $0x0, %eax
jne 0x1511da
jmp 0x1511f9
leaq 0x6ed6a(%rip), %rdi     # 0x1bff4b
leaq 0x6ec70(%rip), %rsi     # 0x1bfe58
movl $0xac, %edx
leaq 0x6ee56(%rip), %rcx     # 0x1c004a
callq 0x598a0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x151215
movq 0xc8036(%rip), %rax     # 0x219240
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0x151300
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x151231
movq 0xc8022(%rip), %rax     # 0x219248
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0x1512fe
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jne 0x15124d
movq -0x8(%rbp), %rax
cmpl $0x1, 0x24(%rax)
jne 0x15124d
jmp 0x15126c
leaq 0x6ee26(%rip), %rdi     # 0x1c007a
leaq 0x6ebfd(%rip), %rsi     # 0x1bfe58
movl $0xb3, %edx
leaq 0x6ede3(%rip), %rcx     # 0x1c004a
callq 0x598a0
movq -0x8(%rbp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0x151282
movq -0x8(%rbp), %rax
cmpl $0x2, 0x34(%rax)
jg 0x151282
jmp 0x1512a1
leaq 0x6ee27(%rip), %rdi     # 0x1c00b0
leaq 0x6ebc8(%rip), %rsi     # 0x1bfe58
movl $0xb4, %edx
leaq 0x6edae(%rip), %rcx     # 0x1c004a
callq 0x598a0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
movq -0x8(%rbp), %rdx
imull 0x34(%rdx), %ecx
cmpl %ecx, %eax
jge 0x1512fc
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0xc(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1512a8
jmp 0x1512fe
jmp 0x151300
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/rescaler.c
// Function: WebPRescalerDspInit_body
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 %rbp
movq %rsp, %rbp
leaq -0x70b(%rip), %rax      # 0x150c80
movq %rax, 0xc7eae(%rip)     # 0x219240
leaq -0x489(%rip), %rax      # 0x150f10
movq %rax, 0xc7ea8(%rip)     # 0x219248
leaq -0xb17(%rip), %rax      # 0x150890
movq %rax, 0xc7e8a(%rip)     # 0x219238
leaq -0x915(%rip), %rax      # 0x150aa0
movq %rax, 0xc7e74(%rip)     # 0x219230
movq 0xb736d(%rip), %rax     # 0x208730
cmpq $0x0, (%rax)
je 0x1513e0
xorl %edi, %edi
movq 0xb735e(%rip), %rax     # 0x208730
callq *(%rax)
cmpl $0x0, %eax
je 0x1513de
callq 0x16c200
jmp 0x1513e0
cmpq $0x0, 0xc7e58(%rip)     # 0x219240
je 0x1513ec
jmp 0x15140b
leaq 0x6ece8(%rip), %rdi     # 0x1c00db
leaq 0x6ea5e(%rip), %rsi     # 0x1bfe58
movl $0xf7, %edx
leaq 0x6ecf9(%rip), %rcx     # 0x1c00ff
callq 0x598a0
cmpq $0x0, 0xc7e35(%rip)     # 0x219248
je 0x151417
jmp 0x151436
leaq 0x6ed05(%rip), %rdi     # 0x1c0123
leaq 0x6ea33(%rip), %rsi     # 0x1bfe58
movl $0xf8, %edx
leaq 0x6ecce(%rip), %rcx     # 0x1c00ff
callq 0x598a0
cmpq $0x0, 0xc7dfa(%rip)     # 0x219238
je 0x151442
jmp 0x151461
leaq 0x6ecfe(%rip), %rdi     # 0x1c0147
leaq 0x6ea08(%rip), %rsi     # 0x1bfe58
movl $0xf9, %edx
leaq 0x6eca3(%rip), %rcx     # 0x1c00ff
callq 0x598a0
cmpq $0x0, 0xc7dc7(%rip)     # 0x219230
je 0x15146d
jmp 0x15148c
leaq 0x6ecf7(%rip), %rdi     # 0x1c016b
leaq 0x6e9dd(%rip), %rsi     # 0x1bfe58
movl $0xfa, %edx
leaq 0x6ec78(%rip), %rcx     # 0x1c00ff
callq 0x598a0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv.h
// Function: VP8YuvToRgba4444
static WEBP_INLINE void VP8YuvToRgba4444(int y, int u, int v,
                                         uint8_t* const argb) {
  const int r = VP8YUVToR(y, v);        // 4 usable bits
  const int g = VP8YUVToG(y, u, v);     // 4 usable bits
  const int b = VP8YUVToB(y, u);        // 4 usable bits
  const int rg = (r & 0xf0) | (g >> 4);
  const int ba = (b & 0xf0) | 0x0f;     // overwrite the lower 4 bits
#if (WEBP_SWAP_16BIT_CSP == 1)
  argb[0] = ba;
  argb[1] = rg;
#else
  argb[0] = rg;
  argb[1] = ba;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x151f00
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x151f50
movl %eax, -0x20(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x151fb0
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
andl $0xf0, %eax
movl -0x20(%rbp), %ecx
sarl $0x4, %ecx
orl %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
andl $0xf0, %eax
orl $0xf, %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv.h
// Function: VP8YuvToRgb565
static WEBP_INLINE void VP8YuvToRgb565(int y, int u, int v,
                                       uint8_t* const rgb) {
  const int r = VP8YUVToR(y, v);      // 5 usable bits
  const int g = VP8YUVToG(y, u, v);   // 6 usable bits
  const int b = VP8YUVToB(y, u);      // 5 usable bits
  const int rg = (r & 0xf8) | (g >> 5);
  const int gb = ((g << 3) & 0xe0) | (b >> 3);
#if (WEBP_SWAP_16BIT_CSP == 1)
  rgb[0] = gb;
  rgb[1] = rg;
#else
  rgb[0] = rg;
  rgb[1] = gb;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x151f00
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x151f50
movl %eax, -0x20(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x151fb0
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
andl $0xf8, %eax
movl -0x20(%rbp), %ecx
sarl $0x5, %ecx
orl %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
shll $0x3, %eax
andl $0xe0, %eax
movl -0x24(%rbp), %ecx
sarl $0x3, %ecx
orl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)