LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: LodePNGText_cleanup(LodePNGInfo*)
static void LodePNGText_cleanup(LodePNGInfo* info)
{
  size_t i;
  for(i = 0; i != info->text_num; ++i)
  {
    string_cleanup(&info->text_keys[i]);
    string_cleanup(&info->text_strings[i]);
  }
  lodepng_free(info->text_keys);
  lodepng_free(info->text_strings);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x7865
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x50(%rbx), %r12
movq (%r12,%r15,8), %rdi
callq 0x21b0
movq %r14, (%r12,%r15,8)
movq 0x58(%rbx), %r12
movq (%r12,%r15,8), %rdi
callq 0x21b0
movq %r14, (%r12,%r15,8)
incq %r15
cmpq 0x48(%rbx), %r15
jne 0x783a
movq 0x50(%rbx), %rdi
callq 0x21b0
movq 0x58(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_add_text(LodePNGInfo*, char const*, char const*)
unsigned lodepng_add_text(LodePNGInfo* info, const char* key, const char* str)
{
  char** new_keys = (char**)(lodepng_realloc(info->text_keys, sizeof(char*) * (info->text_num + 1)));
  char** new_strings = (char**)(lodepng_realloc(info->text_strings, sizeof(char*) * (info->text_num + 1)));
  if(!new_keys || !new_strings)
  {
    lodepng_free(new_keys);
    lodepng_free(new_strings);
    return 83; /*alloc fail*/
  }

  ++info->text_num;
  info->text_keys = new_keys;
  info->text_strings = new_strings;

  string_init(&info->text_keys[info->text_num - 1]);
  string_set(&info->text_keys[info->text_num - 1], key);

  string_init(&info->text_strings[info->text_num - 1]);
  string_set(&info->text_strings[info->text_num - 1], str);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x2260
movq %rax, %r12
movq 0x48(%r14), %rax
movq 0x58(%r14), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x2260
movq %rax, %r13
testq %r12, %r12
setne %al
testq %r13, %r13
setne %cl
testb %cl, %al
je 0x795b
movq %rbx, (%rsp)
movq 0x48(%r14), %rbx
leaq 0x1(%rbx), %rbp
movq %rbp, 0x48(%r14)
movq %r12, 0x50(%r14)
movq %r13, 0x58(%r14)
movq $0x0, (%r12,%rbx,8)
movl $0x1, %edi
callq 0x21e0
testq %rax, %rax
je 0x7910
movb $0x0, (%rax)
movq %rax, (%r12,%rbx,8)
leaq -0x8(%r12,%rbp,8), %rdi
movq %r15, %rsi
callq 0x797f
movq 0x48(%r14), %rbx
movq 0x58(%r14), %r15
movq $0x0, -0x8(%r15,%rbx,8)
movl $0x1, %edi
callq 0x21e0
testq %rax, %rax
je 0x7945
movb $0x0, (%rax)
movq %rax, -0x8(%r15,%rbx,8)
movq 0x58(%r14), %rax
leaq -0x8(%rax,%rbx,8), %rdi
movq (%rsp), %rsi
callq 0x797f
xorl %eax, %eax
jmp 0x7970
movq %r12, %rdi
callq 0x21b0
movq %r13, %rdi
callq 0x21b0
movl $0x53, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: string_set(char**, char const*)
static void string_set(char** out, const char* in)
{
  size_t insize = strlen(in), i;
  if(string_resize(out, insize))
  {
    for(i = 0; i != insize; ++i)
    {
      (*out)[i] = in[i];
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2090
movq %rax, %r15
movq (%r14), %rdi
leaq 0x1(%rax), %rsi
callq 0x2260
testq %rax, %rax
je 0x79c6
movb $0x0, (%rax,%r15)
movq %rax, (%r14)
testq %r15, %r15
je 0x79c6
xorl %eax, %eax
movb (%rbx,%rax), %cl
movq (%r14), %rdx
movb %cl, (%rdx,%rax)
incq %rax
cmpq %rax, %r15
jne 0x79b5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: LodePNGIText_cleanup(LodePNGInfo*)
static void LodePNGIText_cleanup(LodePNGInfo* info)
{
  size_t i;
  for(i = 0; i != info->itext_num; ++i)
  {
    string_cleanup(&info->itext_keys[i]);
    string_cleanup(&info->itext_langtags[i]);
    string_cleanup(&info->itext_transkeys[i]);
    string_cleanup(&info->itext_strings[i]);
  }
  lodepng_free(info->itext_keys);
  lodepng_free(info->itext_langtags);
  lodepng_free(info->itext_transkeys);
  lodepng_free(info->itext_strings);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
je 0x7a36
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x68(%rbx), %r12
movq (%r12,%r15,8), %rdi
callq 0x21b0
movq %r14, (%r12,%r15,8)
movq 0x70(%rbx), %r12
movq (%r12,%r15,8), %rdi
callq 0x21b0
movq %r14, (%r12,%r15,8)
movq 0x78(%rbx), %r12
movq (%r12,%r15,8), %rdi
callq 0x21b0
movq %r14, (%r12,%r15,8)
movq 0x80(%rbx), %r12
movq (%r12,%r15,8), %rdi
callq 0x21b0
movq %r14, (%r12,%r15,8)
incq %r15
cmpq 0x60(%rbx), %r15
jne 0x79e6
movq 0x68(%rbx), %rdi
callq 0x21b0
movq 0x70(%rbx), %rdi
callq 0x21b0
movq 0x78(%rbx), %rdi
callq 0x21b0
movq 0x80(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_info_cleanup(LodePNGInfo*)
void lodepng_info_cleanup(LodePNGInfo* info)
{
  lodepng_color_mode_cleanup(&info->color);
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  LodePNGText_cleanup(info);
  LodePNGIText_cleanup(info);

  LodePNGUnknownChunks_cleanup(info);
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x7ccd
callq 0x21b0
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%r14)
movq %rbx, %rdi
callq 0x7822
movq %rbx, %rdi
callq 0x79ce
xorl %r14d, %r14d
movq 0xb8(%rbx,%r14,8), %rdi
callq 0x21b0
incq %r14
cmpq $0x3, %r14
jne 0x7ce9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7cb4
vmovups (%rbx), %zmm0
vmovups 0x40(%rbx), %zmm1
vmovups 0x80(%rbx), %zmm2
vmovups 0xa8(%rbx), %zmm3
vmovups %zmm0, (%r14)
vmovups %zmm3, 0xa8(%r14)
vmovups %zmm2, 0x80(%r14)
vmovups %zmm1, 0x40(%r14)
leaq 0x10(%r14), %rdi
movabsq $0x800000006, %rax      # imm = 0x800000006
movq %rax, 0x10(%r14)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x18(%r14)
leaq 0x10(%rbx), %rsi
vzeroupper
callq 0x75ee
movl %eax, %ebp
testl %eax, %eax
jne 0x7ef9
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x48(%r14)
movq $0x0, 0x58(%r14)
cmpq $0x0, 0x48(%rbx)
je 0x7dd0
xorl %r12d, %r12d
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rcx
movq (%rax,%r12,8), %rsi
movq (%rcx,%r12,8), %rdx
movq %r14, %rdi
callq 0x7882
testl %eax, %eax
cmovnel %eax, %r15d
jne 0x7dd3
incq %r12
cmpq 0x48(%rbx), %r12
jne 0x7da7
xorl %r15d, %r15d
testl %r15d, %r15d
cmovnel %r15d, %ebp
jne 0x7ef9
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x60(%r14)
movq $0x0, 0x80(%r14)
cmpq $0x0, 0x60(%rbx)
je 0x7e3e
xorl %r12d, %r12d
movq 0x68(%rbx), %rax
movq 0x70(%rbx), %rcx
movq (%rax,%r12,8), %rsi
movq (%rcx,%r12,8), %rdx
movq 0x78(%rbx), %rax
movq (%rax,%r12,8), %rcx
movq 0x80(%rbx), %rax
movq (%rax,%r12,8), %r8
movq %r14, %rdi
vzeroupper
callq 0x7a68
testl %eax, %eax
cmovnel %eax, %r15d
jne 0x7e41
incq %r12
cmpq 0x60(%rbx), %r12
jne 0x7dff
xorl %r15d, %r15d
testl %r15d, %r15d
cmovnel %r15d, %ebp
jne 0x7ef9
leaq 0xb8(%r14), %r12
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0xc8(%r14)
vmovups %ymm0, 0xb8(%r14)
xorl %r15d, %r15d
movq (%r12,%r15,8), %rdi
vzeroupper
callq 0x21b0
incq %r15
cmpq $0x3, %r15
jne 0x7e6e
xorl %r13d, %r13d
movq 0xd0(%rbx,%r13,8), %rbp
movq %rbp, 0xd0(%r14,%r13,8)
movq 0xd0(%rbx,%r13,8), %r15
movq %r15, %rdi
callq 0x21e0
movq %rax, 0xb8(%r14,%r13,8)
testq %rax, %rax
setne %al
testq %rbp, %rbp
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x7ef4
testq %r15, %r15
je 0x7ee7
xorl %eax, %eax
movq 0xb8(%rbx,%r13,8), %rcx
movb (%rcx,%rax), %cl
movq (%r12,%r13,8), %rdx
movb %cl, (%rdx,%rax)
incq %rax
cmpq 0xd0(%rbx,%r13,8), %rax
jb 0x7ec8
incq %r13
xorl %ebp, %ebp
cmpq $0x3, %r13
jne 0x7e86
jmp 0x7ef9
movl $0x53, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8502
movl 0x4(%rdi), %ecx
cmpl 0x4(%rsi), %ecx
jne 0x8502
movl 0x18(%rdi), %ecx
cmpl 0x18(%rsi), %ecx
jne 0x8502
testl %ecx, %ecx
je 0x84ca
movl 0x1c(%rdi), %ecx
cmpl 0x1c(%rsi), %ecx
jne 0x8502
movl 0x20(%rdi), %ecx
cmpl 0x20(%rsi), %ecx
jne 0x8502
movl 0x24(%rdi), %ecx
cmpl 0x24(%rsi), %ecx
jne 0x8502
movq 0x10(%rdi), %rcx
cmpq 0x10(%rsi), %rcx
jne 0x8502
shlq $0x2, %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0x8502
movq 0x8(%rdi), %rdx
movq 0x8(%rsi), %rsi
xorl %edi, %edi
movb (%rdx,%rdi), %r8b
cmpb (%rsi,%rdi), %r8b
jne 0x8500
incq %rdi
cmpq %rdi, %rcx
jne 0x84ec
jmp 0x8502
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r13d
movl %esi, %r14d
movq %rdi, %r12
xorl %ebx, %ebx
movl %r8d, 0x4(%rsp)
shrxl %ebx, %r14d, %eax
andl $0x1, %eax
shrxl %ebx, %r13d, %edi
andl $0x1, %edi
shrxl %ebx, %r15d, %r9d
shrxl %ebx, %r8d, %r10d
andl $0x1, %r10d
leal (%r10,%rdi,4), %edi
andl $0x1, %r9d
leal (%rdi,%rax,8), %eax
leal (%rax,%r9,2), %ebp
cmpq $0x0, (%r12,%rbp,8)
jne 0x858a
movl $0x88, %edi
vzeroupper
callq 0x21e0
movl 0x4(%rsp), %r8d
movq %rax, (%r12,%rbp,8)
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm0, (%rax)
vmovups %zmm0, 0x40(%rax)
movl $0xffffffff, 0x80(%rax) # imm = 0xFFFFFFFF
movq (%r12,%rbp,8), %r12
incl %ebx
cmpl $0x8, %ebx
jne 0x8525
movl (%rsp), %eax
movl %eax, 0x80(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x86ec
leaq 0x8fb0(%rip), %r11      # 0x1157c
movslq (%r11,%r10,4), %r10
addq %r11, %r10
jmpq *%r10
movzbl (%r8,%r9,2), %r10d
shll $0x8, %r10d
movzbl 0x1(%r8,%r9,2), %r11d
orl %r10d, %r11d
movw %r11w, (%rdx)
movw %r11w, (%rsi)
movw %r11w, (%rdi)
cmpl $0x0, 0x18(%rax)
je 0x86bb
leaq 0x1(%r9,%r9), %rdx
addq %r9, %r9
movzbl (%r8,%r9), %esi
shll $0x8, %esi
movzbl (%r8,%rdx), %edx
orl %esi, %edx
cmpl 0x1c(%rax), %edx
jne 0x86bb
xorl %eax, %eax
jmp 0x86e9
movzwl (%r8,%r9,4), %eax
movbew %ax, (%rdx)
movbew %ax, (%rsi)
movbew %ax, (%rdi)
movbew 0x2(%r8,%r9,4), %ax
jmp 0x86e9
addq %r9, %r9
leaq (%r9,%r9,2), %r10
movzbl (%r8,%r10), %r11d
shll $0x8, %r11d
movzbl 0x1(%r8,%r10), %ebx
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 0x86bb
leaq 0x1(%r9,%r9,2), %rdx
movzbl (%r8,%r10), %esi
shll $0x8, %esi
movzbl (%r8,%rdx), %edx
orl %esi, %edx
cmpl 0x1c(%rax), %edx
jne 0x86bb
movbew 0x2(%r8,%r10), %dx
movzwl %dx, %edx
cmpl 0x20(%rax), %edx
jne 0x86bb
movbew 0x4(%r8,%r10), %dx
movzwl %dx, %edx
cmpl 0x24(%rax), %edx
je 0x861e
movw $0xffff, %ax            # imm = 0xFFFF
jmp 0x86e9
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_O1/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 0x8e65
callq 0x8e44
movq (%rbx,%r14,8), %rdi
callq 0x21b0
incq %r14
cmpq $0x10, %r14
jne 0x8e4e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9bb8
movl %edi, %ecx
leaq 0x7a5f(%rip), %rdx      # 0x115d0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
addl $-0x8, %esi
andl $-0x9, %esi
movl $0x25, %eax
cmovel %esi, %eax
retq
movl $0x25, %eax
cmpl $0x10, %esi
ja 0x9bb8
movl $0x10116, %ecx          # imm = 0x10116
btl %esi, %ecx
jae 0x9bb8
xorl %eax, %eax
retq
decl %esi
movl $0x25, %eax
cmpl $0x8, %esi
jae 0x9bb8
movl %esi, %eax
leaq 0x868b(%rip), %rcx      # 0x12240
movl (%rcx,%rax,4), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %r8, %rax
movq %rcx, %r8
movl 0x1d0(%rsp), %ecx
leaq 0xc44e(%rip), %r10      # 0x16d98
leaq 0x8(%rsp), %rbx
movq %r10, (%rbx)
xorl %r10d, %r10d
movl %r10d, 0x8(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x10(%rbx)
vmovups %xmm0, 0x1c(%rbx)
vmovaps 0x78b1(%rip), %ymm1     # 0x12220
vmovups %ymm1, 0x2c(%rbx)
movl $0x1, %r11d
movl %r11d, 0x4c(%rbx)
vmovups %xmm0, 0x50(%rbx)
movq %r10, 0x60(%rbx)
movl %r11d, 0x70(%rbx)
movabsq $0x100000001, %r14      # imm = 0x100000001
movq %r14, 0x68(%rbx)
vmovups %xmm0, 0x78(%rbx)
movl %r11d, 0x88(%rbx)
movabsq $0x800000006, %r14      # imm = 0x800000006
movq %r14, 0x90(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x98(%rbx)
movq %r14, 0xc8(%rbx)
vmovups %ymm0, 0xd0(%rbx)
movl %r10d, 0xc0(%rbx)
movq %r10, 0xb8(%rbx)
movl %r10d, 0x15c(%rbx)
vxorps %xmm1, %xmm1, %xmm1
vmovups %zmm1, 0x104(%rbx)
vmovups %zmm1, 0xf0(%rbx)
vmovups %ymm0, 0x180(%rbx)
vmovups %ymm0, 0x170(%rbx)
movl %r11d, 0x1a0(%rbx)
movl %r9d, 0x90(%rbx)
movl %ecx, 0x94(%rbx)
movq %rbx, %rcx
movq %rax, %r9
vzeroupper
callq 0x9bb9
movl %eax, %ebp
movq %rbx, %rdi
callq 0xab06
movl %ebp, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_state_init(LodePNGState*)
void lodepng_state_init(LodePNGState* state)
{
#ifdef LODEPNG_COMPILE_DECODER
  lodepng_decoder_settings_init(&state->decoder);
#endif /*LODEPNG_COMPILE_DECODER*/
#ifdef LODEPNG_COMPILE_ENCODER
  lodepng_encoder_settings_init(&state->encoder);
#endif /*LODEPNG_COMPILE_ENCODER*/
  lodepng_color_mode_init(&state->info_raw);
  lodepng_info_init(&state->info_png);
  state->error = 1;
}

// Assembly:
xorl %eax, %eax
movl %eax, 0x8(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x10(%rdi)
vmovups %xmm0, 0x1c(%rdi)
vmovaps 0x77bd(%rip), %ymm1     # 0x12220
vmovups %ymm1, 0x2c(%rdi)
movl $0x1, %ecx
movl %ecx, 0x4c(%rdi)
vmovups %xmm0, 0x50(%rdi)
movq %rax, 0x60(%rdi)
movl %ecx, 0x70(%rdi)
movabsq $0x100000001, %rdx      # imm = 0x100000001
movq %rdx, 0x68(%rdi)
vmovups %xmm0, 0x78(%rdi)
movl %ecx, 0x88(%rdi)
movabsq $0x800000006, %rdx      # imm = 0x800000006
movq %rdx, 0x90(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x98(%rdi)
movq %rdx, 0xc8(%rdi)
vmovups %ymm0, 0xd0(%rdi)
movl %eax, 0xc0(%rdi)
movq %rax, 0xb8(%rdi)
movl %eax, 0x15c(%rdi)
vxorps %xmm1, %xmm1, %xmm1
vmovups %zmm1, 0x104(%rdi)
vmovups %zmm1, 0xf0(%rdi)
vmovups %ymm0, 0x180(%rdi)
vmovups %ymm0, 0x170(%rdi)
movl %ecx, 0x1a0(%rdi)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x18, %rsp
movl %r9d, %ebp
movl %r8d, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
leaq 0x10(%rsp), %rsi
movq %rcx, %rdx
callq 0x40a9
movl %eax, %r13d
testl %eax, %eax
jne 0xabcc
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movl %ebp, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %r9d
callq 0xa92b
movl %eax, %r13d
movq 0x8(%rsp), %rdi
callq 0x21b0
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_decoder_settings_init(LodePNGDecoderSettings*)
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:
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x24(%rdi)
xorl %eax, %eax
movl %eax, 0x2c(%rdi)
movl %eax, (%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x8(%rdi)
vmovups %xmm0, 0x14(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x765a(%rip), %xmm0     # 0x12290
vmovups %xmm0, (%rdi)
movabsq $0x100000080, %rax      # imm = 0x100000080
movq %rax, 0x10(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x18(%rdi)
movq $0x0, 0x28(%rdi)
movl $0x1, %eax
movl %eax, 0x38(%rdi)
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x30(%rdi)
vmovups %xmm0, 0x40(%rdi)
movl %eax, 0x50(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xab06
leaq 0x8(%rbx), %rdi
leaq 0x8(%r14), %rsi
movl $0x19c, %edx            # imm = 0x19C
callq 0x2100
movl $0x90, %esi
leaq (%rbx,%rsi), %rdi
movabsq $0x800000006, %rax      # imm = 0x800000006
movq %rax, 0x90(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x98(%rbx)
movq %rax, 0xc8(%rbx)
vmovups %ymm0, 0xd0(%rbx)
xorl %eax, %eax
movl %eax, 0xc0(%rbx)
movq $0x0, 0xb8(%rbx)
movl %eax, 0x15c(%rbx)
vxorps %xmm1, %xmm1, %xmm1
vmovups %zmm1, 0xf0(%rbx)
vmovups %zmm1, 0x104(%rbx)
vmovups %ymm0, 0x170(%rbx)
vmovups %ymm0, 0x180(%rbx)
addq %r14, %rsi
vzeroupper
callq 0x75ee
movl %eax, 0x1a0(%rbx)
testl %eax, %eax
jne 0xad40
leaq 0xb8(%rbx), %rdi
addq $0xb8, %r14
movq %r14, %rsi
callq 0x7d07
movl %eax, 0x1a0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
movq 0x8(%rdi), %r14
incq %r14
movq %r14, %rsi
callq 0xd9d0
testl %eax, %eax
je 0xb94f
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movb $-0x77, -0x1(%rax,%r14)
movq 0x8(%rbx), %r14
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd9d0
testl %eax, %eax
je 0xb972
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movb $0x50, -0x1(%rax,%r14)
movq 0x8(%rbx), %r14
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd9d0
testl %eax, %eax
je 0xb995
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movb $0x4e, -0x1(%rax,%r14)
movq 0x8(%rbx), %r14
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd9d0
testl %eax, %eax
je 0xb9b8
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movb $0x47, -0x1(%rax,%r14)
movq 0x8(%rbx), %r14
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd9d0
testl %eax, %eax
je 0xb9db
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movb $0xd, -0x1(%rax,%r14)
movq 0x8(%rbx), %r14
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd9d0
testl %eax, %eax
je 0xb9fe
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movb $0xa, -0x1(%rax,%r14)
movq 0x8(%rbx), %r14
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd9d0
testl %eax, %eax
je 0xba21
movq %r14, 0x8(%rbx)
movq (%rbx), %rax
movb $0x1a, -0x1(%rax,%r14)
movq 0x8(%rbx), %r14
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd9d0
testl %eax, %eax
je 0xba44
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_O1/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:
xorl %eax, %eax
testq %rdx, %rdx
je 0xbcc8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rdi), %r13
movq %rsi, %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x740c
testl %eax, %eax
cmovnel %eax, %ebx
jne 0xbcb8
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 0xbc7f
xorl %eax, %eax
jmp 0xbcba
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_O1/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 %rdi, %rbx
movq 0x10(%rsi), %rax
shlq $0x2, %rax
testq %rax, %rax
je 0xbd89
movq %rsi, %r15
movq %rbx, 0x8(%rsp)
xorl %ebp, %ebp
xorl %r13d, %r13d
xorl %edx, %edx
xorl %r8d, %r8d
movl %ebp, %eax
notl %eax
testb $0x3, %al
je 0xbd6e
movq 0x8(%r15), %rax
movb (%rax,%rbp), %r14b
leaq 0x1(%rdx), %r12
cmpq %r12, %r13
jae 0xbd50
movq %rdx, (%rsp)
leaq (%r13,%r13), %rax
movq %r13, 0x10(%rsp)
leaq (%r12,%r12,2), %r13
shrq %r13
cmpq %r12, %rax
cmovbq %r12, %r13
movq %r8, %rdi
movq %r13, %rsi
movq %r8, %rbx
callq 0x2260
testq %rax, %rax
je 0xbd54
xorl %ecx, %ecx
movq %rax, %r8
movq (%rsp), %rdx
jmp 0xbd62
xorl %ecx, %ecx
jmp 0xbd62
movb $0x1, %cl
movq %rbx, %r8
movq (%rsp), %rdx
movq 0x10(%rsp), %r13
testb %cl, %cl
jne 0xbd6e
movb %r14b, -0x1(%r8,%r12)
movq %r12, %rdx
incq %rbp
movq 0x10(%r15), %rax
shlq $0x2, %rax
cmpq %rax, %rbp
jne 0xbcfd
movq 0x8(%rsp), %rbx
jmp 0xbd8e
xorl %r8d, %r8d
xorl %edx, %edx
leaq 0x8(%rbx), %rsi
leaq 0x7464(%rip), %rcx      # 0x131fd
movq %rbx, %rdi
movq %r8, %r14
callq 0x74cd
testl %eax, %eax
jne 0xbdb0
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_O1/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 0xbe5f
pushq %rbx
xorl %ecx, %ecx
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r10d, %r10d
xorl %r9d, %r9d
testl %r10d, %r10d
jne 0xbdea
cmpb $0x0, 0x3(%rdi,%r9,4)
je 0xbe30
movl $0x2, %eax
cmpb $-0x1, 0x3(%rdi,%r9,4)
jne 0xbe5d
testl %r10d, %r10d
je 0xbe2b
leaq (,%r9,4), %r11
movzbl (%rdi,%r11), %ebx
movl $0x1, %r10d
cmpl %ebx, %r8d
jne 0xbe52
movzbl 0x1(%rdi,%r11), %ebx
cmpl %ebx, %edx
jne 0xbe52
movzbl 0x2(%rdi,%r11), %r11d
cmpl %r11d, %ecx
jne 0xbe52
jmp 0xbe5d
xorl %r10d, %r10d
jmp 0xbe52
shlq $0x2, %r9
movzbl (%rdi,%r9), %r8d
movzbl 0x1(%rdi,%r9), %edx
movzbl 0x2(%rdi,%r9), %ecx
movl $0x1, %r10d
movq $-0x1, %r9
incq %r9
movl %r10d, %eax
cmpq %rsi, %r9
jne 0xbddd
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
vxorps %xmm0, %xmm0, %xmm0
movq %rsp, %r15
vmovaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movl 0xa8(%rsi), %esi
movq %r15, %rdi
callq 0x7201
movl 0xac(%r14), %esi
movq %r15, %rdi
callq 0x7201
movb 0xb0(%r14), %bpl
movq 0x8(%r15), %r12
movq 0x10(%r15), %rax
incq %r12
cmpq %r12, %rax
jae 0xc50e
addq %rax, %rax
leaq (%r12,%r12,2), %r14
shrq %r14
cmpq %r12, %rax
cmovbq %r12, %r14
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x2260
testq %rax, %rax
je 0xc51c
movq %r14, 0x10(%rsp)
movq %rax, (%rsp)
movq %r12, 0x8(%rsp)
movq (%rsp), %rax
movb %bpl, -0x1(%rax,%r12)
leaq 0x8(%rsp), %r15
movq -0x8(%r15), %r14
movl (%r15), %edx
leaq 0x8(%rbx), %rsi
leaq 0x6ced(%rip), %rcx      # 0x13220
movq %rbx, %rdi
movq %r14, %r8
callq 0x74cd
testl %eax, %eax
jne 0xc54a
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%r15)
movq %r14, %rdi
callq 0x21b0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r14
vxorps %xmm0, %xmm0, %xmm0
leaq 0x8(%rsp), %rbx
vmovaps %xmm0, -0x8(%rbx)
movq $0x0, 0x8(%rbx)
movq 0x18(%r8), %rax
movq %rsp, %rdi
movq %rbx, %rsi
testq %rax, %rax
je 0xc5a5
callq *%rax
jmp 0xc5aa
callq 0x6f94
movl %eax, %ebp
testl %eax, %eax
jne 0xc5db
movq (%rsp), %r8
movl 0x8(%rsp), %edx
leaq 0x8(%r14), %rsi
leaq 0x6c30(%rip), %rcx      # 0x131f3
movq %r14, %rdi
callq 0x74cd
movl %eax, %ebp
testl %eax, %eax
jne 0xc5db
movq 0x8(%r14), %rax
movq %rax, 0x10(%r14)
xorl %ebp, %ebp
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_O1/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 %rsi, %r14
movq %rdi, %rbx
movl $0x7, %edi
callq 0x21e0
testq %rax, %rax
je 0xc669
movq %rax, %rbp
vmovdqu (%r14), %xmm0
movl (%r14), %eax
movb %ah, (%rbp)
vpmovdb %xmm0, 0x1(%rbp)
movb 0x10(%r14), %al
movb %al, 0x5(%rbp)
movb 0x14(%r14), %al
movb %al, 0x6(%rbp)
leaq 0x8(%rbx), %rsi
leaq 0x6bda(%rip), %rcx      # 0x1321b
movq %rbx, %rdi
movl $0x7, %edx
movq %rbp, %r8
callq 0x74cd
testl %eax, %eax
jne 0xc65d
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_O1/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
movq %rdx, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movb (%rsi), %r12b
testb %r12b, %r12b
je 0xc9cb
movq $-0x1, %r15
xorl %r9d, %r9d
xorl %r14d, %r14d
xorl %r8d, %r8d
movq %rsi, 0x10(%rsp)
leaq 0x1(%r14), %r13
cmpq %r13, %r9
jae 0xc996
leaq (%r9,%r9), %rax
leaq (%r13,%r13,2), %rbp
shrq %rbp
cmpq %r13, %rax
cmovbq %r13, %rbp
movq %r8, %rdi
movq %r9, 0x8(%rsp)
movq %rbp, %rsi
movq %r8, %rbx
callq 0x2260
testq %rax, %rax
je 0xc99a
xorl %ecx, %ecx
movq %rax, %r8
movq %rbp, %r9
jmp 0xc9a4
xorl %ecx, %ecx
jmp 0xc9a9
movb $0x1, %cl
movq %rbx, %r8
movq 0x8(%rsp), %r9
movq 0x10(%rsp), %rsi
testb %cl, %cl
jne 0xc9b5
movb %r12b, -0x1(%r8,%r13)
movq %r13, %r14
movb 0x2(%rsi,%r15), %r12b
incq %r15
testb %r12b, %r12b
jne 0xc958
cmpq $0x4f, %r15
setae %al
jmp 0xc9d6
movb $0x1, %al
xorl %r8d, %r8d
xorl %r14d, %r14d
xorl %r9d, %r9d
testb %al, %al
movq 0x20(%rsp), %r12
je 0xc9ee
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1(%r14), %r15
cmpq %r15, %r9
jae 0xca29
leaq (%r9,%r9), %rax
leaq (%r15,%r15,2), %r13
shrq %r13
cmpq %r15, %rax
cmovbq %r15, %r13
movq %r8, %rdi
movq %r9, %rbp
movq %r13, %rsi
movq %r8, %rbx
callq 0x2260
testq %rax, %rax
je 0xca2d
xorl %ecx, %ecx
movq %rax, %r8
movq %r13, %r9
jmp 0xca35
xorl %ecx, %ecx
jmp 0xca35
movb $0x1, %cl
movq %rbx, %r8
movq %rbp, %r9
testb %cl, %cl
jne 0xca42
movb $0x0, -0x1(%r8,%r15)
movq %r15, %r14
movb (%r12), %bpl
testb %bpl, %bpl
je 0xcab1
incq %r12
leaq 0x1(%r14), %r15
cmpq %r15, %r9
jae 0xca8b
leaq (%r9,%r9), %rax
leaq (%r15,%r15,2), %r13
shrq %r13
cmpq %r15, %rax
cmovbq %r15, %r13
movq %r8, %rdi
movq %r9, 0x8(%rsp)
movq %r13, %rsi
movq %r8, %rbx
callq 0x2260
testq %rax, %rax
je 0xca8f
xorl %ecx, %ecx
movq %rax, %r8
movq %r13, %r9
jmp 0xca99
xorl %ecx, %ecx
jmp 0xca99
movb $0x1, %cl
movq %rbx, %r8
movq 0x8(%rsp), %r9
testb %cl, %cl
jne 0xcaa5
movb %bpl, -0x1(%r8,%r15)
movq %r15, %r14
movb (%r12), %bpl
incq %r12
testb %bpl, %bpl
jne 0xca4e
movq 0x18(%rsp), %rbx
leaq 0x8(%rbx), %rsi
leaq 0x674b(%rip), %rcx      # 0x1320c
movq %rbx, %rdi
movl %r14d, %edx
movq %r8, %r14
callq 0x74cd
testl %eax, %eax
jne 0xcadb
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rbx)
movq %r14, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/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
movl 0x1d0(%rsp), %eax
leaq 0x9d0d(%rip), %r10      # 0x16d98
leaq 0x8(%rsp), %rbx
movq %r10, (%rbx)
xorl %r10d, %r10d
movl %r10d, 0x8(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x10(%rbx)
vmovups %xmm0, 0x1c(%rbx)
vmovaps 0x5170(%rip), %ymm1     # 0x12220
vmovups %ymm1, 0x2c(%rbx)
movl $0x1, %r11d
movl %r11d, 0x4c(%rbx)
vmovups %xmm0, 0x50(%rbx)
movq %r10, 0x60(%rbx)
movl %r11d, 0x70(%rbx)
movabsq $0x100000001, %r14      # imm = 0x100000001
movq %r14, 0x68(%rbx)
vmovups %xmm0, 0x78(%rbx)
movl %r11d, 0x88(%rbx)
movabsq $0x800000006, %r14      # imm = 0x800000006
movq %r14, 0x90(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x98(%rbx)
movq %r14, 0xc8(%rbx)
vmovups %ymm0, 0xd0(%rbx)
movl %r10d, 0xc0(%rbx)
movq %r10, 0xb8(%rbx)
movl %r10d, 0x15c(%rbx)
vxorps %xmm1, %xmm1, %xmm1
vmovups %zmm1, 0x104(%rbx)
vmovups %zmm1, 0xf0(%rbx)
vmovups %ymm0, 0x180(%rbx)
vmovups %ymm0, 0x170(%rbx)
movl %r11d, 0x1a0(%rbx)
movl %r9d, 0x90(%rbx)
movl %eax, 0x94(%rbx)
movl %r9d, 0xc8(%rbx)
movl %eax, 0xcc(%rbx)
movq %rbx, %r9
vzeroupper
callq 0xad48
movl 0x1a0(%rbx), %ebp
movq %rbx, %rdi
callq 0xab06
movl %ebp, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x18, %rsp
movl %r8d, %eax
movl %ecx, %r8d
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %rbx
movl %r9d, (%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl %eax, %r9d
callq 0xd072
movl %eax, %ebp
testl %eax, %eax
jne 0xd205
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x41e4
movl %eax, %ebp
movq 0x8(%rsp), %rdi
callq 0x21b0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x411c
testq %rax, %rax
js 0xd296
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x10574
testq %r15, %r15
je 0xd29d
movq (%r14), %rdi
movq (%rbx), %rdx
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x418a
movl $0x4e, %eax
jmp 0xd29f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x8(%r8), %rax
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
testq %rax, %rax
je 0xd2f5
callq *%rax
jmp 0xd2fa
callq 0x6e3b
movl %eax, %ebp
movq 0x8(%rsp), %rdx
testq %rdx, %rdx
je 0xd324
movq 0x8(%rbx), %rsi
movq 0x10(%rsp), %rcx
addq %rdx, %rcx
movq %rbx, %rdi
callq 0x106b0
movq 0x8(%rsp), %rdi
callq 0x21b0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r9d, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movl 0x1f0(%rsp), %eax
movl %eax, (%rsp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xa92b
movl %eax, %ebx
movq (%r15), %r15
testq %r15, %r15
sete %al
testl %ebx, %ebx
setne %cl
orb %al, %cl
jne 0xd5a4
leaq 0x98ad(%rip), %rax      # 0x16d50
leaq 0xa0(%rsp), %rdx
movq %rax, -0x90(%rdx)
xorl %eax, %eax
movl %eax, -0x88(%rdx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, -0x80(%rdx)
vmovups %xmm0, -0x74(%rdx)
vmovaps 0x4d50(%rip), %ymm1     # 0x12220
vmovups %ymm1, -0x64(%rdx)
movl $0x1, %ecx
movl %ecx, -0x44(%rdx)
vmovups %xmm0, -0x40(%rdx)
movq %rax, -0x30(%rdx)
movl %ecx, -0x20(%rdx)
movabsq $0x100000001, %rsi      # imm = 0x100000001
movq %rsi, -0x28(%rdx)
vmovups %xmm0, -0x18(%rdx)
movl %ecx, -0x8(%rdx)
movabsq $0x800000006, %rsi      # imm = 0x800000006
movq %rsi, (%rdx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x8(%rdx)
movq %rsi, 0x38(%rdx)
vmovups %ymm0, 0x40(%rdx)
movl %eax, 0x30(%rdx)
movq %rax, 0x28(%rdx)
movl %eax, 0xcc(%rdx)
vxorps %xmm1, %xmm1, %xmm1
vmovups %zmm1, 0x74(%rdx)
vmovups %zmm1, 0x60(%rdx)
vmovups %ymm0, 0xf0(%rdx)
vmovups %ymm0, 0xe0(%rdx)
movl %ecx, 0x110(%rdx)
movl %ebp, (%rdx)
movl 0x1f0(%rsp), %eax
movl %eax, 0x4(%rdx)
movl (%r13), %edi
movl (%r12), %esi
vzeroupper
callq 0x77ae
movq 0x8(%r14), %rsi
leaq (%rax,%r15), %rcx
movq %r14, %rdi
movq %r15, %rdx
callq 0x106b0
movq %r15, %rdi
callq 0x21b0
leaq 0x10(%rsp), %rdi
leaq 0x97b4(%rip), %rax      # 0x16d50
movq %rax, (%rdi)
callq 0xab06
movl %ebx, %eax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
leaq 0x9789(%rip), %rax      # 0x16d50
movq %rax, (%rdi)
callq 0xab06
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/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 %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %rsp, %r15
movq $0x0, (%r15)
movq %r15, %rdi
callq 0x9bb9
movl %eax, %ebp
movq (%r15), %r15
testq %r15, %r15
sete %al
testl %ebp, %ebp
setne %cl
orb %al, %cl
jne 0xd663
movl (%r13), %edi
movl (%r12), %esi
addq $0x90, %r14
movq %r14, %rdx
callq 0x77ae
movq 0x8(%rbx), %rsi
leaq (%rax,%r15), %rcx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x106b0
movq %r15, %rdi
callq 0x21b0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq