// File: /workspace/github_cpp_makefile_star2_O3/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:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x8b8be
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x8b3c8
testb $0x8, 0x8(%rbx)
jne 0x8b61a
cmpb $0x3, 0x25(%rbx)
jne 0x8b62a
leaq 0x2155e(%rip), %rsi     # 0xacb6e
movq %r14, %rdi
callq 0x920b4
jmp 0x8b62a
movq 0x18(%rbx), %rsi
movzwl 0x20(%rbx), %edx
movq %r14, %rdi
callq 0x9ddeb
movl 0x8(%rbx), %eax
testb $0x10, %al
je 0x8b679
testb $0x8, 0x126(%r14)
je 0x8b65d
cmpb $0x3, 0x25(%rbx)
jne 0x8b65d
cmpw $0x0, 0x22(%rbx)
je 0x8b65d
xorl %eax, %eax
movq 0x60(%rbx), %rcx
notb (%rcx,%rax)
incq %rax
movzwl 0x22(%rbx), %ecx
cmpq %rcx, %rax
jb 0x8b64a
movq 0x60(%rbx), %rsi
leaq 0x68(%rbx), %rdx
movzwl 0x22(%rbx), %ecx
movzbl 0x25(%rbx), %r8d
movq %r14, %rdi
callq 0x9eda0
movl 0x8(%rbx), %eax
testb $0x20, %al
je 0x8b690
leaq 0x72(%rbx), %rsi
movzbl 0x25(%rbx), %edx
movq %r14, %rdi
callq 0x9eea1
movl 0x8(%rbx), %eax
testb $0x40, %al
je 0x8b6aa
movq 0x98(%rbx), %rsi
movzwl 0x20(%rbx), %edx
movq %r14, %rdi
callq 0x9efa9
movl 0x8(%rbx), %eax
btl $0x8, %eax
jae 0x8b6cb
movl 0x7c(%rbx), %esi
movl 0x80(%rbx), %edx
movzbl 0x84(%rbx), %ecx
movq %r14, %rdi
callq 0x9f3e1
movl 0x8(%rbx), %eax
btl $0xa, %eax
jae 0x8b70a
movq 0xc0(%rbx), %rsi
movl 0xc8(%rbx), %edx
movl 0xcc(%rbx), %ecx
movzbl 0xe0(%rbx), %r8d
movzbl 0xe1(%rbx), %r9d
movups 0xd0(%rbx), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x9f46e
movl 0x8(%rbx), %eax
btl $0xe, %eax
jae 0x8b732
movzbl 0x11c(%rbx), %esi
movsd 0x120(%rbx), %xmm0
movsd 0x128(%rbx), %xmm1
movq %r14, %rdi
callq 0x9f630
movl 0x8(%rbx), %eax
testb %al, %al
jns 0x8b754
movl 0x88(%rbx), %esi
movl 0x8c(%rbx), %edx
movzbl 0x90(%rbx), %ecx
movq %r14, %rdi
callq 0x9f6d3
movl 0x8(%rbx), %eax
btl $0x9, %eax
jae 0x8b771
leaq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0x9f760
orb $0x2, 0x11d(%r14)
movl 0x8(%rbx), %eax
btl $0xd, %eax
jae 0x8b7ab
cmpl $0x0, 0x118(%rbx)
jle 0x8b7ab
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x110(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x9e808
incq %r12
movslq 0x118(%rbx), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x8b786
cmpl $0x0, 0x3c(%rbx)
jle 0x8b83f
movq 0x48(%rbx), %rax
xorl %r15d, %r15d
xorl %r12d, %r12d
movl (%rax,%r15), %esi
testl %esi, %esi
jle 0x8b802
movq 0x28(%rax,%r15), %rcx
movq 0x30(%rax,%r15), %r8
movq 0x8(%rax,%r15), %rdx
movq 0x10(%rax,%r15), %r9
movq %r14, %rdi
callq 0x9f231
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
movq 0x48(%rbx), %rax
movl %ecx, (%rax,%r15)
incq %r12
movslq 0x3c(%rbx), %rcx
addq $0x38, %r15
cmpq %rcx, %r12
jl 0x8b7bf
jmp 0x8b83f
cmpl $-0x1, %esi
je 0x8b829
testl %esi, %esi
jne 0x8b7f0
movq 0x8(%rax,%r15), %rsi
movq 0x10(%rax,%r15), %rdx
movq %r14, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x9f0f7
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
jmp 0x8b7e8
movq 0x8(%rax,%r15), %rsi
movq 0x10(%rax,%r15), %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x9f050
jmp 0x8b7e3
cmpq $0x0, 0xf0(%rbx)
je 0x8b8b3
jle 0x8b8b3
movq 0xe8(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x874b4
cmpl $0x1, %eax
je 0x8b898
movb 0x18(%r15), %cl
andb $0x6, %cl
cmpb $0x2, %cl
jne 0x8b898
cmpl $0x3, %eax
je 0x8b885
movb 0x3(%r15), %al
andb $0x20, %al
jne 0x8b885
testb $0x1, 0x122(%r14)
je 0x8b898
movq 0x8(%r15), %rdx
movq 0x10(%r15), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x9d8bd
addq $0x20, %r15
movq 0xf0(%rbx), %rax
shlq $0x5, %rax
addq 0xe8(%rbx), %rax
cmpq %rax, %r15
jb 0x8b852
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq