LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/dsp/rescaler.c
// Function: WebPRescalerExportRowShrink_C
void WebPRescalerExportRowShrink_C(WebPRescaler* const wrk) {
  int x_out;
  uint8_t* const dst = wrk->dst;
  rescaler_t* const irow = wrk->irow;
  const int x_out_max = wrk->dst_width * wrk->num_channels;
  const rescaler_t* const frow = wrk->frow;
  const uint32_t yscale = wrk->fy_scale * (-wrk->y_accum);
  assert(!WebPRescalerOutputDone(wrk));
  assert(wrk->y_accum <= 0);
  assert(!wrk->y_expand);
  if (yscale) {
    for (x_out = 0; x_out < x_out_max; ++x_out) {
      const uint32_t frac = (uint32_t)MULT_FIX_FLOOR(frow[x_out], yscale);
      const int v = (int)MULT_FIX(irow[x_out] - frac, wrk->fxy_scale);
      dst[x_out] = (v > 255) ? 255u : (uint8_t)v;
      irow[x_out] = frac;   // new fractional start
    }
  } else {
    for (x_out = 0; x_out < x_out_max; ++x_out) {
      const int v = (int)MULT_FIX(irow[x_out], wrk->fxy_scale);
      dst[x_out] = (v > 255) ? 255u : (uint8_t)v;
      irow[x_out] = 0;
    }
  }
}

