LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: rocket323[P]fishdb/./page.cpp
// Function: fishdb::MemPage::Serialize(char*, int&)
void MemPage::Serialize(char *buf, int &size)
{
    char *sp = buf;
    header.is_leaf = is_leaf;
    memcpy(buf, (char *)&header, sizeof(PageHeader));
    buf += sizeof(PageHeader);

    buf += EncodeInt32(buf, children.size());
    for (size_t i = 0; i < children.size(); ++i)
        buf += EncodeInt64(buf, children[i]);

    buf += EncodeInt32(buf, kvs.size());
    for (size_t i = 0; i < kvs.size(); ++i)
    {
        buf += EncodeString(buf, kvs[i].key);
        buf += EncodeString(buf, kvs[i].value);
    }
    size = buf - sp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movb 0x79(%rsi), %al
andb $0x1, %al
movb %al, 0x26(%rsi)
movq -0x10(%rbp), %rdi
movl $0x28, %edx
callq 0x2190
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x48, %rdi
callq 0x7ec0
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x119d0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x48, %rdi
callq 0x7ec0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x11582
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x48, %rdi
movq -0x28(%rbp), %rsi
callq 0x41b0
movq -0x50(%rbp), %rdi
movq (%rax), %rsi
callq 0x119f0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1151e
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x60, %rdi
callq 0x4200
movq -0x58(%rbp), %rdi
movl %eax, %esi
callq 0x119d0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x60, %rdi
callq 0x4200
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x1165a
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x60, %rdi
movq -0x30(%rbp), %rsi
callq 0x43f0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x11a10
movq -0x40(%rbp), %rdi
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x60, %rdi
movq -0x30(%rbp), %rsi
callq 0x43f0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x11a10
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x115ba
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rocket323[P]fishdb/./page.cpp
// Function: fishdb::MemPage::Parse()
void MemPage::Parse()
{
    char *buf = sbuf;
    memcpy(sbuf, data.c_str(), data.size());
    is_leaf = header.is_leaf;
    int32_t num;

    buf += DecodeInt32(buf, num);
    for (int i = 0; i < num; ++i)
    {
        int64_t c;
        buf += DecodeInt64(buf, c);
        children.push_back(c);
    }

    buf += DecodeInt32(buf, num);
    for (int i = 0; i < num; ++i)
    {
        std::string k, v;
        buf += DecodeString(buf, k);
        buf += DecodeString(buf, v);
        kvs.push_back(KV(k, v));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
leaq 0x9b9f(%rip), %rax      # 0x1b240
movq %rax, -0x10(%rbp)
addq $0x28, %rdi
callq 0x20d0
movq -0xc0(%rbp), %rdi
movq %rax, -0xc8(%rbp)
addq $0x28, %rdi
callq 0x2170
movq -0xc8(%rbp), %rsi
movq %rax, %rdx
leaq 0x9b6a(%rip), %rdi      # 0x1b240
callq 0x2190
movq -0xc0(%rbp), %rax
cmpb $0x0, 0x26(%rax)
setne %cl
andb $0x1, %cl
movb %cl, 0x79(%rax)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x11b10
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x11757
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11b30
movq -0xc0(%rbp), %rdi
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
addq $0x48, %rdi
leaq -0x20(%rbp), %rsi
callq 0x8840
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x11713
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x11b10
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x11898
leaq -0x48(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x22f0
leaq -0x68(%rbp), %rdi
callq 0x22f0
movq -0xd8(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x11b60
movl %eax, -0xcc(%rbp)
jmp 0x117b8
movl -0xcc(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x11b60
movl %eax, -0xdc(%rbp)
jmp 0x117e1
movq -0xc0(%rbp), %rax
movl -0xdc(%rbp), %edx
movq -0x10(%rbp), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, -0x10(%rbp)
addq $0x60, %rax
movq %rax, -0xe8(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x7f60
jmp 0x1181d
movq -0xe8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x118b0
jmp 0x11832
leaq -0xb8(%rbp), %rdi
callq 0x7fc0
leaq -0x68(%rbp), %rdi
callq 0x2140
leaq -0x48(%rbp), %rdi
callq 0x2140
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1177b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x11884
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x7fc0
leaq -0x68(%rbp), %rdi
callq 0x2140
leaq -0x48(%rbp), %rdi
callq 0x2140
jmp 0x118a1
addq $0xf0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x2370
nopw (%rax,%rax)
// File: rocket323[P]fishdb/./util.cpp
// Function: fishdb::DecodeString(char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int DecodeString(char *buf, std::string &str)
{
    int32_t len = 0;
    DecodeInt32(buf, len);
    str = std::string(buf + 4, len);
    return 4 + len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x11b10
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x68(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2380
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0x2260
jmp 0x11bbc
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2290
leaq -0x38(%rbp), %rdi
callq 0x2140
leaq -0x39(%rbp), %rdi
callq 0x2240
movl -0x14(%rbp), %eax
addl $0x4, %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x2240
movq -0x48(%rbp), %rdi
callq 0x2370
// File: cegme[P]vose/VoseTree.cc
// Function: VoseTree::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, long)
double VoseTree::add(std::string label, long weight) {

  struct marble m;
  m.weight = weight;
  m.label = label; // TODO update with a proper copy() method

  return VoseTree::add(m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4190
movq -0x90(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2040
jmp 0x253c
leaq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x41b0
jmp 0x254e
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x25d0
movsd %xmm0, -0xa0(%rbp)
jmp 0x256b
leaq -0x88(%rbp), %rdi
callq 0x4200
leaq -0x48(%rbp), %rdi
callq 0x4200
movsd -0xa0(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x25b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4200
leaq -0x48(%rbp), %rdi
callq 0x4200
movq -0x50(%rbp), %rdi
callq 0x22f0
nopl (%rax)
// File: cegme[P]vose/VoseTree.cc
// Function: VoseTree::rand_marble()
marble VoseTree::rand_marble() {

  // Select a random value in the range of [0, totalsize)
  double rand_sz = random_branch();

  // Binary search to find correct branch O(log n), n = branches.size()
  //std::vector<double>::iterator branch
  auto branch_idx
    = std::lower_bound (branches.begin(), branches.end(), rand_sz);

  size_t branch = branch_idx - branches.begin();
  if (nodes[branch].isBag) {
    // If a Vose class is at the node, we call rand() on the object.
    return nodes[branch].bag.rand_marble(); // O(1)
  }
  else {
    // If a marble is at the branch, return the marble
    return nodes[branch].ball; // O(1)
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4b20
movq -0x48(%rbp), %rdi
movsd %xmm0, -0x18(%rbp)
addq $0x20, %rdi
callq 0x4bb0
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x20, %rdi
callq 0x4be0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x4b60
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x20, %rdi
callq 0x4bb0
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4c10
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x38, %rdi
movq -0x38(%rbp), %rsi
callq 0x4550
testb $0x1, (%rax)
je 0x2fbf
movq -0x48(%rbp), %rdi
addq $0x38, %rdi
movq -0x38(%rbp), %rsi
callq 0x4550
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq $0x38, %rsi
callq 0x112b0
jmp 0x2fe0
movq -0x48(%rbp), %rdi
addq $0x38, %rdi
movq -0x38(%rbp), %rsi
callq 0x4550
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x41b0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: cegme[P]vose/VoseTree.cc
// Function: VoseTree::init()
void VoseTree::init() {
  // Init  all the Vose bags
  for (size_t i = 0; i != nodes.size(); ++i) {
    if (!nodes[i].isBag) break;
    nodes[i].bag.init();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x38, %rdi
callq 0x4520
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x3070
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
callq 0x4550
testb $0x1, (%rax)
jne 0x3045
jmp 0x3070
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
callq 0x4550
movq %rax, %rdi
addq $0x38, %rdi
callq 0x10d30
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x300c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cegme[P]vose/VoseTree.cc
// Function: VoseTree::toString[abi:cxx11]()
std::string VoseTree::toString() {

  std::stringstream ss;
  ss << "[" << total_weight << "]\n";
  std::for_each (nodes.cbegin(), nodes.cend(), [this,&ss] (vosetreenode v) {
    ss << "----> " << v.toString() << "\n";
  });
  ss << "\n";
  return ss.str();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x1f8(%rbp)
movq %rdi, %rax
movq %rax, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2170
leaq -0x188(%rbp), %rdi
leaq 0x18f87(%rip), %rsi     # 0x1c050
callq 0x2210
movq %rax, -0x1e0(%rbp)
jmp 0x30d7
movq -0x1e0(%rbp), %rdi
movq -0x1e8(%rbp), %rax
movq 0x58(%rax), %rsi
callq 0x2310
movq %rax, -0x200(%rbp)
jmp 0x30f7
movq -0x200(%rbp), %rdi
leaq 0x18f4d(%rip), %rsi     # 0x1c052
callq 0x2210
jmp 0x310c
movq -0x1e8(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x218(%rbp)
callq 0x4f30
movq -0x218(%rbp), %rdi
movq %rax, -0x1b0(%rbp)
callq 0x4f60
movq %rax, %rcx
movq -0x1e8(%rbp), %rax
movq %rcx, -0x1b8(%rbp)
movq %rax, -0x1c8(%rbp)
leaq -0x198(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq -0x1b0(%rbp), %rdi
movq -0x1b8(%rbp), %rsi
movq -0x1c8(%rbp), %rdx
movq -0x1c0(%rbp), %rcx
callq 0x3220
movq %rdx, -0x210(%rbp)
movq %rax, -0x208(%rbp)
jmp 0x318d
movq -0x210(%rbp), %rax
movq -0x208(%rbp), %rcx
movq %rcx, -0x1d8(%rbp)
movq %rax, -0x1d0(%rbp)
leaq -0x188(%rbp), %rdi
leaq 0x19365(%rip), %rsi     # 0x1c51c
callq 0x2210
jmp 0x31be
movq -0x1f8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x2200
jmp 0x31d3
leaq -0x198(%rbp), %rdi
callq 0x2190
movq -0x1f0(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2190
movq -0x1a0(%rbp), %rdi
callq 0x22f0
nopl (%rax)
// File: cegme[P]vose/VoseTree.cc
// Function: VoseTree::distribution[abi:cxx11]()
std::map<std::string, long> VoseTree::distribution() {

  std::map<std::string, long> map;
  std::for_each(nodes.cbegin(), nodes.cend(), [&map] (vosetreenode vtn) {
    if(vtn.isBag) {
      for (auto m : vtn.bag.get_scores()) {
        if(map.find(m.label) == map.end()) {
          map.insert(std::pair<std::string, long>(m.label, m.weight));
        }
        else {
          map[m.label] += m.weight;
        }
      }
    }
    else {
      if(map.find(vtn.ball.label) == map.end()) {
        map.insert(std::pair<std::string, long>(vtn.ball.label, vtn.ball.weight));
      }
      else {
        map[vtn.ball.label] += vtn.ball.weight;
      }
    }
  });
  return map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x4f90
movq -0x68(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x60(%rbp)
callq 0x4f30
movq -0x60(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x4f60
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdi, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x33a0
movq %rax, -0x50(%rbp)
jmp 0x334d
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3381
jmp 0x3378
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x4fb0
jmp 0x338b
movq -0x58(%rbp), %rdi
callq 0x4fb0
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: cegme[P]vose/VoseTree.cc
// Function: VoseTree::probabilities[abi:cxx11]()
std::map<std::string, double> VoseTree::probabilities() {

  auto h = distribution();
  std::map<std::string, double> prob;
  //map.resize(h.size());
  std::for_each(h.begin(), h.end(), [&] (std::pair<std::string, long> m) {
    //std::cerr << "p|" << m.first << "," << (double)m.second/total_weight << "\n";
    prob.insert(std::make_pair(m.first, (double)m.second/total_weight));
  });
  return prob;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x32e0
movq -0xa8(%rbp), %rdi
movb $0x0, -0x41(%rbp)
callq 0x4fd0
movq -0xb0(%rbp), %rdi
callq 0x4ff0
movq -0xb0(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x5020
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movq -0xa0(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq %rdi, -0x68(%rbp)
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rcx
callq 0x3590
movq %rdx, -0x98(%rbp)
movq %rax, -0x90(%rbp)
jmp 0x350d
movq -0x98(%rbp), %rax
movq -0x90(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movq %rax, -0x80(%rbp)
movb $0x1, -0x41(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x3561
jmp 0x3555
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x5050
leaq -0x40(%rbp), %rdi
callq 0x4fb0
jmp 0x357a
movq -0xa8(%rbp), %rdi
callq 0x5050
leaq -0x40(%rbp), %rdi
callq 0x4fb0
movq -0xb8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: cegme[P]vose/VoseTree.cc
// Function: VoseTree::kl(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, double>>> const&)
double VoseTree::kl(const std::map<std::string, double> &a, const std::map<std::string, double> &b) {

  /*std::cerr<< "a: ";
  std::for_each(a.begin(), a.end(), [] (std::pair<const std::string, double> z) { 
    std::cerr << "<" << z.first << "," << z.second << ">";
  });
  std::cerr << "\nb: ";
  std::for_each(b.begin(), b.end(), [] (std::pair<const std::string, double> z) { 
    std::cerr << "<" << z.first << "," << z.second << ">";
  });*/

  std::vector<double> v;
  v.resize(a.size());
  std::transform(a.cbegin(), a.cend(), b.cbegin(), v.begin(), [&v] (std::pair<const std::string, double> a, std::pair<const std::string, double> b) {
    //printf("a:%f, b:%f, log(a/b):%f\n", a.second, b.second, log(a.second/b.second));
    return (double)log(a.second/b.second)*a.second;
  });
  return std::accumulate(v.cbegin(), v.cend(), 0.0, std::plus<double>());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x5070
movq -0x8(%rbp), %rdi
callq 0x5120
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x5090
jmp 0x366d
movq -0x8(%rbp), %rdi
callq 0x5140
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5170
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5140
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x51a0
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %r8
callq 0x3760
movq %rax, -0x90(%rbp)
jmp 0x36d8
movq -0x90(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x5230
movq -0xa8(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x5260
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
xorps %xmm0, %xmm0
callq 0x51d0
movsd %xmm0, -0xa0(%rbp)
jmp 0x3721
leaq -0x28(%rbp), %rdi
callq 0x5290
movsd -0xa0(%rbp), %xmm0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5290
movq -0x30(%rbp), %rdi
callq 0x22f0
nopl (%rax)
// File: cegme[P]vose/./Vose.h
// Function: marble::toString[abi:cxx11]()
std::string toString() {
    std::stringstream ss;
    ss << "<" << label;
    ss << ",";
    ss << weight << ">"; 
    return ss.str();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1c8(%rbp)
movq %rdi, %rax
movq %rax, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2170
leaq -0x188(%rbp), %rdi
leaq 0xe667(%rip), %rsi      # 0x1c090
callq 0x2210
movq %rax, -0x1b0(%rbp)
jmp 0xda37
movq -0x1b0(%rbp), %rdi
movq -0x1b8(%rbp), %rsi
addq $0x8, %rsi
callq 0x21e0
jmp 0xda50
leaq -0x188(%rbp), %rdi
leaq 0xe634(%rip), %rsi      # 0x1c092
callq 0x2210
jmp 0xda65
movq -0x1b8(%rbp), %rax
leaq -0x188(%rbp), %rdi
movq (%rax), %rsi
callq 0x2310
movq %rax, -0x1d0(%rbp)
jmp 0xda84
movq -0x1d0(%rbp), %rdi
leaq 0xe917(%rip), %rsi      # 0x1c3a9
callq 0x2210
jmp 0xda99
movq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x2200
jmp 0xdaae
leaq -0x198(%rbp), %rdi
callq 0x2190
movq -0x1c0(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2190
movq -0x1a0(%rbp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
nop
// File: cegme[P]vose/Vose.cc
// Function: Vose::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, long)
double Vose::add(std::string label, long weight) {
  // Create a new marble
  struct marble m;
  m.weight = weight;
  m.label = label; // TODO update with a proper copy() method

  return Vose::add(m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4190
movq -0x90(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2040
jmp 0x10c4c
leaq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x41b0
jmp 0x10c5e
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x10ce0
movsd %xmm0, -0xa0(%rbp)
jmp 0x10c7b
leaq -0x88(%rbp), %rdi
callq 0x4200
leaq -0x48(%rbp), %rdi
callq 0x4200
movsd -0xa0(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x10cc7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4200
leaq -0x48(%rbp), %rdi
callq 0x4200
movq -0x50(%rbp), %rdi
callq 0x22f0
nopl (%rax)
// File: cegme[P]vose/Vose.cc
// Function: Vose::add(marble)
double Vose::add(marble m) {
  
  // Update the total size of the Urn
  total_weight += m.weight;

  // Add the marble to the list
  scores.push_back(m);

  // TODO update streaming data structures

  return (double) m.weight / total_weight;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq (%rsi), %rax
addq 0x58(%rdi), %rax
movq %rax, 0x58(%rdi)
addq $0x40, %rdi
callq 0x11a40
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
cvtsi2sdq (%rsi), %xmm0
cvtsi2sdq 0x58(%rax), %xmm1
divsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: cegme[P]vose/Vose.cc
// Function: Vose::rand()
size_t Vose::rand() {
  // Warning! init() must have been called. 
  // TODO update this method to a more numerically stable version

  double u = random_scores_double();
  //std::cerr << "rand(): u = " << u << "\n";
  // Grab a random column from the main scores list
  size_t col = floor(u);
  //std::cerr << "rand(): col = " << col << "\n";

  // Make a toss to choose either alias side or the probability side 
  return (u - col)<=prob[col]? col : alias[col];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x11f30
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x22e0
movq -0x28(%rbp), %rdi
movsd 0xaff4(%rip), %xmm2     # 0x1c1f8
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movaps 0xadee(%rip), %xmm2     # 0x1c020
movq -0x18(%rbp), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0xaded(%rip), %xmm2     # 0x1c030
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
addq $0x78, %rdi
movq -0x18(%rbp), %rsi
callq 0x11dd0
movsd -0x20(%rbp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x11281
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x11299
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rsi
callq 0x11eb0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: cegme[P]vose/Vose.cc
// Function: Vose::kl(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
double Vose::kl(const std::vector<double> &a, const std::vector<double> &b) {

  std::vector<double> v;
  for(size_t i = 0; i != a.size(); ++i) {
    printf("a:%f, b:%f, log(a/b):%f\n", a[i], b[i], log(a[i]/b[i]));
    v.push_back(log(a[i]/b[i])*a[i]);
  }
  return std::accumulate(v.cbegin(), v.cend(), 0.0, std::plus<double>());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5070
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6a10
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
je 0x11471
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x11f50
movsd (%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x11f50
movsd (%rax), %xmm0
movsd %xmm0, -0x78(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x11f50
movsd (%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x11f50
movsd -0x80(%rbp), %xmm0
movsd (%rax), %xmm1
divsd %xmm1, %xmm0
callq 0x21b0
movsd -0x78(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x70(%rbp), %xmm0
leaq 0xae36(%rip), %rdi      # 0x1c200
movb $0x3, %al
callq 0x2050
jmp 0x113d3
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x11f50
movsd (%rax), %xmm0
movsd %xmm0, -0x90(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x11f50
movsd -0x90(%rbp), %xmm0
movsd (%rax), %xmm1
divsd %xmm1, %xmm0
callq 0x21b0
movsd %xmm0, -0x88(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x11f50
movsd -0x88(%rbp), %xmm0
movsd (%rax), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x11f70
jmp 0x11447
jmp 0x11449
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x11334
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5290
jmp 0x114c9
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5230
movq -0xa0(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x5260
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
xorps %xmm0, %xmm0
callq 0x51d0
movsd %xmm0, -0x98(%rbp)
jmp 0x114af
leaq -0x28(%rbp), %rdi
callq 0x5290
movsd -0x98(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: cegme[P]vose/Vose.cc
// Function: Vose::merge(Vose const&, Vose const&)
Vose Vose::merge(const Vose &v1, const Vose &v2) {

  Vose v;
  std::copy (v1.scores.begin(), v1.scores.end(), std::back_inserter(v.scores)); 
  std::copy (v2.scores.begin(), v2.scores.end(), std::back_inserter(v.scores)); 
  v.total_weight = v1.total_weight + v2.total_weight;

  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x4480
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x5cd0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x5d00
movq -0x88(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x40, %rdi
callq 0x12010
movq %rax, -0x80(%rbp)
jmp 0x1154d
movq -0x80(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x11fa0
movq %rax, -0x98(%rbp)
jmp 0x1156f
movq -0x98(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
callq 0x5cd0
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
callq 0x5d00
movq -0x88(%rbp), %rdi
movq %rax, -0x68(%rbp)
addq $0x40, %rdi
callq 0x12010
movq %rax, -0xa0(%rbp)
jmp 0x115b5
movq -0xa0(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x11fa0
movq %rax, -0xa8(%rbp)
jmp 0x115da
movq -0x88(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq -0x18(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq -0x20(%rbp), %rdx
addq 0x58(%rdx), %rcx
movq %rcx, 0x58(%rax)
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x11632
jmp 0x11626
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x46f0
jmp 0x11642
movq -0x88(%rbp), %rdi
callq 0x46f0
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x22f0
nopl (%rax,%rax)
// File: cegme[P]vose/Vose.cc
// Function: Vose::merge(Vose const&)
Vose Vose::merge(const Vose& vose) {

  Vose v;

  // concatenate the two scores arrays
  std::copy (scores.begin(),scores.end(),std::back_inserter(v.scores)); 
  std::copy (vose.scores.begin(),vose.scores.end(),std::back_inserter(v.scores)); 

  // update the total_weight
  v.total_weight = total_weight + vose.total_weight;

  return v; // The person using this shoud call 'init' as soon as possible
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x4480
movq -0x90(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x88(%rbp)
callq 0x7ca0
movq -0x88(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x7cd0
movq -0x80(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x40, %rdi
callq 0x12010
movq %rax, -0x78(%rbp)
jmp 0x116c7
movq -0x78(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x12040
movq %rax, -0xa0(%rbp)
jmp 0x116e9
movq -0xa0(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x5cd0
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x5d00
movq -0x80(%rbp), %rdi
movq %rax, -0x60(%rbp)
addq $0x40, %rdi
callq 0x12010
movq %rax, -0xa8(%rbp)
jmp 0x1172c
movq -0xa8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x11fa0
movq %rax, -0xb0(%rbp)
jmp 0x11751
movq -0x80(%rbp), %rax
movq -0x90(%rbp), %rcx
movq -0xb0(%rbp), %rdx
movq %rdx, -0x70(%rbp)
movq 0x58(%rcx), %rcx
movq -0x18(%rbp), %rdx
addq 0x58(%rdx), %rcx
movq %rcx, 0x58(%rax)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x117a3
jmp 0x1179a
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x46f0
jmp 0x117b3
movq -0x80(%rbp), %rdi
callq 0x46f0
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22f0
nopl (%rax)
// File: cegme[P]vose/Vose.cc
// Function: Vose::toString[abi:cxx11]()
std::string Vose::toString() {
  std::stringstream ss;
  ss << "[" << total_weight << "|";
  std::for_each(scores.cbegin(), scores.cend(),[&ss] (marble m) {
    ss << m.toString();
  });
  ss << "]";
  return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1e8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2170
leaq -0x188(%rbp), %rdi
leaq 0xa847(%rip), %rsi      # 0x1c050
callq 0x2210
movq %rax, -0x1d0(%rbp)
jmp 0x11817
movq -0x1d0(%rbp), %rdi
movq -0x1d8(%rbp), %rax
movq 0x58(%rax), %rsi
callq 0x2310
movq %rax, -0x1f0(%rbp)
jmp 0x11837
movq -0x1f0(%rbp), %rdi
leaq 0xa9d4(%rip), %rsi      # 0x1c219
callq 0x2210
jmp 0x1184c
movq -0x1d8(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x200(%rbp)
callq 0x120b0
movq -0x200(%rbp), %rdi
movq %rax, -0x1b0(%rbp)
callq 0x120e0
movq %rax, -0x1b8(%rbp)
leaq -0x198(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq -0x1b0(%rbp), %rdi
movq -0x1b8(%rbp), %rsi
movq -0x1c0(%rbp), %rdx
callq 0x11930
movq %rax, -0x1f8(%rbp)
jmp 0x118ae
movq -0x1f8(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0x188(%rbp), %rdi
leaq 0xa951(%rip), %rsi      # 0x1c21b
callq 0x2210
jmp 0x118d1
movq -0x1e8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x2200
jmp 0x118e6
leaq -0x198(%rbp), %rdi
callq 0x2190
movq -0x1e0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2190
movq -0x1a0(%rbp), %rdi
callq 0x22f0
nopl (%rax)
// File: cegme[P]vose/./Vose.h
// Function: Vose::reset_scores_die()
void reset_scores_die() {
    // Update the random number generators
    std::default_random_engine generator(VoseUtil::RANDOM_SEED); 
    std::uniform_real_distribution<double>
      real_distribution(0, scores.size()>0?scores.size():1);

    random_scores_die = std::bind(real_distribution, generator);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x196ed(%rip), %rsi     # 0x2b1b8
leaq -0x10(%rbp), %rdi
callq 0x4a30
movq -0x40(%rbp), %rdi
addq $0x40, %rdi
callq 0x5ba0
cmpq $0x0, %rax
jbe 0x11afa
movq -0x40(%rbp), %rdi
addq $0x40, %rdi
callq 0x5ba0
movq %rax, -0x48(%rbp)
jmp 0x11b05
movl $0x1, %eax
movq %rax, -0x48(%rbp)
jmp 0x11b05
movq -0x48(%rbp), %rax
movq %rax, %xmm1
movaps 0xa50b(%rip), %xmm0     # 0x1c020
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0xa50f(%rip), %xmm0     # 0x1c030
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
leaq -0x20(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x4a60
leaq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x4a90
movq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4ad0
addq $0x50, %rsp
popq %rbp
retq
// File: cegme[P]vose/./Vose.h
// Function: Vose::reset_random_double()
void reset_random_double() {
    // Update the random number generators
    std::default_random_engine generator(VoseUtil::RANDOM_SEED);
    std::uniform_real_distribution<double> uniform_distribution(0.0,1.0);

    random_prob_die = std::bind(uniform_distribution, generator);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x1963d(%rip), %rsi     # 0x2b1b8
leaq -0x10(%rbp), %rdi
callq 0x4a30
leaq -0x20(%rbp), %rdi
xorps %xmm0, %xmm0
movsd 0xa475(%rip), %xmm1     # 0x1c008
callq 0x4a60
leaq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x4a90
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
leaq -0x38(%rbp), %rsi
callq 0x4ad0
addq $0x40, %rsp
popq %rbp
retq
// File: cegme[P]vose/test.cc
// Function: main
int main(int argc, char **argv) {
  
  test t;
  
  std::cout << "\nTest 1" << "----------------------------------------\n";
  t.test1();
  
  std::cout << "\nTest 2" << "----------------------------------------\n";
  t.test2();
  
  std::cout << "\nTest 3" << "----------------------------------------\n";
  t.test3();
  
  std::cout << "\nTest 4" << "----------------------------------------\n";
  t.test4();
  
  std::cout << "\nTest 5" << "----------------------------------------\n";
  t.test5();

  std::cout << "\nTest 6" << "----------------------------------------\n";
  t.test6();

  std::cout << "\nTest 7" << "----------------------------------------\n";
  t.test7();


 return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x12ec3(%rip), %rdi     # 0x2afd0
leaq 0x43d8(%rip), %rsi      # 0x1c4ec
callq 0x2210
movq %rax, %rdi
leaq 0x43d1(%rip), %rsi      # 0x1c4f4
callq 0x2210
leaq -0x11(%rbp), %rdi
callq 0x153e0
movq 0x12e98(%rip), %rdi     # 0x2afd0
leaq 0x43df(%rip), %rsi      # 0x1c51e
callq 0x2210
movq %rax, %rdi
leaq 0x43a6(%rip), %rsi      # 0x1c4f4
callq 0x2210
leaq -0x11(%rbp), %rdi
callq 0x157d0
movq 0x12e6d(%rip), %rdi     # 0x2afd0
leaq 0x43bc(%rip), %rsi      # 0x1c526
callq 0x2210
movq %rax, %rdi
leaq 0x437b(%rip), %rsi      # 0x1c4f4
callq 0x2210
leaq -0x11(%rbp), %rdi
callq 0x161b0
movq 0x12e42(%rip), %rdi     # 0x2afd0
leaq 0x4399(%rip), %rsi      # 0x1c52e
callq 0x2210
movq %rax, %rdi
leaq 0x4350(%rip), %rsi      # 0x1c4f4
callq 0x2210
leaq -0x11(%rbp), %rdi
callq 0x16cb0
movq 0x12e17(%rip), %rdi     # 0x2afd0
leaq 0x4376(%rip), %rsi      # 0x1c536
callq 0x2210
movq %rax, %rdi
leaq 0x4325(%rip), %rsi      # 0x1c4f4
callq 0x2210
leaq -0x11(%rbp), %rdi
callq 0x17080
movq 0x12dec(%rip), %rdi     # 0x2afd0
leaq 0x4353(%rip), %rsi      # 0x1c53e
callq 0x2210
movq %rax, %rdi
leaq 0x42fa(%rip), %rsi      # 0x1c4f4
callq 0x2210
leaq -0x11(%rbp), %rdi
callq 0x17950
movq 0x12dc1(%rip), %rdi     # 0x2afd0
leaq 0x4330(%rip), %rsi      # 0x1c546
callq 0x2210
movq %rax, %rdi
leaq 0x42cf(%rip), %rsi      # 0x1c4f4
callq 0x2210
leaq -0x11(%rbp), %rdi
callq 0x17d80
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cegme[P]vose/./Vose.h
// Function: Vose::probabilities()
inline std::vector<double> probabilities() {
    std::vector<double> v;
    std::for_each (scores.begin(), scores.end(), [&] (marble m) {
        v.push_back((double) m.weight/total_weight);
    });
    return v;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5070
movq -0x70(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x80(%rbp)
callq 0x7ca0
movq -0x80(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x7cd0
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rdi, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x18be0
movq %rdx, -0x68(%rbp)
movq %rax, -0x60(%rbp)
jmp 0x18366
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x50(%rbp)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x183a2
jmp 0x18399
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x5290
jmp 0x183b2
movq -0x78(%rbp), %rdi
callq 0x5290
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22f0
nopl (%rax,%rax)
// File: tkaczenko[P]asteroids-clone/src/App.cpp
// Function: App::App()
App::App()
{
    if (SDL_Init(SDL_INIT_EVERYTHING) != 0 ) {
        std::cout << "Unable initialize SDL: " << SDL_GetError();
        return;
    }
    win = new Window("Asteroids");
    rend = new Renderer(win->getWin());

    nextFrameTime = SDL_GetTicks();
    srand(time(NULL));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, -0x50(%rbp)
callq 0x42f0
movq -0x48(%rbp), %rax
movb $0x1, 0xd8(%rax)
movl $0x0, 0x118(%rax)
movl $0x0, 0x11c(%rax)
movl $0x1e, 0x120(%rax)
movl 0x120(%rax), %ecx
xorl %edx, %edx
movl $0x3e8, %eax            # imm = 0x3E8
idivl %ecx
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x124(%rax)
movl $0x5, 0x128(%rax)
movl $0x0, 0x12c(%rax)
movl $0x0, 0x130(%rax)
movl $0x0, 0x134(%rax)
movl $0x0, 0x138(%rax)
movl $0x0, 0x13c(%rax)
movl $0xf231, %edi           # imm = 0xF231
callq 0x3270
movl %eax, -0x40(%rbp)
jmp 0x3752
movl -0x40(%rbp), %eax
cmpl $0x0, %eax
je 0x37a3
movq 0x9877(%rip), %rdi      # 0xcfd8
leaq 0x58a0(%rip), %rsi      # 0x9008
callq 0x32e0
movq %rax, -0x58(%rbp)
jmp 0x3773
callq 0x3200
movq %rax, -0x60(%rbp)
jmp 0x377e
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x32e0
jmp 0x378d
jmp 0x3874
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x38d1
movl $0x8, %edi
callq 0x32f0
movq %rax, -0x68(%rbp)
jmp 0x37b3
movb $0x1, -0x3a(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x33f0
movq -0x70(%rbp), %rdx
leaq 0x5851(%rip), %rsi      # 0x9020
leaq -0x38(%rbp), %rdi
callq 0x3350
jmp 0x37da
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3dd0
jmp 0x37e9
movq -0x48(%rbp), %rax
movq -0x68(%rbp), %rcx
movb $0x0, -0x3a(%rbp)
movq %rcx, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x31b0
leaq -0x39(%rbp), %rdi
callq 0x3330
movl $0x8, %edi
callq 0x32f0
movq %rax, -0x78(%rbp)
jmp 0x381a
movq -0x48(%rbp), %rax
movq (%rax), %rdi
callq 0x3e30
movq %rax, -0x80(%rbp)
jmp 0x382c
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x3e50
jmp 0x383b
movq -0x48(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, 0x8(%rax)
callq 0x3300
movl %eax, -0x84(%rbp)
jmp 0x3854
movq -0x48(%rbp), %rax
movl -0x84(%rbp), %ecx
movl %ecx, 0x130(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x3290
movl %eax, %edi
callq 0x32c0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x38a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31b0
leaq -0x39(%rbp), %rdi
callq 0x3330
testb $0x1, -0x3a(%rbp)
jne 0x38b1
jmp 0x38ba
movq -0x68(%rbp), %rdi
callq 0x32b0
jmp 0x38d1
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x32b0
movq -0x50(%rbp), %rdi
callq 0x47f0
movq -0x10(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: tkaczenko[P]asteroids-clone/src/Bullet.cpp
// Function: Bullet::Bullet(SDL_Point, float const&, float const&, int const&, int const&)
Bullet::Bullet(SDL_Point p, const float& vX, const float& vY, const int& t, const int& n)
: num(n), type(t), dead(false)
{
    position = {p.x, p.y};
    prevPosition = {p.x, p.y};
    if (type == BULLET) {

    }

    velocity[0] = vX;
    velocity[1] = vY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4260
movq -0x48(%rbp), %rax
leaq 0x8cc8(%rip), %rcx      # 0xcc40
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x2c(%rax)
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x30(%rax)
movl $0x0, 0x34(%rax)
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x38(%rax)
movb $0x0, 0x3c(%rax)
movl -0x8(%rbp), %ecx
movl %ecx, -0x38(%rbp)
movl -0x4(%rbp), %ecx
movl %ecx, -0x34(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x8(%rbp), %ecx
movl %ecx, -0x40(%rbp)
movl -0x4(%rbp), %ecx
movl %ecx, -0x3c(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
cmpl $0x25c, 0x38(%rax)      # imm = 0x25C
jne 0x3fd6
jmp 0x3fd6
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
movss (%rcx), %xmm0
movss %xmm0, 0x1c(%rax)
movq -0x20(%rbp), %rcx
movss (%rcx), %xmm0
movss %xmm0, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tkaczenko[P]asteroids-clone/src/Bullet.cpp
// Function: Bullet::updatePosition(float const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Bullet, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Bullet>>>&)
void Bullet::updatePosition(const float& dT, std::map<std::string, Bullet>& m)
{
    position.x = prevPosition.x - velocity[0] * dT;
    position.y = prevPosition.y - velocity[1] * dT;

    if (position.x > 800) {
        position.x -= 800;
    } else if (position.x < 0) {
        position.x += 800;
    }
    if (position.y > 600) {
        position.y -= 600;
    } else if (position.y < 0) {
        position.y += 600;
    }

    if (type == BULLET) {
        if (life > 25) {
            dead = true;
        } else {
            life++;
        }
    }

    prevPosition.x = position.x;
    prevPosition.y = position.y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cvtsi2ssl 0x8(%rax), %xmm1
movss 0x1c(%rax), %xmm0
movq -0x10(%rbp), %rcx
movss (%rcx), %xmm2
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, 0x10(%rax)
cvtsi2ssl 0xc(%rax), %xmm1
movss 0x20(%rax), %xmm0
movq -0x10(%rbp), %rcx
movss (%rcx), %xmm2
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, 0x14(%rax)
cmpl $0x320, 0x10(%rax)      # imm = 0x320
jle 0x40a1
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
subl $0x320, %ecx            # imm = 0x320
movl %ecx, 0x10(%rax)
jmp 0x40bd
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jge 0x40bb
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x320, %ecx            # imm = 0x320
movl %ecx, 0x10(%rax)
jmp 0x40bd
movq -0x20(%rbp), %rax
cmpl $0x258, 0x14(%rax)      # imm = 0x258
jle 0x40dc
movq -0x20(%rbp), %rax
movl 0x14(%rax), %ecx
subl $0x258, %ecx            # imm = 0x258
movl %ecx, 0x14(%rax)
jmp 0x40f8
movq -0x20(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jge 0x40f6
movq -0x20(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x258, %ecx            # imm = 0x258
movl %ecx, 0x14(%rax)
jmp 0x40f8
movq -0x20(%rbp), %rax
cmpl $0x25c, 0x38(%rax)      # imm = 0x25C
jne 0x4128
movq -0x20(%rbp), %rax
cmpl $0x19, 0x2c(%rax)
jle 0x4119
movq -0x20(%rbp), %rax
movb $0x1, 0x3c(%rax)
jmp 0x4126
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rax)
jmp 0x4128
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
movl %ecx, 0x8(%rax)
movl 0x14(%rax), %ecx
movl %ecx, 0xc(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: tkaczenko[P]asteroids-clone/src/Bullet.cpp
// Function: Bullet::draw(SDL_Renderer*)
void Bullet::draw(SDL_Renderer* r)
{
    if (type == BULLET) {
        SDL_SetRenderDrawColor(r, 0, 255, 0, 1.0);
        SDL_RenderDrawPoint(r, position.x, position.y);
        SDL_SetRenderDrawColor(r, 0, 0, 0, 255);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x25c, 0x38(%rax)      # imm = 0x25C
jne 0x4231
movq -0x10(%rbp), %rdi
xorl %ecx, %ecx
movl $0xff, %edx
movl $0x1, %r8d
movl %ecx, %esi
callq 0x3360
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x10(%rax), %esi
movl 0x14(%rax), %edx
callq 0x3280
movq -0x10(%rbp), %rdi
xorl %ecx, %ecx
movl $0xff, %r8d
movl %ecx, %esi
movl %ecx, %edx
callq 0x3360
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)