LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/upsampling.c
// Function: WebPInitYUV444Converters
WEBP_DSP_INIT_FUNC(WebPInitYUV444Converters) {
  WebPYUV444Converters[MODE_RGBA]      = WebPYuv444ToRgba_C;
  WebPYUV444Converters[MODE_BGRA]      = WebPYuv444ToBgra_C;
  WebPYUV444Converters[MODE_RGB]       = WebPYuv444ToRgb_C;
  WebPYUV444Converters[MODE_BGR]       = WebPYuv444ToBgr_C;
  WebPYUV444Converters[MODE_ARGB]      = WebPYuv444ToArgb_C;
  WebPYUV444Converters[MODE_RGBA_4444] = WebPYuv444ToRgba4444_C;
  WebPYUV444Converters[MODE_RGB_565]   = WebPYuv444ToRgb565_C;
  WebPYUV444Converters[MODE_rgbA]      = WebPYuv444ToRgba_C;
  WebPYUV444Converters[MODE_bgrA]      = WebPYuv444ToBgra_C;
  WebPYUV444Converters[MODE_Argb]      = WebPYuv444ToArgb_C;
  WebPYUV444Converters[MODE_rgbA_4444] = WebPYuv444ToRgba4444_C;

  if (VP8GetCPUInfo != NULL) {
#if defined(WEBP_HAVE_SSE2)
    if (VP8GetCPUInfo(kSSE2)) {
      WebPInitYUV444ConvertersSSE2();
    }
#endif
#if defined(WEBP_HAVE_SSE41)
    if (VP8GetCPUInfo(kSSE4_1)) {
      WebPInitYUV444ConvertersSSE41();
    }
#endif
#if defined(WEBP_USE_MIPS_DSP_R2)
    if (VP8GetCPUInfo(kMIPSdspR2)) {
      WebPInitYUV444ConvertersMIPSdspR2();
    }
#endif
  }
}

// Assembly:
pushq %rbx
movq 0x91aa7(%rip), %rcx     # 0x16e3a0
movq 0x8ee58(%rip), %rbx     # 0x16b758
movq (%rbx), %rax
cmpq %rax, %rcx
je 0xdc9a6
leaq -0x734(%rip), %rcx      # 0xdc1df
movq %rcx, 0x9ed5e(%rip)     # 0x17b678
leaq -0x644(%rip), %rdx      # 0xdc2dd
movq %rdx, 0x9ed60(%rip)     # 0x17b688
leaq -0x552(%rip), %rsi      # 0xdc3dd
movq %rsi, 0x9ed3a(%rip)     # 0x17b670
leaq -0x464(%rip), %rsi      # 0xdc4d9
movq %rsi, 0x9ed3c(%rip)     # 0x17b680
leaq -0x374(%rip), %rsi      # 0xdc5d7
movq %rsi, 0x9ed3e(%rip)     # 0x17b690
leaq -0x284(%rip), %rdi      # 0xdc6d5
movq %rdi, 0x9ed38(%rip)     # 0x17b698
leaq -0x187(%rip), %r8       # 0xdc7e0
movq %r8, 0x9ed32(%rip)      # 0x17b6a0
movq %rcx, 0x9ed33(%rip)     # 0x17b6a8
movq %rdx, 0x9ed34(%rip)     # 0x17b6b0
movq %rsi, 0x9ed35(%rip)     # 0x17b6b8
movq %rdi, 0x9ed36(%rip)     # 0x17b6c0
testq %rax, %rax
je 0xdc99c
xorl %edi, %edi
callq *%rax
testl %eax, %eax
je 0xdc99c
callq 0xec121
movq (%rbx), %rax
movq %rax, 0x919fa(%rip)     # 0x16e3a0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv.c
// Function: WebPSamplerProcessPlane
void WebPSamplerProcessPlane(const uint8_t* y, int y_stride,
                             const uint8_t* u, const uint8_t* v, int uv_stride,
                             uint8_t* dst, int dst_stride,
                             int width, int height, WebPSamplerRowFunc func) {
  int j;
  for (j = 0; j < height; ++j) {
    func(y, u, v, dst, width);
    y += y_stride;
    if (j & 1) {
      u += uv_stride;
      v += uv_stride;
    }
    dst += dst_stride;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x60(%rsp), %eax
testl %eax, %eax
jle 0xe0603
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movslq %esi, %rax
movq %rax, 0x10(%rsp)
movslq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl 0x58(%rsp), %r8d
callq *0x68(%rsp)
addq 0x10(%rsp), %r12
movl %r13d, %eax
andl $0x1, %eax
negl %eax
andl %ebp, %eax
cltq
addq %rax, %r14
addq %rax, %r15
movl 0x60(%rsp), %eax
addq 0x8(%rsp), %rbx
incl %r13d
cmpl %r13d, %eax
jne 0xe05c6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv.c
// Function: WebPConvertRGBA32ToUV_C
void WebPConvertRGBA32ToUV_C(const uint16_t* rgb,
                             uint8_t* u, uint8_t* v, int width) {
  int i;
  for (i = 0; i < width; i += 1, rgb += 4) {
    const int r = rgb[0], g = rgb[1], b = rgb[2];
    u[i] = VP8RGBToU(r, g, b, YUV_HALF << 2);
    v[i] = VP8RGBToV(r, g, b, YUV_HALF << 2);
  }
}

// Assembly:
testl %ecx, %ecx
jle 0xe091b
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %eax
xorl %ecx, %ecx
movl $0x2020000, %r8d        # imm = 0x2020000
xorl %r9d, %r9d
movzwl (%rdi,%r9,8), %r11d
movzwl 0x2(%rdi,%r9,8), %ebx
movzwl 0x4(%rdi,%r9,8), %r10d
imull $0xffffda09, %r11d, %ebp # imm = 0xFFFFDA09
imull $0xffffb577, %ebx, %r15d # imm = 0xFFFFB577
addl %ebp, %r15d
imull $0x7080, %r10d, %r14d   # imm = 0x7080
addl %r8d, %r14d
addl %r15d, %r14d
sarl $0x12, %r14d
testl %r14d, %r14d
cmovlel %ecx, %r14d
movl $0xff, %ebp
cmpl %ebp, %r14d
jl 0xe08ce
movl $0xff, %r14d
movb %r14b, (%rsi,%r9)
imull $0x7080, %r11d, %r11d   # imm = 0x7080
imull $0xffffa1cc, %ebx, %ebx # imm = 0xFFFFA1CC
addl %r11d, %ebx
imull $0xffffedb4, %r10d, %r10d # imm = 0xFFFFEDB4
addl %r8d, %r10d
addl %ebx, %r10d
sarl $0x12, %r10d
testl %r10d, %r10d
cmovlel %ecx, %r10d
cmpl %ebp, %r10d
jl 0xe0905
movl $0xff, %r10d
movb %r10b, (%rdx,%r9)
incq %r9
cmpq %r9, %rax
jne 0xe0884
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv.c
// Function: WebPInitConvertARGBToYUV
WEBP_DSP_INIT_FUNC(WebPInitConvertARGBToYUV) {
  WebPConvertARGBToY = ConvertARGBToY_C;
  WebPConvertARGBToUV = WebPConvertARGBToUV_C;

  WebPConvertRGB24ToY = ConvertRGB24ToY_C;
  WebPConvertBGR24ToY = ConvertBGR24ToY_C;

  WebPConvertRGBA32ToUV = WebPConvertRGBA32ToUV_C;

  if (VP8GetCPUInfo != NULL) {
#if defined(WEBP_HAVE_SSE2)
    if (VP8GetCPUInfo(kSSE2)) {
      WebPInitConvertARGBToYUVSSE2();
    }
#endif  // WEBP_HAVE_SSE2
#if defined(WEBP_HAVE_SSE41)
    if (VP8GetCPUInfo(kSSE4_1)) {
      WebPInitConvertARGBToYUVSSE41();
    }
#endif  // WEBP_HAVE_SSE41
  }

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

  assert(WebPConvertARGBToY != NULL);
  assert(WebPConvertARGBToUV != NULL);
  assert(WebPConvertRGB24ToY != NULL);
  assert(WebPConvertBGR24ToY != NULL);
  assert(WebPConvertRGBA32ToUV != NULL);
}

// Assembly:
pushq %rbx
movq 0x8da94(%rip), %rcx     # 0x16e3b8
movq 0x8ae2d(%rip), %rbx     # 0x16b758
movq (%rbx), %rax
cmpq %rax, %rcx
je 0xe09cf
leaq 0x149c(%rip), %rcx      # 0xe1dda
movq %rcx, 0x9ae1b(%rip)     # 0x17b760
leaq -0x283(%rip), %rcx      # 0xe06c9
movq %rcx, 0x9ae15(%rip)     # 0x17b768
leaq 0x14db(%rip), %rcx      # 0xe1e35
movq %rcx, 0x9ade7(%rip)     # 0x17b748
leaq 0x1515(%rip), %rcx      # 0xe1e7d
movq %rcx, 0x9ade1(%rip)     # 0x17b750
leaq -0x10d(%rip), %rcx      # 0xe0869
movq %rcx, 0x9addb(%rip)     # 0x17b758
testq %rax, %rax
je 0xe098f
xorl %edi, %edi
callq *%rax
testl %eax, %eax
je 0xe098f
callq 0xeecff
cmpq $0x0, 0x9adc9(%rip)     # 0x17b760
je 0xe09d1
cmpq $0x0, 0x9adc7(%rip)     # 0x17b768
je 0xe09f0
cmpq $0x0, 0x9ad9d(%rip)     # 0x17b748
je 0xe0a0f
cmpq $0x0, 0x9ad9b(%rip)     # 0x17b750
je 0xe0a2e
cmpq $0x0, 0x9ad99(%rip)     # 0x17b758
je 0xe0a4d
movq (%rbx), %rax
movq %rax, 0x8d9e9(%rip)     # 0x16e3b8
popq %rbx
retq
leaq 0x4c157(%rip), %rdi     # 0x12cb2f
leaq 0x4c16b(%rip), %rsi     # 0x12cb4a
leaq 0x4c172(%rip), %rcx     # 0x12cb58
movl $0xf0, %edx
callq 0x55710
leaq 0x4c18a(%rip), %rdi     # 0x12cb81
leaq 0x4c14c(%rip), %rsi     # 0x12cb4a
leaq 0x4c153(%rip), %rcx     # 0x12cb58
movl $0xf1, %edx
callq 0x55710
leaq 0x4c187(%rip), %rdi     # 0x12cb9d
leaq 0x4c12d(%rip), %rsi     # 0x12cb4a
leaq 0x4c134(%rip), %rcx     # 0x12cb58
movl $0xf2, %edx
callq 0x55710
leaq 0x4c184(%rip), %rdi     # 0x12cbb9
leaq 0x4c10e(%rip), %rsi     # 0x12cb4a
leaq 0x4c115(%rip), %rcx     # 0x12cb58
movl $0xf3, %edx
callq 0x55710
leaq 0x4c181(%rip), %rdi     # 0x12cbd5
leaq 0x4c0ef(%rip), %rsi     # 0x12cb4a
leaq 0x4c0f6(%rip), %rcx     # 0x12cb58
movl $0xf4, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv.c
// Function: ConvertARGBToY_C
static void ConvertARGBToY_C(const uint32_t* argb, uint8_t* y, int width) {
  int i;
  for (i = 0; i < width; ++i) {
    const uint32_t p = argb[i];
    y[i] = VP8RGBToY((p >> 16) & 0xff, (p >> 8) & 0xff, (p >>  0) & 0xff,
                     YUV_HALF);
  }
}

// Assembly:
testl %edx, %edx
jle 0xe1e34
movl %edx, %eax
xorl %ecx, %ecx
movl $0xff, %edx
movl (%rdi,%rcx,4), %r8d
movl %r8d, %r9d
shrl $0x10, %r9d
andl %edx, %r9d
movl %r8d, %r10d
shrl $0x8, %r10d
andl %edx, %r10d
andl %edx, %r8d
imull $0x41c7, %r9d, %r9d     # imm = 0x41C7
imull $0x8123, %r10d, %r10d   # imm = 0x8123
imull $0x1914, %r8d, %r8d     # imm = 0x1914
addl %r9d, %r8d
addl %r10d, %r8d
addl $0x108000, %r8d         # imm = 0x108000
shrl $0x10, %r8d
movb %r8b, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0xe1de7
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing_sse2.c
// Function: WebPInitAlphaProcessingSSE2
WEBP_TSAN_IGNORE_FUNCTION void WebPInitAlphaProcessingSSE2(void) {
  WebPMultARGBRow = MultARGBRow_SSE2;
  WebPMultRow = MultRow_SSE2;
  WebPApplyAlphaMultiply = ApplyAlphaMultiply_SSE2;
  WebPDispatchAlpha = DispatchAlpha_SSE2;
  WebPDispatchAlphaToGreen = DispatchAlphaToGreen_SSE2;
  WebPExtractAlpha = ExtractAlpha_SSE2;
  WebPExtractGreen = ExtractGreen_SSE2;

  WebPHasAlpha8b = HasAlpha8b_SSE2;
  WebPHasAlpha32b = HasAlpha32b_SSE2;
  WebPAlphaReplace = AlphaReplace_SSE2;
}

// Assembly:
leaq 0xa4(%rip), %rax        # 0xe1f77
leaq 0x9931e(%rip), %rcx     # 0x17b1f8
movq %rax, (%rcx)
leaq 0x112(%rip), %rax       # 0xe1ff6
leaq 0x99315(%rip), %rcx     # 0x17b200
movq %rax, (%rcx)
leaq 0x17c(%rip), %rax       # 0xe2071
leaq 0x9930c(%rip), %rcx     # 0x17b208
movq %rax, (%rcx)
leaq 0x300(%rip), %rax       # 0xe2206
leaq 0x9930b(%rip), %rcx     # 0x17b218
movq %rax, (%rcx)
leaq 0x3ca(%rip), %rax       # 0xe22e1
leaq 0x99302(%rip), %rcx     # 0x17b220
movq %rax, (%rcx)
leaq 0x4cb(%rip), %rax       # 0xe23f3
leaq 0x992f9(%rip), %rcx     # 0x17b228
movq %rax, (%rcx)
leaq 0x577(%rip), %rax       # 0xe24b0
leaq 0x992f0(%rip), %rcx     # 0x17b230
movq %rax, (%rcx)
leaq 0x63a(%rip), %rax       # 0xe2584
leaq 0x992ef(%rip), %rcx     # 0x17b240
movq %rax, (%rcx)
leaq 0x670(%rip), %rax       # 0xe25cb
leaq 0x992e6(%rip), %rcx     # 0x17b248
movq %rax, (%rcx)
leaq 0x720(%rip), %rax       # 0xe268c
leaq 0x992dd(%rip), %rcx     # 0x17b250
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing_sse2.c
// Function: MultARGBRow_SSE2
static void MultARGBRow_SSE2(uint32_t* const ptr, int width, int inverse) {
  int x = 0;
  if (!inverse) {
    const int kSpan = 2;
    const __m128i zero = _mm_setzero_si128();
    const __m128i k128 = _mm_set1_epi16(128);
    const __m128i kMult = _mm_set1_epi16(0x0101);
    const __m128i kMask = _mm_set_epi16(0, 0xff, 0, 0, 0, 0xff, 0, 0);
    for (x = 0; x + kSpan <= width; x += kSpan) {
      // To compute 'result = (int)(a * x / 255. + .5)', we use:
      //   tmp = a * v + 128, result = (tmp * 0x0101u) >> 16
      const __m128i A0 = _mm_loadl_epi64((const __m128i*)&ptr[x]);
      const __m128i A1 = _mm_unpacklo_epi8(A0, zero);
      const __m128i A2 = _mm_or_si128(A1, kMask);
      const __m128i A3 = _mm_shufflelo_epi16(A2, _MM_SHUFFLE(2, 3, 3, 3));
      const __m128i A4 = _mm_shufflehi_epi16(A3, _MM_SHUFFLE(2, 3, 3, 3));
      // here, A4 = [ff a0 a0 a0][ff a1 a1 a1]
      const __m128i A5 = _mm_mullo_epi16(A4, A1);
      const __m128i A6 = _mm_add_epi16(A5, k128);
      const __m128i A7 = _mm_mulhi_epu16(A6, kMult);
      const __m128i A10 = _mm_packus_epi16(A7, zero);
      _mm_storel_epi64((__m128i*)&ptr[x], A10);
    }
  }
  width -= x;
  if (width > 0) WebPMultARGBRow_C(ptr + x, width, inverse);
}

// Assembly:
testl %edx, %edx
setne %al
cmpl $0x2, %esi
setl %r8b
xorl %ecx, %ecx
orb %al, %r8b
jne 0xe1fe6
movl %esi, %eax
xorl %ecx, %ecx
pxor %xmm0, %xmm0
movdqa 0x4ac66(%rip), %xmm1    # 0x12cc00
movdqa 0x4ac6e(%rip), %xmm2    # 0x12cc10
movdqa 0x4ac76(%rip), %xmm3    # 0x12cc20
movq %rcx, %r8
movq (%rdi,%rcx,4), %xmm4
punpcklbw %xmm0, %xmm4    # xmm4 = xmm4[0],xmm0[0],xmm4[1],xmm0[1],xmm4[2],xmm0[2],xmm4[3],xmm0[3],xmm4[4],xmm0[4],xmm4[5],xmm0[5],xmm4[6],xmm0[6],xmm4[7],xmm0[7]
pshuflw $0xbf, %xmm4, %xmm5     # xmm5 = xmm4[3,3,3,2,4,5,6,7]
pshufhw $0xbf, %xmm5, %xmm5     # xmm5 = xmm5[0,1,2,3,7,7,7,6]
por %xmm1, %xmm5
pmullw %xmm4, %xmm5
paddw %xmm2, %xmm5
pmulhuw %xmm3, %xmm5
packuswb %xmm5, %xmm5
movq %xmm5, (%rdi,%rcx,4)
addq $0x2, %rcx
addq $0x4, %r8
cmpq %rax, %r8
jbe 0xe1faa
subl %ecx, %esi
jle 0xe1ff5
movl %ecx, %eax
leaq (%rdi,%rax,4), %rdi
jmp 0xd6c10
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing_sse2.c
// Function: MultRow_SSE2
static void MultRow_SSE2(uint8_t* WEBP_RESTRICT const ptr,
                         const uint8_t* WEBP_RESTRICT const alpha,
                         int width, int inverse) {
  int x = 0;
  if (!inverse) {
    const __m128i zero = _mm_setzero_si128();
    const __m128i k128 = _mm_set1_epi16(128);
    const __m128i kMult = _mm_set1_epi16(0x0101);
    for (x = 0; x + 8 <= width; x += 8) {
      const __m128i v0 = _mm_loadl_epi64((__m128i*)&ptr[x]);
      const __m128i a0 = _mm_loadl_epi64((const __m128i*)&alpha[x]);
      const __m128i v1 = _mm_unpacklo_epi8(v0, zero);
      const __m128i a1 = _mm_unpacklo_epi8(a0, zero);
      const __m128i v2 = _mm_mullo_epi16(v1, a1);
      const __m128i v3 = _mm_add_epi16(v2, k128);
      const __m128i v4 = _mm_mulhi_epu16(v3, kMult);
      const __m128i v5 = _mm_packus_epi16(v4, zero);
      _mm_storel_epi64((__m128i*)&ptr[x], v5);
    }
  }
  width -= x;
  if (width > 0) WebPMultRow_C(ptr + x, alpha + x, width, inverse);
}

// Assembly:
testl %ecx, %ecx
setne %al
cmpl $0x8, %edx
setl %r9b
xorl %r8d, %r8d
orb %al, %r9b
jne 0xe205d
movl %edx, %eax
xorl %r8d, %r8d
pxor %xmm0, %xmm0
movdqa 0x4abf5(%rip), %xmm1    # 0x12cc10
movdqa 0x4abfd(%rip), %xmm2    # 0x12cc20
movq %r8, %r9
movq (%rdi,%r8), %xmm3
movq (%rsi,%r8), %xmm4
punpcklbw %xmm0, %xmm3    # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1],xmm3[2],xmm0[2],xmm3[3],xmm0[3],xmm3[4],xmm0[4],xmm3[5],xmm0[5],xmm3[6],xmm0[6],xmm3[7],xmm0[7]
punpcklbw %xmm0, %xmm4    # xmm4 = xmm4[0],xmm0[0],xmm4[1],xmm0[1],xmm4[2],xmm0[2],xmm4[3],xmm0[3],xmm4[4],xmm0[4],xmm4[5],xmm0[5],xmm4[6],xmm0[6],xmm4[7],xmm0[7]
pmullw %xmm3, %xmm4
paddw %xmm1, %xmm4
pmulhuw %xmm2, %xmm4
packuswb %xmm4, %xmm4
movq %xmm4, (%rdi,%r8)
addq $0x8, %r8
addq $0x10, %r9
cmpq %rax, %r9
jbe 0xe2023
subl %r8d, %edx
jle 0xe2070
movl %r8d, %eax
addq %rax, %rdi
addq %rax, %rsi
jmp 0xd6cc4
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing_sse2.c
// Function: ExtractAlpha_SSE2
static int ExtractAlpha_SSE2(const uint8_t* WEBP_RESTRICT argb, int argb_stride,
                             int width, int height,
                             uint8_t* WEBP_RESTRICT alpha, int alpha_stride) {
  // alpha_and stores an 'and' operation of all the alpha[] values. The final
  // value is not 0xff if any of the alpha[] is not equal to 0xff.
  uint32_t alpha_and = 0xff;
  int i, j;
  const __m128i a_mask = _mm_set1_epi32(0xff);  // to preserve alpha
  const __m128i all_0xff = _mm_set_epi32(0, 0, ~0, ~0);
  __m128i all_alphas = all_0xff;

  // We must be able to access 3 extra bytes after the last written byte
  // 'src[4 * width - 4]', because we don't know if alpha is the first or the
  // last byte of the quadruplet.
  const int limit = (width - 1) & ~7;

  for (j = 0; j < height; ++j) {
    const __m128i* src = (const __m128i*)argb;
    for (i = 0; i < limit; i += 8) {
      // load 32 argb bytes
      const __m128i a0 = _mm_loadu_si128(src + 0);
      const __m128i a1 = _mm_loadu_si128(src + 1);
      const __m128i b0 = _mm_and_si128(a0, a_mask);
      const __m128i b1 = _mm_and_si128(a1, a_mask);
      const __m128i c0 = _mm_packs_epi32(b0, b1);
      const __m128i d0 = _mm_packus_epi16(c0, c0);
      // store
      _mm_storel_epi64((__m128i*)&alpha[i], d0);
      // accumulate eight alpha 'and' in parallel
      all_alphas = _mm_and_si128(all_alphas, d0);
      src += 2;
    }
    for (; i < width; ++i) {
      const uint32_t alpha_value = argb[4 * i];
      alpha[i] = alpha_value;
      alpha_and &= alpha_value;
    }
    argb += argb_stride;
    alpha += alpha_stride;
  }
  // Combine the eight alpha 'and' into a 8-bit mask.
  alpha_and &= _mm_movemask_epi8(_mm_cmpeq_epi8(all_alphas, all_0xff));
  return (alpha_and == 0xff);
}

// Assembly:
testl %ecx, %ecx
jle 0xe24aa
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
leal -0x1(%rdx), %eax
andl $-0x8, %eax
movslq %esi, %r10
movslq %r9d, %r9
movslq %eax, %r11
movl %edx, %ebx
movq 0x4a876(%rip), %xmm0    # 0x12cc90
xorl %r14d, %r14d
movl $0xff, %esi
movdqa 0x4a846(%rip), %xmm1    # 0x12cc70
xorl %r15d, %r15d
testl %eax, %eax
jle 0xe2461
movdqu (%rdi,%r15,4), %xmm2
movdqu 0x10(%rdi,%r15,4), %xmm3
pand %xmm1, %xmm2
pand %xmm1, %xmm3
packssdw %xmm3, %xmm2
packuswb %xmm2, %xmm2
movq %xmm2, (%r8,%r15)
pand %xmm2, %xmm0
addq $0x8, %r15
cmpq %r11, %r15
jl 0xe2431
cmpl %edx, %r15d
jge 0xe247c
movl %r15d, %r15d
movzbl (%rdi,%r15,4), %ebp
movb %bpl, (%r8,%r15)
andl %ebp, %esi
incq %r15
cmpq %r15, %rbx
jne 0xe2469
addq %r10, %rdi
addq %r9, %r8
incl %r14d
cmpl %ecx, %r14d
jne 0xe242a
pcmpeqb 0x148ae(%rip), %xmm0    # 0xf6d40
pmovmskb %xmm0, %eax
andl %eax, %esi
xorl %eax, %eax
cmpl $0xff, %esi
sete %al
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing_sse2.c
// Function: ExtractGreen_SSE2
static void ExtractGreen_SSE2(const uint32_t* WEBP_RESTRICT argb,
                              uint8_t* WEBP_RESTRICT alpha, int size) {
  int i;
  const __m128i mask = _mm_set1_epi32(0xff);
  const __m128i* src = (const __m128i*)argb;

  for (i = 0; i + 16 <= size; i += 16, src += 4) {
    const __m128i a0 = _mm_loadu_si128(src + 0);
    const __m128i a1 = _mm_loadu_si128(src + 1);
    const __m128i a2 = _mm_loadu_si128(src + 2);
    const __m128i a3 = _mm_loadu_si128(src + 3);
    const __m128i b0 = _mm_srli_epi32(a0, 8);
    const __m128i b1 = _mm_srli_epi32(a1, 8);
    const __m128i b2 = _mm_srli_epi32(a2, 8);
    const __m128i b3 = _mm_srli_epi32(a3, 8);
    const __m128i c0 = _mm_and_si128(b0, mask);
    const __m128i c1 = _mm_and_si128(b1, mask);
    const __m128i c2 = _mm_and_si128(b2, mask);
    const __m128i c3 = _mm_and_si128(b3, mask);
    const __m128i d0 = _mm_packs_epi32(c0, c1);
    const __m128i d1 = _mm_packs_epi32(c2, c3);
    const __m128i e = _mm_packus_epi16(d0, d1);
    // store
    _mm_storeu_si128((__m128i*)&alpha[i], e);
  }
  if (i + 8 <= size) {
    const __m128i a0 = _mm_loadu_si128(src + 0);
    const __m128i a1 = _mm_loadu_si128(src + 1);
    const __m128i b0 = _mm_srli_epi32(a0, 8);
    const __m128i b1 = _mm_srli_epi32(a1, 8);
    const __m128i c0 = _mm_and_si128(b0, mask);
    const __m128i c1 = _mm_and_si128(b1, mask);
    const __m128i d = _mm_packs_epi32(c0, c1);
    const __m128i e = _mm_packus_epi16(d, d);
    _mm_storel_epi64((__m128i*)&alpha[i], e);
    i += 8;
  }
  for (; i < size; ++i) alpha[i] = argb[i] >> 8;
}

// Assembly:
xorl %r8d, %r8d
movl %edx, %eax
movq %rdi, %rcx
cmpl $0x10, %edx
jl 0xe2528
xorl %r8d, %r8d
movdqa 0x4a7a8(%rip), %xmm0    # 0x12cc70
movq %rdi, %rcx
movq %r8, %r9
movdqu (%rcx), %xmm1
movdqu 0x10(%rcx), %xmm2
movdqu 0x20(%rcx), %xmm3
movdqu 0x30(%rcx), %xmm4
psrld $0x8, %xmm1
psrld $0x8, %xmm2
psrld $0x8, %xmm3
psrld $0x8, %xmm4
pand %xmm0, %xmm1
pand %xmm0, %xmm2
packssdw %xmm2, %xmm1
pand %xmm0, %xmm3
pand %xmm0, %xmm4
packssdw %xmm4, %xmm3
packuswb %xmm3, %xmm1
movdqu %xmm1, (%rsi,%r8)
addq $0x40, %rcx
addq $0x10, %r8
addq $0x20, %r9
cmpq %rax, %r9
jbe 0xe24cb
movl %r8d, %r9d
orl $0x8, %r9d
cmpl %edx, %r9d
jle 0xe2539
movl %r8d, %r9d
jmp 0xe256c
movdqu (%rcx), %xmm0
movdqu 0x10(%rcx), %xmm1
psrld $0x8, %xmm0
psrld $0x8, %xmm1
movdqa 0x4a71c(%rip), %xmm2    # 0x12cc70
pand %xmm2, %xmm0
pand %xmm2, %xmm1
packssdw %xmm1, %xmm0
packuswb %xmm0, %xmm0
movl %r8d, %ecx
movq %xmm0, (%rsi,%rcx)
cmpl %edx, %r9d
jge 0xe2583
movl %r9d, %ecx
movb 0x1(%rdi,%rcx,4), %dl
movb %dl, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0xe2574
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing_sse2.c
// Function: HasAlpha8b_SSE2
static int HasAlpha8b_SSE2(const uint8_t* src, int length) {
  const __m128i all_0xff = _mm_set1_epi8((char)0xff);
  int i = 0;
  for (; i + 16 <= length; i += 16) {
    const __m128i v = _mm_loadu_si128((const __m128i*)(src + i));
    const __m128i bits = _mm_cmpeq_epi8(v, all_0xff);
    const int mask = _mm_movemask_epi8(bits);
    if (mask != 0xffff) return 1;
  }
  for (; i < length; ++i) if (src[i] != 0xff) return 1;
  return 0;
}

// Assembly:
movslq %esi, %rax
xorl %ecx, %ecx
pcmpeqd %xmm0, %xmm0
leaq 0x10(%rcx), %rdx
cmpq %rax, %rdx
jg 0xe25b4
movdqu (%rdi,%rcx), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ecx
xorl $0xffff, %ecx           # imm = 0xFFFF
movq %rdx, %rcx
je 0xe258d
movl $0x1, %eax
retq
xorl %eax, %eax
cmpl %esi, %ecx
jge 0xe25ca
movl %esi, %edx
cmpb $-0x1, (%rdi,%rcx)
jne 0xe25ae
incq %rcx
cmpq %rcx, %rdx
jne 0xe25bc
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing_sse2.c
// Function: HasAlpha32b_SSE2
static int HasAlpha32b_SSE2(const uint8_t* src, int length) {
  const __m128i alpha_mask = _mm_set1_epi32(0xff);
  const __m128i all_0xff = _mm_set1_epi8((char)0xff);
  int i = 0;
  // We don't know if we can access the last 3 bytes after the last alpha
  // value 'src[4 * length - 4]' (because we don't know if alpha is the first
  // or the last byte of the quadruplet). Hence the '-3' protection below.
  length = length * 4 - 3;   // size in bytes
  for (; i + 64 <= length; i += 64) {
    const __m128i a0 = _mm_loadu_si128((const __m128i*)(src + i +  0));
    const __m128i a1 = _mm_loadu_si128((const __m128i*)(src + i + 16));
    const __m128i a2 = _mm_loadu_si128((const __m128i*)(src + i + 32));
    const __m128i a3 = _mm_loadu_si128((const __m128i*)(src + i + 48));
    const __m128i b0 = _mm_and_si128(a0, alpha_mask);
    const __m128i b1 = _mm_and_si128(a1, alpha_mask);
    const __m128i b2 = _mm_and_si128(a2, alpha_mask);
    const __m128i b3 = _mm_and_si128(a3, alpha_mask);
    const __m128i c0 = _mm_packs_epi32(b0, b1);
    const __m128i c1 = _mm_packs_epi32(b2, b3);
    const __m128i d  = _mm_packus_epi16(c0, c1);
    const __m128i bits = _mm_cmpeq_epi8(d, all_0xff);
    const int mask = _mm_movemask_epi8(bits);
    if (mask != 0xffff) return 1;
  }
  for (; i + 32 <= length; i += 32) {
    const __m128i a0 = _mm_loadu_si128((const __m128i*)(src + i +  0));
    const __m128i a1 = _mm_loadu_si128((const __m128i*)(src + i + 16));
    const __m128i b0 = _mm_and_si128(a0, alpha_mask);
    const __m128i b1 = _mm_and_si128(a1, alpha_mask);
    const __m128i c  = _mm_packs_epi32(b0, b1);
    const __m128i d  = _mm_packus_epi16(c, c);
    const __m128i bits = _mm_cmpeq_epi8(d, all_0xff);
    const int mask = _mm_movemask_epi8(bits);
    if (mask != 0xffff) return 1;
  }
  for (; i <= length; i += 4) if (src[i] != 0xff) return 1;
  return 0;
}

// Assembly:
leal -0x3(,%rsi,4), %edx
movslq %edx, %rcx
xorl %esi, %esi
movdqa 0x4a691(%rip), %xmm0    # 0x12cc70
pcmpeqd %xmm1, %xmm1
leaq 0x40(%rsi), %rax
cmpq %rcx, %rax
jg 0xe2634
movdqu (%rdi,%rsi), %xmm2
movdqu 0x10(%rdi,%rsi), %xmm3
movdqu 0x20(%rdi,%rsi), %xmm4
movdqu 0x30(%rdi,%rsi), %xmm5
pand %xmm0, %xmm2
pand %xmm0, %xmm3
packssdw %xmm3, %xmm2
pand %xmm0, %xmm4
pand %xmm0, %xmm5
packssdw %xmm5, %xmm4
packuswb %xmm4, %xmm2
pcmpeqb %xmm1, %xmm2
pmovmskb %xmm2, %esi
xorl $0xffff, %esi           # imm = 0xFFFF
movq %rax, %rsi
je 0xe25e3
jmp 0xe266f
pcmpeqd %xmm1, %xmm1
leaq 0x20(%rsi), %rax
cmpq %rcx, %rax
jg 0xe2675
movdqu (%rdi,%rsi), %xmm2
movdqu 0x10(%rdi,%rsi), %xmm3
pand %xmm0, %xmm2
pand %xmm0, %xmm3
packssdw %xmm3, %xmm2
packuswb %xmm2, %xmm2
pcmpeqb %xmm1, %xmm2
pmovmskb %xmm2, %esi
xorl $0xffff, %esi           # imm = 0xFFFF
movq %rax, %rsi
je 0xe2638
movl $0x1, %eax
retq
xorl %eax, %eax
cmpl %esi, %edx
jl 0xe2674
cmpb $-0x1, (%rdi,%rsi)
jne 0xe266f
addq $0x4, %rsi
cmpq %rcx, %rsi
jle 0xe267b
jmp 0xe2674
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/alpha_processing_sse2.c
// Function: AlphaReplace_SSE2
static void AlphaReplace_SSE2(uint32_t* src, int length, uint32_t color) {
  const __m128i m_color = _mm_set1_epi32((int)color);
  const __m128i zero = _mm_setzero_si128();
  int i = 0;
  for (; i + 8 <= length; i += 8) {
    const __m128i a0 = _mm_loadu_si128((const __m128i*)(src + i + 0));
    const __m128i a1 = _mm_loadu_si128((const __m128i*)(src + i + 4));
    const __m128i b0 = _mm_srai_epi32(a0, 24);
    const __m128i b1 = _mm_srai_epi32(a1, 24);
    const __m128i c0 = _mm_cmpeq_epi32(b0, zero);
    const __m128i c1 = _mm_cmpeq_epi32(b1, zero);
    const __m128i d0 = _mm_and_si128(c0, m_color);
    const __m128i d1 = _mm_and_si128(c1, m_color);
    const __m128i e0 = _mm_andnot_si128(c0, a0);
    const __m128i e1 = _mm_andnot_si128(c1, a1);
    _mm_storeu_si128((__m128i*)(src + i + 0), _mm_or_si128(d0, e0));
    _mm_storeu_si128((__m128i*)(src + i + 4), _mm_or_si128(d1, e1));
  }
  for (; i < length; ++i) if ((src[i] >> 24) == 0) src[i] = color;
}

// Assembly:
xorl %ecx, %ecx
movl %esi, %eax
cmpl $0x8, %esi
jl 0xe2706
movd %edx, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
xorl %ecx, %ecx
movdqa 0x306d8(%rip), %xmm1    # 0x112d80
movdqa 0x4a5d0(%rip), %xmm2    # 0x12cc80
movq %rcx, %r8
movdqu (%rdi,%rcx,4), %xmm3
movdqu 0x10(%rdi,%rcx,4), %xmm4
movdqa %xmm3, %xmm5
pxor %xmm1, %xmm5
pcmpgtd %xmm2, %xmm5
movdqa %xmm4, %xmm6
pxor %xmm1, %xmm6
pcmpgtd %xmm2, %xmm6
pand %xmm6, %xmm4
pandn %xmm0, %xmm6
por %xmm4, %xmm6
pand %xmm5, %xmm3
pandn %xmm0, %xmm5
por %xmm3, %xmm5
movdqu %xmm5, (%rdi,%rcx,4)
movdqu %xmm6, 0x10(%rdi,%rcx,4)
addq $0x8, %rcx
addq $0x10, %r8
cmpq %rax, %r8
jbe 0xe26b0
cmpl %esi, %ecx
jge 0xe2720
movl %ecx, %ecx
cmpl $0xffffff, (%rdi,%rcx,4) # imm = 0xFFFFFF
ja 0xe2718
movl %edx, (%rdi,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0xe270c
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: SimpleVFilter16_SSE2
static void SimpleVFilter16_SSE2(uint8_t* p, int stride, int thresh) {
  // Load
  __m128i p1 = _mm_loadu_si128((__m128i*)&p[-2 * stride]);
  __m128i p0 = _mm_loadu_si128((__m128i*)&p[-stride]);
  __m128i q0 = _mm_loadu_si128((__m128i*)&p[0]);
  __m128i q1 = _mm_loadu_si128((__m128i*)&p[stride]);

  DoFilter2_SSE2(&p1, &p0, &q0, &q1, thresh);

  // Store
  _mm_storeu_si128((__m128i*)&p[-stride], p0);
  _mm_storeu_si128((__m128i*)&p[0], q0);
}

// Assembly:
movslq %esi, %rcx
leaq (%rcx,%rcx), %rax
negq %rax
movdqu (%rdi,%rax), %xmm2
movq %rdi, %rax
subq %rcx, %rax
movdqu (%rax), %xmm1
movdqu (%rdi), %xmm0
movdqu (%rdi,%rcx), %xmm6
movd %edx, %xmm3
punpcklbw %xmm3, %xmm3    # xmm3 = xmm3[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm3, %xmm4      # xmm4 = xmm3[0,0,0,0]
movdqa %xmm6, %xmm3
psubusb %xmm2, %xmm3
movdqa %xmm2, %xmm5
psubusb %xmm6, %xmm5
por %xmm3, %xmm5
psrlw $0x1, %xmm5
movdqa %xmm0, %xmm3
psubusb %xmm1, %xmm3
movdqa %xmm1, %xmm7
psubusb %xmm0, %xmm7
por %xmm3, %xmm7
pand 0x43f1d(%rip), %xmm5    # 0x128ea0
paddusb %xmm7, %xmm7
paddusb %xmm7, %xmm5
movdqa 0x4573d(%rip), %xmm3    # 0x12a6d0
pxor %xmm3, %xmm1
pxor %xmm3, %xmm2
pxor %xmm3, %xmm6
psubsb %xmm6, %xmm2
pxor %xmm3, %xmm0
movdqa %xmm0, %xmm6
psubsb %xmm1, %xmm6
paddsb %xmm6, %xmm2
paddsb %xmm6, %xmm2
paddsb %xmm6, %xmm2
pminub %xmm5, %xmm4
pcmpeqb %xmm5, %xmm4
pand %xmm2, %xmm4
movdqa 0x47d01(%rip), %xmm2    # 0x12ccd0
paddsb %xmm4, %xmm2
paddsb 0x47d05(%rip), %xmm4    # 0x12cce0
punpcklbw %xmm4, %xmm5    # xmm5 = xmm5[0],xmm4[0],xmm5[1],xmm4[1],xmm5[2],xmm4[2],xmm5[3],xmm4[3],xmm5[4],xmm4[4],xmm5[5],xmm4[5],xmm5[6],xmm4[6],xmm5[7],xmm4[7]
punpckhbw %xmm4, %xmm4    # xmm4 = xmm4[8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15]
psraw $0xb, %xmm5
psraw $0xb, %xmm4
packsswb %xmm4, %xmm5
punpcklbw %xmm2, %xmm4    # xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1],xmm4[2],xmm2[2],xmm4[3],xmm2[3],xmm4[4],xmm2[4],xmm4[5],xmm2[5],xmm4[6],xmm2[6],xmm4[7],xmm2[7]
punpckhbw %xmm2, %xmm2    # xmm2 = xmm2[8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15]
psraw $0xb, %xmm4
psraw $0xb, %xmm2
packsswb %xmm2, %xmm4
psubsb %xmm5, %xmm0
paddsb %xmm1, %xmm4
pxor %xmm3, %xmm4
pxor %xmm3, %xmm0
movdqu %xmm4, (%rax)
movdqu %xmm0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: SimpleVFilter16i_SSE2
static void SimpleVFilter16i_SSE2(uint8_t* p, int stride, int thresh) {
  int k;
  for (k = 3; k > 0; --k) {
    p += 4 * stride;
    SimpleVFilter16_SSE2(p, stride, thresh);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leal (,%r14,4), %eax
movslq %eax, %r12
addq %r12, %r15
movl $0x4, %ebp
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0xe4f1a
decl %ebp
addq %r12, %r15
cmpl $0x1, %ebp
ja 0xe52f0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: SimpleHFilter16i_SSE2
static void SimpleHFilter16i_SSE2(uint8_t* p, int stride, int thresh) {
  int k;
  for (k = 3; k > 0; --k) {
    p += 4;
    SimpleHFilter16_SSE2(p, stride, thresh);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
addq $0x4, %r14
movl $0x4, %r15d
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0xe5020
decl %r15d
addq $0x4, %r14
cmpl $0x1, %r15d
ja 0xe5328
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: RD4_SSE2
static void RD4_SSE2(uint8_t* dst) {   // Down-right
  const __m128i one = _mm_set1_epi8(1);
  const __m128i XABCD = _mm_loadl_epi64((__m128i*)(dst - BPS - 1));
  const __m128i ____XABCD = _mm_slli_si128(XABCD, 4);
  const uint32_t I = dst[-1 + 0 * BPS];
  const uint32_t J = dst[-1 + 1 * BPS];
  const uint32_t K = dst[-1 + 2 * BPS];
  const uint32_t L = dst[-1 + 3 * BPS];
  const __m128i LKJI_____ =
      _mm_cvtsi32_si128((int)(L | (K << 8) | (J << 16) | (I << 24)));
  const __m128i LKJIXABCD = _mm_or_si128(LKJI_____, ____XABCD);
  const __m128i KJIXABCD_ = _mm_srli_si128(LKJIXABCD, 1);
  const __m128i JIXABCD__ = _mm_srli_si128(LKJIXABCD, 2);
  const __m128i avg1 = _mm_avg_epu8(JIXABCD__, LKJIXABCD);
  const __m128i lsb = _mm_and_si128(_mm_xor_si128(JIXABCD__, LKJIXABCD), one);
  const __m128i avg2 = _mm_subs_epu8(avg1, lsb);
  const __m128i abcdefg = _mm_avg_epu8(avg2, KJIXABCD_);
  WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(               abcdefg    ));
  WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 1)));
  WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 2)));
  WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 3)));
}

