LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: fieryzig[P]GameServer/Common/Client/Client.h
// Function: fieryzig::Client::buffer_t::copyFromHead(void*, int)
inline void copyFromHead(void* dest, int sz) {
            if (head + sz <= BUFSIZE)
                memmove(dest, buffer+head, sz);
            else {
                memmove(dest, buffer+head, BUFSIZE - head);
                memmove((char*)dest+(BUFSIZE-head), buffer, sz-BUFSIZE+head);
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x1004(%rax), %eax
addl -0x14(%rbp), %eax
cmpl $0x1000, %eax           # imm = 0x1000
jg 0xce98
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
movslq 0x1004(%rsi), %rax
addq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x23a0
jmp 0xceee
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdi
movslq 0x1004(%rcx), %rax
movq %rcx, %rsi
addq %rax, %rsi
movl $0x1000, %eax           # imm = 0x1000
subl 0x1004(%rcx), %eax
movslq %eax, %rdx
callq 0x23a0
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl $0x1000, %eax           # imm = 0x1000
subl 0x1004(%rsi), %eax
cltq
addq %rax, %rdi
movl -0x14(%rbp), %eax
subl $0x1000, %eax           # imm = 0x1000
addl 0x1004(%rsi), %eax
movslq %eax, %rdx
callq 0x23a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: fieryzig[P]GameServer/Common/Client/Client.h
// Function: fieryzig::Client::buffer_t::copyIntoTail(void const*, int)
inline void copyIntoTail(const void* src, int sz) {
            if (tail+sz <= BUFSIZE)
                memmove(getTail(), src, sz);
            else {
                memmove(getTail(), src, BUFSIZE-tail);
                memmove(buffer, (char*)src+(BUFSIZE-tail), sz-BUFSIZE+tail);
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x1008(%rax), %eax
addl -0x14(%rbp), %eax
cmpl $0x1000, %eax           # imm = 0x1000
jg 0xcf46
movq -0x20(%rbp), %rdi
callq 0xccc0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x23a0
jmp 0xcf9b
movq -0x20(%rbp), %rdi
callq 0xccc0
movq -0x20(%rbp), %rcx
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x1000, %eax           # imm = 0x1000
subl 0x1008(%rcx), %eax
movslq %eax, %rdx
callq 0x23a0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1000, %eax           # imm = 0x1000
subl 0x1008(%rdi), %eax
cltq
addq %rax, %rsi
movl -0x14(%rbp), %eax
subl $0x1000, %eax           # imm = 0x1000
addl 0x1008(%rdi), %eax
movslq %eax, %rdx
callq 0x23a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tetsuok[P]kernel-pa/kernel_pa_classify.cc
// Function: kernel::(anonymous namespace)::Result::Add(short, short)
bool Add(short y, short predict) {
    if      (y ==  1 && predict ==  1) { results_[0]++; }
    else if (y == -1 && predict == -1) { results_[1]++; }
    else if (y == -1 && predict ==  1) { ++mistake_; results_[2]++; }
    else if (y ==  1 && predict == -1) { ++mistake_; results_[3]++; }
    else                               { return false;  }

    ++num_instance_;

    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x10(%rbp)
movw %cx, -0x12(%rbp)
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movswl -0x12(%rbp), %eax
cmpl $0x1, %eax
jne 0x2d02
movswl -0x14(%rbp), %eax
cmpl $0x1, %eax
jne 0x2d02
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x2d83
movswl -0x12(%rbp), %eax
cmpl $-0x1, %eax
jne 0x2d23
movswl -0x14(%rbp), %eax
cmpl $-0x1, %eax
jne 0x2d23
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x2d81
movswl -0x12(%rbp), %eax
cmpl $-0x1, %eax
jne 0x2d4d
movswl -0x14(%rbp), %eax
cmpl $0x1, %eax
jne 0x2d4d
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x2d7f
movswl -0x12(%rbp), %eax
cmpl $0x1, %eax
jne 0x2d77
movswl -0x14(%rbp), %eax
cmpl $-0x1, %eax
jne 0x2d77
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x2d7d
movb $0x0, -0x1(%rbp)
jmp 0x2d92
jmp 0x2d7f
jmp 0x2d81
jmp 0x2d83
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: tetsuok[P]kernel-pa/kernel_pa_classify.cc
// Function: kernel::(anonymous namespace)::Result::Show() const
void Show() const {
    std::printf("Accuracy %.3f%% (%d/%d)\n(Answer, Predict): "
                "(t,p):%d (t,n):%d (f,p):%d (f,n):%d\n",
                CalcAccuracy(), num_instance_ - mistake_, num_instance_,
                results_[0], results_[1], results_[2], results_[3]);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2df0
movq -0x10(%rbp), %rax
movl (%rax), %esi
subl 0x4(%rax), %esi
movl (%rax), %edx
movl 0x8(%rax), %ecx
movl 0xc(%rax), %r8d
movl 0x10(%rax), %r9d
movl 0x14(%rax), %eax
leaq 0x82e5(%rip), %rdi      # 0xb0be
movl %eax, (%rsp)
movb $0x1, %al
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: tetsuok[P]kernel-pa/./learner.h
// Function: kernel::Learner::Margin(std::vector<std::pair<unsigned int, float>, std::allocator<std::pair<unsigned int, float>>> const&)
float Margin(const fv& x) {
    margin_.assign(margin_.size(), 0.0f);

    for (const auto& p : x) {
      const unsigned int id = p.first;
      const float v = p.second;
      if (id >= sv_index_.size()) {
        continue;
      }
      const fv& s = sv_index_[id];
      for (const auto& p2 : s) {
        margin_[p2.first] += p2.second * v;
      }
    }

    return Polynomial();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
addq $0x40, %rax
movq %rax, -0x70(%rbp)
addq $0x40, %rdi
callq 0x3220
movq -0x70(%rbp), %rdi
movq %rax, %rsi
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
leaq -0x14(%rbp), %rdx
callq 0x31f0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3240
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3270
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x32a0
testb $0x1, %al
jne 0x30cf
jmp 0x31de
leaq -0x28(%rbp), %rdi
callq 0x32e0
movq -0x78(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x40(%rbp)
movl -0x3c(%rbp), %eax
movq %rax, -0x80(%rbp)
addq $0x28, %rdi
callq 0x3300
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jb 0x3118
jmp 0x31d0
movq -0x78(%rbp), %rdi
addq $0x28, %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0x3330
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3240
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3270
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x32a0
testb $0x1, %al
jne 0x3163
jmp 0x31ce
leaq -0x58(%rbp), %rdi
callq 0x32e0
movq -0x78(%rbp), %rdi
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x88(%rbp)
movss -0x40(%rbp), %xmm0
movss %xmm0, -0x84(%rbp)
addq $0x40, %rdi
movq -0x68(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x3350
movss -0x88(%rbp), %xmm0
movss -0x84(%rbp), %xmm2
movss (%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax)
leaq -0x58(%rbp), %rdi
callq 0x3370
jmp 0x3150
jmp 0x31d0
leaq -0x28(%rbp), %rdi
callq 0x3370
jmp 0x30b9
movq -0x78(%rbp), %rdi
callq 0x55e0
addq $0x90, %rsp
popq %rbp
retq
// File: tetsuok[P]kernel-pa/./learner.h
// Function: kernel::Learner::UpdateIndex(std::vector<std::pair<unsigned int, float>, std::allocator<std::pair<unsigned int, float>>> const&, unsigned int)
void UpdateIndex(const fv& x, unsigned int sv_id) {
    for (const auto& p : x) {
      const unsigned int id = p.first;
      if (sv_index_.size() <= id) {
        sv_index_.resize(id + 1);
      }
      sv_index_[id].push_back(std::make_pair(sv_id, p.second));
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3240
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3270
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x32a0
testb $0x1, %al
jne 0x5cc3
jmp 0x5d4b
leaq -0x28(%rbp), %rdi
callq 0x32e0
movq -0x50(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
addq $0x28, %rdi
callq 0x3300
movl -0x3c(%rbp), %ecx
cmpq %rcx, %rax
ja 0x5d05
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5f00
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0x3330
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rsi
addq $0x4, %rsi
leaq -0x14(%rbp), %rdi
callq 0x6c10
movq -0x58(%rbp), %rdi
movq %rax, -0x44(%rbp)
leaq -0x44(%rbp), %rsi
callq 0x6be0
leaq -0x28(%rbp), %rdi
callq 0x3370
jmp 0x5cad
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tetsuok[P]kernel-pa/./common.h
// Function: kernel::L2Norm(std::vector<std::pair<unsigned int, float>, std::allocator<std::pair<unsigned int, float>>> const&)
inline float L2Norm(const fv& x) {
  float r = 1.0f; // bias
  for (const auto& p : x) {
    r += p.second * p.second;
  }
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movss 0x45fc(%rip), %xmm0     # 0xb110
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3240
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3270
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x32a0
testb $0x1, %al
jne 0x6b4e
jmp 0x6b8a
leaq -0x20(%rbp), %rdi
callq 0x32e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x30(%rbp), %rax
movss 0x4(%rax), %xmm2
movss -0xc(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3370
jmp 0x6b3b
movss -0xc(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: append_symbol_coins(Coin*, unsigned int const*, unsigned int, unsigned long)
static unsigned append_symbol_coins(Coin* coins, const unsigned* frequencies, unsigned numcodes, size_t sum)
{
  unsigned i;
  unsigned j = 0; /*index of present symbols*/
  for(i = 0; i < numcodes; i++)
  {
    if(frequencies[i] != 0) /*only include symbols that are present*/
    {
      coins[j].weight = frequencies[i] / (float)sum;
      uivector_push_back(&coins[j].symbols, i);
      j++;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x3dbf
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
cmpl $0x0, (%rax,%rcx,4)
je 0x3daf
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movl (%rax,%rcx,4), %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x30(%rbp)
testq %rax, %rax
movss %xmm0, -0x2c(%rbp)
js 0x3d6f
movss -0x30(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x34(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
divss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movss %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rdi
movl -0x28(%rbp), %eax
shlq $0x5, %rax
addq %rax, %rdi
movl -0x24(%rbp), %esi
callq 0xced0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3db1
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3d05
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: sort_coins(Coin*, unsigned long)
static void sort_coins(Coin* data, size_t amount)
{
  size_t gap = amount;
  unsigned char swapped = 0;
  while((gap > 1) || swapped)
  {
    size_t i;
    gap = (gap * 10) / 13; /*shrink factor 1.3*/
    if(gap == 9 || gap == 10) gap = 11; /*combsort11*/
    if(gap < 1) gap = 1;
    swapped = 0;
    for(i = 0; i < amount - gap; i++)
    {
      size_t j = i + gap;
      if(data[j].weight < data[i].weight)
      {
        float temp = data[j].weight; data[j].weight = data[i].weight; data[i].weight = temp;
        uivector_swap(&data[i].symbols, &data[j].symbols);
        swapped = 1;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movb $0x1, %al
cmpq $0x1, -0x18(%rbp)
movb %al, -0x35(%rbp)
ja 0x3e02
cmpb $0x0, -0x19(%rbp)
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x3e0e
jmp 0x3f3d
imulq $0xa, -0x18(%rbp), %rax
movl $0xd, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x18(%rbp)
cmpq $0x9, -0x18(%rbp)
je 0x3e2f
cmpq $0xa, -0x18(%rbp)
jne 0x3e37
movq $0xb, -0x18(%rbp)
cmpq $0x1, -0x18(%rbp)
jae 0x3e46
movq $0x1, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jae 0x3f38
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movss 0x18(%rax), %xmm1
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movss 0x18(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x3f25
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movss 0x18(%rax), %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movss 0x18(%rax), %xmm0
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movss %xmm0, 0x18(%rax)
movss -0x34(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movss %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0xcfd0
movb $0x1, -0x19(%rbp)
jmp 0x3f27
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3e52
jmp 0x3dec
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: lodepng_inflatev(ucvector*, unsigned char const*, unsigned long, LodePNGDecompressSettings const*)
static unsigned lodepng_inflatev(ucvector* out,
                                 const unsigned char* in, size_t insize,
                                 const LodePNGDecompressSettings* settings)
{
  /*bit pointer in the "in" data, current byte is bp >> 3, current bit is bp & 0x7 (from lsb to msb of the byte)*/
  size_t bp = 0;
  unsigned BFINAL = 0;
  size_t pos = 0; /*byte position in the out buffer*/

  unsigned error = 0;

  (void)settings;

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

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

    if(error) return error;
  }

  /*Only now we know the true size of out, resize it to that*/
  if(!ucvector_resize(out, pos)) error = 83; /*alloc fail*/

  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
cmpl $0x0, -0x34(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4168
jmp 0x4232
movq -0x30(%rbp), %rax
addq $0x2, %rax
movq -0x20(%rbp), %rcx
shlq $0x3, %rcx
cmpq %rcx, %rax
jb 0x4189
movl $0x34, -0x4(%rbp)
jmp 0x4251
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xd150
movzbl %al, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xd150
movzbl %al, %eax
shll $0x0, %eax
movl %eax, -0x48(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xd150
movzbl %al, %eax
shll %eax
addl -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
cmpl $0x3, -0x48(%rbp)
jne 0x41d9
movl $0x14, -0x4(%rbp)
jmp 0x4251
cmpl $0x0, -0x48(%rbp)
jne 0x41fd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %r8
leaq -0x30(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0xd1a0
movl %eax, -0x44(%rbp)
jmp 0x421d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %r8
movl -0x48(%rbp), %r9d
leaq -0x30(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0xd350
movl %eax, -0x44(%rbp)
jmp 0x421f
cmpl $0x0, -0x44(%rbp)
je 0x422d
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4251
jmp 0x4156
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xd730
cmpl $0x0, %eax
jne 0x424b
movl $0x53, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: lodepng_compress_settings_init(LodePNGCompressSettings*)
void lodepng_compress_settings_init(LodePNGCompressSettings* settings)
{
  /*compress with dynamic huffman tree (not in the mathematical sense, just not the predefined one)*/
  settings->btype = 2;
  settings->use_lz77 = 1;
  settings->windowsize = DEFAULT_WINDOWSIZE;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x800, 0x8(%rax)       # imm = 0x800
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
popq %rbp
retq
nop
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: Crc32_update_crc(unsigned char const*, unsigned int, unsigned long)
static unsigned Crc32_update_crc(const unsigned char* buf, unsigned crc, size_t len)
{
  unsigned c = crc;
  size_t n;

  if(!Crc32_crc_table_computed) Crc32_make_crc_table();
  for(n = 0; n < len; n++)
  {
    c = Crc32_crc_table[(c ^ buf[n]) & 0xff] ^ (c >> 8);
  }
  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, 0x23840(%rip)     # 0x28290
jne 0x4a57
callq 0x10590
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x4aa6
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x23816(%rip), %rax     # 0x282a0
movl (%rax,%rcx,4), %eax
movl -0x1c(%rbp), %ecx
shrl $0x8, %ecx
xorl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4a5f
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: lodepng_chunk_append(unsigned char**, unsigned long*, unsigned char const*)
unsigned lodepng_chunk_append(unsigned char** out, size_t* outlength, const unsigned char* chunk)
{
  unsigned i;
  unsigned total_chunk_length = lodepng_chunk_length(chunk) + 12;
  unsigned char *chunk_start, *new_buffer;
  size_t new_length = (*outlength) + total_chunk_length;
  if(new_length < total_chunk_length || new_length < (*outlength)) return 77; /*integer overflow happened*/

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

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

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4ab0
addl $0xc, %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x28(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl -0x28(%rbp), %ecx
cmpq %rcx, %rax
jb 0x4e2d
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x4e39
movl $0x4d, -0x4(%rbp)
jmp 0x4ec0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0x4ed0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x4e5d
movl $0x53, -0x4(%rbp)
jmp 0x4ec0
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movl -0x28(%rbp), %edx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x4eb9
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4e92
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: lodepng_chunk_create(unsigned char**, unsigned long*, unsigned int, char const*, unsigned char const*)
unsigned lodepng_chunk_create(unsigned char** out, size_t* outlength, unsigned length,
                              const char* type, const unsigned char* data)
{
  unsigned i;
  unsigned char *chunk, *new_buffer;
  size_t new_length = (*outlength) + length + 12;
  if(new_length < length + 12 || new_length < (*outlength)) return 77; /*integer overflow happened*/
  new_buffer = (unsigned char*)myrealloc(*out, new_length);
  if(!new_buffer) return 83; /*alloc fail*/
  (*out) = new_buffer;
  (*outlength) = new_length;
  chunk = &(*out)[(*outlength) - length - 12];

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

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

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

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

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
addq %rcx, %rax
addq $0xc, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xc, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jb 0x4f4e
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x4f5a
movl $0x4d, -0x4(%rbp)
jmp 0x503c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x50(%rbp), %rsi
callq 0x4ed0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x4f81
movl $0x53, -0x4(%rbp)
jmp 0x503c
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movl -0x1c(%rbp), %edx
subq %rdx, %rcx
subq $0xc, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x4d20
movq -0x28(%rbp), %rax
movb (%rax), %cl
movq -0x40(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x28(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x40(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x28(%rbp), %rax
movb 0x2(%rax), %cl
movq -0x40(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x28(%rbp), %rax
movb 0x3(%rax), %cl
movq -0x40(%rbp), %rax
movb %cl, 0x7(%rax)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x502c
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x40(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x8, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5000
movq -0x40(%rbp), %rdi
callq 0x4cd0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: lodepng_color_mode_copy(LodePNGColorMode*, LodePNGColorMode const*)
unsigned lodepng_color_mode_copy(LodePNGColorMode* dest, const LodePNGColorMode* source)
{
  size_t i;
  lodepng_color_mode_cleanup(dest);
  *dest = *source;
  if(source->palette)
  {
    dest->palette = (unsigned char*)mymalloc(source->palettesize * 4);
    if(!dest->palette && source->palettesize) return 83; /*alloc fail*/
    for(i = 0; i < source->palettesize * 4; i++) dest->palette[i] = source->palette[i];
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x50c0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl $0x28, %edx
callq 0x31c0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x51e0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
shlq $0x2, %rdi
callq 0x3840
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5195
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5195
movl $0x53, -0x4(%rbp)
jmp 0x51e7
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
cmpq %rcx, %rax
jae 0x51de
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x519d
jmp 0x51e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: lodepng_palette_add(LodePNGColorMode*, unsigned char, unsigned char, unsigned char, unsigned char)
unsigned lodepng_palette_add(LodePNGColorMode* info,
                             unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
  unsigned char* data;
  /*the same resize technique as C++ std::vectors is used, and here it's made so that for a palette with
  the max of 256 colors, it'll have the exact alloc size*/
  if(!(info->palettesize & (info->palettesize - 1))) /*if palettesize is 0 or a power of two*/
  {
    /*allocated data must be at least 4* palettesize (for 4 color bytes)*/
    size_t alloc_size = info->palettesize == 0 ? 4 : info->palettesize * 4 * 2;
    data = (unsigned char*)myrealloc(info->palette, alloc_size);
    if(!data) return 83; /*alloc fail*/
    else info->palette = data;
  }
  info->palette[4 * info->palettesize + 0] = r;
  info->palette[4 * info->palettesize + 1] = g;
  info->palette[4 * info->palettesize + 2] = b;
  info->palette[4 * info->palettesize + 3] = a;
  info->palettesize++;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
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 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x5290
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x523f
movl $0x4, %eax
movq %rax, -0x30(%rbp)
jmp 0x5252
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
shlq $0x2, %rax
shlq %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x4ed0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5282
movl $0x53, -0x4(%rbp)
jmp 0x5312
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x5290
movb -0x11(%rbp), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
movb %dl, (%rax,%rcx)
movb -0x12(%rbp), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
movb %dl, 0x1(%rax,%rcx)
movb -0x13(%rbp), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
movb %dl, 0x2(%rax,%rcx)
movb -0x14(%rbp), %dl
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
movb %dl, 0x3(%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: lodepng_has_palette_alpha(LodePNGColorMode const*)
unsigned lodepng_has_palette_alpha(const LodePNGColorMode* info)
{
  size_t i;
  for(i = 0; i < info->palettesize; i++)
  {
    if(info->palette[i * 4 + 3] < 255) return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x54c3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x2, %rcx
movzbl 0x3(%rax,%rcx), %eax
cmpl $0xff, %eax
jge 0x54b3
movl $0x1, -0x4(%rbp)
jmp 0x54ca
jmp 0x54b5
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5480
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: LodePNGText_cleanup(LodePNGInfo*)
static void LodePNGText_cleanup(LodePNGInfo* info)
{
  size_t i;
  for(i = 0; i < info->text_num; i++)
  {
    string_cleanup(&info->text_keys[i]);
    string_cleanup(&info->text_strings[i]);
  }
  myfree(info->text_keys);
  myfree(info->text_strings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x5620
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x10620
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x10620
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x55d4
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x4050
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x4050
addq $0x10, %rsp
popq %rbp
retq
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: lodepng_add_text(LodePNGInfo*, char const*, char const*)
unsigned lodepng_add_text(LodePNGInfo* info, const char* key, const char* str)
{
  char** new_keys = (char**)(myrealloc(info->text_keys, sizeof(char*) * (info->text_num + 1)));
  char** new_strings = (char**)(myrealloc(info->text_strings, sizeof(char*) * (info->text_num + 1)));
  if(!new_keys || !new_strings)
  {
    myfree(new_keys);
    myfree(new_strings);
    return 83; /*alloc fail*/
  }

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

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

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

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x4ed0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x4ed0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x56a4
cmpq $0x0, -0x30(%rbp)
jne 0x56c2
movq -0x28(%rbp), %rdi
callq 0x4050
movq -0x30(%rbp), %rdi
callq 0x4050
movl $0x53, -0x4(%rbp)
jmp 0x5779
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x5790
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x57c0
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x5790
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x57c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: string_set(char**, char const*)
static void string_set(char** out, const char* in)
{
  size_t insize = strlen(in), i = 0;
  if(string_resize(out, insize))
  {
    for(i = 0; i < insize; i++)
    {
      (*out)[i] = in[i];
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3100
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10650
cmpl $0x0, %eax
je 0x5832
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5830
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x57ff
jmp 0x5832
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: LodePNGIText_cleanup(LodePNGInfo*)
static void LodePNGIText_cleanup(LodePNGInfo* info)
{
  size_t i;
  for(i = 0; i < info->itext_num; i++)
  {
    string_cleanup(&info->itext_keys[i]);
    string_cleanup(&info->itext_langtags[i]);
    string_cleanup(&info->itext_transkeys[i]);
    string_cleanup(&info->itext_strings[i]);
  }
  myfree(info->itext_keys);
  myfree(info->itext_langtags);
  myfree(info->itext_transkeys);
  myfree(info->itext_strings);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x60(%rcx), %rax
jae 0x58f3
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x10620
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x10620
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x10620
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x10620
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5874
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x4050
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x4050
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x4050
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x4050
addq $0x10, %rsp
popq %rbp
retq
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: LodePNGText_copy(LodePNGInfo*, LodePNGInfo const*)
static unsigned LodePNGText_copy(LodePNGInfo* dest, const LodePNGInfo* source)
{
  size_t i = 0;
  dest->text_keys = 0;
  dest->text_strings = 0;
  dest->text_num = 0;
  for(i = 0; i < source->text_num; i++)
  {
    CERROR_TRY_RETURN(lodepng_add_text(dest, source->text_keys[i], source->text_strings[i]));
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x5f1c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x5640
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x5f0c
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5f23
jmp 0x5f0e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5ec4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: LodePNGIText_copy(LodePNGInfo*, LodePNGInfo const*)
static unsigned LodePNGIText_copy(LodePNGInfo* dest, const LodePNGInfo* source)
{
  size_t i = 0;
  dest->itext_keys = 0;
  dest->itext_langtags = 0;
  dest->itext_transkeys = 0;
  dest->itext_strings = 0;
  dest->itext_num = 0;
  for(i = 0; i < source->itext_num; i++)
  {
    CERROR_TRY_RETURN(lodepng_add_itext(dest, source->itext_keys[i], source->itext_langtags[i],
                                        source->itext_transkeys[i], source->itext_strings[i]));
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x60(%rcx), %rax
jae 0x600a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x20(%rbp), %r8
movq (%rax,%r8,8), %r8
callq 0x5930
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x5ffa
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6011
jmp 0x5ffc
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5f8f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: LodePNGUnknownChunks_copy(LodePNGInfo*, LodePNGInfo const*)
static unsigned LodePNGUnknownChunks_copy(LodePNGInfo* dest, const LodePNGInfo* src)
{
  unsigned i;

  LodePNGUnknownChunks_cleanup(dest);

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

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5d60
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jae 0x6122
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq 0xd0(%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq %rdx, 0xd0(%rax,%rcx,8)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq 0xd0(%rax,%rcx,8), %rdi
callq 0x3840
movq %rax, %rdx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq %rdx, 0xb8(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq $0x0, 0xb8(%rax,%rcx,8)
jne 0x60bb
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq $0x0, 0xd0(%rax,%rcx,8)
je 0x60bb
movl $0x53, -0x4(%rbp)
jmp 0x6129
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %edx
cmpq 0xd0(%rcx,%rdx,8), %rax
jae 0x6112
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq 0xb8(%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq 0xb8(%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x60c3
jmp 0x6114
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: lodepng_color_mode_equal(LodePNGColorMode const*, LodePNGColorMode const*)
static int lodepng_color_mode_equal(const LodePNGColorMode* a, const LodePNGColorMode* b)
{
  size_t i;
  if(a->colortype != b->colortype) return 0;
  if(a->bitdepth != b->bitdepth) return 0;
  if(a->key_defined != b->key_defined) return 0;
  if(a->key_defined)
  {
    if(a->key_r != b->key_r) return 0;
    if(a->key_g != b->key_g) return 0;
    if(a->key_b != b->key_b) return 0;
  }
  if(a->palettesize != b->palettesize) return 0;
  for(i = 0; i < a->palettesize * 4; i++)
  {
    if(a->palette[i] != b->palette[i]) return 0;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x6516
movl $0x0, -0x4(%rbp)
jmp 0x6627
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
je 0x6532
movl $0x0, -0x4(%rbp)
jmp 0x6627
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
je 0x654e
movl $0x0, -0x4(%rbp)
jmp 0x6627
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x65ab
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
je 0x6574
movl $0x0, -0x4(%rbp)
jmp 0x6627
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
je 0x6590
movl $0x0, -0x4(%rbp)
jmp 0x6627
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x24(%rcx), %eax
je 0x65a9
movl $0x0, -0x4(%rbp)
jmp 0x6627
jmp 0x65ab
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x65c6
movl $0x0, -0x4(%rbp)
jmp 0x6627
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x2, %rcx
cmpq %rcx, %rax
jae 0x6620
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x6610
movl $0x0, -0x4(%rbp)
jmp 0x6627
jmp 0x6612
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x65ce
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: color_tree_add(ColorTree*, unsigned char, unsigned char, unsigned char, unsigned char, int)
static void color_tree_add(ColorTree* tree, unsigned char r, unsigned char g, unsigned char b, unsigned char a, int index)
{
  tree = &tree->next[r];
  if(tree->next == 0) color_tree_make_next(tree);
  tree = &tree->next[g];
  if(tree->next == 0) color_tree_make_next(tree);
  tree = &tree->next[b];
  if(tree->next == 0) color_tree_make_next(tree);
  tree = &tree->next[a];

  tree->index = index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movb %sil, -0x9(%rbp)
movb %dl, -0xa(%rbp)
movb %cl, -0xb(%rbp)
movb %al, -0xc(%rbp)
movl %r9d, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl -0x9(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x66b9
movq -0x8(%rbp), %rdi
callq 0x106b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl -0xa(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x66e2
movq -0x8(%rbp), %rdi
callq 0x106b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl -0xb(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x670b
movq -0x8(%rbp), %rdi
callq 0x106b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: lodepng_encoder_settings_init(LodePNGEncoderSettings*)
void lodepng_encoder_settings_init(LodePNGEncoderSettings* settings)
{
  lodepng_compress_settings_init(&settings->zlibsettings);
  settings->filter_strategy = LFS_HEURISTIC;
  settings->auto_convert = LAC_AUTO;
  settings->force_palette = 0;
  settings->predefined_filters = 0;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  settings->add_id = 0;
  settings->text_compression = 1;
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4960
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x40(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: drummyfish[P]flowchart/src/lodepng.cpp
// Function: addChunk_tIME(ucvector*, LodePNGTime const*)
static unsigned addChunk_tIME(ucvector* out, const LodePNGTime* time)
{
  unsigned error = 0;
  unsigned char* data = (unsigned char*)mymalloc(7);
  if(!data) return 83; /*alloc fail*/
  data[0] = (unsigned char)(time->year / 256);
  data[1] = (unsigned char)(time->year % 256);
  data[2] = time->month;
  data[3] = time->day;
  data[4] = time->hour;
  data[5] = time->minute;
  data[6] = time->second;
  error = addChunk(out, "tIME", data, 7);
  myfree(data);
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x7, %edi
callq 0x3840
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xb228
movl $0x53, -0x4(%rbp)
jmp 0xb2c8
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x140c5(%rip), %rsi     # 0x1f371
movl $0x7, %ecx
callq 0x13550
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4050
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)