// File: tomfunkhouser[P]gaps/pkgs/png/pngwrite.c
// Function: png_write_info
void PNGAPI
png_write_info(png_structp png_ptr, png_infop info_ptr)
{
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
   int i;
#endif

   png_debug(1, "in png_write_info");

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

   png_write_info_before_PLTE(png_ptr, info_ptr);

   if (info_ptr->valid & PNG_INFO_PLTE)
      png_write_PLTE(png_ptr, info_ptr->palette,
         (png_uint_32)info_ptr->num_palette);
   else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
      png_error(png_ptr, "Valid palette required for paletted images");

#ifdef PNG_WRITE_tRNS_SUPPORTED
   if (info_ptr->valid & PNG_INFO_tRNS)
   {
#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
      /* Invert the alpha channel (in tRNS) */
      if ((png_ptr->transformations & PNG_INVERT_ALPHA) &&
         info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
      {
         int j;
         for (j = 0; j<(int)info_ptr->num_trans; j++)
            info_ptr->trans_alpha[j] = (png_byte)(255 - info_ptr->trans_alpha[j]);
      }
#endif
      png_write_tRNS(png_ptr, info_ptr->trans_alpha, &(info_ptr->trans_color),
         info_ptr->num_trans, info_ptr->color_type);
   }
#endif
#ifdef PNG_WRITE_bKGD_SUPPORTED
   if (info_ptr->valid & PNG_INFO_bKGD)
      png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);
#endif
#ifdef PNG_WRITE_hIST_SUPPORTED
   if (info_ptr->valid & PNG_INFO_hIST)
      png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);
#endif
#ifdef PNG_WRITE_oFFs_SUPPORTED
   if (info_ptr->valid & PNG_INFO_oFFs)
      png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,
         info_ptr->offset_unit_type);
#endif
#ifdef PNG_WRITE_pCAL_SUPPORTED
   if (info_ptr->valid & PNG_INFO_pCAL)
      png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,
         info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,
         info_ptr->pcal_units, info_ptr->pcal_params);
#endif

#ifdef PNG_sCAL_SUPPORTED
   if (info_ptr->valid & PNG_INFO_sCAL)
#ifdef PNG_WRITE_sCAL_SUPPORTED
#if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)
      png_write_sCAL(png_ptr, (int)info_ptr->scal_unit,
          info_ptr->scal_pixel_width, info_ptr->scal_pixel_height);
#else /* !FLOATING_POINT */
#ifdef PNG_FIXED_POINT_SUPPORTED
      png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,
          info_ptr->scal_s_width, info_ptr->scal_s_height);
#endif /* FIXED_POINT */
#endif /* FLOATING_POINT */
#else  /* !WRITE_sCAL */
      png_warning(png_ptr,
          "png_write_sCAL not supported; sCAL chunk not written");
#endif /* WRITE_sCAL */
#endif /* sCAL */

#ifdef PNG_WRITE_pHYs_SUPPORTED
   if (info_ptr->valid & PNG_INFO_pHYs)
      png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,
         info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);
#endif /* pHYs */

#ifdef PNG_WRITE_tIME_SUPPORTED
   if (info_ptr->valid & PNG_INFO_tIME)
   {
      png_write_tIME(png_ptr, &(info_ptr->mod_time));
      png_ptr->mode |= PNG_WROTE_tIME;
   }
#endif /* tIME */

#ifdef PNG_WRITE_sPLT_SUPPORTED
   if (info_ptr->valid & PNG_INFO_sPLT)
     for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
       png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);
#endif /* sPLT */

