LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/upsampling.c
// Function: WebPInitYUV444Converters_body
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 %rbp
movq %rsp, %rbp
leaq -0x68b(%rip), %rax      # 0x151510
movq %rax, 0xc7726(%rip)     # 0x2192c8
leaq -0x5c9(%rip), %rax      # 0x1515e0
movq %rax, 0xc7728(%rip)     # 0x2192d8
leaq -0x507(%rip), %rax      # 0x1516b0
movq %rax, 0xc7702(%rip)     # 0x2192c0
leaq -0x435(%rip), %rax      # 0x151790
movq %rax, 0xc7704(%rip)     # 0x2192d0
leaq -0x363(%rip), %rax      # 0x151870
movq %rax, 0xc7706(%rip)     # 0x2192e0
leaq -0x2a1(%rip), %rax      # 0x151940
movq %rax, 0xc7700(%rip)     # 0x2192e8
leaq -0x1af(%rip), %rax      # 0x151a40
movq %rax, 0xc76fa(%rip)     # 0x2192f0
leaq -0x6ed(%rip), %rax      # 0x151510
movq %rax, 0xc76f4(%rip)     # 0x2192f8
leaq -0x62b(%rip), %rax      # 0x1515e0
movq %rax, 0xc76ee(%rip)     # 0x219300
leaq -0x3a9(%rip), %rax      # 0x151870
movq %rax, 0xc76e8(%rip)     # 0x219308
leaq -0x2e7(%rip), %rax      # 0x151940
movq %rax, 0xc76e2(%rip)     # 0x219310
movq 0xb6afb(%rip), %rax     # 0x208730
cmpq $0x0, (%rax)
je 0x151c52
xorl %edi, %edi
movq 0xb6aec(%rip), %rax     # 0x208730
callq *(%rax)
cmpl $0x0, %eax
je 0x151c50
callq 0x179490
jmp 0x151c52
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x28(%rbp), %rax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl 0x20(%rbp), %eax
jge 0x153a8f
movq 0x28(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl 0x18(%rbp), %r8d
callq *%rax
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x34(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x153a73
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl 0x10(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x153a13
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv.c
// Function: WebPInitSamplers_body
WEBP_DSP_INIT_FUNC(WebPInitSamplers) {
  WebPSamplers[MODE_RGB]       = YuvToRgbRow;
  WebPSamplers[MODE_RGBA]      = YuvToRgbaRow;
  WebPSamplers[MODE_BGR]       = YuvToBgrRow;
  WebPSamplers[MODE_BGRA]      = YuvToBgraRow;
  WebPSamplers[MODE_ARGB]      = YuvToArgbRow;
  WebPSamplers[MODE_RGBA_4444] = YuvToRgba4444Row;
  WebPSamplers[MODE_RGB_565]   = YuvToRgb565Row;
  WebPSamplers[MODE_rgbA]      = YuvToRgbaRow;
  WebPSamplers[MODE_bgrA]      = YuvToBgraRow;
  WebPSamplers[MODE_Argb]      = YuvToArgbRow;
  WebPSamplers[MODE_rgbA_4444] = YuvToRgba4444Row;

  // If defined, use CPUInfo() to overwrite some pointers with faster versions.
  if (VP8GetCPUInfo != NULL) {
#if defined(WEBP_HAVE_SSE2)
    if (VP8GetCPUInfo(kSSE2)) {
      WebPInitSamplersSSE2();
    }
#endif  // WEBP_HAVE_SSE2
#if defined(WEBP_HAVE_SSE41)
    if (VP8GetCPUInfo(kSSE4_1)) {
      WebPInitSamplersSSE41();
    }
#endif  // WEBP_HAVE_SSE41
#if defined(WEBP_USE_MIPS32)
    if (VP8GetCPUInfo(kMIPS32)) {
      WebPInitSamplersMIPS32();
    }
#endif  // WEBP_USE_MIPS32
#if defined(WEBP_USE_MIPS_DSP_R2)
    if (VP8GetCPUInfo(kMIPSdspR2)) {
      WebPInitSamplersMIPSdspR2();
    }
#endif  // WEBP_USE_MIPS_DSP_R2
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x5f5(%rip), %rax       # 0x1540e0
movq %rax, 0xc583e(%rip)     # 0x219330
leaq 0x6c7(%rip), %rax       # 0x1541c0
movq %rax, 0xc5838(%rip)     # 0x219338
leaq 0x7b9(%rip), %rax       # 0x1542c0
movq %rax, 0xc5832(%rip)     # 0x219340
leaq 0x88b(%rip), %rax       # 0x1543a0
movq %rax, 0xc582c(%rip)     # 0x219348
leaq 0x97d(%rip), %rax       # 0x1544a0
movq %rax, 0xc5826(%rip)     # 0x219350
leaq 0xa6f(%rip), %rax       # 0x1545a0
movq %rax, 0xc5820(%rip)     # 0x219358
leaq 0xb41(%rip), %rax       # 0x154680
movq %rax, 0xc581a(%rip)     # 0x219360
leaq 0x673(%rip), %rax       # 0x1541c0
movq %rax, 0xc5814(%rip)     # 0x219368
leaq 0x845(%rip), %rax       # 0x1543a0
movq %rax, 0xc580e(%rip)     # 0x219370
leaq 0x937(%rip), %rax       # 0x1544a0
movq %rax, 0xc5808(%rip)     # 0x219378
leaq 0xa29(%rip), %rax       # 0x1545a0
movq %rax, 0xc5802(%rip)     # 0x219380
movq 0xb4bab(%rip), %rax     # 0x208730
cmpq $0x0, (%rax)
je 0x153ba2
xorl %edi, %edi
movq 0xb4b9c(%rip), %rax     # 0x208730
callq *(%rax)
cmpl $0x0, %eax
je 0x153ba0
callq 0x17c060
jmp 0x153ba2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x153f3d
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
movl -0x2c(%rbp), %edx
movl $0x20000, %ecx          # imm = 0x20000
callq 0x153e00
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
movl -0x2c(%rbp), %edx
movl $0x20000, %ecx          # imm = 0x20000
callq 0x153e50
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x153ebe
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv.c
// Function: WebPInitConvertARGBToYUV_body
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 %rbp
movq %rsp, %rbp
leaq 0xc35(%rip), %rax       # 0x154bd0
movq %rax, 0xc540e(%rip)     # 0x2193b0
leaq -0x3f9(%rip), %rax      # 0x153bb0
movq %rax, 0xc5408(%rip)     # 0x2193b8
leaq 0xc99(%rip), %rax       # 0x154c50
movq %rax, 0xc53da(%rip)     # 0x219398
leaq 0xcfb(%rip), %rax       # 0x154cc0
movq %rax, 0xc53d4(%rip)     # 0x2193a0
leaq -0x133(%rip), %rax      # 0x153ea0
movq %rax, 0xc53ce(%rip)     # 0x2193a8
movq 0xb474f(%rip), %rax     # 0x208730
cmpq $0x0, (%rax)
je 0x153ffe
xorl %edi, %edi
movq 0xb4740(%rip), %rax     # 0x208730
callq *(%rax)
cmpl $0x0, %eax
je 0x153ffc
callq 0x17cde0
jmp 0x153ffe
cmpq $0x0, 0xc53aa(%rip)     # 0x2193b0
je 0x15400a
jmp 0x154029
leaq 0x6c794(%rip), %rdi     # 0x1c07a5
leaq 0x6c7a8(%rip), %rsi     # 0x1c07c0
movl $0xf0, %edx
leaq 0x6c7aa(%rip), %rcx     # 0x1c07ce
callq 0x598a0
cmpq $0x0, 0xc5387(%rip)     # 0x2193b8
je 0x154035
jmp 0x154054
leaq 0x6c7bb(%rip), %rdi     # 0x1c07f7
leaq 0x6c77d(%rip), %rsi     # 0x1c07c0
movl $0xf1, %edx
leaq 0x6c77f(%rip), %rcx     # 0x1c07ce
callq 0x598a0
cmpq $0x0, 0xc533c(%rip)     # 0x219398
je 0x154060
jmp 0x15407f
leaq 0x6c7ac(%rip), %rdi     # 0x1c0813
leaq 0x6c752(%rip), %rsi     # 0x1c07c0
movl $0xf2, %edx
leaq 0x6c754(%rip), %rcx     # 0x1c07ce
callq 0x598a0
cmpq $0x0, 0xc5319(%rip)     # 0x2193a0
je 0x15408b
jmp 0x1540aa
leaq 0x6c79d(%rip), %rdi     # 0x1c082f
leaq 0x6c727(%rip), %rsi     # 0x1c07c0
movl $0xf3, %edx
leaq 0x6c729(%rip), %rcx     # 0x1c07ce
callq 0x598a0
cmpq $0x0, 0xc52f6(%rip)     # 0x2193a8
je 0x1540b6
jmp 0x1540d5
leaq 0x6c78e(%rip), %rdi     # 0x1c084b
leaq 0x6c6fc(%rip), %rsi     # 0x1c07c0
movl $0xf4, %edx
leaq 0x6c6fe(%rip), %rcx     # 0x1c07ce
callq 0x598a0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x154c46
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
shrl $0x10, %edi
andl $0xff, %edi
movl -0x1c(%rbp), %esi
shrl $0x8, %esi
andl $0xff, %esi
movl -0x1c(%rbp), %edx
shrl $0x0, %edx
andl $0xff, %edx
movl $0x8000, %ecx           # imm = 0x8000
callq 0x154d30
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x154bea
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq 0xc40cd(%rip), %rax     # 0x218e48
leaq 0x9e(%rip), %rcx        # 0x154e20
movq %rcx, (%rax)
leaq 0xc40c4(%rip), %rax     # 0x218e50
leaq 0x59d(%rip), %rcx       # 0x155330
movq %rcx, (%rax)
leaq 0xc40bb(%rip), %rax     # 0x218e58
leaq 0x9dc(%rip), %rcx       # 0x155780
movq %rcx, (%rax)
leaq 0xc40ba(%rip), %rax     # 0x218e68
leaq 0x142b(%rip), %rcx      # 0x1561e0
movq %rcx, (%rax)
leaq 0xc40b1(%rip), %rax     # 0x218e70
leaq 0x195a(%rip), %rcx      # 0x156720
movq %rcx, (%rax)
leaq 0xc40a8(%rip), %rax     # 0x218e78
leaq 0x1cd9(%rip), %rcx      # 0x156ab0
movq %rcx, (%rax)
leaq 0xc409f(%rip), %rax     # 0x218e80
leaq 0x20d8(%rip), %rcx      # 0x156ec0
movq %rcx, (%rax)
leaq 0xc409e(%rip), %rax     # 0x218e90
leaq 0x26d7(%rip), %rcx      # 0x1574d0
movq %rcx, (%rax)
leaq 0xc4095(%rip), %rax     # 0x218e98
leaq 0x28e6(%rip), %rcx      # 0x1576f0
movq %rcx, (%rax)
leaq 0xc408c(%rip), %rax     # 0x218ea0
leaq 0x2f45(%rip), %rcx      # 0x157d60
movq %rcx, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x68(%rbp)
movl %esi, -0x6c(%rbp)
movl %edx, -0x70(%rbp)
movq -0x68(%rbp), %rax
imull $0xfffffffe, -0x6c(%rbp), %ecx # imm = 0xFFFFFFFE
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movdqu (%rax), %xmm0
movdqa %xmm0, -0x80(%rbp)
movq -0x68(%rbp), %rax
xorl %ecx, %ecx
subl -0x6c(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movdqu (%rax), %xmm0
movdqa %xmm0, -0x90(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movdqu (%rax), %xmm0
movdqa %xmm0, -0xa0(%rbp)
movq -0x68(%rbp), %rax
movslq -0x6c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movdqu (%rax), %xmm0
movdqa %xmm0, -0xb0(%rbp)
movl -0x70(%rbp), %r8d
leaq -0x80(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
callq 0x162840
movq -0x68(%rbp), %rax
xorl %ecx, %ecx
subl -0x6c(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movdqa -0x90(%rbp), %xmm0
movq %rax, -0x8(%rbp)
movdqa %xmm0, -0x20(%rbp)
movdqa -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movdqu %xmm0, (%rax)
movq -0x68(%rbp), %rax
movdqa -0xa0(%rbp), %xmm0
movq %rax, -0x28(%rbp)
movdqa %xmm0, -0x40(%rbp)
movdqa -0x40(%rbp), %xmm0
movq -0x28(%rbp), %rax
movdqu %xmm0, (%rax)
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %eax
shll $0x3, %eax
cltq
addq %rax, %rsi
movl -0xc(%rbp), %edx
leaq -0x20(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x40(%rbp), %r9
leaq -0x50(%rbp), %rax
movq %rax, (%rsp)
callq 0x161490
movl -0x10(%rbp), %r8d
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x162840
movq -0x8(%rbp), %r8
movq -0x8(%rbp), %r9
movl -0xc(%rbp), %eax
shll $0x3, %eax
cltq
addq %rax, %r9
movl -0xc(%rbp), %eax
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movl %eax, (%rsp)
callq 0x1615f0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x3, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x15d95d
movl -0xc(%rbp), %ecx
shll $0x2, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x15d760
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x15d929
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x3, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x15d9b5
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x15d870
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x15d989
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x88(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movaps -0x60(%rbp), %xmm0
movaps %xmm0, -0xa0(%rbp)
movq -0x88(%rbp), %rax
addq $-0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0xb0(%rbp)
movaps -0xb0(%rbp), %xmm1
movaps -0xa0(%rbp), %xmm0
movaps %xmm1, -0x10(%rbp)
movaps %xmm0, -0x20(%rbp)
movaps -0x10(%rbp), %xmm0
movaps -0x20(%rbp), %xmm1
psadbw %xmm1, %xmm0
movaps %xmm0, -0xc0(%rbp)
movaps -0xc0(%rbp), %xmm1
pshufd $0x2, %xmm1, %xmm0      # xmm0 = xmm1[2,0,0,0]
movdqa %xmm1, -0x70(%rbp)
movdqa %xmm0, -0x80(%rbp)
movdqa -0x70(%rbp), %xmm0
movdqa -0x80(%rbp), %xmm1
paddw %xmm1, %xmm0
movdqa %xmm0, -0xd0(%rbp)
movl $0x0, -0xd4(%rbp)
movl $0x0, -0xd8(%rbp)
cmpl $0x10, -0xd8(%rbp)
jge 0x15ee4d
movq -0x88(%rbp), %rax
movl -0xd8(%rbp), %ecx
shll $0x5, %ecx
addl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addl -0xd4(%rbp), %eax
movl %eax, -0xd4(%rbp)
movl -0xd8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xd8(%rbp)
jmp 0x15ee0a
movaps -0xd0(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movaps -0x40(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movl -0x50(%rbp), %eax
addl -0xd4(%rbp), %eax
addl $0x10, %eax
movl %eax, -0xdc(%rbp)
movl -0xdc(%rbp), %eax
sarl $0x5, %eax
movq -0x88(%rbp), %rsi
movzbl %al, %edi
callq 0x1632d0
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $-0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movdqu (%rax), %xmm0
movdqa %xmm0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0x10, -0x44(%rbp)
jge 0x15ef24
movq -0x30(%rbp), %rax
movl -0x44(%rbp), %ecx
shll $0x5, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movdqa -0x40(%rbp), %xmm0
movq %rax, -0x8(%rbp)
movdqa %xmm0, -0x20(%rbp)
movdqa -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movdqu %xmm0, (%rax)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x15eee8
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x8, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x10, -0x10(%rbp)
jge 0x15f0d8
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
shll $0x5, %ecx
addl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x15f0aa
movl -0xc(%rbp), %eax
sarl $0x4, %eax
movq -0x8(%rbp), %rsi
movzbl %al, %edi
callq 0x1632d0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x88(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movaps -0x60(%rbp), %xmm0
movaps %xmm0, -0xa0(%rbp)
movq -0x88(%rbp), %rax
addq $-0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0xb0(%rbp)
movaps -0xb0(%rbp), %xmm1
movaps -0xa0(%rbp), %xmm0
movaps %xmm1, -0x10(%rbp)
movaps %xmm0, -0x20(%rbp)
movaps -0x10(%rbp), %xmm0
movaps -0x20(%rbp), %xmm1
psadbw %xmm1, %xmm0
movaps %xmm0, -0xc0(%rbp)
movaps -0xc0(%rbp), %xmm1
pshufd $0x2, %xmm1, %xmm0      # xmm0 = xmm1[2,0,0,0]
movaps %xmm1, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps -0x70(%rbp), %xmm0
movaps -0x80(%rbp), %xmm1
paddw %xmm1, %xmm0
movaps %xmm0, -0xd0(%rbp)
movaps -0xd0(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movaps -0x40(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movl -0x50(%rbp), %eax
addl $0x8, %eax
movl %eax, -0xd4(%rbp)
movl -0xd4(%rbp), %eax
sarl $0x4, %eax
movq -0x88(%rbp), %rsi
movzbl %al, %edi
callq 0x1632d0
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x78(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps -0x50(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
movq -0x78(%rbp), %rax
addq $-0x20, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %xmm0
movdqa %xmm0, -0x70(%rbp)
movdqa -0x70(%rbp), %xmm0
movdqa %xmm0, -0xa0(%rbp)
movdqa -0xa0(%rbp), %xmm1
movdqa -0x90(%rbp), %xmm0
movdqa %xmm1, -0x10(%rbp)
movdqa %xmm0, -0x20(%rbp)
movdqa -0x10(%rbp), %xmm0
movdqa -0x20(%rbp), %xmm1
psadbw %xmm1, %xmm0
movdqa %xmm0, -0xb0(%rbp)
movl $0x0, -0xb4(%rbp)
movl $0x0, -0xb8(%rbp)
cmpl $0x8, -0xb8(%rbp)
jge 0x15f2bb
movq -0x78(%rbp), %rax
movl -0xb8(%rbp), %ecx
shll $0x5, %ecx
addl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addl -0xb4(%rbp), %eax
movl %eax, -0xb4(%rbp)
movl -0xb8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb8(%rbp)
jmp 0x15f27b
movaps -0xb0(%rbp), %xmm0
movaps %xmm0, -0x30(%rbp)
movaps -0x30(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movl -0x40(%rbp), %eax
addl -0xb4(%rbp), %eax
addl $0x8, %eax
movl %eax, -0xbc(%rbp)
movl -0xbc(%rbp), %eax
sarl $0x4, %eax
movq -0x78(%rbp), %rsi
movzbl %al, %edi
callq 0x163430
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq $-0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %xmm0
movdqa %xmm0, -0x40(%rbp)
movdqa -0x40(%rbp), %xmm0
movdqa %xmm0, -0x60(%rbp)
movl $0x0, -0x4c(%rbp)
cmpl $0x8, -0x4c(%rbp)
jge 0x15f38a
movq -0x48(%rbp), %rax
movl -0x4c(%rbp), %ecx
shll $0x5, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movaps -0x60(%rbp), %xmm0
movq %rax, -0x8(%rbp)
movaps %xmm0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x15f352
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x4, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0x15f3d8
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
shll $0x5, %ecx
addl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x15f3aa
movl -0xc(%rbp), %eax
sarl $0x3, %eax
movq -0x8(%rbp), %rsi
movzbl %al, %edi
callq 0x163430
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x78(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps -0x50(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
movq -0x78(%rbp), %rax
addq $-0x20, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %xmm0
movaps %xmm0, -0x70(%rbp)
movaps -0x70(%rbp), %xmm0
movaps %xmm0, -0xa0(%rbp)
movaps -0xa0(%rbp), %xmm1
movaps -0x90(%rbp), %xmm0
movaps %xmm1, -0x10(%rbp)
movaps %xmm0, -0x20(%rbp)
movaps -0x10(%rbp), %xmm0
movaps -0x20(%rbp), %xmm1
psadbw %xmm1, %xmm0
movaps %xmm0, -0xb0(%rbp)
movaps -0xb0(%rbp), %xmm0
movaps %xmm0, -0x30(%rbp)
movaps -0x30(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movl -0x40(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %eax
sarl $0x3, %eax
movq -0x78(%rbp), %rsi
movzbl %al, %edi
callq 0x163430
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: GetBaseDelta_SSE2
static WEBP_INLINE void GetBaseDelta_SSE2(const __m128i* const p1,
                                          const __m128i* const p0,
                                          const __m128i* const q0,
                                          const __m128i* const q1,
                                          __m128i* const delta) {
  // beware of addition order, for saturation!
  const __m128i p1_q1 = _mm_subs_epi8(*p1, *q1);   // p1 - q1
  const __m128i q0_p0 = _mm_subs_epi8(*q0, *p0);   // q0 - p0
  const __m128i s1 = _mm_adds_epi8(p1_q1, q0_p0);  // p1 - q1 + 1 * (q0 - p0)
  const __m128i s2 = _mm_adds_epi8(q0_p0, s1);     // p1 - q1 + 2 * (q0 - p0)
  const __m128i s3 = _mm_adds_epi8(q0_p0, s2);     // p1 - q1 + 3 * (q0 - p0)
  *delta = s3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rsi, -0xb0(%rbp)
movq %rdx, -0xb8(%rbp)
movq %rcx, -0xc0(%rbp)
movq %r8, -0xc8(%rbp)
movq -0xa8(%rbp), %rax
movdqa (%rax), %xmm1
movq -0xc0(%rbp), %rax
movdqa (%rax), %xmm0
movdqa %xmm1, -0x70(%rbp)
movdqa %xmm0, -0x80(%rbp)
movdqa -0x70(%rbp), %xmm0
movdqa -0x80(%rbp), %xmm1
psubsb %xmm1, %xmm0
movdqa %xmm0, -0xe0(%rbp)
movq -0xb8(%rbp), %rax
movdqa (%rax), %xmm1
movq -0xb0(%rbp), %rax
movdqa (%rax), %xmm0
movdqa %xmm1, -0x90(%rbp)
movdqa %xmm0, -0xa0(%rbp)
movdqa -0x90(%rbp), %xmm0
movdqa -0xa0(%rbp), %xmm1
psubsb %xmm1, %xmm0
movdqa %xmm0, -0xf0(%rbp)
movdqa -0xe0(%rbp), %xmm1
movdqa -0xf0(%rbp), %xmm0
movdqa %xmm1, -0x10(%rbp)
movdqa %xmm0, -0x20(%rbp)
movdqa -0x10(%rbp), %xmm0
movdqa -0x20(%rbp), %xmm1
paddsb %xmm1, %xmm0
movdqa %xmm0, -0x100(%rbp)
movdqa -0xf0(%rbp), %xmm1
movdqa -0x100(%rbp), %xmm0
movdqa %xmm1, -0x30(%rbp)
movdqa %xmm0, -0x40(%rbp)
movdqa -0x30(%rbp), %xmm0
movdqa -0x40(%rbp), %xmm1
paddsb %xmm1, %xmm0
movdqa %xmm0, -0x110(%rbp)
movdqa -0xf0(%rbp), %xmm1
movdqa -0x110(%rbp), %xmm0
movdqa %xmm1, -0x50(%rbp)
movdqa %xmm0, -0x60(%rbp)
movdqa -0x50(%rbp), %xmm0
movdqa -0x60(%rbp), %xmm1
paddsb %xmm1, %xmm0
movdqa %xmm0, -0x120(%rbp)
movdqa -0x120(%rbp), %xmm0
movq -0xc8(%rbp), %rax
movdqa %xmm0, (%rax)
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: SignedShift8b_SSE2
static WEBP_INLINE void SignedShift8b_SSE2(__m128i* const x) {
  const __m128i zero = _mm_setzero_si128();
  const __m128i lo_0 = _mm_unpacklo_epi8(zero, *x);
  const __m128i hi_0 = _mm_unpackhi_epi8(zero, *x);
  const __m128i lo_1 = _mm_srai_epi16(lo_0, 3 + 8);
  const __m128i hi_1 = _mm_srai_epi16(hi_0, 3 + 8);
  *x = _mm_packs_epi16(lo_1, hi_1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0xb0(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movaps -0x70(%rbp), %xmm0
movaps %xmm0, -0xc0(%rbp)
movaps -0xc0(%rbp), %xmm1
movq -0xb0(%rbp), %rax
movaps (%rax), %xmm0
movaps %xmm1, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps -0x50(%rbp), %xmm0
movaps -0x60(%rbp), %xmm1
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]
movaps %xmm0, -0xd0(%rbp)
movaps -0xc0(%rbp), %xmm1
movq -0xb0(%rbp), %rax
movaps (%rax), %xmm0
movaps %xmm1, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps -0x30(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
punpckhbw %xmm1, %xmm0    # xmm0 = xmm0[8],xmm1[8],xmm0[9],xmm1[9],xmm0[10],xmm1[10],xmm0[11],xmm1[11],xmm0[12],xmm1[12],xmm0[13],xmm1[13],xmm0[14],xmm1[14],xmm0[15],xmm1[15]
movdqa %xmm0, -0xe0(%rbp)
movdqa -0xd0(%rbp), %xmm0
movdqa %xmm0, -0x80(%rbp)
movl $0xb, -0x84(%rbp)
movdqa -0x80(%rbp), %xmm0
movl -0x84(%rbp), %eax
movd %eax, %xmm1
psraw %xmm1, %xmm0
movdqa %xmm0, -0xf0(%rbp)
movdqa -0xe0(%rbp), %xmm0
movdqa %xmm0, -0xa0(%rbp)
movl $0xb, -0xa4(%rbp)
movdqa -0xa0(%rbp), %xmm0
movl -0xa4(%rbp), %eax
movd %eax, %xmm1
psraw %xmm1, %xmm0
movdqa %xmm0, -0x100(%rbp)
movdqa -0xf0(%rbp), %xmm1
movdqa -0x100(%rbp), %xmm0
movdqa %xmm1, -0x10(%rbp)
movdqa %xmm0, -0x20(%rbp)
movdqa -0x10(%rbp), %xmm0
movdqa -0x20(%rbp), %xmm1
packsswb %xmm1, %xmm0
movq -0xb0(%rbp), %rax
movdqa %xmm0, (%rax)
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movl %edx, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
cmpl $0x4, -0x38(%rbp)
jge 0x161bdf
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movaps (%rax), %xmm0
movaps %xmm0, -0x10(%rbp)
movaps -0x10(%rbp), %xmm0
movaps %xmm0, -0x20(%rbp)
movl -0x20(%rbp), %esi
callq 0x15f7a0
movq -0x28(%rbp), %rax
movaps (%rax), %xmm0
psrldq $0x4, %xmm0             # xmm0 = xmm0[4,5,6,7,8,9,10,11,12,13,14,15],zero,zero,zero,zero
movq -0x28(%rbp), %rax
movdqa %xmm0, (%rax)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x161b8a
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq 0xb5aa5(%rip), %rax     # 0x219040
leaq 0x6e(%rip), %rcx        # 0x163610
movq %rcx, 0x8(%rax)
leaq 0xb5a93(%rip), %rax     # 0x219040
leaq 0x36c(%rip), %rcx       # 0x163920
movq %rcx, 0x10(%rax)
leaq 0xb5a81(%rip), %rax     # 0x219040
leaq 0x5fa(%rip), %rcx       # 0x163bc0
movq %rcx, 0x18(%rax)
leaq 0xb5a4f(%rip), %rax     # 0x219020
leaq 0x668(%rip), %rcx       # 0x163c40
movq %rcx, 0x8(%rax)
leaq 0xb5a3d(%rip), %rax     # 0x219020
leaq 0x696(%rip), %rcx       # 0x163c80
movq %rcx, 0x10(%rax)
leaq 0xb5a2b(%rip), %rax     # 0x219020
leaq 0x6c4(%rip), %rcx       # 0x163cc0
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x163bf4
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edi
callq 0x163610
jmp 0x163c2f
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
addl %ecx, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq -0x8(%rbp), %rsi
addq $0x1, %rsi
movq -0x18(%rbp), %rdx
addq $0x1, %rdx
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
callq 0x163d00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless_sse2.c
// Function: PredictorAdd0_SSE2
static void PredictorAdd0_SSE2(const uint32_t* in, const uint32_t* upper,
                               int num_pixels, uint32_t* out) {
  int i;
  const __m128i black = _mm_set1_epi32((int)ARGB_BLACK);
  for (i = 0; i + 4 <= num_pixels; i += 4) {
    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
    const __m128i res = _mm_add_epi8(src, black);
    _mm_storeu_si128((__m128i*)&out[i], res);
  }
  if (i != num_pixels) {
    VP8LPredictorsAdd_C[0](in + i, NULL, num_pixels - i, out + i);
  }
  (void)upper;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x78(%rbp)
movq %rsi, -0x80(%rbp)
movl %edx, -0x84(%rbp)
movq %rcx, -0x90(%rbp)
movl $0xff000000, -0x4c(%rbp) # imm = 0xFF000000
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl %eax, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl %eax, -0x10(%rbp)
movd -0x4(%rbp), %xmm0
movd -0x8(%rbp), %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movd -0xc(%rbp), %xmm2
movd -0x10(%rbp), %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movdqa %xmm0, -0x20(%rbp)
movdqa -0x20(%rbp), %xmm0
movdqa %xmm0, -0xb0(%rbp)
movl $0x0, -0x94(%rbp)
movl -0x94(%rbp), %eax
addl $0x4, %eax
cmpl -0x84(%rbp), %eax
jg 0x1656c4
movq -0x78(%rbp), %rax
movslq -0x94(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movdqu (%rax), %xmm0
movdqa %xmm0, -0xc0(%rbp)
movdqa -0xc0(%rbp), %xmm1
movdqa -0xb0(%rbp), %xmm0
movdqa %xmm1, -0x30(%rbp)
movdqa %xmm0, -0x40(%rbp)
movdqa -0x30(%rbp), %xmm0
movdqa -0x40(%rbp), %xmm1
paddb %xmm1, %xmm0
movdqa %xmm0, -0xd0(%rbp)
movq -0x90(%rbp), %rax
movslq -0x94(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movdqa -0xd0(%rbp), %xmm0
movq %rax, -0x58(%rbp)
movdqa %xmm0, -0x70(%rbp)
movdqa -0x70(%rbp), %xmm0
movq -0x58(%rbp), %rax
movdqu %xmm0, (%rax)
movl -0x94(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x94(%rbp)
jmp 0x165612
movl -0x94(%rbp), %eax
cmpl -0x84(%rbp), %eax
je 0x165713
leaq 0xb3ac7(%rip), %rax     # 0x2191a0
movq (%rax), %rax
movq -0x78(%rbp), %rdi
movslq -0x94(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rdi
movl -0x84(%rbp), %edx
subl -0x94(%rbp), %edx
movq -0x90(%rbp), %rcx
movslq -0x94(%rbp), %rsi
shlq $0x2, %rsi
addq %rsi, %rcx
xorl %esi, %esi
callq *%rax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless_sse2.c
// Function: AddGreenToBlueAndRed_SSE2
static void AddGreenToBlueAndRed_SSE2(const uint32_t* const src, int num_pixels,
                                      uint32_t* dst) {
  int i;
  for (i = 0; i + 4 <= num_pixels; i += 4) {
    const __m128i in = _mm_loadu_si128((const __m128i*)&src[i]); // argb
    const __m128i A = _mm_srli_epi16(in, 8);     // 0 a 0 g
    const __m128i B = _mm_shufflelo_epi16(A, _MM_SHUFFLE(2, 2, 0, 0));
    const __m128i C = _mm_shufflehi_epi16(B, _MM_SHUFFLE(2, 2, 0, 0));  // 0g0g
    const __m128i out = _mm_add_epi8(in, C);
    _mm_storeu_si128((__m128i*)&dst[i], out);
  }
  // fallthrough and finish off with plain-C
  if (i != num_pixels) {
    VP8LAddGreenToBlueAndRed_C(src + i, num_pixels - i, dst + i);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x60(%rbp)
movl %esi, -0x64(%rbp)
movq %rdx, -0x70(%rbp)
movl $0x0, -0x74(%rbp)
movl -0x74(%rbp), %eax
addl $0x4, %eax
cmpl -0x64(%rbp), %eax
jg 0x167b92
movq -0x60(%rbp), %rax
movslq -0x74(%rbp), %rcx
leaq (%rax,%rcx,4), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x90(%rbp)
movaps -0x90(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movl $0x8, -0x54(%rbp)
movaps -0x50(%rbp), %xmm0
movd -0x54(%rbp), %xmm1
psrlw %xmm1, %xmm0
movaps %xmm0, -0xa0(%rbp)
movaps -0xa0(%rbp), %xmm0
pshuflw $0xa0, %xmm0, %xmm0     # xmm0 = xmm0[0,0,2,2,4,5,6,7]
movaps %xmm0, -0xb0(%rbp)
movaps -0xb0(%rbp), %xmm0
pshufhw $0xa0, %xmm0, %xmm0     # xmm0 = xmm0[0,1,2,3,4,4,6,6]
movdqa %xmm0, -0xc0(%rbp)
movdqa -0x90(%rbp), %xmm1
movdqa -0xc0(%rbp), %xmm0
movdqa %xmm1, -0x10(%rbp)
movdqa %xmm0, -0x20(%rbp)
movdqa -0x10(%rbp), %xmm0
movdqa -0x20(%rbp), %xmm1
paddb %xmm1, %xmm0
movdqa %xmm0, -0xd0(%rbp)
movq -0x70(%rbp), %rax
movslq -0x74(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movdqa -0xd0(%rbp), %xmm0
movq %rax, -0x30(%rbp)
movdqa %xmm0, -0x40(%rbp)
movdqa -0x40(%rbp), %xmm0
movq -0x30(%rbp), %rax
movdqu %xmm0, (%rax)
movl -0x74(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x74(%rbp)
jmp 0x167aad
movl -0x74(%rbp), %eax
cmpl -0x64(%rbp), %eax
je 0x167bc3
movq -0x60(%rbp), %rdi
movslq -0x74(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movl -0x64(%rbp), %esi
subl -0x74(%rbp), %esi
movq -0x70(%rbp), %rdx
movslq -0x74(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
callq 0x14e690
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless_sse2.c
// Function: Average3_SSE2
static WEBP_INLINE uint32_t Average3_SSE2(uint32_t a0, uint32_t a1,
                                          uint32_t a2) {
  const __m128i zero = _mm_setzero_si128();
  const __m128i avg1 = Average2_uint32_16_SSE2(a0, a2);
  const __m128i A1 = _mm_unpacklo_epi8(_mm_cvtsi32_si128((int)a1), zero);
  const __m128i sum = _mm_add_epi16(avg1, A1);
  const __m128i avg2 = _mm_srli_epi16(sum, 1);
  const __m128i A2 = _mm_packus_epi16(avg2, avg2);
  return (uint32_t)_mm_cvtsi128_si32(A2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movl %edi, -0xd4(%rbp)
movl %esi, -0xd8(%rbp)
movl %edx, -0xdc(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0xd0(%rbp)
movaps -0xd0(%rbp), %xmm0
movaps %xmm0, -0xf0(%rbp)
movl -0xd4(%rbp), %edi
movl -0xdc(%rbp), %esi
callq 0x169ba0
movaps %xmm0, -0x100(%rbp)
movl -0xd8(%rbp), %eax
movl %eax, -0x84(%rbp)
movd -0x84(%rbp), %xmm0
movaps %xmm0, -0xa0(%rbp)
movaps -0xa0(%rbp), %xmm1
movaps -0xf0(%rbp), %xmm0
movaps %xmm1, -0xb0(%rbp)
movaps %xmm0, -0xc0(%rbp)
movaps -0xb0(%rbp), %xmm0
movaps -0xc0(%rbp), %xmm1
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]
movaps %xmm0, -0x110(%rbp)
movaps -0x100(%rbp), %xmm1
movaps -0x110(%rbp), %xmm0
movaps %xmm1, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps -0x70(%rbp), %xmm0
movaps -0x80(%rbp), %xmm1
paddw %xmm1, %xmm0
movaps %xmm0, -0x120(%rbp)
movaps -0x120(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movl $0x1, -0x54(%rbp)
movaps -0x50(%rbp), %xmm0
movd -0x54(%rbp), %xmm1
psrlw %xmm1, %xmm0
movaps %xmm0, -0x130(%rbp)
movaps -0x130(%rbp), %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps -0x30(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
packuswb %xmm1, %xmm0
movaps %xmm0, -0x140(%rbp)
movaps -0x140(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movaps -0x10(%rbp), %xmm0
movaps %xmm0, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless_sse2.c
// Function: Average2_uint32_16_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:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0xd4(%rbp)
movl %esi, -0xd8(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0xd0(%rbp)
movaps -0xd0(%rbp), %xmm0
movaps %xmm0, -0xf0(%rbp)
movl -0xd4(%rbp), %eax
movl %eax, -0x44(%rbp)
movd -0x44(%rbp), %xmm0
movaps %xmm0, -0x60(%rbp)
movaps -0x60(%rbp), %xmm1
movaps -0xf0(%rbp), %xmm0
movaps %xmm1, -0x90(%rbp)
movaps %xmm0, -0xa0(%rbp)
movaps -0x90(%rbp), %xmm0
movaps -0xa0(%rbp), %xmm1
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]
movaps %xmm0, -0x100(%rbp)
movl -0xd8(%rbp), %eax
movl %eax, -0x64(%rbp)
movd -0x64(%rbp), %xmm0
movaps %xmm0, -0x80(%rbp)
movaps -0x80(%rbp), %xmm1
movaps -0xf0(%rbp), %xmm0
movaps %xmm1, -0xb0(%rbp)
movaps %xmm0, -0xc0(%rbp)
movaps -0xb0(%rbp), %xmm0
movaps -0xc0(%rbp), %xmm1
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]
movdqa %xmm0, -0x110(%rbp)
movdqa -0x110(%rbp), %xmm1
movdqa -0x100(%rbp), %xmm0
movdqa %xmm1, -0x30(%rbp)
movdqa %xmm0, -0x40(%rbp)
movdqa -0x30(%rbp), %xmm0
movdqa -0x40(%rbp), %xmm1
paddw %xmm1, %xmm0
movdqa %xmm0, -0x120(%rbp)
movdqa -0x120(%rbp), %xmm0
movdqa %xmm0, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movdqa -0x10(%rbp), %xmm0
movl -0x14(%rbp), %eax
movd %eax, %xmm1
psrlw %xmm1, %xmm0
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless_sse2.c
// Function: Average4_SSE2
static WEBP_INLINE uint32_t Average4_SSE2(uint32_t a0, uint32_t a1,
                                          uint32_t a2, uint32_t a3) {
  const __m128i avg1 = Average2_uint32_16_SSE2(a0, a1);
  const __m128i avg2 = Average2_uint32_16_SSE2(a2, a3);
  const __m128i sum = _mm_add_epi16(avg2, avg1);
  const __m128i avg3 = _mm_srli_epi16(sum, 1);
  const __m128i A0 = _mm_packus_epi16(avg3, avg3);
  return (uint32_t)_mm_cvtsi128_si32(A0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl %edi, -0x84(%rbp)
movl %esi, -0x88(%rbp)
movl %edx, -0x8c(%rbp)
movl %ecx, -0x90(%rbp)
movl -0x84(%rbp), %edi
movl -0x88(%rbp), %esi
callq 0x169ba0
movaps %xmm0, -0xa0(%rbp)
movl -0x8c(%rbp), %edi
movl -0x90(%rbp), %esi
callq 0x169ba0
movaps %xmm0, -0xb0(%rbp)
movaps -0xb0(%rbp), %xmm1
movaps -0xa0(%rbp), %xmm0
movaps %xmm1, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps -0x70(%rbp), %xmm0
movaps -0x80(%rbp), %xmm1
paddw %xmm1, %xmm0
movaps %xmm0, -0xc0(%rbp)
movaps -0xc0(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movl $0x1, -0x54(%rbp)
movaps -0x50(%rbp), %xmm0
movd -0x54(%rbp), %xmm1
psrlw %xmm1, %xmm0
movaps %xmm0, -0xd0(%rbp)
movaps -0xd0(%rbp), %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps -0x30(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
packuswb %xmm1, %xmm0
movaps %xmm0, -0xe0(%rbp)
movaps -0xe0(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movaps -0x10(%rbp), %xmm0
movaps %xmm0, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)