LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/lossless.c
// Function: PredictorAdd1_C
static void PredictorAdd1_C(const uint32_t* in, const uint32_t* upper,
                            int num_pixels, uint32_t* out) {
  int i;
  uint32_t left = out[-1];
  (void)upper;
  for (i = 0; i < num_pixels; ++i) {
    out[i] = left = VP8LAddPixels(in[i], left);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movq %rdi, %r15
movl -0x4(%rcx), %eax
xorl %r12d, %r12d
testl %edx, %edx
cmovlel %r12d, %r14d
cmpq %r12, %r14
je 0xd28e8
movl (%r15,%r12,4), %edi
movl %eax, %esi
callq 0xd295b
movl %eax, (%rbx,%r12,4)
incq %r12
jmp 0xd28cf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/rescaler.c
// Function: WebPRescalerImportRowExpand_C
void WebPRescalerImportRowExpand_C(WebPRescaler* const wrk,
                                   const uint8_t* src) {
  const int x_stride = wrk->num_channels;
  const int x_out_max = wrk->dst_width * wrk->num_channels;
  int channel;
  assert(!WebPRescalerInputDone(wrk));
  assert(wrk->x_expand);
  for (channel = 0; channel < x_stride; ++channel) {
    int x_in = channel;
    int x_out = channel;
    // simple bilinear interpolation
    int accum = wrk->x_add;
    rescaler_t left = (rescaler_t)src[x_in];
    rescaler_t right =
        (wrk->src_width > 1) ? (rescaler_t)src[x_in + x_stride] : left;
    x_in += x_stride;
    while (1) {
      wrk->frow[x_out] = right * wrk->x_add + (left - right) * accum;
      x_out += x_stride;
      if (x_out >= x_out_max) break;
      accum -= wrk->x_sub;
      if (accum < 0) {
        left = right;
        x_in += x_stride;
        assert(x_in < wrk->src_width * x_stride);
        right = (rescaler_t)src[x_in];
        accum += wrk->x_add;
      }
    }
    assert(wrk->x_sub == 0 /* <- special case for src_width=1 */ || accum == 0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x3c(%rdi), %eax
cmpl 0x30(%rdi), %eax
jge 0xd302d
cmpl $0x0, (%rdi)
je 0xd3046
movslq 0x8(%rdi), %rax
movslq 0x34(%rdi), %rcx
imulq %rax, %rcx
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %r8d
cmovgl %eax, %r8d
cmpq %r8, %rdx
je 0xd3007
movzbl (%rsi,%rdx), %ebp
leaq (%rdx,%rax), %r9
cmpl $0x2, 0x2c(%rdi)
movl %ebp, %r10d
jl 0xd2f76
movzbl (%rsi,%r9), %r10d
movl 0x24(%rdi), %r15d
movq 0x60(%rdi), %rbx
movq %rdx, %r14
movl %r15d, %r11d
subl %r10d, %ebp
imull %r10d, %r15d
movl %ebp, %r12d
imull %r11d, %r12d
addl %r15d, %r12d
movl %r12d, (%rbx,%r14,4)
leaq (%r14,%rax), %r12
movl 0x28(%rdi), %r15d
cmpq %rcx, %r12
jge 0xd2fd9
subl %r15d, %r11d
js 0xd2fb4
movl 0x24(%rdi), %r15d
movq %r12, %r14
jmp 0xd2f87
addl %eax, %r9d
movl 0x2c(%rdi), %ebp
imull %eax, %ebp
cmpl %ebp, %r9d
jge 0xd3010
addq %rax, %r14
movslq %r9d, %r15
movl %r10d, %ebp
movzbl (%rsi,%r15), %r10d
movl 0x24(%rdi), %r15d
addl %r15d, %r11d
jmp 0xd2f84
incq %rdx
testl %r15d, %r15d
je 0xd2f57
testl %r11d, %r11d
je 0xd2f57
leaq 0x48f4a(%rip), %rdi     # 0x11bf3f
leaq 0x48ec6(%rip), %rsi     # 0x11bec2
leaq 0x48ed2(%rip), %rcx     # 0x11bed5
pushq $0x3a
jmp 0xd3027
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x48f07(%rip), %rdi     # 0x11bf1e
leaq 0x48ea4(%rip), %rsi     # 0x11bec2
leaq 0x48eb0(%rip), %rcx     # 0x11bed5
pushq $0x35
popq %rdx
callq 0x56770
leaq 0x48e72(%rip), %rdi     # 0x11bea6
leaq 0x48e87(%rip), %rsi     # 0x11bec2
leaq 0x48e93(%rip), %rcx     # 0x11bed5
pushq $0x22
jmp 0xd3027
leaq 0x48f5a(%rip), %rdi     # 0x11bfa7
leaq 0x48e6e(%rip), %rsi     # 0x11bec2
leaq 0x48e7a(%rip), %rcx     # 0x11bed5
pushq $0x23
jmp 0xd3027
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/rescaler.c
// Function: WebPRescalerImportRowShrink_C
void WebPRescalerImportRowShrink_C(WebPRescaler* const wrk,
                                   const uint8_t* src) {
  const int x_stride = wrk->num_channels;
  const int x_out_max = wrk->dst_width * wrk->num_channels;
  int channel;
  assert(!WebPRescalerInputDone(wrk));
  assert(!wrk->x_expand);
  for (channel = 0; channel < x_stride; ++channel) {
    int x_in = channel;
    int x_out = channel;
    uint32_t sum = 0;
    int accum = 0;
    while (x_out < x_out_max) {
      uint32_t base = 0;
      accum += wrk->x_add;
      while (accum > 0) {
        accum -= wrk->x_sub;
        assert(x_in < wrk->src_width * x_stride);
        base = src[x_in];
        sum += base;
        x_in += x_stride;
      }
      {        // Emit next horizontal pixel.
        const rescaler_t frac = base * (-accum);
        wrk->frow[x_out] = sum * wrk->x_sub - frac;
        // fresh fractional start for next pixel
        sum = (int)MULT_FIX(frac, wrk->fx_scale);
      }
      x_out += x_stride;
    }
    assert(accum == 0);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x3c(%rdi), %eax
cmpl 0x30(%rdi), %eax
jge 0xd314a
cmpl $0x0, (%rdi)
jne 0xd3163
movslq 0x8(%rdi), %rax
movslq 0x34(%rdi), %rcx
imulq %rax, %rcx
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %r8d
cmovgl %eax, %r8d
cmpq %r8, %rdx
je 0xd3127
xorl %ebx, %ebx
movq %rdx, %r10
movq %rdx, %r11
xorl %r9d, %r9d
cmpq %rcx, %r10
jge 0xd3106
addl 0x24(%rdi), %r9d
movslq %r11d, %r11
xorl %r14d, %r14d
testl %r9d, %r9d
jle 0xd30d9
movslq 0x2c(%rdi), %r14
imulq %rax, %r14
cmpq %r14, %r11
jge 0xd312d
subl 0x28(%rdi), %r9d
movzbl (%rsi,%r11), %r14d
addl %r14d, %ebx
addq %rax, %r11
jmp 0xd30b6
imull %r9d, %r14d
imull 0x28(%rdi), %ebx
addl %r14d, %ebx
negl %r14d
movq 0x60(%rdi), %r15
movl %ebx, (%r15,%r10,4)
movl 0xc(%rdi), %ebx
imulq %r14, %rbx
subq $-0x80000000, %rbx      # imm = 0x80000000
shrq $0x20, %rbx
addq %rax, %r10
jmp 0xd30a7
incq %rdx
testl %r9d, %r9d
je 0xd3093
leaq 0x48e3d(%rip), %rdi     # 0x11bf52
leaq 0x48da6(%rip), %rsi     # 0x11bec2
leaq 0x48e3a(%rip), %rcx     # 0x11bf5d
pushq $0x5c
jmp 0xd3144
popq %rbx
popq %r14
popq %r15
retq
leaq 0x48dea(%rip), %rdi     # 0x11bf1e
leaq 0x48d87(%rip), %rsi     # 0x11bec2
leaq 0x48e1b(%rip), %rcx     # 0x11bf5d
pushq $0x4f
popq %rdx
callq 0x56770
leaq 0x48d55(%rip), %rdi     # 0x11bea6
leaq 0x48d6a(%rip), %rsi     # 0x11bec2
leaq 0x48dfe(%rip), %rcx     # 0x11bf5d
pushq $0x43
jmp 0xd3144
leaq 0x48e3c(%rip), %rdi     # 0x11bfa6
leaq 0x48d51(%rip), %rsi     # 0x11bec2
leaq 0x48de5(%rip), %rcx     # 0x11bf5d
pushq $0x44
jmp 0xd3144
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/rescaler.c
// Function: WebPRescalerExportRowExpand_C
void WebPRescalerExportRowExpand_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;
  assert(!WebPRescalerOutputDone(wrk));
  assert(wrk->y_accum <= 0);
  assert(wrk->y_expand);
  assert(wrk->y_sub != 0);
  if (wrk->y_accum == 0) {
    for (x_out = 0; x_out < x_out_max; ++x_out) {
      const uint32_t J = frow[x_out];
      const int v = (int)MULT_FIX(J, wrk->fy_scale);
      dst[x_out] = (v > 255) ? 255u : (uint8_t)v;
    }
  } else {
    const uint32_t B = WEBP_RESCALER_FRAC(-wrk->y_accum, wrk->y_sub);
    const uint32_t A = (uint32_t)(WEBP_RESCALER_ONE - B);
    for (x_out = 0; x_out < x_out_max; ++x_out) {
      const uint64_t I = (uint64_t)A * frow[x_out]
                       + (uint64_t)B * irow[x_out];
      const uint32_t J = (uint32_t)((I + ROUNDER) >> WEBP_RESCALER_RFIX);
      const int v = (int)MULT_FIX(J, wrk->fy_scale);
      dst[x_out] = (v > 255) ? 255u : (uint8_t)v;
    }
  }
}

// Assembly:
pushq %rbx
movl 0x40(%rdi), %eax
cmpl 0x38(%rdi), %eax
jge 0xd3277
movl 0x18(%rdi), %eax
testl %eax, %eax
jg 0xd3290
cmpl $0x0, 0x4(%rdi)
je 0xd32a9
movslq 0x20(%rdi), %r11
testq %r11, %r11
je 0xd32c2
movq 0x48(%rdi), %rcx
movl 0x8(%rdi), %r9d
imull 0x34(%rdi), %r9d
movq 0x60(%rdi), %rsi
testl %eax, %eax
je 0xd3237
movq 0x58(%rdi), %r8
negl %eax
shlq $0x20, %rax
xorl %r10d, %r10d
xorl %edx, %edx
divq %r11
movl %eax, %edx
negl %eax
testl %r9d, %r9d
movl $0x0, %r11d
cmovgl %r9d, %r11d
cmpq %r10, %r11
je 0xd3275
movl (%rsi,%r10,4), %r9d
imulq %rax, %r9
movl (%r8,%r10,4), %ebx
imulq %rdx, %rbx
addq %r9, %rbx
subq $-0x80000000, %rbx      # imm = 0x80000000
shrq $0x20, %rbx
movl 0x10(%rdi), %r9d
imulq %rbx, %r9
subq $-0x80000000, %r9       # imm = 0x80000000
shrq $0x20, %r9
movl $0xff, %ebx
cmpl $0x100, %r9d            # imm = 0x100
jge 0xd322e
movl %r9d, %ebx
movb %bl, (%rcx,%r10)
incq %r10
jmp 0xd31e3
xorl %eax, %eax
testl %r9d, %r9d
cmovlel %eax, %r9d
movl $0xff, %edx
cmpq %rax, %r9
je 0xd3275
movl (%rsi,%rax,4), %r8d
movl 0x10(%rdi), %r10d
imulq %r8, %r10
subq $-0x80000000, %r10      # imm = 0x80000000
shrq $0x20, %r10
cmpl $0x100, %r10d           # imm = 0x100
cmovgel %edx, %r10d
movb %r10b, (%rcx,%rax)
incq %rax
jmp 0xd3245
popq %rbx
retq
leaq 0x48d37(%rip), %rdi     # 0x11bfb5
leaq 0x48c3d(%rip), %rsi     # 0x11bec2
leaq 0x48d46(%rip), %rcx     # 0x11bfd2
pushq $0x69
jmp 0xd32d9
leaq 0x48d73(%rip), %rdi     # 0x11c00a
leaq 0x48c24(%rip), %rsi     # 0x11bec2
leaq 0x48d2d(%rip), %rcx     # 0x11bfd2
pushq $0x6a
jmp 0xd32d9
leaq 0x48db5(%rip), %rdi     # 0x11c065
leaq 0x48c0b(%rip), %rsi     # 0x11bec2
leaq 0x48d14(%rip), %rcx     # 0x11bfd2
pushq $0x6b
jmp 0xd32d9
leaq 0x48d53(%rip), %rdi     # 0x11c01c
leaq 0x48bf2(%rip), %rsi     # 0x11bec2
leaq 0x48cfb(%rip), %rcx     # 0x11bfd2
pushq $0x6c
popq %rdx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/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 0xd33bf
movl 0x18(%rdi), %r8d
testl %r8d, %r8d
jg 0xd33de
cmpl $0x0, 0x4(%rdi)
jne 0xd33fd
movq 0x48(%rdi), %rax
movl 0x8(%rdi), %ecx
imull 0x34(%rdi), %ecx
movq 0x58(%rdi), %rdx
imull 0x10(%rdi), %r8d
testl %r8d, %r8d
je 0xd337c
movq 0x60(%rdi), %rsi
negl %r8d
movl %r8d, %r8d
xorl %r9d, %r9d
testl %ecx, %ecx
cmovlel %r9d, %ecx
cmpq %r9, %rcx
je 0xd33bd
movl (%rsi,%r9,4), %r10d
imulq %r8, %r10
shrq $0x20, %r10
movl (%rdx,%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 0xd336f
movl %r11d, %ebx
movb %bl, (%rax,%r9)
movl %r10d, (%rdx,%r9,4)
incq %r9
jmp 0xd332f
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
movl $0xff, %r8d
cmpq %rsi, %rcx
je 0xd33bd
movl (%rdx,%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)
andl $0x0, (%rdx,%rsi,4)
incq %rsi
jmp 0xd3389
popq %rbx
retq
leaq 0x48bef(%rip), %rdi     # 0x11bfb5
leaq 0x48af5(%rip), %rsi     # 0x11bec2
leaq 0x48c58(%rip), %rcx     # 0x11c02c
movl $0x87, %edx
callq 0x56770
leaq 0x48c25(%rip), %rdi     # 0x11c00a
leaq 0x48ad6(%rip), %rsi     # 0x11bec2
leaq 0x48c39(%rip), %rcx     # 0x11c02c
movl $0x88, %edx
callq 0x56770
leaq 0x48c60(%rip), %rdi     # 0x11c064
leaq 0x48ab7(%rip), %rsi     # 0x11bec2
leaq 0x48c1a(%rip), %rcx     # 0x11c02c
movl $0x89, %edx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/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 0xd34a2
movq %rdi, %rbx
movl 0x38(%rdi), %eax
cmpl %eax, 0x40(%rdi)
jge 0xd34ed
cmpl $0x0, 0x4(%rbx)
je 0xd347f
leaq 0x9e333(%rip), %rax     # 0x1717b0
jmp 0xd348c
cmpl $0x0, 0x14(%rbx)
je 0xd34a4
leaq 0x9e32c(%rip), %rax     # 0x1717b8
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 0xd350c
cmpl $0x1, 0x24(%rbx)
jne 0xd350c
cmpl $0x1, 0x2c(%rbx)
jne 0xd352b
movl 0x34(%rbx), %ecx
cmpl $0x2, %ecx
jg 0xd352b
xorl %eax, %eax
movslq 0x8(%rbx), %rdx
movslq %ecx, %rcx
imulq %rdx, %rcx
cmpq %rcx, %rax
jge 0xd3491
movq 0x48(%rbx), %rcx
movq 0x58(%rbx), %rdx
movb (%rdx,%rax,4), %dl
movb %dl, (%rcx,%rax)
movq 0x58(%rbx), %rcx
andl $0x0, (%rcx,%rax,4)
incq %rax
movl 0x34(%rbx), %ecx
jmp 0xd34bf
leaq 0x48ac1(%rip), %rdi     # 0x11bfb5
leaq 0x489c7(%rip), %rsi     # 0x11bec2
leaq 0x48bb2(%rip), %rcx     # 0x11c0b4
movl $0xac, %edx
callq 0x56770
leaq 0x48bd1(%rip), %rdi     # 0x11c0e4
leaq 0x489a8(%rip), %rsi     # 0x11bec2
leaq 0x48b93(%rip), %rcx     # 0x11c0b4
movl $0xb3, %edx
callq 0x56770
leaq 0x48be8(%rip), %rdi     # 0x11c11a
leaq 0x48989(%rip), %rsi     # 0x11bec2
leaq 0x48b74(%rip), %rcx     # 0x11c0b4
movl $0xb4, %edx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/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 0x91006(%rip), %rcx     # 0x164558
movq 0x8e1ff(%rip), %rbx     # 0x161758
movq (%rbx), %rax
cmpq %rax, %rcx
je 0xd35e5
leaq -0x3f0(%rip), %rcx      # 0xd317c
movq %rcx, 0x9e23d(%rip)     # 0x1717b0
leaq -0x29b(%rip), %rcx      # 0xd32df
movq %rcx, 0x9e237(%rip)     # 0x1717b8
leaq -0x668(%rip), %rcx      # 0xd2f20
movq %rcx, 0x9e219(%rip)     # 0x1717a8
leaq -0x537(%rip), %rcx      # 0xd305f
movq %rcx, 0x9e203(%rip)     # 0x1717a0
testq %rax, %rax
je 0xd35dc
xorl %edi, %edi
callq *%rax
testl %eax, %eax
je 0xd35af
callq 0xda8ac
cmpq $0x0, 0x9e1f9(%rip)     # 0x1717b0
je 0xd35e7
cmpq $0x0, 0x9e1f7(%rip)     # 0x1717b8
je 0xd3606
cmpq $0x0, 0x9e1dd(%rip)     # 0x1717a8
je 0xd3625
cmpq $0x0, 0x9e1cb(%rip)     # 0x1717a0
je 0xd3644
movq (%rbx), %rax
jmp 0xd35de
xorl %eax, %eax
movq %rax, 0x90f73(%rip)     # 0x164558
popq %rbx
retq
leaq 0x48b57(%rip), %rdi     # 0x11c145
leaq 0x488cd(%rip), %rsi     # 0x11bec2
leaq 0x48b6d(%rip), %rcx     # 0x11c169
movl $0xf7, %edx
callq 0x56770
leaq 0x48b80(%rip), %rdi     # 0x11c18d
leaq 0x488ae(%rip), %rsi     # 0x11bec2
leaq 0x48b4e(%rip), %rcx     # 0x11c169
movl $0xf8, %edx
callq 0x56770
leaq 0x48b85(%rip), %rdi     # 0x11c1b1
leaq 0x4888f(%rip), %rsi     # 0x11bec2
leaq 0x48b2f(%rip), %rcx     # 0x11c169
movl $0xf9, %edx
callq 0x56770
leaq 0x48b8a(%rip), %rdi     # 0x11c1d5
leaq 0x48870(%rip), %rsi     # 0x11bec2
leaq 0x48b10(%rip), %rcx     # 0x11c169
movl $0xfa, %edx
callq 0x56770
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv.h
// Function: VP8YuvToRgba4444
static WEBP_INLINE void VP8YuvToRgba4444(int y, int u, int v,
                                         uint8_t* const argb) {
  const int r = VP8YUVToR(y, v);        // 4 usable bits
  const int g = VP8YUVToG(y, u, v);     // 4 usable bits
  const int b = VP8YUVToB(y, u);        // 4 usable bits
  const int rg = (r & 0xf0) | (g >> 4);
  const int ba = (b & 0xf0) | 0x0f;     // overwrite the lower 4 bits
#if (WEBP_SWAP_16BIT_CSP == 1)
  argb[0] = ba;
  argb[1] = rg;
#else
  argb[0] = rg;
  argb[1] = ba;
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movl %edx, %esi
callq 0xd3da1
movl %eax, %r12d
movl %r15d, %edi
movl %r14d, %esi
movl %ebp, %edx
callq 0xd3dd4
movl %eax, %ebp
movl %r15d, %edi
movl %r14d, %esi
callq 0xd3e17
andl $0xf0, %r12d
shrl $0x4, %ebp
orl %r12d, %ebp
movb %bpl, (%rbx)
orb $0xf, %al
movb %al, 0x1(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/yuv.h
// Function: VP8YuvToRgb565
static WEBP_INLINE void VP8YuvToRgb565(int y, int u, int v,
                                       uint8_t* const rgb) {
  const int r = VP8YUVToR(y, v);      // 5 usable bits
  const int g = VP8YUVToG(y, u, v);   // 6 usable bits
  const int b = VP8YUVToB(y, u);      // 5 usable bits
  const int rg = (r & 0xf8) | (g >> 5);
  const int gb = ((g << 3) & 0xe0) | (b >> 3);
#if (WEBP_SWAP_16BIT_CSP == 1)
  rgb[0] = gb;
  rgb[1] = rg;
#else
  rgb[0] = rg;
  rgb[1] = gb;
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movl %edx, %esi
callq 0xd3da1
movl %eax, %r12d
movl %r15d, %edi
movl %r14d, %esi
movl %ebp, %edx
callq 0xd3dd4
movl %eax, %ebp
movl %r15d, %edi
movl %r14d, %esi
callq 0xd3e17
andl $0xf8, %r12d
movl %ebp, %ecx
shrl $0x5, %ecx
orl %r12d, %ecx
andl $0x1c, %ebp
shll $0x3, %ebp
shrl $0x3, %eax
orl %ebp, %eax
movb %cl, (%rbx)
movb %al, 0x1(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/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 0x9086e(%rip), %rcx     # 0x164560
movq 0x8da5f(%rip), %rbx     # 0x161758
movq (%rbx), %rax
cmpq %rax, %rcx
je 0xd3d9f
leaq -0x3e5(%rip), %rcx      # 0xd3927
movq %rcx, 0x9db25(%rip)     # 0x171838
leaq -0x38d(%rip), %rdx      # 0xd398d
movq %rdx, 0x9db27(%rip)     # 0x171848
leaq -0x335(%rip), %rsi      # 0xd39f3
movq %rsi, 0x9db01(%rip)     # 0x171830
leaq -0x2a8(%rip), %rsi      # 0xd3a8e
movq %rsi, 0x9db03(%rip)     # 0x171840
leaq -0x21e(%rip), %rsi      # 0xd3b26
movq %rsi, 0x9db05(%rip)     # 0x171850
leaq -0x1ca(%rip), %rdi      # 0xd3b88
movq %rdi, 0x9daff(%rip)     # 0x171858
leaq -0x12c(%rip), %r8       # 0xd3c34
movq %r8, 0x9daf9(%rip)      # 0x171860
movq %rcx, 0x9dafa(%rip)     # 0x171868
movq %rdx, 0x9dafb(%rip)     # 0x171870
movq %rsi, 0x9dafc(%rip)     # 0x171878
movq %rdi, 0x9dafd(%rip)     # 0x171880
testq %rax, %rax
je 0xd3d95
xorl %edi, %edi
callq *%rax
testl %eax, %eax
je 0xd3d95
callq 0xde02a
movq (%rbx), %rax
movq %rax, 0x907c1(%rip)     # 0x164560
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %r9, %rbx
movl %r8d, 0x4(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movslq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x60(%rsp), %ebp
movslq %esi, %rax
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
testl %ebp, %ebp
cmovlel %r13d, %ebp
cmpl %r13d, %ebp
je 0xd566f
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl 0x58(%rsp), %r8d
callq *0x68(%rsp)
addq 0x8(%rsp), %r12
movl %r13d, %eax
andl $0x1, %eax
negl %eax
andl 0x4(%rsp), %eax
cltq
addq %rax, %r14
addq %rax, %r15
addq 0x10(%rsp), %rbx
incl %r13d
jmp 0xd5632
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/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
pushq %r15
pushq %r14
pushq %rbx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
movl $0x2020000, %r8d        # imm = 0x2020000
xorl %r9d, %r9d
cmpq %r9, %rcx
je 0xd5976
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 %eax, %r14d
movl $0xff, %ebp
cmpl %ebp, %r14d
jl 0xd5933
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 %eax, %r10d
cmpl %ebp, %r10d
jl 0xd596a
movl $0xff, %r10d
movb %r10b, (%rdx,%r9)
incq %r9
jmp 0xd58e0
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8ebf3(%rip), %rcx     # 0x164578
movq 0x8bdcc(%rip), %rbx     # 0x161758
movq (%rbx), %rax
cmpq %rax, %rcx
je 0xd5a30
leaq 0x835(%rip), %rcx       # 0xd61d4
movq %rcx, 0x9bf7a(%rip)     # 0x171920
leaq -0x278(%rip), %rcx      # 0xd5735
movq %rcx, 0x9bf74(%rip)     # 0x171928
leaq 0x875(%rip), %rcx       # 0xd6230
movq %rcx, 0x9bf46(%rip)     # 0x171908
leaq 0x8b0(%rip), %rcx       # 0xd6279
movq %rcx, 0x9bf40(%rip)     # 0x171910
leaq -0x10d(%rip), %rcx      # 0xd58ca
movq %rcx, 0x9bf3a(%rip)     # 0x171918
testq %rax, %rax
je 0xd59f0
xorl %edi, %edi
callq *%rax
testl %eax, %eax
je 0xd59f0
callq 0xdf80d
cmpq $0x0, 0x9bf28(%rip)     # 0x171920
je 0xd5a32
cmpq $0x0, 0x9bf26(%rip)     # 0x171928
je 0xd5a51
cmpq $0x0, 0x9befc(%rip)     # 0x171908
je 0xd5a70
cmpq $0x0, 0x9befa(%rip)     # 0x171910
je 0xd5a8f
cmpq $0x0, 0x9bef8(%rip)     # 0x171918
je 0xd5aae
movq (%rbx), %rax
movq %rax, 0x8eb48(%rip)     # 0x164578
popq %rbx
retq
leaq 0x46dd6(%rip), %rdi     # 0x11c80f
leaq 0x46dea(%rip), %rsi     # 0x11c82a
leaq 0x46df1(%rip), %rcx     # 0x11c838
movl $0xf0, %edx
callq 0x56770
leaq 0x46e09(%rip), %rdi     # 0x11c861
leaq 0x46dcb(%rip), %rsi     # 0x11c82a
leaq 0x46dd2(%rip), %rcx     # 0x11c838
movl $0xf1, %edx
callq 0x56770
leaq 0x46e06(%rip), %rdi     # 0x11c87d
leaq 0x46dac(%rip), %rsi     # 0x11c82a
leaq 0x46db3(%rip), %rcx     # 0x11c838
movl $0xf2, %edx
callq 0x56770
leaq 0x46e03(%rip), %rdi     # 0x11c899
leaq 0x46d8d(%rip), %rsi     # 0x11c82a
leaq 0x46d94(%rip), %rcx     # 0x11c838
movl $0xf3, %edx
callq 0x56770
leaq 0x46e00(%rip), %rdi     # 0x11c8b5
leaq 0x46d6e(%rip), %rsi     # 0x11c82a
leaq 0x46d75(%rip), %rcx     # 0x11c838
movl $0xf4, %edx
callq 0x56770
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
movl $0xff, %ecx
cmpq %rax, %rdx
je 0xd622f
movl (%rdi,%rax,4), %r8d
movl %r8d, %r9d
shrl $0x10, %r9d
andl %ecx, %r9d
movl %r8d, %r10d
shrl $0x8, %r10d
andl %ecx, %r10d
andl %ecx, %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,%rax)
incq %rax
jmp 0xd61e0
retq
// File: /workspace/github_c_makefile_star2_O2/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        # 0xd6373
leaq 0x9b0e2(%rip), %rcx     # 0x1713b8
movq %rax, (%rcx)
leaq 0x104(%rip), %rax       # 0xd63e4
leaq 0x9b0d9(%rip), %rcx     # 0x1713c0
movq %rax, (%rcx)
leaq 0x159(%rip), %rax       # 0xd644a
leaq 0x9b0d0(%rip), %rcx     # 0x1713c8
movq %rax, (%rcx)
leaq 0x2c1(%rip), %rax       # 0xd65c3
leaq 0x9b0cf(%rip), %rcx     # 0x1713d8
movq %rax, (%rcx)
leaq 0x39a(%rip), %rax       # 0xd66ad
leaq 0x9b0c6(%rip), %rcx     # 0x1713e0
movq %rax, (%rcx)
leaq 0x4a0(%rip), %rax       # 0xd67c4
leaq 0x9b0bd(%rip), %rcx     # 0x1713e8
movq %rax, (%rcx)
leaq 0x551(%rip), %rax       # 0xd6886
leaq 0x9b0b4(%rip), %rcx     # 0x1713f0
movq %rax, (%rcx)
leaq 0x5f1(%rip), %rax       # 0xd6937
leaq 0x9b0b3(%rip), %rcx     # 0x171400
movq %rax, (%rcx)
leaq 0x620(%rip), %rax       # 0xd6977
leaq 0x9b0aa(%rip), %rcx     # 0x171408
movq %rax, (%rcx)
leaq 0x6c9(%rip), %rax       # 0xd6a31
leaq 0x9b0a1(%rip), %rcx     # 0x171410
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testl %edx, %edx
je 0xd6388
subl %eax, %esi
jle 0xd63e3
movl %eax, %eax
leaq (%rdi,%rax,4), %rdi
jmp 0xce930
movslq %esi, %rcx
xorl %eax, %eax
pxor %xmm0, %xmm0
movdqa 0x46547(%rip), %xmm1    # 0x11c8e0
movdqa 0x4654f(%rip), %xmm2    # 0x11c8f0
movdqa 0x46557(%rip), %xmm3    # 0x11c900
leaq 0x2(%rax), %r8
cmpq %rcx, %r8
jg 0xd6379
movq (%rdi,%rax,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,%rax,4)
movq %r8, %rax
jmp 0xd63a9
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testl %ecx, %ecx
je 0xd63fb
subl %eax, %edx
jle 0xd6449
movl %eax, %eax
addq %rax, %rdi
addq %rax, %rsi
jmp 0xce9e5
movslq %edx, %r8
xorl %eax, %eax
pxor %xmm0, %xmm0
movdqa 0x464e4(%rip), %xmm1    # 0x11c8f0
movdqa 0x464ec(%rip), %xmm2    # 0x11c900
leaq 0x8(%rax), %r9
cmpq %r8, %r9
jg 0xd63ea
movq (%rdi,%rax), %xmm3
movq (%rsi,%rax), %xmm4
punpcklbw %xmm0, %xmm3    # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1],xmm3[2],xmm0[2],xmm3[3],xmm0[3],xmm3[4],xmm0[4],xmm3[5],xmm0[5],xmm3[6],xmm0[6],xmm3[7],xmm0[7]
punpcklbw %xmm0, %xmm4    # xmm4 = xmm4[0],xmm0[0],xmm4[1],xmm0[1],xmm4[2],xmm0[2],xmm4[3],xmm0[3],xmm4[4],xmm0[4],xmm4[5],xmm0[5],xmm4[6],xmm0[6],xmm4[7],xmm0[7]
pmullw %xmm3, %xmm4
paddw %xmm1, %xmm4
pmulhuw %xmm2, %xmm4
packuswb %xmm4, %xmm4
movq %xmm4, (%rdi,%rax)
movq %r9, %rax
jmp 0xd6414
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
leal -0x1(%rdx), %r10d
andl $-0x8, %r10d
movslq %esi, %rax
movslq %r9d, %rsi
movslq %r10d, %r9
xorl %r10d, %r10d
testl %ecx, %ecx
cmovlel %r10d, %ecx
movslq %edx, %r11
movl $0xff, %edx
movq 0x4619c(%rip), %xmm0    # 0x11c990
movdqa 0x46164(%rip), %xmm1    # 0x11c960
cmpl %ecx, %r10d
je 0xd6866
movq %rdi, %rbx
movq %r8, %r14
xorl %r15d, %r15d
cmpq %r9, %r15
jge 0xd6856
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
addq $0x8, %r14
addq $0x20, %rbx
jmp 0xd680a
movzbl (%rbx), %ebp
movb %bpl, (%r14)
andl %ebp, %edx
incq %r15
incq %r14
addq $0x4, %rbx
cmpq %r11, %r15
jl 0xd6844
addq %rax, %rdi
addq %rsi, %r8
incl %r10d
jmp 0xd67fc
pcmpeqb 0x103d2(%rip), %xmm0    # 0xe6c40
pmovmskb %xmm0, %eax
andl %eax, %edx
xorl %eax, %eax
cmpl $0xff, %edx
sete %al
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movslq %edx, %rax
xorl %ecx, %ecx
movdqa 0x460cd(%rip), %xmm0    # 0x11c960
leaq 0x10(%rcx), %r8
cmpq %rax, %r8
jg 0xd68ed
movdqu (%rdi,%rcx,4), %xmm1
movdqu 0x10(%rdi,%rcx,4), %xmm2
movdqu 0x20(%rdi,%rcx,4), %xmm3
movdqu 0x30(%rdi,%rcx,4), %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,%rcx)
movq %r8, %rcx
jmp 0xd6893
leaq 0x8(%rcx), %r8
cmpl %edx, %r8d
jg 0xd6923
movdqu (%rdi,%rcx,4), %xmm1
movdqu 0x10(%rdi,%rcx,4), %xmm2
psrld $0x8, %xmm1
psrld $0x8, %xmm2
pand %xmm0, %xmm1
pand %xmm0, %xmm2
packssdw %xmm2, %xmm1
packuswb %xmm1, %xmm1
movq %xmm1, (%rsi,%rcx)
movl %r8d, %ecx
movl %ecx, %ecx
cmpq %rax, %rcx
jge 0xd6936
movb 0x1(%rdi,%rcx,4), %dl
movb %dl, (%rsi,%rcx)
incq %rcx
jmp 0xd6925
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rcx
xorl %edx, %edx
pcmpeqd %xmm0, %xmm0
pushq $0x1
popq %rax
leaq 0x10(%rdx), %rsi
cmpq %rcx, %rsi
jg 0xd696f
movdqu (%rdi,%rdx), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %edx
xorl $0xffff, %edx           # imm = 0xFFFF
movq %rsi, %rdx
je 0xd6943
retq
cmpb $-0x1, (%rdi,%rdx)
leaq 0x1(%rdx), %rdx
jne 0xd6964
cmpq %rcx, %rdx
jl 0xd6965
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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), %eax
movslq %eax, %rcx
xorl %edx, %edx
movdqa 0x45fd5(%rip), %xmm0    # 0x11c960
pcmpeqd %xmm1, %xmm1
pushq $0x1
popq %rax
leaq 0x40(%rdx), %rsi
cmpq %rcx, %rsi
jg 0xd69e3
movdqu (%rdi,%rdx), %xmm2
movdqu 0x10(%rdi,%rdx), %xmm3
movdqu 0x20(%rdi,%rdx), %xmm4
movdqu 0x30(%rdi,%rdx), %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, %edx
xorl $0xffff, %edx           # imm = 0xFFFF
movq %rsi, %rdx
je 0xd6992
jmp 0xd6a1e
pcmpeqd %xmm1, %xmm1
leaq 0x20(%rdx), %rsi
cmpq %rcx, %rsi
jg 0xd6a29
movdqu (%rdi,%rdx), %xmm2
movdqu 0x10(%rdi,%rdx), %xmm3
pand %xmm0, %xmm2
pand %xmm0, %xmm3
packssdw %xmm3, %xmm2
packuswb %xmm2, %xmm2
pcmpeqb %xmm1, %xmm2
pmovmskb %xmm2, %edx
xorl $0xffff, %edx           # imm = 0xFFFF
movq %rsi, %rdx
je 0xd69e7
retq
cmpb $-0x1, (%rdi,%rdx)
leaq 0x4(%rdx), %rdx
jne 0xd6a1e
cmpq %rcx, %rdx
jle 0xd6a1f
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movd %edx, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movslq %esi, %rax
xorl %ecx, %ecx
movdqa 0x45f29(%rip), %xmm1    # 0x11c970
movdqa 0x45f31(%rip), %xmm2    # 0x11c980
leaq 0x8(%rcx), %rsi
cmpq %rax, %rsi
jg 0xd6ab2
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)
movq %rsi, %rcx
jmp 0xd6a4f
cmpl $0xffffff, (%rdi,%rcx,4) # imm = 0xFFFFFF
ja 0xd6aaf
movl %edx, (%rdi,%rcx,4)
incq %rcx
cmpq %rax, %rcx
jl 0xd6aa3
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/libraries/libwebp/src/dsp/dec_sse2.c
// Function: HFilter8_SSE2
static void HFilter8_SSE2(uint8_t* u, uint8_t* v, int stride,
                          int thresh, int ithresh, int hev_thresh) {
  __m128i mask;
  __m128i p3, p2, p1, p0, q0, q1, q2, q3;

  uint8_t* const tu = u - 4;
  uint8_t* const tv = v - 4;
  Load16x4_SSE2(tu, tv, stride, &p3, &p2, &p1, &p0);
  MAX_DIFF1(p3, p2, p1, p0, mask);

  Load16x4_SSE2(u, v, stride, &q0, &q1, &q2, &q3);
  MAX_DIFF2(q3, q2, q1, q0, mask);

  ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
  DoFilter6_SSE2(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);

  Store16x4_SSE2(&p3, &p2, &p1, &p0, tu, tv, stride);
  Store16x4_SSE2(&q0, &q1, &q2, &q3, u, v, stride);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %r9d, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x4(%rdi), %rdi
movq %r14, 0x20(%rsp)
movq %rdi, 0x38(%rsp)
leaq -0x4(%rsi), %rsi
movq %rbx, 0x28(%rsp)
movq %rsi, 0x30(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq %rax, %r15
leaq 0x50(%rsp), %rcx
leaq 0xb0(%rsp), %r13
leaq 0xa0(%rsp), %r12
movl %edx, %ebp
movq %r13, %r8
movq %r12, %r9
callq 0xd8926
movdqa (%r15), %xmm0
movdqa (%r12), %xmm1
movdqa %xmm1, %xmm2
psubusb %xmm0, %xmm2
psubusb %xmm1, %xmm0
por %xmm2, %xmm0
movdqa (%r13), %xmm4
leaq 0x50(%rsp), %rax
movdqa (%rax), %xmm3
movdqa %xmm4, %xmm2
psubusb %xmm3, %xmm2
psubusb %xmm4, %xmm3
por %xmm2, %xmm3
pmaxub %xmm0, %xmm3
movdqa %xmm3, 0x70(%rsp)
movdqa %xmm1, %xmm0
psubusb %xmm4, %xmm0
psubusb %xmm1, %xmm4
por %xmm0, %xmm4
movdqa %xmm4, 0x60(%rsp)
leaq 0x80(%rsp), %rax
movq %rax, (%rsp)
movq %rax, %r15
leaq 0xd0(%rsp), %r12
leaq 0xc0(%rsp), %r13
leaq 0x90(%rsp), %r9
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r12, %rcx
movq %r13, %r8
movq %r9, %rbx
callq 0xd8926
movdqa (%r12), %xmm0
movdqa (%r13), %xmm1
movdqa %xmm1, %xmm2
psubusb %xmm0, %xmm2
psubusb %xmm1, %xmm0
por %xmm2, %xmm0
pmaxub 0x60(%rsp), %xmm0
pmaxub 0x70(%rsp), %xmm0
movdqa (%rbx), %xmm2
movdqa (%r15), %xmm3
movdqa %xmm2, %xmm4
psubusb %xmm3, %xmm4
psubusb %xmm2, %xmm3
por %xmm4, %xmm3
movdqa %xmm1, %xmm4
psubusb %xmm2, %xmm4
psubusb %xmm1, %xmm2
por %xmm4, %xmm2
pmaxub %xmm3, %xmm2
pmaxub %xmm0, %xmm2
leaq 0xe0(%rsp), %r15
movdqa %xmm2, (%r15)
movq %r15, (%rsp)
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
leaq 0x40(%rsp), %rbx
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %rcx
movl 0x14(%rsp), %r8d
movl 0x18(%rsp), %r9d
callq 0xd8554
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
movq %r15, (%rsp)
leaq 0xb0(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movq %r13, %r8
leaq 0x90(%rsp), %rbx
movq %rbx, %r9
callq 0xd85a5
movl %ebp, (%rsp)
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
leaq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r9
callq 0xd89a3
movl %ebp, (%rsp)
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
leaq 0x80(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x28(%rsp), %r9
callq 0xd89a3
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq