LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: EmitRescaledRGB
static int EmitRescaledRGB(const VP8Io* const io, WebPDecParams* const p) {
  const int mb_h = io->mb_h;
  const int uv_mb_h = (mb_h + 1) >> 1;
  int j = 0, uv_j = 0;
  int num_lines_out = 0;
  while (j < mb_h) {
    const int y_lines_in =
        WebPRescalerImport(p->scaler_y, mb_h - j,
                           io->y + (size_t)j * io->y_stride, io->y_stride);
    j += y_lines_in;
    if (WebPRescaleNeededLines(p->scaler_u, uv_mb_h - uv_j)) {
      const int u_lines_in = WebPRescalerImport(
          p->scaler_u, uv_mb_h - uv_j, io->u + (size_t)uv_j * io->uv_stride,
          io->uv_stride);
      const int v_lines_in = WebPRescalerImport(
          p->scaler_v, uv_mb_h - uv_j, io->v + (size_t)uv_j * io->uv_stride,
          io->uv_stride);
      (void)v_lines_in;   // remove a gcc warning
      assert(u_lines_in == v_lines_in);
      uv_j += u_lines_in;
    }
    num_lines_out += ExportRGB(p, p->last_y + num_lines_out);
  }
  return num_lines_out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
sarl %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1418b3
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x14(%rbp), %esi
subl -0x1c(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
movslq -0x1c(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
imulq %rcx, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
callq 0x13d830
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0x18(%rbp), %esi
subl -0x20(%rbp), %esi
callq 0x13d7e0
cmpl $0x0, %eax
je 0x141895
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0x18(%rbp), %esi
subl -0x20(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
movslq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x34(%rcx), %rcx
imulq %rcx, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movl 0x34(%rax), %ecx
callq 0x13d830
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movl -0x18(%rbp), %esi
subl -0x20(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdx
movslq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x34(%rcx), %rcx
imulq %rcx, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movl 0x34(%rax), %ecx
callq 0x13d830
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jne 0x14186d
jmp 0x14188c
leaq 0x7b4ca(%rip), %rdi     # 0x1bcd3e
leaq 0x7b495(%rip), %rsi     # 0x1bcd10
movl $0x192, %edx            # imm = 0x192
leaq 0x7b4d0(%rip), %rcx     # 0x1bcd57
callq 0x598a0
movl -0x2c(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %esi
addl -0x24(%rbp), %esi
callq 0x141d00
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x14178a
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: EmitRescaledAlphaRGB
static int EmitRescaledAlphaRGB(const VP8Io* const io, WebPDecParams* const p,
                                int expected_num_out_lines) {
  if (io->a != NULL) {
    WebPRescaler* const scaler = p->scaler_a;
    int lines_left = expected_num_out_lines;
    const int y_end = p->last_y + lines_left;
    while (lines_left > 0) {
      const int64_t row_offset = (int64_t)scaler->src_y - io->mb_y;
      WebPRescalerImport(scaler, io->mb_h + io->mb_y - scaler->src_y,
                         io->a + row_offset * io->width, io->width);
      lines_left -= p->emit_alpha_row(p, y_end - lines_left, lines_left);
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0x14198a
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x141988
movq -0x20(%rbp), %rax
movslq 0x3c(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x8(%rbp), %rax
addl 0x8(%rax), %esi
movq -0x20(%rbp), %rax
subl 0x3c(%rax), %esi
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdx
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
imulq %rcx, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
callq 0x13d830
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
subl -0x24(%rbp), %esi
movl -0x24(%rbp), %edx
callq *%rax
movl %eax, %ecx
movl -0x24(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0x141904
jmp 0x14198a
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: EmitRescaledYUV
static int EmitRescaledYUV(const VP8Io* const io, WebPDecParams* const p) {
  const int mb_h = io->mb_h;
  const int uv_mb_h = (mb_h + 1) >> 1;
  WebPRescaler* const scaler = p->scaler_y;
  int num_lines_out = 0;
  if (WebPIsAlphaMode(p->output->colorspace) && io->a != NULL) {
    // Before rescaling, we premultiply the luma directly into the io->y
    // internal buffer. This is OK since these samples are not used for
    // intra-prediction (the top samples are saved in cache_y_/u_/v_).
    // But we need to cast the const away, though.
    WebPMultRows((uint8_t*)io->y, io->y_stride,
                 io->a, io->width, io->mb_w, mb_h, 0);
  }
  num_lines_out = Rescale(io->y, io->y_stride, mb_h, scaler);
  Rescale(io->u, io->uv_stride, uv_mb_h, p->scaler_u);
  Rescale(io->v, io->uv_stride, uv_mb_h, p->scaler_v);
  return num_lines_out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
sarl %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0x1405d0
cmpl $0x0, %eax
je 0x141f93
movq -0x8(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0x141f93
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x30(%rax), %esi
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl 0xc(%rax), %r8d
movl -0x14(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x149330
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x30(%rax), %esi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x142170
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x34(%rax), %esi
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
callq 0x142170
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x34(%rax), %esi
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
callq 0x142170
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: EmitRescaledAlphaYUV
static int EmitRescaledAlphaYUV(const VP8Io* const io, WebPDecParams* const p,
                                int expected_num_lines_out) {
  const WebPYUVABuffer* const buf = &p->output->u.YUVA;
  uint8_t* const dst_a = buf->a + (size_t)p->last_y * buf->a_stride;
  if (io->a != NULL) {
    uint8_t* const dst_y = buf->y + (size_t)p->last_y * buf->y_stride;
    const int num_lines_out = Rescale(io->a, io->width, io->mb_h, p->scaler_a);
    assert(expected_num_lines_out == num_lines_out);
    if (num_lines_out > 0) {   // unmultiply the Y
      WebPMultRows(dst_y, buf->y_stride, dst_a, buf->a_stride,
                   p->scaler_a->dst_width, num_lines_out, 1);
    }
  } else if (buf->a != NULL) {
    // the user requested alpha, but there is none, set it to opaque.
    assert(p->last_y + expected_num_lines_out <= io->scaled_height);
    FillAlphaPlane(dst_a, io->scaled_width, expected_num_lines_out,
                   buf->a_stride);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x20(%rcx), %rcx
movq -0x20(%rbp), %rdx
movslq 0x2c(%rdx), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0x142104
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x20(%rcx), %rcx
movq -0x20(%rbp), %rdx
movslq 0x20(%rdx), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
callq 0x142170
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x34(%rbp), %eax
jne 0x1420ab
jmp 0x1420ca
leaq 0x7adcb(%rip), %rdi     # 0x1bce7d
leaq 0x7ac57(%rip), %rsi     # 0x1bcd10
movl $0x116, %edx            # imm = 0x116
leaq 0x7ade0(%rip), %rcx     # 0x1bcea5
callq 0x598a0
cmpl $0x0, -0x34(%rbp)
jle 0x142102
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x20(%rax), %esi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl 0x34(%rax), %r8d
movl -0x34(%rbp), %r9d
movl $0x1, (%rsp)
callq 0x149330
jmp 0x142165
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x142163
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
addl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x90(%rcx), %eax
jg 0x142127
jmp 0x142146
leaq 0x7adbf(%rip), %rdi     # 0x1bceed
leaq 0x7abdb(%rip), %rsi     # 0x1bcd10
movl $0x11d, %edx            # imm = 0x11D
leaq 0x7ad64(%rip), %rcx     # 0x1bcea5
callq 0x598a0
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8c(%rax), %esi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %ecx
callq 0x1421f0
jmp 0x142165
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: Rescale
static int Rescale(const uint8_t* src, int src_stride,
                   int new_lines, WebPRescaler* const wrk) {
  int num_lines_out = 0;
  while (new_lines > 0) {    // import new contributions of source rows.
    const int lines_in = WebPRescalerImport(wrk, new_lines, src, src_stride);
    src += lines_in * src_stride;
    new_lines -= lines_in;
    num_lines_out += WebPRescalerExport(wrk);    // emit output row(s)
  }
  return num_lines_out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x1421da
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
callq 0x13d830
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
imull -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x20(%rbp), %ecx
movl -0x10(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13d9a0
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x14218d
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: FillAlphaPlane
static void FillAlphaPlane(uint8_t* dst, int w, int h, int stride) {
  int j;
  for (j = 0; j < h; ++j) {
    memset(dst, 0xff, w * sizeof(*dst));
    dst += stride;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x142246
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
shlq $0x0, %rdx
movl $0xff, %esi
callq 0x5a200
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x14220c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/io_dec.c
// Function: GetAlphaSourceRow
static int GetAlphaSourceRow(const VP8Io* const io,
                             const uint8_t** alpha, int* const num_rows) {
  int start_y = io->mb_y;
  *num_rows = io->mb_h;

  // Compensate for the 1-line delay of the fancy upscaler.
  // This is similar to EmitFancyRGB().
  if (io->fancy_upsampling) {
    if (start_y == 0) {
      // We don't process the last row yet. It'll be done during the next call.
      --*num_rows;
    } else {
      --start_y;
      // Fortunately, *alpha data is persistent, so we can go back
      // one row and finish alpha blending, now that the fancy upscaler
      // completed the YUV->RGB interpolation.
      *alpha -= io->width;
    }
    if (io->crop_top + io->mb_y + io->mb_h == io->crop_bottom) {
      // If it's the very last call, we process all the remaining rows!
      *num_rows = io->crop_bottom - io->crop_top - start_y;
    }
  }
  return start_y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x58(%rax)
je 0x1422fb
cmpl $0x0, -0x1c(%rbp)
jne 0x142294
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x1422b8
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movslq %edx, %rsi
xorl %edx, %edx
subq %rsi, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x80(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x8(%rcx), %eax
movq -0x8(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x8(%rbp), %rcx
cmpl 0x84(%rcx), %eax
jne 0x1422f9
movq -0x8(%rbp), %rax
movl 0x84(%rax), %ecx
movq -0x8(%rbp), %rax
subl 0x80(%rax), %ecx
subl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1422fb
movl -0x1c(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: VP8InitIoInternal
int VP8InitIoInternal(VP8Io* const io, int version) {
  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) {
    return 0;  // mismatch error
  }
  if (io != NULL) {
    memset(io, 0, sizeof(*io));
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
sarl $0x8, %eax
cmpl $0x2, %eax
je 0x142333
movl $0x0, -0x4(%rbp)
jmp 0x142351
cmpq $0x0, -0x10(%rbp)
je 0x14234a
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0xa0, %edx
callq 0x5a200
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: VP8New
VP8Decoder* VP8New(void) {
  VP8Decoder* const dec = (VP8Decoder*)WebPSafeCalloc(1ULL, sizeof(*dec));
  if (dec != NULL) {
    SetOk(dec);
    WebPGetWorkerInterface()->Init(&dec->worker_);
    dec->ready_ = 0;
    dec->num_parts_minus_one_ = 0;
    InitGetCoeffs();
  }
  return dec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0xbd0, %esi            # imm = 0xBD0
callq 0x5a9f0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1423be
movq -0x8(%rbp), %rdi
callq 0x1423d0
callq 0x5ab60
movq (%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x98, %rdi
callq *%rax
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1b0(%rax)
callq 0x142400
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: VP8Clear
void VP8Clear(VP8Decoder* const dec) {
  if (dec == NULL) {
    return;
  }
  WebPGetWorkerInterface()->End(&dec->worker_);
  WebPDeallocateAlphaMemory(dec);
  WebPSafeFree(dec->mem_);
  dec->mem_ = NULL;
  dec->mem_size_ = 0;
  memset(&dec->br_, 0, sizeof(dec->br_));
  dec->ready_ = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x142505
jmp 0x142571
callq 0x5ab60
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x98, %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x184730
movq -0x8(%rbp), %rax
movq 0xb48(%rax), %rdi
callq 0x5b920
movq -0x8(%rbp), %rax
movq $0x0, 0xb48(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xb50(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x5a200
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: VP8SetError
int VP8SetError(VP8Decoder* const dec,
                VP8StatusCode error, const char* const msg) {
  // VP8_STATUS_SUSPENDED is only meaningful in incremental decoding.
  assert(dec->incremental_ || error != VP8_STATUS_SUSPENDED);
  // The oldest error reported takes precedence over the new one.
  if (dec->status_ == VP8_STATUS_OK) {
    dec->status_ = error;
    dec->error_msg_ = msg;
    dec->ready_ = 0;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x1425a3
cmpl $0x5, -0xc(%rbp)
je 0x1425a5
jmp 0x1425c4
leaq 0x7aa8a(%rip), %rdi     # 0x1bd036
leaq 0x7aab6(%rip), %rsi     # 0x1bd069
movl $0x5a, %edx
leaq 0x7aabc(%rip), %rcx     # 0x1bd07b
callq 0x598a0
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x1425ed
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: ResetSegmentHeader
static void ResetSegmentHeader(VP8SegmentHeader* const hdr) {
  assert(hdr != NULL);
  hdr->use_segment_ = 0;
  hdr->update_map_ = 0;
  hdr->absolute_delta_ = 1;
  memset(hdr->quantizer_, 0, sizeof(hdr->quantizer_));
  memset(hdr->filter_strength_, 0, sizeof(hdr->filter_strength_));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x142cf5
jmp 0x142d14
leaq 0x7a530(%rip), %rdi     # 0x1bd22c
leaq 0x7a366(%rip), %rsi     # 0x1bd069
movl $0x99, %edx
leaq 0x7a529(%rip), %rcx     # 0x1bd238
callq 0x598a0
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0xc, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x5a200
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x5a200
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: ParseFilterHeader
static int ParseFilterHeader(VP8BitReader* br, VP8Decoder* const dec) {
  VP8FilterHeader* const hdr = &dec->filter_hdr_;
  hdr->simple_    = VP8Get(br, "global-header");
  hdr->level_     = VP8GetValue(br, 6, "global-header");
  hdr->sharpness_ = VP8GetValue(br, 3, "global-header");
  hdr->use_lf_delta_ = VP8Get(br, "global-header");
  if (hdr->use_lf_delta_) {
    if (VP8Get(br, "global-header")) {   // update lf-delta?
      int i;
      for (i = 0; i < NUM_REF_LF_DELTAS; ++i) {
        if (VP8Get(br, "global-header")) {
          hdr->ref_lf_delta_[i] = VP8GetSignedValue(br, 6, "global-header");
        }
      }
      for (i = 0; i < NUM_MODE_LF_DELTAS; ++i) {
        if (VP8Get(br, "global-header")) {
          hdr->mode_lf_delta_[i] = VP8GetSignedValue(br, 6, "global-header");
        }
      }
    }
  }
  dec->filter_type_ = (hdr->level_ == 0) ? 0 : hdr->simple_ ? 1 : 2;
  return !br->eof_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x54, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x181ef0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x181ef0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x181ef0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x181ef0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x1430b2
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x181ef0
cmpl $0x0, %eax
je 0x1430b0
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x143065
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x181ef0
cmpl $0x0, %eax
je 0x143058
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x182020
movl %eax, %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, 0x10(%rax,%rcx,4)
jmp 0x14305a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x143023
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x1430ae
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x181ef0
cmpl $0x0, %eax
je 0x1430a1
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x182020
movl %eax, %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, 0x20(%rax,%rcx,4)
jmp 0x1430a3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x14306c
jmp 0x1430b0
jmp 0x1430b2
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x1430c3
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0x1430dc
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl $0x2, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xb68(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: VP8DecodeMB
int VP8DecodeMB(VP8Decoder* const dec, VP8BitReader* const token_br) {
  VP8MB* const left = dec->mb_info_ - 1;
  VP8MB* const mb = dec->mb_info_ + dec->mb_x_;
  VP8MBData* const block = dec->mb_data_ + dec->mb_x_;
  int skip = dec->use_skip_proba_ ? block->skip_ : 0;

  if (!skip) {
    skip = ParseResiduals(dec, mb, token_br);
  } else {
    left->nz_ = mb->nz_ = 0;
    if (!block->is_i4x4_) {
      left->nz_dc_ = mb->nz_dc_ = 0;
    }
    block->non_zero_y_ = 0;
    block->non_zero_uv_ = 0;
    block->dither_ = 0;
  }

  if (dec->filter_type_ > 0) {  // store filter info
    VP8FInfo* const finfo = dec->f_info_ + dec->mb_x_;
    *finfo = dec->fstrengths_[block->segment_][block->is_i4x4_];
    finfo->f_inner_ |= !skip;
  }

  return !token_br->eof_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xb10(%rax), %rax
addq $-0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0xb10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0xb58(%rcx), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0xb60(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0xb58(%rcx), %rcx
imulq $0x320, %rcx, %rcx      # imm = 0x320
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xaf0(%rax)
je 0x143344
movq -0x28(%rbp), %rax
movzbl 0x31d(%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0x14334b
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x14334b
movl -0x3c(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x14336d
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x143460
movl %eax, -0x2c(%rbp)
jmp 0x1433bf
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
cmpb $0x0, 0x300(%rax)
jne 0x143398
movq -0x20(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x314(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x318(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x31c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xb68(%rax)
jle 0x143439
movq -0x8(%rbp), %rax
movq 0xb18(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0xb58(%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0xb6c, %rcx            # imm = 0xB6C
movq -0x28(%rbp), %rdx
movzbl 0x31e(%rdx), %edx
shlq $0x3, %rdx
addq %rdx, %rcx
movq -0x28(%rbp), %rdx
movzbl 0x300(%rdx), %edx
movl (%rcx,%rdx,4), %ecx
movl %ecx, (%rax)
cmpl $0x0, -0x2c(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %edx
movq -0x38(%rbp), %rax
movzbl 0x2(%rax), %ecx
orl %edx, %ecx
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: VP8InitScanline
void VP8InitScanline(VP8Decoder* const dec) {
  VP8MB* const left = dec->mb_info_ - 1;
  left->nz_ = 0;
  left->nz_dc_ = 0;
  memset(dec->intra_l_, B_DC_PRED, sizeof(dec->intra_l_));
  dec->mb_x_ = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xb10(%rax), %rax
addq $-0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rdi
addq $0xb00, %rdi            # imm = 0xB00
xorl %esi, %esi
movl $0x4, %edx
callq 0x5a200
movq -0x8(%rbp), %rax
movl $0x0, 0xb58(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: VP8Decode
int VP8Decode(VP8Decoder* const dec, VP8Io* const io) {
  int ok = 0;
  if (dec == NULL) {
    return 0;
  }
  if (io == NULL) {
    return VP8SetError(dec, VP8_STATUS_INVALID_PARAM,
                       "NULL VP8Io parameter in VP8Decode().");
  }

  if (!dec->ready_) {
    if (!VP8GetHeaders(dec, io)) {
      return 0;
    }
  }
  assert(dec->ready_);

  // Finish setting up the decoding parameter. Will call io->setup().
  ok = (VP8EnterCritical(dec, io) == VP8_STATUS_OK);
  if (ok) {   // good to go.
    // Will allocate memory and prepare everything.
    if (ok) ok = VP8InitFrame(dec, io);

    // Main decoding loop
    if (ok) ok = ParseFrame(dec, io);

    // Exit.
    ok &= VP8ExitCritical(dec, io);
  }

  if (!ok) {
    VP8Clear(dec);
    return 0;
  }

  dec->ready_ = 0;
  return ok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x143a2a
movl $0x0, -0x4(%rbp)
jmp 0x143b2c
cmpq $0x0, -0x18(%rbp)
jne 0x143a4e
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x7978b(%rip), %rdx     # 0x1bd1cc
callq 0x142580
movl %eax, -0x4(%rbp)
jmp 0x143b2c
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x143a78
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1427d0
cmpl $0x0, %eax
jne 0x143a76
movl $0x0, -0x4(%rbp)
jmp 0x143b2c
jmp 0x143a78
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x143a84
jmp 0x143aa3
leaq 0x79766(%rip), %rdi     # 0x1bd1f1
leaq 0x795d7(%rip), %rsi     # 0x1bd069
movl $0x2b3, %edx            # imm = 0x2B3
leaq 0x7975f(%rip), %rcx     # 0x1bd1fd
callq 0x598a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13ee30
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x143b03
cmpl $0x0, -0x1c(%rbp)
je 0x143ada
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13f2d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x143af0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x143b40
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13f1f0
andl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x143b1b
movq -0x10(%rbp), %rdi
callq 0x1424f0
movl $0x0, -0x4(%rbp)
jmp 0x143b2c
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: ParseFrame
static int ParseFrame(VP8Decoder* const dec, VP8Io* io) {
  for (dec->mb_y_ = 0; dec->mb_y_ < dec->br_mb_y_; ++dec->mb_y_) {
    // Parse bitstream for this row.
    VP8BitReader* const token_br =
        &dec->parts_[dec->mb_y_ & dec->num_parts_minus_one_];
    if (!VP8ParseIntraModeRow(&dec->br_, dec)) {
      return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA,
                         "Premature end-of-partition0 encountered.");
    }
    for (; dec->mb_x_ < dec->mb_w_; ++dec->mb_x_) {
      if (!VP8DecodeMB(dec, token_br)) {
        return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA,
                           "Premature end-of-file encountered.");
      }
    }
    VP8InitScanline(dec);   // Prepare for next scanline

    // Reconstruct, filter and emit the row.
    if (!VP8ProcessRow(dec, io)) {
      return VP8SetError(dec, VP8_STATUS_USER_ABORT, "Output aborted.");
    }
  }
  if (dec->mt_method_ > 0) {
    if (!WebPGetWorkerInterface()->Sync(&dec->worker_)) return 0;
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0xb5c(%rax)
movq -0x10(%rbp), %rax
movl 0xb5c(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1ac(%rcx), %eax
jge 0x143c83
movq -0x10(%rbp), %rax
addq $0x1b8, %rax            # imm = 0x1B8
movq -0x10(%rbp), %rcx
movl 0xb5c(%rcx), %ecx
movq -0x10(%rbp), %rdx
andl 0x1b0(%rdx), %ecx
movl %ecx, %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x185460
cmpl $0x0, %eax
jne 0x143bd6
movq -0x10(%rbp), %rdi
movl $0x7, %esi
leaq 0x797af(%rip), %rdx     # 0x1bd378
callq 0x142580
movl %eax, -0x4(%rbp)
jmp 0x143cbd
jmp 0x143bd8
movq -0x10(%rbp), %rax
movl 0xb58(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x198(%rcx), %eax
jge 0x143c34
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1432c0
cmpl $0x0, %eax
jne 0x143c1d
movq -0x10(%rbp), %rdi
movl $0x7, %esi
leaq 0x79791(%rip), %rdx     # 0x1bd3a1
callq 0x142580
movl %eax, -0x4(%rbp)
jmp 0x143cbd
jmp 0x143c1f
movq -0x10(%rbp), %rax
movl 0xb58(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xb58(%rax)
jmp 0x143bd8
movq -0x10(%rbp), %rdi
callq 0x1439a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13e000
cmpl $0x0, %eax
jne 0x143c69
movq -0x10(%rbp), %rdi
movl $0x6, %esi
leaq 0x79765(%rip), %rdx     # 0x1bd3c4
callq 0x142580
movl %eax, -0x4(%rbp)
jmp 0x143cbd
jmp 0x143c6b
movq -0x10(%rbp), %rax
movl 0xb5c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xb5c(%rax)
jmp 0x143b5e
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc8(%rax)
jle 0x143cb6
callq 0x5ab60
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
callq *%rax
cmpl $0x0, %eax
jne 0x143cb4
movl $0x0, -0x4(%rbp)
jmp 0x143cbd
jmp 0x143cb6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: InitGetCoeffs_body
WEBP_DSP_INIT_FUNC(InitGetCoeffs) {
  if (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kSlowSSSE3)) {
    GetCoeffs = GetCoeffsAlt;
  } else {
    GetCoeffs = GetCoeffsFast;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xc4a55(%rip), %rax     # 0x208730
cmpq $0x0, (%rax)
je 0x143d04
movl $0x2, %edi
movq 0xc4a43(%rip), %rax     # 0x208730
callq *(%rax)
cmpl $0x0, %eax
je 0x143d04
leaq 0x25(%rip), %rax        # 0x143d20
movq %rax, 0xd513e(%rip)     # 0x218e40
jmp 0x143d12
leaq 0x185(%rip), %rax       # 0x143e90
movq %rax, 0xd512e(%rip)     # 0x218e40
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: GetCoeffsAlt
static int GetCoeffsAlt(VP8BitReader* const br,
                        const VP8BandProbas* const prob[],
                        int ctx, const quant_t dq, int n, int16_t* out) {
  const uint8_t* p = prob[n]->probas_[ctx];
  for (; n < 16; ++n) {
    if (!VP8GetBitAlt(br, p[0], "coeffs")) {
      return n;  // previous coeff was last non-zero coeff
    }
    while (!VP8GetBitAlt(br, p[1], "coeffs")) {       // sequence of zero coeffs
      p = prob[++n]->probas_[0];
      if (n == 16) return 16;
    }
    {        // non zero coeff
      const VP8ProbaArray* const p_ctx = &prob[n + 1]->probas_[0];
      int v;
      if (!VP8GetBitAlt(br, p[2], "coeffs")) {
        v = 1;
        p = p_ctx[1];
      } else {
        v = GetLargeValue(br, p);
        p = p_ctx[2];
      }
      out[kZigzag[n]] = VP8GetSigned(br, v, "coeffs") * dq[n > 0];
    }
  }
  return 16;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xb, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
cmpl $0x10, -0x2c(%rbp)
jge 0x143e79
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rax
movzbl (%rax), %esi
callq 0x144000
cmpl $0x0, %eax
jne 0x143d84
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x143e80
jmp 0x143d86
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rax
movzbl 0x1(%rax), %esi
callq 0x144000
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x143da5
jmp 0x143dd1
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x2c(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpl $0x10, -0x2c(%rbp)
jne 0x143dcf
movl $0x10, -0x4(%rbp)
jmp 0x143e80
jmp 0x143d86
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rax
movzbl 0x2(%rax), %esi
callq 0x144000
cmpl $0x0, %eax
jne 0x143e11
movl $0x1, -0x4c(%rbp)
movq -0x48(%rbp), %rax
addq $0xb, %rax
movq %rax, -0x40(%rbp)
jmp 0x143e2d
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x1440f0
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
addq $0x16, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x144270
movq -0x28(%rbp), %rcx
cmpl $0x0, -0x2c(%rbp)
setg %dl
andb $0x1, %dl
movzbl %dl, %edx
movslq %edx, %rdx
imull (%rcx,%rdx,4), %eax
movw %ax, %dx
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rsi
leaq 0x7957d(%rip), %rcx     # 0x1bd3e0
movzbl (%rcx,%rsi), %ecx
movw %dx, (%rax,%rcx,2)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x143d5a
movl $0x10, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: GetCoeffsFast
static int GetCoeffsFast(VP8BitReader* const br,
                         const VP8BandProbas* const prob[],
                         int ctx, const quant_t dq, int n, int16_t* out) {
  const uint8_t* p = prob[n]->probas_[ctx];
  for (; n < 16; ++n) {
    if (!VP8GetBit(br, p[0], "coeffs")) {
      return n;  // previous coeff was last non-zero coeff
    }
    while (!VP8GetBit(br, p[1], "coeffs")) {       // sequence of zero coeffs
      p = prob[++n]->probas_[0];
      if (n == 16) return 16;
    }
    {        // non zero coeff
      const VP8ProbaArray* const p_ctx = &prob[n + 1]->probas_[0];
      int v;
      if (!VP8GetBit(br, p[2], "coeffs")) {
        v = 1;
        p = p_ctx[1];
      } else {
        v = GetLargeValue(br, p);
        p = p_ctx[2];
      }
      out[kZigzag[n]] = VP8GetSigned(br, v, "coeffs") * dq[n > 0];
    }
  }
  return 16;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xb, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
cmpl $0x10, -0x2c(%rbp)
jge 0x143fe9
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rax
movzbl (%rax), %esi
callq 0x144400
cmpl $0x0, %eax
jne 0x143ef4
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x143ff0
jmp 0x143ef6
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rax
movzbl 0x1(%rax), %esi
callq 0x144400
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x143f15
jmp 0x143f41
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x2c(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpl $0x10, -0x2c(%rbp)
jne 0x143f3f
movl $0x10, -0x4(%rbp)
jmp 0x143ff0
jmp 0x143ef6
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rax
movzbl 0x2(%rax), %esi
callq 0x144400
cmpl $0x0, %eax
jne 0x143f81
movl $0x1, -0x4c(%rbp)
movq -0x48(%rbp), %rax
addq $0xb, %rax
movq %rax, -0x40(%rbp)
jmp 0x143f9d
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x1440f0
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
addq $0x16, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x144270
movq -0x28(%rbp), %rcx
cmpl $0x0, -0x2c(%rbp)
setg %dl
andb $0x1, %dl
movzbl %dl, %edx
movslq %edx, %rdx
imull (%rcx,%rdx,4), %eax
movw %ax, %dx
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rsi
leaq 0x7940d(%rip), %rcx     # 0x1bd3e0
movzbl (%rcx,%rsi), %ecx
movw %dx, (%rax,%rcx,2)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x143eca
movl $0x10, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8_dec.c
// Function: GetLargeValue
static int GetLargeValue(VP8BitReader* const br, const uint8_t* const p) {
  int v;
  if (!VP8GetBit(br, p[3], "coeffs")) {
    if (!VP8GetBit(br, p[4], "coeffs")) {
      v = 2;
    } else {
      v = 3 + VP8GetBit(br, p[5], "coeffs");
    }
  } else {
    if (!VP8GetBit(br, p[6], "coeffs")) {
      if (!VP8GetBit(br, p[7], "coeffs")) {
        v = 5 + VP8GetBit(br, 159, "coeffs");
      } else {
        v = 7 + 2 * VP8GetBit(br, 165, "coeffs");
        v += VP8GetBit(br, 145, "coeffs");
      }
    } else {
      const uint8_t* tab;
      const int bit1 = VP8GetBit(br, p[8], "coeffs");
      const int bit0 = VP8GetBit(br, p[9 + bit1], "coeffs");
      const int cat = 2 * bit1 + bit0;
      v = 0;
      for (tab = kCat3456[cat]; *tab; ++tab) {
        v += v + VP8GetBit(br, *tab, "coeffs");
      }
      v += 3 + (8 << cat);
    }
  }
  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %esi
callq 0x144400
cmpl $0x0, %eax
jne 0x144151
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %esi
callq 0x144400
cmpl $0x0, %eax
jne 0x144135
movl $0x2, -0x14(%rbp)
jmp 0x14414c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %esi
callq 0x144400
addl $0x3, %eax
movl %eax, -0x14(%rbp)
jmp 0x144267
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x6(%rax), %esi
callq 0x144400
cmpl $0x0, %eax
jne 0x1441c2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x7(%rax), %esi
callq 0x144400
cmpl $0x0, %eax
jne 0x144193
movq -0x8(%rbp), %rdi
movl $0x9f, %esi
callq 0x144400
addl $0x5, %eax
movl %eax, -0x14(%rbp)
jmp 0x1441bd
movq -0x8(%rbp), %rdi
movl $0xa5, %esi
callq 0x144400
shll %eax
addl $0x7, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x91, %esi
callq 0x144400
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x144265
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %esi
callq 0x144400
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x9, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %esi
callq 0x144400
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
shll %eax
addl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x2c(%rbp), %rcx
leaq 0xc3d70(%rip), %rax     # 0x207f80
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x144252
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movzbl (%rax), %esi
callq 0x144400
movl %eax, %ecx
movl -0x30(%rbp), %eax
addl %ecx, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x144218
movl -0x2c(%rbp), %ecx
movl $0x8, %eax
shll %cl, %eax
addl $0x3, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x144267
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8l_dec.c
// Function: VP8LGetInfo
int VP8LGetInfo(const uint8_t* data, size_t data_size,
                int* const width, int* const height, int* const has_alpha) {
  if (data == NULL || data_size < VP8L_FRAME_HEADER_SIZE) {
    return 0;         // not enough data
  } else if (!VP8LCheckSignature(data, data_size)) {
    return 0;         // bad signature
  } else {
    int w, h, a;
    VP8LBitReader br;
    VP8LInitBitReader(&br, data, data_size);
    if (!ReadImageInfo(&br, &w, &h, &a)) {
      return 0;
    }
    if (width != NULL) *width = w;
    if (height != NULL) *height = h;
    if (has_alpha != NULL) *has_alpha = a;
    return 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1445ca
cmpq $0x5, -0x18(%rbp)
jae 0x1445d6
movl $0x0, -0x4(%rbp)
jmp 0x14465c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5cd90
cmpl $0x0, %eax
jne 0x1445f1
movl $0x0, -0x4(%rbp)
jmp 0x14465c
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x182070
leaq -0x68(%rbp), %rdi
leaq -0x34(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq -0x3c(%rbp), %rcx
callq 0x144670
cmpl $0x0, %eax
jne 0x144625
movl $0x0, -0x4(%rbp)
jmp 0x14465c
cmpq $0x0, -0x20(%rbp)
je 0x144635
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x144645
movl -0x38(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x144655
movl -0x3c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8l_dec.c
// Function: ReadImageInfo
static int ReadImageInfo(VP8LBitReader* const br,
                         int* const width, int* const height,
                         int* const has_alpha) {
  if (VP8LReadBits(br, 8) != VP8L_MAGIC_BYTE) return 0;
  *width = VP8LReadBits(br, VP8L_IMAGE_SIZE_BITS) + 1;
  *height = VP8LReadBits(br, VP8L_IMAGE_SIZE_BITS) + 1;
  *has_alpha = VP8LReadBits(br, 1);
  if (VP8LReadBits(br, VP8L_VERSION_BITS) != 0) return 0;
  return !br->eos_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x1824b0
cmpl $0x2f, %eax
je 0x1446a4
movl $0x0, -0x4(%rbp)
jmp 0x14471d
movq -0x10(%rbp), %rdi
movl $0xe, %esi
callq 0x1824b0
movl %eax, %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movl $0xe, %esi
callq 0x1824b0
movl %eax, %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1824b0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x1824b0
cmpl $0x0, %eax
je 0x144708
movl $0x0, -0x4(%rbp)
jmp 0x14471d
movq -0x10(%rbp), %rax
cmpl $0x0, 0x24(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8l_dec.c
// Function: VP8LSetError
static int VP8LSetError(VP8LDecoder* const dec, VP8StatusCode error) {
  // The oldest error reported takes precedence over the new one.
  if (dec->status_ == VP8_STATUS_OK || dec->status_ == VP8_STATUS_SUSPENDED) {
    dec->status_ = error;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x144bdd
movq -0x8(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x144be6
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/enzo1982[P]smooth/libraries/libwebp/src/dec/vp8l_dec.c
// Function: BuildPackedTable
static void BuildPackedTable(HTreeGroup* const htree_group) {
  uint32_t code;
  for (code = 0; code < HUFFMAN_PACKED_TABLE_SIZE; ++code) {
    uint32_t bits = code;
    HuffmanCode32* const huff = &htree_group->packed_table[bits];
    HuffmanCode hcode = htree_group->htrees[GREEN][bits];
    if (hcode.value >= NUM_LITERAL_CODES) {
      huff->bits = hcode.bits + BITS_SPECIAL_MARKER;
      huff->value = hcode.value;
    } else {
      huff->bits = 0;
      huff->value = 0;
      bits >>= AccumulateHCode(hcode, 8, huff);
      bits >>= AccumulateHCode(htree_group->htrees[RED][bits], 16, huff);
      bits >>= AccumulateHCode(htree_group->htrees[BLUE][bits], 0, huff);
      bits >>= AccumulateHCode(htree_group->htrees[ALPHA][bits], 24, huff);
      (void)bits;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jae 0x144f33
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x38, %rax
movl -0x10(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x10(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movzwl -0x1a(%rbp), %eax
cmpl $0x100, %eax            # imm = 0x100
jl 0x144e84
movzbl -0x1c(%rbp), %ecx
addl $0x100, %ecx            # imm = 0x100
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movzwl -0x1a(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x144f23
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %edi
movl $0x8, %esi
callq 0x147370
movl %eax, %ecx
movl -0x10(%rbp), %eax
shrl %cl, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rdx
movl (%rax,%rcx,4), %edi
movl $0x10, %esi
callq 0x147370
movl %eax, %ecx
movl -0x10(%rbp), %eax
shrl %cl, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rdx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
callq 0x147370
movl %eax, %ecx
movl -0x10(%rbp), %eax
shrl %cl, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rdx
movl (%rax,%rcx,4), %edi
movl $0x18, %esi
callq 0x147370
movl %eax, %ecx
movl -0x10(%rbp), %eax
shrl %cl, %eax
movl %eax, -0x10(%rbp)
jmp 0x144f25
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x144e23
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)