// Assembly:
pushq %rbx
movl 0x40(%rdi), %eax
cmpl 0x38(%rdi), %eax
jge 0xdcb30
movl 0x18(%rdi), %esi
testl %esi, %esi
jg 0xdcb4f
cmpl $0x0, 0x4(%rdi)
jne 0xdcb6e
movq 0x48(%rdi), %rax
movl 0x8(%rdi), %r8d
imull 0x34(%rdi), %r8d
movq 0x58(%rdi), %rcx
imull 0x10(%rdi), %esi
testl %esi, %esi
je 0xdcae9
testl %r8d, %r8d
jle 0xdcb2e
movq 0x60(%rdi), %rdx
negl %esi
movl %esi, %esi
movl %r8d, %r8d
xorl %r9d, %r9d
movl (%rdx,%r9,4), %r10d
imulq %rsi, %r10
shrq $0x20, %r10
movl (%rcx,%r9,4), %ebx
subl %r10d, %ebx
movl 0x14(%rdi), %r11d
imulq %rbx, %r11
subq $-0x80000000, %r11      # imm = 0x80000000
shrq $0x20, %r11
movl $0xff, %ebx
cmpl $0x100, %r11d           # imm = 0x100
jge 0xdcad7
movl %r11d, %ebx
movb %bl, (%rax,%r9)
movl %r10d, (%rcx,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0xdcaa0
jmp 0xdcb2e
testl %r8d, %r8d
jle 0xdcb2e
movl %r8d, %edx
xorl %esi, %esi
movl $0xff, %r8d
movl (%rcx,%rsi,4), %r9d
movl 0x14(%rdi), %r10d
imulq %r9, %r10
subq $-0x80000000, %r10      # imm = 0x80000000
shrq $0x20, %r10
cmpl $0x100, %r10d           # imm = 0x100
cmovgel %r8d, %r10d
movb %r10b, (%rax,%rsi)
movl $0x0, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0xdcaf9
popq %rbx
retq
leaq 0x5054e(%rip), %rdi     # 0x12d085
leaq 0x50454(%rip), %rsi     # 0x12cf92
leaq 0x505b7(%rip), %rcx     # 0x12d0fc
movl $0x87, %edx
callq 0x55710
leaq 0x50584(%rip), %rdi     # 0x12d0da
leaq 0x50435(%rip), %rsi     # 0x12cf92
leaq 0x50598(%rip), %rcx     # 0x12d0fc
movl $0x88, %edx
callq 0x55710
leaq 0x505bf(%rip), %rdi     # 0x12d134
leaq 0x50416(%rip), %rsi     # 0x12cf92
leaq 0x50579(%rip), %rcx     # 0x12d0fc
movl $0x89, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/dsp/rescaler.c
// Function: WebPRescalerExportRow
void WebPRescalerExportRow(WebPRescaler* const wrk) {
  if (wrk->y_accum <= 0) {
    assert(!WebPRescalerOutputDone(wrk));
    if (wrk->y_expand) {
      WebPRescalerExportRowExpand(wrk);
    } else if (wrk->fxy_scale) {
      WebPRescalerExportRowShrink(wrk);
    } else {  // special case
      int i;
      assert(wrk->src_height == wrk->dst_height && wrk->x_add == 1);
      assert(wrk->src_width == 1 && wrk->dst_width <= 2);
      for (i = 0; i < wrk->num_channels * wrk->dst_width; ++i) {
        wrk->dst[i] = wrk->irow[i];
        wrk->irow[i] = 0;
      }
    }
    wrk->y_accum += wrk->y_add;
    wrk->dst += wrk->dst_stride;
    ++wrk->dst_y;
  }
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x18(%rdi)
jg 0xdcc17
movq %rdi, %rbx
movl 0x38(%rdi), %eax
cmpl %eax, 0x40(%rdi)
jge 0xdcc70
cmpl $0x0, 0x4(%rbx)
je 0xdcbf4
leaq 0x9f9fe(%rip), %rax     # 0x17c5f0
jmp 0xdcc01
cmpl $0x0, 0x14(%rbx)
je 0xdcc19
leaq 0x9f9f7(%rip), %rax     # 0x17c5f8
movq %rbx, %rdi
callq *(%rax)
movl 0x1c(%rbx), %eax
addl %eax, 0x18(%rbx)
movslq 0x50(%rbx), %rax
addq %rax, 0x48(%rbx)
incl 0x40(%rbx)
popq %rbx
retq
cmpl %eax, 0x30(%rbx)
jne 0xdcc8f
cmpl $0x1, 0x24(%rbx)
jne 0xdcc8f
cmpl $0x1, 0x2c(%rbx)
jne 0xdccae
cmpl $0x2, 0x34(%rbx)
jg 0xdccae
movl 0x34(%rbx), %eax
imull 0x8(%rbx), %eax
testl %eax, %eax
jle 0xdcc06
xorl %eax, %eax
movq 0x48(%rbx), %rcx
movq 0x58(%rbx), %rdx
movb (%rdx,%rax,4), %dl
movb %dl, (%rcx,%rax)
movq 0x58(%rbx), %rcx
movl $0x0, (%rcx,%rax,4)
incq %rax
movslq 0x8(%rbx), %rcx
movslq 0x34(%rbx), %rdx
imulq %rcx, %rdx
cmpq %rdx, %rax
jl 0xdcc41
jmp 0xdcc06
leaq 0x5040e(%rip), %rdi     # 0x12d085
leaq 0x50314(%rip), %rsi     # 0x12cf92
leaq 0x504ff(%rip), %rcx     # 0x12d184
movl $0xac, %edx
callq 0x55710
leaq 0x5051e(%rip), %rdi     # 0x12d1b4
leaq 0x502f5(%rip), %rsi     # 0x12cf92
leaq 0x504e0(%rip), %rcx     # 0x12d184
movl $0xb3, %edx
callq 0x55710
leaq 0x50535(%rip), %rdi     # 0x12d1ea
leaq 0x502d6(%rip), %rsi     # 0x12cf92
leaq 0x504c1(%rip), %rcx     # 0x12d184
movl $0xb4, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/dsp/rescaler.c
// Function: WebPRescalerDspInit
WEBP_DSP_INIT_FUNC(WebPRescalerDspInit) {
#if !defined(WEBP_REDUCE_SIZE)
#if !WEBP_NEON_OMIT_C_CODE
  WebPRescalerExportRowExpand = WebPRescalerExportRowExpand_C;
  WebPRescalerExportRowShrink = WebPRescalerExportRowShrink_C;
#endif

  WebPRescalerImportRowExpand = WebPRescalerImportRowExpand_C;
  WebPRescalerImportRowShrink = WebPRescalerImportRowShrink_C;

  if (VP8GetCPUInfo != NULL) {
#if defined(WEBP_HAVE_SSE2)
    if (VP8GetCPUInfo(kSSE2)) {
      WebPRescalerDspInitSSE2();
    }
#endif
#if defined(WEBP_USE_MIPS32)
    if (VP8GetCPUInfo(kMIPS32)) {
      WebPRescalerDspInitMIPS32();
    }
#endif
#if defined(WEBP_USE_MIPS_DSP_R2)
    if (VP8GetCPUInfo(kMIPSdspR2)) {
      WebPRescalerDspInitMIPSdspR2();
    }
#endif
#if defined(WEBP_USE_MSA)
    if (VP8GetCPUInfo(kMSA)) {
      WebPRescalerDspInitMSA();
    }
#endif
  }

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

  assert(WebPRescalerExportRowExpand != NULL);
  assert(WebPRescalerExportRowShrink != NULL);
  assert(WebPRescalerImportRowExpand != NULL);
  assert(WebPRescalerImportRowShrink != NULL);
#endif   // WEBP_REDUCE_SIZE
}

// Assembly:
pushq %rbx
movq 0x926c3(%rip), %rcx     # 0x16f398
movq 0x8fa7c(%rip), %rbx     # 0x16c758
movq (%rbx), %rax
cmpq %rax, %rcx
je 0xdcd60
leaq -0x410(%rip), %rcx      # 0xdc8db
movq %rcx, 0x9f8fe(%rip)     # 0x17c5f0
leaq -0x2ab(%rip), %rcx      # 0xdca4e
movq %rcx, 0x9f8f8(%rip)     # 0x17c5f8
leaq -0x6cb(%rip), %rcx      # 0xdc63c
movq %rcx, 0x9f8da(%rip)     # 0x17c5e8
leaq -0x566(%rip), %rcx      # 0xdc7af
movq %rcx, 0x9f8c4(%rip)     # 0x17c5e0
testq %rax, %rax
je 0xdcd2e
xorl %edi, %edi
callq *%rax
testl %eax, %eax
je 0xdcd2e
callq 0xe8360
cmpq $0x0, 0x9f8ba(%rip)     # 0x17c5f0
je 0xdcd62
cmpq $0x0, 0x9f8b8(%rip)     # 0x17c5f8
je 0xdcd81
cmpq $0x0, 0x9f89e(%rip)     # 0x17c5e8
je 0xdcda0
cmpq $0x0, 0x9f88c(%rip)     # 0x17c5e0
je 0xdcdbf
movq (%rbx), %rax
movq %rax, 0x92638(%rip)     # 0x16f398
popq %rbx
retq
leaq 0x504ac(%rip), %rdi     # 0x12d215
leaq 0x50222(%rip), %rsi     # 0x12cf92
leaq 0x504c2(%rip), %rcx     # 0x12d239
movl $0xf7, %edx
callq 0x55710
leaq 0x504d5(%rip), %rdi     # 0x12d25d
leaq 0x50203(%rip), %rsi     # 0x12cf92
leaq 0x504a3(%rip), %rcx     # 0x12d239
movl $0xf8, %edx
callq 0x55710
leaq 0x504da(%rip), %rdi     # 0x12d281
leaq 0x501e4(%rip), %rsi     # 0x12cf92
leaq 0x50484(%rip), %rcx     # 0x12d239
movl $0xf9, %edx
callq 0x55710
leaq 0x504df(%rip), %rdi     # 0x12d2a5
leaq 0x501c5(%rip), %rsi     # 0x12cf92
leaq 0x50465(%rip), %rcx     # 0x12d239
movl $0xfa, %edx
callq 0x55710
nop
// File: /workspace/github_c_makefile_star2_O1/enzo1982[P]smooth/libraries/libwebp/src/dsp/upsampling.c
// Function: WebPYuv444ToRgba4444_C
static void EmptyYuv444Func(const uint8_t* y,
                            const uint8_t* u, const uint8_t* v,
                            uint8_t* dst, int len) {
  (void)y;
  (void)u;
  (void)v;
  (void)dst;
  (void)len;
}

// Assembly:
testl %r8d, %r8d
jle 0xdd6a3
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %eax
xorl %r8d, %r8d
movl $0x4000, %r9d           # imm = 0x4000
xorl %r10d, %r10d
movzbl (%rdi,%r10), %r11d
movzbl (%rdx,%r10), %ebp
imull $0x4a85, %r11d, %ebx    # imm = 0x4A85
shrl $0x8, %ebx
imull $0x6625, %ebp, %r14d    # imm = 0x6625
shrl $0x8, %r14d
addl %ebx, %r14d
subl $0x379a, %r14d          # imm = 0x379A
movl $0xf0, %r15d
cmovbl %r8d, %r15d
movl %r14d, %r11d
shrl $0x6, %r11d
cmpl %r9d, %r14d
cmovael %r15d, %r11d
movzbl (%rsi,%r10), %r14d
imull $0x1913, %r14d, %r15d   # imm = 0x1913
shrl $0x8, %r15d
imull $0x3408, %ebp, %r12d    # imm = 0x3408
shrl $0x8, %r12d
addl %r15d, %r12d
movl %ebx, %ebp
subl %r12d, %ebp
negl %r12d
leal (%rbx,%r12), %r15d
addl $0x2204, %r15d          # imm = 0x2204
movl %r15d, %r12d
shrl $0xa, %r12d
cmpl $0xffffddfc, %ebp       # imm = 0xFFFFDDFC
movl $0xf, %ebp
cmovll %r8d, %ebp
cmpl %r9d, %r15d
cmovbl %r12d, %ebp
imull $0x811a, %r14d, %r14d   # imm = 0x811A
shrl $0x8, %r14d
addl %ebx, %r14d
subl $0x4515, %r14d          # imm = 0x4515
setb %bl
movl %r14d, %r15d
shrl $0x6, %r15d
shlb $0x4, %bl
addb $-0x10, %bl
andl $0xf0, %r11d
orl %ebp, %r11d
cmpl %r9d, %r14d
movb %r11b, (%rcx,%r10,2)
movzbl %bl, %r11d
cmovbl %r15d, %r11d
orb $0xf, %r11b
movb %r11b, 0x1(%rcx,%r10,2)
incq %r10
cmpq %r10, %rax
jne 0xdd5b9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x91be3(%rip), %rcx     # 0x16f3a0
movq 0x8ef94(%rip), %rbx     # 0x16c758
movq (%rbx), %rax
cmpq %rax, %rcx
je 0xdd86a
leaq -0x734(%rip), %rcx      # 0xdd0a3
movq %rcx, 0x9ee9a(%rip)     # 0x17c678
leaq -0x644(%rip), %rdx      # 0xdd1a1
movq %rdx, 0x9ee9c(%rip)     # 0x17c688
leaq -0x552(%rip), %rsi      # 0xdd2a1
movq %rsi, 0x9ee76(%rip)     # 0x17c670
leaq -0x464(%rip), %rsi      # 0xdd39d
movq %rsi, 0x9ee78(%rip)     # 0x17c680
leaq -0x374(%rip), %rsi      # 0xdd49b
movq %rsi, 0x9ee7a(%rip)     # 0x17c690
leaq -0x284(%rip), %rdi      # 0xdd599
movq %rdi, 0x9ee74(%rip)     # 0x17c698
leaq -0x187(%rip), %r8       # 0xdd6a4
movq %r8, 0x9ee6e(%rip)      # 0x17c6a0
movq %rcx, 0x9ee6f(%rip)     # 0x17c6a8
movq %rdx, 0x9ee70(%rip)     # 0x17c6b0
movq %rsi, 0x9ee71(%rip)     # 0x17c6b8
movq %rdi, 0x9ee72(%rip)     # 0x17c6c0
testq %rax, %rax
je 0xdd860
xorl %edi, %edi
callq *%rax
testl %eax, %eax
je 0xdd860
callq 0xecf22
movq (%rbx), %rax
movq %rax, 0x91b36(%rip)     # 0x16f3a0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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), %r13d
testl %r13d, %r13d
jle 0xe14cc
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movslq %esi, %rcx
movq %rcx, 0x10(%rsp)
movslq %r8d, %rcx
movq %rcx, 0x8(%rsp)
movslq 0x50(%rsp), %rcx
movq %rcx, (%rsp)
xorl %ebp, %ebp
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl 0x58(%rsp), %r8d
callq *0x68(%rsp)
addq 0x10(%rsp), %r12
testb $0x1, %bpl
movq 0x8(%rsp), %rax
movl $0x0, %ecx
cmoveq %rcx, %rax
addq %rax, %r14
addq %rax, %r15
addq (%rsp), %rbx
incl %ebp
cmpl %ebp, %r13d
jne 0xe148f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe1800
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 0xe17b3
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 0xe17ea
movl $0xff, %r10d
movb %r10b, (%rdx,%r9)
incq %r9
cmpq %r9, %rax
jne 0xe1769
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8dbaf(%rip), %rcx     # 0x16f3b8
movq 0x8af48(%rip), %rbx     # 0x16c758
movq (%rbx), %rax
cmpq %rax, %rcx
je 0xe18b4
leaq 0x145d(%rip), %rcx      # 0xe2c80
movq %rcx, 0x9af36(%rip)     # 0x17c760
leaq -0x29f(%rip), %rcx      # 0xe1592
movq %rcx, 0x9af30(%rip)     # 0x17c768
leaq 0x149c(%rip), %rcx      # 0xe2cdb
movq %rcx, 0x9af02(%rip)     # 0x17c748
leaq 0x14d6(%rip), %rcx      # 0xe2d23
movq %rcx, 0x9aefc(%rip)     # 0x17c750
leaq -0x10d(%rip), %rcx      # 0xe174e
movq %rcx, 0x9aef6(%rip)     # 0x17c758
testq %rax, %rax
je 0xe1874
xorl %edi, %edi
callq *%rax
testl %eax, %eax
je 0xe1874
callq 0xefaff
cmpq $0x0, 0x9aee4(%rip)     # 0x17c760
je 0xe18b6
cmpq $0x0, 0x9aee2(%rip)     # 0x17c768
je 0xe18d5
cmpq $0x0, 0x9aeb8(%rip)     # 0x17c748
je 0xe18f4
cmpq $0x0, 0x9aeb6(%rip)     # 0x17c750
je 0xe1913
cmpq $0x0, 0x9aeb4(%rip)     # 0x17c758
je 0xe1932
movq (%rbx), %rax
movq %rax, 0x8db04(%rip)     # 0x16f3b8
popq %rbx
retq
leaq 0x4c022(%rip), %rdi     # 0x12d8df
leaq 0x4c036(%rip), %rsi     # 0x12d8fa
leaq 0x4c03d(%rip), %rcx     # 0x12d908
movl $0xf0, %edx
callq 0x55710
leaq 0x4c055(%rip), %rdi     # 0x12d931
leaq 0x4c017(%rip), %rsi     # 0x12d8fa
leaq 0x4c01e(%rip), %rcx     # 0x12d908
movl $0xf1, %edx
callq 0x55710
leaq 0x4c052(%rip), %rdi     # 0x12d94d
leaq 0x4bff8(%rip), %rsi     # 0x12d8fa
leaq 0x4bfff(%rip), %rcx     # 0x12d908
movl $0xf2, %edx
callq 0x55710
leaq 0x4c04f(%rip), %rdi     # 0x12d969
leaq 0x4bfd9(%rip), %rsi     # 0x12d8fa
leaq 0x4bfe0(%rip), %rcx     # 0x12d908
movl $0xf3, %edx
callq 0x55710
leaq 0x4c04c(%rip), %rdi     # 0x12d985
leaq 0x4bfba(%rip), %rsi     # 0x12d8fa
leaq 0x4bfc1(%rip), %rcx     # 0x12d908
movl $0xf4, %edx
callq 0x55710
// File: /workspace/github_c_makefile_star2_O1/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 0xe2cda
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 0xe2c8d
retq
// File: /workspace/github_c_makefile_star2_O1/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        # 0xe2e1b
leaq 0x9947a(%rip), %rcx     # 0x17c1f8
movq %rax, (%rcx)
leaq 0x112(%rip), %rax       # 0xe2e9a
leaq 0x99471(%rip), %rcx     # 0x17c200
movq %rax, (%rcx)
leaq 0x17c(%rip), %rax       # 0xe2f15
leaq 0x99468(%rip), %rcx     # 0x17c208
movq %rax, (%rcx)
leaq 0x300(%rip), %rax       # 0xe30aa
leaq 0x99467(%rip), %rcx     # 0x17c218
movq %rax, (%rcx)
leaq 0x3ca(%rip), %rax       # 0xe3185
leaq 0x9945e(%rip), %rcx     # 0x17c220
movq %rax, (%rcx)
leaq 0x4cb(%rip), %rax       # 0xe3297
leaq 0x99455(%rip), %rcx     # 0x17c228
movq %rax, (%rcx)
leaq 0x577(%rip), %rax       # 0xe3354
leaq 0x9944c(%rip), %rcx     # 0x17c230
movq %rax, (%rcx)
leaq 0x63a(%rip), %rax       # 0xe3428
leaq 0x9944b(%rip), %rcx     # 0x17c240
movq %rax, (%rcx)
leaq 0x670(%rip), %rax       # 0xe346f
leaq 0x99442(%rip), %rcx     # 0x17c248
movq %rax, (%rcx)
leaq 0x720(%rip), %rax       # 0xe3530
leaq 0x99439(%rip), %rcx     # 0x17c250
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe2e8a
movl %esi, %eax
xorl %ecx, %ecx
pxor %xmm0, %xmm0
movdqa 0x4ab72(%rip), %xmm1    # 0x12d9b0
movdqa 0x4ab7a(%rip), %xmm2    # 0x12d9c0
movdqa 0x4ab82(%rip), %xmm3    # 0x12d9d0
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 0xe2e4e
subl %ecx, %esi
jle 0xe2e99
movl %ecx, %eax
leaq (%rdi,%rax,4), %rdi
jmp 0xd7bf0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe2f01
movl %edx, %eax
xorl %r8d, %r8d
pxor %xmm0, %xmm0
movdqa 0x4ab01(%rip), %xmm1    # 0x12d9c0
movdqa 0x4ab09(%rip), %xmm2    # 0x12d9d0
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 0xe2ec7
subl %r8d, %edx
jle 0xe2f14
movl %r8d, %eax
addq %rax, %rdi
addq %rax, %rsi
jmp 0xd7ca4
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe334e
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 0x4a7b2(%rip), %xmm0    # 0x12da70
xorl %r14d, %r14d
movl $0xff, %esi
movdqa 0x4a772(%rip), %xmm1    # 0x12da40
xorl %r15d, %r15d
testl %eax, %eax
jle 0xe3305
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 0xe32d5
cmpl %edx, %r15d
jge 0xe3320
movl %r15d, %r15d
movzbl (%rdi,%r15,4), %ebp
movb %bpl, (%r8,%r15)
andl %ebp, %esi
incq %r15
cmpq %r15, %rbx
jne 0xe330d
addq %r10, %rdi
addq %r9, %r8
incl %r14d
cmpl %ecx, %r14d
jne 0xe32ce
pcmpeqb 0x4a6ca(%rip), %xmm0    # 0x12da00
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_O1/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 0xe33cc
xorl %r8d, %r8d
movdqa 0x4a6d4(%rip), %xmm0    # 0x12da40
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 0xe336f
movl %r8d, %r9d
orl $0x8, %r9d
cmpl %edx, %r9d
jle 0xe33dd
movl %r8d, %r9d
jmp 0xe3410
movdqu (%rcx), %xmm0
movdqu 0x10(%rcx), %xmm1
psrld $0x8, %xmm0
psrld $0x8, %xmm1
movdqa 0x4a648(%rip), %xmm2    # 0x12da40
pand %xmm2, %xmm0
pand %xmm2, %xmm1
packssdw %xmm1, %xmm0
packuswb %xmm0, %xmm0
movl %r8d, %ecx
movq %xmm0, (%rsi,%rcx)
cmpl %edx, %r9d
jge 0xe3427
movl %r9d, %ecx
movb 0x1(%rdi,%rcx,4), %dl
movb %dl, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0xe3418
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe3458
movdqu (%rdi,%rcx), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ecx
xorl $0xffff, %ecx           # imm = 0xFFFF
movq %rdx, %rcx
je 0xe3431
movl $0x1, %eax
retq
xorl %eax, %eax
cmpl %esi, %ecx
jge 0xe346e
movl %esi, %edx
cmpb $-0x1, (%rdi,%rcx)
jne 0xe3452
incq %rcx
cmpq %rcx, %rdx
jne 0xe3460
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4a5bd(%rip), %xmm0    # 0x12da40
pcmpeqd %xmm1, %xmm1
leaq 0x40(%rsi), %rax
cmpq %rcx, %rax
jg 0xe34d8
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 0xe3487
jmp 0xe3513
pcmpeqd %xmm1, %xmm1
leaq 0x20(%rsi), %rax
cmpq %rcx, %rax
jg 0xe3519
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 0xe34dc
movl $0x1, %eax
retq
xorl %eax, %eax
cmpl %esi, %edx
jl 0xe3518
cmpb $-0x1, (%rdi,%rsi)
jne 0xe3513
addq $0x4, %rsi
cmpq %rcx, %rsi
jle 0xe351f
jmp 0xe3518
// File: /workspace/github_c_makefile_star2_O1/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 0xe35aa
movd %edx, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
xorl %ecx, %ecx
movdqa 0x4a504(%rip), %xmm1    # 0x12da50
movdqa 0x4a50c(%rip), %xmm2    # 0x12da60
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 0xe3554
cmpl %esi, %ecx
jge 0xe35c4
movl %ecx, %ecx
cmpl $0xffffff, (%rdi,%rcx,4) # imm = 0xFFFFFF
ja 0xe35bc
movl %edx, (%rdi,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0xe35b0
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 (%rdi,%rcx), %xmm6
movd %edx, %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, %xmm3      # xmm3 = xmm0[0,0,0,0]
movdqa %xmm6, %xmm0
psubusb %xmm2, %xmm0
movdqa %xmm2, %xmm5
psubusb %xmm6, %xmm5
por %xmm0, %xmm5
psrlw $0x1, %xmm5
movdqu (%rdi), %xmm0
movdqu (%rax), %xmm1
movdqa %xmm0, %xmm4
psubusb %xmm1, %xmm4
movdqa %xmm1, %xmm7
psubusb %xmm0, %xmm7
por %xmm4, %xmm7
pand 0x43f04(%rip), %xmm5    # 0x129c80
paddusb %xmm7, %xmm7
paddusb %xmm7, %xmm5
movdqa 0x45724(%rip), %xmm4    # 0x12b4b0
pxor %xmm4, %xmm2
pxor %xmm4, %xmm6
psubsb %xmm6, %xmm2
pxor %xmm4, %xmm0
pxor %xmm4, %xmm1
movdqa %xmm0, %xmm6
psubsb %xmm1, %xmm6
paddsb %xmm6, %xmm2
paddsb %xmm6, %xmm2
paddsb %xmm6, %xmm2
pminub %xmm5, %xmm3
pcmpeqb %xmm5, %xmm3
pand %xmm2, %xmm3
movdqa 0x47ce8(%rip), %xmm2    # 0x12dab0
paddsb %xmm3, %xmm2
paddsb 0x47cec(%rip), %xmm3    # 0x12dac0
punpcklbw %xmm3, %xmm5    # xmm5 = xmm5[0],xmm3[0],xmm5[1],xmm3[1],xmm5[2],xmm3[2],xmm5[3],xmm3[3],xmm5[4],xmm3[4],xmm5[5],xmm3[5],xmm5[6],xmm3[6],xmm5[7],xmm3[7]
punpckhbw %xmm3, %xmm3    # xmm3 = xmm3[8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15]
psraw $0xb, %xmm5
psraw $0xb, %xmm3
packsswb %xmm3, %xmm5
punpcklbw %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1],xmm3[2],xmm2[2],xmm3[3],xmm2[3],xmm3[4],xmm2[4],xmm3[5],xmm2[5],xmm3[6],xmm2[6],xmm3[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, %xmm3
psraw $0xb, %xmm2
packsswb %xmm2, %xmm3
psubsb %xmm5, %xmm0
paddsb %xmm1, %xmm3
pxor %xmm4, %xmm3
pxor %xmm4, %xmm0
movdqu %xmm3, (%rax)
movdqu %xmm0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe5d13
decl %ebp
addq %r12, %r15
cmpl $0x1, %ebp
ja 0xe60d1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe5e19
decl %r15d
addq $0x4, %r14
cmpl $0x1, %r15d
ja 0xe6109
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4783f(%rip), %xmm1    # 0x12d9d0
psubusb %xmm1, %xmm2
pavgb %xmm0, %xmm2
movd %xmm2, %eax
xorl %ecx, %ecx
movl %eax, (%rdi,%rcx)
addq $0x20, %rcx
cmpq $0x80, %rcx
jne 0xe619f
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x477d3(%rip), %xmm1    # 0x12d9d0
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_O1/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: VR4_SSE2
static void VR4_SSE2(uint8_t* dst) {   // Vertical-Right
  const __m128i one = _mm_set1_epi8(1);
  const int I = dst[-1 + 0 * BPS];
  const int J = dst[-1 + 1 * BPS];
  const int K = dst[-1 + 2 * BPS];
  const int X = dst[-1 - BPS];
  const __m128i XABCD = _mm_loadl_epi64((__m128i*)(dst - BPS - 1));
  const __m128i ABCD0 = _mm_srli_si128(XABCD, 1);
  const __m128i abcd = _mm_avg_epu8(XABCD, ABCD0);
  const __m128i _XABCD = _mm_slli_si128(XABCD, 1);
  const __m128i IXABCD = _mm_insert_epi16(_XABCD, (short)(I | (X << 8)), 0);
  const __m128i avg1 = _mm_avg_epu8(IXABCD, ABCD0);
  const __m128i lsb = _mm_and_si128(_mm_xor_si128(IXABCD, ABCD0), one);
  const __m128i avg2 = _mm_subs_epu8(avg1, lsb);
  const __m128i efgh = _mm_avg_epu8(avg2, XABCD);
  WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(               abcd    ));
  WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(               efgh    ));
  WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_slli_si128(abcd, 1)));
  WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(_mm_slli_si128(efgh, 1)));

  // these two are hard to implement in SSE2, so we keep the C-version:
  DST(0, 2) = AVG3(J, I, X);
  DST(0, 3) = AVG3(K, J, I);
}

