LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: addChunk_zTXt(ucvector*, char const*, char const*, LodePNGCompressSettings*)
static unsigned addChunk_zTXt(ucvector* out, const char* keyword, const char* textstring,
                              LodePNGCompressSettings* zlibsettings)
{
  unsigned error = 0;
  ucvector data, compressed;
  size_t i, textsize = strlen(textstring);

  ucvector_init(&data);
  ucvector_init(&compressed);
  for(i = 0; keyword[i] != 0; i++) ucvector_push_back(&data, (unsigned char)keyword[i]);
  ucvector_push_back(&data, 0); /*0 termination char*/
  ucvector_push_back(&data, 0); /*compression method: 0*/

  error = zlib_compress(&compressed.data, &compressed.size,
                        (unsigned char*)textstring, textsize, zlibsettings);
  if(!error)
  {
    for(i = 0; i < compressed.size; i++) ucvector_push_back(&data, compressed.data[i]);
    error = addChunk(out, "zTXt", data.data, data.size);
  }

  ucvector_cleanup(&compressed);
  ucvector_cleanup(&data);
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3100
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa980
leaq -0x58(%rbp), %rdi
callq 0xa980
movq $0x0, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq -0x60(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xb35a
movq -0x10(%rbp), %rax
movq -0x60(%rbp), %rcx
leaq -0x40(%rbp), %rdi
movzbl (%rax,%rcx), %esi
callq 0x4840
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0xb326
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x4840
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x4840
leaq -0x58(%rbp), %rdi
leaq -0x58(%rbp), %rsi
addq $0x8, %rsi
movq -0x18(%rbp), %rdx
movq -0x68(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0xc440
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xb3e6
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x50(%rbp), %rax
jae 0xb3cb
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
leaq -0x40(%rbp), %rdi
movzbl (%rax,%rcx), %esi
callq 0x4840
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0xb39e
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq 0x13f89(%rip), %rsi     # 0x1f367
callq 0x13550
movl %eax, -0x24(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x10950
leaq -0x40(%rbp), %rdi
callq 0x10950
movl -0x24(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: addChunk_tEXt(ucvector*, char const*, char const*)
static unsigned addChunk_tEXt(ucvector* out, const char* keyword, const char* textstring)
{
  unsigned error = 0;
  size_t i;
  ucvector text;
  ucvector_init(&text);
  for(i = 0; keyword[i] != 0; i++) ucvector_push_back(&text, (unsigned char)keyword[i]);
  ucvector_push_back(&text, 0);
  for(i = 0; textstring[i] != 0; i++) ucvector_push_back(&text, (unsigned char)textstring[i]);
  error = addChunk(out, "tEXt", text.data, text.size);
  ucvector_cleanup(&text);

  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa980
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xb470
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
leaq -0x40(%rbp), %rdi
movzbl (%rax,%rcx), %esi
callq 0x4840
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xb43c
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x4840
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xb4b7
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
leaq -0x40(%rbp), %rdi
movzbl (%rax,%rcx), %esi
callq 0x4840
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xb483
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq 0x13e98(%rip), %rsi     # 0x1f362
callq 0x13550
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x10950
movl -0x1c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: lodepng::compress(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char const*, unsigned long, LodePNGCompressSettings const&)
unsigned compress(std::vector<unsigned char>& out, const unsigned char* in, size_t insize,
                  const LodePNGCompressSettings& settings)
{
  unsigned char* buffer = 0;
  size_t buffersize = 0;
  unsigned error = zlib_compress(&buffer, &buffersize, in, insize, &settings);
  if(buffer)
  {
    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
    myfree(buffer);
  }
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc440
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xc433
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13840
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x13870
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x28(%rbp), %rcx
addq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rsi
callq 0x137a0
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4050
movl -0x34(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: lodepng::encode(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char const*, unsigned int, unsigned int, LodePNGColorType, unsigned int)
unsigned encode(std::vector<unsigned char>& out, const unsigned char* in, unsigned w, unsigned h,
                LodePNGColorType colortype, unsigned bitdepth)
{
  unsigned char* buffer;
  size_t buffersize;
  unsigned error = lodepng_encode_memory(&buffer, &buffersize, in, w, h, colortype, bitdepth);
  if(buffer)
  {
    out.insert(out.end(), &buffer[0], &buffer[buffersize]);
    myfree(buffer);
  }
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movl -0x20(%rbp), %eax
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl %eax, (%rsp)
callq 0xb760
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xcb22
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13840
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x13870
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x28(%rbp), %rcx
addq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rsi
callq 0x137a0
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4050
movl -0x34(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: uivector_resize(uivector*, unsigned long)
static unsigned uivector_resize(uivector* p, size_t size)
{
  if(size * sizeof(unsigned) > p->allocsize)
  {
    size_t newsize = size * sizeof(unsigned) * 2;
    void* data = myrealloc(p->data, newsize);
    if(data)
    {
      p->allocsize = newsize;
      p->data = (unsigned*)data;
      p->size = size;
    }
    else return 0;
  }
  else p->size = size;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0x2, %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0xcfac
movq -0x18(%rbp), %rax
shlq $0x2, %rax
shlq %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4ed0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xcfa1
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xcfaa
movl $0x0, -0x4(%rbp)
jmp 0xcfbf
jmp 0xcfb8
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: ucvector_resize(ucvector*, unsigned long)
static unsigned ucvector_resize(ucvector* p, size_t size)
{
  if(size * sizeof(unsigned char) > p->allocsize)
  {
    size_t newsize = size * sizeof(unsigned char) * 2;
    void* data = myrealloc(p->data, newsize);
    if(data)
    {
      p->allocsize = newsize;
      p->data = (unsigned char*)data;
      p->size = size;
    }
    else return 0; /*error: not enough memory*/
  }
  else p->size = size;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0x0, %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0xd7ac
movq -0x18(%rbp), %rax
shlq $0x0, %rax
shlq %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4ed0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xd7a1
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xd7aa
movl $0x0, -0x4(%rbp)
jmp 0xd7bf
jmp 0xd7b8
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: readBitsFromStream(unsigned long*, unsigned char const*, unsigned long)
static unsigned readBitsFromStream(size_t* bitpointer, const unsigned char* bitstream, size_t nbits)
{
  unsigned result = 0, i;
  for(i = 0; i < nbits; i++)
  {
    result += ((unsigned)READBIT(*bitpointer, bitstream)) << i;
    (*bitpointer)++;
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpq -0x18(%rbp), %rax
jae 0xdf4e
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x3, %rcx
movzbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
andq $0x7, %rcx
sarl %cl, %eax
andl $0x1, %eax
movl -0x20(%rbp), %ecx
shll %cl, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xdefe
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: generateFixedLitLenTree(HuffmanTree*)
static unsigned generateFixedLitLenTree(HuffmanTree* tree)
{
  unsigned i, error = 0;
  unsigned* bitlen = (unsigned*)mymalloc(NUM_DEFLATE_CODE_SYMBOLS * sizeof(unsigned));
  if(!bitlen) return 83; /*alloc fail*/

  /*288 possible codes: 0-255=literals, 256=endcode, 257-285=lengthcodes, 286-287=unused*/
  for(i =   0; i <= 143; i++) bitlen[i] = 8;
  for(i = 144; i <= 255; i++) bitlen[i] = 9;
  for(i = 256; i <= 279; i++) bitlen[i] = 7;
  for(i = 280; i <= 287; i++) bitlen[i] = 8;

  error = HuffmanTree_makeFromLengths(tree, bitlen, NUM_DEFLATE_CODE_SYMBOLS, 15);

  myfree(bitlen);
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x480, %edi            # imm = 0x480
callq 0x3840
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xdfd4
movl $0x53, -0x4(%rbp)
jmp 0xe0a1
movl $0x0, -0x14(%rbp)
cmpl $0x8f, -0x14(%rbp)
ja 0xdffd
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl $0x8, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xdfdb
movl $0x90, -0x14(%rbp)
cmpl $0xff, -0x14(%rbp)
ja 0xe026
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl $0x9, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe004
movl $0x100, -0x14(%rbp)     # imm = 0x100
cmpl $0x117, -0x14(%rbp)     # imm = 0x117
ja 0xe04f
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl $0x7, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe02d
movl $0x118, -0x14(%rbp)     # imm = 0x118
cmpl $0x11f, -0x14(%rbp)     # imm = 0x11F
ja 0xe078
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl $0x8, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe056
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x120, %edx            # imm = 0x120
movl $0xf, %ecx
callq 0xe140
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4050
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: generateFixedDistanceTree(HuffmanTree*)
static unsigned generateFixedDistanceTree(HuffmanTree* tree)
{
  unsigned i, error = 0;
  unsigned* bitlen = (unsigned*)mymalloc(NUM_DISTANCE_SYMBOLS * sizeof(unsigned));
  if(!bitlen) return 83; /*alloc fail*/

  /*there are 32 distance codes, but 30-31 are unused*/
  for(i = 0; i < NUM_DISTANCE_SYMBOLS; i++) bitlen[i] = 5;
  error = HuffmanTree_makeFromLengths(tree, bitlen, NUM_DISTANCE_SYMBOLS, 15);

  myfree(bitlen);
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x80, %edi
callq 0x3840
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe0e1
movl $0x53, -0x4(%rbp)
jmp 0xe130
movl $0x0, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jae 0xe107
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl $0x5, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe0e8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x20, %edx
movl $0xf, %ecx
callq 0xe140
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4050
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: HuffmanTree_makeFromLengths(HuffmanTree*, unsigned int const*, unsigned long, unsigned int)
static unsigned HuffmanTree_makeFromLengths(HuffmanTree* tree, const unsigned* bitlen,
                                            size_t numcodes, unsigned maxbitlen)
{
  unsigned i;
  tree->lengths = (unsigned*)mymalloc(numcodes * sizeof(unsigned));
  if(!tree->lengths) return 83; /*alloc fail*/
  for(i = 0; i < numcodes; i++) tree->lengths[i] = bitlen[i];
  tree->numcodes = (unsigned)numcodes; /*number of symbols*/
  tree->maxbitlen = maxbitlen;
  return HuffmanTree_makeFromLengths2(tree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rdi
shlq $0x2, %rdi
callq 0x3840
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xe183
movl $0x53, -0x4(%rbp)
jmp 0xe1d9
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpq -0x20(%rbp), %rax
jae 0xe1b6
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x28(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xe18a
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xe1f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: uivector_resizev(uivector*, unsigned long, unsigned int)
static unsigned uivector_resizev(uivector* p, size_t size, unsigned value)
{
  size_t oldsize = p->size, i;
  if(!uivector_resize(p, size)) return 0;
  for(i = oldsize; i < size; i++) p->data[i] = value;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xcf30
cmpl $0x0, %eax
jne 0xe3ea
movl $0x0, -0x4(%rbp)
jmp 0xe422
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xe41b
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xe3f2
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: hash_init(Hash*, unsigned int)
static unsigned hash_init(Hash* hash, unsigned windowsize)
{
  unsigned i;
  hash->head = (int*)mymalloc(sizeof(int) * HASH_NUM_VALUES);
  hash->val = (int*)mymalloc(sizeof(int) * windowsize);
  hash->chain = (unsigned short*)mymalloc(sizeof(unsigned short) * windowsize);
  hash->zeros = (unsigned short*)mymalloc(sizeof(unsigned short) * windowsize);

  if(!hash->head || !hash->val || !hash->chain || !hash->zeros) return 83; /*alloc fail*/

  /*initialize hash table*/
  for(i = 0; i < HASH_NUM_VALUES; i++) hash->head[i] = -1;
  for(i = 0; i < windowsize; i++) hash->val[i] = -1;
  for(i = 0; i < windowsize; i++) hash->chain[i] = i; /*same value as index indicates uninitialized*/

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x40000, %edi          # imm = 0x40000
callq 0x3840
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x3840
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %eax
movl %eax, %edi
shlq %rdi
callq 0x3840
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %eax
movl %eax, %edi
shlq %rdi
callq 0x3840
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xe867
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe867
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe867
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xe873
movl $0x53, -0x4(%rbp)
jmp 0xe901
movl $0x0, -0x18(%rbp)
cmpl $0x10000, -0x18(%rbp)   # imm = 0x10000
jae 0xe89f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x18(%rbp), %ecx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xe87a
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xe8cb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %ecx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xe8a6
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xe8fa
movl -0x18(%rbp), %eax
movw %ax, %dx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x18(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xe8d2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: hash_cleanup(Hash*)
static void hash_cleanup(Hash* hash)
{
  myfree(hash->head);
  myfree(hash->val);
  myfree(hash->chain);
  myfree(hash->zeros);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4050
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drummyfish[P]flowchart/src/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;
  size_t amount, i;
  if(pos >= size) return 0;
  amount = HASH_NUM_CHARACTERS;
  if(pos + amount >= size) amount = size - pos;
  for(i = 0; i < amount; i++) result ^= (data[pos + i] << (i * HASH_SHIFT));
  return result % HASH_NUM_VALUES;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x1003a
movl $0x0, -0x4(%rbp)
jmp 0x100a6
movq $0x3, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x1005c
movq -0x18(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x1009b
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
addq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x38(%rbp), %rcx
shlq %rcx
shll %cl, %eax
xorl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x10064
movl -0x24(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: updateHashChain(Hash*, unsigned long, int, unsigned int)
static void updateHashChain(Hash* hash,
                            size_t pos, int hashval, unsigned windowsize)
{
  unsigned wpos = pos % windowsize;
  hash->val[wpos] = hashval;
  if(hash->head[hashval] != -1)
  {
    hash->chain[wpos] = hash->head[hashval];
  }
  hash->head[hashval] = wpos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x10115
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopl (%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: HuffmanTree_makeFromFrequencies(HuffmanTree*, unsigned int const*, unsigned long, unsigned int)
static unsigned HuffmanTree_makeFromFrequencies(HuffmanTree* tree, const unsigned* frequencies,
                                                size_t numcodes, unsigned maxbitlen)
{
  unsigned error = 0;
  tree->maxbitlen = maxbitlen;
  tree->numcodes = (unsigned)numcodes; /*number of symbols*/
  tree->lengths = (unsigned*)myrealloc(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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
shlq $0x2, %rsi
callq 0x4ed0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x10479
movl $0x53, -0x4(%rbp)
jmp 0x104c3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x3130
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x38d0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x104bd
movq -0x10(%rbp), %rdi
callq 0xe1f0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: Crc32_make_crc_table()
static void Crc32_make_crc_table(void)
{
  unsigned c, k, n;
  for(n = 0; n < 256; n++)
  {
    c = n;
    for(k = 0; k < 8; k++)
    {
      if(c & 1) c = 0xedb88320L ^ (c >> 1);
      else c = c >> 1;
    }
    Crc32_crc_table[n] = c;
  }
  Crc32_crc_table_computed = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jae 0x1060d
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x8, -0x8(%rbp)
jae 0x105f0
movl -0x4(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x105db
movl -0x4(%rbp), %eax
shrl %eax
movl %eax, %eax
movabsq $0xedb88320, %rcx       # imm = 0xEDB88320
xorq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x105e3
movl -0x4(%rbp), %eax
shrl %eax
movl %eax, -0x4(%rbp)
jmp 0x105e5
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x105b1
movl -0x4(%rbp), %edx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x17ca1(%rip), %rax     # 0x282a0
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1059b
movl $0x1, 0x17c79(%rip)     # 0x28290
popq %rbp
retq
nopl (%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: string_resize(char**, unsigned long)
static unsigned string_resize(char** out, size_t size)
{
  char* data = (char*)myrealloc(*out, size + 1);
  if(data)
  {
    data[size] = 0; /*null termination char*/
    *out = data;
  }
  return data != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
callq 0x4ed0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x10696
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: drummyfish[P]flowchart/src/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)
{
  /*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 % (8 / bits);
  in &= (1 << bits) - 1; /*filter out any other bits of the input value*/
  in = in << (bits * (8 / bits - p - 1));
  if(p == 0) out[index * bits / 8] = in;
  else out[index * bits / 8] |= in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x8, %eax
xorl %edx, %edx
divl -0x14(%rbp)
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
andl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movl $0x8, %eax
xorl %edx, %edx
divl -0x14(%rbp)
movl %eax, %edx
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %edx
subl $0x1, %edx
imull %edx, %ecx
shll %cl, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x10862
movl -0x18(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %esi
imulq %rsi, %rcx
shrq $0x3, %rcx
movb %dl, (%rax,%rcx)
jmp 0x10881
movl -0x18(%rbp), %esi
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
imulq %rdx, %rcx
shrq $0x3, %rcx
movzbl (%rax,%rcx), %edx
orl %esi, %edx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drummyfish[P]flowchart/src/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)
{
  tree = &tree->next[r];
  if(tree->next == 0) return -1;
  tree = &tree->next[g];
  if(tree->next == 0) return -1;
  tree = &tree->next[b];
  if(tree->next == 0) return -1;
  tree = &tree->next[a];

  return tree->index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movb %sil, -0x11(%rbp)
movb %dl, -0x12(%rbp)
movb %cl, -0x13(%rbp)
movb %al, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl -0x11(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x108d1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10943
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl -0x12(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x108fa
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10943
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl -0x13(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x10923
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10943
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl -0x14(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: ucvector_resizev(ucvector*, unsigned long, unsigned char)
static unsigned ucvector_resizev(ucvector* p, size_t size, unsigned char value)
{
  size_t oldsize = p->size, i;
  if(!ucvector_resize(p, size)) return 0;
  for(i = oldsize; i < size; i++) p->data[i] = value;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd730
cmpl $0x0, %eax
jne 0x109dc
movl $0x0, -0x4(%rbp)
jmp 0x10a14
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x10a0d
movb -0x19(%rbp), %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x109e4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: color_profile_init(ColorProfile*, LodePNGColorMode*)
static void color_profile_init(ColorProfile* profile, LodePNGColorMode* mode)
{
  profile->sixteenbit = 0;
  profile->sixteenbit_done = mode->bitdepth == 16 ? 0 : 1;

  profile->colored = 0;
  profile->colored_done = lodepng_is_greyscale_type(mode) ? 1 : 0;

  profile->key = 0;
  profile->alpha = 0;
  profile->alpha_done = lodepng_can_have_alpha(mode) ? 0 : 1;

  profile->numcolors = 0;
  color_tree_init(&profile->tree, 1);
  profile->palette = (unsigned char*)mymalloc(1024);
  profile->maxnumcolors = 257;
  if(lodepng_get_bpp(mode) <= 8)
  {
    int bpp = lodepng_get_bpp(mode);
    profile->maxnumcolors = bpp == 1 ? 2 : (bpp == 2 ? 4 : (bpp == 4 ? 16 : 256));
  }
  profile->numcolors_done = 0;

  profile->greybits = 1;
  profile->greybits_done = lodepng_get_bpp(mode) == 1 ? 1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x10, %edx
cmovel %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x2(%rax)
movq -0x10(%rbp), %rdi
callq 0x5400
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x54d0
movl %eax, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xd(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl $0x1, %esi
callq 0x6630
movl $0x400, %edi            # imm = 0x400
callq 0x3840
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x101, 0x30(%rax)      # imm = 0x101
movq -0x10(%rbp), %rdi
callq 0x5320
cmpl $0x8, %eax
ja 0x11b8b
movq -0x10(%rbp), %rdi
callq 0x5320
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x11b55
movl $0x2, %eax
movl %eax, -0x18(%rbp)
jmp 0x11b81
cmpl $0x2, -0x14(%rbp)
jne 0x11b65
movl $0x4, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11b7b
movl -0x14(%rbp), %edx
movl $0x100, %eax            # imm = 0x100
movl $0x10, %ecx
cmpl $0x4, %edx
cmovel %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x34(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x10(%rbp), %rdi
callq 0x5320
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x1, %edx
cmovel %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drummyfish[P]flowchart/src/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x18(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x123cb
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x1238c
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x10780
movb %al, -0x49(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movzbl -0x49(%rbp), %edx
callq 0x11960
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x12353
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x123bb
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
callq 0x11960
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x12394
jmp 0x123bd
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1233f
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drummyfish[P]flowchart/src/image.cpp
// Function: image::load_bmp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool image::load_bmp(string filename)
  {
    this->delete_image();

    this->bmp_image = new bitmap_image(filename);

    if (!this->bmp_image->is_loaded())
      {
        this->delete_image();
        return false;
      }

    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x16130
movl $0x40, %edi
callq 0x3230
movq -0x38(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x16190
jmp 0x15a70
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x16220
testb $0x1, %al
jne 0x15ab2
movq -0x40(%rbp), %rdi
callq 0x16130
movb $0x0, -0x1(%rbp)
jmp 0x15ab6
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x40, %esi
callq 0x3240
jmp 0x15ac1
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3460
nopw (%rax,%rax)
// File: drummyfish[P]flowchart/src/image.cpp
// Function: image::load_png(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool image::load_png(string filename)
  {
    this->delete_image();

    unsigned char *pixel_data, r, g, b;
    unsigned int width, height, i, j, offset;

    if (lodepng_decode32_file(&pixel_data,&width,&height,filename.c_str()) != 0)
      return false;

    this->bmp_image = new bitmap_image(width,height);

    offset = 0;

    for (j = 0; j < height; j++)
      for (i = 0; i < width; i++)
        {
          r = pixel_data[offset];
          g = pixel_data[offset + 1];
          b = pixel_data[offset + 2];

          this->bmp_image->set_pixel(i,j,r,g,b);

          offset += 4;
        }

    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x16130
movq -0x50(%rbp), %rdi
callq 0x30e0
movq %rax, %rcx
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x95a0
cmpl $0x0, %eax
je 0x15b1c
movb $0x0, -0x1(%rbp)
jmp 0x15c0e
movl $0x40, %edi
callq 0x3230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movl -0x28(%rbp), %esi
movl -0x2c(%rbp), %edx
callq 0x16280
jmp 0x15b3d
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jae 0x15c0a
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x15bfa
movq -0x58(%rbp), %rax
movq -0x20(%rbp), %rcx
movl -0x38(%rbp), %edx
movb (%rcx,%rdx), %cl
movb %cl, -0x21(%rbp)
movq -0x20(%rbp), %rcx
movl -0x38(%rbp), %edx
addl $0x1, %edx
movl %edx, %edx
movb (%rcx,%rdx), %cl
movb %cl, -0x22(%rbp)
movq -0x20(%rbp), %rcx
movl -0x38(%rbp), %edx
addl $0x2, %edx
movl %edx, %edx
movb (%rcx,%rdx), %cl
movb %cl, -0x23(%rbp)
movq (%rax), %rdi
movl -0x30(%rbp), %esi
movl -0x34(%rbp), %edx
movb -0x21(%rbp), %cl
movb -0x22(%rbp), %al
movzbl %cl, %ecx
movzbl %al, %r8d
movzbl -0x23(%rbp), %r9d
callq 0x16340
movl -0x38(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x38(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x15b69
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0x40, %esi
callq 0x3240
jmp 0x15c19
jmp 0x15bfc
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x15b56
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: drummyfish[P]flowchart/src/image.cpp
// Function: image::load_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool image::load_file(string filename)
  {
    if (this->load_png(filename))
      return true;

    if (this->load_bmp(filename))
      return true;

    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x30f0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x15ad0
movb %al, -0x69(%rbp)
jmp 0x15c71
leaq -0x38(%rbp), %rdi
callq 0x3160
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x15c83
jmp 0x15ca0
movb $0x1, -0x1(%rbp)
jmp 0x15d05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
jmp 0x15d13
movq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x30f0
movq -0x80(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x15a30
movb %al, -0x89(%rbp)
jmp 0x15ccf
leaq -0x68(%rbp), %rdi
callq 0x3160
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x15ce4
jmp 0x15d01
movb $0x1, -0x1(%rbp)
jmp 0x15d05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3160
jmp 0x15d13
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3460
nopl (%rax)
// File: drummyfish[P]flowchart/src/image.cpp
// Function: image::save_png(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool image::save_png(string filename)
  {
    if (this->bmp_image == NULL)
      return false;

    unsigned char *pixel_data, r, g, b;
    unsigned int i, j, offset;
    bool result;

    pixel_data = (unsigned char *) malloc(this->bmp_image->width() * this->bmp_image->height() * 3);

    offset = 0;

    for (j = 0; j < this->bmp_image->width(); j++)
      for (i = 0; i < this->bmp_image->width(); i++)
        {
          this->bmp_image->get_pixel(i,j,r,g,b);

          pixel_data[offset] = r;
          pixel_data[offset + 1] = g;
          pixel_data[offset + 2] = b;

          offset += 3;
        }

    result = (lodepng_encode24_file(filename.c_str(),pixel_data,
      this->bmp_image->width(),this->bmp_image->height()) == 0);

    free(pixel_data);

    return result;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, (%rax)
jne 0x15d9b
movb $0x0, -0x1(%rbp)
jmp 0x15ef5
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x166c0
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, -0x4c(%rbp)
movq (%rax), %rdi
callq 0x166e0
movl %eax, %ecx
movl -0x4c(%rbp), %eax
imull %ecx, %eax
imull $0x3, %eax, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x3340
movq %rax, -0x20(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x40(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, -0x50(%rbp)
movq (%rax), %rdi
callq 0x166c0
movl %eax, %ecx
movl -0x50(%rbp), %eax
cmpl %ecx, %eax
jae 0x15e92
movl $0x0, -0x28(%rbp)
movq -0x40(%rbp), %rax
movl -0x28(%rbp), %ecx
movl %ecx, -0x54(%rbp)
movq (%rax), %rdi
callq 0x166c0
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jae 0x15e82
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movl -0x28(%rbp), %esi
movl -0x2c(%rbp), %edx
leaq -0x21(%rbp), %rcx
leaq -0x22(%rbp), %r8
leaq -0x23(%rbp), %r9
callq 0x16700
movb -0x21(%rbp), %dl
movq -0x20(%rbp), %rax
movl -0x30(%rbp), %ecx
movb %dl, (%rax,%rcx)
movb -0x22(%rbp), %dl
movq -0x20(%rbp), %rax
movl -0x30(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movb -0x23(%rbp), %dl
movq -0x20(%rbp), %rax
movl -0x30(%rbp), %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x30(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x30(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x15e04
jmp 0x15e84
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x15dde
movq -0x48(%rbp), %rdi
callq 0x30e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x68(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq (%rax), %rdi
callq 0x166c0
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, -0x58(%rbp)
movq (%rax), %rdi
callq 0x166e0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl -0x58(%rbp), %edx
movl %eax, %ecx
callq 0xb9a0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x20(%rbp), %rdi
callq 0x32e0
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
// File: drummyfish[P]flowchart/src/image.cpp
// Function: image::get_pixel(unsigned int, unsigned int, unsigned char&, unsigned char&, unsigned char&)
void image::get_pixel(const unsigned int x, const unsigned int y,
  unsigned char &red, unsigned char &green, unsigned char &blue)
  {
    if (this->bmp_image != NULL && x < this->bmp_image->width() && y < this->bmp_image->height())
      {
        this->bmp_image->get_pixel(x,y,red,green,blue);
      }
    else
      {
        red = 255;
        green = 255;
        blue = 255;
      }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, (%rax)
je 0x16002
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, -0x34(%rbp)
movq (%rax), %rdi
callq 0x166c0
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jae 0x16002
movq -0x30(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, -0x38(%rbp)
movq (%rax), %rdi
callq 0x166e0
movl %eax, %ecx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jae 0x16002
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
callq 0x16700
jmp 0x16017
movq -0x18(%rbp), %rax
movb $-0x1, (%rax)
movq -0x20(%rbp), %rax
movb $-0x1, (%rax)
movq -0x28(%rbp), %rax
movb $-0x1, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: drummyfish[P]flowchart/src/image.cpp
// Function: image::set_pixel(unsigned int, unsigned int, char const&, char const&, char const&)
void image::set_pixel(const unsigned int x, const unsigned int y,
  const char &red, const char &green, const char &blue)
  {
    if (x >= this->bmp_image->width() || y >= this->bmp_image->height())
      return;

    if (this->bmp_image != NULL)
      this->bmp_image->set_pixel(x,y,red,green,blue);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, -0x2c(%rbp)
movq (%rax), %rdi
callq 0x166c0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jae 0x16078
movq -0x38(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, -0x3c(%rbp)
movq (%rax), %rdi
callq 0x166e0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jb 0x1607a
jmp 0x160b2
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
je 0x160b2
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x20(%rbp), %rax
movb (%rax), %r8b
movq -0x28(%rbp), %rax
movzbl %cl, %ecx
movzbl %r8b, %r8d
movzbl (%rax), %r9d
callq 0x16340
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: drummyfish[P]flowchart/src/bitmap_image.hpp
// Function: bitmap_image::is_loaded()
inline bool is_loaded()
   {
      return !((data_         == 0) ||
             (length_       == 0) ||
             (width_        == 0) ||
             (height_       == 0) ||
             (row_increment_== 0));
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, 0x20(%rcx)
movb %al, -0x9(%rbp)
je 0x16277
movq -0x18(%rbp), %rcx
movb $0x1, %al
cmpl $0x0, 0x2c(%rcx)
movb %al, -0x9(%rbp)
je 0x16277
movq -0x18(%rbp), %rcx
movb $0x1, %al
cmpl $0x0, 0x30(%rcx)
movb %al, -0x9(%rbp)
je 0x16277
movq -0x18(%rbp), %rcx
movb $0x1, %al
cmpl $0x0, 0x34(%rcx)
movb %al, -0x9(%rbp)
je 0x16277
movq -0x18(%rbp), %rax
cmpl $0x0, 0x38(%rax)
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
popq %rbp
retq