LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_info_copy(LodePNGInfo*, LodePNGInfo const*)
unsigned lodepng_info_copy(LodePNGInfo* dest, const LodePNGInfo* source)
{
  lodepng_info_cleanup(dest);
  *dest = *source;
  lodepng_color_mode_init(&dest->color);
  CERROR_TRY_RETURN(lodepng_color_mode_copy(&dest->color, &source->color));

#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  CERROR_TRY_RETURN(LodePNGText_copy(dest, source));
  CERROR_TRY_RETURN(LodePNGIText_copy(dest, source));

  LodePNGUnknownChunks_init(dest);
  CERROR_TRY_RETURN(LodePNGUnknownChunks_copy(dest, source));
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7cc4
vmovups (%rbx), %zmm0
vmovups 0x40(%rbx), %zmm1
vmovups 0x80(%rbx), %zmm2
vmovups 0xa8(%rbx), %zmm3
leaq 0x10(%r14), %rdi
leaq 0x10(%rbx), %rsi
movabsq $0x800000006, %rax      # imm = 0x800000006
vmovups %zmm0, (%r14)
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm3, 0xa8(%r14)
vmovups %zmm2, 0x80(%r14)
vmovups %zmm1, 0x40(%r14)
movq %rax, 0x10(%r14)
vmovups %ymm0, 0x18(%r14)
vzeroupper
callq 0x75fd
testl %eax, %eax
je 0x7d9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
vxorps %xmm0, %xmm0, %xmm0
movq $0x0, 0x58(%r14)
vmovups %xmm0, 0x48(%r14)
cmpq $0x0, 0x48(%rbx)
je 0x7dde
xorl %r15d, %r15d
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rcx
movq %r14, %rdi
movq (%rax,%r15,8), %rsi
movq (%rcx,%r15,8), %rdx
callq 0x7892
testl %eax, %eax
jne 0x7d93
incq %r15
cmpq 0x48(%rbx), %r15
jne 0x7db9
vxorps %xmm0, %xmm0, %xmm0
movq $0x0, 0x80(%r14)
vmovups %ymm0, 0x60(%r14)
cmpq $0x0, 0x60(%rbx)
je 0x7e3c
xorl %r15d, %r15d
movq 0x68(%rbx), %rax
movq 0x70(%rbx), %rcx
movq %r14, %rdi
movq (%rax,%r15,8), %rsi
movq (%rcx,%r15,8), %rdx
movq 0x78(%rbx), %rcx
movq 0x80(%rbx), %rax
movq (%rcx,%r15,8), %rcx
movq (%rax,%r15,8), %r8
vzeroupper
callq 0x7a78
testl %eax, %eax
jne 0x7d93
incq %r15
cmpq 0x60(%rbx), %r15
jne 0x7dfd
vxorps %xmm0, %xmm0, %xmm0
leaq 0xb8(%r14), %r12
xorl %r15d, %r15d
vmovups %ymm0, 0xc8(%r14)
vmovups %ymm0, 0xb8(%r14)
movq (%r12,%r15,8), %rdi
vzeroupper
callq 0x21b0
incq %r15
cmpq $0x3, %r15
jne 0x7e5c
xorl %r13d, %r13d
movq 0xd0(%rbx,%r13,8), %r15
movq %r15, %rdi
movq %r15, 0xd0(%r14,%r13,8)
callq 0x21e0
testq %rax, %rax
movq %rax, 0xb8(%r14,%r13,8)
sete %al
testq %r15, %r15
setne %cl
testb %al, %cl
jne 0x7eda
testq %r15, %r15
je 0x7eca
xorl %eax, %eax
movq 0xb8(%rbx,%r13,8), %rcx
movq (%r12,%r13,8), %rdx
movb (%rcx,%rax), %cl
movb %cl, (%rdx,%rax)
incq %rax
cmpq 0xd0(%rbx,%r13,8), %rax
jb 0x7eab
incq %r13
cmpq $0x3, %r13
jne 0x7e74
xorl %eax, %eax
jmp 0x7d93
movl $0x53, %eax
jmp 0x7d93
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_color_mode_equal(LodePNGColorMode const*, LodePNGColorMode const*)
static int lodepng_color_mode_equal(const LodePNGColorMode* a, const LodePNGColorMode* b)
{
  size_t i;
  if(a->colortype != b->colortype) return 0;
  if(a->bitdepth != b->bitdepth) return 0;
  if(a->key_defined != b->key_defined) return 0;
  if(a->key_defined)
  {
    if(a->key_r != b->key_r) return 0;
    if(a->key_g != b->key_g) return 0;
    if(a->key_b != b->key_b) return 0;
  }
  /*if one of the palette sizes is 0, then we consider it to be the same as the
  other: it means that e.g. the palette was not given by the user and should be
  considered the same as the palette inside the PNG.*/
  if(1/*a->palettesize != 0 && b->palettesize != 0*/) {
    if(a->palettesize != b->palettesize) return 0;
    for(i = 0; i != a->palettesize * 4; ++i)
    {
      if(a->palette[i] != b->palette[i]) return 0;
    }
  }
  return 1;
}

// Assembly:
movl (%rdi), %ecx
xorl %eax, %eax
cmpl (%rsi), %ecx
jne 0x847a
movl 0x4(%rdi), %ecx
cmpl 0x4(%rsi), %ecx
jne 0x847a
movl 0x18(%rdi), %ecx
cmpl 0x18(%rsi), %ecx
jne 0x847a
testl %ecx, %ecx
je 0x8442
movl 0x1c(%rdi), %ecx
cmpl 0x1c(%rsi), %ecx
jne 0x847a
movl 0x20(%rdi), %ecx
cmpl 0x20(%rsi), %ecx
jne 0x847a
movl 0x24(%rdi), %ecx
cmpl 0x24(%rsi), %ecx
jne 0x847a
movq 0x10(%rdi), %rcx
cmpq 0x10(%rsi), %rcx
jne 0x847a
shlq $0x2, %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0x847a
movq 0x8(%rdi), %rdx
movq 0x8(%rsi), %rsi
xorl %edi, %edi
movb (%rdx,%rdi), %r8b
cmpb (%rsi,%rdi), %r8b
jne 0x8478
incq %rdi
cmpq %rdi, %rcx
jne 0x8464
jmp 0x847a
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: color_tree_add(ColorTree*, unsigned char, unsigned char, unsigned char, unsigned char, unsigned int)
static void color_tree_add(ColorTree* tree,
                           unsigned char r, unsigned char g, unsigned char b, unsigned char a, unsigned index)
{
  int bit;
  for(bit = 0; bit < 8; ++bit)
  {
    int i = 8 * ((r >> bit) & 1) + 4 * ((g >> bit) & 1) + 2 * ((b >> bit) & 1) + 1 * ((a >> bit) & 1);
    if(!tree->children[i])
    {
      tree->children[i] = (ColorTree*)lodepng_malloc(sizeof(ColorTree));
      color_tree_init(tree->children[i]);
    }
    tree = tree->children[i];
  }
  tree->index = (int)index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, (%rsp)
movl %ecx, %r15d
movl %edx, %r12d
movl %esi, %r14d
movq %rdi, %r13
xorl %ebx, %ebx
movl %r8d, 0x4(%rsp)
shrxl %ebx, %r12d, %edi
shrxl %ebx, %r8d, %r10d
shrxl %ebx, %r14d, %eax
shrxl %ebx, %r15d, %r9d
andl $0x1, %edi
andl $0x1, %r10d
andl $0x1, %eax
andl $0x1, %r9d
leal (%r10,%rdi,4), %edi
leal (%rdi,%rax,8), %eax
leal (%rax,%r9,2), %ebp
movq (%r13,%rbp,8), %rax
testq %rax, %rax
jne 0x850b
movl $0x88, %edi
vzeroupper
callq 0x21e0
vxorps %xmm0, %xmm0, %xmm0
movq %rax, (%r13,%rbp,8)
movl 0x4(%rsp), %r8d
vmovups %zmm0, (%rax)
vmovups %zmm0, 0x40(%rax)
movl $0xffffffff, 0x80(%rax) # imm = 0xFFFFFFFF
movq (%r13,%rbp,8), %rax
incl %ebx
movq %rax, %r13
cmpl $0x8, %ebx
jne 0x849d
movl (%rsp), %ecx
movl %ecx, 0x80(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: getPixelColorRGBA16(unsigned short*, unsigned short*, unsigned short*, unsigned short*, unsigned char const*, unsigned long, LodePNGColorMode const*)
static void getPixelColorRGBA16(unsigned short* r, unsigned short* g, unsigned short* b, unsigned short* a,
                                const unsigned char* in, size_t i, const LodePNGColorMode* mode)
{
  if(mode->colortype == LCT_GREY)
  {
    *r = *g = *b = 256 * in[i * 2 + 0] + in[i * 2 + 1];
    if(mode->key_defined && 256U * in[i * 2 + 0] + in[i * 2 + 1] == mode->key_r) *a = 0;
    else *a = 65535;
  }
  else if(mode->colortype == LCT_RGB)
  {
    *r = 256u * in[i * 6 + 0] + in[i * 6 + 1];
    *g = 256u * in[i * 6 + 2] + in[i * 6 + 3];
    *b = 256u * in[i * 6 + 4] + in[i * 6 + 5];
    if(mode->key_defined
       && 256u * in[i * 6 + 0] + in[i * 6 + 1] == mode->key_r
       && 256u * in[i * 6 + 2] + in[i * 6 + 3] == mode->key_g
       && 256u * in[i * 6 + 4] + in[i * 6 + 5] == mode->key_b) *a = 0;
    else *a = 65535;
  }
  else if(mode->colortype == LCT_GREY_ALPHA)
  {
    *r = *g = *b = 256u * in[i * 4 + 0] + in[i * 4 + 1];
    *a = 256u * in[i * 4 + 2] + in[i * 4 + 3];
  }
  else if(mode->colortype == LCT_RGBA)
  {
    *r = 256u * in[i * 8 + 0] + in[i * 8 + 1];
    *g = 256u * in[i * 8 + 2] + in[i * 8 + 3];
    *b = 256u * in[i * 8 + 4] + in[i * 8 + 5];
    *a = 256u * in[i * 8 + 6] + in[i * 8 + 7];
  }
}

// Assembly:
pushq %rbx
movq 0x10(%rsp), %rax
movl (%rax), %r10d
cmpq $0x6, %r10
ja 0x866a
leaq 0x9072(%rip), %r11      # 0x115bc
movslq (%r11,%r10,4), %r10
addq %r11, %r10
jmpq *%r10
movzbl (%r8,%r9,2), %r10d
movzbl 0x1(%r8,%r9,2), %r11d
shll $0x8, %r10d
orl %r10d, %r11d
movw %r11w, (%rdx)
movw %r11w, (%rsi)
movw %r11w, (%rdi)
cmpl $0x0, 0x18(%rax)
je 0x8639
leaq 0x1(%r9,%r9), %rdx
addq %r9, %r9
movzbl (%r8,%r9), %esi
movzbl (%r8,%rdx), %edx
shll $0x8, %esi
orl %esi, %edx
cmpl 0x1c(%rax), %edx
jne 0x8639
xorl %eax, %eax
jmp 0x8667
movzwl (%r8,%r9,4), %eax
movbew %ax, (%rdx)
movbew %ax, (%rsi)
movbew %ax, (%rdi)
movbew 0x2(%r8,%r9,4), %ax
jmp 0x8667
addq %r9, %r9
leaq (%r9,%r9,2), %r10
movzbl (%r8,%r10), %r11d
movzbl 0x1(%r8,%r10), %ebx
shll $0x8, %r11d
orl %r11d, %ebx
movw %bx, (%rdi)
movzwl 0x2(%r8,%r10), %edi
movbew %di, (%rsi)
movzwl 0x4(%r8,%r10), %esi
movbew %si, (%rdx)
cmpl $0x0, 0x18(%rax)
je 0x8639
leaq 0x1(%r9,%r9,2), %rdx
movzbl (%r8,%r10), %esi
movzbl (%r8,%rdx), %edx
shll $0x8, %esi
orl %esi, %edx
cmpl 0x1c(%rax), %edx
jne 0x8639
movbew 0x2(%r8,%r10), %dx
movzwl %dx, %edx
cmpl 0x20(%rax), %edx
jne 0x8639
movbew 0x4(%r8,%r10), %dx
movzwl %dx, %edx
cmpl 0x24(%rax), %edx
je 0x859c
movw $0xffff, %ax            # imm = 0xFFFF
jmp 0x8667
movzwl (%r8,%r9,8), %eax
movbew %ax, (%rdi)
movzwl 0x2(%r8,%r9,8), %eax
movbew %ax, (%rsi)
movzwl 0x4(%r8,%r9,8), %eax
movbew %ax, (%rdx)
movbew 0x6(%r8,%r9,8), %ax
movw %ax, (%rcx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: color_tree_cleanup(ColorTree*)
static void color_tree_cleanup(ColorTree* tree)
{
  int i;
  for(i = 0; i != 16; ++i)
  {
    if(tree->children[i])
    {
      color_tree_cleanup(tree->children[i]);
      lodepng_free(tree->children[i]);
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x8de5
callq 0x8dc4
movq (%rbx,%r14,8), %rdi
callq 0x21b0
incq %r14
cmpq $0x10, %r14
jne 0x8dce
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: checkColorValidity(LodePNGColorType, unsigned int)
static unsigned checkColorValidity(LodePNGColorType colortype, unsigned bd) /*bd = bitdepth*/
{
  switch(colortype)
  {
    case 0: if(!(bd == 1 || bd == 2 || bd == 4 || bd == 8 || bd == 16)) return 37; break; /*grey*/
    case 2: if(!(                                 bd == 8 || bd == 16)) return 37; break; /*RGB*/
    case 3: if(!(bd == 1 || bd == 2 || bd == 4 || bd == 8            )) return 37; break; /*palette*/
    case 4: if(!(                                 bd == 8 || bd == 16)) return 37; break; /*grey + alpha*/
    case 6: if(!(                                 bd == 8 || bd == 16)) return 37; break; /*RGBA*/
    default: return 31;
  }
  return 0; /*allowed color type / bits combination*/
}

// Assembly:
movl $0x1f, %eax
cmpl $0x6, %edi
ja 0x9aa9
leaq 0x7bb0(%rip), %rdx      # 0x11610
movl %edi, %ecx
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
addl $-0x8, %esi
movl $0x25, %eax
andl $-0x9, %esi
cmovel %esi, %eax
retq
movl $0x25, %eax
cmpl $0x10, %esi
ja 0x9aa9
movl $0x10116, %ecx          # imm = 0x10116
btl %esi, %ecx
jae 0x9aa9
xorl %eax, %eax
retq
decl %esi
movl $0x25, %eax
cmpl $0x8, %esi
jae 0x9aa9
leaq 0x87fc(%rip), %rcx      # 0x122a0
movl %esi, %eax
movl (%rcx,%rax,4), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_decode_memory(unsigned char**, unsigned int*, unsigned int*, unsigned char const*, unsigned long, LodePNGColorType, unsigned int)
unsigned lodepng_decode_memory(unsigned char** out, unsigned* w, unsigned* h, const unsigned char* in,
                               size_t insize, LodePNGColorType colortype, unsigned bitdepth)
{
  unsigned error;
  LodePNGState state;
  lodepng_state_init(&state);
  state.info_raw.colortype = colortype;
  state.info_raw.bitdepth = bitdepth;
  error = lodepng_decode(out, w, h, &state, in, insize);
  lodepng_state_cleanup(&state);
  return error;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
vmovaps 0x7981(%rip), %ymm1     # 0x12280
movq %r8, %rax
movq %rcx, %r8
movl 0x1d0(%rsp), %ecx
leaq 0xc485(%rip), %r10      # 0x16d98
leaq 0x8(%rsp), %rbx
vxorps %xmm0, %xmm0, %xmm0
movl $0x1, %r11d
movabsq $0x100000001, %r14      # imm = 0x100000001
movq %r10, (%rbx)
xorl %r10d, %r10d
movl %r10d, 0x8(%rbx)
vmovups %xmm0, 0x10(%rbx)
vmovups %xmm0, 0x1c(%rbx)
vmovups %ymm1, 0x2c(%rbx)
movl %r11d, 0x4c(%rbx)
vmovups %xmm0, 0x50(%rbx)
movq %r10, 0x60(%rbx)
movl %r11d, 0x70(%rbx)
movq %r14, 0x68(%rbx)
vmovups %xmm0, 0x78(%rbx)
vxorps %xmm0, %xmm0, %xmm0
movabsq $0x800000006, %r14      # imm = 0x800000006
movl %r11d, 0x88(%rbx)
vmovups %ymm0, 0x98(%rbx)
movq %r14, 0xc8(%rbx)
vmovups %ymm0, 0xd0(%rbx)
movl %r10d, 0xc0(%rbx)
movq %r10, 0xb8(%rbx)
movl %r10d, 0x15c(%rbx)
vmovups %ymm0, 0x180(%rbx)
vmovups %ymm0, 0x170(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm0, 0x104(%rbx)
vmovups %zmm0, 0xf0(%rbx)
movl %r11d, 0x1a0(%rbx)
movl %r9d, 0x90(%rbx)
movl %ecx, 0x94(%rbx)
movq %rbx, %rcx
movq %rax, %r9
vzeroupper
callq 0x9aaa
movq %rbx, %rdi
movl %eax, %ebp
callq 0xaac0
movl %ebp, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_state_init(LodePNGState*)
void lodepng_decoder_settings_init(LodePNGDecoderSettings* settings)
{
  settings->color_convert = 1;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  settings->read_text_chunks = 1;
  settings->remember_unknown_chunks = 0;
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
  settings->ignore_crc = 0;
  lodepng_decompress_settings_init(&settings->zlibsettings);
}

// Assembly:
vmovaps 0x7876(%rip), %ymm1     # 0x12280
vxorps %xmm0, %xmm0, %xmm0
movl $0x1, %ecx
movabsq $0x100000001, %rdx      # imm = 0x100000001
xorl %eax, %eax
movl %eax, 0x8(%rdi)
vmovups %xmm0, 0x10(%rdi)
vmovups %xmm0, 0x1c(%rdi)
vmovups %ymm1, 0x2c(%rdi)
movl %ecx, 0x4c(%rdi)
vmovups %xmm0, 0x50(%rdi)
movq %rax, 0x60(%rdi)
movl %ecx, 0x70(%rdi)
movq %rdx, 0x68(%rdi)
vmovups %xmm0, 0x78(%rdi)
movabsq $0x800000006, %rdx      # imm = 0x800000006
vxorps %xmm0, %xmm0, %xmm0
movl %ecx, 0x88(%rdi)
movq %rdx, 0x90(%rdi)
vmovups %ymm0, 0x98(%rdi)
movq %rdx, 0xc8(%rdi)
vmovups %ymm0, 0xd0(%rdi)
movl %eax, 0xc0(%rdi)
movq %rax, 0xb8(%rdi)
movl %eax, 0x15c(%rdi)
vmovups %ymm0, 0x180(%rdi)
vmovups %ymm0, 0x170(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm0, 0x104(%rdi)
vmovups %zmm0, 0xf0(%rdi)
movl %ecx, 0x1a0(%rdi)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_decode_file(unsigned char**, unsigned int*, unsigned int*, char const*, LodePNGColorType, unsigned int)
unsigned lodepng_decode_file(unsigned char** out, unsigned* w, unsigned* h, const char* filename,
                             LodePNGColorType colortype, unsigned bitdepth)
{
  unsigned char* buffer = 0;
  size_t buffersize;
  unsigned error;
  error = lodepng_load_file(&buffer, &buffersize, filename);
  if(!error) error = lodepng_decode_memory(out, w, h, buffer, buffersize, colortype, bitdepth);
  lodepng_free(buffer);
  return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
leaq 0x20(%rsp), %r12
leaq 0x18(%rsp), %rsi
movq %rdx, %r14
movq %rdi, %r13
movl %r9d, %ebp
movl %r8d, 0x14(%rsp)
movq %rcx, %rdx
movq %r12, %rdi
movq $0x0, (%r12)
callq 0x4071
movq (%r12), %r12
movl %eax, %ebx
testl %eax, %eax
jne 0xab8e
movq 0x18(%rsp), %r8
movl 0x14(%rsp), %r9d
movl %ebp, (%rsp)
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0xa8ec
movl %eax, %ebx
movq %r12, %rdi
callq 0x21b0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_encoder_settings_init(LodePNGEncoderSettings*)
void lodepng_compress_settings_init(LodePNGCompressSettings* settings)
{
  /*compress with dynamic huffman tree (not in the mathematical sense, just not the predefined one)*/
  settings->btype = 2;
  settings->use_lz77 = 1;
  settings->windowsize = DEFAULT_WINDOWSIZE;
  settings->minmatch = 3;
  settings->nicematch = 128;
  settings->lazymatching = 1;

  settings->custom_zlib = 0;
  settings->custom_deflate = 0;
  settings->custom_context = 0;
}

// Assembly:
vmovaps 0x76fb(%rip), %xmm0     # 0x122f0
movabsq $0x100000080, %rax      # imm = 0x100000080
movabsq $0x100000001, %rcx      # imm = 0x100000001
vmovups %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
vxorps %xmm0, %xmm0, %xmm0
movl $0x1, %eax
movq $0x0, 0x28(%rdi)
vmovups %xmm0, 0x18(%rdi)
movl %eax, 0x38(%rdi)
movq %rcx, 0x30(%rdi)
vmovups %xmm0, 0x40(%rdi)
movl %eax, 0x50(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_state_copy(LodePNGState*, LodePNGState const*)
void lodepng_state_copy(LodePNGState* dest, const LodePNGState* source)
{
  lodepng_state_cleanup(dest);
  *dest = *source;
  lodepng_color_mode_init(&dest->info_raw);
  lodepng_info_init(&dest->info_png);
  dest->error = lodepng_color_mode_copy(&dest->info_raw, &source->info_raw); if(dest->error) return;
  dest->error = lodepng_info_copy(&dest->info_png, &source->info_png); if(dest->error) return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xaac0
leaq 0x8(%rbx), %rdi
leaq 0x8(%r14), %rsi
movl $0x19c, %edx            # imm = 0x19C
callq 0x2100
movl $0x90, %esi
movabsq $0x800000006, %rax      # imm = 0x800000006
vxorps %xmm0, %xmm0, %xmm0
leaq (%rbx,%rsi), %rdi
movq %rax, 0x90(%rbx)
vmovups %ymm0, 0x98(%rbx)
movq %rax, 0xc8(%rbx)
addq %r14, %rsi
vmovups %ymm0, 0xd0(%rbx)
xorl %eax, %eax
movl %eax, 0xc0(%rbx)
movq $0x0, 0xb8(%rbx)
movl %eax, 0x15c(%rbx)
vmovups %ymm0, 0x170(%rbx)
vmovups %ymm0, 0x180(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm0, 0xf0(%rbx)
vmovups %zmm0, 0x104(%rbx)
vzeroupper
callq 0x75fd
movl %eax, 0x1a0(%rbx)
testl %eax, %eax
jne 0xacff
addq $0xb8, %r14
leaq 0xb8(%rbx), %rdi
movq %r14, %rsi
callq 0x7d17
movl %eax, 0x1a0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: writeSignature(ucvector*)
static void writeSignature(ucvector* out)
{
  /*8 bytes PNG signature, aka the magic bytes*/
  ucvector_push_back(out, 137);
  ucvector_push_back(out, 80);
  ucvector_push_back(out, 78);
  ucvector_push_back(out, 71);
  ucvector_push_back(out, 13);
  ucvector_push_back(out, 10);
  ucvector_push_back(out, 26);
  ucvector_push_back(out, 10);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
movq %rdi, %rbx
incq %r14
movq %r14, %rsi
callq 0xd905
testl %eax, %eax
je 0xb8e7
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movb $-0x77, -0x1(%rax,%r14)
movq 0x8(%rbx), %r14
movq %rbx, %rdi
incq %r14
movq %r14, %rsi
callq 0xd905
testl %eax, %eax
je 0xb90a
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movb $0x50, -0x1(%rax,%r14)
movq 0x8(%rbx), %r14
movq %rbx, %rdi
incq %r14
movq %r14, %rsi
callq 0xd905
testl %eax, %eax
je 0xb92d
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movb $0x4e, -0x1(%rax,%r14)
movq 0x8(%rbx), %r14
movq %rbx, %rdi
incq %r14
movq %r14, %rsi
callq 0xd905
testl %eax, %eax
je 0xb950
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movb $0x47, -0x1(%rax,%r14)
movq 0x8(%rbx), %r14
movq %rbx, %rdi
incq %r14
movq %r14, %rsi
callq 0xd905
testl %eax, %eax
je 0xb973
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movb $0xd, -0x1(%rax,%r14)
movq 0x8(%rbx), %r14
movq %rbx, %rdi
incq %r14
movq %r14, %rsi
callq 0xd905
testl %eax, %eax
je 0xb996
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movb $0xa, -0x1(%rax,%r14)
movq 0x8(%rbx), %r14
movq %rbx, %rdi
incq %r14
movq %r14, %rsi
callq 0xd905
testl %eax, %eax
je 0xb9b9
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movb $0x1a, -0x1(%rax,%r14)
movq 0x8(%rbx), %r14
movq %rbx, %rdi
incq %r14
movq %r14, %rsi
callq 0xd905
testl %eax, %eax
je 0xb9dc
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movb $0xa, -0x1(%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: addUnknownChunks(ucvector*, unsigned char*, unsigned long)
static unsigned addUnknownChunks(ucvector* out, unsigned char* data, size_t datasize)
{
  unsigned char* inchunk = data;
  while((size_t)(inchunk - data) < datasize)
  {
    CERROR_TRY_RETURN(lodepng_chunk_append(&out->data, &out->size, inchunk));
    out->allocsize = out->size; /*fix the allocsize again*/
    inchunk = lodepng_chunk_next(inchunk);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdx, %rdx
je 0xbc62
leaq 0x8(%rdi), %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x741b
testl %eax, %eax
jne 0xbc60
movq 0x8(%r12), %rax
movq %rax, 0x10(%r12)
movbel (%rbp), %eax
addl $0xc, %eax
addq %rax, %rbp
movq %rbp, %rax
subq %r15, %rax
cmpq %r14, %rax
jb 0xbc2c
jmp 0xbc62
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: addChunk_PLTE(ucvector*, LodePNGColorMode const*)
static unsigned addChunk_PLTE(ucvector* out, const LodePNGColorMode* info)
{
  unsigned error = 0;
  size_t i;
  ucvector PLTE;
  ucvector_init(&PLTE);
  for(i = 0; i != info->palettesize * 4; ++i)
  {
    /*add all channels except alpha channel*/
    if(i % 4 != 3) ucvector_push_back(&PLTE, info->palette[i]);
  }
  error = addChunk(out, "PLTE", PLTE.data, PLTE.size);
  ucvector_cleanup(&PLTE);

  return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x10(%rsi), %rax
movq %rdi, %rbx
shlq $0x2, %rax
testq %rax, %rax
je 0xbd26
movq %rbx, 0x8(%rsp)
xorl %ebp, %ebp
xorl %r14d, %r14d
xorl %edx, %edx
xorl %r15d, %r15d
movq %rsi, 0x10(%rsp)
movl %ebp, %eax
notl %eax
testb $0x3, %al
je 0xbd0f
movq 0x8(%rsi), %rax
leaq 0x1(%rdx), %r12
movb (%rax,%rbp), %dil
cmpq %r12, %r14
jae 0xbcfb
leaq (%r12,%r12,2), %r13
leaq (%r14,%r14), %rax
movb %dil, 0x7(%rsp)
movq %r15, %rdi
movq %rdx, %rbx
shrq %r13
cmpq %r12, %rax
cmovbq %r12, %r13
movq %r13, %rsi
callq 0x2260
movb 0x7(%rsp), %dil
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
testq %rax, %rax
jne 0xbd01
jmp 0xbd0f
movq %r15, %rax
movq %r14, %r13
movb %dil, -0x1(%rax,%r12)
movq %rax, %r15
movq %r12, %rdx
movq %r13, %r14
movq 0x10(%rsi), %rax
incq %rbp
shlq $0x2, %rax
cmpq %rax, %rbp
jne 0xbca9
movq 0x8(%rsp), %rbx
jmp 0xbd2b
xorl %r15d, %r15d
xorl %edx, %edx
leaq 0x8(%rbx), %rsi
leaq 0x7527(%rip), %rcx      # 0x1325d
movq %rbx, %rdi
movq %r15, %r8
callq 0x74dc
testl %eax, %eax
jne 0xbd4d
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rbx)
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: getPaletteTranslucency(unsigned char const*, unsigned long)
static unsigned getPaletteTranslucency(const unsigned char* palette, size_t palettesize)
{
  size_t i;
  unsigned key = 0;
  unsigned r = 0, g = 0, b = 0; /*the value of the color with alpha 0, so long as color keying is possible*/
  for(i = 0; i != palettesize; ++i)
  {
    if(!key && palette[4 * i + 3] == 0)
    {
      r = palette[4 * i + 0]; g = palette[4 * i + 1]; b = palette[4 * i + 2];
      key = 1;
      i = (size_t)(-1); /*restart from beginning, to detect earlier opaque colors with key's value*/
    }
    else if(palette[4 * i + 3] != 255) return 2;
    /*when key, no opaque RGB may have key's RGB*/
    else if(key && r == palette[i * 4 + 0] && g == palette[i * 4 + 1] && b == palette[i * 4 + 2]) return 2;
  }
  return key;
}

// Assembly:
testq %rsi, %rsi
je 0xbdfb
pushq %rbx
xorl %ecx, %ecx
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r10d, %r10d
xorl %r9d, %r9d
movzbl 0x3(%rdi,%r9,4), %ebx
leaq (,%r9,4), %r11
testl %r10d, %r10d
je 0xbdc1
movl $0x2, %eax
cmpl $0xff, %ebx
jne 0xbdf9
movzbl (%rdi,%r11), %ebx
movl $0x1, %r10d
cmpl %ebx, %r8d
jne 0xbdee
movzbl 0x1(%rdi,%r11), %ebx
cmpl %ebx, %edx
jne 0xbdee
movzbl 0x2(%rdi,%r11), %r11d
cmpl %r11d, %ecx
jne 0xbdee
jmp 0xbdf9
xorl %r10d, %r10d
cmpl $0xff, %ebx
je 0xbdee
testl %ebx, %ebx
jne 0xbdfe
movzbl (%rdi,%r11), %r8d
movzbl 0x1(%rdi,%r11), %edx
movzbl 0x2(%rdi,%r11), %ecx
movl $0x1, %r10d
movq $-0x1, %r9
incq %r9
movl %r10d, %eax
cmpq %rsi, %r9
jne 0xbd7a
popq %rbx
retq
xorl %eax, %eax
retq
movl $0x2, %eax
jmp 0xbdf9
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: addChunk_pHYs(ucvector*, LodePNGInfo const*)
static unsigned addChunk_pHYs(ucvector* out, const LodePNGInfo* info)
{
  unsigned error = 0;
  ucvector data;
  ucvector_init(&data);

  lodepng_add32bitInt(&data, info->phys_x);
  lodepng_add32bitInt(&data, info->phys_y);
  ucvector_push_back(&data, info->phys_unit);

  error = addChunk(out, "pHYs", data.data, data.size);
  ucvector_cleanup(&data);

  return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
vxorps %xmm0, %xmm0, %xmm0
movq %rsp, %r12
movq $0x0, 0x10(%r12)
movq %rsi, %r14
movq %rdi, %rbx
movq %r12, %rdi
vmovaps %xmm0, (%r12)
movl 0xa8(%rsi), %esi
callq 0x720d
movl 0xac(%r14), %esi
movq %r12, %rdi
callq 0x720d
movq 0x8(%r12), %r15
movb 0xb0(%r14), %bpl
movq (%r12), %r14
movq 0x10(%r12), %rax
leaq 0x1(%r15), %r13
cmpq %r13, %rax
jae 0xc535
leaq (%r13,%r13,2), %rsi
addq %rax, %rax
movq %r14, %rdi
shrq %rsi
cmpq %r13, %rax
cmovbq %r13, %rsi
callq 0x2260
testq %rax, %rax
jne 0xc538
jmp 0xc543
movq %r14, %rax
movb %bpl, -0x1(%rax,%r13)
movq %r13, %r15
movq %rax, %r14
leaq 0x8(%rbx), %rsi
leaq 0x6d32(%rip), %rcx      # 0x13280
movq %rbx, %rdi
movl %r15d, %edx
movq %r14, %r8
callq 0x74dc
testl %eax, %eax
jne 0xc568
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rbx)
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: addChunk_IDAT(ucvector*, unsigned char const*, unsigned long, LodePNGCompressSettings*)
static unsigned addChunk_IDAT(ucvector* out, const unsigned char* data, size_t datasize,
                              LodePNGCompressSettings* zlibsettings)
{
  ucvector zlibdata;
  unsigned error = 0;

  /*compress with the Zlib compressor*/
  ucvector_init(&zlibdata);
  error = zlib_compress(&zlibdata.data, &zlibdata.size, data, datasize, zlibsettings);
  if(!error) error = addChunk(out, "IDAT", zlibdata.data, zlibdata.size);
  ucvector_cleanup(&zlibdata);

  return error;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
vxorps %xmm0, %xmm0, %xmm0
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r14
movq %rsp, %rdi
vmovaps %xmm0, -0x8(%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rsi
movq 0x18(%r8), %rax
testq %rax, %rax
je 0xc5bb
callq *%rax
jmp 0xc5c0
callq 0x6f8b
movl %eax, %ebp
testl %eax, %eax
jne 0xc5f1
movq (%rsp), %r8
movl 0x8(%rsp), %edx
leaq 0x8(%r14), %rsi
leaq 0x6c7a(%rip), %rcx      # 0x13253
movq %r14, %rdi
callq 0x74dc
movl %eax, %ebp
testl %eax, %eax
jne 0xc5f1
movq 0x8(%r14), %rax
xorl %ebp, %ebp
movq %rax, 0x10(%r14)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rbx)
movq (%rsp), %rdi
callq 0x21b0
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: addChunk_tIME(ucvector*, LodePNGTime const*)
static unsigned addChunk_tIME(ucvector* out, const LodePNGTime* time)
{
  unsigned error = 0;
  unsigned char* data = (unsigned char*)lodepng_malloc(7);
  if(!data) return 83; /*alloc fail*/
  data[0] = (unsigned char)(time->year >> 8);
  data[1] = (unsigned char)(time->year & 255);
  data[2] = (unsigned char)time->month;
  data[3] = (unsigned char)time->day;
  data[4] = (unsigned char)time->hour;
  data[5] = (unsigned char)time->minute;
  data[6] = (unsigned char)time->second;
  error = addChunk(out, "tIME", data, 7);
  lodepng_free(data);
  return error;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x7, %edi
movq %rsi, %r14
callq 0x21e0
testq %rax, %rax
je 0xc67f
vmovdqu (%r14), %xmm0
movq %rax, %rbp
movl (%r14), %eax
leaq 0x8(%rbx), %rsi
leaq 0x6c3f(%rip), %rcx      # 0x1327b
movl $0x7, %edx
movq %rbx, %rdi
movq %rbp, %r8
movb %ah, (%rbp)
vpmovdb %xmm0, 0x1(%rbp)
movb 0x10(%r14), %al
movb %al, 0x5(%rbp)
movb 0x14(%r14), %al
movb %al, 0x6(%rbp)
callq 0x74dc
testl %eax, %eax
jne 0xc673
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rbx)
movq %rbp, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x21b0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: addChunk_tEXt(ucvector*, char const*, char const*)
static unsigned addChunk_tEXt(ucvector* out, const char* keyword, const char* textstring)
{
  unsigned error = 0;
  size_t i;
  ucvector text;
  ucvector_init(&text);
  for(i = 0; keyword[i] != 0; ++i) ucvector_push_back(&text, (unsigned char)keyword[i]);
  if(i < 1 || i > 79) return 89; /*error: invalid keyword size*/
  ucvector_push_back(&text, 0); /*0 termination char*/
  for(i = 0; textstring[i] != 0; ++i) ucvector_push_back(&text, (unsigned char)textstring[i]);
  error = addChunk(out, "tEXt", text.data, text.size);
  ucvector_cleanup(&text);

  return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movb (%rsi), %r13b
movq %rdx, 0x8(%rsp)
testb %r13b, %r13b
je 0xc9a0
movq $-0x1, %r14
movq %rdi, 0x10(%rsp)
xorl %edx, %edx
xorl %ebx, %ebx
xorl %r15d, %r15d
movq %rsi, 0x18(%rsp)
leaq 0x1(%rbx), %r12
cmpq %r12, %rdx
jae 0xc979
leaq (%r12,%r12,2), %rbp
leaq (%rdx,%rdx), %rax
movq %r15, %rdi
movq %rdx, 0x20(%rsp)
shrq %rbp
cmpq %r12, %rax
cmovbq %r12, %rbp
movq %rbp, %rsi
callq 0x2260
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
testq %rax, %rax
jne 0xc97f
jmp 0xc98d
movq %r15, %rax
movq %rdx, %rbp
movb %r13b, -0x1(%rax,%r12)
movq %rbp, %rdx
movq %rax, %r15
movq %r12, %rbx
movb 0x2(%rsi,%r14), %r13b
incq %r14
testb %r13b, %r13b
jne 0xc93d
cmpq $0x4e, %r14
jbe 0xc9af
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1(%rbx), %r14
cmpq %r14, %rdx
jae 0xc9ea
leaq (%r14,%r14,2), %r13
leaq (%rdx,%rdx), %rax
movq %r15, %rdi
movq %rdx, %r12
shrq %r13
cmpq %r14, %rax
cmovbq %r14, %r13
movq %r13, %rsi
callq 0x2260
movq 0x8(%rsp), %rcx
movq %rbx, %rdx
movq %r12, %rbx
testq %rax, %rax
jne 0xc9f5
jmp 0xca04
movq 0x8(%rsp), %rcx
movq %r15, %rax
movq %rdx, %r13
movb $0x0, -0x1(%rax,%r14)
movq %r13, %rbx
movq %rax, %r15
movq %r14, %rdx
movb (%rcx), %bpl
testb %bpl, %bpl
je 0xca6b
incq %rcx
leaq 0x1(%rdx), %r14
cmpq %r14, %rbx
jae 0xca4c
leaq (%r14,%r14,2), %r13
leaq (%rbx,%rbx), %rax
movq %r15, %rdi
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
shrq %r13
cmpq %r14, %rax
cmovbq %r14, %r13
movq %r13, %rsi
callq 0x2260
movq 0x8(%rsp), %rcx
movq %r12, %rdx
testq %rax, %rax
jne 0xca52
jmp 0xca60
movq %r15, %rax
movq %rbx, %r13
movb %bpl, -0x1(%rax,%r14)
movq %r13, %rbx
movq %rax, %r15
movq %r14, %rdx
movb (%rcx), %bpl
incq %rcx
testb %bpl, %bpl
jne 0xca0f
movq 0x10(%rsp), %r14
leaq 0x67f5(%rip), %rcx      # 0x1326c
movq %r15, %r8
leaq 0x8(%r14), %rsi
movq %r14, %rdi
callq 0x74dc
testl %eax, %eax
jne 0xca92
movq 0x8(%r14), %rax
movq %rax, 0x10(%r14)
movq %r15, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_encode_memory(unsigned char**, unsigned long*, unsigned char const*, unsigned int, unsigned int, LodePNGColorType, unsigned int)
unsigned lodepng_encode_memory(unsigned char** out, size_t* outsize, const unsigned char* image,
                               unsigned w, unsigned h, LodePNGColorType colortype, unsigned bitdepth)
{
  unsigned error;
  LodePNGState state;
  lodepng_state_init(&state);
  state.info_raw.colortype = colortype;
  state.info_raw.bitdepth = bitdepth;
  state.info_png.color.colortype = colortype;
  state.info_png.color.bitdepth = bitdepth;
  lodepng_encode(out, outsize, image, w, h, &state);
  error = state.error;
  lodepng_state_cleanup(&state);
  return error;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
vmovaps 0x52b1(%rip), %ymm1     # 0x12280
movl 0x1d0(%rsp), %eax
leaq 0x9dbb(%rip), %r10      # 0x16d98
leaq 0x8(%rsp), %rbx
vxorps %xmm0, %xmm0, %xmm0
movl $0x1, %r11d
movabsq $0x100000001, %r14      # imm = 0x100000001
movq %r10, (%rbx)
xorl %r10d, %r10d
movl %r10d, 0x8(%rbx)
vmovups %xmm0, 0x10(%rbx)
vmovups %xmm0, 0x1c(%rbx)
vmovups %ymm1, 0x2c(%rbx)
movl %r11d, 0x4c(%rbx)
vmovups %xmm0, 0x50(%rbx)
movq %r10, 0x60(%rbx)
movl %r11d, 0x70(%rbx)
movq %r14, 0x68(%rbx)
vmovups %xmm0, 0x78(%rbx)
vxorps %xmm0, %xmm0, %xmm0
movl %r11d, 0x88(%rbx)
vmovups %ymm0, 0x98(%rbx)
vmovups %ymm0, 0xd0(%rbx)
movl %r10d, 0xc0(%rbx)
movq %r10, 0xb8(%rbx)
movl %r10d, 0x15c(%rbx)
vmovups %ymm0, 0x170(%rbx)
vmovups %ymm0, 0x180(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm0, 0x104(%rbx)
vmovups %zmm0, 0xf0(%rbx)
movl %r11d, 0x1a0(%rbx)
movl %r9d, 0x90(%rbx)
movl %eax, 0x94(%rbx)
movl %r9d, 0xc8(%rbx)
movq %rbx, %r9
movl %eax, 0xcc(%rbx)
vzeroupper
callq 0xad07
movl 0x1a0(%rbx), %ebp
movq %rbx, %rdi
callq 0xaac0
movl %ebp, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_encode_file(char const*, unsigned char const*, unsigned int, unsigned int, LodePNGColorType, unsigned int)
unsigned lodepng_encode_file(const char* filename, const unsigned char* image, unsigned w, unsigned h,
                             LodePNGColorType colortype, unsigned bitdepth)
{
  unsigned char* buffer;
  size_t buffersize;
  unsigned error = lodepng_encode_memory(&buffer, &buffersize, image, w, h, colortype, bitdepth);
  if(!error) error = lodepng_save_file(buffer, buffersize, filename);
  lodepng_free(buffer);
  return error;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %r8d, %eax
movl %ecx, %r8d
movl %edx, %ecx
movq %rsi, %rdx
leaq 0x18(%rsp), %r14
leaq 0x10(%rsp), %rsi
movq %rdi, %rbx
movl %r9d, (%rsp)
movl %eax, %r9d
movq %r14, %rdi
callq 0xcfbc
movq (%r14), %r14
movl %eax, %ebp
testl %eax, %eax
jne 0xd13d
movq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x41ac
movl %eax, %ebp
movq %r14, %rdi
callq 0x21b0
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::load_file(std::vector<unsigned char, std::allocator<unsigned char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
unsigned load_file(std::vector<unsigned char>& buffer, const std::string& filename)
{
  long size = lodepng_filesize(filename.c_str());
  if(size < 0) return 78;
  buffer.resize((size_t)size);
  return size == 0 ? 0 : lodepng_buffer_file(&buffer[0], (size_t)size, filename.c_str());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rsi), %rdi
movq %rsi, %rbx
callq 0x40e4
testq %rax, %rax
js 0xd1ce
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x10096
testq %r15, %r15
je 0xd1d5
movq (%r14), %rdi
movq (%rbx), %rdx
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4152
movl $0x4e, %eax
jmp 0xd1d7
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::decompress(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char const*, unsigned long, LodePNGDecompressSettings const&)
unsigned decompress(std::vector<unsigned char>& out, const unsigned char* in, size_t insize,
                    const LodePNGDecompressSettings& settings)
{
  unsigned char* buffer = 0;
  size_t buffersize = 0;
  unsigned error = zlib_decompress(&buffer, &buffersize, in, insize, &settings);
  if(buffer)
  {
    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
    lodepng_free(buffer);
  }
  return error;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x8(%r8), %rax
testq %rax, %rax
je 0xd22d
callq *%rax
jmp 0xd232
callq 0x6e34
movq 0x8(%rsp), %rdx
movl %eax, %ebp
testq %rdx, %rdx
je 0xd25c
movq 0x10(%rsp), %rcx
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
addq %rdx, %rcx
callq 0x101c4
movq 0x8(%rsp), %rdi
callq 0x21b0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::compress(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char const*, unsigned long, LodePNGCompressSettings const&)
unsigned compress(std::vector<unsigned char>& out, const unsigned char* in, size_t insize,
                  const LodePNGCompressSettings& settings)
{
  unsigned char* buffer = 0;
  size_t buffersize = 0;
  unsigned error = zlib_compress(&buffer, &buffersize, in, insize, &settings);
  if(buffer)
  {
    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
    lodepng_free(buffer);
  }
  return error;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x18(%r8), %rax
testq %rax, %rax
je 0xd2c1
callq *%rax
jmp 0xd2c6
callq 0x6f8b
movq 0x8(%rsp), %rdx
movl %eax, %ebp
testq %rdx, %rdx
je 0xd2f0
movq 0x10(%rsp), %rcx
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
addq %rdx, %rcx
callq 0x101c4
movq 0x8(%rsp), %rdi
callq 0x21b0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::decode(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int&, unsigned int&, unsigned char const*, unsigned long, LodePNGColorType, unsigned int)
unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h, const unsigned char* in,
                size_t insize, LodePNGColorType colortype, unsigned bitdepth)
{
  unsigned char* buffer;
  unsigned error = lodepng_decode_memory(&buffer, &w, &h, in, insize, colortype, bitdepth);
  if(buffer && !error)
  {
    State state;
    state.info_raw.colortype = colortype;
    state.info_raw.bitdepth = bitdepth;
    size_t buffersize = lodepng_get_raw_size(w, h, &state.info_raw);
    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
    lodepng_free(buffer);
  }
  return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movl 0x1f0(%rsp), %eax
leaq 0x8(%rsp), %r15
movq %rdi, %r14
movl %r9d, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %r15, %rdi
movl %eax, (%rsp)
callq 0xa8ec
movq (%r15), %r15
movl %eax, %ebx
testq %r15, %r15
sete %al
testl %ebx, %ebx
setne %cl
orb %al, %cl
jne 0xd4d9
vmovaps 0x4ea4(%rip), %ymm1     # 0x12280
leaq 0x996d(%rip), %rax      # 0x16d50
leaq 0xa0(%rsp), %rdx
vxorps %xmm0, %xmm0, %xmm0
movl $0x1, %ecx
movabsq $0x100000001, %rsi      # imm = 0x100000001
movq %rax, -0x90(%rdx)
xorl %eax, %eax
movl %eax, -0x88(%rdx)
vmovups %xmm0, -0x80(%rdx)
vmovups %xmm0, -0x74(%rdx)
vmovups %ymm1, -0x64(%rdx)
movl %ecx, -0x44(%rdx)
vmovups %xmm0, -0x40(%rdx)
movq %rax, -0x30(%rdx)
movl %ecx, -0x20(%rdx)
movq %rsi, -0x28(%rdx)
vmovups %xmm0, -0x18(%rdx)
vxorps %xmm0, %xmm0, %xmm0
movabsq $0x800000006, %rsi      # imm = 0x800000006
movl %ecx, -0x8(%rdx)
vmovups %ymm0, 0x8(%rdx)
movq %rsi, 0x38(%rdx)
vmovups %ymm0, 0x40(%rdx)
movl %eax, 0x30(%rdx)
movq %rax, 0x28(%rdx)
movl %eax, 0xcc(%rdx)
vmovups %ymm0, 0xf0(%rdx)
vmovups %ymm0, 0xe0(%rdx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm0, 0x74(%rdx)
vmovups %zmm0, 0x60(%rdx)
movl %ecx, 0x110(%rdx)
movl 0x1f0(%rsp), %ecx
movl %ebp, (%rdx)
movl %ecx, 0x4(%rdx)
movl (%r13), %edi
movl (%r12), %esi
vzeroupper
callq 0x77be
movq 0x8(%r14), %rsi
leaq (%rax,%r15), %rcx
movq %r14, %rdi
movq %r15, %rdx
callq 0x101c4
movq %r15, %rdi
callq 0x21b0
leaq 0x10(%rsp), %rdi
leaq 0x987f(%rip), %rax      # 0x16d50
movq %rax, (%rdi)
callq 0xaac0
movl %ebx, %eax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %rdi
leaq 0x9857(%rip), %rcx      # 0x16d50
movq %rax, %rbx
movq %rcx, (%rdi)
callq 0xaac0
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::decode(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int&, unsigned int&, lodepng::State&, unsigned char const*, unsigned long)
unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h,
                State& state,
                const unsigned char* in, size_t insize)
{
  unsigned char* buffer = NULL;
  unsigned error = lodepng_decode(&buffer, &w, &h, &state, in, insize);
  if(buffer && !error)
  {
    size_t buffersize = lodepng_get_raw_size(w, h, &state.info_raw);
    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
  }
  lodepng_free(buffer);
  return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsp, %r15
movq %rdi, %rbx
movq %r15, %rdi
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq $0x0, (%r15)
callq 0x9aaa
movq (%r15), %r15
movl %eax, %ebp
testq %r15, %r15
sete %al
testl %ebp, %ebp
setne %cl
orb %al, %cl
jne 0xd598
movl (%r13), %edi
movl (%r12), %esi
addq $0x90, %r14
movq %r14, %rdx
callq 0x77be
movq 0x8(%rbx), %rsi
leaq (%rax,%r15), %rcx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x101c4
movq %r15, %rdi
callq 0x21b0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::decode(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int&, unsigned int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, LodePNGColorType, unsigned int)
unsigned decode(std::vector<unsigned char>& out, unsigned& w, unsigned& h, const std::string& filename,
                LodePNGColorType colortype, unsigned bitdepth)
{
  std::vector<unsigned char> buffer;
  unsigned error = load_file(buffer, filename);
  if(error) return error;
  return decode(out, w, h, buffer, colortype, bitdepth);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
leaq 0x10(%rsp), %rdi
vxorps %xmm0, %xmm0, %xmm0
movl %r9d, %ebp
movl %r8d, %ebx
movq %rdx, %r14
movq %rsi, %r15
vmovaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rcx, %rsi
callq 0xd190
movl %eax, %r13d
testl %eax, %eax
jne 0xd635
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %r8
xorl %ecx, %ecx
cmpq %r8, %rax
cmovneq %rax, %rcx
subl %eax, %r8d
movl %ebp, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %r9d
callq 0xd388
movl %eax, %r13d
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xd644
callq 0x2120
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0xd668
callq 0x2120
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::encode(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char const*, unsigned int, unsigned int, LodePNGColorType, unsigned int)
unsigned encode(std::vector<unsigned char>& out, const unsigned char* in, unsigned w, unsigned h,
                LodePNGColorType colortype, unsigned bitdepth)
{
  unsigned char* buffer;
  size_t buffersize;
  unsigned error = lodepng_encode_memory(&buffer, &buffersize, in, w, h, colortype, bitdepth);
  if(buffer)
  {
    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
    lodepng_free(buffer);
  }
  return error;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %r8d, %eax
movl %ecx, %r8d
movl %edx, %ecx
movq %rsi, %rdx
leaq 0x18(%rsp), %r14
leaq 0x10(%rsp), %rsi
movq %rdi, %rbx
movl %r9d, (%rsp)
movl %eax, %r9d
movq %r14, %rdi
callq 0xcfbc
movq (%r14), %r14
movl %eax, %ebp
testq %r14, %r14
je 0xd6c8
movq 0x10(%rsp), %rcx
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
addq %r14, %rcx
callq 0x101c4
movq %r14, %rdi
callq 0x21b0
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::encode(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char const*, unsigned int, unsigned int, lodepng::State&)
unsigned encode(std::vector<unsigned char>& out,
                const unsigned char* in, unsigned w, unsigned h,
                State& state)
{
  unsigned char* buffer;
  size_t buffersize;
  unsigned error = lodepng_encode(&buffer, &buffersize, in, w, h, &state);
  if(buffer)
  {
    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
    lodepng_free(buffer);
  }
  return error;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %r14
movq %r8, %r9
movl %ecx, %r8d
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %rbx
movq %rsp, %rsi
movq %r14, %rdi
callq 0xad07
movq (%r14), %r14
movl %eax, %ebp
testq %r14, %r14
je 0xd79f
movq (%rsp), %rcx
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
addq %r14, %rcx
callq 0x101c4
movq %r14, %rdi
callq 0x21b0
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng::encode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned char const*, unsigned int, unsigned int, LodePNGColorType, unsigned int)
unsigned encode(const std::string& filename,
                const unsigned char* in, unsigned w, unsigned h,
                LodePNGColorType colortype, unsigned bitdepth)
{
  std::vector<unsigned char> buffer;
  unsigned error = encode(buffer, in, w, h, colortype, bitdepth);
  if(!error) error = save_file(buffer, filename);
  return error;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
vxorps %xmm0, %xmm0, %xmm0
movq %rdi, %rbx
movq %rsp, %rdi
movq $0x0, 0x10(%rdi)
vmovaps %xmm0, (%rdi)
callq 0xd670
movl %eax, %ebp
testl %eax, %eax
jne 0xd857
movq (%rsp), %rax
movq 0x8(%rsp), %rsi
movq (%rbx), %rdx
xorl %edi, %edi
subq %rax, %rsi
cmovneq %rax, %rdi
callq 0x41ac
movl %eax, %ebp
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xd865
callq 0x2120
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq (%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0xd87f
callq 0x2120
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: ucvector_reserve(ucvector*, unsigned long)
static unsigned ucvector_reserve(ucvector* p, size_t allocsize)
{
  if(allocsize > p->allocsize)
  {
    size_t newsize = (allocsize > p->allocsize * 2) ? allocsize : (allocsize * 3 / 2);
    void* data = lodepng_realloc(p->data, newsize);
    if(data)
    {
      p->allocsize = newsize;
      p->data = (unsigned char*)data;
    }
    else return 0; /*error: not enough memory*/
  }
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rax
movl $0x1, %ebx
cmpq %rsi, %rax
jae 0xd947
movq %rdi, %r14
movq (%rdi), %rdi
leaq (%rsi,%rsi,2), %r15
addq %rax, %rax
shrq %r15
cmpq %rsi, %rax
cmovbq %rsi, %r15
movq %r15, %rsi
callq 0x2260
testq %rax, %rax
je 0xd945
movq %r15, 0x10(%r14)
movq %rax, (%r14)
jmp 0xd947
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq