LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless_sse2.c
// Function: AddGreenToBlueAndRed_SSE2
static void AddGreenToBlueAndRed_SSE2(const uint32_t* const src, int num_pixels,
                                      uint32_t* dst) {
  int i;
  for (i = 0; i + 4 <= num_pixels; i += 4) {
    const __m128i in = _mm_loadu_si128((const __m128i*)&src[i]); // argb
    const __m128i A = _mm_srli_epi16(in, 8);     // 0 a 0 g
    const __m128i B = _mm_shufflelo_epi16(A, _MM_SHUFFLE(2, 2, 0, 0));
    const __m128i C = _mm_shufflehi_epi16(B, _MM_SHUFFLE(2, 2, 0, 0));  // 0g0g
    const __m128i out = _mm_add_epi8(in, C);
    _mm_storeu_si128((__m128i*)&dst[i], out);
  }
  // fallthrough and finish off with plain-C
  if (i != num_pixels) {
    VP8LAddGreenToBlueAndRed_C(src + i, num_pixels - i, dst + i);
  }
}

// Assembly:
xorl %eax, %eax
cmpl $0x4, %esi
jl 0xe6eee
movl %esi, %ecx
xorl %eax, %eax
movq %rax, %r8
movdqu (%rdi,%rax,4), %xmm0
pshuflw $0xa0, %xmm0, %xmm1     # xmm1 = xmm0[0,0,2,2,4,5,6,7]
pshufhw $0xa0, %xmm1, %xmm1     # xmm1 = xmm1[0,1,2,3,4,4,6,6]
psrlw $0x8, %xmm1
paddb %xmm0, %xmm1
movdqu %xmm1, (%rdx,%rax,4)
addq $0x4, %rax
addq $0x8, %r8
cmpq %rcx, %r8
jbe 0xe6ec1
subl %eax, %esi
jne 0xe6ef3
retq
movl %eax, %eax
leaq (%rdi,%rax,4), %rdi
leaq (%rdx,%rax,4), %rdx
jmp 0xda249
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless_sse2.c
// Function: TransformColorInverse_SSE2
static void TransformColorInverse_SSE2(const VP8LMultipliers* const m,
                                       const uint32_t* const src,
                                       int num_pixels, uint32_t* dst) {
// sign-extended multiplying constants, pre-shifted by 5.
#define CST(X)  (((int16_t)(m->X << 8)) >> 5)   // sign-extend
#define MK_CST_16(HI, LO) \
  _mm_set1_epi32((int)(((uint32_t)(HI) << 16) | ((LO) & 0xffff)))
  const __m128i mults_rb = MK_CST_16(CST(green_to_red_), CST(green_to_blue_));
  const __m128i mults_b2 = MK_CST_16(CST(red_to_blue_), 0);
#undef MK_CST_16
#undef CST
  const __m128i mask_ag = _mm_set1_epi32((int)0xff00ff00);  // alpha-green masks
  int i;
  for (i = 0; i + 4 <= num_pixels; i += 4) {
    const __m128i in = _mm_loadu_si128((const __m128i*)&src[i]); // argb
    const __m128i A = _mm_and_si128(in, mask_ag);     // a   0   g   0
    const __m128i B = _mm_shufflelo_epi16(A, _MM_SHUFFLE(2, 2, 0, 0));
    const __m128i C = _mm_shufflehi_epi16(B, _MM_SHUFFLE(2, 2, 0, 0));  // g0g0
    const __m128i D = _mm_mulhi_epi16(C, mults_rb);    // x dr  x db1
    const __m128i E = _mm_add_epi8(in, D);             // x r'  x   b'
    const __m128i F = _mm_slli_epi16(E, 8);            // r' 0   b' 0
    const __m128i G = _mm_mulhi_epi16(F, mults_b2);    // x db2  0  0
    const __m128i H = _mm_srli_epi32(G, 8);            // 0  x db2  0
    const __m128i I = _mm_add_epi8(H, F);              // r' x  b'' 0
    const __m128i J = _mm_srli_epi16(I, 8);            // 0  r'  0  b''
    const __m128i out = _mm_or_si128(J, A);
    _mm_storeu_si128((__m128i*)&dst[i], out);
  }
  // Fall-back to C-version for left-overs.
  if (i != num_pixels) {
    VP8LTransformColorInverse_C(m, src + i, num_pixels - i, dst + i);
  }
}

// Assembly:
xorl %r8d, %r8d
cmpl $0x4, %edx
jl 0xe6fa4
movsbl 0x2(%rdi), %eax
shll $0x3, %eax
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
pslld $0x10, %xmm0
movsbl (%rdi), %eax
shll $0x13, %eax
movsbl 0x1(%rdi), %r8d
andl $0x1fff, %r8d           # imm = 0x1FFF
leal (%rax,%r8,8), %eax
movd %eax, %xmm1
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
movl %edx, %eax
xorl %r8d, %r8d
movdqa 0x45f81(%rip), %xmm2    # 0x12ced0
movq %r8, %r9
movdqu (%rsi,%r8,4), %xmm3
movdqa %xmm3, %xmm4
pand %xmm2, %xmm4
pshuflw $0xa0, %xmm4, %xmm5     # xmm5 = xmm4[0,0,2,2,4,5,6,7]
pshufhw $0xa0, %xmm5, %xmm5     # xmm5 = xmm5[0,1,2,3,4,4,6,6]
pmulhw %xmm1, %xmm5
paddb %xmm3, %xmm5
psllw $0x8, %xmm5
movdqa %xmm5, %xmm3
pmulhw %xmm0, %xmm3
psrld $0x8, %xmm3
paddb %xmm5, %xmm3
psrlw $0x8, %xmm3
por %xmm4, %xmm3
movdqu %xmm3, (%rcx,%r8,4)
addq $0x4, %r8
addq $0x8, %r9
cmpq %rax, %r9
jbe 0xe6f4f
subl %r8d, %edx
jne 0xe6faa
retq
movl %r8d, %eax
leaq (%rsi,%rax,4), %rsi
leaq (%rcx,%rax,4), %rcx
jmp 0xda28f
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless_sse2.c
// Function: ConvertBGRAToBGR_SSE2
static void ConvertBGRAToBGR_SSE2(const uint32_t* src,
                                  int num_pixels, uint8_t* dst) {
  const __m128i mask_l = _mm_set_epi32(0, 0x00ffffff, 0, 0x00ffffff);
  const __m128i mask_h = _mm_set_epi32(0x00ffffff, 0, 0x00ffffff, 0);
  const __m128i* in = (const __m128i*)src;
  const uint8_t* const end = dst + num_pixels * 3;
  // the last storel_epi64 below writes 8 bytes starting at offset 18
  while (dst + 26 <= end) {
    const __m128i bgra0 = _mm_loadu_si128(in++);     // bgra0|bgra1|bgra2|bgra3
    const __m128i bgra4 = _mm_loadu_si128(in++);     // bgra4|bgra5|bgra6|bgra7
    const __m128i a0l = _mm_and_si128(bgra0, mask_l);   // bgr0|0|bgr0|0
    const __m128i a4l = _mm_and_si128(bgra4, mask_l);   // bgr0|0|bgr0|0
    const __m128i a0h = _mm_and_si128(bgra0, mask_h);   // 0|bgr0|0|bgr0
    const __m128i a4h = _mm_and_si128(bgra4, mask_h);   // 0|bgr0|0|bgr0
    const __m128i b0h = _mm_srli_epi64(a0h, 8);         // 000b|gr00|000b|gr00
    const __m128i b4h = _mm_srli_epi64(a4h, 8);         // 000b|gr00|000b|gr00
    const __m128i c0 = _mm_or_si128(a0l, b0h);          // rgbrgb00|rgbrgb00
    const __m128i c4 = _mm_or_si128(a4l, b4h);          // rgbrgb00|rgbrgb00
    const __m128i c2 = _mm_srli_si128(c0, 8);
    const __m128i c6 = _mm_srli_si128(c4, 8);
    _mm_storel_epi64((__m128i*)(dst +   0), c0);
    _mm_storel_epi64((__m128i*)(dst +   6), c2);
    _mm_storel_epi64((__m128i*)(dst +  12), c4);
    _mm_storel_epi64((__m128i*)(dst +  18), c6);
    dst += 24;
    num_pixels -= 8;
  }
  // left-overs
  if (num_pixels > 0) {
    VP8LConvertBGRAToBGR_C((const uint32_t*)in, num_pixels, dst);
  }
}

// Assembly:
cmpl $0x9, %esi
jl 0xe757f
leal (%rsi,%rsi,2), %eax
cltq
addq %rdx, %rax
movdqa 0x45a20(%rip), %xmm0    # 0x12cf30
movdqa 0x45a28(%rip), %xmm1    # 0x12cf40
movq %rdx, %rcx
movdqu (%rdi), %xmm2
movdqu 0x10(%rdi), %xmm3
addq $0x20, %rdi
movdqa %xmm2, %xmm4
pand %xmm0, %xmm4
movdqa %xmm3, %xmm5
pand %xmm0, %xmm5
psrlq $0x8, %xmm2
pand %xmm1, %xmm2
por %xmm4, %xmm2
psrlq $0x8, %xmm3
pand %xmm1, %xmm3
por %xmm5, %xmm3
movq %xmm2, (%rdx)
pshufd $0xee, %xmm2, %xmm2     # xmm2 = xmm2[2,3,2,3]
movq %xmm2, 0x6(%rdx)
movq %xmm3, 0xc(%rdx)
pshufd $0xee, %xmm3, %xmm2     # xmm2 = xmm3[2,3,2,3]
movq %xmm2, 0x12(%rdx)
addq $0x18, %rdx
addl $-0x8, %esi
addq $0x32, %rcx
cmpq %rax, %rcx
jbe 0xe7518
testl %esi, %esi
jle 0xe7588
jmp 0xda9b8
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/rescaler_sse2.c
// Function: WebPRescalerDspInitSSE2
WEBP_TSAN_IGNORE_FUNCTION void WebPRescalerDspInitSSE2(void) {
  WebPRescalerImportRowExpand = RescalerImportRowExpand_SSE2;
  WebPRescalerImportRowShrink = RescalerImportRowShrink_SSE2;
  WebPRescalerExportRowExpand = RescalerExportRowExpand_SSE2;
  WebPRescalerExportRowShrink = RescalerExportRowShrink_SSE2;
}

// Assembly:
leaq 0x3e(%rip), %rax        # 0xe75d1
leaq 0x9404e(%rip), %rcx     # 0x17b5e8
movq %rax, (%rcx)
leaq 0x2b5(%rip), %rax       # 0xe7859
leaq 0x94035(%rip), %rcx     # 0x17b5e0
movq %rax, (%rcx)
leaq 0x412(%rip), %rax       # 0xe79c7
leaq 0x94034(%rip), %rcx     # 0x17b5f0
movq %rax, (%rcx)
leaq 0x80c(%rip), %rax       # 0xe7dd2
leaq 0x9402b(%rip), %rcx     # 0x17b5f8
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/upsampling_sse2.c
// Function: WebPInitUpsamplersSSE2
WEBP_TSAN_IGNORE_FUNCTION void WebPInitUpsamplersSSE2(void) {
  WebPUpsamplers[MODE_RGBA] = UpsampleRgbaLinePair_SSE2;
  WebPUpsamplers[MODE_BGRA] = UpsampleBgraLinePair_SSE2;
  WebPUpsamplers[MODE_rgbA] = UpsampleRgbaLinePair_SSE2;
  WebPUpsamplers[MODE_bgrA] = UpsampleBgraLinePair_SSE2;
#if !defined(WEBP_REDUCE_CSP)
  WebPUpsamplers[MODE_RGB]  = UpsampleRgbLinePair_SSE2;
  WebPUpsamplers[MODE_BGR]  = UpsampleBgrLinePair_SSE2;
  WebPUpsamplers[MODE_ARGB] = UpsampleArgbLinePair_SSE2;
  WebPUpsamplers[MODE_Argb] = UpsampleArgbLinePair_SSE2;
  WebPUpsamplers[MODE_RGB_565] = UpsampleRgb565LinePair_SSE2;
  WebPUpsamplers[MODE_RGBA_4444] = UpsampleRgba4444LinePair_SSE2;
  WebPUpsamplers[MODE_rgbA_4444] = UpsampleRgba4444LinePair_SSE2;
#endif   // WEBP_REDUCE_CSP
}

// Assembly:
leaq 0x5d(%rip), %rax        # 0xe8168
leaq 0x934ee(%rip), %rcx     # 0x17b600
movq %rax, 0x8(%rcx)
leaq 0x961(%rip), %rdx       # 0xe8a7e
movq %rdx, 0x18(%rcx)
movq %rax, 0x38(%rcx)
movq %rdx, 0x40(%rcx)
leaq 0x1265(%rip), %rax      # 0xe9395
movq %rax, (%rcx)
leaq 0x1b6e(%rip), %rax      # 0xe9ca8
movq %rax, 0x10(%rcx)
leaq 0x2477(%rip), %rax      # 0xea5bc
movq %rax, 0x20(%rcx)
movq %rax, 0x48(%rcx)
leaq 0x2d7e(%rip), %rax      # 0xeaed2
movq %rax, 0x30(%rcx)
leaq 0x36ab(%rip), %rax      # 0xeb80a
movq %rax, 0x28(%rcx)
movq %rax, 0x50(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/upsampling_sse2.c
// Function: WebPInitYUV444ConvertersSSE2
WEBP_TSAN_IGNORE_FUNCTION void WebPInitYUV444ConvertersSSE2(void) {
  WebPYUV444Converters[MODE_RGBA]      = Yuv444ToRgba_SSE2;
  WebPYUV444Converters[MODE_BGRA]      = Yuv444ToBgra_SSE2;
  WebPYUV444Converters[MODE_rgbA]      = Yuv444ToRgba_SSE2;
  WebPYUV444Converters[MODE_bgrA]      = Yuv444ToBgra_SSE2;
#if !defined(WEBP_REDUCE_CSP)
  WebPYUV444Converters[MODE_RGB]       = Yuv444ToRgb_SSE2;
  WebPYUV444Converters[MODE_BGR]       = Yuv444ToBgr_SSE2;
  WebPYUV444Converters[MODE_ARGB]      = Yuv444ToArgb_SSE2;
  WebPYUV444Converters[MODE_RGBA_4444] = Yuv444ToRgba4444_SSE2;
  WebPYUV444Converters[MODE_RGB_565]   = Yuv444ToRgb565_SSE2;
  WebPYUV444Converters[MODE_Argb]      = Yuv444ToArgb_SSE2;
  WebPYUV444Converters[MODE_rgbA_4444] = Yuv444ToRgba4444_SSE2;
#endif   // WEBP_REDUCE_CSP
}

// Assembly:
leaq 0x5d(%rip), %rax        # 0xec185
leaq 0x8f541(%rip), %rcx     # 0x17b670
movq %rax, 0x8(%rcx)
leaq 0xef(%rip), %rdx        # 0xec229
movq %rdx, 0x18(%rcx)
movq %rax, 0x38(%rcx)
movq %rdx, 0x40(%rcx)
leaq 0x180(%rip), %rax       # 0xec2cd
movq %rax, (%rcx)
leaq 0x21a(%rip), %rax       # 0xec371
movq %rax, 0x10(%rcx)
leaq 0x2b3(%rip), %rax       # 0xec415
movq %rax, 0x20(%rcx)
leaq 0x34c(%rip), %rdx       # 0xec4b9
movq %rdx, 0x28(%rcx)
leaq 0x3e2(%rip), %rsi       # 0xec55a
movq %rsi, 0x30(%rcx)
movq %rax, 0x48(%rcx)
movq %rdx, 0x50(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv_sse2.c
// Function: VP8YuvToRgba32_SSE2
void VP8YuvToRgba32_SSE2(const uint8_t* y, const uint8_t* u, const uint8_t* v,
                         uint8_t* dst) {
  const __m128i kAlpha = _mm_set1_epi16(255);
  int n;
  for (n = 0; n < 32; n += 8, dst += 32) {
    __m128i R, G, B;
    YUV444ToRGB_SSE2(y + n, u + n, v + n, &R, &G, &B);
    PackAndStore4_SSE2(&R, &G, &B, &kAlpha, dst);
  }
}

// Assembly:
movq $-0x8, %rax
movdqa 0x410b5(%rip), %xmm0    # 0x12d6c0
movdqa 0x410bd(%rip), %xmm1    # 0x12d6d0
movdqa 0x410c5(%rip), %xmm2    # 0x12d6e0
movdqa 0x410cd(%rip), %xmm3    # 0x12d6f0
movdqa 0x410d5(%rip), %xmm4    # 0x12d700
movdqa 0x410dd(%rip), %xmm5    # 0x12d710
movdqa 0x410e5(%rip), %xmm6    # 0x12d720
movdqa 0x410ed(%rip), %xmm7    # 0x12d730
movdqa 0x40854(%rip), %xmm8    # 0x12cea0
movq 0x8(%rdi,%rax), %xmm9
pxor %xmm11, %xmm11
punpcklbw %xmm9, %xmm11   # xmm11 = xmm11[0],xmm9[0],xmm11[1],xmm9[1],xmm11[2],xmm9[2],xmm11[3],xmm9[3],xmm11[4],xmm9[4],xmm11[5],xmm9[5],xmm11[6],xmm9[6],xmm11[7],xmm9[7]
pmulhuw %xmm0, %xmm11
movq 0x8(%rsi,%rax), %xmm9
pxor %xmm10, %xmm10
punpcklbw %xmm9, %xmm10   # xmm10 = xmm10[0],xmm9[0],xmm10[1],xmm9[1],xmm10[2],xmm9[2],xmm10[3],xmm9[3],xmm10[4],xmm9[4],xmm10[5],xmm9[5],xmm10[6],xmm9[6],xmm10[7],xmm9[7]
movq 0x8(%rdx,%rax), %xmm9
pxor %xmm12, %xmm12
punpcklbw %xmm9, %xmm12   # xmm12 = xmm12[0],xmm9[0],xmm12[1],xmm9[1],xmm12[2],xmm9[2],xmm12[3],xmm9[3],xmm12[4],xmm9[4],xmm12[5],xmm9[5],xmm12[6],xmm9[6],xmm12[7],xmm9[7]
movdqa %xmm12, %xmm9
pmulhuw %xmm1, %xmm9
paddw %xmm11, %xmm9
paddw %xmm2, %xmm9
movdqa %xmm10, %xmm13
pmulhuw %xmm3, %xmm13
pmulhuw %xmm4, %xmm12
paddw %xmm13, %xmm12
pmulhuw %xmm6, %xmm10
paddusw %xmm11, %xmm10
psubw %xmm12, %xmm11
paddw %xmm5, %xmm11
psubusw %xmm7, %xmm10
psraw $0x6, %xmm9
psraw $0x6, %xmm11
packuswb %xmm8, %xmm11
psrlw $0x6, %xmm10
packuswb %xmm10, %xmm9
movdqa %xmm9, %xmm10
punpcklbw %xmm11, %xmm10  # xmm10 = xmm10[0],xmm11[0],xmm10[1],xmm11[1],xmm10[2],xmm11[2],xmm10[3],xmm11[3],xmm10[4],xmm11[4],xmm10[5],xmm11[5],xmm10[6],xmm11[6],xmm10[7],xmm11[7]
punpckhbw %xmm11, %xmm9   # xmm9 = xmm9[8],xmm11[8],xmm9[9],xmm11[9],xmm9[10],xmm11[10],xmm9[11],xmm11[11],xmm9[12],xmm11[12],xmm9[13],xmm11[13],xmm9[14],xmm11[14],xmm9[15],xmm11[15]
movdqa %xmm10, %xmm11
punpcklwd %xmm9, %xmm11   # xmm11 = xmm11[0],xmm9[0],xmm11[1],xmm9[1],xmm11[2],xmm9[2],xmm11[3],xmm9[3]
punpckhwd %xmm9, %xmm10   # xmm10 = xmm10[4],xmm9[4],xmm10[5],xmm9[5],xmm10[6],xmm9[6],xmm10[7],xmm9[7]
movdqu %xmm11, 0x20(%rcx,%rax,4)
movdqu %xmm10, 0x30(%rcx,%rax,4)
addq $0x8, %rax
cmpq $0x18, %rax
jb 0xec64c
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv_sse2.c
// Function: VP8YuvToBgra32_SSE2
void VP8YuvToBgra32_SSE2(const uint8_t* y, const uint8_t* u, const uint8_t* v,
                         uint8_t* dst) {
  const __m128i kAlpha = _mm_set1_epi16(255);
  int n;
  for (n = 0; n < 32; n += 8, dst += 32) {
    __m128i R, G, B;
    YUV444ToRGB_SSE2(y + n, u + n, v + n, &R, &G, &B);
    PackAndStore4_SSE2(&B, &G, &R, &kAlpha, dst);
  }
}

// Assembly:
movq $-0x8, %rax
movdqa 0x40f95(%rip), %xmm0    # 0x12d6c0
movdqa 0x40f9d(%rip), %xmm1    # 0x12d6d0
movdqa 0x40fa5(%rip), %xmm2    # 0x12d6e0
movdqa 0x40fad(%rip), %xmm3    # 0x12d6f0
movdqa 0x40fb5(%rip), %xmm4    # 0x12d700
movdqa 0x40fbd(%rip), %xmm5    # 0x12d710
movdqa 0x40fc5(%rip), %xmm6    # 0x12d720
movdqa 0x40fcd(%rip), %xmm7    # 0x12d730
movdqa 0x40734(%rip), %xmm8    # 0x12cea0
movq 0x8(%rdi,%rax), %xmm9
pxor %xmm11, %xmm11
punpcklbw %xmm9, %xmm11   # xmm11 = xmm11[0],xmm9[0],xmm11[1],xmm9[1],xmm11[2],xmm9[2],xmm11[3],xmm9[3],xmm11[4],xmm9[4],xmm11[5],xmm9[5],xmm11[6],xmm9[6],xmm11[7],xmm9[7]
pmulhuw %xmm0, %xmm11
movq 0x8(%rsi,%rax), %xmm10
pxor %xmm9, %xmm9
punpcklbw %xmm10, %xmm9   # xmm9 = xmm9[0],xmm10[0],xmm9[1],xmm10[1],xmm9[2],xmm10[2],xmm9[3],xmm10[3],xmm9[4],xmm10[4],xmm9[5],xmm10[5],xmm9[6],xmm10[6],xmm9[7],xmm10[7]
movq 0x8(%rdx,%rax), %xmm10
pxor %xmm12, %xmm12
punpcklbw %xmm10, %xmm12  # xmm12 = xmm12[0],xmm10[0],xmm12[1],xmm10[1],xmm12[2],xmm10[2],xmm12[3],xmm10[3],xmm12[4],xmm10[4],xmm12[5],xmm10[5],xmm12[6],xmm10[6],xmm12[7],xmm10[7]
movdqa %xmm12, %xmm10
pmulhuw %xmm1, %xmm10
paddw %xmm11, %xmm10
paddw %xmm2, %xmm10
movdqa %xmm9, %xmm13
pmulhuw %xmm3, %xmm13
pmulhuw %xmm4, %xmm12
paddw %xmm13, %xmm12
pmulhuw %xmm6, %xmm9
paddusw %xmm11, %xmm9
psubw %xmm12, %xmm11
paddw %xmm5, %xmm11
psubusw %xmm7, %xmm9
psraw $0x6, %xmm10
psraw $0x6, %xmm11
packuswb %xmm8, %xmm11
psrlw $0x6, %xmm9
packuswb %xmm10, %xmm9
movdqa %xmm9, %xmm10
punpcklbw %xmm11, %xmm10  # xmm10 = xmm10[0],xmm11[0],xmm10[1],xmm11[1],xmm10[2],xmm11[2],xmm10[3],xmm11[3],xmm10[4],xmm11[4],xmm10[5],xmm11[5],xmm10[6],xmm11[6],xmm10[7],xmm11[7]
punpckhbw %xmm11, %xmm9   # xmm9 = xmm9[8],xmm11[8],xmm9[9],xmm11[9],xmm9[10],xmm11[10],xmm9[11],xmm11[11],xmm9[12],xmm11[12],xmm9[13],xmm11[13],xmm9[14],xmm11[14],xmm9[15],xmm11[15]
movdqa %xmm10, %xmm11
punpcklwd %xmm9, %xmm11   # xmm11 = xmm11[0],xmm9[0],xmm11[1],xmm9[1],xmm11[2],xmm9[2],xmm11[3],xmm9[3]
punpckhwd %xmm9, %xmm10   # xmm10 = xmm10[4],xmm9[4],xmm10[5],xmm9[5],xmm10[6],xmm9[6],xmm10[7],xmm9[7]
movdqu %xmm11, 0x20(%rcx,%rax,4)
movdqu %xmm10, 0x30(%rcx,%rax,4)
addq $0x8, %rax
cmpq $0x18, %rax
jb 0xec76c
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv_sse2.c
// Function: VP8YuvToArgb32_SSE2
void VP8YuvToArgb32_SSE2(const uint8_t* y, const uint8_t* u, const uint8_t* v,
                         uint8_t* dst) {
  const __m128i kAlpha = _mm_set1_epi16(255);
  int n;
  for (n = 0; n < 32; n += 8, dst += 32) {
    __m128i R, G, B;
    YUV444ToRGB_SSE2(y + n, u + n, v + n, &R, &G, &B);
    PackAndStore4_SSE2(&kAlpha, &R, &G, &B, dst);
  }
}

// Assembly:
movq $-0x8, %rax
movdqa 0x40e75(%rip), %xmm0    # 0x12d6c0
movdqa 0x40e7d(%rip), %xmm1    # 0x12d6d0
movdqa 0x40e85(%rip), %xmm2    # 0x12d6e0
movdqa 0x40e8d(%rip), %xmm3    # 0x12d6f0
movdqa 0x40e95(%rip), %xmm4    # 0x12d700
movdqa 0x40e9d(%rip), %xmm5    # 0x12d710
movdqa 0x40ea5(%rip), %xmm6    # 0x12d720
movdqa 0x40ead(%rip), %xmm7    # 0x12d730
movdqa 0x40614(%rip), %xmm8    # 0x12cea0
movq 0x8(%rdi,%rax), %xmm9
pxor %xmm11, %xmm11
punpcklbw %xmm9, %xmm11   # xmm11 = xmm11[0],xmm9[0],xmm11[1],xmm9[1],xmm11[2],xmm9[2],xmm11[3],xmm9[3],xmm11[4],xmm9[4],xmm11[5],xmm9[5],xmm11[6],xmm9[6],xmm11[7],xmm9[7]
pmulhuw %xmm0, %xmm11
movq 0x8(%rsi,%rax), %xmm10
pxor %xmm9, %xmm9
punpcklbw %xmm10, %xmm9   # xmm9 = xmm9[0],xmm10[0],xmm9[1],xmm10[1],xmm9[2],xmm10[2],xmm9[3],xmm10[3],xmm9[4],xmm10[4],xmm9[5],xmm10[5],xmm9[6],xmm10[6],xmm9[7],xmm10[7]
movq 0x8(%rdx,%rax), %xmm10
pxor %xmm12, %xmm12
punpcklbw %xmm10, %xmm12  # xmm12 = xmm12[0],xmm10[0],xmm12[1],xmm10[1],xmm12[2],xmm10[2],xmm12[3],xmm10[3],xmm12[4],xmm10[4],xmm12[5],xmm10[5],xmm12[6],xmm10[6],xmm12[7],xmm10[7]
movdqa %xmm12, %xmm10
pmulhuw %xmm1, %xmm10
paddw %xmm11, %xmm10
paddw %xmm2, %xmm10
movdqa %xmm9, %xmm13
pmulhuw %xmm3, %xmm13
pmulhuw %xmm4, %xmm12
paddw %xmm13, %xmm12
pmulhuw %xmm6, %xmm9
paddusw %xmm11, %xmm9
psubw %xmm12, %xmm11
paddw %xmm5, %xmm11
psubusw %xmm7, %xmm9
psraw $0x6, %xmm10
psraw $0x6, %xmm11
movdqa %xmm8, %xmm12
packuswb %xmm11, %xmm12
psrlw $0x6, %xmm9
packuswb %xmm9, %xmm10
movdqa %xmm12, %xmm9
punpcklbw %xmm10, %xmm9   # xmm9 = xmm9[0],xmm10[0],xmm9[1],xmm10[1],xmm9[2],xmm10[2],xmm9[3],xmm10[3],xmm9[4],xmm10[4],xmm9[5],xmm10[5],xmm9[6],xmm10[6],xmm9[7],xmm10[7]
punpckhbw %xmm10, %xmm12  # xmm12 = xmm12[8],xmm10[8],xmm12[9],xmm10[9],xmm12[10],xmm10[10],xmm12[11],xmm10[11],xmm12[12],xmm10[12],xmm12[13],xmm10[13],xmm12[14],xmm10[14],xmm12[15],xmm10[15]
movdqa %xmm9, %xmm10
punpcklwd %xmm12, %xmm10  # xmm10 = xmm10[0],xmm12[0],xmm10[1],xmm12[1],xmm10[2],xmm12[2],xmm10[3],xmm12[3]
punpckhwd %xmm12, %xmm9   # xmm9 = xmm9[4],xmm12[4],xmm9[5],xmm12[5],xmm9[6],xmm12[6],xmm9[7],xmm12[7]
movdqu %xmm10, 0x20(%rcx,%rax,4)
movdqu %xmm9, 0x30(%rcx,%rax,4)
addq $0x8, %rax
cmpq $0x18, %rax
jb 0xec88c
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv_sse2.c
// Function: VP8YuvToRgba444432_SSE2
void VP8YuvToRgba444432_SSE2(const uint8_t* y, const uint8_t* u,
                             const uint8_t* v, uint8_t* dst) {
  const __m128i kAlpha = _mm_set1_epi16(255);
  int n;
  for (n = 0; n < 32; n += 8, dst += 16) {
    __m128i R, G, B;
    YUV444ToRGB_SSE2(y + n, u + n, v + n, &R, &G, &B);
    PackAndStore4444_SSE2(&R, &G, &B, &kAlpha, dst);
  }
}

// Assembly:
movq $-0x8, %rax
movdqa 0x40d50(%rip), %xmm0    # 0x12d6c0
movdqa 0x40d58(%rip), %xmm1    # 0x12d6d0
movdqa 0x40d60(%rip), %xmm2    # 0x12d6e0
movdqa 0x40d68(%rip), %xmm3    # 0x12d6f0
movdqa 0x40d70(%rip), %xmm4    # 0x12d700
movdqa 0x40d78(%rip), %xmm5    # 0x12d710
movdqa 0x40d80(%rip), %xmm6    # 0x12d720
movdqa 0x40d88(%rip), %xmm7    # 0x12d730
movdqa 0x404ef(%rip), %xmm8    # 0x12cea0
movdqa 0x40526(%rip), %xmm9    # 0x12cee0
movdqa 0x4052d(%rip), %xmm10   # 0x12cef0
movq 0x8(%rdi,%rax), %xmm11
pxor %xmm13, %xmm13
punpcklbw %xmm11, %xmm13  # xmm13 = xmm13[0],xmm11[0],xmm13[1],xmm11[1],xmm13[2],xmm11[2],xmm13[3],xmm11[3],xmm13[4],xmm11[4],xmm13[5],xmm11[5],xmm13[6],xmm11[6],xmm13[7],xmm11[7]
pmulhuw %xmm0, %xmm13
movq 0x8(%rsi,%rax), %xmm11
pxor %xmm12, %xmm12
punpcklbw %xmm11, %xmm12  # xmm12 = xmm12[0],xmm11[0],xmm12[1],xmm11[1],xmm12[2],xmm11[2],xmm12[3],xmm11[3],xmm12[4],xmm11[4],xmm12[5],xmm11[5],xmm12[6],xmm11[6],xmm12[7],xmm11[7]
movq 0x8(%rdx,%rax), %xmm11
pxor %xmm14, %xmm14
punpcklbw %xmm11, %xmm14  # xmm14 = xmm14[0],xmm11[0],xmm14[1],xmm11[1],xmm14[2],xmm11[2],xmm14[3],xmm11[3],xmm14[4],xmm11[4],xmm14[5],xmm11[5],xmm14[6],xmm11[6],xmm14[7],xmm11[7]
movdqa %xmm14, %xmm11
pmulhuw %xmm1, %xmm11
paddw %xmm13, %xmm11
paddw %xmm2, %xmm11
movdqa %xmm12, %xmm15
pmulhuw %xmm3, %xmm15
pmulhuw %xmm4, %xmm14
paddw %xmm15, %xmm14
pmulhuw %xmm6, %xmm12
paddusw %xmm13, %xmm12
psubw %xmm14, %xmm13
paddw %xmm5, %xmm13
psubusw %xmm7, %xmm12
psraw $0x6, %xmm11
psraw $0x6, %xmm13
packuswb %xmm13, %xmm11
psrlw $0x6, %xmm12
packuswb %xmm8, %xmm12
movdqa %xmm11, %xmm13
punpcklbw %xmm12, %xmm13  # xmm13 = xmm13[0],xmm12[0],xmm13[1],xmm12[1],xmm13[2],xmm12[2],xmm13[3],xmm12[3],xmm13[4],xmm12[4],xmm13[5],xmm12[5],xmm13[6],xmm12[6],xmm13[7],xmm12[7]
pand %xmm9, %xmm13
punpckhbw %xmm12, %xmm11  # xmm11 = xmm11[8],xmm12[8],xmm11[9],xmm12[9],xmm11[10],xmm12[10],xmm11[11],xmm12[11],xmm11[12],xmm12[12],xmm11[13],xmm12[13],xmm11[14],xmm12[14],xmm11[15],xmm12[15]
psrlw $0x4, %xmm11
pand %xmm10, %xmm11
por %xmm13, %xmm11
movdqu %xmm11, 0x10(%rcx,%rax,2)
addq $0x8, %rax
cmpq $0x18, %rax
jb 0xec9c3
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv_sse2.c
// Function: VP8YuvToRgb56532_SSE2
void VP8YuvToRgb56532_SSE2(const uint8_t* y, const uint8_t* u, const uint8_t* v,
                           uint8_t* dst) {
  int n;
  for (n = 0; n < 32; n += 8, dst += 16) {
    __m128i R, G, B;
    YUV444ToRGB_SSE2(y + n, u + n, v + n, &R, &G, &B);
    PackAndStore565_SSE2(&R, &G, &B, dst);
  }
}

// Assembly:
movq $-0x8, %rax
movdqa 0x40c2f(%rip), %xmm1    # 0x12d6d0
movdqa 0x40c37(%rip), %xmm2    # 0x12d6e0
movdqa 0x40c3f(%rip), %xmm3    # 0x12d6f0
movdqa 0x40c47(%rip), %xmm4    # 0x12d700
movdqa 0x40c4f(%rip), %xmm5    # 0x12d710
movdqa 0x40c57(%rip), %xmm6    # 0x12d720
movdqa 0x40c5f(%rip), %xmm7    # 0x12d730
movdqa 0x40426(%rip), %xmm8    # 0x12cf00
movdqa 0x40c5d(%rip), %xmm9    # 0x12d740
movdqa 0x40424(%rip), %xmm10   # 0x12cf10
movdqa 0x4042b(%rip), %xmm11   # 0x12cf20
movq 0x8(%rdi,%rax), %xmm12
pxor %xmm14, %xmm14
punpcklbw %xmm12, %xmm14  # xmm14 = xmm14[0],xmm12[0],xmm14[1],xmm12[1],xmm14[2],xmm12[2],xmm14[3],xmm12[3],xmm14[4],xmm12[4],xmm14[5],xmm12[5],xmm14[6],xmm12[6],xmm14[7],xmm12[7]
movq 0x8(%rsi,%rax), %xmm13
pxor %xmm12, %xmm12
punpcklbw %xmm13, %xmm12  # xmm12 = xmm12[0],xmm13[0],xmm12[1],xmm13[1],xmm12[2],xmm13[2],xmm12[3],xmm13[3],xmm12[4],xmm13[4],xmm12[5],xmm13[5],xmm12[6],xmm13[6],xmm12[7],xmm13[7]
movq 0x8(%rdx,%rax), %xmm13
pxor %xmm15, %xmm15
punpcklbw %xmm13, %xmm15  # xmm15 = xmm15[0],xmm13[0],xmm15[1],xmm13[1],xmm15[2],xmm13[2],xmm15[3],xmm13[3],xmm15[4],xmm13[4],xmm15[5],xmm13[5],xmm15[6],xmm13[6],xmm15[7],xmm13[7]
movdqa %xmm15, %xmm13
movdqa %xmm12, %xmm0
pmulhuw %xmm3, %xmm0
pmulhuw %xmm4, %xmm15
paddw %xmm0, %xmm15
pmulhuw 0x40b77(%rip), %xmm14   # 0x12d6c0
pmulhuw %xmm1, %xmm13
paddw %xmm14, %xmm13
paddw %xmm2, %xmm13
pmulhuw %xmm6, %xmm12
paddusw %xmm14, %xmm12
psubw %xmm15, %xmm14
paddw %xmm5, %xmm14
psraw $0x6, %xmm13
packuswb %xmm13, %xmm13
pand %xmm8, %xmm13
psraw $0x6, %xmm14
packuswb %xmm14, %xmm14
movdqa %xmm14, %xmm0
psrlw $0x5, %xmm0
pand %xmm10, %xmm0
por %xmm13, %xmm0
psubusw %xmm7, %xmm12
psrlw $0x6, %xmm12
packuswb %xmm12, %xmm12
psrlw $0x3, %xmm12
pand %xmm9, %xmm12
psllw $0x3, %xmm14
pand %xmm11, %xmm14
por %xmm12, %xmm14
punpcklbw %xmm14, %xmm0   # xmm0 = xmm0[0],xmm14[0],xmm0[1],xmm14[1],xmm0[2],xmm14[2],xmm0[3],xmm14[3],xmm0[4],xmm14[4],xmm0[5],xmm14[5],xmm0[6],xmm14[6],xmm0[7],xmm14[7]
movdqu %xmm0, 0x10(%rcx,%rax,2)
addq $0x8, %rax
cmpq $0x18, %rax
jb 0xecaf5
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv_sse2.c
// Function: WebPInitSamplersSSE2
WEBP_TSAN_IGNORE_FUNCTION void WebPInitSamplersSSE2(void) {
  WebPSamplers[MODE_RGB]  = YuvToRgbRow_SSE2;
  WebPSamplers[MODE_RGBA] = YuvToRgbaRow_SSE2;
  WebPSamplers[MODE_BGR]  = YuvToBgrRow_SSE2;
  WebPSamplers[MODE_BGRA] = YuvToBgraRow_SSE2;
  WebPSamplers[MODE_ARGB] = YuvToArgbRow_SSE2;
}

// Assembly:
leaq 0x37(%rip), %rax        # 0xed5ac
leaq 0x8e164(%rip), %rcx     # 0x17b6e0
movq %rax, (%rcx)
leaq 0x7a1(%rip), %rax       # 0xedd27
movq %rax, 0x8(%rcx)
leaq 0xa5e(%rip), %rax       # 0xedfef
movq %rax, 0x10(%rcx)
leaq 0x11ce(%rip), %rax      # 0xee76a
movq %rax, 0x18(%rcx)
leaq 0x148b(%rip), %rax      # 0xeea32
movq %rax, 0x20(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv_sse2.c
// Function: WebPInitConvertARGBToYUVSSE2
WEBP_TSAN_IGNORE_FUNCTION void WebPInitConvertARGBToYUVSSE2(void) {
  WebPConvertARGBToY = ConvertARGBToY_SSE2;
  WebPConvertARGBToUV = ConvertARGBToUV_SSE2;

  WebPConvertRGB24ToY = ConvertRGB24ToY_SSE2;
  WebPConvertBGR24ToY = ConvertBGR24ToY_SSE2;

  WebPConvertRGBA32ToUV = ConvertRGBA32ToUV_SSE2;
}

// Assembly:
leaq 0x4f(%rip), %rax        # 0xeed55
leaq 0x8ca53(%rip), %rcx     # 0x17b760
movq %rax, (%rcx)
leaq 0x20e(%rip), %rax       # 0xeef25
leaq 0x8ca4a(%rip), %rcx     # 0x17b768
movq %rax, (%rcx)
leaq 0x56d(%rip), %rax       # 0xef295
leaq 0x8ca19(%rip), %rcx     # 0x17b748
movq %rax, (%rcx)
leaq 0x826(%rip), %rax       # 0xef55f
leaq 0x8ca10(%rip), %rcx     # 0x17b750
movq %rax, (%rcx)
leaq 0xae3(%rip), %rax       # 0xef82d
leaq 0x8ca07(%rip), %rcx     # 0x17b758
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xefb30
testq %rsi, %rsi
je 0xefb4f
movq %rdx, %rax
shrq $0x1f, %rax
jne 0xefb6e
movabsq $-0x7ffffff02, %rax     # imm = 0xFFFFFFF8000000FE
movq %rax, 0x8(%rdi)
movq $0x0, (%rdi)
movl $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)
cmpq %rsi, %rax
jbe 0xefb2a
movq (%rsi), %rax
addq $0x7, %rsi
bswapq %rax
movq %rsi, 0x10(%rdi)
shrq $0x8, %rax
movq %rax, (%rdi)
movl $0x30, 0xc(%rdi)
popq %rax
retq
popq %rax
jmp 0xefba6
leaq 0x3dca9(%rip), %rdi     # 0x12d7e0
leaq 0x3dcad(%rip), %rsi     # 0x12d7eb
leaq 0x3dcc3(%rip), %rcx     # 0x12d808
movl $0x25, %edx
callq 0x55710
leaq 0x39eb7(%rip), %rdi     # 0x129a0d
leaq 0x3dc8e(%rip), %rsi     # 0x12d7eb
leaq 0x3dca4(%rip), %rcx     # 0x12d808
movl $0x26, %edx
callq 0x55710
leaq 0x3dcdc(%rip), %rdi     # 0x12d851
leaq 0x3dc6f(%rip), %rsi     # 0x12d7eb
leaq 0x3dc85(%rip), %rcx     # 0x12d808
movl $0x27, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/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 0xefba5
addq %rsi, %rax
movq %rax, 0x10(%rdi)
addq %rsi, 0x18(%rdi)
addq %rsi, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xefbf5
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xefbf5
cmpq 0x18(%rdi), %rax
jae 0xefbd7
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 0xefbe5
movl $0x0, 0xc(%rdi)
retq
shlq $0x8, (%rdi)
addl $0x8, 0xc(%rdi)
movl $0x1, 0x28(%rdi)
retq
pushq %rax
leaq 0x39ac3(%rip), %rdi     # 0x1296c0
leaq 0x3dbe7(%rip), %rsi     # 0x12d7eb
leaq 0x3dc58(%rip), %rcx     # 0x12d863
movl $0x59, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/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
testl %esi, %esi
jle 0xefcdd
movl %esi, %ebx
movq %rdi, %r14
movl 0x8(%rdi), %r15d
movl 0xc(%rdi), %ecx
incl %ebx
xorl %ebp, %ebp
testl %ecx, %ecx
jns 0xefc6f
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xefcec
cmpq 0x20(%r14), %rax
jae 0xefc63
movq (%rax), %rdx
addq $0x7, %rax
movq %rax, 0x10(%r14)
bswapq %rdx
shldq $0x38, %rdx, (%r14)
addl $0x38, %ecx
jmp 0xefc6f
movq %r14, %rdi
callq 0xefba6
movl 0xc(%r14), %ecx
movl %r15d, %esi
shrl %esi
andl $0xffffff, %esi         # imm = 0xFFFFFF
movq (%r14), %rdx
movl %ecx, %eax
movq %rdx, %rdi
shrq %cl, %rdi
cmpl %edi, %esi
jae 0xefc9f
movl %esi, %r8d
incq %r8
movl %eax, %ecx
shlq %cl, %r8
subl %esi, %r15d
subq %r8, %rdx
movq %rdx, (%r14)
jmp 0xefca3
leal 0x1(%rsi), %r15d
leal -0x2(%rbx), %edx
xorl %r8d, %r8d
cmpl %edi, %esi
setb %r8b
bsrl %r15d, %ecx
xorl $0x7, %ecx
shll %cl, %r15d
subl %ecx, %eax
movl %eax, 0xc(%r14)
decl %r15d
movl %r15d, 0x8(%r14)
movl %edx, %ecx
shll %cl, %r8d
orl %r8d, %ebp
decl %ebx
movl %eax, %ecx
cmpl $0x1, %ebx
ja 0xefc34
jmp 0xefcdf
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x399cd(%rip), %rdi     # 0x1296c0
leaq 0x399e5(%rip), %rsi     # 0x1296df
leaq 0x39a49(%rip), %rcx     # 0x12974a
movl $0x3b, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/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 0xefdac
testq %rsi, %rsi
je 0xefdcb
movq %rdx, %rax
shrq $0x3, %rax
cmpq $0x1fffffff, %rax       # imm = 0x1FFFFFFF
jae 0xefdea
movq %rdx, 0x10(%rdi)
xorl %r8d, %r8d
movq %r8, (%rdi)
movq %r8, 0x20(%rdi)
cmpq $0x8, %rdx
movl $0x8, %eax
cmovbq %rdx, %rax
testq %rdx, %rdx
je 0xefd9f
leaq (,%rax,8), %rdx
xorl %ecx, %ecx
movq %rsi, %r9
xorl %r8d, %r8d
movzbl (%r9), %r10d
shlq %cl, %r10
orq %r10, %r8
addq $0x8, %rcx
incq %r9
cmpq %rcx, %rdx
jne 0xefd89
movq %r8, (%rdi)
movq %rax, 0x18(%rdi)
movq %rsi, 0x8(%rdi)
popq %rax
retq
leaq 0x3da2d(%rip), %rdi     # 0x12d7e0
leaq 0x3da31(%rip), %rsi     # 0x12d7eb
leaq 0x3dace(%rip), %rcx     # 0x12d88f
movl $0x91, %edx
callq 0x55710
leaq 0x39c3b(%rip), %rdi     # 0x129a0d
leaq 0x3da12(%rip), %rsi     # 0x12d7eb
leaq 0x3daaf(%rip), %rcx     # 0x12d88f
movl $0x92, %edx
callq 0x55710
leaq 0x3dae9(%rip), %rdi     # 0x12d8da
leaq 0x3d9f3(%rip), %rsi     # 0x12d7eb
leaq 0x3da90(%rip), %rcx     # 0x12d88f
movl $0x93, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/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 %rax
testq %rdi, %rdi
je 0xefe54
testq %rsi, %rsi
je 0xefe73
movq %rdx, %rax
shrq $0x3, %rax
cmpq $0x1fffffff, %rax       # imm = 0x1FFFFFFF
jae 0xefe92
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq 0x18(%rdi), %rcx
movl $0x1, %eax
cmpq %rdx, %rcx
ja 0xefe4f
cmpl $0x0, 0x24(%rdi)
jne 0xefe4f
xorl %eax, %eax
cmpq %rdx, %rcx
jne 0xefe4f
xorl %eax, %eax
cmpl $0x41, 0x20(%rdi)
setge %al
movl %eax, 0x24(%rdi)
popq %rax
retq
leaq 0x3d985(%rip), %rdi     # 0x12d7e0
leaq 0x3d989(%rip), %rsi     # 0x12d7eb
leaq 0x3da86(%rip), %rcx     # 0x12d8ef
movl $0xa7, %edx
callq 0x55710
leaq 0x38938(%rip), %rdi     # 0x1287b2
leaq 0x3d96a(%rip), %rsi     # 0x12d7eb
leaq 0x3da67(%rip), %rcx     # 0x12d8ef
movl $0xa8, %edx
callq 0x55710
leaq 0x3daa6(%rip), %rdi     # 0x12d93f
leaq 0x3d94b(%rip), %rsi     # 0x12d7eb
leaq 0x3da48(%rip), %rcx     # 0x12d8ef
movl $0xa9, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/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 0xefef4
movq 0x18(%rdi), %rax
leaq 0x8(%rax), %rdx
cmpq 0x10(%rdi), %rdx
jae 0xefef2
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 0xeff14
pushq %rax
leaq 0x3da55(%rip), %rdi     # 0x12d951
leaq 0x3d8e8(%rip), %rsi     # 0x12d7eb
leaq 0x3da62(%rip), %rcx     # 0x12d96c
movl $0xc3, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movl 0x20(%rdi), %edx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
movb $0x1, %sil
cmpl $0x8, %edx
jl 0xeff6a
cmpq %rax, %rcx
jae 0xeff61
movq (%rdi), %rsi
movq 0x8(%rdi), %r8
movq %rsi, %r9
shrq $0x8, %r9
movq %r9, (%rdi)
movzbl (%r8,%rcx), %r8d
shldq $0x38, %rsi, %r8
movq %r8, (%rdi)
incq %rcx
movq %rcx, 0x18(%rdi)
leal -0x8(%rdx), %esi
movl %esi, 0x20(%rdi)
cmpl $0xf, %edx
movl %esi, %edx
jg 0xeff28
jmp 0xeff63
movl %edx, %esi
cmpl $0x41, %esi
setl %sil
cmpq %rax, %rcx
ja 0xeff8d
setne %al
cmpl $0x0, 0x24(%rdi)
jne 0xeff7d
orb %al, %sil
jne 0xeff8b
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x20(%rdi)
popq %rax
retq
leaq 0x39f9b(%rip), %rdi     # 0x129f2f
leaq 0x39fa9(%rip), %rsi     # 0x129f44
leaq 0x3a009(%rip), %rcx     # 0x129fab
movl $0xac, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/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 0xefff1
cmpl $0x18, %esi
ja 0xeffdd
cmpl $0x0, 0x24(%rdi)
jne 0xeffdd
movq (%rdi), %rbx
movl 0x20(%rdi), %ecx
shrq %cl, %rbx
movl %esi, %eax
leaq 0x3db12(%rip), %rdx     # 0x12dae0
andl (%rdx,%rax,4), %ebx
addl %esi, %ecx
movl %ecx, 0x20(%rdi)
callq 0xeff14
jmp 0xeffed
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x20(%rdi)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
leaq 0x3d9a3(%rip), %rdi     # 0x12d99b
leaq 0x3d7ec(%rip), %rsi     # 0x12d7eb
leaq 0x3d9a1(%rip), %rcx     # 0x12d9a7
movl $0xd2, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl $0x1, %eax
movl %ebx, %ecx
shll %cl, %eax
testq %rdi, %rdi
je 0xf0060
testl %ebx, %ebx
jle 0xf007f
movq %rdi, %r14
movslq %eax, %rdi
movl $0x4, %esi
callq 0x56580
movq %rax, (%r14)
testq %rax, %rax
je 0xf0056
movl $0x20, %eax
subl %ebx, %eax
movl %eax, 0x8(%r14)
movl %ebx, 0xc(%r14)
movl $0x1, %eax
jmp 0xf0058
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3dadd(%rip), %rdi     # 0x12db44
leaq 0x3daea(%rip), %rsi     # 0x12db58
leaq 0x3db01(%rip), %rcx     # 0x12db76
movl $0x19, %edx
callq 0x55710
leaq 0x3db23(%rip), %rdi     # 0x12dba9
leaq 0x3dacb(%rip), %rsi     # 0x12db58
leaq 0x3dae2(%rip), %rcx     # 0x12db76
movl $0x1a, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/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 0xf00e2
testq %rsi, %rsi
je 0xf0101
movl 0xc(%rdi), %ecx
cmpl 0xc(%rsi), %ecx
jne 0xf0120
movq (%rsi), %rax
movl $0x4, %edx
shlq %cl, %rdx
movq (%rdi), %rsi
movq %rax, %rdi
popq %rax
jmp 0x552d0
leaq 0x3dace(%rip), %rdi     # 0x12dbb7
leaq 0x3da68(%rip), %rsi     # 0x12db58
leaq 0x3dacc(%rip), %rcx     # 0x12dbc3
movl $0x2c, %edx
callq 0x55710
leaq 0x38c6a(%rip), %rdi     # 0x128d72
leaq 0x3da49(%rip), %rsi     # 0x12db58
leaq 0x3daad(%rip), %rcx     # 0x12dbc3
movl $0x2d, %edx
callq 0x55710
leaq 0x3dae8(%rip), %rdi     # 0x12dc0f
leaq 0x3da2a(%rip), %rsi     # 0x12db58
leaq 0x3da8e(%rip), %rcx     # 0x12dbc3
movl $0x2e, %edx
callq 0x55710
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x56b20
testq %rax, %rax
sete %cl
cmpl $0x10001, %ebx          # imm = 0x10001
setl %dl
orb %cl, %dl
je 0xf0166
popq %rbx
retq
leaq 0x3dac5(%rip), %rdi     # 0x12dc32
leaq 0x3dae3(%rip), %rsi     # 0x12dc57
leaq 0x3daf6(%rip), %rcx     # 0x12dc71
movl $0x1f, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/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)
movq $0x0, 0x10(%rsi)
movslq %edi, %rdi
movl $0x4, %esi
callq 0x56b20
movq %rax, (%rbx)
testq %rax, %rax
je 0xf095e
movq %rax, 0x8(%rbx)
movl %ebp, 0x18(%rbx)
movl $0x1, %eax
jmp 0xf0960
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf09b0
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x10(%r14), %rbx
callq 0x57290
xorl %eax, %eax
movq %rax, (%r14)
movq %rax, 0x10(%r14)
testq %rbx, %rbx
je 0xf09a9
movq (%rbx), %rdi
movq 0x10(%rbx), %r14
callq 0x57290
movq %rbx, %rdi
callq 0x57290
movq %r14, %rbx
testq %r14, %r14
jne 0xf098d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0xf09d7
xorl %ecx, %ecx
leal (%rdx,%rcx), %eax
sarl %eax
movslq %eax, %r9
movl %eax, %r8d
cmpl %esi, (%rdi,%r9,4)
jb 0xf09d2
movl %ecx, %r8d
movl %eax, %edx
movl %r8d, %ecx
jne 0xf09bc
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl %esi, %r12d
leaq (,%r12,4), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x552d0
leaq 0x56(%rip), %rcx        # 0xf0a5e
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x57590
testl %ebp, %ebp
je 0xf0a55
xorl %eax, %eax
movl (%r15,%rax,4), %ecx
cmpl %ecx, (%r14)
jne 0xf0a2b
xorl %esi, %esi
jmp 0xf0a4a
xorl %edx, %edx
movl %ebp, %edi
leal (%rdi,%rdx), %r8d
sarl %r8d
movslq %r8d, %rsi
cmpl %ecx, (%r14,%rsi,4)
jae 0xf0a45
movl %r8d, %edx
movl %edi, %r8d
movl %r8d, %edi
jne 0xf0a2f
movl %eax, (%rbx,%rsi,4)
incq %rax
cmpq %r12, %rax
jne 0xf0a1e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/utils/palette.c
// Function: PaletteCompareColorsForQsort
static int PaletteCompareColorsForQsort(const void* p1, const void* p2) {
  const uint32_t a = WebPMemToUint32((uint8_t*)p1);
  const uint32_t b = WebPMemToUint32((uint8_t*)p2);
  assert(a != b);
  return (a < b) ? -1 : 1;
}

// Assembly:
movl (%rdi), %ecx
movl (%rsi), %edx
cmpl %edx, %ecx
je 0xf0a70
xorl %eax, %eax
cmpl %edx, %ecx
sbbl %eax, %eax
orl $0x1, %eax
retq
pushq %rax
leaq 0x3d485(%rip), %rdi     # 0x12defd
leaq 0x3d3aa(%rip), %rsi     # 0x12de29
leaq 0x3d47e(%rip), %rcx     # 0x12df04
movl $0x20, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/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 0x3cd77(%rip), %rsi     # 0x12e040
movl $0xdc, %edx
callq 0x552d0
movabsq $0x1f00000000, %rax     # imm = 0x1F00000000
movq %rax, (%rbx)
movss 0xc(%rsp), %xmm1
ucomiss 0x37ba3(%rip), %xmm1    # 0x128e90
movss 0x3cd3b(%rip), %xmm0    # 0x12e030
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_O3/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 0xf1375
cmpq $0x0, (%rdi)
je 0xf1375
cmpq $0x0, 0x8(%rdi)
je 0xf1375
cmpq $0x0, 0x10(%rdi)
je 0xf1375
cmpq $0x0, 0x18(%rdi)
je 0xf1375
cmpq $0x0, 0x20(%rdi)
je 0xf1375
cmpq $0x0, 0x28(%rdi)
je 0xf1375
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups 0x20(%rdi), %xmm2
movups %xmm2, 0x7d07e(%rip)    # 0x16e3e0
movups %xmm1, 0x7d067(%rip)    # 0x16e3d0
movups %xmm0, 0x7d050(%rip)    # 0x16e3c0
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf14ac
movq %rdi, %rbx
movq 0xbb0(%rdi), %rdi
callq 0x57290
xorps %xmm0, %xmm0
movups %xmm0, 0xbb0(%rbx)
movq 0xb90(%rbx), %rdi
callq 0xf14cb
movq $0x0, 0xb90(%rbx)
popq %rbx
retq
leaq 0x3842a(%rip), %rdi     # 0x1298dd
leaq 0x3ccdf(%rip), %rsi     # 0x12e199
leaq 0x3ccec(%rip), %rcx     # 0x12e1ad
movl $0xa4, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/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 0xf14ee
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xd3fa5
movq $0x0, 0x18(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x57290
retq