// Assembly:
movq -0x21(%rdi), %xmm0
pshufd $0x90, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,2]
movzbl -0x1(%rdi), %eax
movzbl 0x1f(%rdi), %ecx
movzbl 0x3f(%rdi), %edx
movzbl 0x5f(%rdi), %esi
shll $0x8, %edx
shll $0x10, %ecx
shll $0x18, %eax
orl %ecx, %eax
orl %esi, %eax
orl %edx, %eax
movd %eax, %xmm1
movss %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1,2,3]
movaps %xmm0, %xmm1
psrldq $0x2, %xmm1             # xmm1 = xmm1[2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero,zero
movdqa %xmm1, %xmm2
pavgb %xmm0, %xmm2
pxor %xmm0, %xmm1
pand 0x47804(%rip), %xmm1    # 0x12cc20
psrldq $0x1, %xmm0             # xmm0 = xmm0[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
psubusb %xmm1, %xmm2
pavgb %xmm0, %xmm2
movd %xmm2, 0x60(%rdi)
movdqa %xmm2, %xmm0
psrlq $0x8, %xmm0
movd %xmm0, 0x40(%rdi)
movdqa %xmm2, %xmm0
psrlq $0x10, %xmm0
movd %xmm0, 0x20(%rdi)
psrlq $0x18, %xmm2
movd %xmm2, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: LD4_SSE2
static void LD4_SSE2(uint8_t* dst) {   // Down-Left
  const __m128i one = _mm_set1_epi8(1);
  const __m128i ABCDEFGH = _mm_loadl_epi64((__m128i*)(dst - BPS));
  const __m128i BCDEFGH0 = _mm_srli_si128(ABCDEFGH, 1);
  const __m128i CDEFGH00 = _mm_srli_si128(ABCDEFGH, 2);
  const __m128i CDEFGHH0 = _mm_insert_epi16(CDEFGH00, dst[-BPS + 7], 3);
  const __m128i avg1 = _mm_avg_epu8(ABCDEFGH, CDEFGHH0);
  const __m128i lsb = _mm_and_si128(_mm_xor_si128(ABCDEFGH, CDEFGHH0), one);
  const __m128i avg2 = _mm_subs_epu8(avg1, lsb);
  const __m128i abcdefg = _mm_avg_epu8(avg2, BCDEFGH0);
  WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(               abcdefg    ));
  WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 1)));
  WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 2)));
  WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 3)));
}

// Assembly:
movq -0x20(%rdi), %rax
movq %rax, %xmm0
movq -0x20(%rdi), %xmm1
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
psrldq $0xa, %xmm0             # xmm0 = xmm0[10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero,zero,zero
shrq $0x38, %rax
pinsrw $0x3, %eax, %xmm0
movdqa %xmm1, %xmm2
pavgb %xmm0, %xmm2
pxor %xmm1, %xmm0
pand 0x47707(%rip), %xmm0    # 0x12cc20
psrlq $0x8, %xmm1
psubusb %xmm0, %xmm2
pavgb %xmm1, %xmm2
movd %xmm2, (%rdi)
movdqa %xmm2, %xmm0
psrlq $0x8, %xmm0
movd %xmm0, 0x20(%rdi)
movdqa %xmm2, %xmm0
psrlq $0x10, %xmm0
movd %xmm0, 0x40(%rdi)
psrlq $0x18, %xmm2
movd %xmm2, 0x60(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: DC8uvNoTop_SSE2
static void DC8uvNoTop_SSE2(uint8_t* dst) {  // DC with no top samples
  int dc0 = 4;
  int i;
  for (i = 0; i < 8; ++i) {
    dc0 += dst[-1 + i * BPS];
  }
  Put8x8uv_SSE2(dc0 >> 3, dst);
}

// Assembly:
movl $0x4, %eax
movq $-0x1, %rcx
movzbl (%rdi,%rcx), %edx
addl %edx, %eax
addq $0x20, %rcx
cmpq $0xff, %rcx
jne 0xe582d
shrl $0x3, %eax
movd %eax, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
movq %xmm0, %rax
xorl %ecx, %ecx
movq %rax, (%rdi,%rcx)
addq $0x20, %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0xe5857
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/filters_sse2.c
// Function: VP8FiltersInitSSE2
WEBP_TSAN_IGNORE_FUNCTION void VP8FiltersInitSSE2(void) {
  WebPUnfilters[WEBP_FILTER_HORIZONTAL] = HorizontalUnfilter_SSE2;
#if defined(CHROMIUM)
  // TODO(crbug.com/654974)
  (void)VerticalUnfilter_SSE2;
#else
  WebPUnfilters[WEBP_FILTER_VERTICAL] = VerticalUnfilter_SSE2;
#endif
  WebPUnfilters[WEBP_FILTER_GRADIENT] = GradientUnfilter_SSE2;

  WebPFilters[WEBP_FILTER_HORIZONTAL] = HorizontalFilter_SSE2;
  WebPFilters[WEBP_FILTER_VERTICAL] = VerticalFilter_SSE2;
  WebPFilters[WEBP_FILTER_GRADIENT] = GradientFilter_SSE2;
}

// Assembly:
leaq 0x4a(%rip), %rax        # 0xe5915
leaq 0x95b1e(%rip), %rcx     # 0x17b3f0
movq %rax, 0x8(%rcx)
leaq 0xcf(%rip), %rax        # 0xe59ac
movq %rax, 0x10(%rcx)
leaq 0x153(%rip), %rax       # 0xe5a3b
movq %rax, 0x18(%rcx)
leaq 0x25c(%rip), %rax       # 0xe5b4f
leaq 0x95ad6(%rip), %rcx     # 0x17b3d0
movq %rax, 0x8(%rcx)
leaq 0x413(%rip), %rax       # 0xe5d18
movq %rax, 0x10(%rcx)
leaq 0x5ac(%rip), %rax       # 0xe5ebc
movq %rax, 0x18(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/filters_sse2.c
// Function: HorizontalUnfilter_SSE2
static void HorizontalUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
                                    uint8_t* out, int width) {
  int i;
  __m128i last;
  out[0] = (uint8_t)(in[0] + (prev == NULL ? 0 : prev[0]));
  if (width <= 1) return;
  last = _mm_set_epi32(0, 0, 0, out[0]);
  for (i = 1; i + 8 <= width; i += 8) {
    const __m128i A0 = _mm_loadl_epi64((const __m128i*)(in + i));
    const __m128i A1 = _mm_add_epi8(A0, last);
    const __m128i A2 = _mm_slli_si128(A1, 1);
    const __m128i A3 = _mm_add_epi8(A1, A2);
    const __m128i A4 = _mm_slli_si128(A3, 2);
    const __m128i A5 = _mm_add_epi8(A3, A4);
    const __m128i A6 = _mm_slli_si128(A5, 4);
    const __m128i A7 = _mm_add_epi8(A5, A6);
    _mm_storel_epi64((__m128i*)(out + i), A7);
    last = _mm_srli_epi64(A7, 56);
  }
  for (; i < width; ++i) out[i] = (uint8_t)(in[i] + out[i - 1]);
}

// Assembly:
movb (%rsi), %al
testq %rdi, %rdi
je 0xe5921
movb (%rdi), %r8b
jmp 0xe5924
xorl %r8d, %r8d
addb %al, %r8b
movb %r8b, (%rdx)
cmpl $0x2, %ecx
jl 0xe59ab
movl $0x1, %edi
movl %ecx, %eax
cmpl $0x9, %ecx
jb 0xe5990
movzbl %r8b, %edi
movd %edi, %xmm0
movl $0x9, %edi
movq -0x8(%rsi,%rdi), %xmm1
paddb %xmm0, %xmm1
movdqa %xmm1, %xmm0
pslldq $0x1, %xmm0             # xmm0 = zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
paddb %xmm1, %xmm0
movdqa %xmm0, %xmm1
pslldq $0x2, %xmm1             # xmm1 = zero,zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
paddb %xmm0, %xmm1
movdqa %xmm1, %xmm0
pslldq $0x4, %xmm0             # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7,8,9,10,11]
paddb %xmm1, %xmm0
movq %xmm0, -0x8(%rdx,%rdi)
psrlq $0x38, %xmm0
addq $0x8, %rdi
cmpq %rax, %rdi
jbe 0xe5948
addl $-0x8, %edi
cmpl %ecx, %edi
jge 0xe59ab
movl %edi, %ecx
movb -0x1(%rdx,%rcx), %dil
addb (%rsi,%rcx), %dil
movb %dil, (%rdx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0xe599b
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/filters_sse2.c
// Function: VerticalUnfilter_SSE2
static void VerticalUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
                                  uint8_t* out, int width) {
  if (prev == NULL) {
    HorizontalUnfilter_SSE2(NULL, in, out, width);
  } else {
    int i;
    const int max_pos = width & ~31;
    assert(width >= 0);
    for (i = 0; i < max_pos; i += 32) {
      const __m128i A0 = _mm_loadu_si128((const __m128i*)&in[i +  0]);
      const __m128i A1 = _mm_loadu_si128((const __m128i*)&in[i + 16]);
      const __m128i B0 = _mm_loadu_si128((const __m128i*)&prev[i +  0]);
      const __m128i B1 = _mm_loadu_si128((const __m128i*)&prev[i + 16]);
      const __m128i C0 = _mm_add_epi8(A0, B0);
      const __m128i C1 = _mm_add_epi8(A1, B1);
      _mm_storeu_si128((__m128i*)&out[i +  0], C0);
      _mm_storeu_si128((__m128i*)&out[i + 16], C1);
    }
    for (; i < width; ++i) out[i] = (uint8_t)(in[i] + prev[i]);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xe59f5
testl %ecx, %ecx
js 0xe5a1b
movl %ecx, %eax
andl $-0x20, %eax
jle 0xe59fc
movl %eax, %r8d
xorl %eax, %eax
movdqu (%rsi,%rax), %xmm0
movdqu 0x10(%rsi,%rax), %xmm1
movdqu (%rdi,%rax), %xmm2
paddb %xmm0, %xmm2
movdqu 0x10(%rdi,%rax), %xmm0
paddb %xmm1, %xmm0
movdqu %xmm2, (%rdx,%rax)
movdqu %xmm0, 0x10(%rdx,%rax)
addq $0x20, %rax
cmpq %r8, %rax
jb 0xe59c1
jmp 0xe59fe
xorl %edi, %edi
jmp 0xe5915
xorl %eax, %eax
cmpl %ecx, %eax
jge 0xe5a1a
movl %eax, %eax
movl %ecx, %ecx
movb (%rdi,%rax), %r8b
addb (%rsi,%rax), %r8b
movb %r8b, (%rdx,%rax)
incq %rax
cmpq %rax, %rcx
jne 0xe5a06
retq
pushq %rax
leaq 0x47311(%rip), %rdi     # 0x12cd34
leaq 0x47315(%rip), %rsi     # 0x12cd3f
leaq 0x47325(%rip), %rcx     # 0x12cd56
movl $0xfe, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/filters_sse2.c
// Function: GradientUnfilter_SSE2
static void GradientUnfilter_SSE2(const uint8_t* prev, const uint8_t* in,
                                  uint8_t* out, int width) {
  if (prev == NULL) {
    HorizontalUnfilter_SSE2(NULL, in, out, width);
  } else {
    out[0] = (uint8_t)(in[0] + prev[0]);  // predict from above
    GradientPredictInverse_SSE2(in + 1, prev + 1, out + 1, width - 1);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xe5af9
movb (%rdi), %al
addb (%rsi), %al
movb %al, (%rdx)
cmpl $0x2, %ecx
jl 0xe5b4e
decl %ecx
movl %ecx, %r8d
andl $0x7ffffff8, %r8d       # imm = 0x7FFFFFF8
je 0xe5b00
movzbl %al, %eax
movd %eax, %xmm1
movl %r8d, %r8d
xorl %eax, %eax
pxor %xmm0, %xmm0
movd 0x472b3(%rip), %xmm2    # 0x12cd30
movq 0x1(%rdi,%rax), %xmm3
movq (%rdi,%rax), %xmm4
punpcklbw %xmm0, %xmm3    # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1],xmm3[2],xmm0[2],xmm3[3],xmm0[3],xmm3[4],xmm0[4],xmm3[5],xmm0[5],xmm3[6],xmm0[6],xmm3[7],xmm0[7]
punpcklbw %xmm0, %xmm4    # xmm4 = xmm4[0],xmm0[0],xmm4[1],xmm0[1],xmm4[2],xmm0[2],xmm4[3],xmm0[3],xmm4[4],xmm0[4],xmm4[5],xmm0[5],xmm4[6],xmm0[6],xmm4[7],xmm0[7]
psubw %xmm4, %xmm3
movq 0x1(%rsi,%rax), %xmm4
paddw %xmm3, %xmm1
packuswb %xmm1, %xmm1
paddb %xmm4, %xmm1
pand %xmm2, %xmm1
movl $0xfffffff9, %r9d       # imm = 0xFFFFFFF9
movdqa %xmm1, %xmm5
movdqa %xmm2, %xmm6
psllq $0x8, %xmm5
pslldq $0x1, %xmm6             # xmm6 = zero,xmm6[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
punpcklbw %xmm0, %xmm5    # xmm5 = xmm5[0],xmm0[0],xmm5[1],xmm0[1],xmm5[2],xmm0[2],xmm5[3],xmm0[3],xmm5[4],xmm0[4],xmm5[5],xmm0[5],xmm5[6],xmm0[6],xmm5[7],xmm0[7]
paddw %xmm3, %xmm5
packuswb %xmm0, %xmm5
paddb %xmm4, %xmm5
pand %xmm6, %xmm5
por %xmm5, %xmm1
incl %r9d
jne 0xe5ab8
psrldq $0x7, %xmm5             # xmm5 = xmm5[7,8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero
movq %xmm1, 0x1(%rdx,%rax)
addq $0x8, %rax
movdqa %xmm5, %xmm1
cmpq %r8, %rax
jb 0xe5a7d
jmp 0xe5b02
xorl %edi, %edi
jmp 0xe5915
xorl %eax, %eax
cmpl %ecx, %eax
jge 0xe5b4e
movl %eax, %eax
movl %ecx, %ecx
movb (%rdx,%rax), %r8b
movzbl 0x1(%rdi,%rax), %r9d
movzbl (%rdi,%rax), %r10d
movzbl %r8b, %r8d
addl %r9d, %r8d
subl %r10d, %r8d
testl %r8d, %r8d
jg 0xe5b2b
xorl %r8d, %r8d
movl $0xff, %r9d
cmpl %r9d, %r8d
jl 0xe5b3c
movl $0xff, %r8d
addb 0x1(%rsi,%rax), %r8b
movb %r8b, 0x1(%rdx,%rax)
incq %rax
cmpq %rax, %rcx
jne 0xe5b0e
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless_sse2.c
// Function: Predictor10_SSE2
static WEBP_INLINE __m128i Average2_uint32_16_SSE2(uint32_t a0, uint32_t a1) {
  const __m128i zero = _mm_setzero_si128();
  const __m128i A0 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)a0), zero);
  const __m128i A1 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)a1), zero);
  const __m128i sum = _mm_add_epi16(A1, A0);
  return _mm_srli_epi16(sum, 1);
}

// Assembly:
movd (%rdi), %xmm1
punpcklbw %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
movd -0x4(%rsi), %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
movdqa %xmm0, %xmm2
pand %xmm1, %xmm2
pxor %xmm1, %xmm0
psrlw $0x1, %xmm0
movdqa 0x42b39(%rip), %xmm1    # 0x128ea0
pand %xmm1, %xmm0
paddb %xmm2, %xmm0
movd (%rsi), %xmm2
punpcklbw %xmm2, %xmm2    # xmm2 = xmm2[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
movd 0x4(%rsi), %xmm3
punpcklbw %xmm3, %xmm3    # xmm3 = xmm3[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
movdqa %xmm3, %xmm4
pand %xmm2, %xmm4
pxor %xmm2, %xmm3
psrlw $0x1, %xmm3
pand %xmm1, %xmm3
paddb %xmm4, %xmm3
movdqa %xmm3, %xmm2
pand %xmm0, %xmm2
pxor %xmm0, %xmm3
psrlw $0x1, %xmm3
pand %xmm1, %xmm3
paddb %xmm2, %xmm3
pand 0x46ae6(%rip), %xmm3    # 0x12cea0
packuswb %xmm3, %xmm3
movd %xmm3, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless_sse2.c
// Function: Predictor13_SSE2
static WEBP_INLINE uint32_t ClampedAddSubtractHalf_SSE2(uint32_t c0,
                                                        uint32_t c1,
                                                        uint32_t c2) {
  const __m128i zero = _mm_setzero_si128();
  const __m128i C0 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)c0), zero);
  const __m128i C1 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)c1), zero);
  const __m128i B0 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)c2), zero);
  const __m128i avg = _mm_add_epi16(C1, C0);
  const __m128i A0 = _mm_srli_epi16(avg, 1);
  const __m128i A1 = _mm_sub_epi16(A0, B0);
  const __m128i BgtA = _mm_cmpgt_epi16(B0, A0);
  const __m128i A2 = _mm_sub_epi16(A1, BgtA);
  const __m128i A3 = _mm_srai_epi16(A2, 1);
  const __m128i A4 = _mm_add_epi16(A0, A3);
  const __m128i A5 = _mm_packus_epi16(A4, A4);
  return (uint32_t)_mm_cvtsi128_si32(A5);
}

// Assembly:
movd (%rdi), %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
movd (%rsi), %xmm1
punpcklbw %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
movd -0x4(%rsi), %xmm2
pxor %xmm3, %xmm3
punpcklbw %xmm3, %xmm2    # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1],xmm2[2],xmm3[2],xmm2[3],xmm3[3],xmm2[4],xmm3[4],xmm2[5],xmm3[5],xmm2[6],xmm3[6],xmm2[7],xmm3[7]
movdqa %xmm1, %xmm3
pand %xmm0, %xmm3
pxor %xmm0, %xmm1
psrlw $0x1, %xmm1
pand 0x42a13(%rip), %xmm1    # 0x128ea0
paddb %xmm3, %xmm1
pand 0x46a07(%rip), %xmm1    # 0x12cea0
movdqa %xmm1, %xmm0
psubw %xmm2, %xmm0
pcmpgtw %xmm1, %xmm2
psubw %xmm2, %xmm0
psraw $0x1, %xmm0
paddw %xmm1, %xmm0
packuswb %xmm0, %xmm0
movd %xmm0, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless_sse2.c
// Function: PredictorAdd0_SSE2
static void PredictorAdd0_SSE2(const uint32_t* in, const uint32_t* upper,
                               int num_pixels, uint32_t* out) {
  int i;
  const __m128i black = _mm_set1_epi32((int)ARGB_BLACK);
  for (i = 0; i + 4 <= num_pixels; i += 4) {
    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
    const __m128i res = _mm_add_epi8(src, black);
    _mm_storeu_si128((__m128i*)&out[i], res);
  }
  if (i != num_pixels) {
    VP8LPredictorsAdd_C[0](in + i, NULL, num_pixels - i, out + i);
  }
  (void)upper;
}

