LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv_sse2.c
// Function: ConvertRGBToY_SSE2
static WEBP_INLINE void ConvertRGBToY_SSE2(const __m128i* const R,
                                           const __m128i* const G,
                                           const __m128i* const B,
                                           __m128i* const Y) {
  const __m128i kRG_y = MK_CST_16(16839, 33059 - 16384);
  const __m128i kGB_y = MK_CST_16(16384, 6420);
  const __m128i kHALF_Y = _mm_set1_epi32((16 << YUV_FIX) + YUV_HALF);

  const __m128i RG_lo = _mm_unpacklo_epi16(*R, *G);
  const __m128i RG_hi = _mm_unpackhi_epi16(*R, *G);
  const __m128i GB_lo = _mm_unpacklo_epi16(*G, *B);
  const __m128i GB_hi = _mm_unpackhi_epi16(*G, *B);
  TRANSFORM(RG_lo, RG_hi, GB_lo, GB_hi, kRG_y, kGB_y, kHALF_Y, YUV_FIX, *Y);
}

// Assembly:
movdqa (%rdi), %xmm1
movdqa (%rsi), %xmm0
movdqa %xmm1, %xmm2
punpcklwd %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1],xmm2[2],xmm0[2],xmm2[3],xmm0[3]
punpckhwd %xmm0, %xmm1    # xmm1 = xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
movdqa (%rdx), %xmm3
movdqa %xmm0, %xmm4
punpcklwd %xmm3, %xmm4    # xmm4 = xmm4[0],xmm3[0],xmm4[1],xmm3[1],xmm4[2],xmm3[2],xmm4[3],xmm3[3]
punpckhwd %xmm3, %xmm0    # xmm0 = xmm0[4],xmm3[4],xmm0[5],xmm3[5],xmm0[6],xmm3[6],xmm0[7],xmm3[7]
movdqa 0x3d148(%rip), %xmm3    # 0x11d470
pmaddwd %xmm3, %xmm2
pmaddwd %xmm3, %xmm1
movdqa 0x3d148(%rip), %xmm3    # 0x11d480
pmaddwd %xmm3, %xmm4
paddd %xmm2, %xmm4
pmaddwd %xmm3, %xmm0
paddd %xmm1, %xmm0
movdqa 0x3d140(%rip), %xmm1    # 0x11d490
paddd %xmm1, %xmm4
paddd %xmm1, %xmm0
psrad $0x10, %xmm4
psrad $0x10, %xmm0
packssdw %xmm0, %xmm4
movdqa %xmm4, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv_sse2.c
// Function: ConvertRGBToUV_SSE2
static WEBP_INLINE void ConvertRGBToUV_SSE2(const __m128i* const R,
                                            const __m128i* const G,
                                            const __m128i* const B,
                                            __m128i* const U,
                                            __m128i* const V) {
  const __m128i kRG_u = MK_CST_16(-9719, -19081);
  const __m128i kGB_u = MK_CST_16(0, 28800);
  const __m128i kRG_v = MK_CST_16(28800, 0);
  const __m128i kGB_v = MK_CST_16(-24116, -4684);
  const __m128i kHALF_UV = _mm_set1_epi32(((128 << YUV_FIX) + YUV_HALF) << 2);

  const __m128i RG_lo = _mm_unpacklo_epi16(*R, *G);
  const __m128i RG_hi = _mm_unpackhi_epi16(*R, *G);
  const __m128i GB_lo = _mm_unpacklo_epi16(*G, *B);
  const __m128i GB_hi = _mm_unpackhi_epi16(*G, *B);
  TRANSFORM(RG_lo, RG_hi, GB_lo, GB_hi, kRG_u, kGB_u,
            kHALF_UV, YUV_FIX + 2, *U);
  TRANSFORM(RG_lo, RG_hi, GB_lo, GB_hi, kRG_v, kGB_v,
            kHALF_UV, YUV_FIX + 2, *V);
}

// Assembly:
movdqa (%rdi), %xmm2
movdqa (%rsi), %xmm0
movdqa %xmm2, %xmm3
punpcklwd %xmm0, %xmm3    # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1],xmm3[2],xmm0[2],xmm3[3],xmm0[3]
punpckhwd %xmm0, %xmm2    # xmm2 = xmm2[4],xmm0[4],xmm2[5],xmm0[5],xmm2[6],xmm0[6],xmm2[7],xmm0[7]
movdqa (%rdx), %xmm4
movdqa %xmm0, %xmm1
punpcklwd %xmm4, %xmm1    # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1],xmm1[2],xmm4[2],xmm1[3],xmm4[3]
punpckhwd %xmm4, %xmm0    # xmm0 = xmm0[4],xmm4[4],xmm0[5],xmm4[5],xmm0[6],xmm4[6],xmm0[7],xmm4[7]
movdqa 0x3d109(%rip), %xmm4    # 0x11d4a0
movdqa %xmm3, %xmm5
pmaddwd %xmm4, %xmm5
pmaddwd %xmm2, %xmm4
movdqa 0x3d105(%rip), %xmm6    # 0x11d4b0
movdqa %xmm1, %xmm7
pmaddwd %xmm6, %xmm7
paddd %xmm5, %xmm7
pmaddwd %xmm0, %xmm6
paddd %xmm4, %xmm6
movdqa 0x3d0f9(%rip), %xmm4    # 0x11d4c0
paddd %xmm4, %xmm7
paddd %xmm4, %xmm6
psrad $0x12, %xmm7
psrad $0x12, %xmm6
packssdw %xmm6, %xmm7
movdqa %xmm7, (%rcx)
movdqa 0x3d0e7(%rip), %xmm5    # 0x11d4d0
pmaddwd %xmm5, %xmm3
pmaddwd %xmm5, %xmm2
movdqa 0x3d0e7(%rip), %xmm5    # 0x11d4e0
pmaddwd %xmm5, %xmm1
paddd %xmm3, %xmm1
pmaddwd %xmm5, %xmm0
paddd %xmm2, %xmm0
paddd %xmm4, %xmm1
paddd %xmm4, %xmm0
psrad $0x12, %xmm1
psrad $0x12, %xmm0
packssdw %xmm0, %xmm1
movdqa %xmm1, (%r8)
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv_sse2.c
// Function: RGB24PackedToPlanar_SSE2
static WEBP_INLINE void RGB24PackedToPlanar_SSE2(
    const uint8_t* const rgb, __m128i* const out /*out[6]*/) {
  __m128i tmp[6];
  tmp[0] = _mm_loadu_si128((const __m128i*)(rgb +  0));
  tmp[1] = _mm_loadu_si128((const __m128i*)(rgb + 16));
  tmp[2] = _mm_loadu_si128((const __m128i*)(rgb + 32));
  tmp[3] = _mm_loadu_si128((const __m128i*)(rgb + 48));
  tmp[4] = _mm_loadu_si128((const __m128i*)(rgb + 64));
  tmp[5] = _mm_loadu_si128((const __m128i*)(rgb + 80));

  RGB24PackedToPlanarHelper_SSE2(tmp, out);
  RGB24PackedToPlanarHelper_SSE2(out, tmp);
  RGB24PackedToPlanarHelper_SSE2(tmp, out);
  RGB24PackedToPlanarHelper_SSE2(out, tmp);
  RGB24PackedToPlanarHelper_SSE2(tmp, out);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movups (%rdi), %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movups 0x10(%rdi), %xmm0
movaps %xmm0, 0x10(%r14)
movups 0x20(%rdi), %xmm0
movaps %xmm0, 0x20(%r14)
movups 0x30(%rdi), %xmm0
movaps %xmm0, 0x30(%r14)
movups 0x40(%rdi), %xmm0
movaps %xmm0, 0x40(%r14)
movups 0x50(%rdi), %xmm0
movaps %xmm0, 0x50(%r14)
movq %r14, %rdi
callq 0xe04a2
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe04a2
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe04a2
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe04a2
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe04a2
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv_sse2.c
// Function: RGB24PackedToPlanarHelper_SSE2
static WEBP_INLINE void RGB24PackedToPlanarHelper_SSE2(
    const __m128i* const in /*in[6]*/, __m128i* const out /*out[6]*/) {
  out[0] = _mm_unpacklo_epi8(in[0], in[3]);
  out[1] = _mm_unpackhi_epi8(in[0], in[3]);
  out[2] = _mm_unpacklo_epi8(in[1], in[4]);
  out[3] = _mm_unpackhi_epi8(in[1], in[4]);
  out[4] = _mm_unpacklo_epi8(in[2], in[5]);
  out[5] = _mm_unpackhi_epi8(in[2], in[5]);
}

// Assembly:
movdqa (%rdi), %xmm0
punpcklbw 0x30(%rdi), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1],xmm0[2],mem[2],xmm0[3],mem[3],xmm0[4],mem[4],xmm0[5],mem[5],xmm0[6],mem[6],xmm0[7],mem[7]
movdqa %xmm0, (%rsi)
movdqa (%rdi), %xmm0
punpckhbw 0x30(%rdi), %xmm0 # xmm0 = xmm0[8],mem[8],xmm0[9],mem[9],xmm0[10],mem[10],xmm0[11],mem[11],xmm0[12],mem[12],xmm0[13],mem[13],xmm0[14],mem[14],xmm0[15],mem[15]
movdqa %xmm0, 0x10(%rsi)
movdqa 0x10(%rdi), %xmm0
punpcklbw 0x40(%rdi), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1],xmm0[2],mem[2],xmm0[3],mem[3],xmm0[4],mem[4],xmm0[5],mem[5],xmm0[6],mem[6],xmm0[7],mem[7]
movdqa %xmm0, 0x20(%rsi)
movdqa 0x10(%rdi), %xmm0
punpckhbw 0x40(%rdi), %xmm0 # xmm0 = xmm0[8],mem[8],xmm0[9],mem[9],xmm0[10],mem[10],xmm0[11],mem[11],xmm0[12],mem[12],xmm0[13],mem[13],xmm0[14],mem[14],xmm0[15],mem[15]
movdqa %xmm0, 0x30(%rsi)
movdqa 0x20(%rdi), %xmm0
punpcklbw 0x50(%rdi), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1],xmm0[2],mem[2],xmm0[3],mem[3],xmm0[4],mem[4],xmm0[5],mem[5],xmm0[6],mem[6],xmm0[7],mem[7]
movdqa %xmm0, 0x40(%rsi)
movdqa 0x20(%rdi), %xmm0
punpckhbw 0x50(%rdi), %xmm0 # xmm0 = xmm0[8],mem[8],xmm0[9],mem[9],xmm0[10],mem[10],xmm0[11],mem[11],xmm0[12],mem[12],xmm0[13],mem[13],xmm0[14],mem[14],xmm0[15],mem[15]
movdqa %xmm0, 0x50(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv_sse2.c
// Function: RGBA32PackedToPlanar_16b_SSE2
static WEBP_INLINE void RGBA32PackedToPlanar_16b_SSE2(
    const uint16_t* const rgbx,
    __m128i* const r, __m128i* const g, __m128i* const b) {
  const __m128i in0 = LOAD_16(rgbx +  0);  // r0 | g0 | b0 |x| r1 | g1 | b1 |x
  const __m128i in1 = LOAD_16(rgbx +  8);  // r2 | g2 | b2 |x| r3 | g3 | b3 |x
  const __m128i in2 = LOAD_16(rgbx + 16);  // r4 | ...
  const __m128i in3 = LOAD_16(rgbx + 24);  // r6 | ...
  // column-wise transpose
  const __m128i A0 = _mm_unpacklo_epi16(in0, in1);
  const __m128i A1 = _mm_unpackhi_epi16(in0, in1);
  const __m128i A2 = _mm_unpacklo_epi16(in2, in3);
  const __m128i A3 = _mm_unpackhi_epi16(in2, in3);
  const __m128i B0 = _mm_unpacklo_epi16(A0, A1);  // r0 r1 r2 r3 | g0 g1 ..
  const __m128i B1 = _mm_unpackhi_epi16(A0, A1);  // b0 b1 b2 b3 | x x x x
  const __m128i B2 = _mm_unpacklo_epi16(A2, A3);  // r4 r5 r6 r7 | g4 g5 ..
  const __m128i B3 = _mm_unpackhi_epi16(A2, A3);  // b4 b5 b6 b7 | x x x x
  *r = _mm_unpacklo_epi64(B0, B2);
  *g = _mm_unpackhi_epi64(B0, B2);
  *b = _mm_unpacklo_epi64(B1, B3);
}

// Assembly:
movdqu (%rdi), %xmm0
movdqu 0x10(%rdi), %xmm1
movdqu 0x20(%rdi), %xmm2
movdqu 0x30(%rdi), %xmm3
movdqa %xmm0, %xmm4
punpcklwd %xmm1, %xmm4    # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1],xmm4[2],xmm1[2],xmm4[3],xmm1[3]
punpckhwd %xmm1, %xmm0    # xmm0 = xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
movdqa %xmm2, %xmm1
punpcklwd %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1],xmm1[2],xmm3[2],xmm1[3],xmm3[3]
punpckhwd %xmm3, %xmm2    # xmm2 = xmm2[4],xmm3[4],xmm2[5],xmm3[5],xmm2[6],xmm3[6],xmm2[7],xmm3[7]
movdqa %xmm4, %xmm3
punpcklwd %xmm0, %xmm3    # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1],xmm3[2],xmm0[2],xmm3[3],xmm0[3]
punpckhwd %xmm0, %xmm4    # xmm4 = xmm4[4],xmm0[4],xmm4[5],xmm0[5],xmm4[6],xmm0[6],xmm4[7],xmm0[7]
movdqa %xmm1, %xmm0
punpcklwd %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1],xmm0[2],xmm2[2],xmm0[3],xmm2[3]
punpckhwd %xmm2, %xmm1    # xmm1 = xmm1[4],xmm2[4],xmm1[5],xmm2[5],xmm1[6],xmm2[6],xmm1[7],xmm2[7]
punpcklqdq %xmm1, %xmm4    # xmm4 = xmm4[0],xmm1[0]
movdqa %xmm3, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
movdqa %xmm1, (%rsi)
punpckhqdq %xmm0, %xmm3    # xmm3 = xmm3[1],xmm0[1]
movdqa %xmm3, (%rdx)
movdqa %xmm4, (%rcx)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8InitBitReader
void VP8InitBitReader(VP8BitReader* const br,
                      const uint8_t* const start, size_t size) {
  assert(br != NULL);
  assert(start != NULL);
  assert(size < (1u << 31));   // limit ensured by format and upstream checks
  br->range_   = 255 - 1;
  br->value_   = 0;
  br->bits_    = -8;   // to load the very first 8bits
  br->eof_     = 0;
  VP8BitReaderSetBuffer(br, start, size);
  VP8LoadNewBytes(br);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xe05c4
testq %rsi, %rsi
je 0xe05dd
movq %rdx, %rax
shrq $0x1f, %rax
jne 0xe05f6
movabsq $-0x7ffffff02, %rax     # imm = 0xFFFFFFF8000000FE
movq %rax, 0x8(%rdi)
andq $0x0, (%rdi)
andl $0x0, 0x28(%rdi)
movq %rsi, 0x10(%rdi)
leaq (%rsi,%rdx), %rax
movq %rax, 0x18(%rdi)
cmpq $0x8, %rdx
leaq -0x7(%rsi,%rdx), %rax
cmovbq %rsi, %rax
movq %rax, 0x20(%rdi)
popq %rax
jmp 0xe0613
leaq 0x3cf25(%rip), %rdi     # 0x11d4f0
leaq 0x3cf29(%rip), %rsi     # 0x11d4fb
leaq 0x3cf3f(%rip), %rcx     # 0x11d518
pushq $0x25
jmp 0xe060d
leaq 0x39159(%rip), %rdi     # 0x11973d
leaq 0x3cf10(%rip), %rsi     # 0x11d4fb
leaq 0x3cf26(%rip), %rcx     # 0x11d518
pushq $0x26
jmp 0xe060d
leaq 0x3cf64(%rip), %rdi     # 0x11d561
leaq 0x3cef7(%rip), %rsi     # 0x11d4fb
leaq 0x3cf0d(%rip), %rcx     # 0x11d518
pushq $0x27
popq %rdx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8RemapBitReader
void VP8RemapBitReader(VP8BitReader* const br, ptrdiff_t offset) {
  if (br->buf_ != NULL) {
    br->buf_ += offset;
    br->buf_end_ += offset;
    br->buf_max_ += offset;
  }
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xe067a
addq %rsi, %rax
movq %rax, 0x10(%rdi)
addq %rsi, 0x18(%rdi)
addq %rsi, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8LoadFinalBytes
void VP8LoadFinalBytes(VP8BitReader* const br) {
  assert(br != NULL && br->buf_ != NULL);
  // Only read 8bits at a time
  if (br->buf_ < br->buf_end_) {
    br->bits_ += 8;
    br->value_ = (bit_t)(*br->buf_++) | (br->value_ << 8);
  } else if (!br->eof_) {
    br->value_ <<= 8;
    br->bits_ += 8;
    br->eof_ = 1;
  } else {
    br->bits_ = 0;  // This is to avoid undefined behaviour with shifts.
  }
}

// Assembly:
testq %rdi, %rdi
je 0xe06c7
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xe06c7
cmpq 0x18(%rdi), %rax
jae 0xe06ac
addl $0x8, 0xc(%rdi)
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rdi)
movzbl (%rax), %eax
movq (%rdi), %rcx
shlq $0x8, %rcx
orq %rax, %rcx
movq %rcx, (%rdi)
retq
cmpl $0x0, 0x28(%rdi)
je 0xe06b7
andl $0x0, 0xc(%rdi)
retq
shlq $0x8, (%rdi)
addl $0x8, 0xc(%rdi)
movl $0x1, 0x28(%rdi)
retq
pushq %rax
leaq 0x38d21(%rip), %rdi     # 0x1193f0
leaq 0x3ce25(%rip), %rsi     # 0x11d4fb
leaq 0x3ce96(%rip), %rcx     # 0x11d573
pushq $0x59
popq %rdx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8GetValue
uint32_t VP8GetValue(VP8BitReader* const br, int bits, const char label[]) {
  uint32_t v = 0;
  while (bits-- > 0) {
    v |= VP8GetBit(br, 0x80, label) << bits;
  }
  return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
testl %ebx, %ebx
jle 0xe076a
movl 0x8(%r14), %r15d
movl 0xc(%r14), %ecx
testl %ecx, %ecx
jns 0xe070f
movq %r14, %rdi
callq 0xe0613
movl 0xc(%r14), %ecx
movl %r15d, %edx
shrl %edx
andl $0xffffff, %edx         # imm = 0xFFFFFF
movq (%r14), %rdi
movl %ecx, %eax
movq %rdi, %rsi
shrq %cl, %rsi
cmpl %esi, %edx
jae 0xe073d
leaq 0x1(%rdx), %r8
movl %eax, %ecx
shlq %cl, %r8
subl %edx, %r15d
subq %r8, %rdi
movq %rdi, (%r14)
jmp 0xe0741
leal 0x1(%rdx), %r15d
decl %ebx
xorl %edi, %edi
cmpl %esi, %edx
setb %dil
bsrl %r15d, %ecx
xorl $0x7, %ecx
shll %cl, %r15d
subl %ecx, %eax
movl %eax, 0xc(%r14)
decl %r15d
movl %r15d, 0x8(%r14)
movl %ebx, %ecx
shll %cl, %edi
orl %edi, %ebp
jmp 0xe06f3
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8LInitBitReader
void VP8LInitBitReader(VP8LBitReader* const br, const uint8_t* const start,
                       size_t length) {
  size_t i;
  vp8l_val_t value = 0;
  assert(br != NULL);
  assert(start != NULL);
  assert(length < 0xfffffff8u);   // can't happen with a RIFF chunk.

  br->len_ = length;
  br->val_ = 0;
  br->bit_pos_ = 0;
  br->eos_ = 0;

  if (length > sizeof(br->val_)) {
    length = sizeof(br->val_);
  }
  for (i = 0; i < length; ++i) {
    value |= (vp8l_val_t)start[i] << (8 * i);
  }
  br->val_ = value;
  br->pos_ = length;
  br->buf_ = start;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xe080b
testq %rsi, %rsi
je 0xe082a
movq %rdx, %rax
shrq $0x3, %rax
cmpq $0x1fffffff, %rax       # imm = 0x1FFFFFFF
jae 0xe0849
movq %rdx, 0x10(%rdi)
andq $0x0, (%rdi)
andq $0x0, 0x20(%rdi)
cmpq $0x8, %rdx
pushq $0x8
popq %rax
cmovbq %rdx, %rax
leal (,%rax,8), %edx
xorl %ecx, %ecx
movq %rsi, %r8
xorl %r9d, %r9d
cmpq %rcx, %rdx
je 0xe07fe
movzbl (%r8), %r10d
shlq %cl, %r10
orq %r10, %r9
addq $0x8, %rcx
incq %r8
jmp 0xe07e6
movq %r9, (%rdi)
movq %rax, 0x18(%rdi)
movq %rsi, 0x8(%rdi)
popq %rax
retq
leaq 0x3ccde(%rip), %rdi     # 0x11d4f0
leaq 0x3cce2(%rip), %rsi     # 0x11d4fb
leaq 0x3cd7f(%rip), %rcx     # 0x11d59f
movl $0x91, %edx
callq 0x56770
leaq 0x38f0c(%rip), %rdi     # 0x11973d
leaq 0x3ccc3(%rip), %rsi     # 0x11d4fb
leaq 0x3cd60(%rip), %rcx     # 0x11d59f
movl $0x92, %edx
callq 0x56770
leaq 0x3cd9a(%rip), %rdi     # 0x11d5ea
leaq 0x3cca4(%rip), %rsi     # 0x11d4fb
leaq 0x3cd41(%rip), %rcx     # 0x11d59f
movl $0x93, %edx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8LBitReaderSetBuffer
void VP8LBitReaderSetBuffer(VP8LBitReader* const br,
                            const uint8_t* const buf, size_t len) {
  assert(br != NULL);
  assert(buf != NULL);
  assert(len < 0xfffffff8u);   // can't happen with a RIFF chunk.
  br->buf_ = buf;
  br->len_ = len;
  // pos_ > len_ should be considered a param error.
  br->eos_ = (br->pos_ > br->len_) || VP8LIsEndOfStream(br);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xe08a5
testq %rsi, %rsi
je 0xe08c4
movq %rdx, %rax
shrq $0x3, %rax
cmpq $0x1fffffff, %rax       # imm = 0x1FFFFFFF
jae 0xe08e3
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
cmpq %rdx, 0x18(%rdi)
jbe 0xe0898
pushq $0x1
popq %rax
jmp 0xe08a0
movq %rbx, %rdi
callq 0xe0902
movl %eax, 0x24(%rbx)
popq %rbx
retq
leaq 0x3cc44(%rip), %rdi     # 0x11d4f0
leaq 0x3cc48(%rip), %rsi     # 0x11d4fb
leaq 0x3cd45(%rip), %rcx     # 0x11d5ff
movl $0xa7, %edx
callq 0x56770
leaq 0x37d67(%rip), %rdi     # 0x118632
leaq 0x3cc29(%rip), %rsi     # 0x11d4fb
leaq 0x3cd26(%rip), %rcx     # 0x11d5ff
movl $0xa8, %edx
callq 0x56770
leaq 0x3cd65(%rip), %rdi     # 0x11d64f
leaq 0x3cc0a(%rip), %rsi     # 0x11d4fb
leaq 0x3cd07(%rip), %rcx     # 0x11d5ff
movl $0xa9, %edx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8LDoFillBitWindow
void VP8LDoFillBitWindow(VP8LBitReader* const br) {
  assert(br->bit_pos_ >= VP8L_WBITS);
#if defined(VP8L_USE_FAST_LOAD)
  if (br->pos_ + sizeof(br->val_) < br->len_) {
    br->val_ >>= VP8L_WBITS;
    br->bit_pos_ -= VP8L_WBITS;
    br->val_ |= (vp8l_val_t)HToLE32(WebPMemToUint32(br->buf_ + br->pos_)) <<
                (VP8L_LBITS - VP8L_WBITS);
    br->pos_ += VP8L_LOG8_WBITS;
    return;
  }
#endif
  ShiftBytes(br);       // Slow path.
}

// Assembly:
movl 0x20(%rdi), %ecx
cmpl $0x1f, %ecx
jle 0xe098d
movq 0x18(%rdi), %rax
leaq 0x8(%rax), %rdx
cmpq 0x10(%rdi), %rdx
jae 0xe098b
movq (%rdi), %rdx
movq 0x8(%rdi), %rsi
movq %rdx, %r8
shrq $0x20, %r8
movq %r8, (%rdi)
addl $-0x20, %ecx
movl %ecx, 0x20(%rdi)
movl (%rsi,%rax), %ecx
shldq $0x20, %rdx, %rcx
movq %rcx, (%rdi)
addq $0x4, %rax
movq %rax, 0x18(%rdi)
retq
jmp 0xe09ad
pushq %rax
leaq 0x3cccc(%rip), %rdi     # 0x11d661
leaq 0x3cb5f(%rip), %rsi     # 0x11d4fb
leaq 0x3ccd9(%rip), %rcx     # 0x11d67c
movl $0xc3, %edx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: ShiftBytes
static void ShiftBytes(VP8LBitReader* const br) {
  while (br->bit_pos_ >= 8 && br->pos_ < br->len_) {
    br->val_ >>= 8;
    br->val_ |= ((vp8l_val_t)br->buf_[br->pos_]) << (VP8L_LBITS - 8);
    ++br->pos_;
    br->bit_pos_ -= 8;
  }
  if (VP8LIsEndOfStream(br)) {
    VP8LSetEndOfStream(br);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpl $0x8, %eax
jl 0xe09ef
movq 0x18(%rbx), %rcx
cmpq 0x10(%rbx), %rcx
jae 0xe09ef
movq (%rbx), %rdx
movq 0x8(%rbx), %rsi
movq %rdx, %rdi
shrq $0x8, %rdi
movq %rdi, (%rbx)
movzbl (%rsi,%rcx), %esi
shldq $0x38, %rdx, %rsi
movq %rsi, (%rbx)
incq %rcx
movq %rcx, 0x18(%rbx)
addl $-0x8, %eax
movl %eax, 0x20(%rbx)
jmp 0xe09b4
movq %rbx, %rdi
callq 0xe0902
testl %eax, %eax
je 0xe0a09
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/bit_reader_utils.c
// Function: VP8LReadBits
uint32_t VP8LReadBits(VP8LBitReader* const br, int n_bits) {
  assert(n_bits >= 0);
  // Flag an error if end_of_stream or n_bits is more than allowed limit.
  if (!br->eos_ && n_bits <= VP8L_MAX_NUM_BIT_READ) {
    const uint32_t val = VP8LPrefetchBits(br) & kBitMask[n_bits];
    const int new_bits = br->bit_pos_ + n_bits;
    br->bit_pos_ = new_bits;
    ShiftBytes(br);
    return val;
  } else {
    VP8LSetEndOfStream(br);
    return 0;
  }
}

// Assembly:
pushq %rbx
testl %esi, %esi
js 0xe0a50
cmpl $0x18, %esi
ja 0xe0a3c
cmpl $0x0, 0x24(%rdi)
jne 0xe0a3c
movq (%rdi), %rbx
movl 0x20(%rdi), %ecx
shrq %cl, %rbx
movl %esi, %eax
leaq 0x3cdc3(%rip), %rdx     # 0x11d7f0
andl (%rdx,%rax,4), %ebx
addl %esi, %ecx
movl %ecx, 0x20(%rdi)
callq 0xe09ad
jmp 0xe0a4c
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x20(%rdi)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
leaq 0x3cc54(%rip), %rdi     # 0x11d6ab
leaq 0x3ca9d(%rip), %rsi     # 0x11d4fb
leaq 0x3cc52(%rip), %rcx     # 0x11d6b7
movl $0xd2, %edx
callq 0x56770
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/color_cache_utils.c
// Function: VP8LColorCacheInit
int VP8LColorCacheInit(VP8LColorCache* const color_cache, int hash_bits) {
  const int hash_size = 1 << hash_bits;
  assert(color_cache != NULL);
  assert(hash_bits > 0);
  color_cache->colors_ = (uint32_t*)WebPSafeCalloc(
      (uint64_t)hash_size, sizeof(*color_cache->colors_));
  if (color_cache->colors_ == NULL) return 0;
  color_cache->hash_shift_ = 32 - hash_bits;
  color_cache->hash_bits_ = hash_bits;
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
pushq $0x1
popq %rbx
movl %ebx, %eax
movl %ebp, %ecx
shll %cl, %eax
testq %rdi, %rdi
je 0xe0ab6
testl %ebp, %ebp
jle 0xe0acf
movq %rdi, %r14
movslq %eax, %rdi
pushq $0x4
popq %rsi
callq 0x57690
movq %rax, (%r14)
testq %rax, %rax
je 0xe0aad
pushq $0x20
popq %rax
subl %ebp, %eax
movl %eax, 0x8(%r14)
movl %ebp, 0xc(%r14)
jmp 0xe0aaf
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3cd97(%rip), %rdi     # 0x11d854
leaq 0x3cda4(%rip), %rsi     # 0x11d868
leaq 0x3cdbb(%rip), %rcx     # 0x11d886
pushq $0x19
jmp 0xe0ae6
leaq 0x3cde3(%rip), %rdi     # 0x11d8b9
leaq 0x3cd8b(%rip), %rsi     # 0x11d868
leaq 0x3cda2(%rip), %rcx     # 0x11d886
pushq $0x1a
popq %rdx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/color_cache_utils.c
// Function: VP8LColorCacheCopy
void VP8LColorCacheCopy(const VP8LColorCache* const src,
                        VP8LColorCache* const dst) {
  assert(src != NULL);
  assert(dst != NULL);
  assert(src->hash_bits_ == dst->hash_bits_);
  memcpy(dst->colors_, src->colors_,
         ((size_t)1u << dst->hash_bits_) * sizeof(*dst->colors_));
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xe0b2b
testq %rsi, %rsi
je 0xe0b44
movl 0xc(%rdi), %ecx
cmpl 0xc(%rsi), %ecx
jne 0xe0b5d
movq (%rsi), %rax
pushq $0x4
popq %rdx
shlq %cl, %rdx
movq (%rdi), %rsi
movq %rax, %rdi
popq %rax
jmp 0x562f0
leaq 0x3cd95(%rip), %rdi     # 0x11d8c7
leaq 0x3cd2f(%rip), %rsi     # 0x11d868
leaq 0x3cd93(%rip), %rcx     # 0x11d8d3
pushq $0x2c
jmp 0xe0b74
leaq 0x37f61(%rip), %rdi     # 0x118aac
leaq 0x3cd16(%rip), %rsi     # 0x11d868
leaq 0x3cd7a(%rip), %rcx     # 0x11d8d3
pushq $0x2d
jmp 0xe0b74
leaq 0x3cdbb(%rip), %rdi     # 0x11d91f
leaq 0x3ccfd(%rip), %rsi     # 0x11d868
leaq 0x3cd61(%rip), %rcx     # 0x11d8d3
pushq $0x2e
popq %rdx
callq 0x56770
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/huffman_utils.c
// Function: VP8LHtreeGroupsNew
HTreeGroup* VP8LHtreeGroupsNew(int num_htree_groups) {
  HTreeGroup* const htree_groups =
      (HTreeGroup*)WebPSafeMalloc(num_htree_groups, sizeof(*htree_groups));
  if (htree_groups == NULL) {
    return NULL;
  }
  assert(num_htree_groups <= MAX_HTREE_GROUPS);
  return htree_groups;
}

// Assembly:
pushq %rbx
movslq %edi, %rbx
movl $0x238, %esi            # imm = 0x238
movq %rbx, %rdi
callq 0x57c90
testq %rax, %rax
sete %cl
cmpl $0x10001, %ebx          # imm = 0x10001
setl %dl
orb %cl, %dl
je 0xe0ba2
popq %rbx
retq
leaq 0x3cdb7(%rip), %rdi     # 0x11d960
leaq 0x3cdd5(%rip), %rsi     # 0x11d985
leaq 0x3cde8(%rip), %rcx     # 0x11d99f
pushq $0x1f
popq %rdx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/huffman_utils.c
// Function: VP8LHuffmanTablesAllocate
int VP8LHuffmanTablesAllocate(int size, HuffmanTables* huffman_tables) {
  // Have 'segment' point to the first segment for now, 'root'.
  HuffmanTablesSegment* const root = &huffman_tables->root;
  huffman_tables->curr_segment = root;
  root->next = NULL;
  // Allocate root.
  root->start = (HuffmanCode*)WebPSafeMalloc(size, sizeof(*root->start));
  if (root->start == NULL) return 0;
  root->curr_table = root->start;
  root->size = size;
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq %rsi, 0x20(%rsi)
andq $0x0, 0x10(%rsi)
movslq %edi, %rdi
pushq $0x4
popq %rsi
callq 0x57c90
movq %rax, (%rbx)
testq %rax, %rax
je 0xe12d1
movq %rax, 0x8(%rbx)
movl %ebp, 0x18(%rbx)
pushq $0x1
popq %rax
jmp 0xe12d3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/huffman_utils.c
// Function: VP8LHuffmanTablesDeallocate
void VP8LHuffmanTablesDeallocate(HuffmanTables* const huffman_tables) {
  HuffmanTablesSegment *current, *next;
  if (huffman_tables == NULL) return;
  // Free the root node.
  current = &huffman_tables->root;
  next = current->next;
  WebPSafeFree(current->start);
  current->start = NULL;
  current->next = NULL;
  current = next;
  // Free the following nodes.
  while (current != NULL) {
    next = current->next;
    WebPSafeFree(current->start);
    WebPSafeFree(current);
    current = next;
  }
}

// Assembly:
testq %rdi, %rdi
je 0xe1320
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x10(%r14), %rbx
callq 0x58480
andq $0x0, (%r14)
andq $0x0, 0x10(%r14)
testq %rbx, %rbx
je 0xe1319
movq (%rbx), %rdi
movq 0x10(%rbx), %r14
callq 0x58480
movq %rbx, %rdi
callq 0x58480
movq %r14, %rbx
jmp 0xe12fb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/huffman_utils.c
// Function: ReplicateValue
static WEBP_INLINE void ReplicateValue(HuffmanCode* table,
                                       int step, int end,
                                       HuffmanCode code) {
  assert(end % step == 0);
  do {
    end -= step;
    table[end] = code;
  } while (end > 0);
}

// Assembly:
movl %edx, %r8d
movl %edx, %eax
cltd
idivl %esi
testl %edx, %edx
jne 0xe1344
movl %esi, %eax
negl %eax
leal (%rax,%r8), %edx
subl %esi, %r8d
movslq %edx, %rdx
movl %ecx, (%rdi,%rdx,4)
testl %r8d, %r8d
jg 0xe1331
retq
pushq %rax
leaq 0x3c7c1(%rip), %rdi     # 0x11db0d
leaq 0x3c632(%rip), %rsi     # 0x11d985
leaq 0x3c7c3(%rip), %rcx     # 0x11db1d
pushq $0x38
popq %rdx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/huffman_utils.c
// Function: GetNextKey
static WEBP_INLINE uint32_t GetNextKey(uint32_t key, int len) {
  uint32_t step = 1 << (len - 1);
  while (key & step) {
    step >>= 1;
  }
  return step ? (key & (step - 1)) + step : key;
}

// Assembly:
leal -0x1(%rsi), %ecx
pushq $0x1
popq %rax
shll %cl, %eax
movl %eax, %ecx
shrl %eax
testl %edi, %ecx
jne 0xe136a
leal -0x1(%rcx), %eax
andl %edi, %eax
addl %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/palette.c
// Function: SearchColorNoIdx
int SearchColorNoIdx(const uint32_t sorted[], uint32_t color, int num_colors) {
  int low = 0, hi = num_colors;
  if (sorted[low] == color) return low;  // loop invariant: sorted[low] != color
  while (1) {
    const int mid = (low + hi) >> 1;
    if (sorted[mid] == color) {
      return mid;
    } else if (sorted[mid] < color) {
      low = mid;
    } else {
      hi = mid;
    }
  }
  assert(0);
  return 0;
}

// Assembly:
xorl %eax, %eax
cmpl %esi, (%rdi)
je 0xe139f
xorl %ecx, %ecx
leal (%rdx,%rcx), %eax
sarl %eax
movslq %eax, %r9
movl %eax, %r8d
cmpl %esi, (%rdi,%r9,4)
jb 0xe139a
movl %ecx, %r8d
movl %eax, %edx
movl %r8d, %ecx
jne 0xe1384
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/palette.c
// Function: PrepareMapToPalette
void PrepareMapToPalette(const uint32_t palette[], uint32_t num_colors,
                         uint32_t sorted[], uint32_t idx_map[]) {
  uint32_t i;
  memcpy(sorted, palette, num_colors * sizeof(*sorted));
  qsort(sorted, num_colors, sizeof(*sorted), PaletteCompareColorsForQsort);
  for (i = 0; i < num_colors; ++i) {
    idx_map[SearchColorNoIdx(sorted, palette[i], num_colors)] = i;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %r12d
leaq (,%r12,4), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x562f0
leaq 0x3a(%rip), %rcx        # 0xe1409
pushq $0x4
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x587a0
xorl %r13d, %r13d
cmpq %r13, %r12
je 0xe13ff
movl (%r15,%r13,4), %esi
movq %r14, %rdi
movl %r12d, %edx
callq 0xe137c
cltq
movl %r13d, (%rbx,%rax,4)
incq %r13
jmp 0xe13e0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless_common.h
// Function: VP8LSubPixels
static WEBP_UBSAN_IGNORE_UNSIGNED_OVERFLOW WEBP_INLINE
uint32_t VP8LSubPixels(uint32_t a, uint32_t b) {
  const uint32_t alpha_and_green =
      0x00ff00ffu + (a & 0xff00ff00u) - (b & 0xff00ff00u);
  const uint32_t red_and_blue =
      0xff00ff00u + (a & 0x00ff00ffu) - (b & 0x00ff00ffu);
  return (alpha_and_green & 0xff00ff00u) | (red_and_blue & 0x00ff00ffu);
}

// Assembly:
movl %edi, %ecx
orl $0xff0000, %ecx         # imm = 0xFF0000
movl $0xff00ff00, %edx       # imm = 0xFF00FF00
movl %esi, %eax
andl %edx, %eax
subl %eax, %ecx
orl $0xff00, %edi           # imm = 0xFF00
movl $0xff00ff, %eax         # imm = 0xFF00FF
andl %eax, %esi
subl %esi, %edi
andl %edx, %ecx
andl %edi, %eax
orl %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/random_utils.c
// Function: VP8InitRandom
void VP8InitRandom(VP8Random* const rg, float dithering) {
  memcpy(rg->tab_, kRandomTable, sizeof(rg->tab_));
  rg->index1_ = 0;
  rg->index2_ = 31;
  rg->amp_ = (dithering < 0.0) ? 0
           : (dithering > 1.0) ? (1 << VP8_RANDOM_DITHER_FIX)
           : (uint32_t)((1 << VP8_RANDOM_DITHER_FIX) * dithering);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
addq $0x8, %rdi
leaq 0x3c19b(%rip), %rsi     # 0x11dd70
movl $0xdc, %edx
callq 0x562f0
movabsq $0x1f00000000, %rax     # imm = 0x1F00000000
movq %rax, (%rbx)
movss 0xc(%rsp), %xmm1
ucomiss 0x36fcf(%rip), %xmm1    # 0x118bc8
movss 0x3c15f(%rip), %xmm0    # 0x11dd60
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movl $0x100, %ecx            # imm = 0x100
cmovbel %eax, %ecx
xorl %eax, %eax
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
cmovbel %ecx, %eax
movl %eax, 0xe4(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/utils/thread_utils.c
// Function: WebPSetWorkerInterface
int WebPSetWorkerInterface(const WebPWorkerInterface* const winterface) {
  if (winterface == NULL ||
      winterface->Init == NULL || winterface->Reset == NULL ||
      winterface->Sync == NULL || winterface->Launch == NULL ||
      winterface->Execute == NULL || winterface->End == NULL) {
    return 0;
  }
  g_worker_interface = *winterface;
  return 1;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0xe1c7f
cmpq $0x0, (%rdi)
je 0xe1c7f
cmpq $0x0, 0x8(%rdi)
je 0xe1c7f
cmpq $0x0, 0x10(%rdi)
je 0xe1c7f
cmpq $0x0, 0x18(%rdi)
je 0xe1c7f
cmpq $0x0, 0x20(%rdi)
je 0xe1c7f
cmpq $0x0, 0x28(%rdi)
je 0xe1c7f
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups 0x20(%rdi), %xmm2
movups %xmm2, 0x82932(%rip)    # 0x1645a0
movups %xmm1, 0x8291b(%rip)    # 0x164590
movups %xmm0, 0x82904(%rip)    # 0x164580
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dec/alpha_dec.c
// Function: WebPDeallocateAlphaMemory
void WebPDeallocateAlphaMemory(VP8Decoder* const dec) {
  assert(dec != NULL);
  WebPSafeFree(dec->alpha_plane_mem_);
  dec->alpha_plane_mem_ = NULL;
  dec->alpha_plane_ = NULL;
  ALPHDelete(dec->alph_dec_);
  dec->alph_dec_ = NULL;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xe1da5
movq %rdi, %rbx
movq 0xbb0(%rdi), %rdi
callq 0x58480
xorps %xmm0, %xmm0
movups %xmm0, 0xbb0(%rbx)
movq 0xb90(%rbx), %rdi
callq 0xe1dc4
andq $0x0, 0xb90(%rbx)
popq %rbx
retq
leaq 0x37861(%rip), %rdi     # 0x11960d
leaq 0x3c152(%rip), %rsi     # 0x11df05
leaq 0x3c15f(%rip), %rcx     # 0x11df19
movl $0xa4, %edx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dec/alpha_dec.c
// Function: ALPHDelete
static void ALPHDelete(ALPHDecoder* const dec) {
  if (dec != NULL) {
    VP8LDelete(dec->vp8l_dec_);
    dec->vp8l_dec_ = NULL;
    WebPSafeFree(dec);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xe1de4
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xcc3d9
andq $0x0, 0x18(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x58480
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dec/tree_dec.c
// Function: VP8ParseIntraModeRow
int VP8ParseIntraModeRow(VP8BitReader* const br, VP8Decoder* const dec) {
  int mb_x;
  for (mb_x = 0; mb_x < dec->mb_w_; ++mb_x) {
    ParseIntraMode(br, dec, mb_x);
  }
  return !dec->br_.eof_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq 0xb00(%rsi), %r15
xorl %ecx, %ecx
leaq 0x3c9a6(%rip), %rbp     # 0x11ef20
movl $0xa2ea, %r12d          # imm = 0xA2EA
movq %rsi, (%rsp)
movq %r15, 0x18(%rsp)
movslq 0x198(%rsi), %rax
cmpq %rax, %rcx
jge 0xe27b6
leaq (,%rcx,4), %rbx
addq 0xaf8(%rsi), %rbx
movq %rcx, 0x10(%rsp)
imulq $0x320, %rcx, %r13      # imm = 0x320
addq 0xb60(%rsi), %r13
cmpl $0x0, 0x88(%rsi)
movq %rbx, 0x8(%rsp)
je 0xe25f3
movq %rsi, %rbx
movzbl 0x4a8(%rsi), %esi
movq %r14, %rdi
callq 0xe2973
testl %eax, %eax
je 0xe25f7
movzbl 0x4aa(%rbx), %esi
movq %r14, %rdi
callq 0xe2973
orl $0x2, %eax
jmp 0xe2606
xorl %eax, %eax
jmp 0xe260f
movzbl 0x4a9(%rbx), %esi
movq %r14, %rdi
callq 0xe2973
movq (%rsp), %rsi
movq 0x8(%rsp), %rbx
movb %al, 0x31e(%r13)
cmpl $0x0, 0xaf0(%rsi)
je 0xe2635
movzbl 0xaf4(%rsi), %esi
movq %r14, %rdi
callq 0xe2973
movb %al, 0x31d(%r13)
movq %r14, %rdi
movl $0x91, %esi
callq 0xe2973
movl %eax, %ecx
xorb $0x1, %cl
movb %cl, 0x300(%r13)
testl %eax, %eax
je 0xe2682
movq %r14, %rdi
movl $0x9c, %esi
callq 0xe2973
movq %r14, %rdi
testl %eax, %eax
je 0xe273a
movl $0x80, %esi
callq 0xe2973
testl %eax, %eax
sete %al
addb %al, %al
incb %al
jmp 0xe274b
leaq 0x301(%r13), %rax
xorl %ecx, %ecx
movq %r13, 0x20(%rsp)
cmpq $0x4, %rcx
je 0xe2760
movq %rax, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movzbl (%r15,%rcx), %r13d
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0xe270f
movzbl (%rbx,%r15), %eax
movl %r13d, %ecx
imulq $0x5a, %rax, %rax
leaq 0x3c4cb(%rip), %rdx     # 0x11eb90
addq %rdx, %rax
leaq (%rcx,%rcx,8), %rcx
leaq (%rax,%rcx), %rbx
movzbl (%rax,%rcx), %esi
movq %r14, %rdi
callq 0xe2973
movl %eax, %ecx
movsbl (%rcx,%rbp), %r13d
btq %rax, %r12
jae 0xe26fe
movl %r13d, %eax
movzbl (%rbx,%rax), %esi
movq %r14, %rdi
callq 0xe2973
leal (%rax,%r13,2), %eax
jmp 0xe26dc
negl %r13d
movq 0x8(%rsp), %rbx
movb %r13b, (%rbx,%r15)
incq %r15
jmp 0xe26ac
movl (%rbx), %eax
movq 0x30(%rsp), %rcx
movl %eax, (%rcx)
movq %rcx, %rax
addq $0x4, %rax
movq 0x18(%rsp), %r15
movq 0x28(%rsp), %rcx
movb %r13b, (%r15,%rcx)
incq %rcx
movq 0x20(%rsp), %r13
jmp 0xe2690
movl $0xa3, %esi
callq 0xe2973
testl %eax, %eax
setne %al
addb %al, %al
movb %al, 0x301(%r13)
movzbl %al, %eax
imull $0x1010101, %eax, %eax  # imm = 0x1010101
movl %eax, (%rbx)
movl %eax, (%r15)
movq %r14, %rdi
movl $0x8e, %esi
callq 0xe2973
testl %eax, %eax
je 0xe2798
movq %r14, %rdi
pushq $0x72
popq %rsi
callq 0xe2973
testl %eax, %eax
je 0xe279c
movq %r14, %rdi
movl $0xb7, %esi
callq 0xe2973
testl %eax, %eax
sete %al
addb %al, %al
incb %al
jmp 0xe279e
xorl %eax, %eax
jmp 0xe279e
movb $0x2, %al
movb %al, 0x311(%r13)
movq 0x10(%rsp), %rcx
incq %rcx
movq (%rsp), %rsi
jmp 0xe2589
xorl %eax, %eax
cmpl $0x0, 0x38(%rsi)
sete %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dec/tree_dec.c
// Function: VP8ParseProba
void VP8ParseProba(VP8BitReader* const br, VP8Decoder* const dec) {
  VP8Proba* const proba = &dec->proba_;
  int t, b, c, p;
  for (t = 0; t < NUM_TYPES; ++t) {
    for (b = 0; b < NUM_BANDS; ++b) {
      for (c = 0; c < NUM_CTX; ++c) {
        for (p = 0; p < NUM_PROBAS; ++p) {
          const int v =
              VP8GetBit(br, CoeffsUpdateProba[t][b][c][p], "global-header") ?
                        VP8GetValue(br, 8, "global-header") :
                        CoeffsProba0[t][b][c][p];
          proba->bands_[t][b].probas_[c][p] = v;
        }
      }
    }
    for (b = 0; b < 16 + 1; ++b) {
      proba->bands_ptr_[t][b] = &proba->bands_[t][kBands[b]];
    }
  }
  dec->use_skip_proba_ = VP8Get(br, "global-header");
  if (dec->use_skip_proba_) {
    dec->skip_p_ = VP8GetValue(br, 8, "global-header");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
leaq 0x4ab(%rsi), %rax
movq %rsi, 0x28(%rsp)
leaq 0x8d0(%rsi), %rcx
movq %rcx, 0x20(%rsp)
leaq 0x3bb32(%rip), %rcx     # 0x11e330
movq %rcx, 0x18(%rsp)
leaq 0x3bf46(%rip), %rcx     # 0x11e750
movq %rcx, 0x10(%rsp)
xorl %edi, %edi
pushq $0x8
popq %rbp
movq %rax, 0x30(%rsp)
movq %rax, 0x8(%rsp)
cmpq $0x4, %rdi
je 0xe2939
movq 0x8(%rsp), %rbx
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %r13
xorl %eax, %eax
movq %rdi, 0x38(%rsp)
cmpq $0x8, %rax
je 0xe28e0
movq %rbx, 0x50(%rsp)
movq %r15, 0x48(%rsp)
movq %r13, 0x40(%rsp)
xorl %ecx, %ecx
movq %rax, 0x58(%rsp)
cmpq $0x3, %rcx
je 0xe28b8
movq %rcx, 0x60(%rsp)
xorl %r12d, %r12d
cmpq $0xb, %r12
je 0xe289d
movzbl (%r13,%r12), %esi
movq %r14, %rdi
callq 0xe2973
testl %eax, %eax
je 0xe2890
movq %r14, %rdi
movl %ebp, %esi
callq 0xe06e5
jmp 0xe2894
movb (%r15,%r12), %al
movb %al, (%rbx,%r12)
incq %r12
jmp 0xe286c
movq 0x60(%rsp), %rcx
incq %rcx
addq $0xb, %r13
addq $0xb, %r15
addq $0xb, %rbx
movq 0x58(%rsp), %rax
jmp 0xe285e
incq %rax
movq 0x40(%rsp), %r13
addq $0x21, %r13
movq 0x48(%rsp), %r15
addq $0x21, %r15
movq 0x50(%rsp), %rbx
addq $0x21, %rbx
movq 0x38(%rsp), %rdi
jmp 0xe283e
imulq $0x108, %rdi, %rax      # imm = 0x108
addq 0x30(%rsp), %rax
xorl %ecx, %ecx
cmpq $0x11, %rcx
je 0xe2914
leaq 0x3c275(%rip), %rdx     # 0x11eb70
movzbl (%rcx,%rdx), %edx
imulq $0x21, %rdx, %rdx
addq %rax, %rdx
movq 0x20(%rsp), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
jmp 0xe28ee
incq %rdi
movl $0x108, %eax            # imm = 0x108
addq %rax, 0x18(%rsp)
addq %rax, 0x10(%rsp)
addq %rax, 0x8(%rsp)
addq $0x88, 0x20(%rsp)
jmp 0xe281e
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xe06e5
movq 0x28(%rsp), %rbx
movl %eax, 0xaf0(%rbx)
testl %eax, %eax
je 0xe2964
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0xe06e5
movb %al, 0xaf4(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/generot[P]VM-0/src/lang/util.cc
// Function: lexer::expect(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
bool lexer::expect(string tok, bool kill_prog) {
    if(tokens[ix] != tok) {
        if(kill_prog)
            ISSUE_ERROR("Expected \"%s\", got \"%s\" instead.", tok.c_str(), tokens[ix].c_str());

        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
shlq $0x5, %rdi
addq 0x20(%rbx), %rdi
callq 0x4f69
andb %al, %bpl
cmpb $0x1, %bpl
je 0x47a9
xorb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
movq 0x1b808(%rip), %rax     # 0x1ffb8
movq (%rax), %rdi
movq (%r14), %rdx
movq 0x20(%rbx), %rax
movq 0x40(%rbx), %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rcx
leaq 0xf92b(%rip), %rsi      # 0x140f8
xorl %eax, %eax
callq 0x4430
pushq $-0x1
popq %rdi
callq 0x4360
// File: /workspace/github_c_makefile_star2_O2/generot[P]VM-0/src/lang/util.cc
// Function: lexer::file_path[abi:cxx11]()
string lexer::file_path(void) { 
    int i;

    for(i = (int)filepath.length() - 1; i > 0 && 
        (filepath[i] != '/' && filepath[i] != '\\'); i--);

    return string(filepath.substr(0, i)) + (i != 0 ? "/" : "");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movq (%rsi), %rdx
leal -0x1(%rax), %edi
movslq %edi, %r8
movq %rdi, %r15
movq %r8, %rcx
cmpl $0x2, %eax
jl 0x483c
movzbl (%rdx,%r15), %r9d
cmpl $0x5c, %r9d
je 0x483c
decl %eax
leaq -0x1(%r15), %rdi
leaq -0x1(%rcx), %r8
cmpl $0x2f, %r9d
jne 0x4816
movq %rsp, %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x42f0
testq %r15, %r15
leaq 0xf9aa(%rip), %rax      # 0x141fd
leaq 0xf8c4(%rip), %rdx      # 0x1411e
cmoveq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f80
movq %rsp, %rdi
callq 0x4130
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x44e0
nop
// File: /workspace/github_c_makefile_star2_O2/generot[P]VM-0/src/lang/util.cc
// Function: match_comp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
opcode match_comp(string strrep) {
    string comps[] = { ">", "<", ">=", "<=", "==", "!=" };

    for(int i = 0; i < 6; i++) {
        if(strrep == comps[i])
            return opcode(OPC_GT + i);
    }

    return OPC_INVALID;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r15
leaq 0xf74b(%rip), %rsi      # 0x14125
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x4fa0
leaq 0x30(%rsp), %r14
leaq 0xf72f(%rip), %rsi      # 0x14127
leaq 0xe(%rsp), %rdx
movq %r14, %rdi
callq 0x4fa0
leaq 0x50(%rsp), %r14
leaq 0xf718(%rip), %rsi      # 0x14129
leaq 0xd(%rsp), %rdx
movq %r14, %rdi
callq 0x4fa0
leaq 0x70(%rsp), %r14
leaq 0xf702(%rip), %rsi      # 0x1412c
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0x4fa0
leaq 0x90(%rsp), %r14
leaq 0xf6e9(%rip), %rsi      # 0x1412f
leaq 0xb(%rsp), %rdx
movq %r14, %rdi
callq 0x4fa0
leaq 0xb0(%rsp), %r14
leaq 0xf6d0(%rip), %rsi      # 0x14132
leaq 0xa(%rsp), %rdx
movq %r14, %rdi
callq 0x4fa0
pushq $-0x6
popq %r14
pushq $0x26
popq %rbp
testq %r14, %r14
je 0x4a9a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4fe5
testb %al, %al
jne 0x4a93
incq %r14
addq $0x20, %rbx
jmp 0x4a76
addl $0x20, %r14d
movl %r14d, %ebp
movl $0xa0, %ebx
leaq (%rsp,%rbx), %rdi
addq $0x10, %rdi
callq 0x4130
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0x4a9f
movl %ebp, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4ace
jmp 0x4ace
jmp 0x4ace
jmp 0x4ace
movq %rax, %r15
addq $-0x20, %r14
movq %r14, %rdi
callq 0x4130
cmpq %rbx, %r14
jne 0x4ad1
movq %r15, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O2/generot[P]VM-0/src/lang/util.cc
// Function: dump_program(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<_Instruction, std::allocator<_Instruction>>, long long)
void dump_program(string filename, vector<instr> prog, size_s entry_addr) {
    ofstream outf = ofstream(filename.c_str(), ios::out | ios::binary);

    bcode_header header;

    header.program_size = prog.size();
    header.stack_size_spec = bcode_header::STACK_SIZE_DEFAULT;
    header.entry_point_addr = (size_t)entry_addr;

    header.code_seg_sz = header.data_seg_sz = 0;

    outf.write((const char*)&header, sizeof(bcode_header));
    outf.write((const char*)prog.data(), prog.size() * sizeof(instr));

    outf.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdi), %rsi
leaq 0x30(%rsp), %r15
pushq $0x14
popq %rdx
movq %r15, %rdi
callq 0x4310
movq 0x8(%rbx), %rax
subq (%rbx), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x1, 0x10(%rsi)
movq %r14, 0x8(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsi)
pushq $0x28
popq %rdx
movq %r15, %rdi
callq 0x43d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
subq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0x43d0
leaq 0x30(%rsp), %rdi
callq 0x4420
leaq 0x30(%rsp), %rdi
callq 0x4450
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4450
movq %rbx, %rdi
callq 0x44e0
// File: /workspace/github_c_makefile_star2_O2/generot[P]VM-0/src/lang/vc.cc
// Function: program(lexer&)
void program(lexer& lx) {
    while(!lx.eof()) {
        if(!(EXPECT("var") || EXPECT("proc") || EXPECT("include")))
            ISSUE_ERROR("Expected top-level declaration, got \"%s\" instead.",
                lx.accept().c_str());

        decl(lx);
        include(lx);
        procedure(lx);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x68(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x48(%rsp), %rbp
leaq 0x28(%rsp), %r13
movq %rbx, %rdi
callq 0x47dc
testb %al, %al
jne 0x117e8
movq %r15, %rdi
leaq 0x3887(%rip), %rsi      # 0x14fc1
movq %r12, %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x477c
testb %al, %al
jne 0x11780
movq %rbp, %rdi
leaq 0x3868(%rip), %rsi      # 0x14fc5
leaq 0x7(%rsp), %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x477c
testb %al, %al
je 0x1178a
movq %rbp, %rdi
callq 0x4130
movq %r15, %rdi
callq 0x4130
jmp 0x117cb
movq %r13, %rdi
leaq 0x3836(%rip), %rsi      # 0x14fca
leaq 0x6(%rsp), %rdx
callq 0x4fa0
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x477c
movl %eax, %r14d
movq %r13, %rdi
callq 0x4130
movq %rbp, %rdi
callq 0x4130
movq %r15, %rdi
callq 0x4130
testb %r14b, %r14b
je 0x117fa
movq %rbx, %rdi
callq 0x1186f
movq %rbx, %rdi
callq 0x11a6c
movq %rbx, %rdi
callq 0x11bb3
jmp 0x11720
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xe7b7(%rip), %rax      # 0x1ffb8
movq (%rax), %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4892
movq (%r15), %rdx
leaq 0x37b4(%rip), %rsi      # 0x14fd2
movq %r14, %rdi
xorl %eax, %eax
callq 0x4430
movq %r15, %rdi
callq 0x4130
pushq $-0x1
popq %rdi
callq 0x4360
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4130
jmp 0x1184e
jmp 0x1184b
jmp 0x1185a
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4130
jmp 0x1185d
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x4130
movq %rbx, %rdi
callq 0x44e0