LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jcphuff.c
// Function: emit_buffered_bits
LOCAL(void)
emit_buffered_bits (phuff_entropy_ptr entropy, char * bufstart,
		    unsigned int nbits)
{
  if (entropy->gather_statistics)
    return;			/* no real work */

  while (nbits > 0) {
    emit_bits(entropy, (unsigned int) (*bufstart), 1);
    bufstart++;
    nbits--;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0xe05ff
jmp 0xe063a
jmp 0xe0601
cmpl $0x0, 0x4(%rsp)
jbe 0xe063a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movsbl (%rax), %esi
movl $0x1, %edx
callq 0xe0280
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xe0601
addq $0x18, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jcdctmgr.c
// Function: jinit_forward_dct
GLOBAL(void)
jinit_forward_dct (j_compress_ptr cinfo)
{
  my_fdct_ptr fdct;
  int i;

  fdct = (my_fdct_ptr)
    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
				SIZEOF(my_fdct_controller));
  cinfo->fdct = (struct jpeg_forward_dct *) fdct;
  fdct->pub.start_pass = start_pass_fdctmgr;

  switch (cinfo->dct_method) {
#ifdef DCT_ISLOW_SUPPORTED
  case JDCT_ISLOW:
    fdct->pub.forward_DCT = forward_DCT;
    fdct->do_dct = jpeg_fdct_islow;
    break;
#endif
#ifdef DCT_IFAST_SUPPORTED
  case JDCT_IFAST:
    fdct->pub.forward_DCT = forward_DCT;
    fdct->do_dct = jpeg_fdct_ifast;
    break;
#endif
#ifdef DCT_FLOAT_SUPPORTED
  case JDCT_FLOAT:
    fdct->pub.forward_DCT = forward_DCT_float;
    fdct->do_float_dct = jpeg_fdct_float;
    break;
#endif
  default:
    ERREXIT(cinfo, JERR_NOT_COMPILED);
    break;
  }

  /* Mark divisor tables unallocated */
  for (i = 0; i < NUM_QUANT_TBLS; i++) {
    fdct->divisors[i] = NULL;
#ifdef DCT_FLOAT_SUPPORTED
    fdct->float_divisors[i] = NULL;
#endif
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rax
movq (%rax), %rax
movl $0x1, %esi
movl $0x60, %edx
callq *%rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x1e8(%rax)
movq 0x8(%rsp), %rax
leaq 0xfd(%rip), %rcx        # 0xe0780
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl 0x114(%rax), %eax
movl %eax, (%rsp)
testl %eax, %eax
je 0xe06ae
jmp 0xe069a
movl (%rsp), %eax
subl $0x1, %eax
je 0xe06d0
jmp 0xe06a4
movl (%rsp), %eax
subl $0x2, %eax
je 0xe06f2
jmp 0xe0714
movq 0x8(%rsp), %rax
leaq 0x446(%rip), %rcx       # 0xe0b00
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
leaq 0x15f6(%rip), %rcx      # 0xe1cc0
movq %rcx, 0x10(%rax)
jmp 0xe0735
movq 0x8(%rsp), %rax
leaq 0x424(%rip), %rcx       # 0xe0b00
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
leaq 0xb24(%rip), %rcx       # 0xe1210
movq %rcx, 0x10(%rax)
jmp 0xe0735
movq 0x8(%rsp), %rax
leaq 0x7b2(%rip), %rcx       # 0xe0eb0
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
leaq 0xfa2(%rip), %rcx       # 0xe16b0
movq %rcx, 0x38(%rax)
jmp 0xe0735
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl $0x30, 0x28(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movl $0x0, 0x4(%rsp)
cmpl $0x4, 0x4(%rsp)
jge 0xe0777
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq $0x0, 0x18(%rax,%rcx,8)
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq $0x0, 0x40(%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xe073d
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdapimin.c
// Function: jpeg_read_header
GLOBAL(int)
jpeg_read_header (j_decompress_ptr cinfo, jboolean require_image)
{
  int retcode;

  if (cinfo->global_state != DSTATE_START &&
      cinfo->global_state != DSTATE_INHEADER)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);

  retcode = jpeg_consume_input(cinfo);

  switch (retcode) {
  case JPEG_REACHED_SOS:
    retcode = JPEG_HEADER_OK;
    break;
  case JPEG_REACHED_EOI:
    if (require_image)		/* Complain if application wanted an image */
      ERREXIT(cinfo, JERR_NO_IMAGE);
    /* Reset to start state; it would be safer to require the application to
     * call jpeg_abort, but we can't change it now for compatibility reasons.
     * A side effect is to free any temporary memory (there shouldn't be any).
     */
    jpeg_abort((j_common_ptr) cinfo); /* sets state = DSTATE_START */
    retcode = JPEG_HEADER_TABLES_ONLY;
    break;
  case JPEG_SUSPENDED:
    /* no work */
    break;
  }

  return retcode;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpl $0xc8, 0x24(%rax)
je 0xe25ad
movq 0x10(%rsp), %rax
cmpl $0xc9, 0x24(%rax)
je 0xe25ad
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl $0x14, 0x28(%rax)
movq 0x10(%rsp), %rax
movl 0x24(%rax), %ecx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl %ecx, 0x2c(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movq 0x10(%rsp), %rdi
callq 0xe2630
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0xe2625
jmp 0xe25c9
movl 0x4(%rsp), %eax
subl $0x1, %eax
je 0xe25df
jmp 0xe25d4
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0xe25e9
jmp 0xe2627
movl $0x1, 0x8(%rsp)
jmp 0xe2627
cmpl $0x0, 0xc(%rsp)
je 0xe2611
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl $0x33, 0x28(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movq 0x10(%rsp), %rdi
callq 0xf91a0
movl $0x2, 0x8(%rsp)
jmp 0xe2627
jmp 0xe2627
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdapimin.c
// Function: jpeg_consume_input
GLOBAL(int)
jpeg_consume_input (j_decompress_ptr cinfo)
{
  int retcode = JPEG_SUSPENDED;

  /* NB: every possible DSTATE value should be listed in this switch */
  switch (cinfo->global_state) {
  case DSTATE_START:
    /* Start-of-datastream actions: reset appropriate modules */
    (*cinfo->inputctl->reset_input_controller) (cinfo);
    /* Initialize application's data source module */
    (*cinfo->src->init_source) (cinfo);
    cinfo->global_state = DSTATE_INHEADER;
    /*FALLTHROUGH*/
  case DSTATE_INHEADER:
    retcode = (*cinfo->inputctl->consume_input) (cinfo);
    if (retcode == JPEG_REACHED_SOS) { /* Found SOS, prepare to decompress */
      /* Set up default parameters based on header data */
      default_decompress_parms(cinfo);
      /* Set global state: ready for start_decompress */
      cinfo->global_state = DSTATE_READY;
    }
    break;
  case DSTATE_READY:
    /* Can't advance past first SOS until start_decompress is called */
    retcode = JPEG_REACHED_SOS;
    break;
  case DSTATE_PRELOAD:
  case DSTATE_PRESCAN:
  case DSTATE_SCANNING:
  case DSTATE_RAW_OK:
  case DSTATE_BUFIMAGE:
  case DSTATE_BUFPOST:
  case DSTATE_STOPPING:
    retcode = (*cinfo->inputctl->consume_input) (cinfo);
    break;
  default:
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  }
  return retcode;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0x24(%rax), %eax
addl $0xffffff38, %eax       # imm = 0xFFFFFF38
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0xa, %eax
ja 0xe2707
movq (%rsp), %rax
leaq 0x547c8(%rip), %rcx     # 0x136e30
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rax
movq 0x240(%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movq 0x10(%rsp), %rax
movl $0xc9, 0x24(%rax)
movq 0x10(%rsp), %rax
movq 0x240(%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movl %eax, 0xc(%rsp)
cmpl $0x1, 0xc(%rsp)
jne 0xe26df
movq 0x10(%rsp), %rdi
callq 0xe2750
movq 0x10(%rsp), %rax
movl $0xca, 0x24(%rax)
jmp 0xe273b
movl $0x1, 0xc(%rsp)
jmp 0xe273b
movq 0x10(%rsp), %rax
movq 0x240(%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movl %eax, 0xc(%rsp)
jmp 0xe273b
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl $0x14, 0x28(%rax)
movq 0x10(%rsp), %rax
movl 0x24(%rax), %ecx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl %ecx, 0x2c(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdapimin.c
// Function: jpeg_input_complete
GLOBAL(jboolean)
jpeg_input_complete (j_decompress_ptr cinfo)
{
  /* Check for valid jpeg object */
  if (cinfo->global_state < DSTATE_START ||
      cinfo->global_state > DSTATE_STOPPING)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  return cinfo->inputctl->eoi_reached;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpl $0xc8, 0x24(%rax)
jl 0xe2b2f
movq (%rsp), %rax
cmpl $0xd2, 0x24(%rax)
jle 0xe2b5e
movq (%rsp), %rax
movq (%rax), %rax
movl $0x14, 0x28(%rax)
movq (%rsp), %rax
movl 0x24(%rax), %ecx
movq (%rsp), %rax
movq (%rax), %rax
movl %ecx, 0x2c(%rax)
movq (%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rsp), %rdi
callq *%rax
movq (%rsp), %rax
movq 0x240(%rax), %rax
movl 0x24(%rax), %eax
popq %rcx
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdapimin.c
// Function: jpeg_has_multiple_scans
GLOBAL(jboolean)
jpeg_has_multiple_scans (j_decompress_ptr cinfo)
{
  /* Only valid after jpeg_read_header completes */
  if (cinfo->global_state < DSTATE_READY ||
      cinfo->global_state > DSTATE_STOPPING)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  return cinfo->inputctl->has_multiple_scans;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpl $0xca, 0x24(%rax)
jl 0xe2b8f
movq (%rsp), %rax
cmpl $0xd2, 0x24(%rax)
jle 0xe2bbe
movq (%rsp), %rax
movq (%rax), %rax
movl $0x14, 0x28(%rax)
movq (%rsp), %rax
movl 0x24(%rax), %ecx
movq (%rsp), %rax
movq (%rax), %rax
movl %ecx, 0x2c(%rax)
movq (%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rsp), %rdi
callq *%rax
movq (%rsp), %rax
movq 0x240(%rax), %rax
movl 0x20(%rax), %eax
popq %rcx
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdapimin.c
// Function: jpeg_finish_decompress
GLOBAL(jboolean)
jpeg_finish_decompress (j_decompress_ptr cinfo)
{
  if ((cinfo->global_state == DSTATE_SCANNING ||
       cinfo->global_state == DSTATE_RAW_OK) && ! cinfo->buffered_image) {
    /* Terminate final pass of non-buffered mode */
    if (cinfo->output_scanline < cinfo->output_height)
      ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
    (*cinfo->master->finish_output_pass) (cinfo);
    cinfo->global_state = DSTATE_STOPPING;
  } else if (cinfo->global_state == DSTATE_BUFIMAGE) {
    /* Finishing after a buffered-image operation */
    cinfo->global_state = DSTATE_STOPPING;
  } else if (cinfo->global_state != DSTATE_STOPPING) {
    /* STOPPING = repeat call after a suspension, anything else is error */
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  }
  /* Read until EOI */
  while (! cinfo->inputctl->eoi_reached) {
    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
      return FALSE;		/* Suspend, come back later */
  }
  /* Do final cleanup */
  (*cinfo->src->term_source) (cinfo);
  /* We can use jpeg_abort to release memory and reset global_state */
  jpeg_abort((j_common_ptr) cinfo);
  return TRUE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0xcd, 0x24(%rax)
je 0xe2bf5
movq 0x8(%rsp), %rax
cmpl $0xce, 0x24(%rax)
jne 0xe2c5e
movq 0x8(%rsp), %rax
cmpl $0x0, 0x58(%rax)
jne 0xe2c5e
movq 0x8(%rsp), %rax
movl 0xa8(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x8c(%rcx), %eax
jae 0xe2c39
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl $0x43, 0x28(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movq 0x8(%rsp), %rax
movq 0x220(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movq 0x8(%rsp), %rax
movl $0xd2, 0x24(%rax)
jmp 0xe2cc0
movq 0x8(%rsp), %rax
cmpl $0xcf, 0x24(%rax)
jne 0xe2c7a
movq 0x8(%rsp), %rax
movl $0xd2, 0x24(%rax)
jmp 0xe2cbe
movq 0x8(%rsp), %rax
cmpl $0xd2, 0x24(%rax)
je 0xe2cbc
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl $0x14, 0x28(%rax)
movq 0x8(%rsp), %rax
movl 0x24(%rax), %ecx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl %ecx, 0x2c(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
jmp 0xe2cbe
jmp 0xe2cc0
jmp 0xe2cc2
movq 0x8(%rsp), %rax
movq 0x240(%rax), %rax
cmpl $0x0, 0x24(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xe2cdd
jmp 0xe2d04
movq 0x8(%rsp), %rax
movq 0x240(%rax), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
cmpl $0x0, %eax
jne 0xe2d02
movl $0x0, 0x14(%rsp)
jmp 0xe2d2a
jmp 0xe2cc2
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x30(%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movq 0x8(%rsp), %rdi
callq 0xf91a0
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdapistd.c
// Function: jpeg_read_scanlines
GLOBAL(JDIMENSION)
jpeg_read_scanlines (j_decompress_ptr cinfo, JSAMPARRAY scanlines,
		     JDIMENSION max_lines)
{
  JDIMENSION row_ctr;

  if (cinfo->global_state != DSTATE_SCANNING)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  if (cinfo->output_scanline >= cinfo->output_height) {
    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
    return 0;
  }

  /* Call progress monitor hook if present */
  if (cinfo->progress != NULL) {
    cinfo->progress->pass_counter = (long) cinfo->output_scanline;
    cinfo->progress->pass_limit = (long) cinfo->output_height;
    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
  }

  /* Process some data */
  row_ctr = 0;
  (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, max_lines);
  cinfo->output_scanline += row_ctr;
  return row_ctr;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rax
cmpl $0xcd, 0x24(%rax)
je 0xe30e4
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl $0x14, 0x28(%rax)
movq 0x18(%rsp), %rax
movl 0x24(%rax), %ecx
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl %ecx, 0x2c(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rdi
callq *%rax
movq 0x18(%rsp), %rax
movl 0xa8(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8c(%rcx), %eax
jb 0xe3130
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl $0x7b, 0x28(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq *%rax
movl $0x0, 0x24(%rsp)
jmp 0xe31cd
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe3183
movq 0x18(%rsp), %rax
movl 0xa8(%rax), %eax
movl %eax, %ecx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl 0x8c(%rax), %eax
movl %eax, %ecx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rdi
callq *%rax
movl $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x228(%rax), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %ecx
leaq 0x8(%rsp), %rdx
callq *%rax
movl 0x8(%rsp), %ecx
movq 0x18(%rsp), %rax
addl 0xa8(%rax), %ecx
movl %ecx, 0xa8(%rax)
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdapistd.c
// Function: jpeg_read_raw_data
GLOBAL(JDIMENSION)
jpeg_read_raw_data (j_decompress_ptr cinfo, JSAMPIMAGE data,
		    JDIMENSION max_lines)
{
  JDIMENSION lines_per_iMCU_row;

  if (cinfo->global_state != DSTATE_RAW_OK)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  if (cinfo->output_scanline >= cinfo->output_height) {
    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
    return 0;
  }

  /* Call progress monitor hook if present */
  if (cinfo->progress != NULL) {
    cinfo->progress->pass_counter = (long) cinfo->output_scanline;
    cinfo->progress->pass_limit = (long) cinfo->output_height;
    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
  }

  /* Verify that at least one iMCU row can be returned. */
  lines_per_iMCU_row = cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size;
  if (max_lines < lines_per_iMCU_row)
    ERREXIT(cinfo, JERR_BUFFER_SIZE);

  /* Decompress directly into user's buffer. */
  if (! (*cinfo->coef->decompress_data) (cinfo, data))
    return 0;			/* suspension forced, can do nothing more */

  /* OK, we processed one iMCU row. */
  cinfo->output_scanline += lines_per_iMCU_row;
  return lines_per_iMCU_row;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rax
cmpl $0xce, 0x24(%rax)
je 0xe3234
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl $0x14, 0x28(%rax)
movq 0x18(%rsp), %rax
movl 0x24(%rax), %ecx
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl %ecx, 0x2c(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rdi
callq *%rax
movq 0x18(%rsp), %rax
movl 0xa8(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8c(%rcx), %eax
jb 0xe3280
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl $0x7b, 0x28(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq *%rax
movl $0x0, 0x24(%rsp)
jmp 0xe3361
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe32d3
movq 0x18(%rsp), %rax
movl 0xa8(%rax), %eax
movl %eax, %ecx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl 0x8c(%rax), %eax
movl %eax, %ecx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rdi
callq *%rax
movq 0x18(%rsp), %rax
movl 0x19c(%rax), %eax
movq 0x18(%rsp), %rcx
imull 0x1a0(%rcx), %eax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jae 0xe3319
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl $0x17, 0x28(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rdi
callq *%rax
movq 0x18(%rsp), %rax
movq 0x230(%rax), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0xe3344
movl $0x0, 0x24(%rsp)
jmp 0xe3361
movl 0x8(%rsp), %ecx
movq 0x18(%rsp), %rax
addl 0xa8(%rax), %ecx
movl %ecx, 0xa8(%rax)
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdapistd.c
// Function: jpeg_start_output
GLOBAL(jboolean)
jpeg_start_output (j_decompress_ptr cinfo, int scan_number)
{
  if (cinfo->global_state != DSTATE_BUFIMAGE &&
      cinfo->global_state != DSTATE_PRESCAN)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  /* Limit scan number to valid range */
  if (scan_number <= 0)
    scan_number = 1;
  if (cinfo->inputctl->eoi_reached &&
      scan_number > cinfo->input_scan_number)
    scan_number = cinfo->input_scan_number;
  cinfo->output_scan_number = scan_number;
  /* Perform any dummy output passes, and set up for the real pass */
  return output_pass_setup(cinfo);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpl $0xcf, 0x24(%rax)
je 0xe33cd
movq 0x10(%rsp), %rax
cmpl $0xcc, 0x24(%rax)
je 0xe33cd
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl $0x14, 0x28(%rax)
movq 0x10(%rsp), %rax
movl 0x24(%rax), %ecx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl %ecx, 0x2c(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
cmpl $0x0, 0xc(%rsp)
jg 0xe33dc
movl $0x1, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x240(%rax), %rax
cmpl $0x0, 0x24(%rax)
je 0xe340e
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0xac(%rcx), %eax
jle 0xe340e
movq 0x10(%rsp), %rax
movl 0xac(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xb4(%rax)
movq 0x10(%rsp), %rdi
callq 0xe2ef0
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdapistd.c
// Function: jpeg_finish_output
GLOBAL(jboolean)
jpeg_finish_output (j_decompress_ptr cinfo)
{
  if ((cinfo->global_state == DSTATE_SCANNING ||
       cinfo->global_state == DSTATE_RAW_OK) && cinfo->buffered_image) {
    /* Terminate this pass. */
    /* We do not require the whole pass to have been completed. */
    (*cinfo->master->finish_output_pass) (cinfo);
    cinfo->global_state = DSTATE_BUFPOST;
  } else if (cinfo->global_state != DSTATE_BUFPOST) {
    /* BUFPOST = repeat call after a suspension, anything else is error */
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  }
  /* Read markers looking for SOS or EOI */
  while (cinfo->input_scan_number <= cinfo->output_scan_number &&
	 ! cinfo->inputctl->eoi_reached) {
    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
      return FALSE;		/* Suspend, come back later */
  }
  cinfo->global_state = DSTATE_BUFIMAGE;
  return TRUE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0xcd, 0x24(%rax)
je 0xe3455
movq 0x8(%rsp), %rax
cmpl $0xce, 0x24(%rax)
jne 0xe3485
movq 0x8(%rsp), %rax
cmpl $0x0, 0x58(%rax)
je 0xe3485
movq 0x8(%rsp), %rax
movq 0x220(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movq 0x8(%rsp), %rax
movl $0xd0, 0x24(%rax)
jmp 0xe34c9
movq 0x8(%rsp), %rax
cmpl $0xd0, 0x24(%rax)
je 0xe34c7
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl $0x14, 0x28(%rax)
movq 0x8(%rsp), %rax
movl 0x24(%rax), %ecx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl %ecx, 0x2c(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
jmp 0xe34c9
jmp 0xe34cb
movq 0x8(%rsp), %rax
movl 0xac(%rax), %ecx
movq 0x8(%rsp), %rdx
xorl %eax, %eax
cmpl 0xb4(%rdx), %ecx
movb %al, 0x7(%rsp)
jg 0xe3502
movq 0x8(%rsp), %rax
movq 0x240(%rax), %rax
cmpl $0x0, 0x24(%rax)
setne %al
xorb $-0x1, %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xe350c
jmp 0xe3533
movq 0x8(%rsp), %rax
movq 0x240(%rax), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
cmpl $0x0, %eax
jne 0xe3531
movl $0x0, 0x14(%rsp)
jmp 0xe3547
jmp 0xe34cb
movq 0x8(%rsp), %rax
movl $0xcf, 0x24(%rax)
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdatasrc.c
// Function: jpeg_stdio_src
GLOBAL(void)
jpeg_stdio_src (j_decompress_ptr cinfo, FILE * infile)
{
  my_src_ptr src;

  /* The source object and input buffer are made permanent so that a series
   * of JPEG images can be read from the same file by calling jpeg_stdio_src
   * only before the first one.  (If we discarded the buffer at the end of
   * one image, we'd likely lose the start of the next one.)
   * This makes it unsafe to use this manager and a different source
   * manager serially with the same JPEG object.  Caveat programmer.
   */
  if (cinfo->src == NULL) {	/* first time for this JPEG object? */
    cinfo->src = (struct jpeg_source_mgr *)
      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
				  SIZEOF(my_source_mgr));
    src = (my_src_ptr) cinfo->src;
    src->buffer = (JOCTET *)
      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
				  INPUT_BUF_SIZE * SIZEOF(JOCTET));
  }

  src = (my_src_ptr) cinfo->src;
  src->pub.init_source = init_source;
  src->pub.fill_input_buffer = fill_input_buffer;
  src->pub.skip_input_data = skip_input_data;
  src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
  src->pub.term_source = term_source;
  src->infile = infile;
  src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
  src->pub.next_input_byte = NULL; /* until buffer loaded */
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xe35c2
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq *%rax
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq *%rax
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
leaq 0x76(%rip), %rcx        # 0xe3650
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
leaq 0x87(%rip), %rcx        # 0xe3670
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
leaq 0x168(%rip), %rcx       # 0xe3760
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
leaq 0x1d09(%rip), %rcx      # 0xe5310
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
leaq 0x1ca(%rip), %rcx       # 0xe37e0
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdatasrc.c
// Function: fill_input_buffer
METHODDEF(jboolean)
fill_input_buffer (j_decompress_ptr cinfo)
{
  my_src_ptr src = (my_src_ptr) cinfo->src;
  size_t nbytes;

  nbytes = JFREAD(src->infile, src->buffer, INPUT_BUF_SIZE);

  if (nbytes <= 0) {
    if (src->start_of_file)	/* Treat empty input file as fatal error */
      ERREXIT(cinfo, JERR_INPUT_EMPTY);
    WARNMS(cinfo, JWRN_JPEG_EOF);
    /* Insert a fake EOI marker */
    src->buffer[0] = (JOCTET) 0xFF;
    src->buffer[1] = (JOCTET) JPEG_EOI;
    nbytes = 2;
  }

  src->pub.next_input_byte = src->buffer;
  src->pub.bytes_in_buffer = nbytes;
  src->start_of_file = FALSE;

  return TRUE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rcx
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0xf780
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
ja 0xe3727
movq 0x8(%rsp), %rax
cmpl $0x0, 0x48(%rax)
je 0xe36df
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl $0x2a, 0x28(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl $0x78, 0x28(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq *%rax
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movb $-0x1, (%rax)
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movb $-0x27, 0x1(%rax)
movq $0x2, (%rsp)
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x48(%rax)
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdatasrc.c
// Function: skip_input_data
METHODDEF(void)
skip_input_data (j_decompress_ptr cinfo, long num_bytes)
{
  my_src_ptr src = (my_src_ptr) cinfo->src;

  /* Just a dumb implementation for now.  Could use fseek() except
   * it doesn't work on pipes.  Not clear that being smart is worth
   * any trouble anyway --- large skips are infrequent.
   */
  if (num_bytes > 0) {
    while (num_bytes > (long) src->pub.bytes_in_buffer) {
      num_bytes -= (long) src->pub.bytes_in_buffer;
      (void) fill_input_buffer(cinfo);
      /* note we assume that fill_input_buffer will never return FALSE,
       * so suspension need not be handled.
       */
    }
    src->pub.next_input_byte += (size_t) num_bytes;
    src->pub.bytes_in_buffer -= (size_t) num_bytes;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
jle 0xe37d8
jmp 0xe3785
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
cmpq 0x8(%rcx), %rax
jle 0xe37b5
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xe3670
jmp 0xe3785
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rdx
movq (%rsp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdmaster.c
// Function: use_merged_upsample
LOCAL(jboolean)
use_merged_upsample (j_decompress_ptr cinfo)
{
#ifdef UPSAMPLE_MERGING_SUPPORTED
  /* Merging is the equivalent of plain box-filter upsampling */
  if (cinfo->do_fancy_upsampling || cinfo->CCIR601_sampling)
    return FALSE;
  /* jdmerge.c only supports YCC=>RGB color conversion */
  if (cinfo->jpeg_color_space != JCS_YCbCr || cinfo->num_components != 3 ||
      cinfo->out_color_space != JCS_RGB ||
      cinfo->out_color_components != RGB_PIXELSIZE)
    return FALSE;
  /* and it only handles 2h1v or 2h2v sampling ratios */
  if (cinfo->comp_info[0].h_samp_factor != 2 ||
      cinfo->comp_info[1].h_samp_factor != 1 ||
      cinfo->comp_info[2].h_samp_factor != 1 ||
      cinfo->comp_info[0].v_samp_factor >  2 ||
      cinfo->comp_info[1].v_samp_factor != 1 ||
      cinfo->comp_info[2].v_samp_factor != 1)
    return FALSE;
  /* furthermore, it doesn't work if we've scaled the IDCTs differently */
  if (cinfo->comp_info[0].DCT_scaled_size != cinfo->min_DCT_scaled_size ||
      cinfo->comp_info[1].DCT_scaled_size != cinfo->min_DCT_scaled_size ||
      cinfo->comp_info[2].DCT_scaled_size != cinfo->min_DCT_scaled_size)
    return FALSE;
  /* ??? also need to test for upsample-time rescaling, when & if supported */
  return TRUE;			/* by golly, it'll work... */
#else
  return FALSE;
#endif
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpl $0x0, 0x64(%rax)
jne 0xe3c6e
movq -0x10(%rsp), %rax
cmpl $0x0, 0x188(%rax)
je 0xe3c7b
movl $0x0, -0x4(%rsp)
jmp 0xe3d9f
movq -0x10(%rsp), %rax
cmpl $0x3, 0x3c(%rax)
jne 0xe3caa
movq -0x10(%rsp), %rax
cmpl $0x3, 0x38(%rax)
jne 0xe3caa
movq -0x10(%rsp), %rax
cmpl $0x2, 0x40(%rax)
jne 0xe3caa
movq -0x10(%rsp), %rax
cmpl $0x3, 0x90(%rax)
je 0xe3cb7
movl $0x0, -0x4(%rsp)
jmp 0xe3d9f
movq -0x10(%rsp), %rax
movq 0x130(%rax), %rax
cmpl $0x2, 0x8(%rax)
jne 0xe3d29
movq -0x10(%rsp), %rax
movq 0x130(%rax), %rax
cmpl $0x1, 0x68(%rax)
jne 0xe3d29
movq -0x10(%rsp), %rax
movq 0x130(%rax), %rax
cmpl $0x1, 0xc8(%rax)
jne 0xe3d29
movq -0x10(%rsp), %rax
movq 0x130(%rax), %rax
cmpl $0x2, 0xc(%rax)
jg 0xe3d29
movq -0x10(%rsp), %rax
movq 0x130(%rax), %rax
cmpl $0x1, 0x6c(%rax)
jne 0xe3d29
movq -0x10(%rsp), %rax
movq 0x130(%rax), %rax
cmpl $0x1, 0xcc(%rax)
je 0xe3d33
movl $0x0, -0x4(%rsp)
jmp 0xe3d9f
movq -0x10(%rsp), %rax
movq 0x130(%rax), %rax
movl 0x24(%rax), %eax
movq -0x10(%rsp), %rcx
cmpl 0x1a0(%rcx), %eax
jne 0xe3d8d
movq -0x10(%rsp), %rax
movq 0x130(%rax), %rax
movl 0x84(%rax), %eax
movq -0x10(%rsp), %rcx
cmpl 0x1a0(%rcx), %eax
jne 0xe3d8d
movq -0x10(%rsp), %rax
movq 0x130(%rax), %rax
movl 0xe4(%rax), %eax
movq -0x10(%rsp), %rcx
cmpl 0x1a0(%rcx), %eax
je 0xe3d97
movl $0x0, -0x4(%rsp)
jmp 0xe3d9f
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdmaster.c
// Function: jpeg_new_colormap
GLOBAL(void)
jpeg_new_colormap (j_decompress_ptr cinfo)
{
  my_master_ptr master = (my_master_ptr) cinfo->master;

  /* Prevent application from calling me at wrong times */
  if (cinfo->global_state != DSTATE_BUFIMAGE)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);

  if (cinfo->quantize_colors && cinfo->enable_external_quant &&
      cinfo->colormap != NULL) {
    /* Select 2-pass quantizer for external colormap use */
    cinfo->cquantize = master->quantizer_2pass;
    /* Notify quantizer of colormap change */
    (*cinfo->cquantize->new_color_map) (cinfo);
    master->pub.is_dummy_pass = FALSE; /* just in case */
  } else
    ERREXIT(cinfo, JERR_MODE_CHANGE);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x220(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpl $0xcf, 0x24(%rax)
je 0xe3e0c
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl $0x14, 0x28(%rax)
movq 0x10(%rsp), %rax
movl 0x24(%rax), %ecx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl %ecx, 0x2c(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movq 0x10(%rsp), %rax
cmpl $0x0, 0x6c(%rax)
je 0xe3e6e
movq 0x10(%rsp), %rax
cmpl $0x0, 0x80(%rax)
je 0xe3e6e
movq 0x10(%rsp), %rax
cmpq $0x0, 0xa0(%rax)
je 0xe3e6e
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x270(%rax)
movq 0x10(%rsp), %rax
movq 0x270(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movq 0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
jmp 0xe3e8f
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl $0x2e, 0x28(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdmaster.c
// Function: jinit_master_decompress
GLOBAL(void)
jinit_master_decompress (j_decompress_ptr cinfo)
{
  my_master_ptr master;

  master = (my_master_ptr)
      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
				  SIZEOF(my_decomp_master));
  cinfo->master = (struct jpeg_decomp_master *) master;
  master->pub.prepare_for_output_pass = prepare_for_output_pass;
  master->pub.finish_output_pass = finish_output_pass;

  master->pub.is_dummy_pass = FALSE;

  master_selection(cinfo);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x30, %edx
callq *%rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x220(%rax)
movq 0x8(%rsp), %rax
leaq 0x38(%rip), %rcx        # 0xe3f20
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
leaq 0x2d9(%rip), %rcx       # 0xe41d0
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x10(%rsp), %rdi
callq 0xe4220
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdmaster.c
// Function: finish_output_pass
METHODDEF(void)
finish_output_pass (j_decompress_ptr cinfo)
{
  my_master_ptr master = (my_master_ptr) cinfo->master;

  if (cinfo->quantize_colors)
    (*cinfo->cquantize->finish_pass) (cinfo);
  master->pass_number++;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x220(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x6c(%rax)
je 0xe420c
movq 0x10(%rsp), %rax
movq 0x270(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movq 0x8(%rsp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
addq $0x18, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdmaster.c
// Function: prepare_range_limit_table
LOCAL(void)
prepare_range_limit_table (j_decompress_ptr cinfo)
/* Allocate and fill in the sample_range_limit table */
{
  JSAMPLE * table;
  int i;

  table = (JSAMPLE *)
    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
		(5 * (MAXJSAMPLE+1) + CENTERJSAMPLE) * SIZEOF(JSAMPLE));
  table += (MAXJSAMPLE+1);	/* allow negative subscripts of simple table */
  cinfo->sample_range_limit = table;
  /* First segment of "simple" table: limit[x] = 0 for x < 0 */
  MEMZERO(table - (MAXJSAMPLE+1), (MAXJSAMPLE+1) * SIZEOF(JSAMPLE));
  /* Main part of "simple" table: limit[x] = x */
  for (i = 0; i <= MAXJSAMPLE; i++)
    table[i] = (JSAMPLE) i;
  table += CENTERJSAMPLE;	/* Point to where post-IDCT table starts */
  /* End of simple table, rest of first half of post-IDCT table */
  for (i = CENTERJSAMPLE; i < 2*(MAXJSAMPLE+1); i++)
    table[i] = MAXJSAMPLE;
  /* Second half of post-IDCT table */
  MEMZERO(table + (2 * (MAXJSAMPLE+1)),
	  (2 * (MAXJSAMPLE+1) - CENTERJSAMPLE) * SIZEOF(JSAMPLE));
  MEMCOPY(table + (4 * (MAXJSAMPLE+1) - CENTERJSAMPLE),
	  cinfo->sample_range_limit, CENTERJSAMPLE * SIZEOF(JSAMPLE));
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x580, %edx            # imm = 0x580
callq *%rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x1a8(%rax)
movq 0x8(%rsp), %rdi
addq $-0x100, %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0xf280
movl $0x0, 0x4(%rsp)
cmpl $0xff, 0x4(%rsp)
jg 0xe4706
movl 0x4(%rsp), %eax
movb %al, %dl
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xe46dc
movq 0x8(%rsp), %rax
addq $0x80, %rax
movq %rax, 0x8(%rsp)
movl $0x80, 0x4(%rsp)
cmpl $0x200, 0x4(%rsp)       # imm = 0x200
jge 0xe4743
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb $-0x1, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xe471e
movq 0x8(%rsp), %rdi
addq $0x200, %rdi            # imm = 0x200
xorl %esi, %esi
movl $0x180, %edx            # imm = 0x180
callq 0xf280
movq 0x8(%rsp), %rdi
addq $0x380, %rdi            # imm = 0x380
movq 0x10(%rsp), %rax
movq 0x1a8(%rax), %rsi
movl $0x80, %edx
callq 0xf3d0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdinput.c
// Function: jinit_input_controller
GLOBAL(void)
jinit_input_controller (j_decompress_ptr cinfo)
{
  my_inputctl_ptr inputctl;

  /* Create subobject in permanent pool */
  inputctl = (my_inputctl_ptr)
    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
				SIZEOF(my_input_controller));
  cinfo->inputctl = (struct jpeg_input_controller *) inputctl;
  /* Initialize method pointers */
  inputctl->pub.consume_input = consume_markers;
  inputctl->pub.reset_input_controller = reset_input_controller;
  inputctl->pub.start_input_pass = start_input_pass;
  inputctl->pub.finish_input_pass = finish_input_pass;
  /* Initialize state: can't use reset_input_controller since we don't
   * want to try to reset other modules yet.
   */
  inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
  inputctl->pub.eoi_reached = FALSE;
  inputctl->inheaders = TRUE;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq *%rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x240(%rax)
movq 0x8(%rsp), %rax
leaq 0x6b(%rip), %rcx        # 0xe4840
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
leaq 0x1cc(%rip), %rcx       # 0xe49b0
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
leaq 0x24c(%rip), %rcx       # 0xe4a40
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
leaq 0x29c(%rip), %rcx       # 0xe4aa0
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x24(%rax)
movq 0x8(%rsp), %rax
movl $0x1, 0x28(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdinput.c
// Function: consume_markers
METHODDEF(int)
consume_markers (j_decompress_ptr cinfo)
{
  my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;
  int val;

  if (inputctl->pub.eoi_reached) /* After hitting EOI, read no further */
    return JPEG_REACHED_EOI;

  val = (*cinfo->marker->read_markers) (cinfo);

  switch (val) {
  case JPEG_REACHED_SOS:	/* Found SOS */
    if (inputctl->inheaders) {	/* 1st SOS */
      initial_setup(cinfo);
      inputctl->inheaders = FALSE;
      /* Note: start_input_pass must be called by jdmaster.c
       * before any more input can be consumed.  jdapimin.c is
       * responsible for enforcing this sequencing.
       */
    } else {			/* 2nd or later SOS marker */
      if (! inputctl->pub.has_multiple_scans)
	ERREXIT(cinfo, JERR_EOI_EXPECTED); /* Oops, I wasn't expecting this! */
      start_input_pass(cinfo);
    }
    break;
  case JPEG_REACHED_EOI:	/* Found EOI */
    inputctl->pub.eoi_reached = TRUE;
    if (inputctl->inheaders) {	/* Tables-only datastream, apparently */
      if (cinfo->marker->saw_SOF)
	ERREXIT(cinfo, JERR_SOF_NO_SOS);
    } else {
      /* Prevent infinite loop in coef ctlr's decompress_data routine
       * if user set output_scan_number larger than number of scans.
       */
      if (cinfo->output_scan_number > cinfo->input_scan_number)
	cinfo->output_scan_number = cinfo->input_scan_number;
    }
    break;
  case JPEG_SUSPENDED:
    break;
  }

  return val;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x240(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x24(%rax)
je 0xe4872
movl $0x2, 0x24(%rsp)
jmp 0xe4999
movq 0x18(%rsp), %rdi
movq 0x248(%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0xe498f
jmp 0xe489a
movl 0x8(%rsp), %eax
subl $0x1, %eax
je 0xe48b3
jmp 0xe48a5
movl 0x8(%rsp), %eax
subl $0x2, %eax
je 0xe4911
jmp 0xe4991
movq 0x10(%rsp), %rax
cmpl $0x0, 0x28(%rax)
je 0xe48d6
movq 0x18(%rsp), %rdi
callq 0xe4ac0
movq 0x10(%rsp), %rax
movl $0x0, 0x28(%rax)
jmp 0xe490c
movq 0x10(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jne 0xe4902
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl $0x23, 0x28(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rdi
callq *%rax
movq 0x18(%rsp), %rdi
callq 0xe4a40
jmp 0xe4991
movq 0x10(%rsp), %rax
movl $0x1, 0x24(%rax)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x28(%rax)
je 0xe495d
movq 0x18(%rsp), %rax
movq 0x248(%rax), %rax
cmpl $0x0, 0x1c(%rax)
je 0xe495b
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl $0x3b, 0x28(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rdi
callq *%rax
jmp 0xe498d
movq 0x18(%rsp), %rax
movl 0xb4(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0xac(%rcx), %eax
jle 0xe498b
movq 0x18(%rsp), %rax
movl 0xac(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0xb4(%rax)
jmp 0xe498d
jmp 0xe4991
jmp 0xe4991
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdinput.c
// Function: reset_input_controller
METHODDEF(void)
reset_input_controller (j_decompress_ptr cinfo)
{
  my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;

  inputctl->pub.consume_input = consume_markers;
  inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
  inputctl->pub.eoi_reached = FALSE;
  inputctl->inheaders = TRUE;
  /* Reset other modules */
  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
  (*cinfo->marker->reset_marker_reader) (cinfo);
  /* Reset progression state -- would be cleaner if entropy decoder did this */
  cinfo->coef_bits = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x240(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
leaq -0x196(%rip), %rcx      # 0xe4840
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x24(%rax)
movq 0x8(%rsp), %rax
movl $0x1, 0x28(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movq 0x10(%rsp), %rax
movq 0x248(%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movq 0x10(%rsp), %rax
movq $0x0, 0xc0(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdinput.c
// Function: start_input_pass
METHODDEF(void)
start_input_pass (j_decompress_ptr cinfo)
{
  per_scan_setup(cinfo);
  latch_quant_tables(cinfo);
  (*cinfo->entropy->start_pass) (cinfo);
  (*cinfo->coef->start_input_pass) (cinfo);
  cinfo->inputctl->consume_input = cinfo->coef->consume_data;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0xe4eb0
movq (%rsp), %rdi
callq 0xe51f0
movq (%rsp), %rax
movq 0x250(%rax), %rax
movq (%rax), %rax
movq (%rsp), %rdi
callq *%rax
movq (%rsp), %rax
movq 0x230(%rax), %rax
movq (%rax), %rax
movq (%rsp), %rdi
callq *%rax
movq (%rsp), %rax
movq 0x230(%rax), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq 0x240(%rax), %rax
movq %rcx, (%rax)
popq %rax
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdinput.c
// Function: latch_quant_tables
LOCAL(void)
latch_quant_tables (j_decompress_ptr cinfo)
{
  int ci, qtblno;
  jpeg_component_info *compptr;
  JQUANT_TBL * qtbl;

  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
    compptr = cinfo->cur_comp_info[ci];
    /* No work if we already saved Q-table for this component */
    if (compptr->quant_table != NULL)
      continue;
    /* Make sure specified quantization table is present */
    qtblno = compptr->quant_tbl_no;
    if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
	cinfo->quant_tbl_ptrs[qtblno] == NULL)
      ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
    /* OK, save away the quantization table */
    qtbl = (JQUANT_TBL *)
      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
				  SIZEOF(JQUANT_TBL));
    MEMCOPY(qtbl, cinfo->quant_tbl_ptrs[qtblno], SIZEOF(JQUANT_TBL));
    compptr->quant_table = qtbl;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x1b0(%rcx), %eax
jge 0xe52fe
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq 0x1b8(%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0xe523e
jmp 0xe52ee
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
jl 0xe526d
cmpl $0x4, 0x18(%rsp)
jge 0xe526d
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
cmpq $0x0, 0xc8(%rax,%rcx,8)
jne 0xe529d
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl $0x34, 0x28(%rax)
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl %ecx, 0x2c(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rdi
callq *%rax
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rdi
movl $0x1, %esi
movl $0x84, %edx
callq *%rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq 0xc8(%rax,%rcx,8), %rsi
movl $0x84, %edx
callq 0xf3d0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xe5201
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jdmarker.c
// Function: jinit_marker_reader
GLOBAL(void)
jinit_marker_reader (j_decompress_ptr cinfo)
{
  my_marker_ptr marker;
  int i;

  /* Create subobject in permanent pool */
  marker = (my_marker_ptr)
    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
				SIZEOF(my_marker_reader));
  cinfo->marker = (struct jpeg_marker_reader *) marker;
  /* Initialize public method pointers */
  marker->pub.reset_marker_reader = reset_marker_reader;
  marker->pub.read_markers = read_markers;
  marker->pub.read_restart_marker = read_restart_marker;
  /* Initialize COM/APPn processing.
   * By default, we examine and then discard APP0 and APP14,
   * but simply discard COM and all other APPn.
   */
  marker->process_COM = skip_variable;
  marker->length_limit_COM = 0;
  for (i = 0; i < 16; i++) {
    marker->process_APPn[i] = skip_variable;
    marker->length_limit_APPn[i] = 0;
  }
  marker->process_APPn[0] = get_interesting_appn;
  marker->process_APPn[14] = get_interesting_appn;
  /* Reset marker processing state */
  reset_marker_reader(cinfo);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x108, %edx            # imm = 0x108
callq *%rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x248(%rax)
movq 0x8(%rsp), %rax
leaq 0xbb(%rip), %rcx        # 0xe58c0
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
leaq 0x12c(%rip), %rcx       # 0xe5940
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
leaq 0x4dc(%rip), %rcx       # 0xe5d00
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
leaq 0x5ec(%rip), %rcx       # 0xe5e20
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0xb0(%rax)
movl $0x0, 0x4(%rsp)
cmpl $0x10, 0x4(%rsp)
jge 0xe588e
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
leaq 0x5b9(%rip), %rdx       # 0xe5e20
movq %rdx, 0x30(%rax,%rcx,8)
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movl $0x0, 0xb4(%rax,%rcx,4)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xe584f
movq 0x8(%rsp), %rax
leaq 0x746(%rip), %rcx       # 0xe5fe0
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rax
leaq 0x736(%rip), %rcx       # 0xe5fe0
movq %rcx, 0xa0(%rax)
movq 0x10(%rsp), %rdi
callq 0xe58c0
addq $0x18, %rsp
retq