LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: hash_cleanup(Hash*)
static void hash_cleanup(Hash* hash)
{
  lodepng_free(hash->head);
  lodepng_free(hash->val);
  lodepng_free(hash->chain);

  lodepng_free(hash->zeros);
  lodepng_free(hash->headz);
  lodepng_free(hash->chainz);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x78b0
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x78b0
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x78b0
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x78b0
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x78b0
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x78b0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: getHash(unsigned char const*, unsigned long, unsigned long)
static unsigned getHash(const unsigned char* data, size_t size, size_t pos)
{
  unsigned result = 0;
  if(pos + 2 < size)
  {
    /*A simple shift and xor hash is used. Since the data of PNGs is dominated
    by zeroes due to the filters, a better hash does not have a significant
    effect on speed in traversing the chain, and causes more time spend on
    calculating the hash.*/
    result ^= (unsigned)(data[pos + 0] << 0u);
    result ^= (unsigned)(data[pos + 1] << 4u);
    result ^= (unsigned)(data[pos + 2] << 8u);
  } else {
    size_t amount, i;
    if(pos >= size) return 0;
    amount = size - pos;
    for(i = 0; i != amount; ++i) result ^= (unsigned)(data[pos + i] << (i * 8u));
  }
  return result & HASH_BIT_MASK;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movq -0x20(%rsp), %rax
addq $0x2, %rax
cmpq -0x18(%rsp), %rax
jae 0x15786
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
shll $0x0, %eax
xorl -0x24(%rsp), %eax
movl %eax, -0x24(%rsp)
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movzbl 0x1(%rax,%rcx), %eax
shll $0x4, %eax
xorl -0x24(%rsp), %eax
movl %eax, -0x24(%rsp)
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movzbl 0x2(%rax,%rcx), %eax
shll $0x8, %eax
xorl -0x24(%rsp), %eax
movl %eax, -0x24(%rsp)
jmp 0x157f8
movq -0x20(%rsp), %rax
cmpq -0x18(%rsp), %rax
jb 0x1579c
movl $0x0, -0x4(%rsp)
jmp 0x15805
movq -0x18(%rsp), %rax
subq -0x20(%rsp), %rax
movq %rax, -0x30(%rsp)
movq $0x0, -0x38(%rsp)
movq -0x38(%rsp), %rax
cmpq -0x30(%rsp), %rax
je 0x157f6
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
addq -0x38(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x38(%rsp), %rcx
shlq $0x3, %rcx
shll %cl, %eax
xorl -0x24(%rsp), %eax
movl %eax, -0x24(%rsp)
movq -0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
jmp 0x157b4
jmp 0x157f8
movl -0x24(%rsp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: countZeros(unsigned char const*, unsigned long, unsigned long)
static unsigned countZeros(const unsigned char* data, size_t size, size_t pos)
{
  const unsigned char* start = data + pos;
  const unsigned char* end = start + MAX_SUPPORTED_DEFLATE_LENGTH;
  if(end > data + size) end = data + size;
  data = start;
  while(data != end && *data == 0) ++data;
  /*subtracting two addresses returned as 32-bit number (max value is MAX_SUPPORTED_DEFLATE_LENGTH)*/
  return (unsigned)(data - start);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
addq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
addq $0x102, %rax            # imm = 0x102
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq -0x8(%rsp), %rcx
addq -0x10(%rsp), %rcx
cmpq %rcx, %rax
jbe 0x15861
movq -0x8(%rsp), %rax
addq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rcx
xorl %eax, %eax
cmpq -0x28(%rsp), %rcx
movb %al, -0x29(%rsp)
je 0x1588f
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x29(%rsp)
movb -0x29(%rsp), %al
testb $0x1, %al
jne 0x15899
jmp 0x158a9
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
jmp 0x1586b
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
subq %rcx, %rax
retq
nopw (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: updateHashChain(Hash*, unsigned long, unsigned int, unsigned short)
static void updateHashChain(Hash* hash, size_t wpos, unsigned hashval, unsigned short numzeros)
{
  hash->val[wpos] = (int)hashval;
  if(hash->head[hashval] != -1) hash->chain[wpos] = hash->head[hashval];
  hash->head[hashval] = wpos;

  hash->zeros[wpos] = numzeros;
  if(hash->headz[numzeros] != -1) hash->chainz[wpos] = hash->headz[numzeros];
  hash->headz[numzeros] = wpos;
}

// Assembly:
movw %cx, %ax
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movw %ax, -0x16(%rsp)
movl -0x14(%rsp), %edx
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movl -0x14(%rsp), %ecx
cmpl $-0x1, (%rax,%rcx,4)
je 0x15921
movq -0x8(%rsp), %rax
movq (%rax), %rax
movl -0x14(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movw %ax, %dx
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
movw %dx, (%rax,%rcx,2)
movq -0x10(%rsp), %rax
movl %eax, %edx
movq -0x8(%rsp), %rax
movq (%rax), %rax
movl -0x14(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movw -0x16(%rsp), %dx
movq -0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rsp), %rcx
movw %dx, (%rax,%rcx,2)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movzwl -0x16(%rsp), %ecx
cmpl $-0x1, (%rax,%rcx,4)
je 0x15988
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movzwl -0x16(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movw %ax, %dx
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rsp), %rcx
movw %dx, (%rax,%rcx,2)
movq -0x10(%rsp), %rax
movl %eax, %edx
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movzwl -0x16(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: addLengthDistance(uivector*, unsigned long, unsigned long)
static void addLengthDistance(uivector* values, size_t length, size_t distance)
{
  /*values in encoded vector are those used by deflate:
  0-255: literal bytes
  256: end
  257-285: length/distance pair (length code, followed by extra length bits, distance code, extra distance bits)
  286-287: invalid*/

  unsigned length_code = (unsigned)searchCodeIndex(LENGTHBASE, 29, length);
  unsigned extra_length = (unsigned)(length - LENGTHBASE[length_code]);
  unsigned dist_code = (unsigned)searchCodeIndex(DISTANCEBASE, 30, distance);
  unsigned extra_distance = (unsigned)(distance - DISTANCEBASE[dist_code]);

  uivector_push_back(values, length_code + FIRST_LENGTH_CODE_INDEX);
  uivector_push_back(values, extra_length);
  uivector_push_back(values, dist_code);
  uivector_push_back(values, extra_distance);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdx
leaq 0x6b51(%rip), %rdi      # 0x1c580
movl $0x1d, %esi
callq 0x15ad0
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, %edx
leaq 0x6b31(%rip), %rcx      # 0x1c580
movl (%rcx,%rdx,4), %ecx
subq %rcx, %rax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x6c1b(%rip), %rdi      # 0x1c680
movl $0x1e, %esi
callq 0x15ad0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %ecx, %edx
leaq 0x6bfb(%rip), %rcx      # 0x1c680
movl (%rcx,%rdx,4), %ecx
subq %rcx, %rax
movl %eax, (%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
addl $0x101, %esi            # imm = 0x101
callq 0x159b0
movq 0x20(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x159b0
movq 0x20(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x159b0
movq 0x20(%rsp), %rdi
movl (%rsp), %esi
callq 0x159b0
addq $0x28, %rsp
retq
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: searchCodeIndex(unsigned int const*, unsigned long, unsigned long)
static size_t searchCodeIndex(const unsigned* array, size_t array_size, size_t value)
{
  /*binary search (only small gain over linear). TODO: use CPU log2 instruction for getting symbols instead*/
  size_t left = 1;
  size_t right = array_size - 1;

  while(left <= right) {
    size_t mid = (left + right) >> 1;
    if (array[mid] >= value) right = mid - 1;
    else left = mid + 1;
  }
  if(left >= array_size || array[left] > value) left--;
  return left;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq $0x1, -0x20(%rsp)
movq -0x10(%rsp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x28(%rsp), %rax
ja 0x15b48
movq -0x20(%rsp), %rax
addq -0x28(%rsp), %rax
shrq %rax
movq %rax, -0x30(%rsp)
movq -0x8(%rsp), %rax
movq -0x30(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpq -0x18(%rsp), %rax
jb 0x15b38
movq -0x30(%rsp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x15b46
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x15af6
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x15b68
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpq -0x18(%rsp), %rax
jbe 0x15b76
movq -0x20(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
retq
nopl (%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: HuffmanTree_makeFromFrequencies(HuffmanTree*, unsigned int const*, unsigned long, unsigned long, unsigned int)
static unsigned HuffmanTree_makeFromFrequencies(HuffmanTree* tree, const unsigned* frequencies,
                                                size_t mincodes, size_t numcodes, unsigned maxbitlen)
{
  unsigned error = 0;
  while(!frequencies[numcodes - 1] && numcodes > mincodes) --numcodes; /*trim zeroes*/
  tree->maxbitlen = maxbitlen;
  tree->numcodes = (unsigned)numcodes; /*number of symbols*/
  tree->lengths = (unsigned*)lodepng_realloc(tree->lengths, numcodes * sizeof(unsigned));
  if(!tree->lengths) return 83; /*alloc fail*/
  /*initialize all lengths to 0*/
  memset(tree->lengths, 0, numcodes * sizeof(unsigned));

  error = lodepng_huffman_code_lengths(tree->lengths, frequencies, numcodes, maxbitlen);
  if(!error) error = HuffmanTree_makeFromLengths2(tree);
  return error;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rdx
subq $0x1, %rdx
xorl %eax, %eax
cmpl $0x0, (%rcx,%rdx,4)
movb %al, 0x7(%rsp)
jne 0x15d40
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
seta %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x15d4a
jmp 0x15d5a
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x15d15
movl 0xc(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x10(%rsp), %rax
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
shlq $0x2, %rsi
callq 0x8890
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x15dae
movl $0x53, 0x34(%rsp)
jmp 0x15e04
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x30f0
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq 0x6de0
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0x15dfc
movq 0x28(%rsp), %rdi
callq 0x12f70
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: update_adler32(unsigned int, unsigned char const*, unsigned int)
static unsigned update_adler32(unsigned adler, const unsigned char* data, unsigned len)
{
   unsigned s1 = adler & 0xffff;
   unsigned s2 = (adler >> 16) & 0xffff;

  while(len > 0)
  {
    /*at least 5550 sums can be done before the sums overflow, saving a lot of module divisions*/
    unsigned amount = len > 5550 ? 5550 : len;
    len -= amount;
    while(amount > 0)
    {
      s1 += (*data++);
      s2 += s1;
      --amount;
    }
    s1 %= 65521;
    s2 %= 65521;
  }

  return (s2 << 16) | s1;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl -0x4(%rsp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x18(%rsp)
movl -0x4(%rsp), %eax
shrl $0x10, %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x1c(%rsp)
cmpl $0x0, -0x14(%rsp)
jbe 0x15edb
cmpl $0x15ae, -0x14(%rsp)    # imm = 0x15AE
jbe 0x15e5a
movl $0x15ae, %eax           # imm = 0x15AE
movl %eax, -0x24(%rsp)
jmp 0x15e62
movl -0x14(%rsp), %eax
movl %eax, -0x24(%rsp)
movl -0x24(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %ecx
movl -0x14(%rsp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rsp)
cmpl $0x0, -0x20(%rsp)
jbe 0x15eb4
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movzbl (%rax), %eax
addl -0x18(%rsp), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
addl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x20(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x15e78
movl -0x18(%rsp), %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
xorl %edx, %edx
divl %ecx
movl %edx, -0x18(%rsp)
movl -0x1c(%rsp), %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
xorl %edx, %edx
divl %ecx
movl %edx, -0x1c(%rsp)
jmp 0x15e3a
movl -0x1c(%rsp), %eax
shll $0x10, %eax
orl -0x18(%rsp), %eax
retq
nopw (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: string_resize(char**, unsigned long)
static unsigned string_resize(char** out, size_t size)
{
  char* data = (char*)lodepng_realloc(*out, size + 1);
  if(data)
  {
    data[size] = 0; /*null termination char*/
    *out = data;
  }
  return data != 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
callq 0x8890
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x15f58
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rsp)
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: readBitsFromReversedStream(unsigned long*, unsigned char const*, unsigned long)
static unsigned readBitsFromReversedStream(size_t* bitpointer, const unsigned char* bitstream, size_t nbits)
{
  unsigned result = 0;
  size_t i;
  for(i = 0 ; i < nbits; ++i)
  {
    result <<= 1;
    result |= (unsigned)readBitFromReversedStream(bitpointer, bitstream);
  }
  return result;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x15fd0
movl 0xc(%rsp), %eax
shll %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x15fe0
movzbl %al, %eax
orl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x15f93
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: addColorBits(unsigned char*, unsigned long, unsigned int, unsigned int)
static void addColorBits(unsigned char* out, size_t index, unsigned bits, unsigned in)
{
  unsigned m = bits == 1 ? 7 : bits == 2 ? 3 : 1; /*8 / bits - 1*/
  /*p = the partial index in the byte, e.g. with 4 palettebits it is 0 for first half or 1 for second half*/
  unsigned p = index & m;
  in &= (1u << bits) - 1u; /*filter out any other bits of the input value*/
  in = in << (bits * (m - p));
  if(p == 0) out[index * bits / 8] = in;
  else out[index * bits / 8] |= in;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
cmpl $0x1, -0x14(%rsp)
jne 0x16054
movl $0x7, %eax
movl %eax, -0x24(%rsp)
jmp 0x1606c
movl -0x14(%rsp), %edx
movl $0x1, %eax
movl $0x3, %ecx
cmpl $0x2, %edx
cmovel %ecx, %eax
movl %eax, -0x24(%rsp)
movl -0x24(%rsp), %eax
movl %eax, -0x1c(%rsp)
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
andq %rcx, %rax
movl %eax, -0x20(%rsp)
movl -0x14(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
andl -0x18(%rsp), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
movl -0x14(%rsp), %ecx
movl -0x1c(%rsp), %edx
subl -0x20(%rsp), %edx
imull %edx, %ecx
shll %cl, %eax
movl %eax, -0x18(%rsp)
cmpl $0x0, -0x20(%rsp)
jne 0x160db
movl -0x18(%rsp), %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movl -0x14(%rsp), %esi
imulq %rsi, %rcx
shrq $0x3, %rcx
movb %dl, (%rax,%rcx)
jmp 0x160fe
movl -0x18(%rsp), %esi
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movl -0x14(%rsp), %edx
imulq %rdx, %rcx
shrq $0x3, %rcx
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
retq
nop
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: color_tree_get(ColorTree*, unsigned char, unsigned char, unsigned char, unsigned char)
static int color_tree_get(ColorTree* tree, unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
  int bit = 0;
  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]) return -1;
    else tree = tree->children[i];
  }
  return tree ? tree->index : -1;
}

// Assembly:
movb %r8b, %al
movq %rdi, -0x10(%rsp)
movb %sil, -0x11(%rsp)
movb %dl, -0x12(%rsp)
movb %cl, -0x13(%rsp)
movb %al, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movl $0x0, -0x18(%rsp)
cmpl $0x8, -0x18(%rsp)
jge 0x161c7
movzbl -0x11(%rsp), %eax
movl -0x18(%rsp), %ecx
sarl %cl, %eax
andl $0x1, %eax
shll $0x3, %eax
movzbl -0x12(%rsp), %edx
movl -0x18(%rsp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
shll $0x2, %ecx
addl %ecx, %eax
movzbl -0x13(%rsp), %edx
movl -0x18(%rsp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
shll %ecx
addl %ecx, %eax
movzbl -0x14(%rsp), %edx
movl -0x18(%rsp), %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
shll $0x0, %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rsp)
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x161a2
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x161f3
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rsp)
jmp 0x161b7
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x16129
cmpq $0x0, -0x10(%rsp)
je 0x161e0
movq -0x10(%rsp), %rax
movl 0x80(%rax), %eax
movl %eax, -0x20(%rsp)
jmp 0x161eb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x20(%rsp)
jmp 0x161eb
movl -0x20(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: readChunk_PLTE(LodePNGColorMode*, unsigned char const*, unsigned long)
static unsigned readChunk_PLTE(LodePNGColorMode* color, const unsigned char* data, size_t chunkLength)
{
  unsigned pos = 0, i;
  if(color->palette) lodepng_free(color->palette);
  color->palettesize = chunkLength / 3;
  color->palette = (unsigned char*)lodepng_malloc(4 * color->palettesize);
  if(!color->palette && color->palettesize)
  {
    color->palettesize = 0;
    return 83; /*alloc fail*/
  }
  if(color->palettesize > 256) return 38; /*error: palette too big*/

  for(i = 0; i != color->palettesize; ++i)
  {
    color->palette[4 * i + 0] = data[pos++]; /*R*/
    color->palette[4 * i + 1] = data[pos++]; /*G*/
    color->palette[4 * i + 2] = data[pos++]; /*B*/
    color->palette[4 * i + 3] = 255; /*alpha*/
  }

  return 0; /* OK */
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x16235
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x78b0
movq 0x8(%rsp), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
shlq $0x2, %rdi
callq 0x6cd0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x162a0
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x162a0
movq 0x18(%rsp), %rax
movq $0x0, 0x10(%rax)
movl $0x53, 0x24(%rsp)
jmp 0x1638d
movq 0x18(%rsp), %rax
cmpq $0x100, 0x10(%rax)      # imm = 0x100
jbe 0x162bc
movl $0x26, 0x24(%rsp)
jmp 0x1638d
movl $0x0, (%rsp)
movl (%rsp), %eax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x16385
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x4(%rsp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rsp), %ecx
shll $0x2, %ecx
addl $0x0, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x4(%rsp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rsp), %ecx
shll $0x2, %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x4(%rsp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rsp), %ecx
shll $0x2, %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rsp), %ecx
shll $0x2, %ecx
addl $0x3, %ecx
movl %ecx, %ecx
movb $-0x1, (%rax,%rcx)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x162c3
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: readChunk_tRNS(LodePNGColorMode*, unsigned char const*, unsigned long)
static unsigned readChunk_tRNS(LodePNGColorMode* color, const unsigned char* data, size_t chunkLength)
{
  unsigned i;
  if(color->colortype == LCT_PALETTE)
  {
    /*error: more alpha values given than there are palette entries*/
    if(chunkLength > color->palettesize) return 38;

    for(i = 0; i != chunkLength; ++i) color->palette[4 * i + 3] = data[i];
  }
  else if(color->colortype == LCT_GREY)
  {
    /*error: this chunk must be 2 bytes for greyscale image*/
    if(chunkLength != 2) return 30;

    color->key_defined = 1;
    color->key_r = color->key_g = color->key_b = 256u * data[0] + data[1];
  }
  else if(color->colortype == LCT_RGB)
  {
    /*error: this chunk must be 6 bytes for RGB image*/
    if(chunkLength != 6) return 41;

    color->key_defined = 1;
    color->key_r = 256u * data[0] + data[1];
    color->key_g = 256u * data[2] + data[3];
    color->key_b = 256u * data[4] + data[5];
  }
  else return 42; /*error: tRNS chunk not allowed for other color models*/

  return 0; /* OK */
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
cmpl $0x3, (%rax)
jne 0x1641f
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x163d6
movl $0x26, -0x4(%rsp)
jmp 0x1651c
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpq -0x20(%rsp), %rax
je 0x1641a
movq -0x18(%rsp), %rax
movl -0x24(%rsp), %ecx
movb (%rax,%rcx), %dl
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rsp), %ecx
shll $0x2, %ecx
addl $0x3, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x163de
jmp 0x16514
movq -0x10(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x1647d
cmpq $0x2, -0x20(%rsp)
je 0x1643e
movl $0x1e, -0x4(%rsp)
jmp 0x1651c
movq -0x10(%rsp), %rax
movl $0x1, 0x18(%rax)
movq -0x18(%rsp), %rax
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rsp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x24(%rax)
movq -0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rsp), %rax
movl %ecx, 0x1c(%rax)
jmp 0x16512
movq -0x10(%rsp), %rax
cmpl $0x2, (%rax)
jne 0x16506
cmpq $0x6, -0x20(%rsp)
je 0x1649c
movl $0x29, -0x4(%rsp)
jmp 0x1651c
movq -0x10(%rsp), %rax
movl $0x1, 0x18(%rax)
movq -0x18(%rsp), %rax
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rsp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq -0x18(%rsp), %rax
movzbl 0x2(%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rsp), %rax
movzbl 0x3(%rax), %eax
addl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq -0x18(%rsp), %rax
movzbl 0x4(%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rsp), %rax
movzbl 0x5(%rax), %eax
addl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x24(%rax)
jmp 0x16510
movl $0x2a, -0x4(%rsp)
jmp 0x1651c
jmp 0x16512
jmp 0x16514
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: readChunk_bKGD(LodePNGInfo*, unsigned char const*, unsigned long)
static unsigned readChunk_bKGD(LodePNGInfo* info, const unsigned char* data, size_t chunkLength)
{
  if(info->color.colortype == LCT_PALETTE)
  {
    /*error: this chunk must be 1 byte for indexed color image*/
    if(chunkLength != 1) return 43;

    info->background_defined = 1;
    info->background_r = info->background_g = info->background_b = data[0];
  }
  else if(info->color.colortype == LCT_GREY || info->color.colortype == LCT_GREY_ALPHA)
  {
    /*error: this chunk must be 2 bytes for greyscale image*/
    if(chunkLength != 2) return 44;

    info->background_defined = 1;
    info->background_r = info->background_g = info->background_b = 256u * data[0] + data[1];
  }
  else if(info->color.colortype == LCT_RGB || info->color.colortype == LCT_RGBA)
  {
    /*error: this chunk must be 6 bytes for greyscale image*/
    if(chunkLength != 6) return 45;

    info->background_defined = 1;
    info->background_r = 256u * data[0] + data[1];
    info->background_g = 256u * data[2] + data[3];
    info->background_b = 256u * data[4] + data[5];
  }

  return 0; /* OK */
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
cmpl $0x3, 0x10(%rax)
jne 0x16590
cmpq $0x1, -0x20(%rsp)
je 0x1655f
movl $0x2b, -0x4(%rsp)
jmp 0x16696
movq -0x10(%rsp), %rax
movl $0x1, 0x38(%rax)
movq -0x18(%rsp), %rax
movzbl (%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x44(%rax)
movq -0x10(%rsp), %rax
movl %ecx, 0x40(%rax)
movq -0x10(%rsp), %rax
movl %ecx, 0x3c(%rax)
jmp 0x1668e
movq -0x10(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0x165a6
movq -0x10(%rsp), %rax
cmpl $0x4, 0x10(%rax)
jne 0x165fa
cmpq $0x2, -0x20(%rsp)
je 0x165bb
movl $0x2c, -0x4(%rsp)
jmp 0x16696
movq -0x10(%rsp), %rax
movl $0x1, 0x38(%rax)
movq -0x18(%rsp), %rax
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rsp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x44(%rax)
movq -0x10(%rsp), %rax
movl %ecx, 0x40(%rax)
movq -0x10(%rsp), %rax
movl %ecx, 0x3c(%rax)
jmp 0x1668c
movq -0x10(%rsp), %rax
cmpl $0x2, 0x10(%rax)
je 0x16610
movq -0x10(%rsp), %rax
cmpl $0x6, 0x10(%rax)
jne 0x1668a
cmpq $0x6, -0x20(%rsp)
je 0x16622
movl $0x2d, -0x4(%rsp)
jmp 0x16696
movq -0x10(%rsp), %rax
movl $0x1, 0x38(%rax)
movq -0x18(%rsp), %rax
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rsp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x3c(%rax)
movq -0x18(%rsp), %rax
movzbl 0x2(%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rsp), %rax
movzbl 0x3(%rax), %eax
addl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x40(%rax)
movq -0x18(%rsp), %rax
movzbl 0x4(%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rsp), %rax
movzbl 0x5(%rax), %eax
addl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x44(%rax)
jmp 0x1668c
jmp 0x1668e
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: readChunk_tIME(LodePNGInfo*, unsigned char const*, unsigned long)
static unsigned readChunk_tIME(LodePNGInfo* info, const unsigned char* data, size_t chunkLength)
{
  if(chunkLength != 7) return 73; /*invalid tIME chunk size*/

  info->time_defined = 1;
  info->time.year = 256u * data[0] + data[1];
  info->time.month = data[2];
  info->time.day = data[3];
  info->time.hour = data[4];
  info->time.minute = data[5];
  info->time.second = data[6];

  return 0; /* OK */
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x7, -0x20(%rsp)
je 0x16f94
movl $0x49, -0x4(%rsp)
jmp 0x17030
movq -0x10(%rsp), %rax
movl $0x1, 0x88(%rax)
movq -0x18(%rsp), %rax
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rsp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x8c(%rax)
movq -0x18(%rsp), %rax
movzbl 0x2(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x90(%rax)
movq -0x18(%rsp), %rax
movzbl 0x3(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x94(%rax)
movq -0x18(%rsp), %rax
movzbl 0x4(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x98(%rax)
movq -0x18(%rsp), %rax
movzbl 0x5(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x9c(%rax)
movq -0x18(%rsp), %rax
movzbl 0x6(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0xa0(%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: readChunk_pHYs(LodePNGInfo*, unsigned char const*, unsigned long)
static unsigned readChunk_pHYs(LodePNGInfo* info, const unsigned char* data, size_t chunkLength)
{
  if(chunkLength != 9) return 74; /*invalid pHYs chunk size*/

  info->phys_defined = 1;
  info->phys_x = 16777216u * data[0] + 65536u * data[1] + 256u * data[2] + data[3];
  info->phys_y = 16777216u * data[4] + 65536u * data[5] + 256u * data[6] + data[7];
  info->phys_unit = data[8];

  return 0; /* OK */
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x9, -0x20(%rsp)
je 0x17064
movl $0x4a, -0x4(%rsp)
jmp 0x1710a
movq -0x10(%rsp), %rax
movl $0x1, 0xa4(%rax)
movq -0x18(%rsp), %rax
movzbl (%rax), %ecx
shll $0x18, %ecx
movq -0x18(%rsp), %rax
movzbl 0x1(%rax), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x18(%rsp), %rax
movzbl 0x2(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x18(%rsp), %rax
movzbl 0x3(%rax), %eax
addl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0xa8(%rax)
movq -0x18(%rsp), %rax
movzbl 0x4(%rax), %ecx
shll $0x18, %ecx
movq -0x18(%rsp), %rax
movzbl 0x5(%rax), %eax
shll $0x10, %eax
addl %eax, %ecx
movq -0x18(%rsp), %rax
movzbl 0x6(%rax), %eax
shll $0x8, %eax
addl %eax, %ecx
movq -0x18(%rsp), %rax
movzbl 0x7(%rax), %eax
addl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0xac(%rax)
movq -0x18(%rsp), %rax
movzbl 0x8(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0xb0(%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: unfilter(unsigned char*, unsigned char const*, unsigned int, unsigned int, unsigned int)
static unsigned unfilter(unsigned char* out, const unsigned char* in, unsigned w, unsigned h, unsigned bpp)
{
  /*
  For PNG filter method 0
  this function unfilters a single image (e.g. without interlacing this is called once, with Adam7 seven times)
  out must have enough bytes allocated already, in must have the scanlines + 1 filtertype byte per scanline
  w and h are image dimensions or dimensions of reduced image, bpp is bits per pixel
  in and out are allowed to be the same memory address (but aren't the same size since in has the extra filter bytes)
  */

  unsigned y;
  unsigned char* prevline = 0;

  /*bytewidth is used for filtering, is 1 when bpp < 8, number of bytes per pixel otherwise*/
  size_t bytewidth = (bpp + 7) / 8;
  size_t linebytes = (w * bpp + 7) / 8;

  for(y = 0; y < h; ++y)
  {
    size_t outindex = linebytes * y;
    size_t inindex = (1 + linebytes) * y; /*the extra filterbyte added to each row*/
    unsigned char filterType = in[inindex];

    CERROR_TRY_RETURN(unfilterScanline(&out[outindex], &in[inindex + 1], prevline, bytewidth, filterType, linebytes));

    prevline = &out[outindex];
  }

  return 0;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movl %ecx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movq $0x0, 0x28(%rsp)
movl 0x34(%rsp), %eax
addl $0x7, %eax
shrl $0x3, %eax
movl %eax, %eax
movq %rax, 0x20(%rsp)
movl 0x3c(%rsp), %eax
imull 0x34(%rsp), %eax
addl $0x7, %eax
shrl $0x3, %eax
movl %eax, %eax
movq %rax, 0x18(%rsp)
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x38(%rsp), %eax
jae 0x175e2
movq 0x18(%rsp), %rax
movl 0x30(%rsp), %ecx
imulq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movl 0x30(%rsp), %ecx
imulq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x7(%rsp)
movq 0x48(%rsp), %rdi
addq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x8(%rsp), %rax
addq $0x1, %rax
addq %rax, %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movb 0x7(%rsp), %al
movq 0x18(%rsp), %r9
movzbl %al, %r8d
callq 0x17ce0
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
je 0x175c3
movl (%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x175ea
movq 0x48(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x17533
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: removePaddingBits(unsigned char*, unsigned char const*, unsigned long, unsigned long, unsigned int)
static void removePaddingBits(unsigned char* out, const unsigned char* in,
                              size_t olinebits, size_t ilinebits, unsigned h)
{
  /*
  After filtering there are still padding bits if scanlines have non multiple of 8 bit amounts. They need
  to be removed (except at last scanline of (Adam7-reduced) image) before working with pure image buffers
  for the Adam7 code, the color convert code and the output to the user.
  in and out are allowed to be the same buffer, in may also be higher but still overlapping; in must
  have >= ilinebits*h bits, out must have >= olinebits*h bits, olinebits must be <= ilinebits
  also used to move bits after earlier such operations happened, e.g. in a sequence of reduced images from Adam7
  only useful if (ilinebits - olinebits) is a value in the range 1..7
  */
  unsigned y;
  size_t diff = ilinebits - olinebits;
  size_t ibp = 0, obp = 0; /*input and output bit pointers*/
  for(y = 0; y < h; ++y)
  {
    size_t x;
    for(x = 0; x < olinebits; ++x)
    {
      unsigned char bit = readBitFromReversedStream(&ibp, in);
      setBitOfReversedStream(&obp, out, bit);
    }
    ibp += diff;
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movq 0x38(%rsp), %rax
subq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x34(%rsp), %eax
jae 0x176b8
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x1769c
movq 0x48(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x15fe0
movb %al, 0xf(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x18(%rsp), %rdi
movzbl 0xf(%rsp), %edx
callq 0x182a0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x17659
movq 0x28(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x17646
addq $0x58, %rsp
retq
nopl (%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: paethPredictor(short, short, short)
static unsigned char paethPredictor(short a, short b, short c)
{
  short pa = abs(b - c);
  short pb = abs(a - c);
  short pc = abs(a + b - c - c);

  if(pc < pa && pc < pb) return (unsigned char)c;
  else if(pb < pa) return (unsigned char)b;
  else return (unsigned char)a;
}

// Assembly:
movw %dx, %ax
movw %si, %cx
movw %di, %dx
movw %dx, -0x4(%rsp)
movw %cx, -0x6(%rsp)
movw %ax, -0x8(%rsp)
movswl -0x6(%rsp), %eax
movswl -0x8(%rsp), %ecx
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movw %ax, -0xa(%rsp)
movswl -0x4(%rsp), %eax
movswl -0x8(%rsp), %ecx
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movw %ax, -0xc(%rsp)
movswl -0x4(%rsp), %eax
movswl -0x6(%rsp), %ecx
addl %ecx, %eax
movswl -0x8(%rsp), %ecx
subl %ecx, %eax
movswl -0x8(%rsp), %ecx
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movw %ax, -0xe(%rsp)
movswl -0xe(%rsp), %eax
movswl -0xa(%rsp), %ecx
cmpl %ecx, %eax
jge 0x18275
movswl -0xe(%rsp), %eax
movswl -0xc(%rsp), %ecx
cmpl %ecx, %eax
jge 0x18275
movw -0x8(%rsp), %ax
movb %al, -0x1(%rsp)
jmp 0x18297
movswl -0xc(%rsp), %eax
movswl -0xa(%rsp), %ecx
cmpl %ecx, %eax
jge 0x1828e
movw -0x6(%rsp), %ax
movb %al, -0x1(%rsp)
jmp 0x18297
movw -0x4(%rsp), %ax
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopl (%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: addPaddingBits(unsigned char*, unsigned char const*, unsigned long, unsigned long, unsigned int)
static void addPaddingBits(unsigned char* out, const unsigned char* in,
                           size_t olinebits, size_t ilinebits, unsigned h)
{
  /*The opposite of the removePaddingBits function
  olinebits must be >= ilinebits*/
  unsigned y;
  size_t diff = olinebits - ilinebits;
  size_t obp = 0, ibp = 0; /*bit pointers*/
  for(y = 0; y != h; ++y)
  {
    size_t x;
    for(x = 0; x < ilinebits; ++x)
    {
      unsigned char bit = readBitFromReversedStream(&ibp, in);
      setBitOfReversedStream(&obp, out, bit);
    }
    /*obp += diff; --> no, fill in some value in the padding bits too, to avoid
    "Use of uninitialised value of size ###" warning from valgrind*/
    for(x = 0; x != diff; ++x) setBitOfReversedStream(&obp, out, 0);
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movq 0x40(%rsp), %rax
subq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x34(%rsp), %eax
je 0x18488
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x18440
movq 0x48(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x15fe0
movb %al, 0xf(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movzbl 0xf(%rsp), %edx
callq 0x182a0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x183fd
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x28(%rsp), %rax
je 0x18476
movq 0x50(%rsp), %rsi
leaq 0x20(%rsp), %rdi
xorl %edx, %edx
callq 0x182a0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x18449
jmp 0x18478
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x183e6
addq $0x58, %rsp
retq
nopl (%rax)
// File: phillip-h[P]fractal-gen/lodepng.cpp
// Function: flog2(float)
static float flog2(float f)
{
  float result = 0;
  while(f > 32) { result += 4; f /= 16; }
  while(f > 2) { ++result; f /= 2; }
  return result + 1.442695f * (f * f * f / 3 - 3 * f * f / 2 + 3 * f - 1.83333f);
}

// Assembly:
vmovss %xmm0, -0x4(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovss %xmm0, -0x8(%rsp)
vmovss -0x4(%rsp), %xmm0
vmovss 0x2d02(%rip), %xmm1     # 0x1c850
vucomiss %xmm1, %xmm0
jbe 0x19b82
vmovss 0x2d0c(%rip), %xmm0     # 0x1c868
vaddss -0x8(%rsp), %xmm0, %xmm0
vmovss %xmm0, -0x8(%rsp)
vmovss -0x4(%rsp), %xmm0
vmovss 0x2cee(%rip), %xmm1     # 0x1c864
vdivss %xmm1, %xmm0, %xmm0
vmovss %xmm0, -0x4(%rsp)
jmp 0x19b40
jmp 0x19b84
vmovss -0x4(%rsp), %xmm0
vmovss 0x2cc2(%rip), %xmm1     # 0x1c854
vucomiss %xmm1, %xmm0
jbe 0x19bc6
vmovss 0x2cac(%rip), %xmm0     # 0x1c84c
vaddss -0x8(%rsp), %xmm0, %xmm0
vmovss %xmm0, -0x8(%rsp)
vmovss -0x4(%rsp), %xmm0
vmovss 0x2c9a(%rip), %xmm1     # 0x1c854
vdivss %xmm1, %xmm0, %xmm0
vmovss %xmm0, -0x4(%rsp)
jmp 0x19b84
vmovss -0x8(%rsp), %xmm2
vmovss -0x4(%rsp), %xmm0
vmulss -0x4(%rsp), %xmm0, %xmm0
vmulss -0x4(%rsp), %xmm0, %xmm0
vmovss 0x2c7a(%rip), %xmm1     # 0x1c860
vdivss %xmm1, %xmm0, %xmm0
vmovss 0x2c6e(%rip), %xmm1     # 0x1c860
vmulss -0x4(%rsp), %xmm1, %xmm1
vmulss -0x4(%rsp), %xmm1, %xmm1
vmovss 0x2c4e(%rip), %xmm3     # 0x1c854
vdivss %xmm3, %xmm1, %xmm1
vsubss %xmm1, %xmm0, %xmm3
vmovss -0x4(%rsp), %xmm1
vmovss 0x2c44(%rip), %xmm0     # 0x1c860
vfmadd213ss %xmm3, %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + xmm3
vmovss 0x2c33(%rip), %xmm1     # 0x1c85c
vsubss %xmm1, %xmm0, %xmm1
vmovss 0x2c23(%rip), %xmm0     # 0x1c858
vfmadd213ss %xmm2, %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + xmm2
retq
nopl (%rax,%rax)
// File: AlgoLab[P]bwt-lcp-parallel/decode_bwt.c
// Function: main
int main(int argc, char **argv) {

  if(argc != 2) {
    fprintf(stderr, "Usage: %s <bwtfile>\n", argv[0]);
    return 1;
  }

  FILE* pFile;
  int c;
  char c1, c2;

  pFile = fopen(argv[1], "r");
  if(pFile == NULL) {
    fprintf(stderr, "Error while opening the file\n");
    return 1;
  }
  else {
    while((c = fgetc(pFile)) != EOF) {
      c1 = codeToChar((c >> 4));
      printf("%c", c1);
      if((c & 0b1111) != 0b1111) {
        c2 = codeToChar((c & 0b1111));
        printf("%c", c2);
      }
    }
  }
  printf("\n");
  fclose(pFile);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x11e7
movq 0x2e35(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xe38(%rip), %rsi       # 0x200c
movb $0x0, %al
callq 0x1060
movl $0x1, -0x4(%rbp)
jmp 0x12b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe2b(%rip), %rsi       # 0x2021
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x122a
movq 0x2deb(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe0c(%rip), %rsi       # 0x2023
movb $0x0, %al
callq 0x1060
movl $0x1, -0x4(%rbp)
jmp 0x12b0
jmp 0x122c
movq -0x18(%rbp), %rdi
callq 0x1050
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0x1290
movl -0x1c(%rbp), %eax
sarl $0x4, %eax
movzbl %al, %edi
callq 0x1180
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %esi
leaq 0xde8(%rip), %rdi       # 0x2041
movb $0x0, %al
callq 0x1040
movl -0x1c(%rbp), %eax
andl $0xf, %eax
cmpl $0xf, %eax
je 0x128e
movl -0x1c(%rbp), %eax
andl $0xf, %eax
movzbl %al, %edi
callq 0x1180
movb %al, -0x1e(%rbp)
movsbl -0x1e(%rbp), %esi
leaq 0xdba(%rip), %rdi       # 0x2041
movb $0x0, %al
callq 0x1040
jmp 0x122c
jmp 0x1292
leaq 0xd86(%rip), %rdi       # 0x201f
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: sile[P]mphf/./generator.hh
// Function: MPHF::Generator::save(std::basic_ofstream<char, std::char_traits<char>>&) const
void save(std::ofstream& out) const {
      out.write(reinterpret_cast<const char*>(&key_count), sizeof(unsigned));
      out.write(reinterpret_cast<const char*>(&hash_value_limit), sizeof(unsigned));
      
      out.write(reinterpret_cast<const char*>(&h[0].param), sizeof(HashImpl::Param));
      out.write(reinterpret_cast<const char*>(&h[1].param), sizeof(HashImpl::Param));

      out.write(reinterpret_cast<const char*>(&rank_bv->bit_length), sizeof(unsigned));      
      out.write(reinterpret_cast<const char*>(rank_bv->blocks), sizeof(unsigned)*rank_bv->block_size()); 
      out.write(reinterpret_cast<const char*>(rank_bv->rank_index), sizeof(unsigned)*rank_bv->rank_index_size()); 

      out.write(reinterpret_cast<const char*>(&hash_assign_bv->bit_length), sizeof(unsigned));      
      out.write(reinterpret_cast<const char*>(hash_assign_bv->blocks), sizeof(unsigned)*hash_assign_bv->block_size()); 
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rsi
movl $0x4, %edx
callq 0x2220
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x2c, %rsi
movl $0x4, %edx
callq 0x2220
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x8(%rax), %rsi
movl $0x8, %edx
callq 0x2220
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x8(%rax), %rsi
addq $0x8, %rsi
movl $0x8, %edx
callq 0x2220
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rsi
movl $0x4, %edx
callq 0x2220
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq 0x18(%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x40(%rbp)
movq 0x18(%rax), %rdi
callq 0x5f60
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %eax, %eax
movl %eax, %edx
shlq $0x2, %rdx
callq 0x2220
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq 0x18(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rdi
callq 0x5ed0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl %eax, %eax
movl %eax, %edx
shlq $0x2, %rdx
callq 0x2220
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rsi
movl $0x4, %edx
callq 0x2220
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x20(%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq 0x20(%rax), %rdi
callq 0x5f60
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl %eax, %eax
movl %eax, %edx
shlq $0x2, %rdx
callq 0x2220
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: sile[P]mphf/./generator.hh
// Function: MPHF::Generator::~Generator()
~Generator() {
      delete [] h;
      delete [] graph;
      BitVector::free(rank_bv);
      BitVector::free(hash_assign_bv);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x328b
movq -0x10(%rbp), %rdi
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x32a6
movq -0x20(%rbp), %rdi
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5f80
jmp 0x32b5
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5f80
jmp 0x32c4
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x5130
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sile[P]mphf/./generator.hh
// Function: MPHF::Generator::count_line(char const*) const
unsigned count_line(const char* filepath) const {
      unsigned count=0;
      std::ifstream in(filepath);
      if(!in)
	return 0;
      
      std::string line;
      while(std::getline(in, line))
	count++;
      
      return count;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x228(%rbp), %rdi
movl $0x8, %edx
callq 0x22d0
movq -0x228(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x228(%rbp,%rax), %rdi
callq 0x20d0
movb %al, -0x259(%rbp)
jmp 0x332f
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0x333b
jmp 0x3368
movl $0x0, -0x4(%rbp)
movl $0x1, -0x238(%rbp)
jmp 0x3401
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
jmp 0x3419
leaq -0x258(%rbp), %rdi
callq 0x2240
leaq -0x228(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x2050
movq %rax, -0x268(%rbp)
jmp 0x3390
movq -0x268(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2200
movb %al, -0x269(%rbp)
jmp 0x33ae
movb -0x269(%rbp), %al
testb $0x1, %al
jne 0x33ba
jmp 0x33e5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3374
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x2120
jmp 0x3419
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x238(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x2120
leaq -0x228(%rbp), %rdi
callq 0x2060
movl -0x4(%rbp), %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
leaq -0x228(%rbp), %rdi
callq 0x2060
movq -0x230(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)