LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_x_pixels_per_meter
png_uint_32 PNGAPI
png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
{
   if (png_ptr != NULL && info_ptr != NULL)
#ifdef PNG_pHYs_SUPPORTED
   if (info_ptr->valid & PNG_INFO_pHYs)
   {
      png_debug1(1, "in %s retrieval function", "png_get_x_pixels_per_meter");

      if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
          return (0);

      else
          return (info_ptr->x_pixels_per_unit);
   }
#else
   return (0);
#endif
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xff34a
cmpq $0x0, -0x18(%rsp)
je 0xff34a
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xff348
movq -0x18(%rsp), %rax
movzbl 0x90(%rax), %eax
cmpl $0x1, %eax
je 0xff337
movl $0x0, -0x4(%rsp)
jmp 0xff352
movq -0x18(%rsp), %rax
movl 0x88(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0xff352
jmp 0xff34a
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_y_pixels_per_meter
png_uint_32 PNGAPI
png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
{
   if (png_ptr != NULL && info_ptr != NULL)
#ifdef PNG_pHYs_SUPPORTED
   if (info_ptr->valid & PNG_INFO_pHYs)
   {
      png_debug1(1, "in %s retrieval function", "png_get_y_pixels_per_meter");

      if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
          return (0);

      else
          return (info_ptr->y_pixels_per_unit);
   }
#else
   return (0);
#endif
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xff3ba
cmpq $0x0, -0x18(%rsp)
je 0xff3ba
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xff3b8
movq -0x18(%rsp), %rax
movzbl 0x90(%rax), %eax
cmpl $0x1, %eax
je 0xff3a7
movl $0x0, -0x4(%rsp)
jmp 0xff3c2
movq -0x18(%rsp), %rax
movl 0x8c(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0xff3c2
jmp 0xff3ba
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_pixels_per_meter
png_uint_32 PNGAPI
png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
{
   if (png_ptr != NULL && info_ptr != NULL)
#ifdef PNG_pHYs_SUPPORTED
   if (info_ptr->valid & PNG_INFO_pHYs)
   {
      png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");

      if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER ||
         info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit)
          return (0);

      else
          return (info_ptr->x_pixels_per_unit);
   }
#else
   return (0);
#endif
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xff442
cmpq $0x0, -0x18(%rsp)
je 0xff442
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xff440
movq -0x18(%rsp), %rax
movzbl 0x90(%rax), %eax
cmpl $0x1, %eax
jne 0xff425
movq -0x18(%rsp), %rax
movl 0x88(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x8c(%rcx), %eax
je 0xff42f
movl $0x0, -0x4(%rsp)
jmp 0xff44a
movq -0x18(%rsp), %rax
movl 0x88(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0xff44a
jmp 0xff442
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_pixel_aspect_ratio
float PNGAPI
png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)
   {
   if (png_ptr != NULL && info_ptr != NULL)
#ifdef PNG_pHYs_SUPPORTED

   if (info_ptr->valid & PNG_INFO_pHYs)
   {
      png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");

      if (info_ptr->x_pixels_per_unit == 0)
         return ((float)0.0);

      else
         return ((float)((float)info_ptr->y_pixels_per_unit
            /(float)info_ptr->x_pixels_per_unit));
   }
#else
      return (0.0);
#endif
   return ((float)0.0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xff4be
cmpq $0x0, -0x18(%rsp)
je 0xff4be
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xff4bc
movq -0x18(%rsp), %rax
cmpl $0x0, 0x88(%rax)
jne 0xff495
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rsp)
jmp 0xff4c7
movq -0x18(%rsp), %rcx
movl 0x88(%rcx), %eax
movl 0x8c(%rcx), %ecx
cvtsi2ss %rcx, %xmm0
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x4(%rsp)
jmp 0xff4c7
jmp 0xff4be
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rsp)
movss -0x4(%rsp), %xmm0
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_x_offset_microns
png_int_32 PNGAPI
png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)
{
   if (png_ptr != NULL && info_ptr != NULL)
#ifdef PNG_oFFs_SUPPORTED

   if (info_ptr->valid & PNG_INFO_oFFs)
   {
      png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");

      if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
          return (0);

      else
          return (info_ptr->x_offset);
   }
#else
      return (0);
#endif
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xff527
cmpq $0x0, -0x18(%rsp)
je 0xff527
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0xff525
movq -0x18(%rsp), %rax
movzbl 0x84(%rax), %eax
cmpl $0x1, %eax
je 0xff517
movl $0x0, -0x4(%rsp)
jmp 0xff52f
movq -0x18(%rsp), %rax
movl 0x7c(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0xff52f
jmp 0xff527
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_y_offset_microns
png_int_32 PNGAPI
png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)
{
   if (png_ptr != NULL && info_ptr != NULL)

#ifdef PNG_oFFs_SUPPORTED
   if (info_ptr->valid & PNG_INFO_oFFs)
   {
      png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");

      if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
          return (0);

      else
          return (info_ptr->y_offset);
   }
#else
   return (0);
#endif
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xff59a
cmpq $0x0, -0x18(%rsp)
je 0xff59a
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0xff598
movq -0x18(%rsp), %rax
movzbl 0x84(%rax), %eax
cmpl $0x1, %eax
je 0xff587
movl $0x0, -0x4(%rsp)
jmp 0xff5a2
movq -0x18(%rsp), %rax
movl 0x80(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0xff5a2
jmp 0xff59a
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_x_offset_pixels
png_int_32 PNGAPI
png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)
{
   if (png_ptr != NULL && info_ptr != NULL)

#ifdef PNG_oFFs_SUPPORTED
   if (info_ptr->valid & PNG_INFO_oFFs)
   {
      png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");

      if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
          return (0);

      else
          return (info_ptr->x_offset);
   }
#else
   return (0);
#endif
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xff607
cmpq $0x0, -0x18(%rsp)
je 0xff607
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0xff605
movq -0x18(%rsp), %rax
movzbl 0x84(%rax), %eax
cmpl $0x0, %eax
je 0xff5f7
movl $0x0, -0x4(%rsp)
jmp 0xff60f
movq -0x18(%rsp), %rax
movl 0x7c(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0xff60f
jmp 0xff607
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_y_offset_pixels
png_int_32 PNGAPI
png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)
{
   if (png_ptr != NULL && info_ptr != NULL)

#ifdef PNG_oFFs_SUPPORTED
   if (info_ptr->valid & PNG_INFO_oFFs)
   {
      png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");

      if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
          return (0);

      else
          return (info_ptr->y_offset);
   }
#else
   return (0);
#endif
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xff67a
cmpq $0x0, -0x18(%rsp)
je 0xff67a
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0xff678
movq -0x18(%rsp), %rax
movzbl 0x84(%rax), %eax
cmpl $0x0, %eax
je 0xff667
movl $0x0, -0x4(%rsp)
jmp 0xff682
movq -0x18(%rsp), %rax
movl 0x80(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0xff682
jmp 0xff67a
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_bKGD
png_uint_32 PNGAPI
png_get_bKGD(png_structp png_ptr, png_infop info_ptr,
   png_color_16p *background)
{
   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)
      && background != NULL)
   {
      png_debug1(1, "in %s retrieval function", "bKGD");

      *background = &(info_ptr->background);
      return (PNG_INFO_bKGD);
   }
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xff762
cmpq $0x0, -0x18(%rsp)
je 0xff762
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xff762
cmpq $0x0, -0x20(%rsp)
je 0xff762
movq -0x18(%rsp), %rcx
addq $0x72, %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movl $0x20, -0x4(%rsp)
jmp 0xff76a
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_cHRM
png_uint_32 PNGAPI
png_get_cHRM(png_structp png_ptr, png_infop info_ptr,
   double *white_x, double *white_y, double *red_x, double *red_y,
   double *green_x, double *green_y, double *blue_x, double *blue_y)
{
   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
   {
      png_debug1(1, "in %s retrieval function", "cHRM");

      if (white_x != NULL)
         *white_x = (double)info_ptr->x_white;
      if (white_y != NULL)
         *white_y = (double)info_ptr->y_white;
      if (red_x != NULL)
         *red_x = (double)info_ptr->x_red;
      if (red_y != NULL)
         *red_y = (double)info_ptr->y_red;
      if (green_x != NULL)
         *green_x = (double)info_ptr->x_green;
      if (green_y != NULL)
         *green_y = (double)info_ptr->y_green;
      if (blue_x != NULL)
         *blue_x = (double)info_ptr->x_blue;
      if (blue_y != NULL)
         *blue_y = (double)info_ptr->y_blue;
      return (PNG_INFO_cHRM);
   }
   return (0);
}

// Assembly:
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rax
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq %r8, -0x30(%rsp)
movq %r9, -0x38(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xff8e8
cmpq $0x0, -0x18(%rsp)
je 0xff8e8
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xff8e8
cmpq $0x0, -0x20(%rsp)
je 0xff7f0
movq -0x18(%rsp), %rax
movss 0xa0(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, (%rax)
cmpq $0x0, -0x28(%rsp)
je 0xff812
movq -0x18(%rsp), %rax
movss 0xa4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x28(%rsp), %rax
movsd %xmm0, (%rax)
cmpq $0x0, -0x30(%rsp)
je 0xff834
movq -0x18(%rsp), %rax
movss 0xa8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x30(%rsp), %rax
movsd %xmm0, (%rax)
cmpq $0x0, -0x38(%rsp)
je 0xff856
movq -0x18(%rsp), %rax
movss 0xac(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x38(%rsp), %rax
movsd %xmm0, (%rax)
cmpq $0x0, 0x8(%rsp)
je 0xff878
movq -0x18(%rsp), %rax
movss 0xb0(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
cmpq $0x0, 0x10(%rsp)
je 0xff89a
movq -0x18(%rsp), %rax
movss 0xb4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
cmpq $0x0, 0x18(%rsp)
je 0xff8bc
movq -0x18(%rsp), %rax
movss 0xb8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, (%rax)
cmpq $0x0, 0x20(%rsp)
je 0xff8de
movq -0x18(%rsp), %rax
movss 0xbc(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x4, -0x4(%rsp)
jmp 0xff8f0
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_cHRM_fixed
png_uint_32 PNGAPI
png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
   png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x,
   png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y,
   png_fixed_point *blue_x, png_fixed_point *blue_y)
{
   png_debug1(1, "in %s retrieval function", "cHRM");

   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM))
   {
      if (white_x != NULL)
         *white_x = info_ptr->int_x_white;
      if (white_y != NULL)
         *white_y = info_ptr->int_y_white;
      if (red_x != NULL)
         *red_x = info_ptr->int_x_red;
      if (red_y != NULL)
         *red_y = info_ptr->int_y_red;
      if (green_x != NULL)
         *green_x = info_ptr->int_x_green;
      if (green_y != NULL)
         *green_y = info_ptr->int_y_green;
      if (blue_x != NULL)
         *blue_x = info_ptr->int_x_blue;
      if (blue_y != NULL)
         *blue_y = info_ptr->int_y_blue;
      return (PNG_INFO_cHRM);
   }
   return (0);
}

// Assembly:
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rax
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq %r8, -0x30(%rsp)
movq %r9, -0x38(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xffa38
cmpq $0x0, -0x18(%rsp)
je 0xffa38
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xffa38
cmpq $0x0, -0x20(%rsp)
je 0xff978
movq -0x18(%rsp), %rax
movl 0x14c(%rax), %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rsp)
je 0xff992
movq -0x18(%rsp), %rax
movl 0x150(%rax), %ecx
movq -0x28(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x30(%rsp)
je 0xff9ac
movq -0x18(%rsp), %rax
movl 0x154(%rax), %ecx
movq -0x30(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x38(%rsp)
je 0xff9c6
movq -0x18(%rsp), %rax
movl 0x158(%rax), %ecx
movq -0x38(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x8(%rsp)
je 0xff9e0
movq -0x18(%rsp), %rax
movl 0x15c(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x10(%rsp)
je 0xff9fa
movq -0x18(%rsp), %rax
movl 0x160(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x18(%rsp)
je 0xffa14
movq -0x18(%rsp), %rax
movl 0x164(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x20(%rsp)
je 0xffa2e
movq -0x18(%rsp), %rax
movl 0x168(%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl $0x4, -0x4(%rsp)
jmp 0xffa40
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_gAMA
png_uint_32 PNGAPI
png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma)
{
   png_debug1(1, "in %s retrieval function", "gAMA");

   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
      && file_gamma != NULL)
   {
      *file_gamma = (double)info_ptr->gamma;
      return (PNG_INFO_gAMA);
   }
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xffaa8
cmpq $0x0, -0x18(%rsp)
je 0xffaa8
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xffaa8
cmpq $0x0, -0x20(%rsp)
je 0xffaa8
movq -0x18(%rsp), %rax
movss 0x34(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x1, -0x4(%rsp)
jmp 0xffab0
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_gAMA_fixed
png_uint_32 PNGAPI
png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr,
    png_fixed_point *int_file_gamma)
{
   png_debug1(1, "in %s retrieval function", "gAMA");

   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)
      && int_file_gamma != NULL)
   {
      *int_file_gamma = info_ptr->int_gamma;
      return (PNG_INFO_gAMA);
   }
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xffb13
cmpq $0x0, -0x18(%rsp)
je 0xffb13
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xffb13
cmpq $0x0, -0x20(%rsp)
je 0xffb13
movq -0x18(%rsp), %rax
movl 0x148(%rax), %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rsp)
jmp 0xffb1b
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_sRGB
png_uint_32 PNGAPI
png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent)
{
   png_debug1(1, "in %s retrieval function", "sRGB");

   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)
      && file_srgb_intent != NULL)
   {
      *file_srgb_intent = (int)info_ptr->srgb_intent;
      return (PNG_INFO_sRGB);
   }
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xffb73
cmpq $0x0, -0x18(%rsp)
je 0xffb73
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xffb73
cmpq $0x0, -0x20(%rsp)
je 0xffb73
movq -0x18(%rsp), %rax
movzbl 0x38(%rax), %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
movl $0x800, -0x4(%rsp)      # imm = 0x800
jmp 0xffb7b
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_iCCP
png_uint_32 PNGAPI
png_get_iCCP(png_structp png_ptr, png_infop info_ptr,
             png_charpp name, int *compression_type,
             png_charpp profile, png_uint_32 *proflen)
{
   png_debug1(1, "in %s retrieval function", "iCCP");

   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)
      && name != NULL && profile != NULL && proflen != NULL)
   {
      *name = info_ptr->iccp_name;
      *profile = info_ptr->iccp_profile;
      /* Compression_type is a dummy so the API won't have to change
       * if we introduce multiple compression types later.
       */
      *proflen = (int)info_ptr->iccp_proflen;
      *compression_type = (int)info_ptr->iccp_compression;
      return (PNG_INFO_iCCP);
   }
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq %r8, -0x30(%rsp)
movq %r9, -0x38(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xffc37
cmpq $0x0, -0x18(%rsp)
je 0xffc37
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0xffc37
cmpq $0x0, -0x20(%rsp)
je 0xffc37
cmpq $0x0, -0x30(%rsp)
je 0xffc37
cmpq $0x0, -0x38(%rsp)
je 0xffc37
movq -0x18(%rsp), %rax
movq 0xf8(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
movq 0x100(%rax), %rcx
movq -0x30(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
movl 0x108(%rax), %ecx
movq -0x38(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
movzbl 0x10c(%rax), %ecx
movq -0x28(%rsp), %rax
movl %ecx, (%rax)
movl $0x1000, -0x4(%rsp)     # imm = 0x1000
jmp 0xffc3f
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_sPLT
png_uint_32 PNGAPI
png_get_sPLT(png_structp png_ptr, png_infop info_ptr,
             png_sPLT_tpp spalettes)
{
   if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)
   {
     *spalettes = info_ptr->splt_palettes;
     return ((png_uint_32)info_ptr->splt_palettes_num);
   }
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xffc9c
cmpq $0x0, -0x18(%rsp)
je 0xffc9c
cmpq $0x0, -0x20(%rsp)
je 0xffc9c
movq -0x18(%rsp), %rax
movq 0x110(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
movl 0x118(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0xffca4
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_hIST
png_uint_32 PNGAPI
png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist)
{
   png_debug1(1, "in %s retrieval function", "hIST");

   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)
      && hist != NULL)
   {
      *hist = info_ptr->hist;
      return (PNG_INFO_hIST);
   }
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xffd05
cmpq $0x0, -0x18(%rsp)
je 0xffd05
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0xffd05
cmpq $0x0, -0x20(%rsp)
je 0xffd05
movq -0x18(%rsp), %rax
movq 0x98(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movl $0x40, -0x4(%rsp)
jmp 0xffd0d
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_IHDR
png_uint_32 PNGAPI
png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
   png_uint_32 *width, png_uint_32 *height, int *bit_depth,
   int *color_type, int *interlace_type, int *compression_type,
   int *filter_type)

{
   png_debug1(1, "in %s retrieval function", "IHDR");

   if (png_ptr == NULL || info_ptr == NULL || width == NULL ||
       height == NULL || bit_depth == NULL || color_type == NULL)
      return (0);

   *width = info_ptr->width;
   *height = info_ptr->height;
   *bit_depth = info_ptr->bit_depth;
   *color_type = info_ptr->color_type;

   if (compression_type != NULL)
      *compression_type = info_ptr->compression_type;

   if (filter_type != NULL)
      *filter_type = info_ptr->filter_type;

   if (interlace_type != NULL)
      *interlace_type = info_ptr->interlace_type;

   /* This is redundant if we can be sure that the info_ptr values were all
    * assigned in png_set_IHDR().  We do the check anyhow in case an
    * application has ignored our advice not to mess with the members
    * of info_ptr directly.
    */
   png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,
       info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,
       info_ptr->compression_type, info_ptr->filter_type);

   return (1);
}

// Assembly:
subq $0x48, %rsp
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rax
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0xffd81
cmpq $0x0, 0x30(%rsp)
je 0xffd81
cmpq $0x0, 0x28(%rsp)
je 0xffd81
cmpq $0x0, 0x20(%rsp)
je 0xffd81
cmpq $0x0, 0x18(%rsp)
je 0xffd81
cmpq $0x0, 0x10(%rsp)
jne 0xffd8e
movl $0x0, 0x44(%rsp)
jmp 0xffe6c
movq 0x30(%rsp), %rax
movl (%rax), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
movzbl 0x24(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
movzbl 0x25(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x58(%rsp)
je 0xffde3
movq 0x30(%rsp), %rax
movzbl 0x26(%rax), %ecx
movq 0x58(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x60(%rsp)
je 0xffdfb
movq 0x30(%rsp), %rax
movzbl 0x27(%rax), %ecx
movq 0x60(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x50(%rsp)
je 0xffe13
movq 0x30(%rsp), %rax
movzbl 0x28(%rax), %ecx
movq 0x50(%rsp), %rax
movl %ecx, (%rax)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movl (%rax), %esi
movq 0x30(%rsp), %rax
movl 0x4(%rax), %edx
movq 0x30(%rsp), %rax
movzbl 0x24(%rax), %ecx
movq 0x30(%rsp), %rax
movzbl 0x25(%rax), %r8d
movq 0x30(%rsp), %rax
movzbl 0x28(%rax), %r9d
movq 0x30(%rsp), %rax
movzbl 0x26(%rax), %r10d
movq 0x30(%rsp), %rax
movzbl 0x27(%rax), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0xfc860
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_oFFs
png_uint_32 PNGAPI
png_get_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 retrieval function", "oFFs");

   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)
      && offset_x != NULL && offset_y != NULL && unit_type != NULL)
   {
      *offset_x = info_ptr->x_offset;
      *offset_y = info_ptr->y_offset;
      *unit_type = (int)info_ptr->offset_unit_type;
      return (PNG_INFO_oFFs);
   }
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq %r8, -0x30(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xfff11
cmpq $0x0, -0x18(%rsp)
je 0xfff11
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0xfff11
cmpq $0x0, -0x20(%rsp)
je 0xfff11
cmpq $0x0, -0x28(%rsp)
je 0xfff11
cmpq $0x0, -0x30(%rsp)
je 0xfff11
movq -0x18(%rsp), %rax
movl 0x7c(%rax), %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
movl 0x80(%rax), %ecx
movq -0x28(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
movzbl 0x84(%rax), %ecx
movq -0x30(%rsp), %rax
movl %ecx, (%rax)
movl $0x100, -0x4(%rsp)      # imm = 0x100
jmp 0xfff19
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_pCAL
png_uint_32 PNGAPI
png_get_pCAL(png_structp png_ptr, png_infop info_ptr,
   png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams,
   png_charp *units, png_charpp *params)
{
   png_debug1(1, "in %s retrieval function", "pCAL");

   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)
       && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
       nparams != NULL && units != NULL && params != NULL)
   {
      *purpose = info_ptr->pcal_purpose;
      *X0 = info_ptr->pcal_X0;
      *X1 = info_ptr->pcal_X1;
      *type = (int)info_ptr->pcal_type;
      *nparams = (int)info_ptr->pcal_nparams;
      *units = info_ptr->pcal_units;
      *params = info_ptr->pcal_params;
      return (PNG_INFO_pCAL);
   }
   return (0);
}

// Assembly:
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rax
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq %r8, -0x30(%rsp)
movq %r9, -0x38(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0x10005f
cmpq $0x0, -0x18(%rsp)
je 0x10005f
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x10005f
cmpq $0x0, -0x20(%rsp)
je 0x10005f
cmpq $0x0, -0x28(%rsp)
je 0x10005f
cmpq $0x0, -0x30(%rsp)
je 0x10005f
cmpq $0x0, -0x38(%rsp)
je 0x10005f
cmpq $0x0, 0x8(%rsp)
je 0x10005f
cmpq $0x0, 0x10(%rsp)
je 0x10005f
cmpq $0x0, 0x18(%rsp)
je 0x10005f
movq -0x18(%rsp), %rax
movq 0xc0(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
movl 0xc8(%rax), %ecx
movq -0x28(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
movl 0xcc(%rax), %ecx
movq -0x30(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
movzbl 0xe0(%rax), %ecx
movq -0x38(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
movzbl 0xe1(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
movq 0xd0(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
movq 0xd8(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movl $0x400, -0x4(%rsp)      # imm = 0x400
jmp 0x100067
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_sCAL
png_uint_32 PNGAPI
png_get_sCAL(png_structp png_ptr, png_infop info_ptr,
             int *unit, double *width, double *height)
{
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_sCAL))
    {
        *unit = info_ptr->scal_unit;
        *width = info_ptr->scal_pixel_width;
        *height = info_ptr->scal_pixel_height;
        return (PNG_INFO_sCAL);
    }
    return(0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq %r8, -0x30(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0x1000f4
cmpq $0x0, -0x18(%rsp)
je 0x1000f4
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x1000f4
movq -0x18(%rsp), %rax
movzbl 0x11c(%rax), %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
movsd 0x120(%rax), %xmm0
movq -0x28(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rsp), %rax
movsd 0x128(%rax), %xmm0
movq -0x30(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x4000, -0x4(%rsp)     # imm = 0x4000
jmp 0x1000fc
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_pHYs
png_uint_32 PNGAPI
png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
   png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)
{
   png_uint_32 retval = 0;

   png_debug1(1, "in %s retrieval function", "pHYs");

   if (png_ptr != NULL && info_ptr != NULL &&
      (info_ptr->valid & PNG_INFO_pHYs))
   {
      if (res_x != NULL)
      {
         *res_x = info_ptr->x_pixels_per_unit;
         retval |= PNG_INFO_pHYs;
      }

      if (res_y != NULL)
      {
         *res_y = info_ptr->y_pixels_per_unit;
         retval |= PNG_INFO_pHYs;
      }

      if (unit_type != NULL)
      {
         *unit_type = (int)info_ptr->phys_unit_type;
         retval |= PNG_INFO_pHYs;
      }
   }
   return (retval);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0x1001d3
cmpq $0x0, -0x10(%rsp)
je 0x1001d3
movq -0x10(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x1001d3
cmpq $0x0, -0x18(%rsp)
je 0x100182
movq -0x10(%rsp), %rax
movl 0x88(%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movl -0x2c(%rsp), %eax
orl $0x80, %eax
movl %eax, -0x2c(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0x1001a9
movq -0x10(%rsp), %rax
movl 0x8c(%rax), %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
movl -0x2c(%rsp), %eax
orl $0x80, %eax
movl %eax, -0x2c(%rsp)
cmpq $0x0, -0x28(%rsp)
je 0x1001d1
movq -0x10(%rsp), %rax
movzbl 0x90(%rax), %ecx
movq -0x28(%rsp), %rax
movl %ecx, (%rax)
movl -0x2c(%rsp), %eax
orl $0x80, %eax
movl %eax, -0x2c(%rsp)
jmp 0x1001d3
movl -0x2c(%rsp), %eax
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_PLTE
png_uint_32 PNGAPI
png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette,
   int *num_palette)
{
   png_debug1(1, "in %s retrieval function", "PLTE");

   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE)
       && palette != NULL)
   {
      *palette = info_ptr->palette;
      *num_palette = info_ptr->num_palette;
      png_debug1(3, "num_palette = %d", *num_palette);
      return (PNG_INFO_PLTE);
   }
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0x100247
cmpq $0x0, -0x18(%rsp)
je 0x100247
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x100247
cmpq $0x0, -0x20(%rsp)
je 0x100247
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
movzwl 0x20(%rax), %ecx
movq -0x28(%rsp), %rax
movl %ecx, (%rax)
movl $0x8, -0x4(%rsp)
jmp 0x10024f
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_sBIT
png_uint_32 PNGAPI
png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit)
{
   png_debug1(1, "in %s retrieval function", "sBIT");

   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)
      && sig_bit != NULL)
   {
      *sig_bit = &(info_ptr->sig_bit);
      return (PNG_INFO_sBIT);
   }
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0x1002b2
cmpq $0x0, -0x18(%rsp)
je 0x1002b2
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1002b2
cmpq $0x0, -0x20(%rsp)
je 0x1002b2
movq -0x18(%rsp), %rcx
addq $0x58, %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rsp)
jmp 0x1002ba
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_text
png_uint_32 PNGAPI
png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
   int *num_text)
{
   if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
   {
      png_debug1(1, "in %s retrieval function",
         (png_ptr->chunk_name[0] == '\0' ? "text"
             : (png_const_charp)png_ptr->chunk_name));

      if (text_ptr != NULL)
         *text_ptr = info_ptr->text;

      if (num_text != NULL)
         *num_text = info_ptr->num_text;

      return ((png_uint_32)info_ptr->num_text);
   }
   if (num_text != NULL)
     *num_text = 0;
   return(0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0x10032d
cmpq $0x0, -0x18(%rsp)
je 0x10032d
movq -0x18(%rsp), %rax
cmpl $0x0, 0x3c(%rax)
jle 0x10032d
cmpq $0x0, -0x20(%rsp)
je 0x100308
movq -0x18(%rsp), %rax
movq 0x48(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rsp)
je 0x10031f
movq -0x18(%rsp), %rax
movl 0x3c(%rax), %ecx
movq -0x28(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x100348
cmpq $0x0, -0x28(%rsp)
je 0x100340
movq -0x28(%rsp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_tIME
png_uint_32 PNGAPI
png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time)
{
   png_debug1(1, "in %s retrieval function", "tIME");

   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)
       && mod_time != NULL)
   {
      *mod_time = &(info_ptr->mod_time);
      return (PNG_INFO_tIME);
   }
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0x1003a4
cmpq $0x0, -0x18(%rsp)
je 0x1003a4
movq -0x18(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x1003a4
cmpq $0x0, -0x20(%rsp)
je 0x1003a4
movq -0x18(%rsp), %rcx
addq $0x50, %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movl $0x200, -0x4(%rsp)      # imm = 0x200
jmp 0x1003ac
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_tRNS
png_uint_32 PNGAPI
png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
   png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)
{
   png_uint_32 retval = 0;
   if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS))
   {
      png_debug1(1, "in %s retrieval function", "tRNS");

      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
      {
          if (trans_alpha != NULL)
          {
             *trans_alpha = info_ptr->trans_alpha;
             retval |= PNG_INFO_tRNS;
          }

          if (trans_color != NULL)
             *trans_color = &(info_ptr->trans_color);
      }
      else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
      {
          if (trans_color != NULL)
          {
             *trans_color = &(info_ptr->trans_color);
             retval |= PNG_INFO_tRNS;
          }

          if (trans_alpha != NULL)
             *trans_alpha = NULL;
      }
      if (num_trans != NULL)
      {
         *num_trans = info_ptr->num_trans;
         retval |= PNG_INFO_tRNS;
      }
   }
   return (retval);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0x1004b9
cmpq $0x0, -0x10(%rsp)
je 0x1004b9
movq -0x10(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1004b9
movq -0x10(%rsp), %rax
movzbl 0x25(%rax), %eax
cmpl $0x3, %eax
jne 0x10045a
cmpq $0x0, -0x18(%rsp)
je 0x10043f
movq -0x10(%rsp), %rax
movq 0x60(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movl -0x2c(%rsp), %eax
orl $0x10, %eax
movl %eax, -0x2c(%rsp)
cmpq $0x0, -0x28(%rsp)
je 0x100458
movq -0x10(%rsp), %rcx
addq $0x68, %rcx
movq -0x28(%rsp), %rax
movq %rcx, (%rax)
jmp 0x100494
cmpq $0x0, -0x28(%rsp)
je 0x10047e
movq -0x10(%rsp), %rcx
addq $0x68, %rcx
movq -0x28(%rsp), %rax
movq %rcx, (%rax)
movl -0x2c(%rsp), %eax
orl $0x10, %eax
movl %eax, -0x2c(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0x100492
movq -0x18(%rsp), %rax
movq $0x0, (%rax)
jmp 0x100494
cmpq $0x0, -0x20(%rsp)
je 0x1004b7
movq -0x10(%rsp), %rax
movzwl 0x22(%rax), %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
movl -0x2c(%rsp), %eax
orl $0x10, %eax
movl %eax, -0x2c(%rsp)
jmp 0x1004b9
movl -0x2c(%rsp), %eax
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/png/pngget.c
// Function: png_get_unknown_chunks
png_uint_32 PNGAPI
png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr,
             png_unknown_chunkpp unknowns)
{
   if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
   {
     *unknowns = info_ptr->unknown_chunks;
     return ((png_uint_32)info_ptr->unknown_chunks_num);
   }
   return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0x10050d
cmpq $0x0, -0x18(%rsp)
je 0x10050d
cmpq $0x0, -0x20(%rsp)
je 0x10050d
movq -0x18(%rsp), %rax
movq 0xe8(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
movq 0xf0(%rax), %rax
movl %eax, -0x4(%rsp)
jmp 0x100515
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngread.c
// Function: png_read_update_info
void PNGAPI
png_read_update_info(png_structp png_ptr, png_infop info_ptr)
{
   png_debug(1, "in png_read_update_info");
 
   if (png_ptr == NULL)
      return;
   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
      png_read_start_row(png_ptr);
   else
      png_warning(png_ptr,
      "Ignoring extra png_read_update_info() call; row buffer not reallocated");

   png_read_transform_info(png_ptr, info_ptr);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x101608
jmp 0x101647
movq 0x10(%rsp), %rax
movl 0x120(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x101627
movq 0x10(%rsp), %rdi
callq 0x129680
jmp 0x101638
movq 0x10(%rsp), %rdi
leaq 0x37bbc(%rip), %rsi     # 0x1391ef
callq 0x113940
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x10a290
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngread.c
// Function: png_start_read_image
void PNGAPI
png_start_read_image(png_structp png_ptr)
{
   png_debug(1, "in png_start_read_image");
 
   if (png_ptr == NULL)
      return;
   if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
      png_read_start_row(png_ptr);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x10165e
jmp 0x101679
movq (%rsp), %rax
movl 0x120(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x101679
movq (%rsp), %rdi
callq 0x129680
popq %rax
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngread.c
// Function: png_read_rows
void PNGAPI
png_read_rows(png_structp png_ptr, png_bytepp row,
   png_bytepp display_row, png_uint_32 num_rows)
{
   png_uint_32 i;
   png_bytepp rp;
   png_bytepp dp;

   png_debug(1, "in png_read_rows");
 
   if (png_ptr == NULL)
      return;
   rp = row;
   dp = display_row;
   if (rp != NULL && dp != NULL)
      for (i = 0; i < num_rows; i++)
      {
         png_bytep rptr = *rp++;
         png_bytep dptr = *dp++;

         png_read_row(png_ptr, rptr, dptr);
      }
   else if (rp != NULL)
      for (i = 0; i < num_rows; i++)
      {
         png_bytep rptr = *rp;
         png_read_row(png_ptr, rptr, NULL);
         rp++;
      }
   else if (dp != NULL)
      for (i = 0; i < num_rows; i++)
      {
         png_bytep dptr = *dp;
         png_read_row(png_ptr, NULL, dptr);
         dp++;
      }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x102194
jmp 0x1022d4
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x102222
cmpq $0x0, 0x28(%rsp)
je 0x102222
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jae 0x10221d
movq 0x30(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x30(%rsp)
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x28(%rsp)
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x101680
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x1021c0
jmp 0x1022d4
cmpq $0x0, 0x30(%rsp)
je 0x102279
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jae 0x102277
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x101680
movq 0x30(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x30(%rsp)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x102232
jmp 0x1022d2
cmpq $0x0, 0x28(%rsp)
je 0x1022d0
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jae 0x1022ce
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x101680
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x102289
jmp 0x1022d0
jmp 0x1022d2
jmp 0x1022d4
addq $0x58, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngread.c
// Function: png_read_image
void PNGAPI
png_read_image(png_structp png_ptr, png_bytepp image)
{
   png_uint_32 i, image_height;
   int pass, j;
   png_bytepp rp;

   png_debug(1, "in png_read_image");
 
   if (png_ptr == NULL)
      return;

#ifdef PNG_READ_INTERLACING_SUPPORTED
   pass = png_set_interlace_handling(png_ptr);
#else
   if (png_ptr->interlaced)
      png_error(png_ptr,
        "Cannot read interlaced image -- interlace handler disabled");
   pass = 1;
#endif


   image_height=png_ptr->height;
   png_ptr->num_rows = image_height; /* Make sure this is set correctly */

   for (j = 0; j < pass; j++)
   {
      rp = image;
      for (i = 0; i < image_height; i++)
      {
         png_read_row(png_ptr, *rp, NULL);
         rp++;
      }
   }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x1022fb
jmp 0x102391
movq 0x20(%rsp), %rdi
callq 0x129f90
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movl 0x1c0(%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x1c4(%rax)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x102391
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jae 0x102382
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x101680
movq (%rsp), %rax
addq $0x8, %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x10234a
jmp 0x102384
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10232f
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngrio.c
// Function: png_default_read_data
void PNGAPI
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
{
   png_size_t check;

   if (png_ptr == NULL)
      return;
   /* fread() returns 0 on error, so it is OK to store this in a png_size_t
    * instead of an int, which is what fread() actually returns.
    */
   check = fread(data, 1, length, (png_FILE_p)png_ptr->io_ptr);

   if (check != length)
      png_error(png_ptr, "Read Error");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x1035ed
jmp 0x10362f
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0xf8(%rax), %rcx
movl $0x1, %esi
callq 0xf780
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x10362f
movq 0x20(%rsp), %rdi
leaq 0x35cce(%rip), %rsi     # 0x1392f8
callq 0x113860
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngrio.c
// Function: png_set_read_fn
void PNGAPI
png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
   png_rw_ptr read_data_fn)
{
   if (png_ptr == NULL)
      return;
   png_ptr->io_ptr = io_ptr;

#ifdef PNG_STDIO_SUPPORTED
   if (read_data_fn != NULL)
      png_ptr->read_data_fn = read_data_fn;
   else
      png_ptr->read_data_fn = png_default_read_data;
#else
   png_ptr->read_data_fn = read_data_fn;
#endif

   /* It is an error to write to a read device */
   if (png_ptr->write_data_fn != NULL)
   {
      png_ptr->write_data_fn = NULL;
      png_warning(png_ptr,
         "It's an error to set both read_data_fn and write_data_fn in the ");
      png_warning(png_ptr,
         "same structure.  Resetting write_data_fn to NULL");
   }

#ifdef PNG_WRITE_FLUSH_SUPPORTED
   png_ptr->output_flush_fn = NULL;
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x10365f
jmp 0x1036ed
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xf8(%rax)
cmpq $0x0, (%rsp)
je 0x103689
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xf0(%rax)
jmp 0x10369c
movq 0x10(%rsp), %rax
leaq -0xc5(%rip), %rcx       # 0x1035d0
movq %rcx, 0xf0(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0xe8(%rax)
je 0x1036dd
movq 0x10(%rsp), %rax
movq $0x0, 0xe8(%rax)
movq 0x10(%rsp), %rdi
leaq 0x35c3c(%rip), %rsi     # 0x139303
callq 0x113940
movq 0x10(%rsp), %rdi
leaq 0x35c6c(%rip), %rsi     # 0x139344
callq 0x113940
movq 0x10(%rsp), %rax
movq $0x0, 0x278(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/png/pngwrite.c
// Function: png_convert_from_struct_tm
void PNGAPI
png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)
{
   png_debug(1, "in png_convert_from_struct_tm");

   ptime->year = (png_uint_16)(1900 + ttime->tm_year);
   ptime->month = (png_byte)(ttime->tm_mon + 1);
   ptime->day = (png_byte)ttime->tm_mday;
   ptime->hour = (png_byte)ttime->tm_hour;
   ptime->minute = (png_byte)ttime->tm_min;
   ptime->second = (png_byte)ttime->tm_sec;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movl 0x14(%rax), %eax
addl $0x76c, %eax            # imm = 0x76C
movw %ax, %cx
movq -0x8(%rsp), %rax
movw %cx, (%rax)
movq -0x10(%rsp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rsp), %rax
movl 0xc(%rax), %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x3(%rax)
movq -0x10(%rsp), %rax
movl 0x8(%rax), %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rsp), %rax
movl 0x4(%rax), %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x5(%rax)
movq -0x10(%rsp), %rax
movl (%rax), %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x6(%rax)
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/png/pngwrite.c
// Function: png_write_rows
void PNGAPI
png_write_rows(png_structp png_ptr, png_bytepp row,
   png_uint_32 num_rows)
{
   png_uint_32 i; /* row counter */
   png_bytepp rp; /* row pointer */

   png_debug(1, "in png_write_rows");

   if (png_ptr == NULL)
      return;

   /* Loop through the rows */
   for (i = 0, rp = row; i < num_rows; i++, rp++)
   {
      png_write_row(png_ptr, *rp);
   }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x104e0c
jmp 0x104e55
movl $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x104e55
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x104e60
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
jmp 0x104e1e
addq $0x28, %rsp
retq
nopw (%rax,%rax)