LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: HFilter8i_SSE2
static void HFilter8i_SSE2(uint8_t* u, uint8_t* v, int stride,
                           int thresh, int ithresh, int hev_thresh) {
  __m128i mask;
  __m128i t1, t2, p1, p0, q0, q1;
  Load16x4_SSE2(u, v, stride, &t2, &t1, &p1, &p0);   // p3, p2, p1, p0
  MAX_DIFF1(t2, t1, p1, p0, mask);

  u += 4;  // beginning of q0
  v += 4;
  Load16x4_SSE2(u, v, stride, &q0, &q1, &t1, &t2);  // q0, q1, q2, q3
  MAX_DIFF2(t2, t1, q1, q0, mask);

  ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
  DoFilter4_SSE2(&p1, &p0, &q0, &q1, &mask, hev_thresh);

  u -= 2;  // beginning of p1
  v -= 2;
  Store16x4_SSE2(&p1, &p0, &q0, &q1, u, v, stride);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r9d, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq %rdi, %r14
leaq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq %rax, %r15
leaq 0x60(%rsp), %rcx
leaq 0x90(%rsp), %r13
leaq 0x50(%rsp), %r12
movq %rsi, %rbx
movq %rsi, 0x18(%rsp)
movl %edx, %ebp
movl %edx, 0x8(%rsp)
movq %r13, %r8
movq %r12, %r9
callq 0xd8926
movdqa (%r15), %xmm0
movdqa (%r12), %xmm1
movdqa %xmm1, %xmm2
psubusb %xmm0, %xmm2
psubusb %xmm1, %xmm0
por %xmm2, %xmm0
movdqa (%r13), %xmm4
leaq 0x60(%rsp), %rax
movdqa (%rax), %xmm3
movdqa %xmm4, %xmm2
psubusb %xmm3, %xmm2
psubusb %xmm4, %xmm3
por %xmm2, %xmm3
pmaxub %xmm0, %xmm3
movdqa %xmm3, 0x30(%rsp)
movdqa %xmm1, %xmm0
psubusb %xmm4, %xmm0
psubusb %xmm1, %xmm4
por %xmm0, %xmm4
movdqa %xmm4, 0x20(%rsp)
leaq 0x4(%r14), %rdi
leaq 0x4(%rbx), %rsi
movq %rax, (%rsp)
movq %rax, %rbx
leaq 0x80(%rsp), %r12
leaq 0x70(%rsp), %r15
movl %ebp, %edx
movq %r12, %rcx
movq %r15, %r8
movq %r13, %r9
callq 0xd8926
movdqa (%r12), %xmm0
movdqa (%r15), %xmm1
movq %r15, %rax
movdqa %xmm1, %xmm2
psubusb %xmm0, %xmm2
psubusb %xmm1, %xmm0
por %xmm2, %xmm0
pmaxub 0x20(%rsp), %xmm0
pmaxub 0x30(%rsp), %xmm0
movdqa (%r13), %xmm2
movdqa (%rbx), %xmm3
movdqa %xmm2, %xmm4
psubusb %xmm3, %xmm4
psubusb %xmm2, %xmm3
por %xmm4, %xmm3
movdqa %xmm1, %xmm4
psubusb %xmm2, %xmm4
psubusb %xmm1, %xmm2
por %xmm4, %xmm2
pmaxub %xmm3, %xmm2
pmaxub %xmm0, %xmm2
leaq 0xa0(%rsp), %r13
movdqa %xmm2, (%r13)
movq %r13, (%rsp)
leaq 0x50(%rsp), %r15
movq %r15, %rdi
leaq 0x40(%rsp), %rbp
movq %rbp, %rsi
movq %r12, %rbx
movq %r12, %rdx
movq %rax, %r12
movq %rax, %rcx
movl 0xc(%rsp), %r8d
movl 0x10(%rsp), %r9d
callq 0xd8554
movq %r15, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movq %r13, %r8
movl 0x14(%rsp), %r9d
callq 0xd8b11
addq $0x2, %r14
movq 0x18(%rsp), %r9
addq $0x2, %r9
movl 0x8(%rsp), %eax
movl %eax, (%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0xd89a3
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r8d
movq %rdi, %rbx
movslq %esi, %rax
leaq (%rax,%rax), %rcx
negq %rcx
movups (%rdi,%rcx), %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movq %rbx, %r12
subq %rax, %r12
movups (%r12), %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
movups (%rbx), %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
movups (%rbx,%rax), %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq %r14, %rsi
movq %r15, %rdx
callq 0xd8c76
movaps (%r14), %xmm0
movups %xmm0, (%r12)
movaps (%r15), %xmm0
movups %xmm0, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: SimpleHFilter16_SSE2
static void SimpleHFilter16_SSE2(uint8_t* p, int stride, int thresh) {
  __m128i p1, p0, q0, q1;

  p -= 2;  // beginning of p1

  Load16x4_SSE2(p, p + 8 * stride, stride, &p1, &p0, &q0, &q1);
  DoFilter2_SSE2(&p1, &p0, &q0, &q1, thresh);
  Store16x4_SSE2(&p1, &p0, &q0, &q1, p, p + 8 * stride, stride);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, 0xc(%rsp)
movl %esi, %r14d
leal (,%r14,8), %eax
cltq
leaq -0x2(%rdi,%rax), %rbx
leaq -0x2(%rdi), %r15
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x40(%rsp), %r13
leaq 0x30(%rsp), %rbp
leaq 0x20(%rsp), %r12
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movq %r13, %rcx
movq %rbp, %r8
movq %r12, %r9
callq 0xd8926
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
leaq 0x10(%rsp), %rcx
movl 0xc(%rsp), %r8d
callq 0xd8c76
movl %r14d, (%rsp)
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
leaq 0x10(%rsp), %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0xd89a3
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/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
pushq $-0x3
popq %rbp
testl %ebp, %ebp
je 0xd8114
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0xd7fc8
addq %r12, %r15
incl %ebp
jmp 0xd80fc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x4
popq %r15
cmpl $0x10, %r15d
je 0xd8148
leaq (%r14,%r15), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0xd8040
addq $0x4, %r15
jmp 0xd812f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: VE4_SSE2
static void VE4_SSE2(uint8_t* dst) {    // vertical
  const __m128i one = _mm_set1_epi8(1);
  const __m128i ABCDEFGH = _mm_loadl_epi64((__m128i*)(dst - BPS - 1));
  const __m128i BCDEFGH0 = _mm_srli_si128(ABCDEFGH, 1);
  const __m128i CDEFGH00 = _mm_srli_si128(ABCDEFGH, 2);
  const __m128i a = _mm_avg_epu8(ABCDEFGH, CDEFGH00);
  const __m128i lsb = _mm_and_si128(_mm_xor_si128(ABCDEFGH, CDEFGH00), one);
  const __m128i b = _mm_subs_epu8(a, lsb);
  const __m128i avg = _mm_avg_epu8(b, BCDEFGH0);
  const int vals = _mm_cvtsi128_si32(avg);
  int i;
  for (i = 0; i < 4; ++i) {
    WebPInt32ToMem(dst + i * BPS, vals);
  }
}

// Assembly:
movq -0x21(%rdi), %xmm0
pshufd $0x44, %xmm0, %xmm1     # xmm1 = xmm0[0,1,0,1]
psrldq $0xa, %xmm1             # xmm1 = xmm1[10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero,zero,zero
movdqa %xmm0, %xmm2
pavgb %xmm1, %xmm2
pxor %xmm0, %xmm1
psrlq $0x8, %xmm0
pand 0x4477d(%rip), %xmm1    # 0x11c900
psubusb %xmm1, %xmm2
pavgb %xmm0, %xmm2
movd %xmm2, %eax
xorl %ecx, %ecx
cmpq $0x80, %rcx
je 0xd81a3
movl %eax, (%rdi,%rcx)
addq $0x20, %rcx
jmp 0xd8191
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4470f(%rip), %xmm1    # 0x11c900
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_O2/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 0x44612(%rip), %xmm0    # 0x11c900
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_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: DC16_SSE2
static void DC16_SSE2(uint8_t* dst) {  // DC
  const __m128i zero = _mm_setzero_si128();
  const __m128i top = _mm_loadu_si128((const __m128i*)(dst - BPS));
  const __m128i sad8x2 = _mm_sad_epu8(top, zero);
  // sum the two sads: sad8x2[0:1] + sad8x2[8:9]
  const __m128i sum = _mm_add_epi16(sad8x2, _mm_shuffle_epi32(sad8x2, 2));
  int left = 0;
  int j;
  for (j = 0; j < 16; ++j) {
    left += dst[-1 + j * BPS];
  }
  {
    const int DC = _mm_cvtsi128_si32(sum) + left + 16;
    Put16_SSE2(DC >> 5, dst);
  }
}

// Assembly:
movq %rdi, %rsi
movdqu -0x20(%rdi), %xmm0
xorl %eax, %eax
pushq $-0x1
popq %rcx
cmpq $0x1ff, %rcx            # imm = 0x1FF
je 0xd83c5
movzbl (%rsi,%rcx), %edx
addl %edx, %eax
addq $0x20, %rcx
jmp 0xd83b0
pxor %xmm1, %xmm1
psadbw %xmm1, %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddw %xmm0, %xmm1
movd %xmm1, %ecx
addl %ecx, %eax
addl $0x10, %eax
shrl $0x5, %eax
movzbl %al, %edi
jmp 0xd8e0a
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: VE16_SSE2
static void VE16_SSE2(uint8_t* dst) {
  const __m128i top = _mm_loadu_si128((const __m128i*)(dst - BPS));
  int j;
  for (j = 0; j < 16; ++j) {
    _mm_storeu_si128((__m128i*)(dst + j * BPS), top);
  }
}

// Assembly:
movups -0x20(%rdi), %xmm0
xorl %eax, %eax
cmpq $0x200, %rax            # imm = 0x200
je 0xd840a
movups %xmm0, (%rdi,%rax)
addq $0x20, %rax
jmp 0xd83f8
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: HE16_SSE2
static void HE16_SSE2(uint8_t* dst) {     // horizontal
  int j;
  for (j = 16; j > 0; --j) {
    const __m128i values = _mm_set1_epi8((char)dst[-1]);
    _mm_storeu_si128((__m128i*)dst, values);
    dst += BPS;
  }
}

// Assembly:
xorl %eax, %eax
cmpl $0x200, %eax            # imm = 0x200
je 0xd8436
movzbl -0x1(%rdi,%rax), %ecx
movd %ecx, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqu %xmm0, (%rdi,%rax)
addq $0x20, %rax
jmp 0xd840d
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: DC16NoTop_SSE2
static void DC16NoTop_SSE2(uint8_t* dst) {  // DC with top samples unavailable
  int DC = 8;
  int j;
  for (j = 0; j < 16; ++j) {
    DC += dst[-1 + j * BPS];
  }
  Put16_SSE2(DC >> 4, dst);
}

// Assembly:
movq %rdi, %rsi
pushq $0x8
popq %rax
pushq $-0x1
popq %rcx
cmpq $0x1ff, %rcx            # imm = 0x1FF
je 0xd8455
movzbl (%rsi,%rcx), %edx
addl %edx, %eax
addq $0x20, %rcx
jmp 0xd8440
shrl $0x4, %eax
movzbl %al, %edi
jmp 0xd8e0a
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: DC16NoLeft_SSE2
static void DC16NoLeft_SSE2(uint8_t* dst) {  // DC with left samples unavailable
  const __m128i zero = _mm_setzero_si128();
  const __m128i top = _mm_loadu_si128((const __m128i*)(dst - BPS));
  const __m128i sad8x2 = _mm_sad_epu8(top, zero);
  // sum the two sads: sad8x2[0:1] + sad8x2[8:9]
  const __m128i sum = _mm_add_epi16(sad8x2, _mm_shuffle_epi32(sad8x2, 2));
  const int DC = _mm_cvtsi128_si32(sum) + 8;
  Put16_SSE2(DC >> 4, dst);
}

// Assembly:
movq %rdi, %rsi
movdqu -0x20(%rdi), %xmm0
pxor %xmm1, %xmm1
psadbw %xmm0, %xmm1
pshufd $0xee, %xmm1, %xmm0     # xmm0 = xmm1[2,3,2,3]
paddw %xmm1, %xmm0
movd %xmm0, %eax
addl $0x8, %eax
shrl $0x4, %eax
movzbl %al, %edi
jmp 0xd8e0a
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: DC8uv_SSE2
static void DC8uv_SSE2(uint8_t* dst) {     // DC
  const __m128i zero = _mm_setzero_si128();
  const __m128i top = _mm_loadl_epi64((const __m128i*)(dst - BPS));
  const __m128i sum = _mm_sad_epu8(top, zero);
  int left = 0;
  int j;
  for (j = 0; j < 8; ++j) {
    left += dst[-1 + j * BPS];
  }
  {
    const int DC = _mm_cvtsi128_si32(sum) + left + 8;
    Put8x8uv_SSE2(DC >> 4, dst);
  }
}

// Assembly:
movq %rdi, %rsi
movq -0x20(%rdi), %rcx
xorl %eax, %eax
pushq $-0x1
popq %rdx
cmpq $0xff, %rdx
je 0xd84b9
movzbl (%rsi,%rdx), %edi
addl %edi, %eax
addq $0x20, %rdx
jmp 0xd84a4
movq %rcx, %xmm0
pxor %xmm1, %xmm1
psadbw %xmm0, %xmm1
movd %xmm1, %ecx
addl %ecx, %eax
addl $0x8, %eax
shrl $0x4, %eax
movzbl %al, %edi
jmp 0xd8e32
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: VE8uv_SSE2
static void VE8uv_SSE2(uint8_t* dst) {    // vertical
  int j;
  const __m128i top = _mm_loadl_epi64((const __m128i*)(dst - BPS));
  for (j = 0; j < 8; ++j) {
    _mm_storel_epi64((__m128i*)(dst + j * BPS), top);
  }
}

// Assembly:
movq -0x20(%rdi), %rax
xorl %ecx, %ecx
cmpq $0x100, %rcx            # imm = 0x100
je 0xd84fb
movq %rax, (%rdi,%rcx)
addq $0x20, %rcx
jmp 0xd84e8
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rsi
pushq $0x4
popq %rax
pushq $-0x1
popq %rcx
cmpq $0xff, %rcx
je 0xd851a
movzbl (%rsi,%rcx), %edx
addl %edx, %eax
addq $0x20, %rcx
jmp 0xd8505
shrl $0x3, %eax
movzbl %al, %edi
jmp 0xd8e32
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: DC8uvNoLeft_SSE2
static void DC8uvNoLeft_SSE2(uint8_t* dst) {   // DC with no left samples
  const __m128i zero = _mm_setzero_si128();
  const __m128i top = _mm_loadl_epi64((const __m128i*)(dst - BPS));
  const __m128i sum = _mm_sad_epu8(top, zero);
  const int DC = _mm_cvtsi128_si32(sum) + 4;
  Put8x8uv_SSE2(DC >> 3, dst);
}

// Assembly:
movq %rdi, %rsi
movq -0x20(%rdi), %xmm0
pxor %xmm1, %xmm1
psadbw %xmm0, %xmm1
movd %xmm1, %eax
addl $0x4, %eax
shrl $0x3, %eax
movzbl %al, %edi
jmp 0xd8e32
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: ComplexMask_SSE2
static WEBP_INLINE void ComplexMask_SSE2(const __m128i* const p1,
                                         const __m128i* const p0,
                                         const __m128i* const q0,
                                         const __m128i* const q1,
                                         int thresh, int ithresh,
                                         __m128i* const mask) {
  const __m128i it = _mm_set1_epi8(ithresh);
  const __m128i diff = _mm_subs_epu8(*mask, it);
  const __m128i thresh_mask = _mm_cmpeq_epi8(diff, _mm_setzero_si128());
  __m128i filter_mask;
  NeedsFilter_SSE2(p1, p0, q0, q1, thresh, &filter_mask);
  *mask = _mm_and_si128(thresh_mask, filter_mask);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x40(%rsp), %r14
movd %r9d, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm1      # xmm1 = xmm0[0,0,0,0]
movdqa (%r14), %xmm0
pminub %xmm0, %xmm1
pcmpeqb %xmm0, %xmm1
movdqa %xmm1, (%rsp)
leaq 0x10(%rsp), %rbx
movq %rbx, %r9
callq 0xd87cd
movaps (%rsp), %xmm0
andps (%rbx), %xmm0
movaps %xmm0, (%r14)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: NeedsFilter_SSE2
static WEBP_INLINE void NeedsFilter_SSE2(const __m128i* const p1,
                                         const __m128i* const p0,
                                         const __m128i* const q0,
                                         const __m128i* const q1,
                                         int thresh, __m128i* const mask) {
  const __m128i m_thresh = _mm_set1_epi8((char)thresh);
  const __m128i t1 = MM_ABS(*p1, *q1);        // abs(p1 - q1)
  const __m128i kFE = _mm_set1_epi8((char)0xFE);
  const __m128i t2 = _mm_and_si128(t1, kFE);  // set lsb of each byte to zero
  const __m128i t3 = _mm_srli_epi16(t2, 1);   // abs(p1 - q1) / 2

  const __m128i t4 = MM_ABS(*p0, *q0);        // abs(p0 - q0)
  const __m128i t5 = _mm_adds_epu8(t4, t4);   // abs(p0 - q0) * 2
  const __m128i t6 = _mm_adds_epu8(t5, t3);   // abs(p0-q0)*2 + abs(p1-q1)/2

  const __m128i t7 = _mm_subs_epu8(t6, m_thresh);  // mask <= m_thresh
  *mask = _mm_cmpeq_epi8(t7, _mm_setzero_si128());
}

// Assembly:
movd %r8d, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa (%rcx), %xmm1
movdqa (%rdi), %xmm2
movdqa %xmm1, %xmm3
psubusb %xmm2, %xmm3
psubusb %xmm1, %xmm2
por %xmm3, %xmm2
psrlw $0x1, %xmm2
movdqa (%rdx), %xmm1
movdqa (%rsi), %xmm3
movdqa %xmm1, %xmm4
psubusb %xmm3, %xmm4
psubusb %xmm1, %xmm3
por %xmm4, %xmm3
paddusb %xmm3, %xmm3
pand 0x403af(%rip), %xmm2    # 0x118bd0
paddusb %xmm3, %xmm2
pminub %xmm2, %xmm0
pcmpeqb %xmm2, %xmm0
movdqa %xmm0, (%r9)
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: GetNotHEV_SSE2
static WEBP_INLINE void GetNotHEV_SSE2(const __m128i* const p1,
                                       const __m128i* const p0,
                                       const __m128i* const q0,
                                       const __m128i* const q1,
                                       int hev_thresh, __m128i* const not_hev) {
  const __m128i zero = _mm_setzero_si128();
  const __m128i t_1 = MM_ABS(*p1, *p0);
  const __m128i t_2 = MM_ABS(*q1, *q0);

  const __m128i h = _mm_set1_epi8(hev_thresh);
  const __m128i t_max = _mm_max_epu8(t_1, t_2);

  const __m128i t_max_h = _mm_subs_epu8(t_max, h);
  *not_hev = _mm_cmpeq_epi8(t_max_h, zero);  // not_hev <= t1 && not_hev <= t2
}

// Assembly:
movdqa (%rsi), %xmm0
movdqa (%rdi), %xmm1
movdqa %xmm0, %xmm2
psubusb %xmm1, %xmm2
psubusb %xmm0, %xmm1
por %xmm2, %xmm1
movdqa (%rdx), %xmm0
movdqa (%rcx), %xmm2
movdqa %xmm0, %xmm3
psubusb %xmm2, %xmm3
psubusb %xmm0, %xmm2
por %xmm3, %xmm2
pmaxub %xmm1, %xmm2
movd %r8d, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
pminub %xmm2, %xmm0
pcmpeqb %xmm2, %xmm0
movdqa %xmm0, (%r9)
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: DoSimpleFilter_SSE2
static WEBP_INLINE void DoSimpleFilter_SSE2(__m128i* const p0,
                                            __m128i* const q0,
                                            const __m128i* const fl) {
  const __m128i k3 = _mm_set1_epi8(3);
  const __m128i k4 = _mm_set1_epi8(4);
  __m128i v3 = _mm_adds_epi8(*fl, k3);
  __m128i v4 = _mm_adds_epi8(*fl, k4);

  SignedShift8b_SSE2(&v4);             // v4 >> 3
  SignedShift8b_SSE2(&v3);             // v3 >> 3
  *q0 = _mm_subs_epi8(*q0, v4);        // q0 -= v4
  *p0 = _mm_adds_epi8(*p0, v3);        // p0 += v3
}

// Assembly:
movdqa (%rdx), %xmm0
movdqa 0x4416c(%rip), %xmm1    # 0x11ca00
paddsb %xmm0, %xmm1
paddsb 0x44170(%rip), %xmm0    # 0x11ca10
punpcklbw %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1],xmm2[2],xmm0[2],xmm2[3],xmm0[3],xmm2[4],xmm0[4],xmm2[5],xmm0[5],xmm2[6],xmm0[6],xmm2[7],xmm0[7]
punpckhbw %xmm0, %xmm0    # xmm0 = xmm0[8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15]
psraw $0xb, %xmm2
psraw $0xb, %xmm0
packsswb %xmm0, %xmm2
punpcklbw %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3],xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
punpckhbw %xmm1, %xmm1    # xmm1 = xmm1[8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15]
psraw $0xb, %xmm0
psraw $0xb, %xmm1
packsswb %xmm1, %xmm0
movdqa (%rsi), %xmm1
psubsb %xmm2, %xmm1
movdqa %xmm1, (%rsi)
paddsb (%rdi), %xmm0
movdqa %xmm0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: Update2Pixels_SSE2
static WEBP_INLINE void Update2Pixels_SSE2(__m128i* const pi, __m128i* const qi,
                                           const __m128i* const a0_lo,
                                           const __m128i* const a0_hi) {
  const __m128i a1_lo = _mm_srai_epi16(*a0_lo, 7);
  const __m128i a1_hi = _mm_srai_epi16(*a0_hi, 7);
  const __m128i delta = _mm_packs_epi16(a1_lo, a1_hi);
  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
  *pi = _mm_adds_epi8(*pi, delta);
  *qi = _mm_subs_epi8(*qi, delta);
  FLIP_SIGN_BIT2(*pi, *qi);
}

// Assembly:
movdqa (%rdx), %xmm0
psraw $0x7, %xmm0
movdqa (%rcx), %xmm1
psraw $0x7, %xmm1
packsswb %xmm1, %xmm0
movdqa (%rdi), %xmm1
paddsb %xmm0, %xmm1
movdqa %xmm1, (%rdi)
movdqa (%rsi), %xmm1
psubsb %xmm0, %xmm1
movdqa %xmm1, (%rsi)
movaps 0x440ba(%rip), %xmm0    # 0x11c9d0
movaps (%rdi), %xmm1
xorps %xmm0, %xmm1
movaps %xmm1, (%rdi)
xorps (%rsi), %xmm0
movaps %xmm0, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: Load16x4_SSE2
static WEBP_INLINE void Load16x4_SSE2(const uint8_t* const r0,
                                      const uint8_t* const r8,
                                      int stride,
                                      __m128i* const p1, __m128i* const p0,
                                      __m128i* const q0, __m128i* const q1) {
  // Assume the pixels around the edge (|) are numbered as follows
  //                00 01 | 02 03
  //                10 11 | 12 13
  //                 ...  |  ...
  //                e0 e1 | e2 e3
  //                f0 f1 | f2 f3
  //
  // r0 is pointing to the 0th row (00)
  // r8 is pointing to the 8th row (80)

  // Load
  // p1 = 71 61 51 41 31 21 11 01 70 60 50 40 30 20 10 00
  // q0 = 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02
  // p0 = f1 e1 d1 c1 b1 a1 91 81 f0 e0 d0 c0 b0 a0 90 80
  // q1 = f3 e3 d3 c3 b3 a3 93 83 f2 e2 d2 c2 b2 a2 92 82
  Load8x4_SSE2(r0, stride, p1, q0);
  Load8x4_SSE2(r8, stride, p0, q1);

  {
    // p1 = f0 e0 d0 c0 b0 a0 90 80 70 60 50 40 30 20 10 00
    // p0 = f1 e1 d1 c1 b1 a1 91 81 71 61 51 41 31 21 11 01
    // q0 = f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02
    // q1 = f3 e3 d3 c3 b3 a3 93 83 73 63 53 43 33 23 13 03
    const __m128i t1 = *p1;
    const __m128i t2 = *q0;
    *p1 = _mm_unpacklo_epi64(t1, *p0);
    *p0 = _mm_unpackhi_epi64(t1, *p0);
    *q0 = _mm_unpacklo_epi64(t2, *q1);
    *q1 = _mm_unpackhi_epi64(t2, *q1);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq 0x40(%rsp), %r13
movl %edx, %esi
movq %rcx, %rdx
movq %r9, %rcx
callq 0xd8a7a
movq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %r13, %rcx
callq 0xd8a7a
movaps (%r15), %xmm0
movaps %xmm0, %xmm1
unpcklpd (%r14), %xmm1           # xmm1 = xmm1[0],mem[0]
movaps (%rbx), %xmm2
movaps %xmm1, (%r15)
unpckhpd (%r14), %xmm0           # xmm0 = xmm0[1],mem[1]
movaps %xmm0, (%r14)
movaps %xmm2, %xmm0
unpcklpd (%r13), %xmm0           # xmm0 = xmm0[0],mem[0]
movaps %xmm0, (%rbx)
unpckhpd (%r13), %xmm2           # xmm2 = xmm2[1],mem[1]
movaps %xmm2, (%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: Load8x4_SSE2
static WEBP_INLINE void Load8x4_SSE2(const uint8_t* const b, int stride,
                                     __m128i* const p, __m128i* const q) {
  // A0 = 63 62 61 60 23 22 21 20 43 42 41 40 03 02 01 00
  // A1 = 73 72 71 70 33 32 31 30 53 52 51 50 13 12 11 10
  const __m128i A0 = _mm_set_epi32(
      WebPMemToInt32(&b[6 * stride]), WebPMemToInt32(&b[2 * stride]),
      WebPMemToInt32(&b[4 * stride]), WebPMemToInt32(&b[0 * stride]));
  const __m128i A1 = _mm_set_epi32(
      WebPMemToInt32(&b[7 * stride]), WebPMemToInt32(&b[3 * stride]),
      WebPMemToInt32(&b[5 * stride]), WebPMemToInt32(&b[1 * stride]));

  // B0 = 53 43 52 42 51 41 50 40 13 03 12 02 11 01 10 00
  // B1 = 73 63 72 62 71 61 70 60 33 23 32 22 31 21 30 20
  const __m128i B0 = _mm_unpacklo_epi8(A0, A1);
  const __m128i B1 = _mm_unpackhi_epi8(A0, A1);

  // C0 = 33 23 13 03 32 22 12 02 31 21 11 01 30 20 10 00
  // C1 = 73 63 53 43 72 62 52 42 71 61 51 41 70 60 50 40
  const __m128i C0 = _mm_unpacklo_epi16(B0, B1);
  const __m128i C1 = _mm_unpackhi_epi16(B0, B1);

  // *p = 71 61 51 41 31 21 11 01 70 60 50 40 30 20 10 00
  // *q = 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02
  *p = _mm_unpacklo_epi32(C0, C1);
  *q = _mm_unpackhi_epi32(C0, C1);
}

// Assembly:
movslq %esi, %rax
imulq $0x6, %rax, %rsi
movd (%rdi,%rax,2), %xmm0
movd (%rdi,%rsi), %xmm1
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movd (%rdi,%rax,4), %xmm1
movd (%rdi), %xmm2
punpckldq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
imulq $0x7, %rax, %rsi
leaq (%rax,%rax,2), %r8
leaq (%rax,%rax,4), %r9
movd (%rdi,%rsi), %xmm1
movd (%rdi,%r8), %xmm3
punpckldq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
punpcklbw %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1],xmm0[2],xmm3[2],xmm0[3],xmm3[3],xmm0[4],xmm3[4],xmm0[5],xmm3[5],xmm0[6],xmm3[6],xmm0[7],xmm3[7]
movd (%rdi,%rax), %xmm1
movd (%rdi,%r9), %xmm3
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
punpcklbw %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3],xmm2[4],xmm1[4],xmm2[5],xmm1[5],xmm2[6],xmm1[6],xmm2[7],xmm1[7]
movdqa %xmm2, %xmm1
punpcklwd %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3]
punpckhwd %xmm0, %xmm2    # xmm2 = xmm2[4],xmm0[4],xmm2[5],xmm0[5],xmm2[6],xmm0[6],xmm2[7],xmm0[7]
movdqa %xmm1, %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movdqa %xmm0, (%rdx)
punpckhdq %xmm2, %xmm1    # xmm1 = xmm1[2],xmm2[2],xmm1[3],xmm2[3]
movdqa %xmm1, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: Store4x4_SSE2
static WEBP_INLINE void Store4x4_SSE2(__m128i* const x,
                                      uint8_t* dst, int stride) {
  int i;
  for (i = 0; i < 4; ++i, dst += stride) {
    WebPInt32ToMem(dst, _mm_cvtsi128_si32(*x));
    *x = _mm_srli_si128(*x, 4);
  }
}

// Assembly:
movslq %edx, %rax
pushq $0x4
popq %rcx
subl $0x1, %ecx
jb 0xd8b10
movl (%rdi), %edx
movl %edx, (%rsi)
movdqa (%rdi), %xmm0
psrldq $0x4, %xmm0             # xmm0 = xmm0[4,5,6,7,8,9,10,11,12,13,14,15],zero,zero,zero,zero
movdqa %xmm0, (%rdi)
addq %rax, %rsi
jmp 0xd8af5
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: DoFilter2_SSE2
static WEBP_INLINE void DoFilter2_SSE2(__m128i* const p1, __m128i* const p0,
                                       __m128i* const q0, __m128i* const q1,
                                       int thresh) {
  __m128i a, mask;
  const __m128i sign_bit = _mm_set1_epi8((char)0x80);
  // convert p1/q1 to int8_t (for GetBaseDelta_SSE2)
  const __m128i p1s = _mm_xor_si128(*p1, sign_bit);
  const __m128i q1s = _mm_xor_si128(*q1, sign_bit);

  NeedsFilter_SSE2(p1, p0, q0, q1, thresh, &mask);

  FLIP_SIGN_BIT2(*p0, *q0);
  GetBaseDelta_SSE2(&p1s, p0, q0, &q1s, &a);
  a = _mm_and_si128(a, mask);     // mask filter values we don't care about
  DoSimpleFilter_SSE2(p0, q0, &a);
  FLIP_SIGN_BIT2(*p0, *q0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movdqa 0x43d43(%rip), %xmm2    # 0x11c9d0
movdqa (%rdi), %xmm1
pxor %xmm2, %xmm1
movdqa (%rcx), %xmm0
pxor %xmm2, %xmm0
psubsb %xmm0, %xmm1
movdqa %xmm1, (%rsp)
leaq 0x10(%rsp), %r15
movq %r15, %r9
callq 0xd87cd
movdqa (%r14), %xmm0
movdqa 0x43d10(%rip), %xmm1    # 0x11c9d0
pxor %xmm1, %xmm0
movdqa %xmm0, (%r14)
movdqa (%rbx), %xmm0
pxor %xmm1, %xmm0
movdqa %xmm0, (%rbx)
psubsb (%r14), %xmm0
movdqa (%rsp), %xmm1
paddsb %xmm0, %xmm1
paddsb %xmm0, %xmm1
paddsb %xmm0, %xmm1
pand (%r15), %xmm1
leaq 0x20(%rsp), %rdx
movdqa %xmm1, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd8888
movaps (%r14), %xmm0
movaps 0x43cc1(%rip), %xmm1    # 0x11c9d0
xorps %xmm1, %xmm0
movaps %xmm0, (%r14)
xorps (%rbx), %xmm1
movaps %xmm1, (%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: Put16_SSE2
static WEBP_INLINE void Put16_SSE2(uint8_t v, uint8_t* dst) {
  int j;
  const __m128i values = _mm_set1_epi8((char)v);
  for (j = 0; j < 16; ++j) {
    _mm_storeu_si128((__m128i*)(dst + j * BPS), values);
  }
}

// Assembly:
movd %edi, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
xorl %eax, %eax
cmpq $0x200, %rax            # imm = 0x200
je 0xd8e31
movdqu %xmm0, (%rsi,%rax)
addq $0x20, %rax
jmp 0xd8e1e
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: Put8x8uv_SSE2
static WEBP_INLINE void Put8x8uv_SSE2(uint8_t v, uint8_t* dst) {
  int j;
  const __m128i values = _mm_set1_epi8((char)v);
  for (j = 0; j < 8; ++j) {
    _mm_storel_epi64((__m128i*)(dst + j * BPS), values);
  }
}

// Assembly:
movd %edi, %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
cmpq $0x100, %rcx            # imm = 0x100
je 0xd8e59
movq %rax, (%rsi,%rcx)
addq $0x20, %rcx
jmp 0xd8e46
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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        # 0xd8ead
leaq 0x98746(%rip), %rcx     # 0x1715b0
movq %rax, 0x8(%rcx)
leaq 0xbf(%rip), %rax        # 0xd8f34
movq %rax, 0x10(%rcx)
leaq 0x13d(%rip), %rax       # 0xd8fbd
movq %rax, 0x18(%rcx)
leaq 0x224(%rip), %rax       # 0xd90af
leaq 0x986fe(%rip), %rcx     # 0x171590
movq %rax, 0x8(%rcx)
leaq 0x2f7(%rip), %rax       # 0xd9194
movq %rax, 0x10(%rcx)
leaq 0x419(%rip), %rax       # 0xd92c1
movq %rax, 0x18(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r8b
testq %rdi, %rdi
je 0xd8eb9
movb (%rdi), %al
jmp 0xd8ebb
xorl %eax, %eax
addb %r8b, %al
movb %al, (%rdx)
cmpl $0x2, %ecx
jge 0xd8ec6
retq
movzbl %al, %eax
movd %eax, %xmm0
movl %ecx, %eax
pushq $0x9
popq %rcx
cmpq %rax, %rcx
ja 0xd8f19
movq -0x8(%rsi,%rcx), %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,%rcx)
psrlq $0x38, %xmm0
addq $0x8, %rcx
jmp 0xd8ed2
addq $-0x8, %rcx
cmpq %rax, %rcx
jae 0xd8ec5
movb -0x1(%rdx,%rcx), %dil
addb (%rsi,%rcx), %dil
movb %dil, (%rdx,%rcx)
incq %rcx
jmp 0xd8f1d
// File: /workspace/github_c_makefile_star2_O2/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 0xd8f96
testl %ecx, %ecx
js 0xd8f9d
movl %ecx, %r8d
andl $0x7fffffe0, %r8d       # imm = 0x7FFFFFE0
xorl %eax, %eax
cmpq %r8, %rax
jae 0xd8f7d
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
jmp 0xd8f49
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0xd8f95
movb (%rdi,%rax), %r8b
addb (%rsi,%rax), %r8b
movb %r8b, (%rdx,%rax)
incq %rax
jmp 0xd8f7f
retq
xorl %edi, %edi
jmp 0xd8ead
pushq %rax
leaq 0x43a9f(%rip), %rdi     # 0x11ca44
leaq 0x43aa3(%rip), %rsi     # 0x11ca4f
leaq 0x43ab3(%rip), %rcx     # 0x11ca66
movl $0xfe, %edx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/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 0xd9064
movb (%rdi), %al
addb (%rsi), %al
movb %al, (%rdx)
cmpl $0x2, %ecx
jl 0xd90ae
decl %ecx
movl %ecx, %r8d
andl $0x7ffffff8, %r8d       # imm = 0x7FFFFFF8
movzbl %al, %eax
movd %eax, %xmm0
xorl %eax, %eax
pxor %xmm1, %xmm1
movd 0x43a4a(%rip), %xmm2    # 0x11ca40
pushq $-0x7
popq %r9
cmpq %r8, %rax
jae 0xd906b
movq 0x1(%rdi,%rax), %xmm3
movq (%rdi,%rax), %xmm4
punpcklbw %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1],xmm3[2],xmm1[2],xmm3[3],xmm1[3],xmm3[4],xmm1[4],xmm3[5],xmm1[5],xmm3[6],xmm1[6],xmm3[7],xmm1[7]
punpcklbw %xmm1, %xmm4    # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1],xmm4[2],xmm1[2],xmm4[3],xmm1[3],xmm4[4],xmm1[4],xmm4[5],xmm1[5],xmm4[6],xmm1[6],xmm4[7],xmm1[7]
psubw %xmm4, %xmm3
movq 0x1(%rsi,%rax), %xmm5
pxor %xmm4, %xmm4
movl %r9d, %r10d
movdqa %xmm2, %xmm6
paddw %xmm3, %xmm0
packuswb %xmm1, %xmm0
paddb %xmm5, %xmm0
pand %xmm6, %xmm0
por %xmm0, %xmm4
testl %r10d, %r10d
je 0xd9053
psllq $0x8, %xmm0
pslldq $0x1, %xmm6             # xmm6 = zero,xmm6[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
punpcklbw %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3],xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
incl %r10d
jmp 0xd9027
psrldq $0x7, %xmm0             # xmm0 = xmm0[7,8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero
movq %xmm4, 0x1(%rdx,%rax)
addq $0x8, %rax
jmp 0xd8ffa
xorl %edi, %edi
jmp 0xd8ead
movl %ecx, %ecx
xorl %r8d, %r8d
movl $0xff, %r9d
cmpq %rcx, %rax
jae 0xd90ae
movzbl (%rdx,%rax), %r10d
movzbl 0x1(%rdi,%rax), %r11d
addl %r10d, %r11d
movzbl (%rdi,%rax), %r10d
subl %r10d, %r11d
testl %r11d, %r11d
cmovlel %r8d, %r11d
cmpl %r9d, %r11d
cmovgel %r9d, %r11d
addb 0x1(%rsi,%rax), %r11b
movb %r11b, 0x1(%rdx,%rax)
incq %rax
jmp 0xd9076
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/filters_sse2.c
// Function: HorizontalFilter_SSE2
static WEBP_INLINE void DoHorizontalFilter_SSE2(const uint8_t* in,
                                                int width, int height,
                                                int stride,
                                                int row, int num_rows,
                                                uint8_t* out) {
  const size_t start_offset = row * stride;
  const int last_row = row + num_rows;
  DCHECK(in, out);
  in += start_offset;
  out += start_offset;

  if (row == 0) {
    // Leftmost pixel is the same as input for topmost scanline.
    out[0] = in[0];
    PredictLineLeft_SSE2(in + 1, out + 1, width - 1);
    row = 1;
    in += stride;
    out += stride;
  }

  // Filter line-by-line.
  while (row < last_row) {
    // Leftmost pixel is predicted from above.
    out[0] = in[0] - in[-stride];
    PredictLineLeft_SSE2(in + 1, out + 1, width - 1);
    ++row;
    in += stride;
    out += stride;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd9153
movq %r8, %r14
testq %r8, %r8
je 0xd915c
movl %esi, %ebp
testl %esi, %esi
jle 0xd9165
movl %edx, %ebx
testl %edx, %edx
jle 0xd916e
movl %ecx, %r12d
cmpl %ebp, %ecx
jl 0xd9177
movq %rdi, %r15
movb (%rdi), %al
movb %al, (%r14)
incq %rdi
leaq 0x1(%r14), %rsi
decl %ebp
movl %ebp, %edx
callq 0xd9486
movl %r12d, %r13d
negl %r12d
movslq %r12d, %r12
addq %r13, %r14
incq %r14
decl %ebx
addq %r13, %r15
incq %r15
subl $0x1, %ebx
jb 0xd9144
movb -0x1(%r15), %al
subb -0x1(%r15,%r12), %al
movb %al, -0x1(%r14)
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xd9486
addq %r13, %r14
addq %r13, %r15
jmp 0xd911d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x42624(%rip), %rdi     # 0x11b77e
jmp 0xd917e
leaq 0x4267c(%rip), %rdi     # 0x11b7df
jmp 0xd917e
leaq 0x42681(%rip), %rdi     # 0x11b7ed
jmp 0xd917e
leaq 0x42682(%rip), %rdi     # 0x11b7f7
jmp 0xd917e
leaq 0x42684(%rip), %rdi     # 0x11b802
leaq 0x438ca(%rip), %rsi     # 0x11ca4f
leaq 0x43927(%rip), %rcx     # 0x11cab3
pushq $0x53
popq %rdx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/filters_sse2.c
// Function: VerticalFilter_SSE2
static WEBP_INLINE void DoVerticalFilter_SSE2(const uint8_t* in,
                                              int width, int height, int stride,
                                              int row, int num_rows,
                                              uint8_t* out) {
  const size_t start_offset = row * stride;
  const int last_row = row + num_rows;
  DCHECK(in, out);
  in += start_offset;
  out += start_offset;

  if (row == 0) {
    // Very first top-left pixel is copied.
    out[0] = in[0];
    // Rest of top scan-line is left-predicted.
    PredictLineLeft_SSE2(in + 1, out + 1, width - 1);
    row = 1;
    in += stride;
    out += stride;
  }

  // Filter line-by-line.
  while (row < last_row) {
    PredictLineTop_SSE2(in, in - stride, out, width);
    ++row;
    in += stride;
    out += stride;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xd9280
movq %r8, %rbx
testq %r8, %r8
je 0xd9289
movl %esi, %r14d
testl %esi, %esi
jle 0xd9292
movl %edx, %ebp
testl %edx, %edx
jle 0xd929b
movl %ecx, %r12d
cmpl %r14d, %ecx
jl 0xd92a4
movq %rdi, %r15
movb (%rdi), %al
movb %al, (%rbx)
incq %rdi
leaq 0x1(%rbx), %rsi
leal -0x1(%r14), %edx
callq 0xd9486
movl %r12d, %eax
movl %r14d, %ecx
andl $0x7fffffe0, %r14d      # imm = 0x7FFFFFE0
leaq (%rbx,%rax), %rdx
leaq (%r15,%rax), %rsi
pushq $0x1
popq %rdi
xorl %r8d, %r8d
movq %r15, %r12
cmpl %ebp, %edi
je 0xd9277
leaq (%r12,%rax), %r9
addq %rax, %rbx
movq %r8, %r10
xorl %r11d, %r11d
cmpq %r14, %r11
jae 0xd9268
movdqu (%r9,%r11), %xmm0
movdqu 0x10(%r9,%r11), %xmm1
movdqu (%r12,%r11), %xmm2
psubb %xmm2, %xmm0
movdqu 0x10(%r12,%r11), %xmm2
psubb %xmm2, %xmm1
movdqu %xmm0, (%rbx,%r11)
movdqu %xmm1, 0x10(%rbx,%r11)
addq $0x20, %r11
addq $0x20, %r10
jmp 0xd9218
movb (%rsi,%r10), %r12b
subb (%r15,%r10), %r12b
movb %r12b, (%rdx,%r10)
incq %r11
incq %r10
cmpq %rcx, %r11
jb 0xd9256
incl %edi
addq %rax, %r8
movq %r9, %r12
jmp 0xd9207
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x424f7(%rip), %rdi     # 0x11b77e
jmp 0xd92ab
leaq 0x4254f(%rip), %rdi     # 0x11b7df
jmp 0xd92ab
leaq 0x42554(%rip), %rdi     # 0x11b7ed
jmp 0xd92ab
leaq 0x42555(%rip), %rdi     # 0x11b7f7
jmp 0xd92ab
leaq 0x42557(%rip), %rdi     # 0x11b802
leaq 0x4379d(%rip), %rsi     # 0x11ca4f
leaq 0x4384c(%rip), %rcx     # 0x11cb05
pushq $0x74
popq %rdx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/filters_sse2.c
// Function: PredictLineLeft_SSE2
static void PredictLineLeft_SSE2(const uint8_t* src, uint8_t* dst, int length) {
  int i;
  const int max_pos = length & ~31;
  assert(length >= 0);
  for (i = 0; i < max_pos; i += 32) {
    const __m128i A0 = _mm_loadu_si128((const __m128i*)(src + i +  0    ));
    const __m128i B0 = _mm_loadu_si128((const __m128i*)(src + i +  0 - 1));
    const __m128i A1 = _mm_loadu_si128((const __m128i*)(src + i + 16    ));
    const __m128i B1 = _mm_loadu_si128((const __m128i*)(src + i + 16 - 1));
    const __m128i C0 = _mm_sub_epi8(A0, B0);
    const __m128i C1 = _mm_sub_epi8(A1, B1);
    _mm_storeu_si128((__m128i*)(dst + i +  0), C0);
    _mm_storeu_si128((__m128i*)(dst + i + 16), C1);
  }
  for (; i < length; ++i) dst[i] = src[i] - src[i - 1];
}

// Assembly:
movl %edx, %eax
andl $-0x20, %eax
movslq %eax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jge 0xd94c5
movdqu -0x1(%rdi,%rax), %xmm0
movdqu (%rdi,%rax), %xmm1
psubb %xmm0, %xmm1
movdqu 0xf(%rdi,%rax), %xmm0
movdqu 0x10(%rdi,%rax), %xmm2
psubb %xmm0, %xmm2
movdqu %xmm1, (%rsi,%rax)
movdqu %xmm2, 0x10(%rsi,%rax)
addq $0x20, %rax
jmp 0xd9490
movslq %edx, %rcx
cmpq %rcx, %rax
jge 0xd94dc
movb (%rdi,%rax), %dl
subb -0x1(%rdi,%rax), %dl
movb %dl, (%rsi,%rax)
incq %rax
jmp 0xd94c8
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x3f449(%rip), %xmm1    # 0x118bd0
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 0x433d6(%rip), %xmm3    # 0x11cbb0
packuswb %xmm3, %xmm3
movd %xmm3, %eax
retq