// Assembly:
xorl %eax, %eax
cmpl $0x4, %edx
jl 0xe64ec
movl %edx, %esi
xorl %eax, %eax
movdqa 0x469f2(%rip), %xmm0    # 0x12cec0
movq %rax, %r8
movdqu (%rdi,%rax,4), %xmm1
paddb %xmm0, %xmm1
movdqu %xmm1, (%rcx,%rax,4)
addq $0x4, %rax
addq $0x8, %r8
cmpq %rsi, %r8
jbe 0xe64ce
subl %eax, %edx
jne 0xe64f1
retq
leaq 0x95058(%rip), %rsi     # 0x17b550
movq (%rsi), %r8
movl %eax, %eax
leaq (%rdi,%rax,4), %rdi
leaq (%rcx,%rax,4), %rcx
xorl %esi, %esi
jmpq *%r8
// File: /workspace/github_c_makefile_star2_O3/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless_sse2.c
// Function: PredictorAdd1_SSE2
static void PredictorAdd1_SSE2(const uint32_t* in, const uint32_t* upper,
                               int num_pixels, uint32_t* out) {
  int i;
  __m128i prev = _mm_set1_epi32((int)out[-1]);
  for (i = 0; i + 4 <= num_pixels; i += 4) {
    // a | b | c | d
    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
    // 0 | a | b | c
    const __m128i shift0 = _mm_slli_si128(src, 4);
    // a | a + b | b + c | c + d
    const __m128i sum0 = _mm_add_epi8(src, shift0);
    // 0 | 0 | a | a + b
    const __m128i shift1 = _mm_slli_si128(sum0, 8);
    // a | a + b | a + b + c | a + b + c + d
    const __m128i sum1 = _mm_add_epi8(sum0, shift1);
    const __m128i res = _mm_add_epi8(sum1, prev);
    _mm_storeu_si128((__m128i*)&out[i], res);
    // replicate prev output on the four lanes
    prev = _mm_shuffle_epi32(res, (3 << 0) | (3 << 2) | (3 << 4) | (3 << 6));
  }
  if (i != num_pixels) {
    VP8LPredictorsAdd_C[1](in + i, upper + i, num_pixels - i, out + i);
  }
}

