LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_inflate(unsigned char**, unsigned long*, unsigned char const*, unsigned long, LodePNGDecompressSettings const*)
unsigned lodepng_inflate(unsigned char** out, size_t* outsize,
                         const unsigned char* in, size_t insize,
                         const LodePNGDecompressSettings* settings)
{
  unsigned error;
  ucvector v;
  ucvector_init_buffer(&v, *out, *outsize);
  error = lodepng_inflatev(&v, in, insize, settings);
  *out = v.data;
  *outsize = v.size;
  return error;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rsi
movq 0x38(%rsp), %rax
movq (%rax), %rdx
movq %rsp, %rdi
callq 0x7940
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq %rsp, %rdi
callq 0x7980
movl %eax, 0x1c(%rsp)
movq (%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movl 0x1c(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_inflatev(ucvector*, unsigned char const*, unsigned long, LodePNGDecompressSettings const*)
static unsigned lodepng_inflatev(ucvector* out,
                                 const unsigned char* in, size_t insize,
                                 const LodePNGDecompressSettings* settings)
{
  /*bit pointer in the "in" data, current byte is bp >> 3, current bit is bp & 0x7 (from lsb to msb of the byte)*/
  size_t bp = 0;
  unsigned BFINAL = 0;
  size_t pos = 0; /*byte position in the out buffer*/
  unsigned error = 0;

  (void)settings;

  while(!BFINAL)
  {
    unsigned BTYPE;
    if(bp + 2 >= insize * 8) return 52; /*error, bit pointer will jump past memory*/
    BFINAL = readBitFromStream(&bp, in);
    BTYPE = 1u * readBitFromStream(&bp, in);
    BTYPE += 2u * readBitFromStream(&bp, in);

    if(BTYPE == 3) return 20; /*error: invalid BTYPE*/
    else if(BTYPE == 0) error = inflateNoCompression(out, in, &bp, &pos, insize); /*no compression*/
    else error = inflateHuffmanBlock(out, in, &bp, &pos, insize, BTYPE); /*compression, BTYPE 01 or 10*/

    if(error) return error;
  }

  return error;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x0, 0x14(%rsp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x79cd
jmp 0x7ab1
movq 0x18(%rsp), %rax
addq $0x2, %rax
movq 0x28(%rsp), %rcx
shlq $0x3, %rcx
cmpq %rcx, %rax
jb 0x79f1
movl $0x34, 0x44(%rsp)
jmp 0x7ab9
movq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x11c80
movzbl %al, %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x11c80
movzbl %al, %eax
shll $0x0, %eax
movl %eax, (%rsp)
movq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x11c80
movzbl %al, %eax
shll %eax
addl (%rsp), %eax
movl %eax, (%rsp)
cmpl $0x3, (%rsp)
jne 0x7a49
movl $0x14, 0x44(%rsp)
jmp 0x7ab9
cmpl $0x0, (%rsp)
jne 0x7a73
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %r8
leaq 0x18(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0x11cd0
movl %eax, 0x4(%rsp)
jmp 0x7a99
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %r8
movl (%rsp), %r9d
leaq 0x18(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0x11e90
movl %eax, 0x4(%rsp)
jmp 0x7a9b
cmpl $0x0, 0x4(%rsp)
je 0x7aac
movl 0x4(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x7ab9
jmp 0x79ba
movl 0x4(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_compress_settings_init(LodePNGCompressSettings*)
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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x2, (%rax)
movq -0x8(%rsp), %rax
movl $0x1, 0x4(%rax)
movq -0x8(%rsp), %rax
movl $0x800, 0x8(%rax)       # imm = 0x800
movq -0x8(%rsp), %rax
movl $0x3, 0xc(%rax)
movq -0x8(%rsp), %rax
movl $0x80, 0x10(%rax)
movq -0x8(%rsp), %rax
movl $0x1, 0x14(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_decompress_settings_init(LodePNGDecompressSettings*)
void lodepng_decompress_settings_init(LodePNGDecompressSettings* settings)
{
  settings->ignore_adler32 = 0;

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

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
retq
nopl (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_crc32(unsigned char const*, unsigned long)
unsigned lodepng_crc32(const unsigned char* data, size_t length)
{
  unsigned r = 0xffffffffu;
  size_t i;
  for(i = 0; i < length; ++i)
  {
    r = lodepng_crc32_table[(r ^ data[i]) & 0xff] ^ (r >> 8);
  }
  return r ^ 0xffffffffu;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0xffffffff, -0x14(%rsp) # imm = 0xFFFFFFFF
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x843b
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
movq -0x20(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x19e25(%rip), %rax     # 0x22240
movl (%rax,%rcx,4), %eax
movl -0x14(%rsp), %ecx
shrl $0x8, %ecx
xorl %ecx, %eax
movl %eax, -0x14(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x83eb
movl -0x14(%rsp), %eax
xorl $-0x1, %eax
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_chunk_check_crc(unsigned char const*)
unsigned lodepng_chunk_check_crc(const unsigned char* chunk)
{
  unsigned length = lodepng_chunk_length(chunk);
  unsigned CRC = lodepng_read32bitInt(&chunk[length + 8]);
  /*the CRC is taken of the data and the 4 chunk type letters, not the length*/
  unsigned checksum = lodepng_crc32(&chunk[4], length + 4);
  if(CRC != checksum) return 1;
  else return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x8450
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
addl $0x8, %eax
movl %eax, %eax
addq %rax, %rdi
callq 0x6b40
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
addq $0x4, %rdi
movl 0x14(%rsp), %eax
addl $0x4, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x83d0
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
cmpl 0xc(%rsp), %eax
je 0x8642
movl $0x1, 0x24(%rsp)
jmp 0x864a
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_chunk_append(unsigned char**, unsigned long*, unsigned char const*)
unsigned lodepng_chunk_append(unsigned char** out, size_t* outlength, const unsigned char* chunk)
{
  unsigned i;
  unsigned total_chunk_length = lodepng_chunk_length(chunk) + 12;
  unsigned char *chunk_start, *new_buffer;
  size_t new_length = (*outlength) + total_chunk_length;
  if(new_length < total_chunk_length || new_length < (*outlength)) return 77; /*integer overflow happened*/

  new_buffer = (unsigned char*)lodepng_realloc(*out, new_length);
  if(!new_buffer) return 83; /*alloc fail*/
  (*out) = new_buffer;
  (*outlength) = new_length;
  chunk_start = &(*out)[new_length - total_chunk_length];

  for(i = 0; i != total_chunk_length; ++i) chunk_start[i] = chunk[i];

  return 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x8450
addl $0xc, %eax
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movl 0x20(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x20(%rsp), %ecx
cmpq %rcx, %rax
jb 0x87d5
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x87e2
movl $0x4d, 0x44(%rsp)
jmp 0x8880
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x8890
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x880b
movl $0x53, 0x44(%rsp)
jmp 0x8880
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movl 0x20(%rsp), %edx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
je 0x8878
movq 0x28(%rsp), %rax
movl 0x24(%rsp), %ecx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x8849
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_chunk_create(unsigned char**, unsigned long*, unsigned int, char const*, unsigned char const*)
unsigned lodepng_chunk_create(unsigned char** out, size_t* outlength, unsigned length,
                              const char* type, const unsigned char* data)
{
  unsigned i;
  unsigned char *chunk, *new_buffer;
  size_t new_length = (*outlength) + length + 12;
  if(new_length < length + 12 || new_length < (*outlength)) return 77; /*integer overflow happened*/
  new_buffer = (unsigned char*)lodepng_realloc(*out, new_length);
  if(!new_buffer) return 83; /*alloc fail*/
  (*out) = new_buffer;
  (*outlength) = new_length;
  chunk = &(*out)[(*outlength) - length - 12];

  /*1: length*/
  lodepng_set32bitInt(chunk, (unsigned)length);

  /*2: chunk name (4 letters)*/
  chunk[4] = (unsigned char)type[0];
  chunk[5] = (unsigned char)type[1];
  chunk[6] = (unsigned char)type[2];
  chunk[7] = (unsigned char)type[3];

  /*3: the data*/
  for(i = 0; i != length; ++i) chunk[8 + i] = data[i];

  /*4: CRC (of the chunkname characters and the data)*/
  lodepng_chunk_generate_crc(chunk);

  return 0;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movl 0x3c(%rsp), %ecx
addq %rcx, %rax
addq $0xc, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x3c(%rsp), %ecx
addl $0xc, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jb 0x8916
movq 0x8(%rsp), %rax
movq 0x40(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x8923
movl $0x4d, 0x54(%rsp)
jmp 0x8a27
movq 0x48(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x8890
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x894f
movl $0x53, 0x54(%rsp)
jmp 0x8a27
movq 0x10(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq 0x40(%rsp), %rcx
movq (%rcx), %rcx
movl 0x3c(%rsp), %edx
subq %rdx, %rcx
subq $0xc, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x86c0
movq 0x30(%rsp), %rax
movb (%rax), %cl
movq 0x18(%rsp), %rax
movb %cl, 0x4(%rax)
movq 0x30(%rsp), %rax
movb 0x1(%rax), %cl
movq 0x18(%rsp), %rax
movb %cl, 0x5(%rax)
movq 0x30(%rsp), %rax
movb 0x2(%rax), %cl
movq 0x18(%rsp), %rax
movb %cl, 0x6(%rax)
movq 0x30(%rsp), %rax
movb 0x3(%rax), %cl
movq 0x18(%rsp), %rax
movb %cl, 0x7(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x3c(%rsp), %eax
je 0x8a15
movq 0x28(%rsp), %rax
movl 0x24(%rsp), %ecx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
addl $0x8, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x89e1
movq 0x18(%rsp), %rdi
callq 0x8660
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_color_mode_init(LodePNGColorMode*)
void lodepng_color_mode_init(LodePNGColorMode* info)
{
  info->key_defined = 0;
  info->key_r = info->key_g = info->key_b = 0;
  info->colortype = LCT_RGBA;
  info->bitdepth = 8;
  info->palette = 0;
  info->palettesize = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rsp), %rax
movl $0x6, (%rax)
movq -0x8(%rsp), %rax
movl $0x8, 0x4(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
retq
nopw (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_color_mode_copy(LodePNGColorMode*, LodePNGColorMode const*)
unsigned lodepng_color_mode_copy(LodePNGColorMode* dest, const LodePNGColorMode* source)
{
  size_t i;
  lodepng_color_mode_cleanup(dest);
  *dest = *source;
  if(source->palette)
  {
    dest->palette = (unsigned char*)lodepng_malloc(1024);
    if(!dest->palette && source->palettesize) return 83; /*alloc fail*/
    for(i = 0; i != source->palettesize * 4; ++i) dest->palette[i] = source->palette[i];
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x8aa0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
movl $0x28, %edx
callq 0x3170
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x8bb8
movl $0x400, %edi            # imm = 0x400
callq 0x6cd0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x8b64
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8b64
movl $0x53, 0x24(%rsp)
jmp 0x8bc0
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
cmpq %rcx, %rax
je 0x8bb6
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x8b6d
jmp 0x8bb8
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_palette_add(LodePNGColorMode*, unsigned char, unsigned char, unsigned char, unsigned char)
unsigned lodepng_palette_add(LodePNGColorMode* info,
                             unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
  unsigned char* data;
  /*the same resize technique as C++ std::vectors is used, and here it's made so that for a palette with
  the max of 256 colors, it'll have the exact alloc size*/
  if(!info->palette) /*allocate palette if empty*/
  {
    /*room for 256 colors with 4 bytes each*/
    data = (unsigned char*)lodepng_realloc(info->palette, 1024);
    if(!data) return 83; /*alloc fail*/
    else info->palette = data;
  }
  info->palette[4 * info->palettesize + 0] = r;
  info->palette[4 * info->palettesize + 1] = g;
  info->palette[4 * info->palettesize + 2] = b;
  info->palette[4 * info->palettesize + 3] = a;
  ++info->palettesize;
  return 0;
}

// Assembly:
subq $0x28, %rsp
movb %r8b, %al
movq %rdi, 0x18(%rsp)
movb %sil, 0x17(%rsp)
movb %dl, 0x16(%rsp)
movb %cl, 0x15(%rsp)
movb %al, 0x14(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x8c36
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x8890
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x8c26
movl $0x53, 0x24(%rsp)
jmp 0x8cc6
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x8c36
movb 0x17(%rsp), %dl
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
movb %dl, (%rax,%rcx)
movb 0x16(%rsp), %dl
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
movb %dl, 0x1(%rax,%rcx)
movb 0x15(%rsp), %dl
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
movb %dl, 0x2(%rax,%rcx)
movb 0x14(%rsp), %dl
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
movb %dl, 0x3(%rax,%rcx)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: getNumColorChannels(LodePNGColorType)
static unsigned getNumColorChannels(LodePNGColorType colortype)
{
  switch(colortype)
  {
    case 0: return 1; /*grey*/
    case 2: return 3; /*RGB*/
    case 3: return 1; /*palette*/
    case 4: return 2; /*grey + alpha*/
    case 6: return 4; /*RGBA*/
  }
  return 0; /*unexisting color type*/
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movq %rax, -0x10(%rsp)
subq $0x6, %rax
ja 0x8d8a
movq -0x10(%rsp), %rax
leaq 0x135e1(%rip), %rcx     # 0x1c330
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rsp)
jmp 0x8d92
movl $0x3, -0x4(%rsp)
jmp 0x8d92
movl $0x1, -0x4(%rsp)
jmp 0x8d92
movl $0x2, -0x4(%rsp)
jmp 0x8d92
movl $0x4, -0x4(%rsp)
jmp 0x8d92
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_has_palette_alpha(LodePNGColorMode const*)
unsigned lodepng_has_palette_alpha(const LodePNGColorMode* info)
{
  size_t i;
  for(i = 0; i != info->palettesize; ++i)
  {
    if(info->palette[i * 4 + 3] < 255) return 1;
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x8e68
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rsp), %rcx
shlq $0x2, %rcx
movzbl 0x3(%rax,%rcx), %eax
cmpl $0xff, %eax
jge 0x8e56
movl $0x1, -0x4(%rsp)
jmp 0x8e70
jmp 0x8e58
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x8e1e
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x48(%rcx), %rax
je 0x9026
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x15ef0
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x15ef0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x8fd2
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x78b0
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x78b0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x8890
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x58(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x8890
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x90bb
cmpq $0x0, 0x8(%rsp)
jne 0x90dc
movq 0x10(%rsp), %rdi
callq 0x78b0
movq 0x8(%rsp), %rdi
callq 0x78b0
movl $0x53, 0x34(%rsp)
jmp 0x91a3
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x91b0
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x91d0
movq 0x28(%rsp), %rax
movq 0x58(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x91b0
movq 0x28(%rsp), %rax
movq 0x58(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x91d0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x30d0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x15f10
cmpl $0x0, %eax
je 0x9245
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x9243
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x920a
jmp 0x9245
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x60(%rcx), %rax
je 0x9300
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x15ef0
movq 0x10(%rsp), %rax
movq 0x70(%rax), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x15ef0
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x15ef0
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x15ef0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x9272
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x78b0
movq 0x10(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x78b0
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rdi
callq 0x78b0
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rdi
callq 0x78b0
addq $0x18, %rsp
retq
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_info_init(LodePNGInfo*)
void lodepng_info_init(LodePNGInfo* info)
{
  lodepng_color_mode_init(&info->color);
  info->interlace_method = 0;
  info->compression_method = 0;
  info->filter_method = 0;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  info->background_defined = 0;
  info->background_r = info->background_g = info->background_b = 0;

  LodePNGText_init(info);
  LodePNGIText_init(info);

  info->time_defined = 0;
  info->phys_defined = 0;

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

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0x8a30
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
movq (%rsp), %rax
movl $0x0, (%rax)
movq (%rsp), %rax
movl $0x0, 0x4(%rax)
movq (%rsp), %rax
movl $0x0, 0x38(%rax)
movq (%rsp), %rax
movl $0x0, 0x44(%rax)
movq (%rsp), %rax
movl $0x0, 0x40(%rax)
movq (%rsp), %rax
movl $0x0, 0x3c(%rax)
movq (%rsp), %rdi
callq 0x9670
movq (%rsp), %rdi
callq 0x96a0
movq (%rsp), %rax
movl $0x0, 0x88(%rax)
movq (%rsp), %rax
movl $0x0, 0xa4(%rax)
movq (%rsp), %rdi
callq 0x96f0
popq %rax
retq
nopw (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: LodePNGIText_init(LodePNGInfo*)
static void LodePNGIText_init(LodePNGInfo* info)
{
  info->itext_num = 0;
  info->itext_keys = NULL;
  info->itext_langtags = NULL;
  info->itext_transkeys = NULL;
  info->itext_strings = NULL;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, 0x60(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x68(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x70(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x78(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x80(%rax)
retq
nopw (%rax,%rax)
// File: 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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0x8aa0
movq (%rsp), %rdi
callq 0x8fc0
movq (%rsp), %rdi
callq 0x9260
movq (%rsp), %rdi
callq 0x9790
popq %rax
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x9760
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
movl $0xe8, %edx
callq 0x3170
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
callq 0x8a30
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rsi
addq $0x10, %rsi
callq 0x8af0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x9836
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x98b1
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x98c0
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0x985a
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x98b1
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x9980
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x987e
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x98b1
movq 0x18(%rsp), %rdi
callq 0x96f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x9a90
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
je 0x98a9
movl (%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x98b1
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: LodePNGText_copy(LodePNGInfo*, LodePNGInfo const*)
static unsigned LodePNGText_copy(LodePNGInfo* dest, const LodePNGInfo* source)
{
  size_t i = 0;
  dest->text_keys = 0;
  dest->text_strings = 0;
  dest->text_num = 0;
  for(i = 0; i != source->text_num; ++i)
  {
    CERROR_TRY_RETURN(lodepng_add_text(dest, source->text_keys[i], source->text_strings[i]));
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x58(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x48(%rax)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x48(%rcx), %rax
je 0x996c
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x9050
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x995a
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x9974
jmp 0x995c
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x9907
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: LodePNGIText_copy(LodePNGInfo*, LodePNGInfo const*)
static unsigned LodePNGIText_copy(LodePNGInfo* dest, const LodePNGInfo* source)
{
  size_t i = 0;
  dest->itext_keys = 0;
  dest->itext_langtags = 0;
  dest->itext_transkeys = 0;
  dest->itext_strings = 0;
  dest->itext_num = 0;
  for(i = 0; i != source->itext_num; ++i)
  {
    CERROR_TRY_RETURN(lodepng_add_itext(dest, source->itext_keys[i], source->itext_langtags[i],
                                        source->itext_transkeys[i], source->itext_strings[i]));
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq $0x0, 0x68(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x70(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x78(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x80(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x60(%rax)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x60(%rcx), %rax
je 0x9a73
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x10(%rsp), %rax
movq 0x70(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rax
movq 0x8(%rsp), %r8
movq (%rax,%r8,8), %r8
callq 0x9340
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x9a5e
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x9a7b
jmp 0x9a60
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x99e4
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: LodePNGUnknownChunks_copy(LodePNGInfo*, LodePNGInfo const*)
static unsigned LodePNGUnknownChunks_copy(LodePNGInfo* dest, const LodePNGInfo* src)
{
  unsigned i;

  LodePNGUnknownChunks_cleanup(dest);

  for(i = 0; i != 3; ++i)
  {
    size_t j;
    dest->unknown_chunks_size[i] = src->unknown_chunks_size[i];
    dest->unknown_chunks_data[i] = (unsigned char*)lodepng_malloc(src->unknown_chunks_size[i]);
    if(!dest->unknown_chunks_data[i] && dest->unknown_chunks_size[i]) return 83; /*alloc fail*/
    for(j = 0; j < src->unknown_chunks_size[i]; ++j)
    {
      dest->unknown_chunks_data[i][j] = src->unknown_chunks_data[i][j];
    }
  }

  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x9790
movl $0x0, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
je 0x9ba8
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movq 0xd0(%rax,%rcx,8), %rdx
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
movq %rdx, 0xd0(%rax,%rcx,8)
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movq 0xd0(%rax,%rcx,8), %rdi
callq 0x6cd0
movq %rax, %rdx
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
movq %rdx, 0xb8(%rax,%rcx,8)
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
cmpq $0x0, 0xb8(%rax,%rcx,8)
jne 0x9b39
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
cmpq $0x0, 0xd0(%rax,%rcx,8)
je 0x9b39
movl $0x53, 0x24(%rsp)
jmp 0x9bb0
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0xc(%rsp), %edx
cmpq 0xd0(%rcx,%rdx,8), %rax
jae 0x9b96
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movq 0xb8(%rax,%rcx,8), %rax
movq (%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
movq 0xb8(%rax,%rcx,8), %rax
movq (%rsp), %rcx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x9b41
jmp 0x9b98
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x9ab0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
je 0xa107
movl $0x0, -0x4(%rsp)
jmp 0xa239
movq -0x10(%rsp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
je 0xa126
movl $0x0, -0x4(%rsp)
jmp 0xa239
movq -0x10(%rsp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x18(%rcx), %eax
je 0xa145
movl $0x0, -0x4(%rsp)
jmp 0xa239
movq -0x10(%rsp), %rax
cmpl $0x0, 0x18(%rax)
je 0xa1af
movq -0x10(%rsp), %rax
movl 0x1c(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x1c(%rcx), %eax
je 0xa16f
movl $0x0, -0x4(%rsp)
jmp 0xa239
movq -0x10(%rsp), %rax
movl 0x20(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x20(%rcx), %eax
je 0xa18e
movl $0x0, -0x4(%rsp)
jmp 0xa239
movq -0x10(%rsp), %rax
movl 0x24(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x24(%rcx), %eax
je 0xa1ad
movl $0x0, -0x4(%rsp)
jmp 0xa239
jmp 0xa1af
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0xa1cd
movl $0x0, -0x4(%rsp)
jmp 0xa239
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
cmpq %rcx, %rax
je 0xa231
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq -0x20(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xa21f
movl $0x0, -0x4(%rsp)
jmp 0xa239
jmp 0xa221
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0xa1d6
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: 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:
subq $0x18, %rsp
movb %r8b, %al
movq %rdi, 0x10(%rsp)
movb %sil, 0xf(%rsp)
movb %dl, 0xe(%rsp)
movb %cl, 0xd(%rsp)
movb %al, 0xc(%rsp)
movl %r9d, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x8, 0x4(%rsp)
jge 0xa375
movzbl 0xf(%rsp), %eax
movl 0x4(%rsp), %ecx
sarl %cl, %eax
andl $0x1, %eax
shll $0x3, %eax
movzbl 0xe(%rsp), %edx
movl 0x4(%rsp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
shll $0x2, %ecx
addl %ecx, %eax
movzbl 0xd(%rsp), %edx
movl 0x4(%rsp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
shll %ecx
addl %ecx, %eax
movzbl 0xc(%rsp), %edx
movl 0x4(%rsp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
shll $0x0, %ecx
addl %ecx, %eax
movl %eax, (%rsp)
movq 0x10(%rsp), %rax
movslq (%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xa353
movl $0x88, %edi
callq 0x6cd0
movq %rax, %rdx
movq 0x10(%rsp), %rax
movslq (%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movslq (%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xa240
movq 0x10(%rsp), %rax
movslq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xa2ba
movl 0x8(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x80(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x10, 0xc(%rsp)
je 0xbe8e
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xbe7f
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xbe30
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x78b0
jmp 0xbe81
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xbe41
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_color_profile_init(LodePNGColorProfile*)
void lodepng_color_profile_init(LodePNGColorProfile* profile)
{
  profile->colored = 0;
  profile->key = 0;
  profile->alpha = 0;
  profile->key_r = profile->key_g = profile->key_b = 0;
  profile->numcolors = 0;
  profile->bits = 1;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, (%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movw $0x0, 0xc(%rax)
movq -0x8(%rsp), %rax
movw $0x0, 0xa(%rax)
movq -0x8(%rsp), %rax
movw $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rsp), %rax
movl $0x1, 0x418(%rax)
retq
nopw %cs:(%rax,%rax)
// File: 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 %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl -0x8(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x6, %rax
ja 0xd35b
movq -0x18(%rsp), %rax
leaq 0xf0a5(%rip), %rcx      # 0x1c34c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x1, -0xc(%rsp)
je 0xd2e0
cmpl $0x2, -0xc(%rsp)
je 0xd2e0
cmpl $0x4, -0xc(%rsp)
je 0xd2e0
cmpl $0x8, -0xc(%rsp)
je 0xd2e0
cmpl $0x10, -0xc(%rsp)
je 0xd2e0
movl $0x25, -0x4(%rsp)
jmp 0xd36d
jmp 0xd365
cmpl $0x8, -0xc(%rsp)
je 0xd2fd
cmpl $0x10, -0xc(%rsp)
je 0xd2fd
movl $0x25, -0x4(%rsp)
jmp 0xd36d
jmp 0xd365
cmpl $0x1, -0xc(%rsp)
je 0xd325
cmpl $0x2, -0xc(%rsp)
je 0xd325
cmpl $0x4, -0xc(%rsp)
je 0xd325
cmpl $0x8, -0xc(%rsp)
je 0xd325
movl $0x25, -0x4(%rsp)
jmp 0xd36d
jmp 0xd365
cmpl $0x8, -0xc(%rsp)
je 0xd33f
cmpl $0x10, -0xc(%rsp)
je 0xd33f
movl $0x25, -0x4(%rsp)
jmp 0xd36d
jmp 0xd365
cmpl $0x8, -0xc(%rsp)
je 0xd359
cmpl $0x10, -0xc(%rsp)
je 0xd359
movl $0x25, -0x4(%rsp)
jmp 0xd36d
jmp 0xd365
movl $0x1f, -0x4(%rsp)
jmp 0xd36d
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x1f8, %rsp            # imm = 0x1F8
movl 0x200(%rsp), %eax
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq %rdx, 0x1e0(%rsp)
movq %rcx, 0x1d8(%rsp)
movq %r8, 0x1d0(%rsp)
movl %r9d, 0x1cc(%rsp)
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x19cc0
movq 0x8(%rsp), %rdi
callq 0xe330
jmp 0xe279
movl 0x1cc(%rsp), %eax
movl %eax, 0xb0(%rsp)
movl 0x200(%rsp), %eax
movl %eax, 0xb4(%rsp)
movq 0x1f0(%rsp), %rdi
movq 0x1e8(%rsp), %rsi
movq 0x1e0(%rsp), %rdx
movq 0x1d8(%rsp), %r8
movq 0x1d0(%rsp), %r9
leaq 0x20(%rsp), %rcx
callq 0xd380
movl %eax, 0x4(%rsp)
jmp 0xe2cd
movl 0x4(%rsp), %eax
movl %eax, 0x1c8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xe380
jmp 0xe2e4
movl 0x1c8(%rsp), %eax
movl %eax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x19ce0
movl (%rsp), %eax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x19ce0
movq 0x18(%rsp), %rdi
callq 0x3390
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0xe580
movq (%rsp), %rdi
addq $0x38, %rdi
callq 0xe5c0
movq (%rsp), %rdi
addq $0x90, %rdi
callq 0x8a30
movq (%rsp), %rdi
addq $0xb8, %rdi
callq 0x95d0
movq (%rsp), %rax
movl $0x1, 0x1a0(%rax)
popq %rax
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movl %r9d, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rdx
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6b80
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0xe4c8
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movl 0x24(%rsp), %r9d
movl 0x20(%rsp), %eax
movl %eax, (%rsp)
callq 0xe220
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0x78b0
movl 0xc(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl $0x1, 0x24(%rax)
movq (%rsp), %rax
movl $0x1, 0x28(%rax)
movq (%rsp), %rax
movl $0x0, 0x2c(%rax)
movq (%rsp), %rax
movl $0x0, 0x20(%rax)
movq (%rsp), %rdi
callq 0x8390
popq %rax
retq
nopl (%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_encoder_settings_init(LodePNGEncoderSettings*)
void lodepng_encoder_settings_init(LodePNGEncoderSettings* settings)
{
  lodepng_compress_settings_init(&settings->zlibsettings);
  settings->filter_palette_zero = 1;
  settings->filter_strategy = LFS_MINSUM;
  settings->auto_convert = 1;
  settings->force_palette = 0;
  settings->predefined_filters = 0;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  settings->add_id = 0;
  settings->text_compression = 1;
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x8310
movq (%rsp), %rax
movl $0x1, 0x34(%rax)
movq (%rsp), %rax
movl $0x1, 0x38(%rax)
movq (%rsp), %rax
movl $0x1, 0x30(%rax)
movq (%rsp), %rax
movl $0x0, 0x48(%rax)
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rax
movl $0x0, 0x4c(%rax)
movq (%rsp), %rax
movl $0x1, 0x50(%rax)
popq %rax
retq
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xe380
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x19cf0
movq 0x10(%rsp), %rdi
addq $0x90, %rdi
callq 0x8a30
movq 0x10(%rsp), %rdi
addq $0xb8, %rdi
callq 0x95d0
movq 0x10(%rsp), %rdi
addq $0x90, %rdi
movq 0x8(%rsp), %rsi
addq $0x90, %rsi
callq 0x8af0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x1a0(%rax)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x1a0(%rax)
je 0xe6a3
jmp 0xe6dd
movq 0x10(%rsp), %rdi
addq $0xb8, %rdi
movq 0x8(%rsp), %rsi
addq $0xb8, %rsi
callq 0x97d0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x1a0(%rax)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x1a0(%rax)
je 0xe6dd
jmp 0xe6dd
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0x89, %esi
callq 0x81d0
movq (%rsp), %rdi
movl $0x50, %esi
callq 0x81d0
movq (%rsp), %rdi
movl $0x4e, %esi
callq 0x81d0
movq (%rsp), %rdi
movl $0x47, %esi
callq 0x81d0
movq (%rsp), %rdi
movl $0xd, %esi
callq 0x81d0
movq (%rsp), %rdi
movl $0xa, %esi
callq 0x81d0
movq (%rsp), %rdi
movl $0x1a, %esi
callq 0x81d0
movq (%rsp), %rdi
movl $0xa, %esi
callq 0x81d0
popq %rax
retq
nopw (%rax,%rax)