#ifdef PNG_WRITE_TEXT_SUPPORTED
   /* Check to see if we need to write text chunks */
   for (i = 0; i < info_ptr->num_text; i++)
   {
      png_debug2(2, "Writing header text chunk %d, type %d", i,
         info_ptr->text[i].compression);
      /* An internationalized chunk? */
      if (info_ptr->text[i].compression > 0)
      {
#ifdef PNG_WRITE_iTXt_SUPPORTED
          /* Write international chunk */
          png_write_iTXt(png_ptr,
                         info_ptr->text[i].compression,
                         info_ptr->text[i].key,
                         info_ptr->text[i].lang,
                         info_ptr->text[i].lang_key,
                         info_ptr->text[i].text);
#else
          png_warning(png_ptr, "Unable to write international text");
#endif
          /* Mark this chunk as written */
          info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
      }
      /* If we want a compressed text chunk */
      else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)
      {
#ifdef PNG_WRITE_zTXt_SUPPORTED
         /* Write compressed chunk */
         png_write_zTXt(png_ptr, info_ptr->text[i].key,
            info_ptr->text[i].text, 0,
            info_ptr->text[i].compression);
#else
         png_warning(png_ptr, "Unable to write compressed text");
#endif
         /* Mark this chunk as written */
         info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
      }
      else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
      {
#ifdef PNG_WRITE_tEXt_SUPPORTED
         /* Write uncompressed chunk */
         png_write_tEXt(png_ptr, info_ptr->text[i].key,
                         info_ptr->text[i].text,
                         0);
         /* Mark this chunk as written */
         info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
#else
         /* Can't get here */
         png_warning(png_ptr, "Unable to write uncompressed text");
#endif
      }
   }
#endif /* tEXt */

