LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jmemmgr.c
// Function: alloc_large
METHODDEF(void FAR *)
alloc_large (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
/* Allocate a "large" object */
{
  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
  large_pool_ptr hdr_ptr;
  size_t odd_bytes;

  /* Check for unsatisfiable request (do now to ensure no overflow below) */
  if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)))
    out_of_memory(cinfo, 3);	/* request exceeds malloc's ability */

  /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */
  odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);
  if (odd_bytes > 0)
    sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;

  /* Always make a new pool */
  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */

  hdr_ptr = (large_pool_ptr) jpeg_get_large(cinfo, sizeofobject +
					    SIZEOF(large_pool_hdr));
  if (hdr_ptr == NULL)
    out_of_memory(cinfo, 4);	/* jpeg_get_large failed */
  mem->total_space_allocated += sizeofobject + SIZEOF(large_pool_hdr);

  /* Success, initialize the new pool header and add to list */
  hdr_ptr->hdr.next = mem->large_list[pool_id];
  /* We maintain space counts in each pool header for statistical purposes,
   * even though they are not needed for allocation.
   */
  hdr_ptr->hdr.bytes_used = sizeofobject;
  hdr_ptr->hdr.bytes_left = 0;
  mem->large_list[pool_id] = hdr_ptr;

  return (void FAR *) (hdr_ptr + 1); /* point to first data byte in pool */
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x3b9ac9e8, 0x20(%rsp) # imm = 0x3B9AC9E8
jbe 0xf9dca
movq 0x30(%rsp), %rdi
movl $0x3, %esi
callq 0xfafe0
movq 0x20(%rsp), %rax
andq $0x7, %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jbe 0xf9df4
movl $0x8, %eax
subq 0x8(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x2c(%rsp)
jl 0xf9e02
cmpl $0x2, 0x2c(%rsp)
jl 0xf9e32
movq 0x30(%rsp), %rax
movq (%rax), %rax
movl $0xe, 0x28(%rax)
movl 0x2c(%rsp), %ecx
movq 0x30(%rsp), %rax
movq (%rax), %rax
movl %ecx, 0x2c(%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rdi
callq *%rax
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x18, %rsi
callq 0xfb460
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xf9e61
movq 0x30(%rsp), %rdi
movl $0x4, %esi
callq 0xfafe0
movq 0x20(%rsp), %rcx
addq $0x18, %rcx
movq 0x18(%rsp), %rax
addq 0x98(%rax), %rcx
movq %rcx, 0x98(%rax)
movq 0x18(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movq 0x78(%rax,%rcx,8), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movq %rdx, 0x78(%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x18, %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jmemmgr.c
// Function: request_virt_sarray
METHODDEF(jvirt_sarray_ptr)
request_virt_sarray (j_common_ptr cinfo, int pool_id, jboolean pre_zero,
		     JDIMENSION samplesperrow, JDIMENSION numrows,
		     JDIMENSION maxaccess)
/* Request a virtual 2-D sample array */
{
  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
  jvirt_sarray_ptr result;

  /* Only IMAGE-lifetime virtual arrays are currently supported */
  if (pool_id != JPOOL_IMAGE)
    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */

  /* get control block */
  result = (jvirt_sarray_ptr) alloc_small(cinfo, pool_id,
					  SIZEOF(struct jvirt_sarray_control));

  result->mem_buffer = NULL;	/* marks array not yet realized */
  result->rows_in_array = numrows;
  result->samplesperrow = samplesperrow;
  result->maxaccess = maxaccess;
  result->pre_zero = pre_zero;
  result->b_s_open = FALSE;	/* no associated backing-store object */
  result->next = mem->virt_sarray_list; /* add to list of virtual arrays */
  mem->virt_sarray_list = result;

  return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpl $0x1, 0x2c(%rsp)
je 0xfa244
movq 0x30(%rsp), %rax
movq (%rax), %rax
movl $0xe, 0x28(%rax)
movl 0x2c(%rsp), %ecx
movq 0x30(%rsp), %rax
movq (%rax), %rax
movl %ecx, 0x2c(%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rdi
callq *%rax
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl $0x98, %edx
callq 0xf9b10
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movl 0x20(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x24(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movl 0x28(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x24(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x2c(%rax)
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x88(%rax)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jmemmgr.c
// Function: request_virt_barray
METHODDEF(jvirt_barray_ptr)
request_virt_barray (j_common_ptr cinfo, int pool_id, jboolean pre_zero,
		     JDIMENSION blocksperrow, JDIMENSION numrows,
		     JDIMENSION maxaccess)
/* Request a virtual 2-D coefficient-block array */
{
  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
  jvirt_barray_ptr result;

  /* Only IMAGE-lifetime virtual arrays are currently supported */
  if (pool_id != JPOOL_IMAGE)
    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */

  /* get control block */
  result = (jvirt_barray_ptr) alloc_small(cinfo, pool_id,
					  SIZEOF(struct jvirt_barray_control));

  result->mem_buffer = NULL;	/* marks array not yet realized */
  result->rows_in_array = numrows;
  result->blocksperrow = blocksperrow;
  result->maxaccess = maxaccess;
  result->pre_zero = pre_zero;
  result->b_s_open = FALSE;	/* no associated backing-store object */
  result->next = mem->virt_barray_list; /* add to list of virtual arrays */
  mem->virt_barray_list = result;

  return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpl $0x1, 0x2c(%rsp)
je 0xfa344
movq 0x30(%rsp), %rax
movq (%rax), %rax
movl $0xe, 0x28(%rax)
movl 0x2c(%rsp), %ecx
movq 0x30(%rsp), %rax
movq (%rax), %rax
movl %ecx, 0x2c(%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rdi
callq *%rax
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl $0x98, %edx
callq 0xf9b10
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movl 0x20(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x24(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movl 0x28(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x24(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x2c(%rax)
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x90(%rax)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/jpeg/jmemmgr.c
// Function: self_destruct
METHODDEF(void)
self_destruct (j_common_ptr cinfo)
{
  int pool;

  /* Close all backing store, release all memory.
   * Releasing pools in reverse order might help avoid fragmentation
   * with some (brain-damaged) malloc libraries.
   */
  for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) {
    free_pool(cinfo, pool);
  }

  /* Release the memory manager control block too. */
  jpeg_free_small(cinfo, (void *) cinfo->mem, SIZEOF(my_memory_mgr));
  cinfo->mem = NULL;		/* ensures I will be called only once */

  jpeg_mem_term(cinfo);		/* system-dependent cleanup */
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0xfafa3
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0xfad00
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xfaf81
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movl $0xa8, %edx
callq 0xfb430
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rdi
callq 0xfb520
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/png.c
// Function: png_set_sig_bytes
void PNGAPI
png_set_sig_bytes(png_structp png_ptr, int num_bytes)
{
   png_debug(1, "in png_set_sig_bytes");

   if (png_ptr == NULL)
      return;

   if (num_bytes > 8)
      png_error(png_ptr, "Too many bytes for PNG signature");

   png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xfb547
jmp 0xfb587
cmpl $0x8, 0xc(%rsp)
jle 0xfb55f
movq 0x10(%rsp), %rdi
leaq 0x3d346(%rip), %rsi     # 0x1388a0
callq 0x113860
cmpl $0x0, 0xc(%rsp)
jge 0xfb56e
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0xfb576
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, 0x254(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/png.c
// Function: png_sig_cmp
int PNGAPI
png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check)
{
   png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
   if (num_to_check > 8)
      num_to_check = 8;
   else if (num_to_check < 1)
      return (-1);

   if (start > 7)
      return (-1);

   if (start + num_to_check > 8)
      num_to_check = 8 - start;

   return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check)));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x3d790(%rip), %rax     # 0x138d3a
movq %rax, (%rsp)
cmpq $0x8, 0x8(%rsp)
jbe 0xfb5c1
movq $0x8, 0x8(%rsp)
jmp 0xfb5d5
cmpq $0x1, 0x8(%rsp)
jae 0xfb5d3
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xfb626
jmp 0xfb5d5
cmpq $0x7, 0x10(%rsp)
jbe 0xfb5e7
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xfb626
movq 0x10(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x8, %rax
jbe 0xfb606
movl $0x8, %eax
subq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
addq 0x10(%rsp), %rdi
movq %rsp, %rsi
addq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xf210
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/png/png.c
// Function: png_zalloc
voidpf /* PRIVATE */
png_zalloc(voidpf png_ptr, uInt items, uInt size)
{
   png_voidp ptr;
   png_structp p=(png_structp)png_ptr;
   png_uint_32 save_flags=p->flags;
   png_alloc_size_t num_bytes;

   if (png_ptr == NULL)
      return (NULL);
   if (items > PNG_UINT_32_MAX/size)
   {
     png_warning (p, "Potential overflow in png_zalloc()");
     return (NULL);
   }
   num_bytes = (png_alloc_size_t)items * size;

   p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
   ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes);
   p->flags=save_flags;

   return ((voidpf)ptr);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x120(%rax), %eax
movl %eax, 0x1c(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0xfb670
movq $0x0, 0x40(%rsp)
jmp 0xfb6ff
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %edx, %edx
divl 0x30(%rsp)
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jbe 0xfb6a9
movq 0x20(%rsp), %rdi
leaq 0x3d228(%rip), %rsi     # 0x1388c1
callq 0x113940
movq $0x0, 0x40(%rsp)
jmp 0xfb6ff
movl 0x34(%rsp), %eax
movl 0x30(%rsp), %ecx
imulq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl 0x120(%rax), %ecx
orq $0x100000, %rcx         # imm = 0x100000
movl %ecx, 0x120(%rax)
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1135b0
movq %rax, 0x28(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x120(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/png.c
// Function: png_calculate_crc
void /* PRIVATE */
png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length)
{
   int need_crc = 1;

   if (png_ptr->chunk_name[0] & 0x20)                     /* ancillary */
   {
      if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
          (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
         need_crc = 0;
   }
   else                                                    /* critical */
   {
      if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE)
         need_crc = 0;
   }

   if (need_crc)
      png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movq 0x20(%rsp), %rax
movzbl 0x244(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xfb7c0
movq 0x20(%rsp), %rax
movl 0x120(%rax), %eax
andl $0x300, %eax            # imm = 0x300
cmpl $0x300, %eax            # imm = 0x300
jne 0xfb7be
movl $0x0, 0xc(%rsp)
jmp 0xfb7df
movq 0x20(%rsp), %rax
movl 0x120(%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xfb7dd
movl $0x0, 0xc(%rsp)
jmp 0xfb7df
cmpl $0x0, 0xc(%rsp)
je 0xfb811
movq 0x20(%rsp), %rax
movl 0x234(%rax), %eax
movl %eax, %edi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movl %eax, %edx
callq 0x113da0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x234(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/png.c
// Function: png_create_info_struct
png_infop PNGAPI
png_create_info_struct(png_structp png_ptr)
{
   png_infop info_ptr;

   png_debug(1, "in png_create_info_struct");

   if (png_ptr == NULL)
      return (NULL);

#ifdef PNG_USER_MEM_SUPPORTED
   info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
      png_ptr->malloc_fn, png_ptr->mem_ptr);
#else
   info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
#endif
   if (info_ptr != NULL)
      png_info_init_3(&info_ptr, png_sizeof(png_info));

   return (info_ptr);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xfb83c
movq $0x0, 0x10(%rsp)
jmp 0xfb87f
movq 0x8(%rsp), %rax
movq 0x420(%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x418(%rax), %rdx
movl $0x2, %edi
callq 0x113380
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0xfb876
movq %rsp, %rdi
movl $0x170, %esi            # imm = 0x170
callq 0xfb890
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/png.c
// Function: png_info_init_3
void PNGAPI
png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
{
   png_infop info_ptr = *ptr_ptr;

   png_debug(1, "in png_info_init_3");

   if (info_ptr == NULL)
      return;

   if (png_sizeof(png_info) > png_info_struct_size)
   {
      png_destroy_struct(info_ptr);
      info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
      *ptr_ptr = info_ptr;
   }

   /* Set everything to 0 */
   png_memset(info_ptr, 0, png_sizeof(png_info));
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xfb8b3
jmp 0xfb8f2
movl $0x170, %eax            # imm = 0x170
cmpq 0x8(%rsp), %rax
jbe 0xfb8e2
movq (%rsp), %rdi
callq 0x1134c0
movl $0x2, %edi
callq 0x113360
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x170, %edx            # imm = 0x170
callq 0xf280
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/png.c
// Function: png_destroy_info_struct
void PNGAPI
png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
{
   png_infop info_ptr = NULL;

   png_debug(1, "in png_destroy_info_struct");

   if (png_ptr == NULL)
      return;

   if (info_ptr_ptr != NULL)
      info_ptr = *info_ptr_ptr;

   if (info_ptr != NULL)
   {
      png_info_destroy(png_ptr, info_ptr);

#ifdef PNG_USER_MEM_SUPPORTED
      png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn,
          png_ptr->mem_ptr);
#else
      png_destroy_struct((png_voidp)info_ptr);
#endif
      *info_ptr_ptr = NULL;
   }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xfb920
jmp 0xfb976
cmpq $0x0, 0x8(%rsp)
je 0xfb934
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0xfb976
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xfb980
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x428(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x418(%rax), %rdx
callq 0x1134e0
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/png.c
// Function: png_info_destroy
void /* PRIVATE */
png_info_destroy(png_structp png_ptr, png_infop info_ptr)
{
   png_debug(1, "in png_info_destroy");

   png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);

#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
   if (png_ptr->num_chunk_list)
   {
      png_free(png_ptr, png_ptr->chunk_list);
      png_ptr->chunk_list = NULL;
      png_ptr->num_chunk_list = 0;
   }
#endif

   png_info_init_3(&info_ptr, png_sizeof(png_info));
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x7fff, %edx           # imm = 0x7FFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0xfba80
movq 0x10(%rsp), %rax
cmpl $0x0, 0x3f0(%rax)
je 0xfb9ea
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x3f8(%rax), %rsi
callq 0x1136d0
movq 0x10(%rsp), %rax
movq $0x0, 0x3f8(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x3f0(%rax)
leaq 0x8(%rsp), %rdi
movl $0x170, %esi            # imm = 0x170
callq 0xfb890
addq $0x18, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/png/png.c
// Function: png_data_freer
void PNGAPI
png_data_freer(png_structp png_ptr, png_infop info_ptr,
   int freer, png_uint_32 mask)
{
   png_debug(1, "in png_data_freer");

   if (png_ptr == NULL || info_ptr == NULL)
      return;

   if (freer == PNG_DESTROY_WILL_FREE_DATA)
      info_ptr->free_me |= mask;
   else if (freer == PNG_USER_WILL_FREE_DATA)
      info_ptr->free_me &= ~mask;
   else
      png_warning(png_ptr,
         "Unknown freer parameter in png_data_freer");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movl %ecx, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xfba25
cmpq $0x0, 0x8(%rsp)
jne 0xfba27
jmp 0xfba77
cmpl $0x1, 0x4(%rsp)
jne 0xfba44
movl (%rsp), %ecx
movq 0x8(%rsp), %rax
orl 0xe4(%rax), %ecx
movl %ecx, 0xe4(%rax)
jmp 0xfba77
cmpl $0x2, 0x4(%rsp)
jne 0xfba64
movl (%rsp), %ecx
xorl $-0x1, %ecx
movq 0x8(%rsp), %rax
andl 0xe4(%rax), %ecx
movl %ecx, 0xe4(%rax)
jmp 0xfba75
movq 0x10(%rsp), %rdi
leaq 0x3ce74(%rip), %rsi     # 0x1388e4
callq 0x113940
jmp 0xfba77
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/png.c
// Function: png_convert_to_rfc1123
png_charp PNGAPI
png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
{
   static PNG_CONST char short_months[12][4] =
        {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

   if (png_ptr == NULL)
      return (NULL);
   if (png_ptr->time_buffer == NULL)
   {
      png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
         png_sizeof(char)));
   }

#ifdef USE_FAR_KEYWORD
   {
      char near_time_buf[29];
      png_snprintf6(near_time_buf, 29, "%d %s %d %02d:%02d:%02d +0000",
          ptime->day % 32, short_months[(ptime->month - 1) % 12],
          ptime->year, ptime->hour % 24, ptime->minute % 60,
          ptime->second % 61);
      png_memcpy(png_ptr->time_buffer, near_time_buf,
          29*png_sizeof(char));
   }
#else
   png_snprintf6(png_ptr->time_buffer, 29, "%d %s %d %02d:%02d:%02d +0000",
       ptime->day % 32, short_months[(ptime->month - 1) % 12],
       ptime->year, ptime->hour % 24, ptime->minute % 60,
       ptime->second % 61);
#endif
   return ((png_charp)png_ptr->time_buffer);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0xfc264
movq $0x0, 0x30(%rsp)
jmp 0xfc34a
movq 0x28(%rsp), %rax
cmpq $0x0, 0x3d0(%rax)
jne 0xfc291
movq 0x28(%rsp), %rdi
movl $0x1d, %esi
callq 0x1135b0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x3d0(%rax)
movq 0x28(%rsp), %rax
movq 0x3d0(%rax), %rdi
movq 0x20(%rsp), %rax
movzbl 0x3(%rax), %eax
movl $0x20, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movq 0x20(%rsp), %rax
movzbl 0x2(%rax), %eax
subl $0x1, %eax
movl $0xc, %esi
cltd
idivl %esi
movslq %edx, %rax
leaq 0x3ca82(%rip), %r8      # 0x138d50
shlq $0x2, %rax
addq %rax, %r8
movq 0x20(%rsp), %rax
movzwl (%rax), %r9d
movq 0x20(%rsp), %rax
movzbl 0x4(%rax), %eax
movl $0x18, %esi
cltd
idivl %esi
movl %edx, %r11d
movq 0x20(%rsp), %rax
movzbl 0x5(%rax), %eax
movl $0x3c, %esi
cltd
idivl %esi
movl %edx, %r10d
movq 0x20(%rsp), %rax
movzbl 0x6(%rax), %eax
movl $0x3d, %esi
cltd
idivl %esi
movl %edx, %eax
movl $0x1d, %esi
leaq 0x3c5e9(%rip), %rdx     # 0x13890e
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x0, %al
callq 0xf800
movq 0x28(%rsp), %rax
movq 0x3d0(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/png.c
// Function: png_handle_as_unknown
int PNGAPI
png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
{
   /* Check chunk_name and return "keep" value if it's on the list, else 0 */
   int i;
   png_bytep p;
   if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list<=0)
      return 0;
   p = png_ptr->chunk_list + png_ptr->num_chunk_list*5 - 5;
   for (i = png_ptr->num_chunk_list; i; i--, p -= 5)
      if (!png_memcmp(chunk_name, p, 4))
        return ((int)*(p + 4));
   return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xfc408
cmpq $0x0, -0x18(%rsp)
je 0xfc408
movq -0x10(%rsp), %rax
cmpl $0x0, 0x3f0(%rax)
jg 0xfc415
movl $0x0, -0x4(%rsp)
jmp 0xfc4a1
movq -0x10(%rsp), %rax
movq 0x3f8(%rax), %rax
movq -0x10(%rsp), %rcx
imull $0x5, 0x3f0(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $-0x5, %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movl 0x3f0(%rax), %eax
movl %eax, -0x1c(%rsp)
cmpl $0x0, -0x1c(%rsp)
je 0xfc499
movq -0x18(%rsp), %rax
movq -0x28(%rsp), %rcx
movl (%rcx), %ecx
movl (%rax), %eax
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xfc47c
movq -0x28(%rsp), %rax
movzbl 0x4(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0xfc4a1
jmp 0xfc47e
movl -0x1c(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rsp)
movq -0x28(%rsp), %rax
addq $-0x5, %rax
movq %rax, -0x28(%rsp)
jmp 0xfc44b
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/png.c
// Function: png_64bit_product
void /* PRIVATE */
png_64bit_product (long v1, long v2, unsigned long *hi_product,
   unsigned long *lo_product)
{
   int a, b, c, d;
   long lo, hi, x, y;

   a = (v1 >> 16) & 0xffff;
   b = v1 & 0xffff;
   c = (v2 >> 16) & 0xffff;
   d = v2 & 0xffff;

   lo = b * d;                   /* BD */
   x = a * d + c * b;            /* AD + CB */
   y = ((lo >> 16) & 0xffff) + x;

   lo = (lo & 0xffff) | ((y & 0xffff) << 16);
   hi = (y >> 16) & 0xffff;

   hi += a * c;                  /* AC */

   *hi_product = (unsigned long)hi;
   *lo_product = (unsigned long)lo;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rax
sarq $0x10, %rax
andq $0xffff, %rax           # imm = 0xFFFF
movl %eax, -0x24(%rsp)
movq -0x8(%rsp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
movl %eax, -0x28(%rsp)
movq -0x10(%rsp), %rax
sarq $0x10, %rax
andq $0xffff, %rax           # imm = 0xFFFF
movl %eax, -0x2c(%rsp)
movq -0x10(%rsp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
movl %eax, -0x30(%rsp)
movl -0x28(%rsp), %eax
imull -0x30(%rsp), %eax
cltq
movq %rax, -0x38(%rsp)
movl -0x24(%rsp), %eax
imull -0x30(%rsp), %eax
movl -0x2c(%rsp), %ecx
imull -0x28(%rsp), %ecx
addl %ecx, %eax
cltq
movq %rax, -0x48(%rsp)
movq -0x38(%rsp), %rax
sarq $0x10, %rax
andq $0xffff, %rax           # imm = 0xFFFF
addq -0x48(%rsp), %rax
movq %rax, -0x50(%rsp)
movq -0x38(%rsp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
movq -0x50(%rsp), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
shlq $0x10, %rcx
orq %rcx, %rax
movq %rax, -0x38(%rsp)
movq -0x50(%rsp), %rax
sarq $0x10, %rax
andq $0xffff, %rax           # imm = 0xFFFF
movq %rax, -0x40(%rsp)
movl -0x24(%rsp), %eax
imull -0x2c(%rsp), %eax
cltq
addq -0x40(%rsp), %rax
movq %rax, -0x40(%rsp)
movq -0x40(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x38(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_set_bKGD
void PNGAPI
png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background)
{
   png_debug1(1, "in %s storage function", "bKGD");

   if (png_ptr == NULL || info_ptr == NULL)
      return;

   png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16));
   info_ptr->valid |= PNG_INFO_bKGD;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0xfcb9f
cmpq $0x0, -0x10(%rsp)
jne 0xfcba1
jmp 0xfcbc8
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x72(%rax)
movw 0x8(%rcx), %cx
movw %cx, 0x7a(%rax)
movq -0x10(%rsp), %rax
movl 0x8(%rax), %ecx
orl $0x20, %ecx
movl %ecx, 0x8(%rax)
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_set_gAMA
void PNGAPI
png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
{
   double png_gamma;

   png_debug1(1, "in %s storage function", "gAMA");

   if (png_ptr == NULL || info_ptr == NULL)
      return;

   /* Check for overflow */
   if (file_gamma > 21474.83)
   {
      png_warning(png_ptr, "Limiting gamma to 21474.83");
      png_gamma=21474.83;
   }
   else
      png_gamma = file_gamma;
   info_ptr->gamma = (float)png_gamma;
#ifdef PNG_FIXED_POINT_SUPPORTED
   info_ptr->int_gamma = (int)(png_gamma*100000.+.5);
#endif
   info_ptr->valid |= PNG_INFO_gAMA;
   if (png_gamma == 0.0)
      png_warning(png_ptr, "Setting gamma=0");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xfd0a4
cmpq $0x0, 0x18(%rsp)
jne 0xfd0a9
jmp 0xfd15b
movsd 0x10(%rsp), %xmm0
movsd 0x3bcd1(%rip), %xmm1    # 0x138d88
ucomisd %xmm1, %xmm0
jbe 0xfd0de
movq 0x20(%rsp), %rdi
leaq 0x3bceb(%rip), %rsi     # 0x138db4
callq 0x113940
movsd 0x3bcb2(%rip), %xmm0    # 0x138d88
movsd %xmm0, 0x8(%rsp)
jmp 0xfd0ea
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x18(%rsp), %rax
movss %xmm0, 0x34(%rax)
movsd 0x8(%rsp), %xmm0
movsd 0x3bc74(%rip), %xmm1    # 0x138d80
mulsd %xmm1, %xmm0
movsd 0x35ef8(%rip), %xmm1    # 0x133010
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x148(%rax)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x8(%rax)
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xfd15b
jp 0xfd15b
movq 0x20(%rsp), %rdi
leaq 0x3bc79(%rip), %rsi     # 0x138dcf
callq 0x113940
addq $0x28, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_set_gAMA_fixed
void PNGAPI
png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
   int_gamma)
{
   png_fixed_point png_gamma;

   png_debug1(1, "in %s storage function", "gAMA");

   if (png_ptr == NULL || info_ptr == NULL)
      return;

   if (int_gamma > (png_fixed_point)PNG_UINT_31_MAX)
   {
      png_warning(png_ptr, "Limiting gamma to 21474.83");
      png_gamma=PNG_UINT_31_MAX;
   }
   else
   {
      if (int_gamma < 0)
      {
         png_warning(png_ptr, "Setting negative gamma to zero");
         png_gamma = 0;
      }
      else
         png_gamma = int_gamma;
   }
#ifdef PNG_FLOATING_POINT_SUPPORTED
   info_ptr->gamma = (float)(png_gamma/100000.);
#endif
#ifdef PNG_FIXED_POINT_SUPPORTED
   info_ptr->int_gamma = png_gamma;
#endif
   info_ptr->valid |= PNG_INFO_gAMA;
   if (png_gamma == 0)
      png_warning(png_ptr, "Setting gamma=0");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xfd182
cmpq $0x0, 0x8(%rsp)
jne 0xfd187
jmp 0xfd227
cmpl $0x7fffffff, 0x4(%rsp)  # imm = 0x7FFFFFFF
jle 0xfd1ab
movq 0x10(%rsp), %rdi
leaq 0x3bc17(%rip), %rsi     # 0x138db4
callq 0x113940
movl $0x7fffffff, (%rsp)     # imm = 0x7FFFFFFF
jmp 0xfd1d5
cmpl $0x0, 0x4(%rsp)
jge 0xfd1cc
movq 0x10(%rsp), %rdi
leaq 0x3bc21(%rip), %rsi     # 0x138ddf
callq 0x113940
movl $0x0, (%rsp)
jmp 0xfd1d3
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
jmp 0xfd1d5
cvtsi2sdl (%rsp), %xmm0
movsd 0x3bb9e(%rip), %xmm1    # 0x138d80
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, 0x34(%rax)
movl (%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x148(%rax)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x8(%rax)
cmpl $0x0, (%rsp)
jne 0xfd227
movq 0x10(%rsp), %rdi
leaq 0x3bbad(%rip), %rsi     # 0x138dcf
callq 0x113940
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_set_hIST
void PNGAPI
png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)
{
   int i;

   png_debug1(1, "in %s storage function", "hIST");

   if (png_ptr == NULL || info_ptr == NULL)
      return;

   if (info_ptr->num_palette == 0 || info_ptr->num_palette
       > PNG_MAX_PALETTE_LENGTH)
   {
      png_warning(png_ptr,
         "Invalid palette size, hIST allocation skipped");
      return;
   }

   png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);
   /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in
    * version 1.2.1
    */
   png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr,
      PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16));
   if (png_ptr->hist == NULL)
   {
      png_warning(png_ptr, "Insufficient memory for hIST chunk data");
      return;
   }

   for (i = 0; i < info_ptr->num_palette; i++)
      png_ptr->hist[i] = hist[i];
   info_ptr->hist = png_ptr->hist;
   info_ptr->valid |= PNG_INFO_hIST;

   info_ptr->free_me |= PNG_FREE_HIST;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xfd253
cmpq $0x0, 0x18(%rsp)
jne 0xfd258
jmp 0xfd368
movq 0x18(%rsp), %rax
movzwl 0x20(%rax), %eax
cmpl $0x0, %eax
je 0xfd276
movq 0x18(%rsp), %rax
movzwl 0x20(%rax), %eax
cmpl $0x100, %eax            # imm = 0x100
jle 0xfd28c
movq 0x20(%rsp), %rdi
leaq 0x3bb7c(%rip), %rsi     # 0x138dfe
callq 0x113940
jmp 0xfd368
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x8, %edx
xorl %ecx, %ecx
callq 0xfba80
movq 0x20(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x113760
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x398(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x398(%rax)
jne 0xfd2e5
movq 0x20(%rsp), %rdi
leaq 0x3bb51(%rip), %rsi     # 0x138e2c
callq 0x113940
jmp 0xfd368
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
movzwl 0x20(%rcx), %ecx
cmpl %ecx, %eax
jge 0xfd32e
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movw (%rax,%rcx,2), %dx
movq 0x20(%rsp), %rax
movq 0x398(%rax), %rax
movslq 0xc(%rsp), %rcx
movw %dx, (%rax,%rcx,2)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xfd2ed
movq 0x20(%rsp), %rax
movq 0x398(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
orl $0x40, %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl 0xe4(%rax), %ecx
orl $0x8, %ecx
movl %ecx, 0xe4(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_set_oFFs
void PNGAPI
png_set_oFFs(png_structp png_ptr, png_infop info_ptr,
   png_int_32 offset_x, png_int_32 offset_y, int unit_type)
{
   png_debug1(1, "in %s storage function", "oFFs");

   if (png_ptr == NULL || info_ptr == NULL)
      return;

   info_ptr->x_offset = offset_x;
   info_ptr->y_offset = offset_y;
   info_ptr->offset_unit_type = (png_byte)unit_type;
   info_ptr->valid |= PNG_INFO_oFFs;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movl %r8d, -0x1c(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0xfd587
cmpq $0x0, -0x10(%rsp)
jne 0xfd589
jmp 0xfd5c6
movl -0x14(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x7c(%rax)
movl -0x18(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x80(%rax)
movl -0x1c(%rsp), %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x84(%rax)
movq -0x10(%rsp), %rax
movl 0x8(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x8(%rax)
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_set_sCAL
void PNGAPI
png_set_sCAL(png_structp png_ptr, png_infop info_ptr,
             int unit, double width, double height)
{
   png_debug1(1, "in %s storage function", "sCAL");

   if (png_ptr == NULL || info_ptr == NULL)
      return;

   info_ptr->scal_unit = (png_byte)unit;
   info_ptr->scal_pixel_width = width;
   info_ptr->scal_pixel_height = height;

   info_ptr->valid |= PNG_INFO_sCAL;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movsd %xmm0, -0x20(%rsp)
movsd %xmm1, -0x28(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0xfd8ca
cmpq $0x0, -0x10(%rsp)
jne 0xfd8cc
jmp 0xfd914
movl -0x14(%rsp), %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x11c(%rax)
movsd -0x20(%rsp), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x120(%rax)
movsd -0x28(%rsp), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x128(%rax)
movq -0x10(%rsp), %rax
movl 0x8(%rax), %ecx
orl $0x4000, %ecx           # imm = 0x4000
movl %ecx, 0x8(%rax)
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_set_pHYs
void PNGAPI
png_set_pHYs(png_structp png_ptr, png_infop info_ptr,
   png_uint_32 res_x, png_uint_32 res_y, int unit_type)
{
   png_debug1(1, "in %s storage function", "pHYs");

   if (png_ptr == NULL || info_ptr == NULL)
      return;

   info_ptr->x_pixels_per_unit = res_x;
   info_ptr->y_pixels_per_unit = res_y;
   info_ptr->phys_unit_type = (png_byte)unit_type;
   info_ptr->valid |= PNG_INFO_pHYs;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movl %r8d, -0x1c(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0xfd947
cmpq $0x0, -0x10(%rsp)
jne 0xfd949
jmp 0xfd989
movl -0x14(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x88(%rax)
movl -0x18(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x8c(%rax)
movl -0x1c(%rsp), %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x90(%rax)
movq -0x10(%rsp), %rax
movl 0x8(%rax), %ecx
orl $0x80, %ecx
movl %ecx, 0x8(%rax)
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_set_PLTE
void PNGAPI
png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
   png_colorp palette, int num_palette)
{

   png_debug1(1, "in %s storage function", "PLTE");

   if (png_ptr == NULL || info_ptr == NULL)
      return;

   if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH)
   {
      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
         png_error(png_ptr, "Invalid palette length");
      else
      {
         png_warning(png_ptr, "Invalid palette length");
         return;
      }
   }

   /* It may not actually be necessary to set png_ptr->palette here;
    * we do it for backward compatibility with the way the png_handle_tRNS
    * function used to do the allocation.
    */
   png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);

   /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead
    * of num_palette entries, in case of an invalid PNG file that has
    * too-large sample values.
    */
   png_ptr->palette = (png_colorp)png_calloc(png_ptr,
      PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));
   png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof(png_color));
   info_ptr->palette = png_ptr->palette;
   info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;

   info_ptr->free_me |= PNG_FREE_PLTE;

   info_ptr->valid |= PNG_INFO_PLTE;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xfd9b7
cmpq $0x0, 0x18(%rsp)
jne 0xfd9bc
jmp 0xfdaaf
cmpl $0x0, 0xc(%rsp)
jl 0xfd9cd
cmpl $0x100, 0xc(%rsp)       # imm = 0x100
jle 0xfda06
movq 0x18(%rsp), %rax
movzbl 0x25(%rax), %eax
cmpl $0x3, %eax
jne 0xfd9ee
movq 0x20(%rsp), %rdi
leaq 0x3b500(%rip), %rsi     # 0x138ee7
callq 0x113860
jmp 0xfda04
movq 0x20(%rsp), %rdi
leaq 0x3b4ed(%rip), %rsi     # 0x138ee7
callq 0x113940
jmp 0xfdaaf
jmp 0xfda06
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
xorl %ecx, %ecx
callq 0xfba80
movq 0x20(%rsp), %rdi
movl $0x300, %esi            # imm = 0x300
callq 0x113560
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x238(%rax)
movq 0x20(%rsp), %rax
movq 0x238(%rax), %rdi
movq 0x10(%rsp), %rsi
movslq 0xc(%rsp), %rax
imulq $0x3, %rax, %rdx
callq 0xf3d0
movq 0x20(%rsp), %rax
movq 0x238(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0xc(%rsp), %eax
movw %ax, %cx
movq 0x20(%rsp), %rax
movw %cx, 0x240(%rax)
movq 0x18(%rsp), %rax
movw %cx, 0x20(%rax)
movq 0x18(%rsp), %rax
movl 0xe4(%rax), %ecx
orl $0x1000, %ecx           # imm = 0x1000
movl %ecx, 0xe4(%rax)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
orl $0x8, %ecx
movl %ecx, 0x8(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_set_sBIT
void PNGAPI
png_set_sBIT(png_structp png_ptr, png_infop info_ptr,
   png_color_8p sig_bit)
{
   png_debug1(1, "in %s storage function", "sBIT");

   if (png_ptr == NULL || info_ptr == NULL)
      return;

   png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof(png_color_8));
   info_ptr->valid |= PNG_INFO_sBIT;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0xfdadf
cmpq $0x0, -0x10(%rsp)
jne 0xfdae1
jmp 0xfdb04
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movl (%rcx), %edx
movl %edx, 0x58(%rax)
movb 0x4(%rcx), %cl
movb %cl, 0x5c(%rax)
movq -0x10(%rsp), %rax
movl 0x8(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x8(%rax)
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_set_sRGB
void PNGAPI
png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent)
{
   png_debug1(1, "in %s storage function", "sRGB");

   if (png_ptr == NULL || info_ptr == NULL)
      return;

   info_ptr->srgb_intent = (png_byte)intent;
   info_ptr->valid |= PNG_INFO_sRGB;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0xfdb2e
cmpq $0x0, -0x10(%rsp)
jne 0xfdb30
jmp 0xfdb4f
movl -0x14(%rsp), %eax
movb %al, %cl
movq -0x10(%rsp), %rax
movb %cl, 0x38(%rax)
movq -0x10(%rsp), %rax
movl 0x8(%rax), %ecx
orl $0x800, %ecx            # imm = 0x800
movl %ecx, 0x8(%rax)
retq
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_set_iCCP
void PNGAPI
png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
             png_charp name, int compression_type,
             png_charp profile, png_uint_32 proflen)
{
   png_charp new_iccp_name;
   png_charp new_iccp_profile;
   png_uint_32 length;

   png_debug1(1, "in %s storage function", "iCCP");

   if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)
      return;

   length = png_strlen(name)+1;
   new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length);
   if (new_iccp_name == NULL)
   {
        png_warning(png_ptr, "Insufficient memory to process iCCP chunk");
      return;
   }
   png_memcpy(new_iccp_name, name, length);
   new_iccp_profile = (png_charp)png_malloc_warn(png_ptr, proflen);
   if (new_iccp_profile == NULL)
   {
      png_free (png_ptr, new_iccp_name);
      png_warning(png_ptr,
          "Insufficient memory to process iCCP profile");
      return;
   }
   png_memcpy(new_iccp_profile, profile, (png_size_t)proflen);

   png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);

   info_ptr->iccp_proflen = proflen;
   info_ptr->iccp_name = new_iccp_name;
   info_ptr->iccp_profile = new_iccp_profile;
   /* Compression is always zero but is here so the API and info structure
    * does not have to change if we introduce multiple compression types
    */
   info_ptr->iccp_compression = (png_byte)compression_type;
   info_ptr->free_me |= PNG_FREE_ICCP;
   info_ptr->valid |= PNG_INFO_iCCP;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0xfdd71
cmpq $0x0, 0x38(%rsp)
je 0xfdd71
cmpq $0x0, 0x30(%rsp)
je 0xfdd71
cmpq $0x0, 0x20(%rsp)
jne 0xfdd76
jmp 0xfdea4
movq 0x30(%rsp), %rdi
callq 0xf200
addq $0x1, %rax
movl %eax, 0x4(%rsp)
movq 0x40(%rsp), %rdi
movl 0x4(%rsp), %eax
movl %eax, %esi
callq 0x113760
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xfddbb
movq 0x40(%rsp), %rdi
leaq 0x3b14d(%rip), %rsi     # 0x138efe
callq 0x113940
jmp 0xfdea4
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x4(%rsp), %eax
movl %eax, %edx
callq 0xf3d0
movq 0x40(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x113760
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xfde12
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1136d0
movq 0x40(%rsp), %rdi
leaq 0x3b120(%rip), %rsi     # 0x138f28
callq 0x113940
jmp 0xfdea4
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %eax
movl %eax, %edx
callq 0xf3d0
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0xfba80
movl 0x1c(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x108(%rax)
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0xf8(%rax)
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x100(%rax)
movl 0x2c(%rsp), %eax
movb %al, %cl
movq 0x38(%rsp), %rax
movb %cl, 0x10c(%rax)
movq 0x38(%rsp), %rax
movl 0xe4(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0xe4(%rax)
movq 0x38(%rsp), %rax
movl 0x8(%rax), %ecx
orl $0x1000, %ecx           # imm = 0x1000
movl %ecx, 0x8(%rax)
addq $0x48, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_set_tIME
void PNGAPI
png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time)
{
   png_debug1(1, "in %s storage function", "tIME");

   if (png_ptr == NULL || info_ptr == NULL ||
       (png_ptr->mode & PNG_WROTE_tIME))
      return;

   png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof(png_time));
   info_ptr->valid |= PNG_INFO_tIME;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0xfe4d4
cmpq $0x0, -0x10(%rsp)
je 0xfe4d4
movq -0x8(%rsp), %rax
movl 0x11c(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0xfe4d6
jmp 0xfe4f8
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x50(%rax)
movq -0x10(%rsp), %rax
movl 0x8(%rax), %ecx
orl $0x200, %ecx            # imm = 0x200
movl %ecx, 0x8(%rax)
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_permit_mng_features
png_uint_32 PNGAPI
png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features)
{
   png_debug(1, "in png_permit_mng_features");

   if (png_ptr == NULL)
      return (png_uint_32)0;
   png_ptr->mng_features_permitted =
     (png_byte)(mng_features & PNG_ALL_MNG_FEATURES);
   return (png_uint_32)png_ptr->mng_features_permitted;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0xfebfb
movl $0x0, -0x4(%rsp)
jmp 0xfec1f
movl -0x14(%rsp), %eax
andl $0x5, %eax
movzbl %al, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x408(%rax)
movq -0x10(%rsp), %rax
movl 0x408(%rax), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_set_read_user_chunk_fn
void PNGAPI
png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr,
   png_user_chunk_ptr read_user_chunk_fn)
{
   png_debug(1, "in png_set_read_user_chunk_fn");

   if (png_ptr == NULL)
      return;

   png_ptr->read_user_chunk_fn = read_user_chunk_fn;
   png_ptr->user_chunk_ptr = user_chunk_ptr;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
cmpq $0x0, -0x8(%rsp)
jne 0xfee39
jmp 0xfee5b
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x3e8(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x3e0(%rax)
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_set_rows
void PNGAPI
png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers)
{
   png_debug1(1, "in %s storage function", "rows");

   if (png_ptr == NULL || info_ptr == NULL)
      return;

   if (info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers))
      png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
   info_ptr->row_pointers = row_pointers;
   if (row_pointers)
      info_ptr->valid |= PNG_INFO_IDAT;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xfee82
cmpq $0x0, 0x8(%rsp)
jne 0xfee84
jmp 0xfeee4
movq 0x8(%rsp), %rax
cmpq $0x0, 0x140(%rax)
je 0xfeebb
movq 0x8(%rsp), %rax
movq 0x140(%rax), %rax
cmpq (%rsp), %rax
je 0xfeebb
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x40, %edx
xorl %ecx, %ecx
callq 0xfba80
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x140(%rax)
cmpq $0x0, (%rsp)
je 0xfeee4
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ecx
orq $0x8000, %rcx           # imm = 0x8000
movl %ecx, 0x8(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_set_compression_buffer_size
void PNGAPI
png_set_compression_buffer_size(png_structp png_ptr,
    png_size_t size)
{
    if (png_ptr == NULL)
       return;
    png_free(png_ptr, png_ptr->zbuf);
    png_ptr->zbuf_size = size;
    png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size);
    png_ptr->zstream.next_out = png_ptr->zbuf;
    png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xfef08
jmp 0xfef7e
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x198(%rax), %rsi
callq 0x1136d0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x1a0(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1135b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x198(%rax)
movq 0x10(%rsp), %rax
movq 0x198(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x140(%rax)
movq 0x10(%rsp), %rax
movq 0x1a0(%rax), %rax
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x148(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngset.c
// Function: png_set_user_limits
void PNGAPI
png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,
    png_uint_32 user_height_max)
{
   /* Images with dimensions larger than these limits will be
    * rejected by png_set_IHDR().  To accept any PNG datastream
    * regardless of dimensions, set both limits to 0x7ffffffL.
    */
   if (png_ptr == NULL)
      return;
   png_ptr->user_width_max = user_width_max;
   png_ptr->user_height_max = user_height_max;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
cmpq $0x0, -0x8(%rsp)
jne 0xfefe7
jmp 0xff005
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x454(%rax)
movl -0x10(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x458(%rax)
retq
nopw %cs:(%rax,%rax)