// Assembly:
movzbl -0x1(%rdi), %ecx
movzbl 0x1f(%rdi), %eax
movzbl 0x3f(%rdi), %edx
movzbl -0x21(%rdi), %esi
movq -0x21(%rdi), %xmm0
movdqa %xmm0, %xmm1
psrlq $0x8, %xmm1
movdqa %xmm0, %xmm2
pslldq $0x1, %xmm2             # xmm2 = zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
leal (%rax,%rcx,2), %r8d
addl %esi, %r8d
addl $0x2, %r8d
shll $0x8, %esi
orl %ecx, %esi
pinsrw $0x0, %esi, %xmm2
movdqa %xmm2, %xmm3
pavgb %xmm1, %xmm3
pxor %xmm1, %xmm2
pand 0x4774b(%rip), %xmm2    # 0x12d9d0
psubusb %xmm2, %xmm3
pavgb %xmm0, %xmm3
pavgb %xmm1, %xmm0
movd %xmm0, (%rdi)
movd %xmm3, 0x20(%rdi)
pslld $0x8, %xmm0
movd %xmm0, 0x40(%rdi)
pslld $0x8, %xmm3
movd %xmm3, 0x60(%rdi)
shrl $0x2, %r8d
movb %r8b, 0x40(%rdi)
addl %ecx, %edx
leal (%rdx,%rax,2), %eax
addl $0x2, %eax
shrl $0x2, %eax
movb %al, 0x60(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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), %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
movzbl -0x19(%rdi), %eax
pinsrw $0x3, %eax, %xmm1
movdqa %xmm0, %xmm2
pavgb %xmm1, %xmm2
pxor %xmm0, %xmm1
pand 0x476df(%rip), %xmm1    # 0x12d9d0
psrlq $0x8, %xmm0
psubusb %xmm1, %xmm2
pavgb %xmm0, %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_O1/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: VL4_SSE2
static void VL4_SSE2(uint8_t* dst) {   // Vertical-Left
  const __m128i one = _mm_set1_epi8(1);
  const __m128i ABCDEFGH = _mm_loadl_epi64((__m128i*)(dst - BPS));
  const __m128i BCDEFGH_ = _mm_srli_si128(ABCDEFGH, 1);
  const __m128i CDEFGH__ = _mm_srli_si128(ABCDEFGH, 2);
  const __m128i avg1 = _mm_avg_epu8(ABCDEFGH, BCDEFGH_);
  const __m128i avg2 = _mm_avg_epu8(CDEFGH__, BCDEFGH_);
  const __m128i avg3 = _mm_avg_epu8(avg1, avg2);
  const __m128i lsb1 = _mm_and_si128(_mm_xor_si128(avg1, avg2), one);
  const __m128i ab = _mm_xor_si128(ABCDEFGH, BCDEFGH_);
  const __m128i bc = _mm_xor_si128(CDEFGH__, BCDEFGH_);
  const __m128i abbc = _mm_or_si128(ab, bc);
  const __m128i lsb2 = _mm_and_si128(abbc, lsb1);
  const __m128i avg4 = _mm_subs_epu8(avg3, lsb2);
  const uint32_t extra_out =
      (uint32_t)_mm_cvtsi128_si32(_mm_srli_si128(avg4, 4));
  WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(               avg1    ));
  WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(               avg4    ));
  WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(avg1, 1)));
  WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(avg4, 1)));

  // these two are hard to get and irregular
  DST(3, 2) = (extra_out >> 0) & 0xff;
  DST(3, 3) = (extra_out >> 8) & 0xff;
}

// Assembly:
movq -0x20(%rdi), %xmm0
movdqa %xmm0, %xmm1
psrlq $0x8, %xmm1
pshufd $0x44, %xmm0, %xmm2     # xmm2 = xmm0[0,1,0,1]
psrldq $0xa, %xmm2             # xmm2 = xmm2[10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero,zero,zero
movdqa %xmm0, %xmm3
pavgb %xmm1, %xmm3
movdqa %xmm2, %xmm4
pavgb %xmm1, %xmm4
movdqa %xmm3, %xmm5
pavgb %xmm4, %xmm5
pxor %xmm3, %xmm4
pxor %xmm1, %xmm0
pxor %xmm1, %xmm2
por %xmm0, %xmm2
pand %xmm4, %xmm2
pand 0x4765b(%rip), %xmm2    # 0x12d9d0
psubusb %xmm2, %xmm5
pshufd $0x55, %xmm5, %xmm0     # xmm0 = xmm5[1,1,1,1]
movd %xmm0, %eax
movd %xmm3, (%rdi)
movd %xmm5, 0x20(%rdi)
psrlq $0x8, %xmm3
movd %xmm3, 0x40(%rdi)
psrlq $0x8, %xmm5
movd %xmm5, 0x60(%rdi)
movb %al, 0x43(%rdi)
movb %ah, 0x63(%rdi)
retq