// Assembly:
xorl %eax, %eax
cmpl $0x4, %edx
jl 0xe655d
movd -0x4(%rcx), %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movl %edx, %r8d
xorl %eax, %eax
movq %rax, %r9
movdqu (%rdi,%rax,4), %xmm1
movdqa %xmm1, %xmm2
pslldq $0x4, %xmm2             # xmm2 = zero,zero,zero,zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11]
paddb %xmm1, %xmm2
movdqa %xmm2, %xmm1
pslldq $0x8, %xmm1             # xmm1 = zero,zero,zero,zero,zero,zero,zero,zero,xmm1[0,1,2,3,4,5,6,7]
paddb %xmm0, %xmm2
paddb %xmm1, %xmm2
movdqu %xmm2, (%rcx,%rax,4)
pshufd $0xff, %xmm2, %xmm0     # xmm0 = xmm2[3,3,3,3]
addq $0x4, %rax
addq $0x8, %r9
cmpq %r8, %r9
jbe 0xe6520
subl %eax, %edx
jne 0xe6562
retq
leaq 0x94fe7(%rip), %r8      # 0x17b550
movq 0x8(%r8), %r8
movl %eax, %eax
leaq (%rdi,%rax,4), %rdi
leaq (%rsi,%rax,4), %rsi
leaq (%rcx,%rax,4), %rcx
jmpq *%r8