#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
   if (info_ptr->unknown_chunks_num)
   {
      png_unknown_chunk *up;

      png_debug(5, "writing extra chunks");

      for (up = info_ptr->unknown_chunks;
           up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
           up++)
      {
         int keep = png_handle_as_unknown(png_ptr, up->name);
         if (keep != PNG_HANDLE_CHUNK_NEVER &&
            up->location && (up->location & PNG_HAVE_PLTE) &&
            !(up->location & PNG_HAVE_IDAT) &&
            ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS ||
            (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
         {
            png_write_chunk(png_ptr, up->name, up->data, up->size);
         }
      }
   }
#endif
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x103a9e
cmpq $0x0, 0x28(%rsp)
jne 0x103aa3
jmp 0x1040e1
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x103700
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x103ae0
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x28(%rsp), %rax
movzwl 0x20(%rax), %edx
callq 0x12b830
jmp 0x103b01
movq 0x28(%rsp), %rax
movzbl 0x25(%rax), %eax
cmpl $0x3, %eax
jne 0x103aff
movq 0x30(%rsp), %rdi
leaq 0x358e4(%rip), %rsi     # 0x1393de
callq 0x113860
jmp 0x103b01
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x103bbd
movq 0x30(%rsp), %rax
movl 0x124(%rax), %eax
andq $0x80000, %rax          # imm = 0x80000
cmpq $0x0, %rax
je 0x103b8e
movq 0x28(%rsp), %rax
movzbl 0x25(%rax), %eax
cmpl $0x3, %eax
jne 0x103b8e
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movq 0x28(%rsp), %rcx
movzwl 0x22(%rcx), %ecx
cmpl %ecx, %eax
jge 0x103b8c
movq 0x28(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x20(%rsp), %rcx
movzbl (%rax,%rcx), %ecx
movl $0xff, %eax
subl %ecx, %eax
movb %al, %dl
movq 0x28(%rsp), %rax
movq 0x60(%rax), %rax
movslq 0x20(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x103b42
jmp 0x103b8e
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x60(%rax), %rsi
movq 0x28(%rsp), %rdx
addq $0x68, %rdx
movq 0x28(%rsp), %rax
movzwl 0x22(%rax), %ecx
movq 0x28(%rsp), %rax
movzbl 0x25(%rax), %r8d
callq 0x12d0e0
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x103be9
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x72, %rsi
movq 0x28(%rsp), %rax
movzbl 0x25(%rax), %edx
callq 0x12d2a0
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x103c18
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x98(%rax), %rsi
movq 0x28(%rsp), %rax
movzwl 0x20(%rax), %edx
callq 0x12d460
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x103c53
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x7c(%rax), %esi
movq 0x28(%rsp), %rax
movl 0x80(%rax), %edx
movq 0x28(%rsp), %rax
movzbl 0x84(%rax), %ecx
callq 0x12da80
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x103ccc
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0xc0(%rax), %rsi
movq 0x28(%rsp), %rax
movl 0xc8(%rax), %edx
movq 0x28(%rsp), %rax
movl 0xcc(%rax), %ecx
movq 0x28(%rsp), %rax
movzbl 0xe0(%rax), %r8d
movq 0x28(%rsp), %rax
movzbl 0xe1(%rax), %r9d
movq 0x28(%rsp), %rax
movq 0xd0(%rax), %r10
movq 0x28(%rsp), %rax
movq 0xd8(%rax), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x12db10
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x103d0e
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movzbl 0x11c(%rax), %esi
movq 0x28(%rsp), %rax
movsd 0x120(%rax), %xmm0
movq 0x28(%rsp), %rax
movsd 0x128(%rax), %xmm1
callq 0x12dd40
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x103d4c
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x88(%rax), %esi
movq 0x28(%rsp), %rax
movl 0x8c(%rax), %edx
movq 0x28(%rsp), %rax
movzbl 0x90(%rax), %ecx
callq 0x12de20
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x103d88
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x50, %rsi
callq 0x12deb0
movq 0x30(%rsp), %rax
movl 0x11c(%rax), %ecx
orl $0x200, %ecx            # imm = 0x200
movl %ecx, 0x11c(%rax)
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x103de4
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x118(%rcx), %eax
jge 0x103de2
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x110(%rax), %rsi
movslq 0x24(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x12c950
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x103da2
jmp 0x103de4
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x3c(%rcx), %eax
jge 0x103fdb
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
jle 0x103ec1
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %esi
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rcx
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x24(%rsp), %r8
imulq $0x38, %r8, %r8
addq %r8, %rax
movq 0x30(%rax), %r8
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x24(%rsp), %r9
imulq $0x38, %r9, %r9
addq %r9, %rax
movq 0x10(%rax), %r9
callq 0x12d7a0
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
jmp 0x103fc9
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0x103f50
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdx
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %r8d
xorl %eax, %eax
movl %eax, %ecx
callq 0x12d610
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
jmp 0x103fc7
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
cmpl $-0x1, (%rax)
jne 0x103fc5
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x12d520
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movl $0xfffffffd, (%rax)     # imm = 0xFFFFFFFD
jmp 0x103fc7
jmp 0x103fc9
jmp 0x103fcb
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x103dec
movq 0x28(%rsp), %rax
cmpq $0x0, 0xf0(%rax)
je 0x1040e1
movq 0x28(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0xe8(%rcx), %rcx
movq 0x28(%rsp), %rdx
movq 0xf0(%rdx), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x1040df
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xfc3e0
movl %eax, 0x14(%rsp)
cmpl $0x1, 0x14(%rsp)
je 0x1040ca
movq 0x18(%rsp), %rax
movzbl 0x18(%rax), %eax
cmpl $0x0, %eax
je 0x1040ca
movq 0x18(%rsp), %rax
movzbl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1040ca
movq 0x18(%rsp), %rax
movzbl 0x18(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x1040ca
movq 0x18(%rsp), %rax
movzbl 0x3(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x1040a9
cmpl $0x3, 0x14(%rsp)
je 0x1040a9
movq 0x30(%rsp), %rax
movl 0x120(%rax), %eax
andq $0x10000, %rax          # imm = 0x10000
cmpq $0x0, %rax
je 0x1040ca
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
callq 0x12b040
jmp 0x1040cc
movq 0x18(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x18(%rsp)
jmp 0x103fff
jmp 0x1040e1
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)